Amr is a young coder who likes music a lot. He always wanted to learn how to play music but he was busy coding so he got an idea.

Amr has n instruments, it takes ai days to learn i-th instrument. Being busy, Amr dedicated k days to learn how to play the maximum possible number of instruments.

Amr asked for your help to distribute his free days between instruments so that he can achieve his goal.

Input

The first line contains two numbers n, k (1 ≤ n ≤ 100, 0 ≤ k ≤ 10 000), the number of instruments and number of days respectively.

The second line contains n integers ai (1 ≤ ai ≤ 100), representing number of days required to learn the i-th instrument.

Output

In the first line output one integer m representing the maximum number of instruments Amr can learn.

In the second line output m space-separated integers: the indices of instruments to be learnt. You may output indices in any order.

if there are multiple optimal solutions output any. It is not necessary to use all days for studying.

Examples

Input

4 10
4 3 1 2


Output

4
1 2 3 4

Input

5 6
4 3 1 1 2


Output

3
1 3 4

Input

1 3
4


Output

0

Note

In the first test Amr can learn all 4 instruments.

In the second test other possible solutions are: {2, 3, 5} or {3, 4, 5}.

In the third test Amr doesn't have enough time to learn the only presented instrument.
#include <bits/stdc++.h>
int matrix[50][50];
using namespace std;
bool equiv(string a, string b) {
  if (a == b) return true;
  int L = a.length();
  if (L % 2 != 0) return false;
  string a1 = a.substr(0, L / 2);
  string a2 = a.substr(L / 2, L / 2);
  string b1 = b.substr(0, L / 2);
  string b2 = b.substr(L / 2, L / 2);
  bool check = equiv(a1, b1) && equiv(a2, b2);
  if (check)
    return true;
  else
    check = equiv(a1, b2) && equiv(a2, b1);
  return check;
}
bool is_prime(int n) {
  int count_primes = 0;
  for (int i = 1; i < n + 1; i++) {
    if (n % i == 0) count_primes++;
  }
  if (count_primes == 2) return true;
  return false;
}
bool valid_or_not(int num1, int num2, int num3, int num4, int r1, int r2,
                  int c1, int c2, int d1, int d2) {
  bool validity = ((num1 + num2) == r1) && ((num1 + num3) == c1) &&
                  ((num1 + num4) == d1) && ((num2 + num4) == c2) &&
                  ((num2 + num3) == d2) && ((num3 + num4) == r2);
  return validity;
}
long long sum(long long n) { return (n * (n + 1) / 2); }
long long sum_interval(long long st, long long en) {
  if (st <= 1) return sum(en);
  return (sum(en) - sum(st - 1));
}
long long find_min_possible(long long n, long long k) {
  long long s = 1, e = k;
  while (s < e) {
    long long mid = (s + e) / 2;
    long long su = sum_interval(mid, k);
    if (su == n)
      return (k - mid + 1);
    else if (su > n)
      s = mid + 1;
    else
      e = mid;
  }
  return k - s + 2;
}
int min_steps(int x) {
  int steps[5] = {1, 2, 3, 4, 5};
  int total_steps = 0, indx = 4;
  while (indx >= 0 && x > 0) {
    if (x >= steps[indx]) {
      total_steps += (x / steps[indx]);
      x %= steps[indx];
    } else
      indx--;
  }
  return total_steps;
}
bool check_digits(int N) {
  set<int> dist;
  while (N) {
    dist.insert(N % 10);
    N /= 10;
  }
  return (dist.size() == 4);
}
int sum(int n) { return (n * (n + 1) / 2); }
bool is_even(int n) { return !(n % 2); }
int calc_dist(int i, int j, vector<int> distances) {
  int dist = 0;
  for (int k = i; k < j; k++) dist += distances[k];
  return dist;
}
bool count_ind_clmn(int i, int c) {
  int c_valid = 0;
  for (int j = 0; j < c; j++) {
    if (matrix[i][j] != -1) c_valid++;
  }
  return (c_valid == c);
}
bool count_ind_row(int j, int r) {
  int r_valid = 0;
  for (int i = 0; i < r; i++) {
    if (matrix[i][j] != -1) r_valid++;
  }
  return (r_valid == r);
}
void swap_two(int &x, int &y) {
  int temp = x;
  x = y;
  y = temp;
}
int sum_except(vector<int> cookies, int indx) {
  int bagsl = cookies.size(), sum_all = 0;
  for (int i = 0; i < bagsl; i++) {
    if (i != indx) sum_all += cookies[i];
  }
  return sum_all;
}
bool is_palindromic(string s) {
  string orgstr = s;
  reverse(s.begin(), s.end());
  string revstr = s;
  return (orgstr == revstr);
}
int find_index(vector<string> digs, string sma) {
  int digsl = digs.size(), requiered_index;
  for (int i = 0; i < digsl; i++) {
    if (sma == digs[i]) {
      requiered_index = i;
      return requiered_index;
    }
  }
}
int max_distances(vector<int> holds, int indx) {
  int max_distance = INT32_MIN, n = holds.size();
  for (int i = 1; i < n - 1; i++) {
    if (i == indx)
      max_distance = max(max_distance, (holds[i + 1] - holds[i - 1]));
    else
      max_distance = max(max_distance, (holds[i + 1] - holds[i]));
  }
  return max_distance;
}
long long fib(int n) {
  long long res, first = 1, second = 1;
  if (n == 1 || n == 2) return 1;
  for (int i = 3; i < n; i++) {
    res = first + second;
    first = second;
    second = res;
  }
  return res;
}
unsigned long long min_shots(unsigned long long N) {
  int bottle_shots[3] = {5, 10, 15};
  unsigned long long min_nshots = 0;
  int indx = 2;
  while (N > 0 && indx >= 0) {
    if (N >= bottle_shots[indx]) {
      min_nshots += (N / bottle_shots[indx]);
      N %= bottle_shots[indx];
    } else
      indx--;
  }
  return min_nshots;
}
void finpout() {
  ios_base::sync_with_stdio(0);
  cin.tie(0), cout.tie(0);
}
int main() {
  finpout();
  int n, k, sum_days = 0;
  cin >> n >> k;
  vector<pair<int, int>> instu_per_day(n);
  for (int i = 0; i < n; i++) {
    cin >> instu_per_day[i].first;
    instu_per_day[i].second = i + 1;
  }
  sort(instu_per_day.begin(), instu_per_day.end());
  vector<int> free_days;
  for (int i = 0; i < n; i++) {
    if (instu_per_day[i].first <= k &&
        (instu_per_day[i].first + sum_days) <= k) {
      free_days.push_back(instu_per_day[i].second);
      sum_days += instu_per_day[i].first;
    }
  }
  int vln = free_days.size();
  printf("%d\n", vln);
  if (!vln) return 0;
  for (int i = 0; i < vln; i++) printf("%d ", free_days[i]);
  printf("\n");
  return 0;
}
