Tired of boring office work, Denis decided to open a fast food restaurant.

On the first day he made a portions of dumplings, b portions of cranberry juice and c pancakes with condensed milk.

The peculiarity of Denis's restaurant is the procedure of ordering food. For each visitor Denis himself chooses a set of dishes that this visitor will receive. When doing so, Denis is guided by the following rules:

  * every visitor should receive at least one dish (dumplings, cranberry juice, pancakes with condensed milk are all considered to be dishes); 
  * each visitor should receive no more than one portion of dumplings, no more than one portion of cranberry juice and no more than one pancake with condensed milk; 
  * all visitors should receive different sets of dishes. 



What is the maximum number of visitors Denis can feed?

Input

The first line contains an integer t (1 ≤ t ≤ 500) — the number of test cases to solve.

Each of the remaining t lines contains integers a, b and c (0 ≤ a, b, c ≤ 10) — the number of portions of dumplings, the number of portions of cranberry juice and the number of condensed milk pancakes Denis made.

Output

For each test case print a single integer — the maximum number of visitors Denis can feed.

Example

Input

7
1 2 1
0 0 0
9 1 7
2 2 3
2 3 2
3 2 2
4 4 4


Output

3
0
4
5
5
5
7

Note

In the first test case of the example, Denis can feed the first visitor with dumplings, give the second a portion of cranberry juice, and give the third visitor a portion of cranberry juice and a pancake with a condensed milk.

In the second test case of the example, the restaurant Denis is not very promising: he can serve no customers.

In the third test case of the example, Denise can serve four visitors. The first guest will receive a full lunch of dumplings, a portion of cranberry juice and a pancake with condensed milk. The second visitor will get only dumplings. The third guest will receive a pancake with condensed milk, and the fourth guest will receive a pancake and a portion of dumplings. Please note that Denis hasn't used all of the prepared products, but is unable to serve more visitors.
import java.io.*;
import java.math.BigInteger;
import java.util.*;
import java.lang.*;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.stream.Stream;

public class Contest {
	//static ArrayList<Integer> prime=new ArrayList();
	
	   public static TreeMap<Long,Integer> t1=new TreeMap();
	    public static void solve()
	    {
	      long m=1;
	      for(int j=2;j<=1000;j++)
	      {
	         
	          if(isprime(j))
	          {
	              m=m*j;
	              if(m>1000000)
	              {
	                  break;
	              }else{
	                  t1.put(m,1);
	              }
	          }
	      }
	    }
	public static long gcd(long n1, long n2)
    {
        if (n2 != 0)
            return gcd(n2, n1 % n2);
        else
            return n1;
    }
	
//////////////////	
	public static class trie {
        int x,y,z;
        trie (int x,int y,int z){
            this.x=x;
            this.y=y;
            this.z=z;
        }
	
	} 
        
	public static class pair {
        int x,y;
        pair (int x,int y){
            this.x=x;
            this.y=y;
        }
        public boolean equals(Object o) {
        	if(o instanceof pair) {
        		pair p = (pair)o;
        		return (x == p.x && y == p.y);
        	}
        	return false;
        }
        public int hashCode() {
        	return (Integer.hashCode(x) * 3 + Integer.hashCode(y) );
        }
    }
	
//////////////////	
	
	static class Cmp implements Comparator<pair>
	{
		public int compare(pair a,pair b)
		{
			if(a.x==b.x)
			{
				return(a.y-b.y);
			}
			return(a.x-b.x);
		}
	}
	
	
//////////////////
	
	
	
	
//////////////////
	
	
	
	
	
	   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; 
	        } 
	   }
	   
////////////////////// 
	//public static ArrayList<Integer> a=new ArrayList();
	   
	  public static ArrayList<Integer> Divisors(int n) 
	   { 
	       // Note that this loop runs till square root 
		  ArrayList<Integer> a=new ArrayList();
		   long sum=0;
	       for (int i=1; i*i<=(n); i++) 
	       { 
	           if (n%i == 0) 
	           { 
	               // If divisors are equal, print only one 
	               if (n/i == i) 
	               {
	                  // printf("%d ", i); 
	            	   sum=sum+1;
	            	   a.add(i);
	               }
	     
	               else // Otherwise print both 
	               {
	                   //printf("%d %d ", i, n/i); 
	            	   sum=sum+2;
	            	   a.add(i);
	            	   a.add(n/i);
	               }
	           } 
	       } 
	       return(a);
	   } 
	   
/////////////////////	  
	  
	  public static long SmallestPrimeDivisor(long n) 
	  { 
	      // if divisible by 2 
	      if (n % 2 == 0) 
	          return 2; 
	    
	      // iterate from 3 to sqrt(n) 
	      for (long i = 3; i * i <= n; i += 2) { 
	          if (n % i == 0) 
	              return i; 
	      } 
	    
	      return n; 
	  } 
	    
////////////////////	  
	   
	   public static boolean isprime(long n)
	    {
	        int count=0;
	     
	        for(long i=2;i*i<=n;i++)
	        {
	            if(n%i==0)
	            {
	                return(false);
	            }
	        }
	        return(true);
	    }
	
	   
//////////////////////
	   
	     //   (x^n)%1000000007
	   public static long modularExponentiation(long x,long n,long M)
	   {
	       if(n==0)
	           return 1;
	       else if(n%2 == 0)        //n is even
	           return modularExponentiation((x*x)%M,n/2,M);
	       else                             //n is odd
	           return (x*modularExponentiation((x*x)%M,(n-1)/2,M))%M;

	   }
	   
	   public static long nCr(int n,int k)
	   {
		  if(k==0)
			  return 1;
		  return(n*nCr(n-1,k-1)/k);
	   }
	   public static long factorial(int n)
	   {
		   if(n==1)
			   return 1;
		   return((n)*factorial(n-1));
	   }
	   
	   public static void debug(Object...o) {
		    System.out.println( Arrays.deepToString(o) );
	   }
	   
	   public static boolean prime[]=new boolean[100005];
	   //prime[j]==false means it's a prime.
	   public static void seive()
	   {
		   prime[0]=false;
		   prime[1]=false;
		   for(int i=2;i*i<=100005;i++)
		   {
			   if(!prime[i])
			   {
				   for(int j=i*i;i<=100005;j+=i)
				   {
					   prime[j]=true;
				   }
			   }
		   }
	   }
	    public static long AtMost(int k,char c[])
	    {
	    	long ans=0;
	    	int left=0,right=0;
	    	int n=c.length;
	    	HashMap<Character,Integer> h=new HashMap();
	    	h.put('1',0);
	    	while(right<n)
	    	{
	    		h.put(c[right],h.getOrDefault(c[right],0)+1);
	    		while(h.get('1')>k)
	    		{
	    			h.replace(c[left],h.get(c[left])-1);
	    			left++;
	    		}
	    		ans=ans+(right-left+1);
	    		right++;
	    	}
	    	return ans;
	    }
	 
	 
	    public static boolean equals(StringBuilder sb1, StringBuilder sb2){
	        
	        /*
	         * If both refer to the same object, they are equal
	         */
	        if(sb1 == sb2)
	            return true;
	 
	        /*
	         * If any of them is null, then they are not equal.
	         * We know both are not null at this point because of the previous
	         * condition which checks equality.
	         */
	        if(sb1 == null || sb2 == null)
	            return false;
	        
	        boolean isEqual = true;
	        
	        /*
	         * If both are not same length, they are not equal
	         */
	        if(sb1.length() == sb2.length()){
	            
	            /*
	             * Now, compare the characters one by one, and break the loop
	             * as soon as the characters at given position are different.
	             */
	            for(int i = 0 ; i < sb1.length(); i++){
	                
	                if(sb1.charAt(i) != sb2.charAt(i)){
	                    isEqual = false;
	                    break;
	                }
	            }
	            
	        }else{
	            isEqual = false;
	        }
	        
	        return isEqual;
	    }
	
	   
	   
	   
	   

		public static void main(String []args) throws Exception
		{
			
			
			 FastReader in =new FastReader();	
			 PrintWriter pw = new PrintWriter(System.out);
		    //Scanner sc=new Scanner(System.in)
			// int x=in.nextInt();
			//String a[]=in.nextLine().split(" ");
			//String b=in.nextLine();
			// StringBuilder s1=new StringBuilder(in.nextLine());
			// StringBuilder s2=new StringBuilder(in.nextLine());
			 int t=in.nextInt();
			 for(int i=0;i<t;i++)
			 {
				 int count=0;
				 int a[]=new int[3];
				 /*
				 int a=in.nextInt();
				 int b=in.nextInt();
				 int c=in.nextInt();
				 */
				 a[0]=in.nextInt();
				 a[1]=in.nextInt();
				 a[2]=in.nextInt();
				 Arrays.sort(a);
                 if(a[0]>0)
                 {
                	 a[0]--;
                	 count++;
                 }
                 if(a[1]>0)
                 {
                	 a[1]--;
                	 count++;
                 }
                 if(a[2]>0)
                 {
                	 a[2]--;
                	 count++;
                 }
				 Arrays.sort(a);
				 if(a[0]>0 && a[2]>0)
				 {
					 count++;
					 a[0]--;
					 a[2]--;
				 }
				 if(a[1]>0 && a[2]>0)
				 {
					 count++;
					 a[1]--;
					 a[2]--;
				 }
				 if(a[0]>0 && a[1]>0)
				 {
					 count++;
					 a[0]--;
					 a[1]--;
				 }
				 if(a[0]>0 && a[1]>0 && a[2]>0)
				 {
					 count++;
					 a[0]--;
					 a[1]--;
					 a[2]--;
				 }
				 /*
				 if(a>0)
				 {
					 count++;
					 a--;
				 }
				 if(b>0)
				 {
					 count++;
					 b--;
				 }
				 if(c>0)
				 {
					 count++;
					 c--;
				 }
				 int min=Math.min(a,Math.min(b, c));
				 int max=Math.max(a,Math.max(b, c));
				 int one=0;
				 int two=0;
				 if(a==1)
				 {
					 one++;
				 }
				 if(a==2)
				 {
					 two++;
				 }
				 if(b==1)
				 {
					 one++;
				 }
				 if(b==2)
				 {
					 two++;
				 }
				 if(c==1)
				 {
					 one++;
				 }
				 if(c==2)
				 {
					 two++;
				 }
				 if(one==2 && two==1)
				 {
					 count=count+2;
				 }
				 else
				 {
				 if(a>0 && b>0)
				 {
					 count++;
					 a--;
					 b--;
				 }
				 if(a>0 && c>0)
				 {
					 count++;
					 a--;
					 c--;
				 }
				 if(c>0 && b>0)
				 {
					 count++;
					 c--;
					 b--;
				 }
				 if(c>0 && b>0 && a>0)
				 {
					 count++;
					 c--;
					 b--;
					 a--;
				 }
				 }
				 
				 
				 */
				 pw.println(count);
			 }
			
			 
		   	pw.flush();
			pw.close();
		   			
		}
			
	}	
		
		
		
		
		
		
		
		
		
		
	

