Problem: Iahub is playing an uncommon game. Initially, he has n boxes, numbered 1, 2, 3, ..., n. Each box has some number of candies in it, described by a sequence a1, a2, ..., an. The number ak represents the number of candies in box k. 

The goal of the game is to move all candies into exactly two boxes. The rest of n - 2 boxes must contain zero candies. Iahub is allowed to do several (possible zero) moves. At each move he chooses two different boxes i and j, such that ai ≤ aj. Then, Iahub moves from box j to box i exactly ai candies. Obviously, when two boxes have equal number of candies, box number j becomes empty.

Your task is to give him a set of moves such as Iahub to archive the goal of the game. If Iahub can't win the game for the given configuration of boxes, output -1. Please note that in case there exist a solution, you don't need to print the solution using minimal number of moves.

Input

The first line of the input contains integer n (3 ≤ n ≤ 1000). The next line contains n non-negative integers: a1, a2, ..., an — sequence elements. It is guaranteed that sum of all numbers in sequence a is up to 106. 

Output

In case there exists no solution, output -1. Otherwise, in the first line output integer c (0 ≤ c ≤ 106), representing number of moves in your solution. Each of the next c lines should contain two integers i and j (1 ≤ i, j ≤ n, i ≠ j): integers i, j in the kth line mean that at the k-th move you will move candies from the j-th box to the i-th one.

Examples

Input

3
3 6 9


Output

2
2 3
1 3


Input

3
0 1 0


Output

-1

Input

4
0 1 1 0


Output

0

Note

For the first sample, after the first move the boxes will contain 3, 12 and 3 candies. After the second move, the boxes will contain 6, 12 and 0 candies. Now all candies are in exactly 2 boxes.

For the second sample, you can observe that the given configuration is not valid, as all candies are in a single box and they should be in two boxes. Also, any move won't change the configuration, so there exists no solution.

For the third sample, all candies are already in 2 boxes. Hence, no move is needed.

Solution (in JAVA):

Solution:
import java.util.*;
import java.io.*;

public class Candy {
    public static void main(String [] args) {
        Solver s = new Solver () ;
        s.solve();
    }
    static class Solver {
        int min_value(ArrayList <Pair> a) {
            int mn = Integer.MAX_VALUE;
            for(Pair i : a) {
                mn = Math.min(mn, i.first);
            }
            return mn;
        }
        void solve() {
            Reader in = new Reader ();
            Writer out = new Writer ();
            int n = in.nextInt();
            Pair [] a = new Pair [n + 1];
            for(int i = 1; i <= n; i++) {
                a[i] = new Pair();
                a[i].first = in.nextInt();
                a[i].second = i;
            }
            Arrays.sort(a, 1, n + 1, new Pair());

            if(a[n - 1].first == 0) {
                System.out.println("-1");
                System.exit(0);
            }
            ArrayList <Pair> ans = new ArrayList <> ();
            ArrayList <Pair> can = new ArrayList <> ();
            can.add(a[n]);
            can.add(a[n - 1]);

            for(int i = n - 2; i >= 1; i--) {
                ArrayList <Pair> cur = new ArrayList <> ();
                cur.add(a[i]);
                cur.add(can.get(0));
                cur.add(can.get(1));
                Collections.sort(cur, new Pair());

                while(min_value(cur) > 0) {
                    int q = cur.get(1).first / cur.get(0).first;
                    for(int b = 0; b < 30; b++) {
                        if((1 << b) > q) break; 
                        if(((q >> b) & 1) == 1) {
                            cur.get(1).first -= cur.get(0).first;
                            cur.get(0).first <<= 1; 
                            ans.add(new Pair(cur.get(0).second, cur.get(1).second));
                        } else {
                            cur.get(2).first -= cur.get(0).first;
                            cur.get(0).first <<= 1;
                            ans.add(new Pair(cur.get(0).second, cur.get(2).second));
                        }
                    }
                    Collections.sort(cur, new Pair());
                } 
                can.clear();
                for(Pair x : cur) {
                    if(x.first != 0) {
                        can.add(x);
                    }
                }
            }
            System.out.println(ans.size());
            for(Pair i : ans) {
                System.out.println(i.first + " " + i.second);
            }
        }
    }
    static class Reader {
        private StringTokenizer a;
        private BufferedReader b;
        Reader () {
            a = null;
            b = new BufferedReader (new InputStreamReader (System.in));
        }
        public String next () {
            while(a == null || !a.hasMoreTokens()) {
                try {
                    a = new StringTokenizer (b.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return a.nextToken();
        }
        public int nextInt() {
            return Integer.parseInt(this.next());
        }
        public long nextLong () {
            return Long.parseLong(this.next());
        }
        public double nextDouble () {
            return Double.parseDouble(this.next());
        }
        public String nextLine() {
            try {
                return b.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return "";
        }
    }
    static class Writer {
        private PrintWriter a;
        private StringBuffer b;
        Writer () {
            a = new PrintWriter (System.out);
            b = new StringBuffer ("");
        }
        public void write (Object s) {
            b.append(s);
        }
        public void writeln(Object s) {
            b.append(s).append('\n');
        }
        public void flush () {
            a.print(b);
            a.flush();
            a.close();
        }
    }
    static class Pair implements Comparator <Pair> {
        int first;
        int second;
        Pair  (int a, int b) {
            this.first = a;
            this.second = b;
        }
        Pair (Pair a) {
            this.first = a.first;
            this.second = a.second;
        } 
        Pair () {}
        public String toString () {
            return "[" + first + ", " + second + "]";
        }
        public int compare (Pair a, Pair b) {
            if(a.first == b.first) {
                return a.second - b.second;
            } else {
                return a.first - b.first;
            }
        }
    } 
}