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 CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
struct ii {
  int x, y;
  ii(int x = 0, int y = 0) : x(x), y(y) {}
  bool operator<(const ii &a) const {
    if (x != a.x) return x < a.x;
    return y < a.y;
  }
  bool operator==(const ii &a) const { return x == a.x && y == a.y; }
  ii friend operator+(ii a, ii b) { return ii(a.x + b.x, a.y + b.y); }
  ii friend operator-(ii a, ii b) { return ii(a.x - b.x, a.y - b.y); }
};
template <class T>
void sc(T &x) {
  x = 0;
  char c;
  int f = 1;
  while (c = getchar(), c < 48)
    if (c == '-') f = -1;
  do x = x * 10 + (c ^ 48);
  while (c = getchar(), c > 47);
  x *= f;
}
template <class T>
void nt(T x) {
  if (!x) return;
  nt(x / 10);
  putchar(x % 10 + '0');
}
template <class T>
void pt(T x) {
  if (x < 0) putchar('-'), x = -x;
  if (!x)
    putchar('0');
  else
    nt(x);
}
template <class T>
void pts(T x) {
  pt(x);
  putchar(' ');
}
template <class T>
void ptn(T x) {
  pt(x);
  putchar('\n');
}
template <class v>
void pp(v x, int y) {
  static char ch[] = {" \n"};
  pt(x);
  putchar(ch[y]);
}
template <class T>
void PP(T *x, int y) {
  for (int i = 0, i_ = (y)-1; i <= i_; ++i) pp(x[i], i == y - 1);
}
template <class T>
void Max(T &x, T y) {
  if (x < y) x = y;
}
template <class T>
void Min(T &x, T y) {
  if (x > y) x = y;
}
const int maxn = 1005;
int n, a[maxn], b[maxn];
vector<int> U, V;
bool cmp(int x, int y) { return a[x] > a[y]; }
void mov(int x, int y) {
  a[y] -= a[x];
  a[x] <<= 1;
  U.push_back(x);
  V.push_back(y);
}
bool solve(int *b) {
  sort(b, b + 3, cmp);
  for (int t = a[b[1]] / a[b[2]]; t; t >>= 1) {
    if (t & 1)
      mov(b[2], b[1]);
    else if (t >> 1)
      mov(b[2], b[0]);
  }
  sort(b, b + 3, cmp);
  return a[b[2]];
}
int main() {
  sc(n);
  for (int i = 1, i_ = (n + 1) - 1; i <= i_; ++i) {
    sc(a[i]);
  }
  for (int i = 1, i_ = (n + 1) - 1; i <= i_; ++i) b[i] = i;
  int cnt = 0;
  sort(b + 1, b + n + 1, cmp);
  for (int i = 1, i_ = (n + 1) - 1; i <= i_; ++i)
    if (a[b[i]]) cnt = i;
  if (cnt < 2) return puts("-1"), 0;
  while (cnt > 2) {
    while (solve(b + cnt - 2))
      ;
    --cnt;
  }
  ptn((int)(U).size());
  for (int i = 0, i_ = ((int)(U).size()) - 1; i <= i_; ++i) {
    pts(U[i]);
    ptn(V[i]);
  }
  return 0;
}