description: 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.
solution: //package com.codeforces.Practise;
  
  import java.io.*;
  import java.util.*;
  
  public class permutation01 {
  
      // you can solve one problem by many approaches.
      // Everything is easy. you feel its hard because of you don't know, and you not understand it very well.
      ////     How to Improve Your problem-solving skill ??( By practise ). ***simple
      /// ==>> Solve problems slightly above of your level (to know some logic and how to approach cp problems)
      //       Otherwise You will stay as it is okk.
      /////////////////////////////////////////////////////////////////////////
      ///      How to Solve Problem in CP ? ( if you feel problem is hard then your approach is wrong )
      // ==>> Step01 :- Understanding problem statement clearly. Then Only Move Forward (Because Everything is mentioned in problem statement).
      //      Step02 :- Think a lot about Solution. if you are confident that your solution might be correct Then only Move Forward
      //      Step03 :- First think of brute force then move to optimal approach
      //      Step04 :- Finally Code ( there is no any sense to code. if you not follow about steps okk)
      ///////////////////////////////////////////////////////////////////////////
      public static void solve(int arr[],int n, BufferedWriter bw) throws IOException{
          TreeSet<Integer> set=new TreeSet<>();
          for (int i = 1; i <= n ; i++) {
              set.add(i);
          }
          for (int i = 0; i < n; i++) {
              if(set.contains(arr[i])){
                  set.remove(arr[i]);
                  arr[i]=-1;
              }
          }
          int ans=0;
          boolean flag=false;
          for (int i = 0; i < n; i++) {
              if(arr[i]!=-1){
                  int val=(arr[i]-1)/2;
                  if(set.floor(val) != null){
                     ans++;
                     set.remove(set.floor(val));
                  }
                  else {
                      flag=true;
                      break;
                  }
              }
          }
          if(flag){
              bw.write("-1");
          }
          else {
              bw.write(ans+"");
          }
          bw.newLine();
      }
      public static void main(String[] args)throws IOException {
          Reader scan=new  Reader();
          BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
          int t=scan.nextInt();
          while (t-->0) {
              int n=scan.nextInt();
              int[] arr=fillArray(n,scan);
              solve(arr,n,bw);
          }
          bw.flush();
      }
      private static int[] fillArray(int n, Reader scan)
      {
          int[] arr=new int[n];
          for (int i = 0; i < n; i++) {
              arr[i]=scan.nextInt();
          }
          return arr;
      }
  
      //FAST READER
      static class Reader {
          public int BS = 1<<16;
          public char NC = (char)0;
          byte[] buf = new byte[BS];
          int bId = 0, size = 0;
          char c = NC;
          double num = 1;
          BufferedInputStream in;
  
          public Reader() {
              in = new BufferedInputStream(System.in, BS);
          }
  
          public Reader(String s) throws FileNotFoundException {
              in = new BufferedInputStream(new FileInputStream(new File(s)), BS);
          }
  
          public char nextChar(){
              while(bId==size) {
                  try {
                      size = in.read(buf);
                  }catch(Exception e) {
                      return NC;
                  }
                  if(size==-1)return NC;
                  bId=0;
              }
              return (char)buf[bId++];
          }
  
          public int nextInt() {
              return (int)nextLong();
          }
  
          public long nextLong() {
              num=1;
              boolean neg = false;
              if(c==NC)c=nextChar();
              for(;(c<'0' || c>'9'); c = nextChar()) {
                  if(c=='-')neg=true;
              }
              long res = 0;
              for(; c>='0' && c <='9'; c=nextChar()) {
                  res = (res<<3)+(res<<1)+c-'0';
                  num*=10;
              }
              return neg?-res:res;
          }
  
          public double nextDouble() {
              double cur = nextLong();
              return c!='.' ? cur:cur+(cur < 0 ? -1*nextLong()/num : nextLong()/num);
          }
  
          public String next() {
              StringBuilder res = new StringBuilder();
              while(c<=32)c=nextChar();
              while(c>32) {
                  res.append(c);
                  c=nextChar();
              }
              return res.toString();
          }
      }
  }
  