description: An important meeting is to be held and there are exactly n people invited. At any moment, any two people can step back and talk in private. The same two people can talk several (as many as they want) times per meeting.
  
  Each person has limited sociability. The sociability of the i-th person is a non-negative integer a_i. This means that after exactly a_i talks this person leaves the meeting (and does not talk to anyone else anymore). If a_i = 0, the i-th person leaves the meeting immediately after it starts.
  
  A meeting is considered most productive if the maximum possible number of talks took place during it.
  
  You are given an array of sociability a, determine which people should talk to each other so that the total number of talks is as large as possible.
  
  Input
  
  The first line contains an integer t (1 ≤ t ≤ 1000) — the number of test cases.
  
  The next 2t lines contain descriptions of the test cases.
  
  The first line of each test case description contains an integer n (2 ≤ n ≤ 2 ⋅ 10^5) —the number of people in the meeting. The second line consists of n space-separated integers a_1, a_2, ..., a_n (0 ≤ a_i ≤ 2 ⋅ 10^5) — the sociability parameters of all people. 
  
  It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5. It is also guaranteed that the sum of all a_i (over all test cases and all i) does not exceed 2 ⋅ 10^5.
  
  Output
  
  Print t answers to all test cases.
  
  On the first line of each answer print the number k — the maximum number of talks possible in a meeting.
  
  On each of the next k lines print two integers i and j (1 ≤ i, j ≤ n and i ≠ j) — the numbers of people who will have another talk.
  
  If there are several possible answers, you may print any of them.
  
  Example
  
  Input
  
  
  8
  2
  2 3
  3
  1 2 3
  4
  1 2 3 4
  3
  0 0 2
  2
  6 2
  3
  0 0 2
  5
  8 2 0 1 1
  5
  0 1 0 0 6
  
  
  Output
  
  
  2
  1 2
  1 2
  3
  1 3
  2 3
  2 3
  5
  1 3
  2 4
  2 4
  3 4
  3 4
  0
  2
  1 2
  1 2
  0
  4
  1 2
  1 5
  1 4
  1 2
  1
  5 2
solution: import java.io.IOException;
  import java.io.InputStream;
  import java.io.OutputStream;
  import java.io.PrintWriter;
  import java.math.BigInteger;
  import java.util.*;
  
  /**
   * @author Mubtasim Shahriar
   */
  
  public class ProMeet {
  
      public static void main(String[] args) {
  
          InputStream inputStream = System.in;
          OutputStream outputStream = System.out;
          InputReader sc = new InputReader(inputStream);
          PrintWriter out = new PrintWriter(outputStream);
          Solver solver = new Solver();
  		int t = sc.nextInt();
  //        int t = 1;
          while (t-- != 0) {
              solver.solve(sc, out);
          }
          out.close();
  
      }
  
      static class Solver {
          public void solve(InputReader sc, PrintWriter out) {
              int n = sc.nextInt();
              int[] arr = sc.nextIntArray(n);
              TreeMap<Integer,ArrayList<Integer>> tm = new TreeMap<>();
              for(int i = 0; i < n; i++) {
                  int now = arr[i];
                  if(now==0) continue;
                  addd(tm,now,i);
              }
              ArrayList<int[]> ans = new ArrayList<>();
              while(!tm.isEmpty()) {
                  if(tm.size()==1) {
                      int fistkey = tm.firstKey();
                      ArrayList<Integer> list = tm.get(fistkey);
                      if((int)list.size()<2) break;
                      int last = list.get(list.size()-1);
                      list.remove(list.size()-1);
                      int prev = list.get(list.size()-1);
                      list.remove(list.size()-1);
                      if(list.isEmpty()) tm.remove(fistkey);
                      if(fistkey>1) {
                          addd(tm,fistkey-1,last);
                          addd(tm,fistkey-1,prev);
                      }
                      ans.add(new int[] {last,prev});
                  } else {
                      int lowkey = tm.firstKey();
                      int highkey = tm.lastKey();
                      ArrayList<Integer> highlist = tm.get(highkey);
                      ArrayList<Integer> lowlist = tm.get(lowkey);
                      int highOne = highlist.get(highlist.size()-1);
                      int lowOne = lowlist.get(lowlist.size()-1);
                      ans.add(new int[] {highOne,lowOne});
                      highlist.remove(highlist.size()-1);
                      lowlist.remove(lowlist.size()-1);
                      if(highlist.size()==0) tm.remove(highkey);
                      if(lowlist.size()==0) tm.remove(lowkey);
                      if(highkey>1) addd(tm,highkey-1,highOne);
                      if(lowkey>1) addd(tm,lowkey-1,lowOne);
                  }
              }
              out.println(ans.size());
              for(int[] ar : ans) out.println(ar[0]+1 + " " + (ar[1]+1));
          }
  
          private void addd(TreeMap<Integer, ArrayList<Integer>> tm, int val, int idx) {
              if(!tm.containsKey(val)) tm.put(val, new ArrayList<>());
              tm.get(val).add(idx);
          }
  
      }
  
      static class Seg {
          int leftmost, rightmost, mid, sum;
          Seg lchild, rchild;
          boolean leaf;
  
          Seg(int l, int r) {
              leftmost = l;
              rightmost = r;
              leaf = l==r;
              mid = (l+r)/2;
              if(leaf) {
                  sum = 0;
              } else {
                  lchild = new Seg(l,mid);
                  rchild = new Seg(mid+1,r);
                  sum = 0;
              }
          }
  
          int query(int l, int r) {
              if(l>rightmost || r<leftmost) return 0;
              if(l<=leftmost && rightmost<=r) return sum;
              return lchild.query(l,r) + rchild.query(l,r);
          }
  
          void update(int pos, int inc) {
              if(leaf) {
                  sum += inc;
                  return;
              }
              if(pos<=mid) lchild.update(pos,inc);
              else rchild.update(pos,inc);
              sum = lchild.sum + rchild.sum;
          }
      }
  
      static void sort(int[] arr) {
          Random rand = new Random();
          int n = arr.length;
          for (int i = 0; i < n; i++) {
              int idx = rand.nextInt(n);
              if (idx == i) continue;
              arr[i] ^= arr[idx];
              arr[idx] ^= arr[i];
              arr[i] ^= arr[idx];
          }
          Arrays.sort(arr);
      }
  
      static void sort(long[] arr) {
          Random rand = new Random();
          int n = arr.length;
          for (int i = 0; i < n; i++) {
              int idx = rand.nextInt(n);
              if (idx == i) continue;
              arr[i] ^= arr[idx];
              arr[idx] ^= arr[i];
              arr[i] ^= arr[idx];
          }
          Arrays.sort(arr);
      }
  
      static void sortDec(int[] arr) {
          Random rand = new Random();
          int n = arr.length;
          for (int i = 0; i < n; i++) {
              int idx = rand.nextInt(n);
              if (idx == i) continue;
              arr[i] ^= arr[idx];
              arr[idx] ^= arr[i];
              arr[i] ^= arr[idx];
          }
          Arrays.sort(arr);
          int l = 0;
          int r = n - 1;
          while (l < r) {
              arr[l] ^= arr[r];
              arr[r] ^= arr[l];
              arr[l] ^= arr[r];
              l++;
              r--;
          }
      }
  
      static void sortDec(long[] arr) {
          Random rand = new Random();
          int n = arr.length;
          for (int i = 0; i < n; i++) {
              int idx = rand.nextInt(n);
              if (idx == i) continue;
              arr[i] ^= arr[idx];
              arr[idx] ^= arr[i];
              arr[i] ^= arr[idx];
          }
          Arrays.sort(arr);
          int l = 0;
          int r = n - 1;
          while (l < r) {
              arr[l] ^= arr[r];
              arr[r] ^= arr[l];
              arr[l] ^= arr[r];
              l++;
              r--;
          }
      }
  
      static class InputReader {
          private boolean finished = false;
  
          private InputStream stream;
          private byte[] buf = new byte[1024];
          private int curChar;
          private int numChars;
          private SpaceCharFilter filter;
  
          public InputReader(InputStream stream) {
              this.stream = stream;
          }
  
          public int read() {
              if (numChars == -1) {
                  throw new InputMismatchException();
              }
              if (curChar >= numChars) {
                  curChar = 0;
                  try {
                      numChars = stream.read(buf);
                  } catch (IOException e) {
                      throw new InputMismatchException();
                  }
                  if (numChars <= 0) {
                      return -1;
                  }
              }
              return buf[curChar++];
          }
  
          public int peek() {
              if (numChars == -1) {
                  return -1;
              }
              if (curChar >= numChars) {
                  curChar = 0;
                  try {
                      numChars = stream.read(buf);
                  } catch (IOException e) {
                      return -1;
                  }
                  if (numChars <= 0) {
                      return -1;
                  }
              }
              return buf[curChar];
          }
  
          public int nextInt() {
              int c = read();
              while (isSpaceChar(c)) {
                  c = read();
              }
              int sgn = 1;
              if (c == '-') {
                  sgn = -1;
                  c = read();
              }
              int res = 0;
              do {
                  if (c < '0' || c > '9') {
                      throw new InputMismatchException();
                  }
                  res *= 10;
                  res += c - '0';
                  c = read();
              } while (!isSpaceChar(c));
              return res * sgn;
          }
  
          public long nextLong() {
              int c = read();
              while (isSpaceChar(c)) {
                  c = read();
              }
              int sgn = 1;
              if (c == '-') {
                  sgn = -1;
                  c = read();
              }
              long res = 0;
              do {
                  if (c < '0' || c > '9') {
                      throw new InputMismatchException();
                  }
                  res *= 10;
                  res += c - '0';
                  c = read();
              } while (!isSpaceChar(c));
              return res * sgn;
          }
  
          public String nextString() {
              int c = read();
              while (isSpaceChar(c)) {
                  c = read();
              }
              StringBuilder res = new StringBuilder();
              do {
                  if (Character.isValidCodePoint(c)) {
                      res.appendCodePoint(c);
                  }
                  c = read();
              } while (!isSpaceChar(c));
              return res.toString();
          }
  
          public boolean isSpaceChar(int c) {
              if (filter != null) {
                  return filter.isSpaceChar(c);
              }
              return isWhitespace(c);
          }
  
          public static boolean isWhitespace(int c) {
              return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
          }
  
          private String readLine0() {
              StringBuilder buf = new StringBuilder();
              int c = read();
              while (c != '\n' && c != -1) {
                  if (c != '\r') {
                      buf.appendCodePoint(c);
                  }
                  c = read();
              }
              return buf.toString();
          }
  
          public String readLine() {
              String s = readLine0();
              while (s.trim().length() == 0) {
                  s = readLine0();
              }
              return s;
          }
  
          public String readLine(boolean ignoreEmptyLines) {
              if (ignoreEmptyLines) {
                  return readLine();
              } else {
                  return readLine0();
              }
          }
  
          public BigInteger readBigInteger() {
              try {
                  return new BigInteger(nextString());
              } catch (NumberFormatException e) {
                  throw new InputMismatchException();
              }
          }
  
          public char nextCharacter() {
              int c = read();
              while (isSpaceChar(c)) {
                  c = read();
              }
              return (char) c;
          }
  
          public double nextDouble() {
              int c = read();
              while (isSpaceChar(c)) {
                  c = read();
              }
              int sgn = 1;
              if (c == '-') {
                  sgn = -1;
                  c = read();
              }
              double res = 0;
              while (!isSpaceChar(c) && c != '.') {
                  if (c == 'e' || c == 'E') {
                      return res * Math.pow(10, nextInt());
                  }
                  if (c < '0' || c > '9') {
                      throw new InputMismatchException();
                  }
                  res *= 10;
                  res += c - '0';
                  c = read();
              }
              if (c == '.') {
                  c = read();
                  double m = 1;
                  while (!isSpaceChar(c)) {
                      if (c == 'e' || c == 'E') {
                          return res * Math.pow(10, nextInt());
                      }
                      if (c < '0' || c > '9') {
                          throw new InputMismatchException();
                      }
                      m /= 10;
                      res += (c - '0') * m;
                      c = read();
                  }
              }
              return res * sgn;
          }
  
          public boolean isExhausted() {
              int value;
              while (isSpaceChar(value = peek()) && value != -1) {
                  read();
              }
              return value == -1;
          }
  
          public String next() {
              return nextString();
          }
  
          public SpaceCharFilter getFilter() {
              return filter;
          }
  
          public void setFilter(SpaceCharFilter filter) {
              this.filter = filter;
          }
  
          public interface SpaceCharFilter {
              public boolean isSpaceChar(int ch);
          }
  
          public int[] nextIntArray(int n) {
              int[] array = new int[n];
              for (int i = 0; i < n; ++i) array[i] = nextInt();
              return array;
          }
  
          public int[] nextSortedIntArray(int n) {
              int array[] = nextIntArray(n);
              Arrays.sort(array);
              return array;
          }
  
          public int[] nextSumIntArray(int n) {
              int[] array = new int[n];
              array[0] = nextInt();
              for (int i = 1; i < n; ++i) array[i] = array[i - 1] + nextInt();
              return array;
          }
  
          public long[] nextLongArray(int n) {
              long[] array = new long[n];
              for (int i = 0; i < n; ++i) array[i] = nextLong();
              return array;
          }
  
          public long[] nextSumLongArray(int n) {
              long[] array = new long[n];
              array[0] = nextInt();
              for (int i = 1; i < n; ++i) array[i] = array[i - 1] + nextInt();
              return array;
          }
  
          public long[] nextSortedLongArray(int n) {
              long array[] = nextLongArray(n);
              Arrays.sort(array);
              return array;
          }
      }
  
  
  }
  