Vasya claims that he had a paper square. He cut it into two rectangular parts using one vertical or horizontal cut. Then Vasya informed you the dimensions of these two rectangular parts. You need to check whether Vasya originally had a square. In other words, check if it is possible to make a square using two given rectangles.


-----Input-----

The first line contains an integer $t$ ($1 \le t \le 10^4$) — the number of test cases in the input. Then $t$ test cases follow.

Each test case is given in two lines.

The first line contains two integers $a_1$ and $b_1$ ($1 \le a_1, b_1 \le 100$) — the dimensions of the first one obtained after cutting rectangle. The sizes are given in random order (that is, it is not known which of the numbers is the width, and which of the numbers is the length).

The second line contains two integers $a_2$ and $b_2$ ($1 \le a_2, b_2 \le 100$) — the dimensions of the second obtained after cutting rectangle. The sizes are given in random order (that is, it is not known which of the numbers is the width, and which of the numbers is the length).


-----Output-----

Print $t$ answers, each of which is a string "YES" (in the case of a positive answer) or "NO" (in the case of a negative answer). The letters in words can be printed in any case (upper or lower).


-----Example-----
Input
3
2 3
3 1
3 2
1 3
3 3
1 3

Output
Yes
Yes
No

Starter code:

Solutions:
for _ in range(int(input())):
    a1, b1 = list(map(int, input().split()))
    a2, b2 = list(map(int, input().split()))
    if a1 > b1:
        a1, b1 = b1, a1
    if a2 > b2:
        a2, b2 = b2, a2
    flag = False
    if a1 == a2 and a1 == b1 + b2:
        flag = True
    if b1 == b2 and b1 == a1 + a2:
        flag = True
    print('Yes' if flag else 'No')


t = int(input())
for _ in range(t):
	a1, b1 = map(int, input().split())
	a2, b2 = map(int, input().split())
	if a1 > b1:
		a1, b1 = b1, a1
	if a2 > b2:
		a2, b2 = b2, a2

	if b1 == b2 and a1 + a2 == b1:
		print("Yes")
	else:
		print("No")

t = int(input())
for case in range(t):
    a, b = list(map(int, input().split()))
    c, d = list(map(int, input().split()))
    if a == c and b + d == a:
        print('Yes')
    elif b == d and a + c == b:
        print('Yes')
    elif a == d and b + c == a:
        print('Yes')
    elif b == c and a + d == b:
        print('Yes')
    else:
        print('No')

import math
for _ in range(int(input())):
    a,b=list(map(int,input().split()))
    c,d=list(map(int,input().split()))
    if min(c,d)+min(a,b)==max(a,b) and max(a,b)==max(c,d):
        print("Yes")
    else:
        print("No")


import sys



for t in range(int(sys.stdin.readline())):


	a, b = list(map(int, sys.stdin.readline().split()))
	x, y = list(map(int, sys.stdin.readline().split()))
	a, b = min(a, b), max(a, b)
	x, y = min(x, y), max(x, y)
	if b == y and b == a + x:
		sys.stdout.write("Yes\n")
	else:
		sys.stdout.write("No\n")


import sys,bisect,string,math,time,functools,random
from heapq import heappush,heappop,heapify
from collections import deque,defaultdict,Counter
from itertools import permutations,combinations,groupby
def Golf():*a,=map(int,open(0))
def I():return int(input())
def S_():return input()
def IS():return input().split()
def LS():return [i for i in input().split()]
def LI():return [int(i) for i in input().split()]
def LI_():return [int(i)-1 for i in input().split()]
def NI(n):return [int(input()) for i in range(n)]
def NI_(n):return [int(input())-1 for i in range(n)]
def StoLI():return [ord(i)-97 for i in input()]
def ItoS(n):return chr(n+97)
def LtoS(ls):return ''.join([chr(i+97) for i in ls])
def GI(V,E,ls=None,Directed=False,index=1):
    org_inp=[];g=[[] for i in range(V)]
    FromStdin=True if ls==None else False
    for i in range(E):
        if FromStdin:
            inp=LI()
            org_inp.append(inp)
        else:
            inp=ls[i]
        if len(inp)==2:
            a,b=inp;c=1
        else:
            a,b,c=inp
        if index==1:a-=1;b-=1
        aa=(a,c);bb=(b,c);g[a].append(bb)
        if not Directed:g[b].append(aa)
    return g,org_inp
def GGI(h,w,search=None,replacement_of_found='.',mp_def={'#':1,'.':0},boundary=1):
#h,w,g,sg=GGI(h,w,search=['S','G'],replacement_of_found='.',mp_def={'#':1,'.':0}) # sample usage
    mp=[boundary]*(w+2);found={}
    for i in range(h):
        s=input()
        for char in search:
            if char in s:
                found[char]=((i+1)*(w+2)+s.index(char)+1)
                mp_def[char]=mp_def[replacement_of_found]
        mp+=[boundary]+[mp_def[j] for j in s]+[boundary]
    mp+=[boundary]*(w+2)
    return h+2,w+2,mp,found
def TI(n):return GI(n,n-1)
def bit_combination(k,n=2):
    rt=[]
    for tb in range(n**k):
        s=[tb//(n**bt)%n for bt in range(k)];rt+=[s]
    return rt
def show(*inp,end='\n'):
    if show_flg:print(*inp,end=end)

YN=['YES','NO'];Yn=['Yes','No']
mo=10**9+7
inf=float('inf')
l_alp=string.ascii_lowercase
#sys.setrecursionlimit(10**7)
input=lambda: sys.stdin.readline().rstrip()

class Tree:
    def __init__(self,inp_size=None,init=True):
        self.LCA_init_stat=False
        self.ETtable=[]
        if init:
            self.stdin(inp_size)
        return

    def stdin(self,inp_size=None,index=1):
        if inp_size==None:
            self.size=int(input())
        else:
            self.size=inp_size
        self.edges,_=GI(self.size,self.size-1,index=index)
        return
    
    def listin(self,ls,index=0):
        self.size=len(ls)+1
        self.edges,_=GI(self.size,self.size-1,ls,index=index)
        return

    def __str__(self):
        return  str(self.edges)

    def dfs(self,x,func=lambda prv,nx,dist:prv+dist,root_v=0):
        q=deque()
        q.append(x)
        v=[-1]*self.size
        v[x]=root_v
        while q:
            c=q.pop()
            for nb,d in self.edges[c]:
                if v[nb]==-1:
                    q.append(nb)
                    v[nb]=func(v[c],nb,d)
        return v

    def EulerTour(self,x):
        q=deque()
        q.append(x)
        self.depth=[None]*self.size
        self.depth[x]=0
        self.ETtable=[]
        self.ETdepth=[]
        self.ETin=[-1]*self.size
        self.ETout=[-1]*self.size
        cnt=0
        while q:
            c=q.pop()
            if c<0:
                ce=~c
            else:
                ce=c
                for nb,d in self.edges[ce]:
                    if self.depth[nb]==None:
                        q.append(~ce)
                        q.append(nb)
                        self.depth[nb]=self.depth[ce]+1
            self.ETtable.append(ce)
            self.ETdepth.append(self.depth[ce])
            if self.ETin[ce]==-1:
                self.ETin[ce]=cnt
            else:
                self.ETout[ce]=cnt
            cnt+=1
        return
    
    def LCA_init(self,root):
        self.EulerTour(root)
        self.st=SparseTable(self.ETdepth,init_func=min,init_idl=inf)
        self.LCA_init_stat=True
        return
    
    def LCA(self,root,x,y):
        if self.LCA_init_stat==False:
            self.LCA_init(root)
        xin,xout=self.ETin[x],self.ETout[x]
        yin,yout=self.ETin[y],self.ETout[y]
        a=min(xin,yin)
        b=max(xout,yout,xin,yin)
        id_of_min_dep_in_et=self.st.query_id(a,b+1)
        return self.ETtable[id_of_min_dep_in_et]

class SparseTable: # O(N log N) for init, O(1) for query(l,r)
    def __init__(self,ls,init_func=min,init_idl=float('inf')):
        self.func=init_func
        self.idl=init_idl
        self.size=len(ls)
        self.N0=self.size.bit_length()
        self.table=[ls[:]]
        self.index=[list(range(self.size))]
        self.lg=[0]*(self.size+1)
        
        for i in range(2,self.size+1):
            self.lg[i]=self.lg[i>>1]+1

        for i in range(self.N0):
            tmp=[self.func(self.table[i][j],self.table[i][min(j+(1<<i),self.size-1)]) for j in range(self.size)]
            tmp_id=[self.index[i][j] if self.table[i][j]==self.func(self.table[i][j],self.table[i][min(j+(1<<i),self.size-1)]) else self.index[i][min(j+(1<<i),self.size-1)] for j in range(self.size)]
            self.table+=[tmp]
            self.index+=[tmp_id]
    
    # return func of [l,r)
    def query(self,l,r):
        #N=(r-l).bit_length()-1
        N=self.lg[r-l]
        return self.func(self.table[N][l],self.table[N][r-(1<<N)])
    
    # return index of which val[i] = func of v among [l,r)
    def query_id(self,l,r):
        #N=(r-l).bit_length()-1
        N=self.lg[r-l]
        a,b=self.index[N][l],self.index[N][r-(1<<N)]
        if self.table[0][a]==self.func(self.table[N][l],self.table[N][r-(1<<N)]):
            b=a
        return b
    
    def __str__(self):
        return str(self.table[0])
        
    def print(self):
        for i in self.table:
            print(*i)

show_flg=False
show_flg=True
ans=0

T=I()
for _ in range(T):
    a,b=LI()
    c,d=LI()
    if a>b:
        a,b=b,a
    if c>d:
        c,d=d,c
    ans='Yes' if b==d and a+c==b else 'No'
    print(ans)



q = int(input())

for _ in range(q):
    a, b = list(map(int, input().split()))
    c, d = list(map(int, input().split()))
    a, b = min(a, b), max(a, b)
    c, d = min(c, d), max(c, d)
    if b == d and a+c == b:
        print("Yes")
    else:
        print("No")



t=int(input())
for tests in range(t):
    a1,b1=list(map(int,input().split()))
    a2,b2=list(map(int,input().split()))

    if min(a1,b1)+min(a2,b2)==max(a1,b1)==max(a2,b2):
        print("Yes")
    else:
        print("No")


for _ in range(int(input())):
    a, b = list(map(int,input().split()))
    c, d = list(map(int,input().split()))
    if b > a:
        a, b = b, a
    if d > c:
        c, d = d, c
    if a == c == b+d:
        print("Yes")
    else:
        print("No")


for __ in range(int(input())):
	a,b=map(int,input().split())
	x,y=map(int,input().split())
	if(a==x and b+y==x):
		print("Yes")
	elif(a==y and b+x==y):
		print("Yes")
	elif(b==x and a+y==x):
		print("Yes")
	elif(b==y and a+x==y):
		print("Yes")
	else:
		print("No")

t=int(input())
for i in range(t):
    a,b=list(map(int,input().split()))
    c,d=list(map(int,input().split()))
    if max(a,b)==max(c,d):
        if min(a,b)+min(c,d)==max(a,b):
            print("Yes")
        else:
            print("No")
    else:
        print("No")


t = int(input())
for i in range(t):
    a, b = list(map(int, input().split()))
    c, d = list(map(int, input().split()))
    if a + c == b == d or a + d == b == c or b + c == a == d or b + d == a == c:
        print("Yes")
    else:
        print("No")

for n in range(int(input())):
	a,b=map(int,input().split())
	c,d=map(int,input().split())
	m1=max(a,b)
	n1=min(a,b)
	m2=max(c,d)
	n2=min(c,d)
	if m1==m2 and n1+n2==m1:
		print('Yes')
	else:
		print('No')

a=int(input())
for i in range(a):
    x,y=list(map(int,input().split()))
    r,s=list(map(int,input().split()))
    if(x==s and y+r==s):
        print('Yes')
    elif(x==r and y+s==x):
        print('Yes')
    elif(y==s and x+r==y):
        print('Yes')
    elif(y==r and x+s==y):
        print('Yes')
    else:
        print('No')


from sys import stdin, exit
input = stdin.readline

def i(): return input()
def ii(): return int(input())
def iis(): return list(map(int, input().split()))
def liis():	return list(map(int, input().split()))
def print_array(a): print(" ".join(map(str, a)))

t = ii()
for _ in range(t):
	a1, b1 = iis()	
	a2, b2 = iis()
	if (a1 == a2 and b1+b2 == a1) or (a1 == b2 and a2+b1 == a1) or (a2 == b1 and a1+b2 == a2) or (b2 == b1 and a1+a2 == b2):
		print("Yes")
	else:
		print("No")


T = int(input())

for t in range(T):
  i1 = [int(i) for i in input().split(' ')]
  i2 = [int(i) for i in input().split(' ')]
  if i1[0]==i2[0] and i1[1]+i2[1]==i1[0]:
    print('Yes')
  elif i1[0]==i2[1] and i1[1]+i2[0]==i1[0]:
    print('Yes')
  elif i1[1]==i2[0] and i1[0]+i2[1]==i1[1]:
    print('Yes')
  elif i1[1]==i2[1] and i1[0]+i2[0]==i1[1]:
    print('Yes')
  else:
    print('No')


def read_int():
    return int(input())


def read_ints():
    return list(map(int, input().split(' ')))


t = read_int()
for case_num in range(t):
    a = list(read_ints())
    b = list(read_ints())
    ok = False
    for i in range(2):
        for j in range(2):
            if a[i] != b[j]:
                continue
            if a[1 - i] + b[1 - j] == a[i]:
                ok = True
    print('Yes' if ok else 'No')


q = int(input())
for i in range(q):
    a1, b1 = map(int, input().split())
    a2, b2 = map(int, input().split())
    if max(a1, b1) == max(a2, b2) == (min(a1, b1) + min(a2, b2)):
        print('Yes')
    else:
        print('No')