So the Beautiful Regional Contest (BeRC) has come to an end! n students took part in the contest. The final standings are already known: the participant in the i-th place solved p_i problems. Since the participants are primarily sorted by the number of solved problems, then p_1 ≥ p_2 ≥ ... ≥ p_n.

Help the jury distribute the gold, silver and bronze medals. Let their numbers be g, s and b, respectively. Here is a list of requirements from the rules, which all must be satisfied:

  * for each of the three types of medals, at least one medal must be awarded (that is, g>0, s>0 and b>0); 
  * the number of gold medals must be strictly less than the number of silver and the number of bronze (that is, g<s and g<b, but there are no requirements between s and b); 
  * each gold medalist must solve strictly more problems than any awarded with a silver medal; 
  * each silver medalist must solve strictly more problems than any awarded a bronze medal; 
  * each bronze medalist must solve strictly more problems than any participant not awarded a medal; 
  * the total number of medalists g+s+b should not exceed half of all participants (for example, if n=21, then you can award a maximum of 10 participants, and if n=26, then you can award a maximum of 13 participants). 



The jury wants to reward with medals the total maximal number participants (i.e. to maximize g+s+b) so that all of the items listed above are fulfilled. Help the jury find such a way to award medals.

Input

The first line of the input contains an integer t (1 ≤ t ≤ 10000) — the number of test cases in the input. Then t test cases follow.

The first line of a test case contains an integer n (1 ≤ n ≤ 4⋅10^5) — the number of BeRC participants. The second line of a test case contains integers p_1, p_2, ..., p_n (0 ≤ p_i ≤ 10^6), where p_i is equal to the number of problems solved by the i-th participant from the final standings. The values p_i are sorted in non-increasing order, i.e. p_1 ≥ p_2 ≥ ... ≥ p_n.

The sum of n over all test cases in the input does not exceed 4⋅10^5.

Output

Print t lines, the j-th line should contain the answer to the j-th test case.

The answer consists of three non-negative integers g, s, b.

  * Print g=s=b=0 if there is no way to reward participants with medals so that all requirements from the statement are satisfied at the same time. 
  * Otherwise, print three positive numbers g, s, b — the possible number of gold, silver and bronze medals, respectively. The sum of g+s+b should be the maximum possible. If there are several answers, print any of them. 

Example

Input


5
12
5 4 4 3 2 2 1 1 1 1 1 1
4
4 3 2 1
1
1000000
20
20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1
32
64 64 63 58 58 58 58 58 37 37 37 37 34 34 28 28 28 28 28 28 24 24 19 17 17 17 17 16 16 16 16 11


Output


1 2 3
0 0 0
0 0 0
2 5 3
2 6 6

Note

In the first test case, it is possible to reward 1 gold, 2 silver and 3 bronze medals. In this case, the participant solved 5 tasks will be rewarded with the gold medal, participants solved 4 tasks will be rewarded with silver medals, participants solved 2 or 3 tasks will be rewarded with bronze medals. Participants solved exactly 1 task won't be rewarded. It's easy to see, that in this case, all conditions are satisfied and it is possible to reward participants in this way. It is impossible to give more than 6 medals because the number of medals should not exceed half of the number of participants. The answer 1, 3, 2 is also correct in this test case.

In the second and third test cases, it is impossible to reward medals, because at least one medal of each type should be given, but the number of medals should not exceed half of the number of participants.
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.Writer;
import java.util.Arrays;
import java.util.InputMismatchException;
import java.util.*;
import java.io.*;
import java.math.*;
public class Main6{

static class Pair
    { 
        int x;
		int y;
        public Pair(int x, int y) 
        {     
            this.x=x;
			this.y=y;
        }     
        
    @Override
            public int hashCode() 
            { 
                final int temp = 14; 
                int ans = 1; 
                ans =x*31+y*13; 
                return ans; 
            } 
      
            // Equal objects must produce the same 
            // hash code as long as they are equal 
        @Override
        public boolean equals(Object o) 
        { 
            if (this == o) { 
                return true; 
            } 
            if (o == null) { 
                return false; 
            } 
            if (this.getClass() != o.getClass()) { 
                return false; 
            } 
            Pair other = (Pair)o; 
            if (this.x != other.x || this.y!=other.y) { 
                return false; 
            } 
            return true; 
        } 
            
    } 
static class Pair1{
	int x;
	int y;
	long z;
	Pair1(int x, int y, long z)
	{
		this.x=x;
		this.y=y;
		this.z=z;
	}
}
    
    public static long pow(long a, long b)
    {
        long result=1;
        while(b>0)
        {
            if (b % 2 != 0)
            {
                result=(result*a)%1000000007;
                b--;
            } 
            a=(a*a)%1000000007;
            b /= 2;
        }   
        return result;
    }
    public static long fact(long num)
    {
                long value=1;
                int i=0;
                for(i=2;i<num;i++)
                {
                    value=((value%mod)*i%mod)%mod;
                }
                return value;
            }
            public static long gcd(long a, long b)
            {
                if (a == 0)
                    return b;
                return gcd(b%a, a);
            }
            
            public static long lcm(long a,long b)
            {
                return a * (b / gcd(a, b));
            }
            public static long sum(int h)
            {
                return (h*(h+1)/2);
            }
        /*   public static void dfs(int parent,boolean[] visited,int[] dp)
            {
                ArrayList<Integer> arr=new ArrayList<Integer>();
                arr=graph.get(parent);
                visited[parent]=true;
                for(int i=0;i<arr.size();i++)
                {
                    int num=(int)arr.get(i);
                    if(visited[num]==false)
                    {
                        dfs(num,visited,dp);
                    }
                    dp[parent]=Math.max(dp[num]+1,dp[parent]);
                }
            }
        //    static int flag1=0;
            static int[] dis;*/
            static int mod=1000000007;
            static ArrayList<ArrayList<Integer>> graph;
            static ArrayList<ArrayList<Integer>> g;
            
       /*    public static void bfs(int num,int size)
            {
                boolean[] visited=new boolean[size+1];
                Queue<Integer> q=new LinkedList<>();
                q.add(num);
                ans[num]=1;
                visited[num]=true;
                while(!q.isEmpty())
                {
                    int x=q.poll();
                    ArrayList<Integer> al=graph.get(x);
                    for(int i=0;i<al.size();i++)
                    {
                        int y=al.get(i);    
                        if(visited[y]==false)
                        {
                            q.add(y);
                            ans[y]=ans[x]+1;
                            visited[y]=true;
                        }
                    }
                }
            }
            static int[] ans;*/
            
            
            
            
            
            
            
            
            
        //    static int[] a;              
            public static int[] sort(int[] a)
            {
                int n=a.length;
                ArrayList<Integer> ar=new ArrayList<>();
                for(int i=0;i<a.length;i++)
                {
                    ar.add(a[i]);
                }
                Collections.sort(ar);
                for(int i=0;i<n;i++)
                {
                    a[i]=ar.get(i);
                }
                return a;
            }
	/*		static class pqcomparator implements Comparator<Pair>
			{
				public int compare(Pair p1 ,Pair p2)
				{
					if(p1.y>p2.y)
					{
						return -1;
					}
					else
						return 1;
				}
			}
			
		*/	
	/*	static int[] answer;
		static void calling()
		{
			boolean[] visited=new boolean[n];
			answer=new int[3*n];
			Arrays.fill(answer,-1); // initalize -1 se kr dena for safety..
			int[] arr=new int[3*n];
			dfs(node,visited,arr,node,0); // node and fin ki value same hai matching ke liye
			for(int i=0;i<3*n;i++)
			{
				if(answer[i]!=-1)
				{
					System.out.print(answer[i]+" "); //here cycle print ho rhi hai
				}
			}
		}
		static void dfs(int node,boolean[] visited, int[] arr,int fin,int k)
		{
			if(node==fin && visited[node]==true)
			{
				for(int i=0;i<k;i++)
				{
					answer[i]=arr[i]; // yaha pe value copy ho rhi hai 
				}
				return;
			}
			visited[node]=true;
			for(int i=0;i<n;i++)
			{
				if(graph[node][i]==1)
				{
					arr[k]=i;
					k++;
					dfs(i,visited,arr,fin,k);
					k--;
					arr[k]=0;
				}
			}
		}*/
		
	/*	public static void dfs(int parent,boolean[] visited)
            {
                ArrayList<Integer> arr=new ArrayList<Integer>();
                arr=graph.get(parent);
                visited[parent]=true;
				ar.add(parent);
				count++;
				for(int i=0;i<arr.size();i++)
                {
					int num=(int)arr.get(i);
                    if(visited[num]==false)
                    {
						dfs(num,visited);
                    }
            	 }
            }*/
			static public void main(String args[])throws IOException
            {
				int t=i();
				StringBuilder sb=new StringBuilder();
				while(t-->0)
				{
					int n=i();
					int[] a=new int[n];
					for(int i=0;i<n;i++)
					{
						a[i]=i();
					}
					ArrayList<Integer> ans=new ArrayList<>();
					ans.add(0);
					ans.add(0);
					ans.add(0);
					HashMap<Integer,Integer> hash=new HashMap<>();
					ArrayList<Integer> ar=new ArrayList<>();
					int count1=0;
					int j=0;
					for(int i=0;i<n/2;i++)
					{
						if(hash.containsKey(a[i]))
							hash.put(a[i],hash.get(a[i])+1);
						else
						{
							ar.add(a[i]);
							hash.put(a[i],1);
						}
						if(hash.size()>=3)
						{
							if(i+1<n)
							{
								if(a[i]!=a[i+1] && count1==0)
								{
									int rem=(i+1)-hash.get(a[0]);
									j=1;
									int count=0;
									int flag=0;
									while(j<ar.size())
									{
										count+=hash.get(ar.get(j));
										j++;
										if(count>hash.get(a[0]) && (rem-count)>hash.get(a[0]))
										{
											ans.clear();
											ans.add(hash.get(a[0]));
											ans.add(count);
											ans.add(rem-count);
											flag=1;
											count1++;
											break;
										}
									}
								}
								else if(a[i]!=a[i+1] && count1!=0)
								{
									int first=ans.get(0);
									int second=ans.get(1);
									int third=ans.get(2);
									third=third+hash.get(a[i]);
									ans.clear();
									ans.add(first);
									ans.add(second);
									ans.add(third);
								}
							}
						}
					}
					sb.append(ans.get(0)+" "+ans.get(1)+" "+ans.get(2)+"\n");
					
				}
				System.out.print(sb.toString());
			}  
			static ArrayList<Integer> check(int mid,int[] a,int n)
			{
				HashMap<Integer,Integer> hash=new HashMap<>();
				for(int i=0;i<mid;i++)
				{
					if(hash.containsKey(a[i]))
						hash.put(a[i],hash.get(a[i])+1);
					else
						hash.put(a[i],1);
				}
				ArrayList<Integer> ans=new ArrayList<>();
				if(hash.size()<3)
				{
					ans.add(-1);
					return ans;
				}
				else
				{
					ans.add(hash.get(a[0]));
					ans.add(mid-hash.get(a[0])-hash.get(a[mid]));
					ans.add(hash.get(a[mid]));
					return ans;
				}
			}
			
            /**/
            static InputReader in=new InputReader(System.in);
                static OutputWriter out=new OutputWriter(System.out);
                public static long l()
                {
                    String s=in.String();
                    return Long.parseLong(s);
                }
                public static void pln(String value)
                {
                    System.out.println(value);
                }
                public static int i()
                {
                    return in.Int();
                }
                public static String s()
                {
                    return in.String();
                }
    }
         
         
         
         
         
         
         
         
         
         
         
         
         
         
         
         
         
         
         
         
         
        class InputReader {
             
            private InputStream stream;
            private byte[] buf = new byte[1024];
            private int curChar;
            private int numChars;
            private SpaceCharFilter filter;
         
            public InputReader(InputStream stream) {
                this.stream = stream;
            }
         
            public int read() {
                if (numChars== -1)
                    throw new InputMismatchException();
                if (curChar >= numChars) {
                    curChar = 0;
                    try {
                        numChars = stream.read(buf);
                    } catch (IOException e) {
                        throw new InputMismatchException();
                    }
                    if (numChars <= 0)
                        return -1;
                }
                return buf[curChar++];
            }
         
            public int Int() {
                int c = read();
                while (isSpaceChar(c))
                    c = read();
                int sgn = 1;
                if (c == '-') {
                    sgn = -1;
                    c = read();
                }
                int res = 0;
                do {
                    if (c < '0' || c > '9')
                        throw new InputMismatchException();
                    res *= 10;
                    res += c - '0';
                    c = read();
                } while (!isSpaceChar(c));
                return res * sgn;
            }
         
            public String String() {
                int c = read();
                while (isSpaceChar(c))
                    c = read();
                StringBuilder res = new StringBuilder();
                do {
                    res.appendCodePoint(c);
                    c = read();
                } while (!isSpaceChar(c));
                return res.toString();
            }
         
            public boolean isSpaceChar(int c) {
                if (filter != null)
                    return filter.isSpaceChar(c);
                return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
            }
         
            public String next() {
                return String();
            }
         
            public interface SpaceCharFilter {
                public boolean isSpaceChar(int ch);
            }
        }
         
        class OutputWriter {
            private final PrintWriter writer;
         
            public OutputWriter(OutputStream outputStream) {
                writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
            }
         
            public OutputWriter(Writer writer) {
                this.writer = new PrintWriter(writer);
            }
         
            public void print(Object...objects) {
                for (int i = 0; i < objects.length; i++) {
                    if (i != 0)
                        writer.print(' ');
                    writer.print(objects[i]);
                }
            }
         
            public void printLine(Object...objects) {
                print(objects);
                writer.println();
            }
         
            public void close() {
                writer.close();
            }
         
            public void flush() {
                writer.flush();
            }
         
            }
         
            class IOUtils {
         
            public static int[] readIntArray(InputReader in, int size) {
                int[] array = new int[size];
                for (int i = 0; i < size; i++)
                    array[i] = in.Int();
                return array;
            }
         
            } 

