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
import java.io.*;
import java.util.*;
import static java.lang.System.*;
import static java.lang.Math.*;
import static java.util.Collections.*;
import static java.util.Arrays.*;
public class A {
    public static int swap(int... args) {
        return args[0];
    } static   ArrayList<Integer> primes = new ArrayList<>();
    //static Scanner sc = new Scanner(System.in);
    static FastReader sc = new FastReader();
    public static void main(String[] args) throws IOException {
        do {
            startTime = currentTimeMillis();
            //setOut(new PrintStream("output"));
            //setIn(new FileInputStream("input"));
            int T = sc.nextInt();while (T-- != 0)
            {
                solve();

            }
            endTime = currentTimeMillis();
            long duration = endTime - startTime;
            //out.println(duration);
            if (false) {
                out.println(max(3, 2));
                Integer[] ARRAY = new Integer[2];
                ArrayList<Integer> LIST = new ArrayList<>();
                LIST.add(2);
                // sort(LIST, reverseOrder());
                LIST.sort(reverseOrder());
                sort(ARRAY, reverseOrder());
                out.println(LIST + " " + Arrays.toString(ARRAY));
            }
        } while (LOCAL);
    }
    public static void solve() throws IOException {
/////////////////////////////////////////////////////////////////////
            TreeSet<Pair> set = new TreeSet<>();
            ArrayList<Pair> list = new ArrayList<>();
            int n =sc.nextInt();
        for (int i = 0; i < n; i++) {
            set.add(new Pair(sc.nextInt(),i+1));
        }
        while (set.size()>1){
           Pair p1 = set.first();
           set.remove(p1);
           Pair p2 = set.first();
           set.remove(p2);
           if(p1.value>0 && p2.value>0){
               list.add(new Pair(p1.key, p2.key));
           }
           p1.value--;
           p2.value--;
           if(p1.value>0){
               set.add(p1);
           }
           if(p2.value>0){
               set.add(p2);
           }

        }
        out.println(list.size());
        for (int i = 0; i < list.size(); i++) {
            out.println(list.get(i).value + " " + list.get(i).key);
        }
///////////////////////////////////////////////////////////////////////

    }
    public static final boolean LOCAL = System.getProperty("ONLINE_JUDGE")==null;
    // public static final boolean LOCAL = System.getProperty("LOCAL")!=null;
    public static final String ANSI_RED = "\u001B[31m";
    public static final String ANSI_RESET = "\u001B[0m";
    static long startTime;
    static long endTime;
    static boolean[] prime;
    static final int M = (int) 1e9 + 7;
    static final long MM = (long) M * M;
    static final int MAX = Integer.MAX_VALUE;
    static final int MIN = Integer.MIN_VALUE;
    static final int SIZE = (int) 1e9 * 2;
    static int [] visited;
    static ArrayList<ArrayList<Integer>> graph;
    static ArrayList<Integer> topologicalSort;
    static  boolean isCyclic = false;
    static void dfs(int src){
        visited[src] = 1;
        for(Integer integer : graph.get(src) ){
            if(visited[integer]!=1){
                dfs(integer);
            }
        }
        topologicalSort.add(src);

    }
    static void detectCycle(int src){
        visited[src] =2;
        for(Integer integer : graph.get(src)){
            if(visited[integer]==0){
                detectCycle(integer);
            }
            else if(visited[integer]==2) {
                isCyclic = true;
                return;
            }

        }
        visited[src] = 1;
    }
    static class FastReader {
        BufferedReader br;
        StringTokenizer st;
        public FastReader() {
            br = new BufferedReader(new
                    InputStreamReader(System.in));
        }
        String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }
        int nextInt() {
            return Integer.parseInt(next());
        }
        long nextLong() {
            return Long.parseLong(next());
        }
        double nextDouble() {
            return Double.parseDouble(next());
        }
        String nextLine() {
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }
    }
    static class Pair implements Comparable< Pair> {
        private int key;
        private int value;
        public Pair(int value, int key) {
            this.key = key;
            this.value = value;
        }
        public int second() {
            return value;
        }
        @Override
        public int compareTo(Pair o) {
            int ke = -Integer.compare(key,  o.key);
            if(ke==0){
                return -Integer.compare(value, o.value);
            }
            return ke;
        }
        @Override
        public String toString() {
            return "Pair{" + "x=" + key + ", y=" + value + '}';
        }
    }
    static <Array, Target> int count(Array[] array, Target target){
        int cn=0;
        for (Array value : array) {
            if (value.equals(target)) cn++;
        }
        return cn;
    }
    static int count (String string , char target){
        int cn=0;
        for (int i = 0; i < string.length(); i++) {
            if(string.charAt(i)==target)cn++;
        }
        return cn;
    }
    static  <Array> void revArray(Array [] arr) {
        int n = arr.length;
        for (int i = 0; i < n / 2; i++) {
            Array temp = arr[i];
            arr[i] = arr[n - i - 1];
            arr[n - i - 1] = temp;
        }

    }
    static <Array> void printArray(Array [] arr) {
        int n = arr.length;
        for (Array array : arr)out.print(array + " ");
        out.println();
    }
    static void yes() {out.println("YES");}
    static void no() {out.println("NO");}
    public static boolean isPal(String s)
    {
        StringBuilder stringBuilder = new StringBuilder(s);
        return s.equals(stringBuilder.reverse().toString());
    }
    public static int lowerBound(Integer[] array, int length, int value) {
        int low = -1;
        int hi = length;
        while (low + 1 < hi) {
            int mid = (low + hi) / 2;
            if (array[mid] <= value) {
                low = mid;
            } else {
                hi = mid;
            }
        }
        return low;
    }
    public static int upperBound(Integer[] array, int length, int value) {
        int low = -1;
        int hi = length;
        while (low + 1 < hi) {
            int mid = (low + hi) >> 1;
            if (array[mid] >= value) {
                hi = mid;
            } else low = mid;
        }
        return hi;
    }
    public static int binarySearch(Integer[] arr, int length, int value) {
        int low = 0;
        int hi = length - 1;
        int ans = -1;
        while (low <= hi) {
            int mid = (low + hi) >> 1;
            if (arr[mid] > value) {
                hi = mid - 1;
            } else if (arr[mid] < value) {
                low = mid + 1;
            } else {
                ans = mid;
                break;
            }
        }
        return ans;
    }
    public static int gcd(int a, int b) {
        return b==0?a:gcd(b, a % b);
    }
    public static int lcm(int a, int b) {
        return a / gcd(a, b) * b;
    }
    public static int countDivs(int n) {
        int cn = 0;
        int sqr = (int) Math.sqrt(n);
        for (int i = 1; i <= sqr; ++i) {
            if (n % i == 0) {
                ++cn;
            }
        }
        cn *= 2;
        if (sqr * sqr == n) cn--;
        return cn;
    }

    static void prime(int x) {
        //sieve algorithm. nlog(log(n)).
        prime = new boolean[(x + 1)];
        Arrays.fill(prime, true);
        prime[0] = prime[1] = false;
        for (int i = 2; i * i <= x; i++)
            if (prime[i])
                for (int j = i * i; j <= x; j += i)
                    prime[j] = false;
    }
    static boolean isEven(long x) {
        return x % 2 == 0;
    }
    static boolean isPrime(long x) {
        boolean flag = true;
        int sqr = (int) Math.sqrt(x);
        if (x < 2) return false;
        for (int i = 2; i <= sqr; i++) {
            if (x % i == 0) {
                flag = false;
                break;
            }
        }
        return flag;
    }

    static long factorial(long x) {
        long total = 1;
        for (int i = 2; i <= x; i++)
            total = (total * i) % M;
        return total;
    }

    static long power(long x, long n) {
        if (n == 0) {
            return 1;
        }
        long pow = power(x, n / 2L);
        if ((n & 1) == 1) {
            return (x * (pow) * (pow));
        }
        return (pow * pow);
    }
    private static <T> String ts(T t) {
        if(t==null) {
            return "null";
        }
        try {
            return ts((Iterable) t);
        }catch(ClassCastException e) {
            if(t instanceof int[]) {
                String s = Arrays.toString((int[]) t);
                return "{"+s.substring(1, s.length()-1)+"}";
            }else if(t instanceof long[]) {
                String s = Arrays.toString((long[]) t);
                return "{"+s.substring(1, s.length()-1)+"}";
            }else if(t instanceof char[]) {
                String s = Arrays.toString((char[]) t);
                return "{"+s.substring(1, s.length()-1)+"}";
            }else if(t instanceof double[]) {
                String s = Arrays.toString((double[]) t);
                return "{"+s.substring(1, s.length()-1)+"}";
            }else if(t instanceof boolean[]) {
                String s = Arrays.toString((boolean[]) t);
                return "{"+s.substring(1, s.length()-1)+"}";
            }
            try {
                return ts((Object[]) t);
            }catch(ClassCastException e1) {
                return t.toString();
            }
        }
    }
    private static <T> String ts(T[] arr) {
        StringBuilder ret = new StringBuilder();
        ret.append("{");
        boolean first = true;
        for(T t: arr) {
            if(!first) {
                ret.append(", ");
            }
            first = false;
            ret.append(ts(t));
        }
        ret.append("}");
        return ret.toString();
    }
    private static <T> String ts(Iterable<T> iter) {
        StringBuilder ret = new StringBuilder();
        ret.append("{");
        boolean first = true;
        for(T t: iter) {
            if(!first) {
                ret.append(", ");
            }
            first = false;
            ret.append(ts(t));
        }
        ret.append("}");
        return ret.toString();
    }
    public static void dbg(Object... o) {
        if(LOCAL) {
            System.err.print("Line #"+Thread.currentThread().getStackTrace()[2].getLineNumber()+": [");
            for(int i = 0; i<o.length; i++) {
                if(i!=0) {
                    System.err.print(", ");
                }
                System.err.print(ts(o[i]));
            }
            System.err.println("]");
        }
    }

}
