Problem: This problem is actually a subproblem of problem G from the same contest.

There are n candies in a candy box. The type of the i-th candy is a_i (1 ≤ a_i ≤ n).

You have to prepare a gift using some of these candies with the following restriction: the numbers of candies of each type presented in a gift should be all distinct (i. e. for example, a gift having two candies of type 1 and two candies of type 2 is bad). 

It is possible that multiple types of candies are completely absent from the gift. It is also possible that not all candies of some types will be taken to a gift.

Your task is to find out the maximum possible size of the single gift you can prepare using the candies you have.

You have to answer q independent queries.

If you are Python programmer, consider using PyPy instead of Python when you submit your code.

Input

The first line of the input contains one integer q (1 ≤ q ≤ 2 ⋅ 10^5) — the number of queries. Each query is represented by two lines.

The first line of each query contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of candies.

The second line of each query contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ n), where a_i is the type of the i-th candy in the box.

It is guaranteed that the sum of n over all queries does not exceed 2 ⋅ 10^5.

Output

For each query print one integer — the maximum possible size of the single gift you can compose using candies you got in this query with the restriction described in the problem statement.

Example

Input


3
8
1 4 8 4 5 6 3 8
16
2 1 3 3 4 3 4 4 1 3 2 2 2 4 1 1
9
2 2 4 4 4 7 7 7 7


Output


3
10
9

Note

In the first query, you can prepare a gift with two candies of type 8 and one candy of type 5, totalling to 3 candies.

Note that this is not the only possible solution — taking two candies of type 4 and one candy of type 6 is also valid.

Solution (in JAVA):

Solution:
import java.io.*;
import java.util.*;
import java.math.*;

public class Competitive_1 {
	
	public static void main(String[] args){
		FastReader in = new FastReader();
		StringBuffer print = new StringBuffer();
		int q = in.nextInt();
		
		while(q-->0) {
			int n = in.nextInt();
			int count[] = new int[n+1];
			
			for(int i=0; i<n; i++) {
				int a = in.nextInt();
				count[a]++;
			}
			
			int ans = 0, lst = Integer.MAX_VALUE;
			
			sort(count);
			
			for(int i=n; i>=0; i--) {
				lst = Math.min(lst, count[i]);
				ans += lst;
				lst--;
				
				if(lst <= 0)
					break;
			}
			
			print.append(ans + "\n");
		}
		
		System.out.println(print);
		
	}
	
	public static void sort(int A[]){
		sort(A, 0, A.length-1);
	}
	
	public static void sort(int A[], int start, int end){
		if(start<end){
			int mid = start + (end - start)/2;
			sort(A, start, mid);
			sort(A, mid+1, end);
			
			merge(A, start, mid, end);
		}
	}
	
	private static void merge(int A[], int start, int mid, int end){
		int merged[] = new int[end-start+1];
		int k=0, point_1 = start, point_2 = mid+1;
		
		for(int i=start; i<=end; i++){
			if(point_1>mid)
				merged[k++] = A[point_2++];
			else if(point_2>end)
				merged[k++] = A[point_1++];
			else if(A[point_1]<A[point_2])
				merged[k++] = A[point_1++];
			else
				merged[k++] = A[point_2++];
		}
		
		for(int i=0; i<k; i++)
			A[start++] = merged[i];
	}
	
	
	
	
	
	
	
	
	
	
	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;
        }
    }
	
	
}