There are quite a lot of ways to have fun with inflatable balloons. For example, you can fill them with water and see what happens.

Grigory and Andrew have the same opinion. So, once upon a time, they went to the shop and bought n packets with inflatable balloons, where i-th of them has exactly a_i balloons inside.

They want to divide the balloons among themselves. In addition, there are several conditions to hold:

  * Do not rip the packets (both Grigory and Andrew should get unbroken packets); 
  * Distribute all packets (every packet should be given to someone); 
  * Give both Grigory and Andrew at least one packet; 
  * To provide more fun, the total number of balloons in Grigory's packets should not be equal to the total number of balloons in Andrew's packets. 



Help them to divide the balloons or determine that it's impossible under these conditions.

Input

The first line of input contains a single integer n (1 ≤ n ≤ 10) — the number of packets with balloons.

The second line contains n integers: a_1, a_2, …, a_n (1 ≤ a_i ≤ 1000) — the number of balloons inside the corresponding packet.

Output

If it's impossible to divide the balloons satisfying the conditions above, print -1.

Otherwise, print an integer k — the number of packets to give to Grigory followed by k distinct integers from 1 to n — the indices of those. The order of packets doesn't matter.

If there are multiple ways to divide balloons, output any of them.

Examples

Input

3
1 2 1


Output

2
1 2


Input

2
5 5


Output

-1


Input

1
10


Output

-1

Note

In the first test Grigory gets 3 balloons in total while Andrey gets 1.

In the second test there's only one way to divide the packets which leads to equal numbers of balloons.

In the third test one of the boys won't get a packet at all.
import java.io.IOException;
import java.io.InputStream;


public class Main
{
    public static void main(String[] args) throws Exception
    {
        InputReader scan = new InputReader();

        int n = scan.nextInt();
        int minVal = Integer.MAX_VALUE, minIdx = -1;
        int[] packets =  new int[n];


        for (int i = 0; i < n; i++) {
            packets[i] = scan.nextInt();
            if(packets[i] < minVal) {
                minIdx = i;
                minVal = packets[i];
            }
        }

        if(n==1) {
            System.out.println("-1");
        } else if(n==2) {
            if (packets[0] == packets[1]) {
                System.out.println("-1");
            } else {
                System.out.println("1");
                System.out.println("1");
            }
        } else {
            System.out.println("1");
            System.out.println(minIdx+1);
        }

    }
}

///////////////////////////////////////////////////////////////////////////////////////////////////

class InputReader {

    /**
     * The default size of the InputReader's buffer is 2<sup>16</sup>.
     */
    public static final int DEFAULT_BUFFER_SIZE = 1 << 16;

    /**
     * The default stream for the InputReader is standard input.
     */
    public static final InputStream DEFAULT_STREAM = System.in;

    /**
     * The maximum number of accurate decimal digits the method {@link #nextDoubleFast() nextDoubleFast()} can read.
     * Currently this value is set to 21 because it is the maximum number of digits a double precision float can have at the moment.
     */
    public static final int MAX_DECIMAL_PRECISION = 21;

    // 'c' is used to refer to the current character in the stream
    private int c;

    // Variables associated with the byte buffer.
    private final byte[] buf;
    private int bufferSize, bufIndex, numBytesRead;

    private final InputStream stream;

    private static final byte EOF   = -1; // End Of File (EOF) character
    private static final byte NL    = 10; // '\n' - New Line (NL)
    private static final byte SP    = 32; // ' '  - Space character (SP)
    private static final byte DASH  = 45; // '-'  - Dash character (DASH)
    private static final byte DOT   = 46; // '.'  - Dot character (DOT)

    // A character buffer I reuse when reading string data.
    private static char[] charBuffer = new char[128];

    // Primitive data type lookup tables used for optimizations
    private static byte[] bytes = new byte[58];
    private static  int[] ints  = new int[58];
    private static char[] chars = new char[128];

    static {
        char ch = ' '; int value = 0; byte _byte = 0;
        for (int i = 48; i <  58; i++ ) bytes[i] = _byte++;
        for (int i = 48; i <  58; i++ )  ints[i] = value++;
        for (int i = 32; i < 128; i++ ) chars[i] = ch++;
    }

    // Primitive double lookup table used for optimizations.
    private static final double[][] doubles = {
            { 0.0d,0.00d,0.000d,0.0000d,0.00000d,0.000000d,0.0000000d,0.00000000d,0.000000000d,0.0000000000d,0.00000000000d,0.000000000000d,0.0000000000000d,0.00000000000000d,0.000000000000000d,0.0000000000000000d,0.00000000000000000d,0.000000000000000000d,0.0000000000000000000d,0.00000000000000000000d,0.000000000000000000000d },
            { 0.1d,0.01d,0.001d,0.0001d,0.00001d,0.000001d,0.0000001d,0.00000001d,0.000000001d,0.0000000001d,0.00000000001d,0.000000000001d,0.0000000000001d,0.00000000000001d,0.000000000000001d,0.0000000000000001d,0.00000000000000001d,0.000000000000000001d,0.0000000000000000001d,0.00000000000000000001d,0.000000000000000000001d },
            { 0.2d,0.02d,0.002d,0.0002d,0.00002d,0.000002d,0.0000002d,0.00000002d,0.000000002d,0.0000000002d,0.00000000002d,0.000000000002d,0.0000000000002d,0.00000000000002d,0.000000000000002d,0.0000000000000002d,0.00000000000000002d,0.000000000000000002d,0.0000000000000000002d,0.00000000000000000002d,0.000000000000000000002d },
            { 0.3d,0.03d,0.003d,0.0003d,0.00003d,0.000003d,0.0000003d,0.00000003d,0.000000003d,0.0000000003d,0.00000000003d,0.000000000003d,0.0000000000003d,0.00000000000003d,0.000000000000003d,0.0000000000000003d,0.00000000000000003d,0.000000000000000003d,0.0000000000000000003d,0.00000000000000000003d,0.000000000000000000003d },
            { 0.4d,0.04d,0.004d,0.0004d,0.00004d,0.000004d,0.0000004d,0.00000004d,0.000000004d,0.0000000004d,0.00000000004d,0.000000000004d,0.0000000000004d,0.00000000000004d,0.000000000000004d,0.0000000000000004d,0.00000000000000004d,0.000000000000000004d,0.0000000000000000004d,0.00000000000000000004d,0.000000000000000000004d },
            { 0.5d,0.05d,0.005d,0.0005d,0.00005d,0.000005d,0.0000005d,0.00000005d,0.000000005d,0.0000000005d,0.00000000005d,0.000000000005d,0.0000000000005d,0.00000000000005d,0.000000000000005d,0.0000000000000005d,0.00000000000000005d,0.000000000000000005d,0.0000000000000000005d,0.00000000000000000005d,0.000000000000000000005d },
            { 0.6d,0.06d,0.006d,0.0006d,0.00006d,0.000006d,0.0000006d,0.00000006d,0.000000006d,0.0000000006d,0.00000000006d,0.000000000006d,0.0000000000006d,0.00000000000006d,0.000000000000006d,0.0000000000000006d,0.00000000000000006d,0.000000000000000006d,0.0000000000000000006d,0.00000000000000000006d,0.000000000000000000006d },
            { 0.7d,0.07d,0.007d,0.0007d,0.00007d,0.000007d,0.0000007d,0.00000007d,0.000000007d,0.0000000007d,0.00000000007d,0.000000000007d,0.0000000000007d,0.00000000000007d,0.000000000000007d,0.0000000000000007d,0.00000000000000007d,0.000000000000000007d,0.0000000000000000007d,0.00000000000000000007d,0.000000000000000000007d },
            { 0.8d,0.08d,0.008d,0.0008d,0.00008d,0.000008d,0.0000008d,0.00000008d,0.000000008d,0.0000000008d,0.00000000008d,0.000000000008d,0.0000000000008d,0.00000000000008d,0.000000000000008d,0.0000000000000008d,0.00000000000000008d,0.000000000000000008d,0.0000000000000000008d,0.00000000000000000008d,0.000000000000000000008d },
            { 0.9d,0.09d,0.009d,0.0009d,0.00009d,0.000009d,0.0000009d,0.00000009d,0.000000009d,0.0000000009d,0.00000000009d,0.000000000009d,0.0000000000009d,0.00000000000009d,0.000000000000009d,0.0000000000000009d,0.00000000000000009d,0.000000000000000009d,0.0000000000000000009d,0.00000000000000000009d,0.000000000000000000009d }
    };

    /**
     * Create an InputReader that reads from standard input.
     */
    public InputReader () {
        this(DEFAULT_STREAM, DEFAULT_BUFFER_SIZE);
    }

    /**
     * Create an InputReader that reads from standard input.
     * @param bufferSize    The buffer size for this input reader.
     */
    public InputReader(int bufferSize) {
        this(DEFAULT_STREAM, bufferSize);
    }

    /**
     * Create an InputReader that reads from standard input.
     * @param stream  Takes an InputStream as a parameter to read from.
     */
    public InputReader(InputStream stream) {
        this(stream, DEFAULT_BUFFER_SIZE);
    }

    /**
     * Create an InputReader that reads from standard input.
     * @param  stream        Takes an {@link java.io.InputStream#InputStream() InputStream} as a parameter to read from.
     * @param  bufferSize    The size of the buffer to use.
     */
    public InputReader (InputStream stream, int bufferSize) {
        if (stream == null || bufferSize <= 0)
            throw new IllegalArgumentException();
        buf = new byte[bufferSize];
        this.bufferSize = bufferSize;
        this.stream = stream;
    }

    /**
     * Reads a single character from the input stream.
     * @return Returns the byte value of the next character in the buffer and EOF
     * at the end of the stream.
     * @throws IOException throws exception if there is no more data to read
     */
    private byte read() throws IOException {

        if (numBytesRead == EOF) throw new IOException();

        if (bufIndex >= numBytesRead) {
            bufIndex = 0;
            numBytesRead = stream.read(buf);
            if (numBytesRead == EOF)
                return EOF;
        }

        return buf[bufIndex++];
    }

    /**
     *  Read values from the input stream until you reach a character with a
     *  higher ASCII value than 'token'
     * @param token The token is a value which we use to stop reading junk out of
     * the stream.
     * @return Returns 0 if a value greater than the token was reached or -1 if
     * the end of the stream was reached.
     * @throws IOException Throws exception at end of stream.
     */
    private int readJunk(int token) throws IOException {

        if (numBytesRead == EOF) return EOF;

        // Seek to the first valid position index
        do {

            while(bufIndex < numBytesRead) {
                if (buf[bufIndex] > token) return 0;
                bufIndex++;
            }

            // reload buffer
            numBytesRead = stream.read(buf);
            if (numBytesRead == EOF) return EOF;
            bufIndex = 0;

        } while(true);

    }

    /**
     * Reads a single byte from the input stream.
     * @return The next byte in the input stream
     * @throws IOException Throws exception at end of stream.
     */
    public byte nextByte() throws IOException {
        return (byte) nextInt();
    }

    /**
     * Reads a 32 bit signed integer from input stream.
     * @return The next integer value in the stream.
     * @throws IOException Throws exception at end of stream.
     */
    public int nextInt() throws IOException {

        if (readJunk(DASH-1) == EOF) throw new IOException();
        int sgn = 1, res = 0;

        c = buf[bufIndex];
        if (c == DASH) { sgn = -1; bufIndex++; }

        do {

            while(bufIndex < numBytesRead) {
                if (buf[bufIndex] > SP) {
                    res = (res<<3)+(res<<1);
                    res += ints[buf[bufIndex++]];
                } else {
                    bufIndex++;
                    return res*sgn;
                }
            }

            // Reload buffer
            numBytesRead = stream.read(buf);
            if (numBytesRead == EOF) return res*sgn;
            bufIndex = 0;

        } while(true);

    }

    /**
     * Reads a 64 bit signed long from input stream.
     * @return The next long value in the stream.
     * @throws IOException Throws exception at end of stream.
     */
    public long nextLong() throws IOException {

        if (readJunk(DASH-1) == EOF) throw new IOException();
        int sgn = 1;
        long res = 0L;
        c = buf[bufIndex];
        if (c == DASH) { sgn = -1; bufIndex++; }

        do {

            while(bufIndex < numBytesRead) {
                if (buf[bufIndex] > SP) {
                    res = (res<<3)+(res<<1);
                    res += ints[buf[bufIndex++]];
                } else {
                    bufIndex++;
                    return res*sgn;
                }
            }

            // Reload buffer
            numBytesRead = stream.read(buf);
            if (numBytesRead == EOF) return res*sgn;
            bufIndex = 0;

        } while(true);

    }

    /**
     * Doubles the size of the internal char buffer for strings
     */
    private void doubleCharBufferSize() {
        char[] newBuffer = new char[charBuffer.length << 1];
        for(int i = 0; i < charBuffer.length; i++) newBuffer[i] = charBuffer[i];
        charBuffer = newBuffer;
    }

    /**
     * Reads a line from the input stream.
     * @return Returns a line from the input stream in the form a String not
     * including the new line character. Returns <code>null</code> when there are
     * no more lines.
     * @throws IOException Throws IOException when something terrible happens.
     */
    public String nextLine() throws IOException {

        try { c=read(); } catch (IOException e) { return null; }
        if (c == NL) return ""; // Empty line
        if (c == EOF) return null; // EOF

        int i = 0;
        charBuffer[i++] = (char)c;

        do {

            while(bufIndex < numBytesRead) {
                if (buf[bufIndex] != NL) {
                    if (i == charBuffer.length) doubleCharBufferSize();
                    charBuffer[i++] = (char) buf[bufIndex++];
                } else {
                    bufIndex++;
                    return new String(charBuffer, 0, i);
                }
            }

            // Reload buffer
            numBytesRead = stream.read(buf);
            if (numBytesRead == EOF)
                return new String(charBuffer, 0, i);
            bufIndex = 0;

        } while(true);

    }

    // Reads a string of characters from the input stream.
    // The delimiter separating a string of characters is set to be:
    // any ASCII value <= 32 meaning any spaces, new lines, EOF, tabs ...
    public String nextString() throws IOException {

        if (numBytesRead == EOF) return null;
        if (readJunk(SP) == EOF) return null;
        int i = 0;

        do {

            while(bufIndex < numBytesRead) {
                if (buf[bufIndex] > SP) {
                    if (i == charBuffer.length) doubleCharBufferSize();
                    charBuffer[i++] = (char) buf[bufIndex++];
                } else {
                    bufIndex++;
                    return new String(charBuffer, 0, i);
                }
            }

            // Reload buffer
            numBytesRead = stream.read(buf);
            if (numBytesRead == EOF) return new String(charBuffer, 0, i);
            bufIndex = 0;

        } while(true);

    }

    // Returns an exact value a double value from the input stream.
    public double nextDouble() throws IOException {
        String doubleVal = nextString();
        if (doubleVal == null) throw new IOException();
        return Double.valueOf(doubleVal);
    }

    // Very quickly reads a double value from the input stream (~3x faster than nextDouble()). However,
    // this method may provide a slightly less accurate reading than .nextDouble() if there are a lot
    // of digits (~16+). In particular, it will only read double values with at most 21 digits after
    // the decimal point and the reading my be as inaccurate as ~5*10^-16 from the true value.
    public double nextDoubleFast() throws IOException {
        c = read(); int sgn = 1;
        while (c <= SP) c = read(); // while c is either: ' ', '\n', EOF
        if (c == DASH) { sgn = -1; c = read(); }
        double res = 0.0;
        // while c is not: ' ', '\n', '.' or -1
        while (c > DOT) {res *= 10.0; res += ints[c]; c = read(); }
        if (c == DOT) {
            int i = 0; c = read();
            // while c is digit and we are less than the maximum decimal precision
            while (c > SP && i < MAX_DECIMAL_PRECISION) {
                res += doubles[ints[c]][i++]; c = read();
            }
        }
        return res * sgn;
    }

    // Read an array of n byte values
    public byte[] nextByteArray(int n) throws IOException {
        byte[] ar = new byte[n];
        for (int i = 0; i < n; i++) ar[i] = nextByte();
        return ar;
    }

    // Read an array of n char values
    // Buggy method must patch
    // public char[] nextCharArray(int n) throws IOException {
    //   String str = nextString();
    //   if (str == null) return null;
    //   return str.toCharArray();
    // }


    // Closes the input stream
    public void close() throws IOException {
        stream.close();
    }

}