Paprika loves permutations. She has an array a_1, a_2, ..., a_n. She wants to make the array a permutation of integers 1 to n.

In order to achieve this goal, she can perform operations on the array. In each operation she can choose two integers i (1 ≤ i ≤ n) and x (x > 0), then perform a_i := a_i mod x (that is, replace a_i by the remainder of a_i divided by x). In different operations, the chosen i and x can be different.

Determine the minimum number of operations needed to make the array a permutation of integers 1 to n. If it is impossible, output -1.

A permutation is an array consisting of n distinct integers from 1 to n in arbitrary order. For example, [2,3,1,5,4] is a permutation, but [1,2,2] is not a permutation (2 appears twice in the array) and [1,3,4] is also not a permutation (n=3 but there is 4 in the array).

Input

Each test contains multiple test cases. The first line contains a single integer t (1 ≤ t ≤ 10^4) — the number of test cases. Description of the test cases follows.

The first line of each test case contains an integer n (1 ≤ n ≤ 10^5).

The second line of each test case contains n integers a_1, a_2, ..., a_n. (1 ≤ a_i ≤ 10^9).

It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5.

Output

For each test case, output the minimum number of operations needed to make the array a permutation of integers 1 to n, or -1 if it is impossible.

Example

Input


4
2
1 7
3
1 5 4
4
12345678 87654321 20211218 23571113
9
1 2 3 4 18 19 5 6 7


Output


1
-1
4
2

Note

For the first test, the only possible sequence of operations which minimizes the number of operations is: 

  * Choose i=2, x=5. Perform a_2 := a_2 mod 5 = 2. 



For the second test, it is impossible to obtain a permutation of integers from 1 to n.
8
2
2 3
3
3 4 5
1
1
1
2
1
3
1
4
1
12071207
5
5 5 5 9 14

1
2
0
-1
1
1
1
4

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;
import java.util.StringTokenizer;

public class PaprikaAndPermutation {
    public static void main(String[] args) {
        
        FastReader fr = new FastReader();
        
        int ts = fr.nextInt();
        StringBuilder result = new StringBuilder();

        // for (int k = 1; k < 15; k++) {

        //     System.out.println("****");
        //     for (int j = k + 1; j >= 1; j--) {

                // we know each number can have a resultant modulus from 0 to n / 2
                // since from n / 2 to n - 1, the modulus is equal to n - k where k is between n / 2 to n - 1

        //     }

        // }

        for (int t = 0; t < ts; t++) {

            int n = fr.nextInt();
            Long[] arr = fr.nextLineAsLongArray(n);

            result.append(solve(arr) + "\n");

        }

        System.out.println(result.toString());

        // 3
        // 1 5 4

        // 5 -> 2 or 3
        // 5 mod 2 = 2 impossible to make into 3
        // 4 mod 

        // what are the conditions to make something into a remainder

        // remainder = x mod k
        // remainder can take values from 0 to min (k - 1, x)
        // 5 can become 5, 0, 1, 2, 1, 0

        // 4 mod 5 = 4
        // 4 mod 4 = 0
        // 4 mod 3 = 1
        // 4 mod 2 = 0
        // 4 mod 1 = 0

        // 5 mod 6 = 5
        // 5 mod 5 = 0
        // 5 mod 4 = 1
        // 5 mod 3 = 2
        // 5 mod 2 = 1
        // 5 mod 1 = 0

        // 6 mod 7 = 6
        // 6 mod 6 = 0
        // 6 mod 5 = 1
        // 6 mod 4 = 2
        // 6 mod 3 = 0
        // 6 mod 2 = 0
        // 6 mod 1 = 0



        // for each x, see what the maximum value we can make it,
        // set the item to the maximum
        // then, sort
        // see if there are any items s.t. it is less than the index

    }

    static long mod(long a, long b) {
        a = a % b;
        if (a < 0) {
            a += b;
        }
        return a;
    }

    static String solve(Long[] arr) {

        // 4 mod 1 = 0
        // 4 mod 2 = 0
        // 4 mod 3 = 1
        // 4 mod 4 = 0

        // 5 mod 1 = 0
        // 5 mod 2 = 1
        // 5 mod 3 = 2
        
        // 6 mod 1 = 0
        // 6 mod 2 = 0
        // 6 mod 3 = 0
        // 6 mod 4 = 2
        // 6 mod 5 = 1
        // 6 mod 6 = 0

        // if even, then can be between 0 to (n / 2) - 1

        Set<Long> seen = new HashSet<>();
        int count = 0;

        for (int i = 0; i < arr.length; i++) {

            if (seen.contains(arr[i]) || arr[i] > arr.length) {
                if (arr[i] == 2) {
                    return "-1";
                }

                if (arr[i] % 2 == 0) {
                    arr[i] = - ((arr[i] / 2) - 1);
                } else {
                    arr[i] = - (arr[i] / 2);
                }
                count++;
            }

            seen.add(Math.abs(arr[i]));
            
        }

        Arrays.sort(arr, (a, b) -> Long.compare(Math.abs(a), Math.abs(b)));

        for (int i = 0; i < arr.length; i++) {

            if (Math.abs(arr[i]) < i + 1) {
                return "-1";
            }

        }

        return String.valueOf(count);
    }


    /** HELPER */

    static class FastReader {
        BufferedReader br;
        StringTokenizer st;
 
        public FastReader()
        {
            br = new BufferedReader(
                new InputStreamReader(System.in));
        }

        int[] nextLineAsIntArray(int n) {
            int[] result = new int[n];

            for (int i = 0; i < n; i++) {
                result[i] = nextInt();
            }
            return result;
        }

        Long[] nextLineAsLongArray(int n) {
            Long[] result = new Long[n];

            for (int i = 0; i < n; i++) {
                result[i] = nextLong();
            }

            return result;
        }
 
        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;
        }
    }
}
