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.
import java.io.*;
import java.math.*;
import java.util.*;
import java.text.*;

public class Main {
    private static FastIO sc;

    public static void main(String[] args) {
        sc = new FastIO(System.in, System.out);
        int n = sc.readInt(), k = sc.readInt();
        ArrayList<IntIntPair> list = new ArrayList<>();
        for (int i = 0; i < n; i++) {
            list.add(IntIntPair.makePair(sc.readInt(), i + 1));
        }
        Collections.sort(list);
        List<Integer> indexes = new ArrayList<>();
        for (IntIntPair c : list) {
            if (c.first <= k) {
                indexes.add(c.second);
                k -= c.first;
            }
        }
        sc.println(indexes.size());
        for (Integer c : indexes) sc.printls(c);
        sc.close();
    }

    static void printPrecision(double d) {
        DecimalFormat ft = new DecimalFormat("0.00000000000");//Change the pattern
        sc.println(ft.format(d));
    }

    static class IntIntPair implements Comparable<IntIntPair> {
        public final int first;
        public final int second;

        public static IntIntPair makePair(int first, int second) {
            return new IntIntPair(first, second);
        }

        public IntIntPair(int first, int second) {
            this.first = first;
            this.second = second;
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) {
                return true;
            }
            if (o == null || getClass() != o.getClass()) {
                return false;
            }

            IntIntPair pair = (IntIntPair) o;

            return first == pair.first && second == pair.second;
        }

        @Override
        public int hashCode() {
            int result = first;
            result = 31 * result + second;
            return result;
        }

        public IntIntPair swap() {
            return IntIntPair.makePair(second, first);
        }

        @Override
        public String toString() {
            return "(" + first + "," + second + ")";
        }

        @SuppressWarnings({"unchecked"})
        public int compareTo(IntIntPair o) {
            int value = Integer.compare(first, o.first);
            if (value != 0) {
                return value;
            }
            return Integer.compare(second, o.second);
        }
    }

    private static class FastIO {

        public static final int DEFAULT_BUFFER_SIZE = 65536;
        public static final int DEFAULT_INTEGER_SIZE = 11;
        public static final int DEFAULT_LONG_SIZE = 20;
        public static final int DEFAULT_WORD_SIZE = 256;
        public static final int DEFAULT_LINE_SIZE = 8192;
        public static final int EOF = -1;

        private final InputStream in;
        private final OutputStream out;

        private byte[] inBuffer;
        private int nextIn, inLength;
        private byte[] outBuffer;
        private int nextOut;

        private char[] charBuffer;
        private byte[] byteBuffer;

        public FastIO(InputStream in, OutputStream out, int inBufferSize, int outBufferSize) {
            this.in = in;
            this.inBuffer = new byte[inBufferSize];
            this.nextIn = 0;
            this.inLength = 0;

            this.out = out;
            this.outBuffer = new byte[outBufferSize];
            this.nextOut = 0;

            this.charBuffer = new char[DEFAULT_LINE_SIZE];
            this.byteBuffer = new byte[DEFAULT_LONG_SIZE];
        }

        public FastIO(InputStream in, OutputStream out) {
            this(in, out, DEFAULT_BUFFER_SIZE, DEFAULT_BUFFER_SIZE);
        }

        public FastIO(InputStream in, OutputStream out, int bufferSize) {
            this(in, out, bufferSize, bufferSize);
        }

        public char readChar() {
            byte b;
            while (isSpace(b = read()))
                ;

            return (char) b;
        }

        public String readString() {
            byte b;
            while (isSpace(b = read()))
                ;

            int pos = 0;
            do {
                charBuffer[pos++] = (char) b;
                ensureCapacity(pos);
            } while (!isSpace(b = read()));

            return new String(charBuffer, 0, pos);
        }

        public String readLine() {
            byte b;
            int pos = 0;

            while (!isLine(b = read())) {
                charBuffer[pos++] = (char) b;
                ensureCapacity(pos);
            }

            return new String(charBuffer, 0, pos);
        }

        public int readInt() {
            byte b;
            while (isSpace(b = read()))
                ;

            boolean negative = false;
            int result = b - '0';
            if (b == '-') {
                negative = true;
                result = 0;
            }

            while (isDigit(b = read()))
                result = (result * 10) + (b - '0');

            return negative ? -result : result;
        }

        public long readLong() {
            byte b;
            while (isSpace(b = read()))
                ;

            boolean negative = false;
            long result = b - '0';
            if (b == '-') {
                negative = true;
                result = 0;
            }

            while (isDigit(b = read()))
                result = (result * 10) + (b - '0');

            return negative ? -result : result;
        }

        public float nextFloat() {
            byte b;
            while (isSpace(b = read()))
                ;

            int pos = 0;
            do {
                charBuffer[pos++] = (char) b;
            } while (!isSpace(b = read()));

            return Float.parseFloat(new String(charBuffer, 0, pos));
        }

        public float nextFloat2() {
            byte b;
            while (isSpace(b = read()))
                ;

            boolean negative = false;
            float result = b - '0';
            if (b == '-') {
                negative = true;
                result = 0;
            }

            while (isDigit(b = read()))
                result = (result * 10) + (b - '0');

            float d = 1;
            if (b == '.') {
                while (isDigit(b = read()))
                    result += (b - '0') / (d *= 10);
            }

            return negative ? -result : result;
        }

        public double readDouble() {
            byte b;
            while (isSpace(b = read()))
                ;

            int pos = 0;
            do {
                charBuffer[pos++] = (char) b;
            } while (!isSpace(b = read()));

            return Double.parseDouble(new String(charBuffer, 0, pos));
        }

        public double nextDouble2() {
            byte b;
            while (isSpace(b = read()))
                ;

            boolean negative = false;
            double result = b - '0';
            if (b == '-') {
                negative = true;
                result = 0;
            }

            while (isDigit(b = read()))
                result = (result * 10) + (b - '0');

            double d = 1;
            if (b == '.') {
                while (isDigit(b = read()))
                    result += (b - '0') / (d *= 10);
            }

            return negative ? -result : result;
        }

        public BigInteger readBigInteger() {
            return new BigInteger(readString());
        }

        public BigDecimal readBigDecimal() {
            return new BigDecimal(readString());
        }

        public char[] nextToCharArray() {
            byte b;
            while (isSpace(b = read()))
                ;

            int pos = 0;
            do {
                charBuffer[pos++] = (char) b;
                ensureCapacity(pos);
            } while (!isSpace(b = read()));

            char[] array = new char[pos];
            System.arraycopy(charBuffer, 0, array, 0, pos);
            return array;
        }

        public int[] readIntArray(int size) {
            int[] array = new int[size];
            for (int i = 0; i < size; i++)
                array[i] = readInt();

            return array;
        }

        public long[] readLongArray(int size) {
            long[] array = new long[size];
            for (int i = 0; i < size; i++)
                array[i] = readLong();

            return array;
        }

        public int[][] nextInt2DArray(int Y, int X) {
            int[][] array = new int[Y][X];
            for (int y = 0; y < Y; y++)
                for (int x = 0; x < X; x++)
                    array[y][x] = readInt();

            return array;
        }

        public void print(char c) {
            write((byte) c);
        }

        public void print(char[] chars) {
            print(chars, 0, chars.length);
        }

        public void print(char[] chars, int start) {
            print(chars, start, chars.length);
        }

        public void print(char[] chars, int start, int end) {
            for (int i = start; i < end; i++)
                write((byte) chars[i]);
        }

        public void print(String s) {
            for (int i = 0; i < s.length(); i++)
                write((byte) s.charAt(i));
        }

        public void print(int i) {
            if (i == 0) {
                write((byte) '0');
                return;
            }
            if (i == Integer.MIN_VALUE) {
                write((byte) '-');
                write((byte) '2');
                write((byte) '1');
                write((byte) '4');
                write((byte) '7');
                write((byte) '4');
                write((byte) '8');
                write((byte) '3');
                write((byte) '6');
                write((byte) '4');
                write((byte) '8');
                return;
            }

            if (i < 0) {
                write((byte) '-');
                i = -i;
            }

            int pos = 0;
            while (i > 0) {
                byteBuffer[pos++] = (byte) ((i % 10) + '0');
                i /= 10;
            }

            while (pos-- > 0)
                write(byteBuffer[pos]);
        }

        public void print(long l) {
            if (l == 0) {
                write((byte) '0');
                return;
            }
            if (l == Long.MIN_VALUE) {
                write((byte) '-');
                write((byte) '9');
                write((byte) '2');
                write((byte) '2');
                write((byte) '3');
                write((byte) '3');
                write((byte) '7');
                write((byte) '2');
                write((byte) '0');
                write((byte) '3');
                write((byte) '6');
                write((byte) '8');
                write((byte) '5');
                write((byte) '4');
                write((byte) '7');
                write((byte) '7');
                write((byte) '5');
                write((byte) '8');
                write((byte) '0');
                write((byte) '8');
                return;
            }

            if (l < 0) {
                write((byte) '-');
                l = -l;
            }

            int pos = 0;
            while (l > 0) {
                byteBuffer[pos++] = (byte) ((l % 10) + '0');
                l /= 10;
            }

            while (pos-- > 0)
                write(byteBuffer[pos]);
        }

        public void print(float f) {
            String sf = Float.toString(f);
            for (int i = 0; i < sf.length(); i++)
                write((byte) sf.charAt(i));
        }

        public void print(double d) {
            String sd = Double.toString(d);
            for (int i = 0; i < sd.length(); i++)
                write((byte) sd.charAt(i));
        }

        public void printls(char c) {
            print(c);
            write((byte) ' ');
        }

        public void printls(String s) {
            print(s);
            write((byte) ' ');
        }

        public void printls(int i) {
            print(i);
            write((byte) ' ');
        }

        public void printls(long l) {
            print(l);
            write((byte) ' ');
        }

        public void printls(float f) {
            print(f);
            write((byte) ' ');
        }

        public void printls(double d) {
            print(d);
            write((byte) ' ');
        }

        public void printls() {
            write((byte) ' ');
        }

        public void println(char c) {
            print(c);
            write((byte) '\n');
        }

        public void println(char[] chars) {
            print(chars, 0, chars.length);
            write((byte) '\n');
        }

        public void println(String s) {
            print(s);
            write((byte) '\n');
        }

        public void println(int i) {
            print(i);
            write((byte) '\n');
        }

        public void println(long l) {
            print(l);
            write((byte) '\n');
        }

        public void println(float f) {
            print(f);
            write((byte) '\n');
        }

        public void println(double d) {
            print(d);
            write((byte) '\n');
        }

        public void println() {
            write((byte) '\n');
        }

        public void printf(String format, Object... args) {
            String s = String.format(format, args);
            for (int i = 0; i < s.length(); i++)
                write((byte) s.charAt(i));
        }

        public void fprint(char c) {
            print(c);
            flushBuffer();
        }

        public void fprint(String s) {
            print(s);
            flushBuffer();
        }

        public void fprint(int i) {
            print(i);
            flushBuffer();
        }

        public void fprint(long l) {
            print(l);
            flushBuffer();
        }

        public void fprint(float f) {
            print(f);
            flushBuffer();
        }

        public void fprint(double d) {
            print(d);
            flushBuffer();
        }

        public void fprintf(String format, Object... args) {
            printf(format, args);
            flushBuffer();
        }

        private byte read() {
            if (nextIn >= inLength) {
                if ((inLength = fill()) == EOF)
                    return EOF;
                nextIn = 0;
            }

            return inBuffer[nextIn++];
        }

        private void write(byte b) {
            if (nextOut >= outBuffer.length)
                flushBuffer();

            outBuffer[nextOut++] = b;
        }

        private int fill() {
            try {
                return in.read(inBuffer, 0, inBuffer.length);
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        }

        public void flush() {
            flushBuffer();
        }

        private void flushBuffer() {
            if (nextOut == 0)
                return;

            try {
                out.write(outBuffer, 0, nextOut);
            } catch (Exception e) {
                throw new RuntimeException(e);
            }

            nextOut = 0;
        }

        public void close() {
            flush();
        }

        public void exit(char c) {
            fprint(c);
            System.exit(0);
        }

        public void exit(String s) {
            fprint(s);
            System.exit(0);
        }

        public void exit(int i) {
            fprint(i);
            System.exit(0);
        }

        public void exit(long l) {
            fprint(l);
            System.exit(0);
        }

        public void exit(float f) {
            fprint(f);
            System.exit(0);
        }

        public void exit(double d) {
            fprint(d);
            System.exit(0);
        }

        public void exit(String format, Object... args) {
            fprintf(format, args);
            System.exit(0);
        }

        public void exit() {
            flushBuffer();
            System.exit(0);
        }

        private void ensureCapacity(int size) {
            if (size < charBuffer.length)
                return;

            char[] array = new char[size * 2];
            System.arraycopy(charBuffer, 0, array, 0, size);
            charBuffer = array;
        }

        private boolean isDigit(byte b) {
            return b >= '0' && b <= '9';
        }

        private boolean isLine(byte b) {
            return b == '\n' || b == '\r' || b == EOF;
        }

        private boolean isSpace(byte b) {
            return b == ' ' || b == '\t' || b == '\n' || b == '\r' || b == '\f' || b == EOF;
        }
    }
}
   	 	 		 		 	 	    	 	 		 	  	