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: # cook your dish here
  import sys
  import bisect
  from bisect import bisect_left as lb
  from bisect import bisect_right as rb
  input_=lambda: sys.stdin.readline().strip("\r\n")
  from math import log
  from math import gcd
  from math import atan2,acos
  from random import randint
  sa=lambda :input_()
  sb=lambda:int(input_())
  sc=lambda:input_().split()
  sd=lambda:list(map(int,input_().split()))
  sflo=lambda:list(map(float,input_().split()))
  se=lambda:float(input_())
  sf=lambda:list(input_())
  flsh=lambda: sys.stdout.flush()
  sys.setrecursionlimit(3*10**5)
  mod=10**9+7
  mod1=998244353
  gp=[]
  cost=[]
  dp=[]
  mx=[]
  ans1=[]
  ans2=[]
  special=[]
  specnode=[]
  a=0
  kthpar=[]
  def dfs2(root,par):
      if par!=-1:
          dp[root]=dp[par]+1
      for i in range(1,20):
          if kthpar[root][i-1]!=-1:
              kthpar[root][i]=kthpar[kthpar[root][i-1]][i-1]
      for child in gp[root]:
          if child==par:continue
          kthpar[child][0]=root
          dfs(child,root)
          
  ans=0
  a=[]
  n,k=0,0
  b=[]
  vis=[]
  tot=0
  time=[]
  time1=[]
  adj=[]
  mx=-1
  eps=0.0000001
  x=0
  pref=[]
  lvl=[]
  gp=[]
  ans=[]
  f=0
  w=[]
  
  def dfs(i,prod,rem,n):
      if rem==0:
          while(i<len(n)):
              prod*=int(n[i])
              i+=1
          return prod
      if i==len(n):
          return prod
      mx=0
      for j in range(9-int(n[i])):
          mx=max(dfs(i+1,(int(n[i])+min(j,rem))*prod,rem-min(j,rem),n),mx)
      return mx
  def hnbhai(tc):
      n=sb()
      a=sd()
      are=[]
      last=1
      a.sort()
      hogaya=[0]*(n+2)
      ans=0
      for i in a:
          if i>=1 and i<=n and hogaya[i]==0:
              hogaya[i]=1
              ans-=1
      d={}
      mark={}
      #print(hogaya)
      for i in a:
          d[i]=d.get(i,0)+1
          if mark.get(i)is None:
              d[i]-=hogaya[min(n+1,i)]
              mark[i]=1
      are=list(d.keys())
      are.sort()
      #print(are)
      last=1
      tot=0
      rem=0
      mn=[0]*(n+1)
      for i in range(len(are)-1,-1,-1):
          kaha=are[i]//2
          if are[i]%2==1:kaha+=0
          else:kaha-=1
          mn[i]=max(kaha,mn[i+1])
      t=0
      #print(d)
      for i in are:
          t+=1
          while(last<=n and hogaya[last]):
              last+=1
          ok=i if i>=1 and i<=n else -1
          kaha=i//2
          #print(i,last)
          if i%2==1:kaha+=0
          else:kaha-=1
          #print(i,d[i])
          while(last<=n and last<=kaha) and d[i]>0:
              if hogaya[last]:
                  last+=1
                  continue
              rem-=1
              d[i]-=1
              #print(last)
              last+=1
              tot+=1
          if d[i]>0:
              print("-1")
              return
      #print(d)
      while(last<=n and hogaya[last]==1):last+=1
      if last<n+1:
          print(-1)
          return
      #print(last,d)
      print(tot)
      return
  for _ in range(sb()):
      hnbhai(_+1)
  ##case
  
  #.
  