There are three sticks with integer lengths l_1, l_2 and l_3.

You are asked to break exactly one of them into two pieces in such a way that: 

  * both pieces have positive (strictly greater than 0) integer length; 
  * the total length of the pieces is equal to the original length of the stick; 
  * it's possible to construct a rectangle from the resulting four sticks such that each stick is used as exactly one of its sides. 



A square is also considered a rectangle.

Determine if it's possible to do that.

Input

The first line contains a single integer t (1 ≤ t ≤ 10^4) — the number of testcases.

The only line of each testcase contains three integers l_1, l_2, l_3 (1 ≤ l_i ≤ 10^8) — the lengths of the sticks.

Output

For each testcase, print "YES" if it's possible to break one of the sticks into two pieces with positive integer length in such a way that it's possible to construct a rectangle from the resulting four sticks. Otherwise, print "NO".

You may print every letter in any case you want (so, for example, the strings yEs, yes, Yes and YES are all recognized as a positive answer).

Example

Input


4
6 1 5
2 5 2
2 4 2
5 5 4


Output


YES
NO
YES
YES

Note

In the first testcase, the first stick can be broken into parts of length 1 and 5. We can construct a rectangle with opposite sides of length 1 and 5.

In the second testcase, breaking the stick of length 2 can only result in sticks of lengths 1, 1, 2, 5, which can't be made into a rectangle. Breaking the stick of length 5 can produce results 2, 3 or 1, 4 but neither of them can't be put into a rectangle.

In the third testcase, the second stick can be broken into parts of length 2 and 2. The resulting rectangle has opposite sides 2 and 2 (which is a square).

In the fourth testcase, the third stick can be broken into parts of length 2 and 2. The resulting rectangle has opposite sides 2 and 5.
2
1 2 3
2 2 4
 1
1 98 99
 3
1 1 1
2 1 3
5 6 7
 6
2 2 4
1 1 2
3 5 6
1 2 3
6 7 8
10 10 20
 4
6 1 5
2 5 2
2 4 2
7 101 108
 1
100000 100000 100000
 1
12344 1 1
 68
1 1 2
1 1 2
1 1 2
1 1 2
1 1 2
1 1 2
1 1 2
1 1 2
1 1 2
1 1 2
1 1 2
1 1 2
1 1 2
1 1 2
1 1 2
1 1 2
1 1 2
1 1 2
1 1 2
1 1 2
1 1 2
1 1 2
1 1 2
1 1 2
1 1 2
1 1 2
1 1 2
1 1 2
1 1 2
1 1 2
1 1 2
1 1 2
1 1 2
1 1 2
1 1 2
1 1 2
1 1 2
1 1 2
1 1 2
1 1 2
1 1 2
1 1 2
1 1 2
1 1 2
1 1 2
1 1 2
1 1 2
1 1 2
1 1 2
1 1 2
1 1 2
1 1 2
1 1 2
1 1 2
1 1 2
1 1 2
1 1 2
1 1 2
1 1 2
1 1 2
1 1 2
1 1 2
1 1 2
1 1 2
1 1 2
1 1 2
1 1 2
1 1 2
 2
1 2 3
4 5 6

YES
YES
 YES
 NO
YES
NO
 YES
YES
NO
YES
NO
YES
 YES
NO
YES
YES
 YES
 YES
 YES
YES
YES
YES
YES
YES
YES
YES
YES
YES
YES
YES
YES
YES
YES
YES
YES
YES
YES
YES
YES
YES
YES
YES
YES
YES
YES
YES
YES
YES
YES
YES
YES
YES
YES
YES
YES
YES
YES
YES
YES
YES
YES
YES
YES
YES
YES
YES
YES
YES
YES
YES
YES
YES
YES
YES
YES
YES
YES
YES
YES
YES
YES
YES
YES
YES
YES
YES
 YES
NO

//   package faltu;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
//import java.security.KeyStore.Entry;
import java.util.*;
import java.util.Map.Entry;

public class Main {
    static long LowerBound(long[] a2, long x) { // x is the target value or key
	  int l=-1,r=a2.length;
	  while(l+1<r) {
	    int m=(l+r)>>>1;
	    if(a2[m]>=x) r=m;
	    else l=m;
	  }
	  return r;
	}
    static int UpperBound(int a[], int x) {// x is the key or target value
	    int l=-1,r=a.length;
	    while(l+1<r) {
	       int m=(l+r)>>>1;
	       if(a[m]<=x) l=m;
	       else r=m;
	    }
	    return l+1;
    }
    public static long getClosest(long val1, long val2,long target)
	{
		if (target - val1 >= val2 - target)
		return val2;       
		else
		return val1;       
	}
    static void ruffleSort(long[] a) {
		int n=a.length;
		Random r=new Random();
		for (int i=0; i<a.length; i++) {
			long oi=r.nextInt(n), temp=a[i];
			a[i]=a[(int)oi];
			a[(int)oi]=temp;
		}
		Arrays.sort(a);
	}
    static void ruffleSort(int[] a) {
		int n=a.length;
		Random r=new Random();
		for (int i=0; i<a.length; i++) {
			int oi=r.nextInt(n), temp=a[i];
			a[i]=a[oi];
			a[oi]=temp;
		}
		Arrays.sort(a);
	}
    private int ceilIndex(int input[], int T[], int end, int s){
        int start = 0;
        int middle;
        int len = end;
        while(start <= end){
            middle = (start + end)/2;
            if(middle < len && input[T[middle]] < s && s <= input[T[middle+1]]){
                return middle+1;
            }else if(input[T[middle]] < s){
                start = middle+1;
            }else{
                end = middle-1;
            }
        }
        return -1;
    }
    public static int findIndex(long arr[], long t) 
    { 
        if (arr == null) { 
            return -1; 
        } 
        int len = arr.length; 
        int i = 0; 
        while (i < len) {
            if (arr[i] == t) { 
                return i; 
            } 
            else { 
                i = i + 1; 
            } 
        } 
        return -1; 
    }
    static long gcd(long a, long b)
    {
        if (a == 0)
            return b; 
        return gcd(b % a, a); 
    }
    static int gcd(int a, int b)
    {
        if (a == 0)
            return b; 
        return gcd(b % a, a); 
    }
    static long lcm(long a, long b)
    {
        return (a / gcd(a, b)) * b;
    }
 
    public static int[] swap(int a[], int left, int right)
    {
        int temp = a[left];
        a[left] = a[right];
        a[right] = temp;
        return a;
    }
    	public static void swap(int max0,int max1)
    {
    	int temp=max0;
    	max0=max1;
    	max1=temp;
    }
 
    	public static int[] reverse(int a[], int left, int right)
    {
 
        // Reverse the sub-array
        while (left < right) {
            int temp = a[left];
            a[left++] = a[right];
            a[right--] = temp;
        }
        return a;
    }
    	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;
        }
    }

//    *******----segement tree implement---*****
//    -------------START--------------------------
    	void buildTree (int[] arr,int[] tree,int start,int end,int treeNode)
    {
    	if(start==end)
    	{
    		tree[treeNode]=arr[start];
    		return;
    	}
    	buildTree(arr,tree,start,end,2*treeNode);
    	buildTree(arr,tree,start,end,2*treeNode+1);
    	tree[treeNode]=tree[treeNode*2]+tree[2*treeNode+1];
    }
    	void updateTree(int[] arr,int[] tree,int start,int end,int treeNode,int idx,int value)
    {
    	if(start==end)
    	{
    		arr[idx]=value;
    		tree[treeNode]=value;
    		return;
    	}
    	int mid=(start+end)/2;
    	if(idx>mid)
    	{
    		updateTree(arr,tree,mid+1,end,2*treeNode+1,idx,value);
    	}
    	else
    	{
    		updateTree(arr,tree,start,mid,2*treeNode,idx,value);
    	}
    	tree[treeNode]=tree[2*treeNode]+tree[2*treeNode+1];
    }
    	static int[][] dp;
//    	disjoint set implementation --start
        static void makeSet(int n)
        {
        	parent=new int[n];
        	rank=new int[n];
        	for(int i=0;i<n;i++)
        	{
        		parent[i]=i;
        		rank[i]=0;
        	}
        }
        static void union(int u,int v)
        {
        	u=findpar(u);
        	v=findpar(v);
        	if(rank[u]<rank[v])parent[u]=v;
        	else if(rank[v]<rank[u])parent[v]=u;
        	else 
        	{
        		parent[v]=u;
        		rank[u]++;
        	}
        }
        
    	private static int findpar(int node)
    	{	
    		if(node==parent[node])return node;
    		return parent[node]=findpar(parent[node]);
    	}
    	static int parent[];
        static int rank[];
//    	*************end
        static Long MOD=(long) (1e9+7);
        private static void solver(long n)
        {
        	int mid = (int) (n / 2);

    	    for (int i = mid; i >= 1; i--){
    	        if (coprime(i, n - i) == true)
    	        {
    	            System.out.print(i+" " +(n - i)+" ");
    	            break;
    	        }
    	    }
        	
        }
        static boolean coprime(int a, long l){
            return (gcd(a, l) == 1);
        }
        static ArrayList<Integer>arr;
        static boolean[] vis;
        static ArrayList<ArrayList<Integer>>adj;
        public static void main(String[] args)
        {
        	FastReader s = new FastReader();
	        dp=new int[1001][1001];
	        long tt = s.nextLong();
	        while (tt-->0)
	        {
	        	long[]a=new long[3];
	        	for(int i=0;i<3;i++)a[i]=s.nextLong();
	        	Arrays.sort(a);
	        	if(a[0]==a[1]&&a[1]==a[2]&&a[0]%2==0)System.out.println("YES");
	        	else if(a[0]==a[1]&&a[2]%2==0)System.out.println("YES");
	        	else if(a[1]==a[2]&&a[0]%2==0)System.out.println("YES");
	        	else if(a[0]+a[1]==a[2])System.out.println("YES");
	        	else System.out.println("NO");
	        }
	        
        }
		private static String solver(long letter, long[] room) {
			int l=0,h=room.length;
			while(l<=h)
			{
				int mid=l+(h-l)/2;
				if(room[mid]<letter)
				{
					l=mid+1;
				}
				else if(room[mid]>letter)
				{
					h=mid-1;
				}
				else 
				{
					String ans=mid+" "+(letter-room[mid-1]);
					return ans;
				}
				
			}
			if(letter<=room[l])
			{
				String ans=l+" "+(letter-room[l-1]);
				return ans;
			}
			String ans=h+" "+(letter-room[h+1]);
			return ans;
		}
		private static void dfs(int i) {
			vis[i]=true;
			arr.add(i);
			for(int x:adj.get(i))
			{
				if(vis[x]==false)dfs(x);
			}
			
		}
		static long power1(long a,long b) {
    	    if(b == 0){
    	        return 1;
    	    }
    	    long ans = power(a,b/2);
    	    ans *= ans;
    	    if(b % 2!=0){
    	        ans *= a;
    	    }
    	    return ans;
    	}
        static void swap(StringBuilder sb,int l,int r)
        {
            char temp = sb.charAt(l);
            sb.setCharAt(l,sb.charAt(r));
            sb.setCharAt(r,temp);
        }
        
        // function to reverse the string between index l and r
        static void reverse(StringBuilder sb,int l,int r)
        {
            while(l < r)
            {
                swap(sb,l,r);
                l++;
                r--;
            }
        }
        
        // function to search a character lying between index l and r 
        // which is closest greater (just greater) than val
        // and return it's index 
        static int binarySearch(StringBuilder sb,int l,int r,char val) 
        { 
          int index = -1; 
          
          while (l <= r) 
          { 
            int mid = (l+r)/2;
            if (sb.charAt(mid) <= val) 
            {
                r = mid - 1;
            }
            else 
            { 
              l = mid + 1; 
              if (index == -1 || sb.charAt(index) >= sb.charAt(mid)) 
                index = mid; 
            } 
          } 
          return index; 
        } 
        
        // this function generates next permutation (if there exists any such permutation) from the given string
        // and returns True
        // Else returns false
        static boolean nextPermutation(StringBuilder sb) 
        { 
          int len = sb.length();
          int i = len-2; 
          
          while (i >= 0 && sb.charAt(i) >= sb.charAt(i+1)) 
          i--;
          
          if (i < 0) 
            return false; 
          else 
          { 
            int index = binarySearch(sb,i+1,len-1,sb.charAt(i)); 
            swap(sb,i,index); 
            reverse(sb,i+1,len-1); 
            return true; 
          } 
        }  
        private static int lps(int m ,int n,String s1,String s2,int[][]mat)
        {
            for(int i=1;i<=m;i++)
            {
                for(int j=1;j<=n;j++)
                {
                    if(s1.charAt(i-1)==s2.charAt(j-1))mat[i][j]=1+mat[i-1][j-1];
                    else mat[i][j]=Math.max(mat[i-1][j],mat[i][j-1]);
                }
            }
            return mat[m][n];
        }
        static String lcs(String X, String Y, int m, int n)
        {
            int[][] L = new int[m+1][n+1];
       
            // Following steps build L[m+1][n+1] in bottom up fashion. Note
            // that L[i][j] contains length of LCS of X[0..i-1] and Y[0..j-1] 
            for (int i=0; i<=m; i++)
            {
                for (int j=0; j<=n; j++)
                {
                    if (i == 0 || j == 0)
                        L[i][j] = 0;
                    else if (X.charAt(i-1) == Y.charAt(j-1))
                        L[i][j] = L[i-1][j-1] + 1;
                    else
                        L[i][j] = Math.max(L[i-1][j], L[i][j-1]);
                }
            }
       
            // Following code is used to print LCS
            int index = L[m][n];
            int temp = index;
       
            // Create a character array to store the lcs string
            char[] lcs = new char[index+1];
            lcs[index] = '\u0000'; // Set the terminating character
       
            // Start from the right-most-bottom-most corner and
            // one by one store characters in lcs[]
            int i = m;
            int j = n;
            while (i > 0 && j > 0)
            {
                // If current character in X[] and Y are same, then
                // current character is part of LCS
                if (X.charAt(i-1) == Y.charAt(j-1))
                {
                    // Put current character in result
                    lcs[index-1] = X.charAt(i-1); 
                      
                    // reduce values of i, j and index
                    i--; 
                    j--; 
                    index--;     
                }
       
                // If not same, then find the larger of two and
                // go in the direction of larger value
                else if (L[i-1][j] > L[i][j-1])
                    i--;
                else
                    j--;
            }
            return String.valueOf(lcs);
            // Print the lcs
//            System.out.print("LCS of "+X+" and "+Y+" is ");
//            for(int k=0;k<=temp;k++)
//                System.out.print(lcs[k]);
        }
        static long lis(long[] aa2, int n)
        {
            long lis[] = new long[n];
            int i, j;
            long max = 0;
            for (i = 0; i < n; i++)
                lis[i] = 1;
            for (i = 1; i < n; i++)
                for (j = 0; j < i; j++)
                    if (aa2[i] >= aa2[j] && lis[i] <= lis[j] + 1)
                        lis[i] = lis[j] + 1;
            for (i = 0; i < n; i++)
                if (max < lis[i])
                    max = lis[i];
     
            return max;
        }
        static boolean isPalindrome(String str)
        {
            int i = 0, j = str.length() - 1;
            while (i < j) {
                if (str.charAt(i) != str.charAt(j))
                    return false;
                i++;
                j--;
            }
            return true;
        }
        static boolean issafe(int i, int j, int r,int c, char ch)
        {
			if (i < 0 || j < 0 || i >= r || j >= c|| ch!= '1')return false;
			else return true;
        }
        static long power(long a, long b)
        {
        	   a %=MOD;
        	    long out = 1;
        	    while (b > 0) {
        	        if((b&1)!=0)out = out * a % MOD;
        	        a = a * a % MOD;
        	        b >>= 1;
        			a*=a;
        	    }
        	    return out;
        }
        static long[] sieve;
   	 	public static void sieve()
   	    {
   	        int nnn=(int) 1e6+1;
   		    	long nn=(int) 1e6;
   		    	sieve=new long[(int) nnn];
   		    	int[] freq=new int[(int) nnn];
   		    	sieve[0]=0;
   		    	sieve[1]=1;
   		    	for(int i=2;i<=nn;i++)
   		    	{
   		    		sieve[i]=1;
   		    		freq[i]=1;
   		    	}
   		    	for(int i=2;i*i<=nn;i++)
   		    	{
   		    		if(sieve[i]==1)
   		    		{
   			    		for(int j=i*i;j<=nn;j+=i)
   			    		{
   			    			if(sieve[j]==1)
   			    			{
   			    				sieve[j]=0;
   			    			}
   			    		}
   		    		}
   		    	}
   	    }

}
class pair{
	long x,y;
	public pair(long x,long y)
	{
		this.x=x;
		this.y=y;
	}
}



