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: class SegTree:
      def __init__(self, init_val, ide_ele, segfunc):
          self.n = len(init_val)
          self.num = 2**(self.n-1).bit_length()
          self.ide_ele = ide_ele
          self.segfunc = segfunc
          self.seg = [ide_ele]*2*self.num
          # set_val
          for i in range(self.n):
              self.seg[i+self.num] = init_val[i]
          # built
          for i in range(self.num-1, 0, -1):
              self.seg[i] = self.segfunc(self.seg[2*i], self.seg[2*i+1])
  
      def update(self, k, x):
          k += self.num
          self.seg[k] = x
          while k:
              k = k >> 1
              self.seg[k] = self.segfunc(self.seg[2*k], self.seg[2*k+1])
  
      def query(self, l, r):
          if r <= l:
              return self.ide_ele
          l += self.num
          r += self.num
          lres = self.ide_ele
          rres = self.ide_ele
          while l < r:
              if r & 1:
                  r -= 1
                  rres = self.segfunc(self.seg[r], rres)
              if l & 1:
                  lres = self.segfunc(lres, self.seg[l])
                  l += 1
              l = l >> 1
              r = r >> 1
          res = self.segfunc(lres, rres)
          return res
  
      def __str__(self): # for debug
          arr = [self.query(i,i+1) for i in range(self.n)]
          return str(arr)
  
  import sys
  import io, os
  input = sys.stdin.buffer.readline
  #input = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
  
  import heapq
  from collections import Counter
  INF = 10**18
  
  t = int(input())
  for _ in range(t):
      n = int(input())
      A = list(map(int, input().split()))
      ans = 0
      C = Counter(A)
      seg = SegTree(list(range(1, n+1)), -INF, max)
      for a in A:
          if 1 <= a <= n:
              seg.update(a-1, -INF)
      A.sort(reverse=True)
      flag = True
      for a in A:
          if a > n:
              r = (a-1)//2
              b = seg.query(0, min(seg.n, r))
              #print(r, b)
              if b == -INF:
                  flag = False
                  break
              ans += 1
              seg.update(b-1, -INF)
          else:
              if C[a] >=2:
                  r = (a-1)//2
                  b = seg.query(0, min(seg.n, r))
                  if b == -INF:
                      flag = False
                      break
                  C[a] -= 1
                  seg.update(b-1, -INF)
                  ans += 1
              else:
                  continue
      #print(seg)
      if flag:
          print(ans)
      else:
          print(-1)
  