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: #     __  __                __    _ __      ______                
  #    / / / /___ ___________/ /_  (_) /_    / ____/___ __________ _
  #   / /_/ / __ `/ ___/ ___/ __ \/ / __/   / / __/ __ `/ ___/ __ `/
  #  / __  / /_/ / /  (__  ) / / / / /_    / /_/ / /_/ / /  / /_/ / 
  # /_/ /_/\__,_/_/  /____/_/ /_/_/\__/____\____/\__,_/_/   \__, /  
  #                                  /_____/               /____/   
  
  from collections import Counter
  from sys import *
  from collections import defaultdict as dd
  from math import *
  
  # sys.stdin = open('input.txt', 'r')  
  # sys.stdout = open('output.txt', 'w')
  
  #input functions
  def inp():
      return int(stdin.readline().strip())
  def vinp():
      return map(int,stdin.readline().strip().split())
  def linp():
      return list(map(int,stdin.readline().strip().split()))
  def sinp(n = 1):
      if n==1:
          return stdin.readline().strip()
      elif n==2:
          return list(stdin.readline().strip())
      else:
          return list(stdin.readline().split())
  
  #output function
  def pr(*x, end = "\n"):
      print(*x,end = end)
  
  #others
  def mod(f, val = 1000000007):
      return f % val
  def csort(c):
      sorted(c.items(), key=lambda pair: pair[1], reverse=True)
  def indc(l,n):
      c={}
      for i in range(n):
          c[l[i]]=c.get(l[i],[])+[i+1]
      return c
  
  if __name__ =="__main__":
      cou=inp()
      for _ in range(cou):
          n = inp()
          l = linp()
          c = dd(int)
          l2 = []
          for i in range(n):
              if l[i]>=1 and l[i]<=n and not c[l[i]]:
                  c[l[i]] = 1
              else:
                  l2.append(l[i])
          l2.sort()
          l3 = [0 for i in range(n+1)]
          for i in c.keys():
              l3[i] = 1
          k=0
          p = True
          for i in range(1,n+1):
              if not l3[i]:
                  if i <= (l2[k]//2 - (l2[k]%2==0)):
                      k+=1
                      l3[i]=1
                  else:
                      p = False
                      break
          if p:
              pr(len(l2))
          else:
              pr(-1)