description: Dmitry has an array of n non-negative integers a_1, a_2, ..., a_n.
  
  In one operation, Dmitry can choose any index j (1 ≤ j ≤ n) and increase the value of the element a_j by 1. He can choose the same index j multiple times.
  
  For each i from 0 to n, determine whether Dmitry can make the MEX of the array equal to exactly i. If it is possible, then determine the minimum number of operations to do it.
  
  The MEX of the array is equal to the minimum non-negative integer that is not in the array. For example, the MEX of the array [3, 1, 0] is equal to 2, and the array [3, 3, 1, 4] is equal to 0.
  
  Input
  
  The first line of input data contains a single integer t (1 ≤ t ≤ 10^4) — the number of test cases in the input. 
  
  The descriptions of the test cases follow.
  
  The first line of the description of each test case contains a single integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the length of the array a.
  
  The second line of the description of each test case contains n integers a_1, a_2, ..., a_n (0 ≤ a_i ≤ n) — elements of the array a.
  
  It is guaranteed that the sum of the values n over all test cases in the test does not exceed 2⋅10^5.
  
  Output
  
  For each test case, output n + 1 integer — i-th number is equal to the minimum number of operations for which you can make the array MEX equal to i (0 ≤ i ≤ n), or -1 if this cannot be done.
  
  Example
  
  Input
  
  
  5
  3
  0 1 3
  7
  0 1 2 3 4 3 2
  4
  3 0 0 0
  7
  4 6 2 3 5 0 5
  5
  4 0 1 0 4
  
  
  Output
  
  
  1 1 0 -1 
  1 1 2 2 1 0 2 6 
  3 0 1 4 3 
  1 0 -1 -1 -1 -1 -1 -1 
  2 1 0 2 -1 -1 
  
  Note
  
  In the first set of example inputs, n=3:
  
    * to get MEX=0, it is enough to perform one increment: a_1++; 
    * to get MEX=1, it is enough to perform one increment: a_2++; 
    * MEX=2 for a given array, so there is no need to perform increments; 
    * it is impossible to get MEX=3 by performing increments. 
solution: import java.util.*;
  import java.io.*;
  public class Main {
  		static long mod = 1000000007;
  		static PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));
  		public static void main(String[] args) throws IOException  {
  			FastReader sc = new FastReader();
  			int t = sc.nextInt();
  			while( t-- > 0) {
  				/*
  				 * i will make a count which will store the number that are less than euqual to cur and avail
  				 * if will carray a boolean that will tell if that is true for the previous one
  				 */
  				int n = sc.nextInt();
  				HashMap<Long,Long> hm = new HashMap<>();
  				for( int i = 0 ;i <= n ;i++) {
  					hm.put((long)i, 0L);
  				}
  				for( int i = 0 ;i< n ;i++) {
  					long temp = sc.nextLong();
  					hm.put(temp, hm.get(temp)+1);
  				}
  				boolean x = true;
  				long tem = 0;
  				PriorityQueue<Long> count = new PriorityQueue<>(Collections.reverseOrder());
  				long c= 0;
  				for( int i = 0 ;i <= n ; i++) {
  					if( x) {
  						long temp = hm.get((long)i);
  						out.print((temp+ tem) + " ");
  						if( temp 	== 0) {
  							if( c == 0) {
  								x = false;
  							}
  							else {
  								c--;
  								tem+= (i - count.poll()); 
  							}
  						}
  						else {
  							for( int j = 0 ;j< temp -1 ; j++) {
  								count.add((long)i);
  								c++;
  							}
  						}
  					}
  					else {
  						out.print(-1 + " ");
  					}
  				}
  				out.println();
  			}
  			out.flush();
  		}
  		/*
  		 * WARNING -> DONT EVER USE ARRAYS.SORT() IN ANY WAY.
  		 * FIRST AND VERY IMP -> READ AND UNDERSTAND THE QUESTION VERY CAREFULLY.
  		 * WARNING -> DONT CODE BULLSHIT , ALWAYS CHECK THE LOGIC ON MULTIPLE TESTCASES AND EDGECASES BEFORE. 
  		 * SECOND -> TRY TO FIND RELEVENT PATTERN SMARTLY.
  		 * WARNING -> IF YOU THINK YOUR SOLUION IS JUST DUMB DONT SUBMIT IT BEFORE RECHECKING ON YOUR END.
  		 */
  		public static boolean ifpowof2(long n ) {
  			return ((n&(n-1)) == 0);
  		}
  		
  		static boolean isprime(long x ) {
  			if( x== 2) {
  				return true;
  			}
  			if( x%2 == 0) {
  				return false;
  			}
  			for( long i = 3 ;i*i <= x ;i+=2) {
  				if( x%i == 0) {
  					return false;
  				}	
  			}
  			return true;
  		}
  		
  		static boolean[] sieveOfEratosthenes(long n) { 
  			boolean prime[] = new boolean[(int)n + 1];
  			for (int i = 0; i <= n; i++) {
  				prime[i] = true;
  			}
  			for (long p = 2; p * p <= n; p++) {   
  				if (prime[(int)p] == true) {
  					for (long i = p * p; i <= n; i += p)
  						prime[(int)i] = false;
  				}
  			}		 
  			return prime;
  		}
  		
  		public static int[] nextLargerElement(int[] arr, int n)	{ 
  			Stack<Integer> stack = new Stack<>();
  			int rtrn[] = new int[n];
  			rtrn[n-1] = -1;
  	        stack.push( n-1);
  	        for( int i = n-2 ;i >= 0 ; i--){
  	            int temp = arr[i];
  	            int lol = -1;
  	            while( !stack.isEmpty() && arr[stack.peek()] <= temp){
  	            	if(arr[stack.peek()] == temp ) {
  	            		lol = stack.peek();
  	            	}
  	                stack.pop();
  	            }
  	            if( stack.isEmpty()){
  	            	if( lol != -1) {
  	            		rtrn[i] = lol;
  	            	}
  	            	else {
  	            		rtrn[i] = -1;
  	            	}
  	            }
  	            else{
  	            	rtrn[i] = stack.peek();
  	            }
  	            stack.push( i);
  	        }
  	        return rtrn;
  		}
  		
  		static void mysort(int[] arr) {
  			for(int i=0;i<arr.length;i++) {
  	            int rand = (int) (Math.random() * arr.length);
  	            int loc = arr[rand];
  	            arr[rand] = arr[i];
  	            arr[i] = loc;
  	        }
  	        Arrays.sort(arr);
  	    }
  		
  		
  		static void mySort(long[] arr) {
  	        for(int i=0;i<arr.length;i++) {
  	            int rand = (int) (Math.random() * arr.length);
  	            long loc = arr[rand];
  	            arr[rand] = arr[i];
  	            arr[i] = loc;
  	        }
  	        Arrays.sort(arr);
  	    }
  		
  		static long gcd(long a, long b)
  		{
  			if (a == 0)
  				return b;
  			return gcd(b % a, a);
  		}
  		
  			   
  		 static long lcm(long a, long b)
  		 {
  			 return (a / gcd(a, b)) * b;
  		 }
  		 
  
  		 static long rightmostsetbit(long n) {
  			 return n&-n;
  		 }
  		 
  		 static long leftmostsetbit(long n)
  		    {
  		        long k = (long)(Math.log(n) / Math.log(2));
  		        return 1 << k;
  		    }
  	 
  		 static HashMap<Long,Long> primefactor( long n){
  			 HashMap<Long ,Long> hm = new HashMap<>();
  			 long temp = 0;
  			 while( n%2 == 0) {
  				 temp++;
  				 n/=2;
  			 }	
  			 if( temp!= 0) {
  				 hm.put( 2L, temp);
  			 }
  			 long c = (long)Math.sqrt(n);
  			 for( long i = 3 ; i <= c ; i+=2) {
  				 temp = 0;
  				 while( n% i == 0) {
  					 temp++;
  					 n/=i;
  				 }
  				 if( temp!= 0) {
  					 hm.put( i, temp);
  				 }
  	 		 }
  	 		 if( n!= 1) {
  	 			 hm.put( n , 1L);
  	 		 }
  	 		 return hm;	
  		 }
  		 
  		 
  		 static ArrayList<Integer> allfactors(int abs) {
  			 HashMap<Integer,Integer> hm = new HashMap<>();
  			 ArrayList<Integer> rtrn = new ArrayList<>();
  			 for( int i = 2 ;i*i <= abs; i++) {
  				 if( abs% i == 0) {
  					 hm.put( i , 0);
  					 hm.put(abs/i, 0);
  				 }
  			 }
  			 for( int x : hm.keySet()) {
  				 rtrn.add(x);
  			 }
  			 
  			 if( abs != 0) {
  				 rtrn.add(abs);
  			 }
  			 
  			 return rtrn;
  		 }
  			
  	 
  		 static class FastReader {
  			 BufferedReader br;
  			 StringTokenizer st;
  		 
  			 public FastReader()
  			 {
  				 br = new BufferedReader(new InputStreamReader(System.in));
  			 }
  		        
  			 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;
  			 }
  		 }	
  }
  
  
  