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 \le t \le 10^4$) — the number of testcases.

The only line of each testcase contains three integers $l_1, l_2, l_3$ ($1 \le l_i \le 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).


-----Examples-----

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$.

Difficulty: EASY

Solutions:
tests = int(input())
res = []
for i in range(tests):
	(a, b, c) = map(int, input().split())
	arr = [a, b, c]
	if abs(a - b) == c or abs(a - c) == b or abs(b - c) == a:
		res.append('YES')
	elif arr.count(max(arr)) == 2 and min(arr) % 2 == 0:
		res.append('YES')
	elif arr.count(min(arr)) == 2 and max(arr) % 2 == 0:
		res.append('YES')
	elif arr.count(min(arr)) == 3 and max(arr) % 2 == 0:
		res.append('YES')
	else:
		res.append('NO')
for i in range(tests):
	print(res[i])


n = []
for i in range(0, int(input())):
	(ro, p, m) = map(int, input().split())
	if abs(ro - p) == m or abs(ro - m) == p or abs(p - m) == ro:
		n.append('YES')
	elif ro == p:
		if m % 2 == 0:
			n.append('YES')
		else:
			n.append('NO')
	elif m == p:
		if ro % 2 == 0:
			n.append('YES')
		else:
			n.append('NO')
	elif ro == m:
		if p % 2 == 0:
			n.append('YES')
		else:
			n.append('NO')
	else:
		n.append('NO')
for c in range(len(n)):
	print(n[c])


import math
t = int(input())
for i in range(t):
	(a, b, c) = map(int, input().split())
	if a == b and c % 2 == 0:
		print('YES')
	elif a == c and b % 2 == 0:
		print('YES')
	elif b == c and a % 2 == 0:
		print('YES')
	elif max(a, b, c) == a + b + c - max(a, b, c):
		print('YES')
	else:
		print('NO')


n = int(input())
for i in range(n):
	l = [int(x) for x in input().split()]
	l.sort()
	if l[0] + l[1] == l[2]:
		print('YES')
	elif l[0] == l[1] or l[1] == l[2]:
		if l[0] == l[1] and l[2] % 2 == 0 or (l[1] == l[2] and l[0] % 2 == 0):
			print('YES')
		else:
			print('NO')
	elif l[0] != l[1] and l[1] != l[2]:
		if l[0] + l[1] == l[2]:
			print('YES')
		else:
			print('NO')


t = int(input())
for _ in range(t):
	(a, b, c) = map(int, input().split())
	k = [a, b, c]
	k.sort()
	if k[0] + k[1] == k[2] or (k[0] == k[1] and k[2] % 2 == 0) or (k[1] == k[2] and k[0] % 2 == 0):
		print('YES')
	else:
		print('NO')


ans = []
for _ in range(int(input())):
	(l1, l2, l3) = map(int, input().split())
	if l1 < l2:
		(l1, l2) = (l2, l1)
	if l1 < l3:
		(l1, l3) = (l3, l1)
	if l2 < l3:
		(l2, l3) = (l3, l2)
	if l1 == l2:
		ans.append('YES' if l3 % 2 == 0 else 'NO')
	elif l2 == l3:
		ans.append('YES' if l1 % 2 == 0 else 'NO')
	elif l1 == l2 + l3:
		ans.append('YES')
	else:
		ans.append('NO')
print(*ans, sep='\n')


for i in range(int(input())):
	(l1, l2, l3) = map(int, input().split())
	if l1 == l2:
		if l3 % 2 == 0:
			print('YES')
		else:
			print('NO')
	elif l2 == l3:
		if l1 % 2 == 0:
			print('YES')
		else:
			print('NO')
	elif l3 == l1:
		if l2 % 2 == 0:
			print('YES')
		else:
			print('NO')
	elif max(l1, l2, l3) == l1 + l2 + l3 - max(l1, l2, l3):
		print('YES')
	else:
		print('NO')


def breaktest(a, b, c):
	if c == a + b and c > max(a, b):
		return True
	if a == b and c % 2 == 0:
		return True
	else:
		return False
T = int(input())
for testcase in range(1, T + 1):
	(a, b, c) = list(map(int, input().split()))
	if breaktest(a, b, c) or breaktest(c, b, a) or breaktest(a, c, b):
		print('YES')
	else:
		print('NO')


x = int(input())

def rectangle(a, b, c):
	if a + b == c or a + c == b or c + b == a or (a == b and c % 2 == 0) or (c == b and a % 2 == 0) or (a == c and b % 2 == 0):
		return 'YES'
	else:
		return 'NO'
z = []
for i in range(x):
	y = []
	y = input().split()
	a = int(y[0])
	b = int(y[1])
	c = int(y[2])
	z.append(rectangle(a, b, c))
for x in z:
	print(x)


t = int(input())
for i in range(t):
	bl = False
	(l1, l2, l3) = map(int, input().split(' '))
	if l1 == l2 and l3 % 2 == 0:
		bl = True
	if l2 == l3 and l1 % 2 == 0:
		bl = True
	if l3 == l1 and l2 % 2 == 0:
		bl = True
	if l1 != l2 and l2 != l3 and (l3 != l1) and (l1 + l2 == l3 or l2 + l3 == l1 or l3 + l1 == l2):
		bl = True
	if bl:
		print('YES')
	else:
		print('NO')


for i in range(int(input())):
	(a, b, c) = map(int, input().split())
	if a == b and c & 1 == 0 or (b == c and a & 1 == 0) or (a == c and b & 1 == 0) or (a + b == c) or (a + c == b) or (b + c == a):
		print('YES')
	else:
		print('NO')


t = int(input())
for k in range(t):
	data = input().split()
	first = int(data[0])
	second = int(data[1])
	third = int(data[2])
	condition = False
	if first == second:
		if third % 2 == 0:
			if not condition:
				condition = True
	if first != second:
		if third == first + second:
			if not condition:
				condition = True
	if first == third:
		if second % 2 == 0:
			if not condition:
				condition = True
	if first != third:
		if second == first + third:
			if not condition:
				condition = True
	if second == third:
		if first % 2 == 0:
			if not condition:
				condition = True
	if second != third:
		if first == second + third:
			if not condition:
				condition = True
	if condition:
		print('YES')
	else:
		print('NO')


import sys
n = sys.stdin.readline()
while True:
	l = sys.stdin.readline()
	if not l:
		break
	(l1, l2, l3) = [int(x) for x in l.split()]
	if l1 == l2 and l3 % 2 == 0 or (l2 == l3 and l1 % 2 == 0) or (l1 == l3 and l2 % 2 == 0):
		print('YES')
		continue
	if l1 + l2 == l3 or l1 + l3 == l2 or l2 + l3 == l1:
		print('YES')
		continue
	print('NO')


for t in range(int(input())):
	(n, m, o) = map(int, input().split())
	h = max(n, max(m, o))
	j = n + m + o
	if n == m and o % 2 == 0 or (n == o and m % 2 == 0) or (m == o and n % 2 == 0):
		print('YES')
	elif (n + m + o) % 2 == 0 and j // 2 == h:
		print('YES')
	else:
		print('NO')


def main():
	t = int(input())
	for i in range(t):
		lados = list(map(int, input().split()))
		lados.sort()
		if lados[0] == lados[1] and lados[0] == lados[2]:
			if lados[0] % 2 != 0:
				print('NO')
			else:
				print('YES')
		elif lados[0] == lados[1]:
			if lados[2] % 2 != 0:
				print('NO')
			else:
				print('YES')
		elif lados[2] == lados[1]:
			if lados[0] % 2 != 0:
				print('NO')
			else:
				print('YES')
		elif lados[0] == lados[1] + lados[2]:
			print('YES')
		elif lados[1] == lados[0] + lados[2]:
			print('YES')
		elif lados[2] == lados[1] + lados[0]:
			print('YES')
		else:
			print('NO')
main()


import sys
get = sys.stdin.readline
for _ in range(int(get())):
	x = sorted(list(map(int, get().split())))
	(a, b, c) = (x[0], x[1], x[2])
	if a + b == c:
		print('YES')
	elif a == b and c % 2 == 0:
		print('YES')
	elif a % 2 == 0 and b == c:
		print('YES')
	elif b % 2 == 0 and a == c:
		print('YES')
	else:
		print('NO')


from sys import stdin
import math
from collections import deque
from heapq import heapify, heappop, heappush
from bisect import bisect_left, bisect_right
input = stdin.readline

def ceil(m, n):
	val = m // n
	if m % n != 0:
		return val + 1
	return val
for _ in range(int(input())):
	(a, b, c) = map(int, input().split())
	(a, b, c) = sorted([a, b, c])
	bool1 = (b == c or a == c) and a % 2 == 0 or c == a + b or (a == b and c % 2 == 0)
	if bool1:
		print('YES')
	else:
		print('NO')


import sys
from os import path

def Construct_rect(lengths):
	lengths = lengths.split(' ')
	L = [int(lengths[0]), int(lengths[1]), int(lengths[2])]
	L.sort()
	if L[0] == L[1] and L[2] % 2 == 0:
		ans = 'YES'
	elif L[1] == L[2] and L[0] % 2 == 0:
		ans = 'YES'
	elif L[0] + L[1] == L[2]:
		ans = 'YES'
	else:
		ans = 'NO'
	return ans

def get_int():
	return int(sys.stdin.readline())

def get_string():
	return sys.stdin.readline().strip()
n = get_int()
final_result = []
for i in range(n):
	word = get_string()
	out = Construct_rect(word)
	final_result.append(out)
for item in final_result:
	sys.stdout.write(item)
	sys.stdout.write('\n')


def solve(l1, l2, l3):
	if l1 % 2 != 0 and l2 % 2 != 0 and (l3 % 2 != 0):
		return 'NO'
	else:
		if l2 + l3 == l1 or l1 + l3 == l2 or l2 + l1 == l3:
			return 'YES'
		elif l1 % 2 == 0 and l2 == l3 or (l2 % 2 == 0 and l1 == l3) or (l3 % 2 == 0 and l2 == l1):
			return 'YES'
		return 'NO'
	pass
T = int(input())
for _ in range(T):
	(l1, l2, l3) = map(int, input().split())
	out_ = solve(l1, l2, l3)
	print(out_)


t = int(input())
for i in range(t):
	(l1, l2, l3) = map(int, input().split())
	if l1 == l2 and l2 == l3 and (l1 % 2 == 0):
		print('YES')
	elif l1 == l2:
		l = int(l3 / 2)
		if l3 == l + l:
			print('YES')
		else:
			print('NO')
	elif l2 == l3:
		l = int(l1 / 2)
		if l1 == l + l:
			print('YES')
		else:
			print('NO')
	elif l1 == l3:
		l = int(l2 / 2)
		if l2 == l + l:
			print('YES')
		else:
			print('NO')
	elif l1 != l2 and l2 != l3 and (l3 != l1):
		if l3 == l1 + l2:
			print('YES')
		elif l2 == l1 + l3:
			print('YES')
		elif l1 == l2 + l3:
			print('YES')
		else:
			print('NO')
	else:
		print('NO')


import sys
import math
from math import gcd, sqrt, log2, ceil, floor
import heapq as hq
from bisect import bisect_right, bisect_left, bisect
import itertools
from sys import stdin, stdout, setrecursionlimit

def isPowerOfTwo(x):
	return x and (not x & x - 1)
MOD = int(1000000000.0) + 7
alp = 'abcdefghijklmnopqrstuvwxyz'
v = {'a': 1, 'e': 1, 'i': 1, 'o': 1, 'u': 1}
c = {}
T = 1
T = int(stdin.readline())
for _ in range(T):
	a = list(map(int, stdin.readline().rstrip().split()))
	a.sort()
	(x, y, z) = a
	if x + y == z:
		print('YES')
	elif x == y:
		if z % 2 == 0:
			print('YES')
		else:
			print('NO')
	elif y == z:
		if x % 2 == 0:
			print('YES')
		else:
			print('NO')
	elif z == x:
		if y % 2 == 0:
			print('YES')
		else:
			print('NO')
	else:
		print('NO')


t = int(input())
import math
for caseNr in range(1, t + 1):
	ls = list(map(int, input().split()))
	flag = 'NO'
	first = ls[0]
	if ls[1] == ls[2]:
		if first % 2 == 0:
			flag = 'YES'
	elif ls[0] == ls[1] + ls[2]:
		flag = 'YES'
	first = ls[1]
	if ls[0] == ls[2]:
		if first % 2 == 0:
			flag = 'YES'
	elif ls[1] == ls[0] + ls[2]:
		flag = 'YES'
	first = ls[2]
	if ls[0] == ls[1]:
		if first % 2 == 0:
			flag = 'YES'
	elif ls[2] == ls[0] + ls[1]:
		flag = 'YES'
	print(flag)


n = int(input())
for z in range(n):
	(a, b, c) = map(int, input().split())
	if a == b + c or b == a + c or c == a + b or (a == b and c % 2 == 0) or (a == c and b % 2 == 0) or (c == b and a % 2 == 0):
		print('YES')
	else:
		print('NO')


for _ in range(int(input())):
	l = list(map(int, input().split()))
	l.sort()
	if l[2] > l[1] and l[2] == l[0] + l[1] or (l[2] == l[1] and l[0] % 2 == 0) or (l[1] == l[0] and l[2] % 2 == 0):
		print('YES')
	else:
		print('NO')


import math
import sys
import itertools
import fractions
wtf = sys.stdin.read()
wtf = wtf.strip().split('\n')
for t in wtf[1:]:
	L = sorted(map(int, t.split()))
	print('YES' if L[1] == L[0] and L[2] % 2 == 0 or (L[1] == L[2] and L[0] % 2 == 0) or L[2] == L[0] + L[1] else 'NO')


test = int(input())
while test:
	l = list(map(int, input().split()))
	l.sort()
	if l[0] == l[1] and l[2] % 2 == 0:
		print('YES')
	elif l[1] == l[2] and l[0] % 2 == 0:
		print('YES')
	elif l[2] == l[1] + l[0]:
		print('YES')
	else:
		print('NO')
	test -= 1


def caso1(a, b, c):
	if a == b and c % 2 == 0:
		return True
	elif a == c and b % 2 == 0:
		return True
	elif c == b and a % 2 == 0:
		return True
	else:
		return False

def caso2(a, b, c):
	list = [a, b, c]
	list.sort()
	if list[2] - list[1] == list[0]:
		return True
	else:
		return False
n = int(input())
for i in range(n):
	new_list = input()
	new_list = new_list.replace(' ', ',')
	my_list = new_list.split(',')
	for i in range(0, 3):
		my_list[i] = int(my_list[i])
	a = my_list[0]
	b = my_list[1]
	c = my_list[2]
	val1 = caso1(a, b, c)
	val2 = caso2(a, b, c)
	if val1 == True or val2 == True:
		print('YES')
	else:
		print('NO')


for _ in range(int(input())):
	a = sorted(list(map(int, input().split())))
	if a[0] + a[1] == a[2] or (a[0] == a[1] and a[2] & 1 == 0) or (a[2] == a[1] and a[0] & 1 == 0):
		print('YES')
	else:
		print('NO')


import sys
import os.path
from collections import *
import math
import bisect
import heapq as hq
from fractions import Fraction
from random import randint
if os.path.exists('input.txt'):
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')
input = sys.stdin.readline

def solve():
	arr = [int(x) for x in input().split()]
	arr.sort()
	if sum(arr[:-1]) == arr[-1]:
		print('YES')
	elif arr[-1] == arr[1] and arr[0] % 2 == 0:
		print('YES')
	elif arr[0] == arr[1] and arr[-1] % 2 == 0:
		print('YES')
	else:
		print('NO')
t = int(input())
while t:
	t -= 1
	solve()


testcases_of_lengths = int(input())
for _ in range(0, testcases_of_lengths):
	listoflengths = list(map(int, input().split()))
	listoflengths.sort()
	if listoflengths[2] == listoflengths[1] + listoflengths[0]:
		print('YES')
	elif listoflengths[0] == listoflengths[1] and listoflengths[2] % 2 == 0 or (listoflengths[1] == listoflengths[2] and listoflengths[0] % 2 == 0) or (listoflengths[2] == listoflengths[0] and listoflengths[1] % 2 == 0):
		print('YES')
	else:
		print('NO')


from collections import deque, defaultdict, Counter
import random
import sys
import os
from io import BytesIO
sys.stdin = BytesIO(os.read(0, os.fstat(0).st_size))
MOD = 1000000007

def calc(l):
	(a, b, c) = sorted(l)
	assert a <= b and b <= c
	if (a + b + c) % 2 == 1:
		return False
	if a % 2 == 0 and b == c:
		return True
	if a + b == c:
		return True
	if c % 2 == 0 and a == b:
		return True
	return False

def solve():
	global tcases
	(a, b, c) = map(int, sys.stdin.readline().split())
	if calc([a, b, c]):
		print('YES')
	else:
		print('NO')
tcases = int(sys.stdin.readline())
for t in range(tcases):
	solve()


import sys

def rall():
	return sys.stdin.readlines()

def rl():
	return sys.stdin.readline().strip()

def rl_types(types):
	str_list = [x for x in sys.stdin.readline().strip().split(' ')]
	return [types[i](str_list[i]) for i in range(len(str_list))]

def pr(something=''):
	sys.stdout.write(str(something) + '\n')

def pra(array):
	sys.stdout.write(' '.join([str(x) for x in array]) + '\n')

def solve(array):
	return array
N = int(rl())
for _ in range(N):
	lengths = sorted(list(map(int, rl().split(' '))))
	valid = lengths[0] + lengths[1] == lengths[2]
	if lengths[0] == lengths[1]:
		valid |= lengths[2] % 2 == 0
	if lengths[0] == lengths[2]:
		valid |= lengths[1] % 2 == 0
	if lengths[2] == lengths[1]:
		valid |= lengths[0] % 2 == 0
	print('YES' if valid else 'NO')


import sys

def run():
	(l1, l2, l3) = map(int, next(sys.stdin).split(' '))
	if l1 < 0 or l2 < 0 or l3 < 0:
		print('NO')
		return
	if l1 == l2 + l3 or l2 == l1 + l3 or l3 == l1 + l2 or (l1 == l2 and l3 % 2 == 0) or (l2 == l3 and l1 % 2 == 0) or (l1 == l3 and l2 % 2 == 0):
		print('YES')
	else:
		print('NO')
test_cases = int(next(sys.stdin))
for _ in range(test_cases):
	run()


for s in [*open(0)][1:]:
	(x, y, z) = sorted(map(int, s.split()))
	print('YNEOS'[(z != x + y) & (x != y != z or (x ^ y ^ z) & 1)::2])


import sys
input = sys.stdin.readline

def inp():
	return int(input())

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

def insr():
	s = input()
	return list(s[:len(s) - 1])

def invr():
	return map(int, input().split())
for i in range(inp()):
	(l1, l2, l3) = sorted(invr())
	if l1 == l2:
		if l3 % 2 == 0:
			print('YES')
		else:
			print('NO')
	elif l3 == l2:
		if l1 % 2 == 0:
			print('YES')
		else:
			print('NO')
	elif l1 + l2 == l3:
		print('YES')
	else:
		print('NO')


for g in [*open(0)][1:]:
	(a, b, c) = sorted(map(int, g.split()))
	print('YNEOS'[(a != b or c % 2) and (b != c or a % 2) and (c != a + b)::2])


import os, sys
from io import BytesIO, IOBase
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
try:
	(sys.stdin, sys.stdout) = (open('in.txt', 'r'), open('out.txt', 'w'))
except:
	pass
ii1 = lambda : int(sys.stdin.readline().strip())
is1 = lambda : sys.stdin.readline().strip()
iia = lambda : list(map(int, sys.stdin.readline().strip().split()))
isa = lambda : sys.stdin.readline().strip().split()
mod = int(1000000000.0 + 7)
from math import inf
from collections import defaultdict as dd

def p(flag=0):
	print('YES' if flag else 'NO')

def main(t):
	arr = iia()
	arr.sort()
	if arr[0] + arr[1] == arr[-1]:
		p(1)
	elif arr[0] % 2 == 0 and arr[1] == arr[-1]:
		p(1)
	elif arr[0] == arr[1] and arr[-1] % 2 == 0:
		p(1)
	else:
		p()
t = 1
t = ii1()
for _ in range(t):
	main(_)


n = int(input())
ans = []
for _ in range(n):
	(a, b, c) = [int(x) for x in input().split()]
	if a - b == c or a - c == b:
		ans.append('YES')
	elif b - a == c or b - c == a:
		ans.append('YES')
	elif c - a == b or c - b == a:
		ans.append('YES')
	elif a == c and b % 2 == 0 or (a == b and c % 2 == 0) or (b == c and a % 2 == 0):
		ans.append('YES')
	else:
		ans.append('NO')
for i in range(n - 1):
	print(ans[i])
print(ans[-1])


for _ in range(int(input())):
	(l1, l2, l3) = map(int, input().split())
	if l1 - l2 == l3 or l2 - l1 == l3 or l2 - l3 == l1 or (l3 - l2 == l1) or (l3 - l1 == l2) or (l1 == l2 and l3 % 2 == 0) or (l1 == l3 and l2 % 2 == 0) or (l2 == l3 and l1 % 2 == 0):
		print('YES')
	else:
		print('NO')


def canRectangle(a, b, c):
	if a == b and c % 2 == 0:
		return True
	elif a == c and b % 2 == 0:
		return True
	elif b == c and a % 2 == 0:
		return True
	elif a == b + c:
		return True
	elif b == a + c:
		return True
	elif c == a + b:
		return True
	return False
t = int(input())
ans = []
for i in range(t):
	(a, b, c) = [int(x) for x in input().split()]
	ans.append(canRectangle(a, b, c))
for i in range(t):
	if ans[i]:
		print('YES')
	else:
		print('NO')


for _ in range(int(input())):
	(a, b, c) = input().split()
	(a, b, c) = [int(a), int(b), int(c)]
	if a == b:
		if c % 2 == 0:
			print('YES')
		else:
			print('NO')
	elif b == c:
		if a % 2 == 0:
			print('YES')
		else:
			print('NO')
	elif a == c:
		if b % 2 == 0:
			print('YES')
		else:
			print('NO')
	elif a + b + c - max(a, b, c) == max(a, b, c):
		print('YES')
	else:
		print('NO')


from collections import Counter
t = int(input())
for i in range(t):
	arr = list(map(int, input().split()))
	arr = sorted(arr)
	if len(set(arr)) == 1:
		if arr[0] % 2 == 0:
			print('YES')
		else:
			print('NO')
	elif len(set(arr)) == 2:
		ans = 0
		a = Counter(arr)
		for i in arr:
			if a[i] == 1:
				ans = i
		if ans % 2 == 0:
			print('YES')
		else:
			print('NO')
	elif max(arr) - min(arr) == arr[1]:
		print('YES')
	else:
		print('NO')


t = int(input())
inputdata = []

def getres(data, rep):
	copy = data
	data.remove(rep)
	data.remove(rep)
	if dat[0] % 2 == 0:
		print('YES')
	else:
		lastchance(copy)

def lastchance(dat):
	Max = max(dat)
	dat.remove(Max)
	if Max - sum(dat) == 0:
		print('YES')
	else:
		print('NO')
for i in range(t):
	inputdata.append(input().split(' '))
	for j in range(len(inputdata[i])):
		inputdata[i][j] = int(inputdata[i][j])
for dat in inputdata:
	if dat.count(dat[0]) >= 2:
		rep = dat[0]
		getres(dat, rep)
	elif dat.count(dat[1]) >= 2:
		rep = dat[1]
		getres(dat, rep)
	else:
		lastchance(dat)


from collections import defaultdict
t = int(input())
for test in range(t):
	freq = defaultdict(int)
	arr = list(map(int, input().split()))
	for i in arr:
		freq[i] += 1
	case1 = False
	same = -1
	not_poss = False
	case2 = False
	for key in freq:
		if freq[key] == 2:
			case1 = True
			same = key
		elif freq[key] == 3:
			case2 = True
	if case1:
		for i in arr:
			if i != same:
				if i % 2 == 1:
					not_poss = True
	elif case2:
		if arr[0] % 2 == 1:
			not_poss = True
	elif max(arr) != sum(arr) / 2:
		not_poss = True
	if not_poss:
		print('NO')
	else:
		print('YES')


import sys, bisect, math
from collections import deque, Counter
input = lambda : sys.stdin.readline().strip()
ceil = lambda x: math.ceil(x)
mod = 10 ** 9 + 7

def solve():
	(a, b, c) = sorted(map(int, input().split()))
	if a + b == c or (a == b and c % 2 == 0) or (b == c and a % 2 == 0):
		return 'YES'
	return 'NO'
t = 1
t = int(input())
for _ in range(t):
	print(solve())


for _ in range(int(input())):
	a = list(map(int, input().split()))
	g = False
	if a[1] == a[0] and a[2] % 2 == 0:
		g = True
	elif a[1] == a[2] and a[0] % 2 == 0:
		g = True
	elif a[2] == a[0] and a[1] % 2 == 0:
		g = True
	else:
		r = max(a)
		a.remove(r)
		if r - a[0] == a[1] or r - a[1] == a[0]:
			g = True
	if g:
		print('YES')
	else:
		print('NO')


no_test_case = int(input())
for test_case in range(no_test_case):
	input_test = list(map(int, input().split()))
	[l1, l2, l3] = input_test
	if l1 - l2 == l3:
		print('YES')
	elif l1 - l3 == l2:
		print('YES')
	elif l2 - l1 == l3:
		print('YES')
	elif l2 - l3 == l1:
		print('YES')
	elif l3 - l1 == l2:
		print('YES')
	elif l3 - l2 == l1:
		print('YES')
	elif l1 == l2 and l3 % 2 == 0:
		print('YES')
	elif l2 == l3 and l1 % 2 == 0:
		print('YES')
	elif l1 == l3 and l2 % 2 == 0:
		print('YES')
	else:
		print('NO')


t = int(input())
results = []
for i in range(t):
	sticks = [int(x) for x in input().split()]
	ans = 'NO'
	if sticks[0] == sticks[1]:
		if sticks[2] % 2 == 0:
			ans = 'YES'
	elif sticks[0] == sticks[2]:
		if sticks[1] % 2 == 0:
			ans = 'YES'
	elif sticks[1] == sticks[2]:
		if sticks[0] % 2 == 0:
			ans = 'YES'
	if ans == 'YES':
		results.append(ans)
		continue
	if 2 * max(sticks) == sum(sticks):
		ans = 'YES'
	results.append(ans)
for result in results:
	print(result)


from collections import Counter
from math import ceil, floor, log, gcd
import bisect as bs
import sys
input = sys.stdin.readline
inp_lis = lambda : list(map(int, input().split()))
inp_multi = lambda : map(int, input().split())
inp_int = lambda : int(input().strip())
for _ in range(int(input().strip())):
	(a, b, c) = inp_multi()
	if a == b and c % 2 == 0 or (a == c and b % 2 == 0) or (c == b and a % 2 == 0):
		print('YES')
	elif a == b + c or b == a + c or c == a + b:
		print('YES')
	else:
		print('NO')


t = int(input())
for _ in range(t):
	(l1, l2, l3) = map(int, input().split())
	if l1 == l2:
		if l3 % 2 == 0:
			print('YES')
		else:
			print('NO')
	elif l2 == l3:
		if l1 % 2 == 0:
			print('YES')
		else:
			print('NO')
	elif l1 == l3:
		if l2 % 2 == 0:
			print('YES')
		else:
			print('NO')
	elif l1 != l2 != l3:
		a = []
		a.append(l1)
		a.append(l2)
		a.append(l3)
		a.sort()
		if a[0] + a[1] == a[-1]:
			print('YES')
		else:
			print('NO')


for i in range(int(input())):
	(x, y, z) = map(int, input().split())
	if abs(x - y) == z or abs(z - y) == x or abs(x - z) == y or (x % 2 == 0 and y == z) or (z % 2 == 0 and y == x) or (y % 2 == 0 and x == z):
		print('YES')
	else:
		print('NO')


def solve(l):
	l.sort()
	(l1, l2, l3) = l
	if l1 == l2 and l3 % 2 == 0 and (l3 > 1):
		return 'YES'
	if l2 == l3 and l1 % 2 == 0 and (l1 > 1):
		return 'YES'
	if l1 == l2 + l3:
		return 'YES'
	if l2 == l1 + l3:
		return 'YES'
	if l3 == l1 + l2:
		return 'YES'
	return 'NO'
for _ in range(int(input())):
	l = list(map(int, input().split()))
	print(solve(l))


import sys
from os import pardir, path
if path.exists('input.txt'):
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')

def CheckRectangle(sticks):
	for i in range(len(sticks)):
		sticks[i].sort()
		temp = sticks[i]
		for j in range(0, len(sticks)):
			if temp[0] == temp[1]:
				if temp[2] % 2 == 0:
					print(f'YES')
					break
				else:
					print(f'NO')
					break
			elif temp[1] == temp[2] and temp[0] % 2 == 0:
				print(f'YES')
				break
			elif temp[0] + temp[1] == temp[2]:
				print(f'YES')
				break
			else:
				print(f'NO')
				break
T = int(input())
sticks = [None] * T
result = []
for i in range(0, T):
	sticks[i] = [int(num) for num in input().strip().split()[:3]]
CheckRectangle(sticks)


cases = int(input())
for abc in range(cases):
	Length = list(map(int, input().split()))[:3]
	Length.sort()
	if Length[2] == Length[1] + Length[0]:
		print('YES')
	elif Length[0] == Length[1] and Length[2] % 2 == 0:
		print('YES')
	elif Length[1] == Length[2] and Length[0] % 2 == 0:
		print('YES')
	else:
		print('NO')


n = int(input())
for _ in range(n):
	(a, b, c) = map(int, input().split())
	if a > b and a > c:
		f = a
		if b + c == f:
			print('YES')
			continue
	if b > a and b > c:
		f = b
		if a + c == f:
			print('YES')
			continue
	if c > a and c > b:
		f = c
		if a + b == f:
			print('YES')
			continue
	if a == b or b == c or a == c:
		if a == b:
			if c % 2 == 0:
				print('YES')
				continue
		elif b == c:
			if a % 2 == 0:
				print('YES')
				continue
		elif a == c:
			if b % 2 == 0:
				print('YES')
				continue
	print('NO')


from collections import Counter
t = int(input())
while t > 0:
	l = list(map(int, input().split()[:3]))
	l.sort()
	d = Counter(l)
	m = -1
	ans = -1
	for (i, k) in d.items():
		if k == 2:
			m = i
		if k == 3 and i % 2 == 0:
			ans = 1
	if m > 0:
		for (i, k) in d.items():
			if i != m:
				if i % 2 == 0:
					ans = 1
	if l[0] + l[1] == l[2] or ans == 1:
		print('YES')
	else:
		print('NO')
	t -= 1


import sys
input = sys.stdin.readline
num_test_cases = int(input())
for test_case_ittr in range(num_test_cases):
	lengths = sorted([int(x) for x in input().split()])
	if lengths[0] + lengths[1] == lengths[2] or (lengths[0] == lengths[1] and lengths[2] % 2 == 0) or (lengths[1] == lengths[2] and lengths[0] % 2 == 0):
		print('YES')
	else:
		print('NO')


import sys
input = sys.stdin.readline
M = 1000000007

def solve():
	a = sorted(list(map(int, input().split())))
	if a[2] == a[1] + a[0]:
		return 'YES'
	if a[2] == a[1] and a[0] % 2 == 0:
		return 'YES'
	if a[0] == a[1] and a[2] % 2 == 0:
		return 'YES'
	return 'NO'
for _ in range(int(input())):
	print(solve())


import collections
import sys
from collections import deque
import heapq
import bisect
import copy
MOD = 1000000007
NO = lambda : print('NO')
YES = lambda : print('YES')
_1 = lambda : print(-1)
ari = lambda : [int(_) for _ in input().split()]
cin = lambda : int(input())
cis = lambda : input()
show = lambda x: print(x)
fast = lambda : sys.stdin.readline()
test_case = 1
test_case = int(input())
sys.setrecursionlimit(10 ** 6)

def ans():
	(x, y, z) = ari()
	st = set([x, y, z])
	st = list(st)
	m = 0
	if x == y or x == z:
		m = x
	elif y == z:
		m = y
	if len(st) == 2 or len(st) == 1:
		if (x + y + z - m * 2) % 2 == 0:
			YES()
		else:
			NO()
	elif max(st) == x + y + z - max(st):
		YES()
	else:
		NO()
	return
for _ in range(test_case):
	ans()


for i in range(int(input())):
	s = list(map(int, input().split()))
	s = sorted(s)
	a = s[0]
	b = s[1]
	c = s[2]
	if a != b != c:
		if a + b == c or b + c == a or a + c == b:
			print('YES')
		else:
			print('NO')
	elif a == b == c:
		if a % 2 == 0:
			print('YES')
		else:
			print('NO')
	elif a == b and b != c:
		if c % 2 == 0:
			print('YES')
		else:
			print('NO')
	elif b == c and b != a:
		if a % 2 == 0:
			print('YES')
		else:
			print('NO')


t = int(input())
for i in range(t):
	l = input()
	l = [int(e) for e in l.split()]
	l.sort()
	if l[0] + l[1] == l[2]:
		print('YES')
	elif l[0] == l[1] and l[2] % 2 == 0:
		print('YES')
	elif l[2] == l[1] and l[0] % 2 == 0:
		print('YES')
	else:
		print('NO')


t = int(input())
for _ in range(t):
	l = list(map(int, input().split()))
	l.sort()
	pos = False
	if l[0] + l[1] == l[2]:
		print('YES')
		continue
	elif l[1] == l[2]:
		pos = l[0] % 2 == 0
	elif l[0] == l[1]:
		pos = l[2] % 2 == 0
	elif l[0] == l[2]:
		pos = l[1] % 2 == 0
	if pos:
		print('YES')
	else:
		print('NO')


import sys

def _input():
	return sys.stdin.readline().strip()

def main():
	for _ in range(int(_input())):
		l = list(map(int, _input().split()))
		l.sort()
		s = set(l)
		(a, b, c) = (l[0], l[1], l[2])
		if len(s) == 3:
			if a + b == c:
				print('YES')
			else:
				print('NO')
		elif len(s) == 2:
			if a == b:
				if c % 2 != 0:
					print('NO')
				else:
					print('YES')
			elif c == b:
				if a % 2 != 0:
					print('NO')
				else:
					print('YES')
			elif b % 2 != 0:
				print('NO')
			else:
				print('YES')
		elif a % 2 == 0:
			print('YES')
		else:
			print('NO')
main()


def f(x, y, z):
	if x == y:
		return (True, x, y)
	elif x == z:
		return (True, x, z)
	elif y == z:
		return (True, y, z)
	return (False, 0)
X = lambda : map(int, input().split())
(t,) = X()
for i in range(t):
	(a, b, c) = X()
	L = [a, b, c]
	if f(a, b, c)[0]:
		L.remove(f(a, b, c)[1])
		L.remove(f(a, b, c)[2])
		if L[0] % 2 == 0:
			print('YES')
		else:
			print('NO')
	else:
		L.sort()
		if L[2] == L[1] + L[0]:
			print('YES')
		else:
			print('NO')


t = int(input())
for _ in range(t):
	(l1, l2, l3) = map(int, input().split())
	ans = False
	for i in range(3):
		if i == 0:
			if l1 == l2 and l3 % 2 == 0:
				ans = True
			elif l1 + l2 == l3:
				ans = True
		elif i == 1:
			if l2 == l3 and l1 % 2 == 0:
				ans = True
			elif l3 + l2 == l1:
				ans = True
		elif l1 == l3 and l2 % 2 == 0:
			ans = True
		elif l1 + l3 == l2:
			ans = True
	print('YES') if ans == True else print('NO')


def solution():
	import sys
	t = int(sys.stdin.readline())
	for _ in range(t):
		l = list(sorted(map(int, sys.stdin.readline().split())))
		if sum(l[:2]) == l[2] or (l[0] == l[1] and l[2] % 2 == 0) or (l[1] == l[2] and l[0] % 2 == 0):
			print('YES')
		else:
			print('NO')
solution()


n = int(input())
list2 = []
for i in range(n):
	flag = 0
	list1 = input().split()
	list1 = [int(x) for x in list1]
	if list1[0] == list1[1] and list1[2] % 2 == 0:
		flag = 1
	elif list1[0] == list1[2] and list1[1] % 2 == 0:
		flag = 1
	elif list1[1] == list1[2] and list1[0] % 2 == 0:
		flag = 1
	else:
		for i in list1:
			if 2 * i == list1[0] + list1[1] + list1[2]:
				flag = 1
	list2.append(flag)
for i in list2:
	if i == 1:
		print('YES')
	else:
		print('NO')


ans = []
t = int(input())
for lala in range(t):
	(l1, l2, l3) = input().split()
	l1 = int(l1)
	l2 = int(l2)
	l3 = int(l3)
	if l1 == l2 + l3 or l2 == l1 + l3 or l3 == l1 + l2 or (l1 == l2 and l3 % 2 == 0) or (l1 == l3 and l2 % 2 == 0) or (l3 == l2 and l1 % 2 == 0):
		ans.append('YES')
	else:
		ans.append('NO')
for x in ans:
	print(x)


import sys
testcases = int(input())
while testcases > 0:
	l = list(map(int, sys.stdin.readline().split()))
	l.sort()
	if l[0] == l[1]:
		if l[2] % 2 == 0:
			print('YES')
		else:
			print('NO')
	elif l[1] == l[2]:
		if l[0] % 2 == 0:
			print('YES')
		else:
			print('NO')
	elif l[2] == l[0] + l[1]:
		print('YES')
	else:
		print('NO')
	testcases -= 1


t = int(input())
for _ in range(t):
	(l1, l2, l3) = list(map(int, input().split()))
	if (l1 + l2 + l3) % 2 != 0:
		print('NO')
	elif [l1 % 2, l2 % 2, l3 % 2].count(0) == 3 and (l1 == l2 == l3 or (l1 == l2 or l2 == l3 or l3 == l1)):
		print('YES')
	elif [l1 % 2, l2 % 2, l3 % 2].count(1) == 2 and (l1 == l2 or l2 == l3 or l3 == l1):
		print('YES')
	elif l1 + l2 == l3 or l2 + l3 == l1 or l3 + l1 == l2:
		print('YES')
	else:
		print('NO')


def get_data_a():
	data = []
	t = int(input())
	for i in range(t):
		data.append([int(k) for k in input().split()])
	return data

def get_res_a(data):
	res = []
	for ls in data:
		l1 = ls[0]
		l2 = ls[1]
		l3 = ls[2]
		if l1 == l2 and l3 % 2 == 0 or (l1 == l3 and l2 % 2 == 0) or (l2 == l3 and l1 % 2 == 0):
			res.append('YES')
		elif l1 + l2 == l3 or l1 + l3 == l2 or l2 + l3 == l1:
			res.append('YES')
		else:
			res.append('NO')
	return res
d = get_data_a()
r = get_res_a(d)
for m in r:
	print(m)


t = int(input())
a = []
b = []
c = []
for i in range(t):
	(x, y, z) = map(int, input().split())
	a.append(x)
	b.append(y)
	c.append(z)
for i in range(t):
	if a[i] + b[i] == c[i]:
		print('YES')
	elif b[i] + c[i] == a[i]:
		print('YES')
	elif a[i] + c[i] == b[i]:
		print('YES')
	elif a[i] == b[i]:
		if c[i] % 2 == 0:
			print('YES')
		else:
			print('NO')
	elif a[i] == c[i]:
		if b[i] % 2 == 0:
			print('YES')
		else:
			print('NO')
	elif c[i] == b[i]:
		if a[i] % 2 == 0:
			print('YES')
		else:
			print('NO')
	else:
		print('NO')


from sys import stdin, stdout, setrecursionlimit
t = 1
t = int(stdin.readline())
for _ in range(t):
	l = list(map(int, stdin.readline().rstrip().split()))
	l.sort()
	if l[0] + l[1] == l[-1]:
		print('YES')
	else:
		if l[0] == l[1]:
			if l[-1] % 2 == 0:
				print('YES')
				continue
		if l[-1] == l[1]:
			if l[0] % 2 == 0:
				print('YES')
				continue
		print('NO')


t = int(input())
rec = []

def solve(lst):
	copy = lst
	for i in range(3):
		count = lst.count(lst[i])
		if count == 2:
			for j in copy:
				if j != lst[i]:
					if j % 2 == 0:
						return 'YES'
					else:
						return 'NO'
		if count == 3:
			if lst[i] % 2 == 0:
				return 'YES'
			else:
				return 'NO'
	for i in range(3):
		for j in range(3):
			if i != j:
				ele = lst[i] - copy[j]
				if ele > 0:
					if ele == lst[3 - i - j]:
						return 'YES'
	return 'NO'
for _ in range(t):
	lst = [int(i) for i in input().split()]
	rec.append(lst)
answer = []
for i in rec:
	ans = solve(i)
	answer.append(ans)
for i in answer:
	print(i)


from collections import Counter, defaultdict, deque
import bisect
from sys import stdin, stdout
from itertools import repeat
import math

def inp(force_list=False):
	re = list(map(int, input().split()))
	if len(re) == 1 and (not force_list):
		return re[0]
	return re

def inst():
	return input().strip()

def gcd(x, y):
	while y:
		(x, y) = (y, x % y)
	return x
MOD = 998244353

def query(a, b, c):
	print('! %d %d %d' % (a + 1, b + 1, c + 1))
	stdout.flush()
	return inp()

def solve():
	(n, k) = map(int, input().split())
	a = list(map(int, input().split()))
	a = sorted(a)
	cost = sum(a[0:n - 2 * k]) + sum(map(lambda x: a[x + n - 2 * k] // a[x + n - k], range(0, k)))
	print(cost)

def my_main():
	kase = inp()
	pans = []
	for _ in range(kase):
		da = inp()
		da.sort()
		if da[0] == da[1] and da[2] % 2 == 0:
			pans.append('YES')
		elif da[1] == da[2] and da[0] % 2 == 0:
			pans.append('YES')
		elif da[2] == da[1] + da[0]:
			pans.append('YES')
		else:
			pans.append('NO')
	print('\n'.join(pans))
my_main()


n = int(input())
ans = []
for i in range(n):
	b = list(input().split(' '))
	a = []
	for j in range(len(b)):
		a.append(int(b[j]))
	if a[0] + a[1] == a[2] or a[2] + a[1] == a[0] or a[2] + a[0] == a[1] or (a[0] == a[1] and a[2] % 2 == 0) or (a[2] == a[1] and a[0] % 2 == 0) or (a[2] == a[0] and a[1] % 2 == 0):
		ans.append('YES')
	else:
		ans.append('NO')
for i in range(n):
	print(ans[i])


for i in range(int(input())):
	arr = [int(x) for x in input().split()]
	arr.sort()
	a = arr[0]
	b = arr[1]
	c = arr[2]
	if c == a + b or (a == b and c % 2 == 0) or (b == c and a % 2 == 0) or (a == c and b % 2 == 0):
		print('YES')
	else:
		print('NO')


import sys

def get_int():
	return int(sys.stdin.readline())

def get_string():
	return sys.stdin.readline().strip()
FILE = False
if FILE:
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')
t = get_int()
for i in range(t):
	(a, b, c) = map(int, get_string().split())
	nums = list([a, b, c])
	if a - b - c == 0 or (b == c and a % 2 == 0):
		print('YES')
		continue
	if b - a - c == 0 or (a == c and b % 2 == 0):
		print('YES')
		continue
	if c - a - b == 0 or (a == b and c % 2 == 0):
		print('YES')
		continue
	print('NO')


t = int(input())
answer = []
for i in range(t):
	(l1, l2, l3) = map(int, input().split())
	if l1 == l2 == l3 and l1 % 2 == 0:
		answer.append('YES')
	elif l1 == l2 and l3 % 2 == 0 or (l1 == l3 and l2 % 2 == 0) or (l2 == l3 and l1 % 2 == 0):
		answer.append('YES')
	elif l1 + l2 == l3 or l2 + l3 == l1 or l1 + l3 == l2:
		answer.append('YES')
	else:
		answer.append('NO')
for k in range(t):
	print(answer[k])


n = int(input())
matrica = []
for i in range(0, n):
	matrica.append(list(map(int, input().split())))
for i in matrica:
	if i[0] == i[1] + i[2] or i[1] == i[0] + i[2] or i[2] == i[1] + i[0]:
		print('YES')
	elif i[0] == i[1] and i[2] % 2 == 0:
		print('YES')
	elif i[0] == i[2] and i[1] % 2 == 0:
		print('YES')
	elif i[2] == i[1] and i[0] % 2 == 0:
		print('YES')
	else:
		print('NO')


t = int(input())
for _ in range(t):
	a = list(map(int, input().split()))
	a.sort()
	if a[0] == a[1] and a[2] % 2 == 0 or (a[1] == a[2] and a[0] % 2 == 0):
		print('YES')
	elif a[0] + a[1] == a[2]:
		print('YES')
	else:
		print('NO')


for s in [*open(0)][1:]:
	(a, b, c) = sorted(map(int, s.split()))
	if a == b and c % 2 == 0 or (b == c and a % 2 == 0) or a + b == c:
		print('YES')
	else:
		print('NO')


import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
import math
from collections import Counter
from itertools import permutations
from itertools import combinations

def prob():
	l = [int(x) for x in input().split()]
	mx = max(l)
	if 2 * mx == sum(l):
		print('YES')
		return
	if sum(l) % 2 == 0:
		a = l[0]
		b = l[1]
		c = l[2]
		if a % 2 == 0 and b == c:
			print('YES')
		elif b % 2 == 0 and c == a:
			print('YES')
		elif c % 2 == 0 and b == a:
			print('YES')
		else:
			print('NO')
	else:
		print('NO')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
t = 1
t = int(input())
for _ in range(0, t):
	prob()


t = int(input())
ans = []
for i in range(t):
	(l1, l2, l3) = map(int, input().split())
	if l1 == l2 == l3:
		if l1 % 2 == 0:
			ans.append('YES')
		else:
			ans.append('NO')
	elif l1 == l2:
		if l3 % 2 == 0:
			ans.append('YES')
		else:
			ans.append('NO')
	elif l2 == l3:
		if l1 % 2 == 0:
			ans.append('YES')
		else:
			ans.append('NO')
	elif l1 == l3:
		if l2 % 2 == 0:
			ans.append('YES')
		else:
			ans.append('NO')
	elif max(l1, l2, l3) == l1 + l2 + l3 - max(l1, l2, l3):
		ans.append('YES')
	else:
		ans.append('NO')
ind = 0
while ind <= len(ans) - 1:
	print(ans[ind])
	ind = ind + 1


testcases = int(input())
for _ in range(testcases):
	(l1, l2, l3) = [int(i) for i in input().split()]
	d = {}
	for i in [l1, l2, l3]:
		if d.get(i) is None:
			d[i] = 1
		else:
			d[i] += 1
	if len(d.keys()) == 1:
		if l1 % 2 == 0:
			print('YES')
		else:
			print('NO')
	elif len(d.keys()) == 2:
		max_value = max(d, key=d.get)
		min_value = min(d, key=d.get)
		if min_value % 2 == 0:
			print('YES')
		else:
			print('NO')
	elif l1 == sum([l2, l3]) or l2 == sum([l1, l3]) or l3 == sum([l1, l2]):
		print('YES')
	else:
		print('NO')


m = []
for i in range(0, int(input())):
	(r, k, j) = map(int, input().split())
	if abs(r - k) == j or abs(r - j) == k or abs(k - j) == r:
		m.append('YES')
	elif r == k:
		if j % 2 == 0:
			m.append('YES')
		else:
			m.append('NO')
	elif j == k:
		if r % 2 == 0:
			m.append('YES')
		else:
			m.append('NO')
	elif r == j:
		if k % 2 == 0:
			m.append('YES')
		else:
			m.append('NO')
	else:
		m.append('NO')
for l in range(len(m)):
	print(m[l])


for i in range(int(input())):
	(l1, l2, l3) = map(int, input().split())
	flag = False
	if l1 + l2 == l3:
		flag = True
	elif l2 + l3 == l1:
		flag = True
	elif l1 + l3 == l2:
		flag = True
	elif l1 == l2 and l3 % 2 == 0:
		flag = True
	elif l2 == l3 and l1 % 2 == 0:
		flag = True
	elif l1 == l3 and l2 % 2 == 0:
		flag = True
	else:
		flag = False
	if flag == True:
		print('YES')
	else:
		print('NO')


n = int(input())
for i in range(n):
	(a, b, c) = map(int, input().split())
	if a == b and b == c:
		if a % 2 == 0:
			print('YES')
		else:
			print('NO')
	elif a == b and c % 2 == 0:
		print('YES')
	elif c == b and a % 2 == 0:
		print('YES')
	elif a == c and b % 2 == 0:
		print('YES')
	else:
		x = max(a, b, c)
		if a == x:
			if b + c == a:
				print('YES')
			else:
				print('NO')
		elif b == x:
			if a + c == b:
				print('YES')
			else:
				print('NO')
		elif b + a == c:
			print('YES')
		else:
			print('NO')


n = int(input())
for i in range(n):
	(a, b, c) = map(int, input().split())
	if a == b and b == c and (a == c):
		if a % 2 == 0:
			print('YES')
		else:
			print('NO')
	elif a == b or b == c or a == c:
		if a == b:
			if c % 2 == 0:
				print('YES')
			else:
				print('NO')
		if b == c:
			if a % 2 == 0:
				print('YES')
			else:
				print('NO')
		if a == c:
			if b % 2 == 0:
				print('YES')
			else:
				print('NO')
	else:
		l = [a, b, c]
		m = max(l) - min(l)
		l.remove(max(l))
		if m == max(l):
			print('YES')
		else:
			print('NO')


def solve():
	(l1, l2, l3) = map(int, input().split())
	m = max(l1, l2)
	m = max(m, l3)
	s = 0
	if l1 != m:
		s += l1
	if l2 != m:
		s += l2
	if l3 != m:
		s += l3
	if l1 == l2 == l3 and (l1 + l2 + l3) % 2 == 0:
		print('YES')
	elif l1 == l2 == l3 and (l1 + l2 + l3) % 2 != 0:
		print('NO')
	elif l1 == l2 and l3 % 2 == 0:
		print('YES')
	elif l1 == l3 and l2 % 2 == 0:
		print('YES')
	elif l2 == l3 and l1 % 2 == 0:
		print('YES')
	elif m == s:
		print('YES')
	else:
		print('NO')
t = int(input())
for i in range(t):
	solve()


def sticks(l):
	for i in range(3):
		if l[(i + 1) % 3] == l[(i + 2) % 3]:
			if l[i] % 2 == 0:
				return True
		elif l[i] == l[(i + 1) % 3] + l[(i + 2) % 3]:
			return True
	return False
n = int(input())
for i in range(n):
	l = list(map(int, input().strip().split()))
	op = sticks(l)
	if op == True:
		print('YES')
	else:
		print('NO')


n = int(input())

def make(n1, n2, n3):
	if n1 % 2 == 0:
		if n2 == n3:
			return True
	if n2 + n3 == n1:
		return True
	else:
		return False
while n > 0:
	n -= 1
	l = input().split(' ')
	(l1, l2, l3) = (int(l[0]), int(l[1]), int(l[2]))
	if make(l1, l2, l3) | make(l2, l1, l3) | make(l3, l2, l1):
		print('YES')
	else:
		print('NO')


def compair(same, diff):
	if diff % 2 == 0:
		return 'YES'
	return 'NO'

def answer():
	txt = input()
	ln = list(map(int, txt.split(' ')))
	ln.sort()
	(a, b, c) = ln
	if a == b:
		return compair(a, c)
	elif b == c:
		return compair(b, a)
	elif a + b == c:
		return 'YES'
	else:
		return 'NO'
t = int(input())
for i in range(t):
	print(answer())


import sys

def solve():
	inp = sys.stdin.readline
	(a, b, c) = map(int, inp().split())
	if a + b == c or a + c == b or b + c == a or (a == b and c % 2 == 0 and (c > 1)) or (a == c and b % 2 == 0 and (b > 1)) or (b == c and a % 2 == 0 and (a > 1)):
		print('YES')
	else:
		print('NO')

def main():
	for i in range(int(sys.stdin.readline())):
		solve()
main()


import os
import sys
from io import BytesIO, IOBase
import math
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
if os.path.exists('input.txt'):
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')
else:
	(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
	input = lambda : sys.stdin.readline().rstrip('\r\n')
for t in range(int(input())):
	inp = list(map(int, input().split()))
	inp.sort(reverse=True)
	if inp[0] == inp[1] + inp[2]:
		print('YES')
		continue
	if inp[0] == inp[1] and inp[2] % 2 == 0:
		print('YES')
		continue
	if inp[1] == inp[2] and inp[0] % 2 == 0:
		print('YES')
		continue
	print('NO')


t = int(input())
for _ in range(t):
	s = [int(i) for i in input().split()]
	s.sort()
	if s[-1] == s[0] + s[1]:
		print('YES')
	else:
		su = set(s)
		if len(su) < len(s):
			for i in s:
				if s.count(i) > 1:
					a = i
			s.remove(a)
			s.remove(a)
			b = s[0]
			if b % 2 == 0:
				print('YES')
			else:
				print('NO')
		else:
			print('NO')


from math import *
import sys
input = sys.stdin.readline

def inp():
	return int(input())

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

def insr():
	s = input()
	return list(s[:len(s) - 1])

def invr():
	return map(int, input().split())

class Solution:

	def __init__(self):
		self.ans = 0

	def check(self, k):
		if floor(k / 2) * 2 == k:
			return 'YES'
		return 'NO'

	def solve(self, arr):
		(a, b, c) = (arr[0], arr[1], arr[2])
		if a == b:
			return self.check(c)
		if b == c:
			return self.check(a)
		if a == c:
			return self.check(b)
		mx = max(a, b, c)
		if mx == a:
			if not a - b == c:
				return 'NO'
		if mx == b:
			if not b - a == c:
				return 'NO'
		if mx == c:
			if not c - b == a:
				return 'NO'
		return 'YES'
sol = Solution()
t = inp()
k = t
ans = []
while t:
	arr = inlt()
	ans.append(sol.solve(arr))
	t -= 1
for i in range(k):
	print(ans[i])


import sys
(n, *data) = [[int(x) for x in line.split()] for line in sys.stdin.read().strip().split('\n')]
for line in data:
	if abs(line[0] - line[1]) == line[2]:
		print('YES')
	elif abs(line[1] - line[2]) == line[0]:
		print('YES')
	elif abs(line[2] - line[0]) == line[1]:
		print('YES')
	elif line[0] == line[1] and line[2] % 2 == 0 or (line[1] == line[2] and line[0] % 2 == 0) or (line[2] == line[0] and line[1] % 2 == 0):
		print('YES')
	else:
		print('NO')


t = int(input())
for i in range(t):
	(a, b, c) = map(int, input().split())
	nums = sorted([a, b, c], reverse=True)
	if nums[0] == nums[1] + nums[2] or (nums[0] == nums[1] and nums[2] % 2 == 0) or (nums[2] == nums[1] and nums[0] % 2 == 0):
		print('YES')
	else:
		print('NO')


list1 = []
list2 = []
rawstickamount = input()
stickamount = int(rawstickamount)

def create_sticks(amount):
	i = 0
	for i in range(amount):
		list2 = [int(i) for i in input().split()]
		list1.append(list2[:])
		list2.clear()
create_sticks(stickamount)
index = 0
for i in range(len(list1)):
	r = 0
	isrect = 0
	while r < 3:
		if list1[index][0] + list1[index][1] == list1[index][2]:
			isrect = +1
		if list1[index][0] == list1[index][1]:
			if list1[index][2] % 2 == 0:
				isrect = +1
		list1[index].insert(0, list1[index].pop(-1))
		r += 1
	if isrect > 0:
		print('YES')
	else:
		print('NO')
	index += 1


def func():
	(x, y, z) = map(int, input().split())
	if x == y + z:
		return 'YES'
	elif y == x + z:
		return 'YES'
	elif z == x + y:
		return 'YES'
	elif x == y and z % 2 == 0:
		return 'YES'
	elif y == z and x % 2 == 0:
		return 'YES'
	elif z == x and y % 2 == 0:
		return 'YES'
	return 'NO'
t = int(input())
for i in range(t):
	print(func())


t = int(input())
for _ in range(t):
	(a, b, c) = map(int, input().split())
	li = [a, b, c]
	li.sort()
	if li[0] + li[1] == li[2]:
		print('YES')
	elif li[0] == li[1]:
		if li[2] % 2 == 0:
			print('YES')
		else:
			print('NO')
	elif li[1] == li[2]:
		if li[0] % 2 == 0:
			print('YES')
		else:
			print('NO')
	else:
		print('NO')


import heapq
import sys
import math
from collections import deque
from bisect import bisect_left, bisect_right
I = sys.stdin.readline
II = lambda : int(I())
IN = lambda x: map(int, x.split())
FN = lambda x: map(float, x.split())
L = lambda x: list(IN(x))
M = 1000000007
P = print
T = True
F = False
for _ in range(II()):
	l = L(I())
	l.sort()
	if l[2] == 1:
		print('NO')
		continue
	elif l[1] == 1:
		if l[2] & 1 == 0:
			print('YES')
		else:
			print('NO')
		continue
	elif l[0] == 1:
		if l[2] - l[1] == 1:
			print('YES')
		else:
			print('NO')
		continue
	if l[0] & 1 == 0 and l[1] == l[2]:
		print('YES')
		continue
	if l[0] == l[1] and l[2] & 1 == 0:
		print('YES')
		continue
	if l[0] + l[1] == l[2]:
		print('YES')
	else:
		print('NO')


t = int(input())
for _ in range(t):
	s = list(map(int, input().split()))
	a = min(s[0] * -1, s[1], s[2])
	b = min(s[0], s[1] * -1, s[2])
	c = min(s[0], s[1], s[2] * -1)
	if (c == a + b or b == a + c or a == b + c or (a == b and c % 2 == 0) or (c == b and a % 2 == 0) or (a == c and b % 2 == 0)) and (a < 0 and b < 0 and (c < 0)):
		print('YES')
	else:
		print('NO')


n = int(input())
for i in range(n):
	a = list((int(x) for x in input().split()))
	a.sort()
	if a[-1] == a[1] + a[0]:
		print('YES')
	elif a[0] == a[1]:
		if a[2] % 2 == 0:
			print('YES')
		else:
			print('NO')
	elif a[2] == a[1]:
		if a[0] % 2 == 0:
			print('YES')
		else:
			print('NO')
	else:
		print('NO')


for t in range(int(input())):
	(a, b, c) = map(int, input().split(' '))
	ans = False
	if b == a and c % 2 == 0 or (b == c and a % 2 == 0) or (a == c and b % 2 == 0):
		ans = True
	l = list(sorted([a, b, c]))
	if l[-1] == l[0] + l[1]:
		ans = True
	print('YES' if ans else 'NO')


import sys
import math
import heapq
INF = int(1000000000000000.0 + 1)
mod = 1000000007
read = sys.stdin.readline
sys.setrecursionlimit(10 ** 5)
dx = [0, 1, 0, -1]
dy = [-1, 0, 1, 0]
seg = []

def power(bottom, up):
	if up == 1:
		return bottom
	elif up == 0:
		return 1
	tmp = power(bottom, int(up // 2))
	if up % 2 == 0:
		return tmp * tmp
	else:
		return tmp * tmp * bottom

def modpower(bottom, up):
	print(bottom, up)
	if up == 1:
		return bottom
	elif up == 0:
		return 1
	tmp = power(bottom, int(up // 2))
	if up % 2 == 0:
		return tmp * tmp % mod
	else:
		return tmp * tmp * bottom % mod

def ccw(p1, p2, p3):
	a = p2[0] - p1[0]
	b = p2[1] - p1[1]
	c = p3[0] - p1[0]
	d = p3[1] - p1[1]
	tmp = a * d - b * c
	if tmp > 0:
		return 1
	elif tmp == 0:
		return 0
	else:
		return -1

def lower_bound(item):
	left = 0
	right = len(queue)
	while left < right:
		mid = int((left + right) // 2)
		if queue[mid] >= item:
			right = mid
		elif queue[mid] < item:
			left = mid + 1
	return int((left + right) // 2)

def make_seg(left, right, node):
	if left == right:
		seg[node] = arr[left - 1]
		return seg[node]
	mid = int((left + right) // 2)
	seg[node] = make_seg(left, mid, node * 2)
	seg[node] += make_seg(mid + 1, right, node * 2 + 1)
	return seg[node]

def seg_replace(left, right, node, index, diff):
	if index < left or index > right:
		return
	seg[node] += diff
	if left == right:
		return
	mid = (left + right) // 2
	seg_replace(left, mid, node * 2, index, diff)
	seg_replace(mid + 1, right, node * 2 + 1, index, diff)

def seg_sum(left, right, start, end, node):
	if start <= left and right <= end:
		return seg[node]
	if end < left or start > right:
		return 0
	mid = (left + right) // 2
	return seg_sum(left, mid, start, end, node * 2) + seg_sum(mid + 1, right, start, end, node * 2 + 1)

def lazy_seg_replace(left, right, node, start, end, diff):
	if seg_lazy[node] != 0:
		seg[node] += seg_lazy[node] * (right - left + 1)
		if left != right:
			seg_lazy[node * 2] += seg_lazy[node]
			seg_lazy[node * 2 + 1] += seg_lazy[node]
		seg_lazy[node] = 0
	if start <= left and right <= end:
		seg_lazy[node] += diff
		seg[node] += seg_lazy[node] * (right - left + 1)
		if left != right:
			seg_lazy[node * 2] += seg_lazy[node]
			seg_lazy[node * 2 + 1] += seg_lazy[node]
		seg_lazy[node] = 0
		return seg[node]
	if end < left or start > right:
		return seg[node]
	mid = (left + right) // 2
	seg[node] = lazy_seg_replace(left, mid, node * 2, start, end, diff)
	seg[node] += lazy_seg_replace(mid + 1, right, node * 2 + 1, start, end, diff)
	return seg[node]

def lazy_seg_sum(left, right, node, start, end):
	if seg_lazy[node] != 0:
		seg[node] += seg_lazy[node] * (right - left + 1)
		if left != right:
			seg_lazy[node * 2] += seg_lazy[node]
			seg_lazy[node * 2 + 1] += seg_lazy[node]
		seg_lazy[node] = 0
	if start <= left and right <= end:
		tmp = seg[node]
		seg[node] = 0
		return tmp
	if end < left or right < start:
		return 0
	mid = (left + right) // 2
	if mid >= end:
		tmp = lazy_seg_sum(left, mid, node * 2, start, end)
	else:
		tmp = lazy_seg_sum(mid + 1, right, node * 2 + 1, start, end)
	seg[node] -= tmp
	return tmp

def seg_index(left, right, node, idx):
	seg[node] -= 1
	if left == right:
		return left
	mid = (left + right) // 2
	if seg[node * 2] < idx:
		return seg_index(mid + 1, right, node * 2 + 1, idx - seg[node * 2])
	else:
		return seg_index(left, mid, node * 2, idx)
loop = int(read())
answer_li = []
for _ in range(loop):
	(first, second, third) = map(int, read().strip().split())
	if first == second and third % 2 == 0:
		answer_li.append('YES')
	elif first == third and second % 2 == 0:
		answer_li.append('YES')
	elif first % 2 == 0 and second == third:
		answer_li.append('YES')
	elif first + second == third:
		answer_li.append('YES')
	elif first + third == second:
		answer_li.append('YES')
	elif second + third == first:
		answer_li.append('YES')
	else:
		answer_li.append('NO')
print('\n'.join(map(str, answer_li)))


import sys
cases = int(sys.stdin.readline())
for _ in range(cases):
	length = [int(x) for x in sys.stdin.readline().split()]
	res = False
	for i in range(3):
		if length[i] == length[i - 1] + length[i - 2]:
			res = True
			break
	for i in range(3):
		if length[i] % 2 == 0 and length[i - 1] == length[i - 2]:
			res = True
			break
	print('YES' if res else 'NO')


def rect(l1, l2, l3):
	if l3 == l1:
		x = l2 // 2
		y = l2 - x
		if x == y:
			return True
	elif l2 == l3:
		x = l1 // 2
		y = l1 - x
		if x == y:
			return True
	elif l1 == l2:
		x = l3 // 2
		y = l3 - x
		if x == y:
			return True
	elif l2 + l3 == l1:
		return True
	elif l1 + l3 == l2:
		return True
	elif l1 + l2 == l3:
		return True
	else:
		return False
t = int(input())
for i in range(t):
	(l1, l2, l3) = map(int, input().split())
	x = rect(l1, l2, l3)
	if x == True:
		print('YES')
	else:
		print('NO')


for t in range(int(input())):
	(l1, l2, l3) = map(int, input().split())
	if l1 == l2 or l1 == l3 or l2 == l3:
		if l1 == l2 and (not l3 % 2):
			print('YES')
		elif l1 == l3 and (not l2 % 2):
			print('YES')
		elif l2 == l3 and (not l1 % 2):
			print('YES')
		else:
			print('NO')
	elif l1 == l2 + l3:
		print('YES')
	elif l2 == l1 + l3:
		print('YES')
	elif l3 == l1 + l2:
		print('YES')
	else:
		print('NO')


from math import ceil, log2, floor, sqrt, gcd
from collections import defaultdict, deque
from bisect import bisect_left
import sys
import os.path
from itertools import permutations
sys.setrecursionlimit(200000)
if os.path.exists('input.txt'):
	sys.stdin = open('input.txt', 'r+')
	sys.stdout = open('output.txt', 'w')

def MI():
	return map(int, input().split())
mod = 10 ** 9 + 7

def solve(testcase):
	a = list(MI())
	a.sort()
	if a[0] == a[1] and a[2] % 2 == 0:
		print('YES')
	elif a[1] == a[2] and a[0] % 2 == 0:
		print('YES')
	elif a[0] == a[2] and a[1] % 2 == 0:
		print('YES')
	elif a[0] + a[1] == a[2]:
		print('YES')
	else:
		print('NO')
t = int(input())
for _ in range(t):
	solve(_ + 1)


t = int(input())
for i in range(t):
	(a, b, c) = sorted(map(int, input().split()))
	if a + b == c or (a == b and c % 2 == 0) or (b == c and a % 2 == 0):
		print('YES')
	else:
		print('NO')


import sys
import io, os
import string
from io import BytesIO, IOBase
from os import path
from collections import Counter, OrderedDict
import itertools
from itertools import chain, combinations
import math
import random
import bisect
from functools import reduce
from sys import stdin, stdout
from math import gcd, floor, sqrt, log
from collections import defaultdict as dd
from bisect import bisect_left as bl, bisect_right as br
if path.exists('input.txt'):
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')
else:
	input = sys.stdin.readline
sys.setrecursionlimit(100000000)
simp = lambda : int(input())
strng = lambda : input().strip()
jn = lambda x, l: x.join(map(str, l))
strl = lambda : list(input().strip())
mul = lambda : map(int, input().strip().split())
mulf = lambda : map(float, input().strip().split())
seq = lambda : list(map(int, input().strip().split()))
ceil = lambda x: int(x) if x == int(x) else int(x) + 1
ceildiv = lambda x, d: x // d if x % d == 0 else x // d + 1
flush = lambda : stdout.flush()
stdstr = lambda : stdin.readline()
stdint = lambda : int(stdin.readline())
stdpr = lambda x: stdout.write(str(x))
n = simp()

def if_its_binaryform_palindrome(n):
	res = 0
	k = n
	while k > 0:
		res = res << 1 | k & 1
		k = k >> 1
	return n == res

def solve(d):
	(a, b, c) = (d[0], d[1], d[2])
	if a == b:
		if c & 1 == 0:
			return 'YES'
		return 'NO'
	elif b == c:
		if a & 1 == 0:
			return 'YES'
		return 'NO'
	elif a == c:
		if b & 1 == 0:
			return 'YES'
		return 'NO'
	if a + b == c or b + c == a or a + c == b:
		return 'YES'
	return 'NO'
for i in range(n):
	a = seq()
	print(solve(a))

def seive(n):
	prime = [1 for i in range(n + 1)]
	p = 2
	while p * p <= n:
		if prime[p] == 1:
			for i in range(p ** 2, n + 1, p):
				prime[i] = 0
		p += 1
	prime[0] = 0
	prime[1] = 0
	for i in range(1, n + 1):
		prime[i] += prime[i - 1]
	return prime

def list_of_prime_sieve(n):
	primes = [True] * (n + 1)
	primes[0] == primes[1] == False
	for i in range(2, int(n ** (1 / 2)) + 1):
		if primes[i] == True:
			for j in range(i * i, n + 1, i):
				primes[j] = False
	list_primes = []
	for i in range(2, len(primes)):
		if primes[i] == True:
			list_primes.append(i)
	return list_primes

def count_primes(a):
	return len(list_of_prime_sieve(a))

def gcdoftwo(a, b):
	if a == 0:
		return b
	else:
		return gcdoftwo(b % a, a)

def lcm(a, b):
	return a * b // gcdoftwo(a, b)

def gcdofList(A):
	res = A[0]
	for c in A[1:]:
		res = gcdoftwo(res, c)
		if res == 1:
			return res
	return res

def binpow(a, b):
	res = 1
	while b > 0:
		if b & 1:
			res = res * a
		a = a * a
		b >>= 1
	return res

def fibo_in_logn(n):
	if n == 0:
		return [0, 1]
	p = fibo_in_logn(n >> 1)
	c = p.first * (2 * p.second - p.first)
	d = p.first * p.first + p.second * p.second
	if n & 1:
		return {d, c + d}
	else:
		return {c, d}

def x_n_mod_m(a, b, m):
	a = a % m
	res = 1
	while b > 0:
		if b & 1:
			res = res * a % m
		a = a * a % m
		b >>= 1
	return res

def change_array(count, t):
	emp = []
	for i in range(len(t)):
		emp.append(count[t[i]])
	return emp

def simpleSieve(limit):
	mark = [True for i in range(limit + 1)]
	p = 2
	while p * p <= limit:
		if mark[p] == True:
			for i in range(p * p, limit + 1, p):
				mark[i] = False
		p += 1
	for p in range(2, limit):
		if mark[p]:
			prime.append(p)
	return prime

def segmentedSieve(n):
	limit = int(math.floor(math.sqrt(n)) + 1)
	t = []
	t += simpleSieve(limit)
	low = limit
	high = limit * 2
	while low < n:
		if high >= n:
			high = n
		mark = [True for i in range(limit + 1)]
		for i in range(len(prime)):
			loLim = int(math.floor(low / prime[i]) * prime[i])
			if loLim < low:
				loLim += prime[i]
			for j in range(loLim, high, prime[i]):
				mark[j - low] = False
		for i in range(low, high):
			if mark[i - low]:
				t.append(i)
		low = low + limit
		high = high + limit
	return t
mod = 1000000007

def occurrences(string, sub):
	count = start = 0
	while True:
		start = string.find(sub, start) + 1
		if start > 0:
			count += 1
		else:
			return count


t = int(input())
for i in range(t):
	arr = list(map(int, input().split()))
	l = sorted(arr)
	if l[0] + l[1] == l[2] or (l[0] == l[1] and l[2] % 2 == 0) or (l[1] == l[2] and l[0] % 2 == 0):
		print('YES')
	else:
		print('NO')


t = int(input())
while t != 0:
	s = [int(x) for x in input().split()]
	a = s[0]
	b = s[1]
	c = s[2]
	if a + b == c or b + c == a or c + a == b:
		print('YES')
	elif a == b and c % 2 == 0 or (b == c and a % 2 == 0) or (a == c and b % 2 == 0):
		print('YES')
	else:
		print('NO')
	t -= 1


def solve():
	t = int(input())
	numbers = []
	for i in range(t):
		inp = list(map(int, input().split()))
		numbers.append(inp)
	for num in numbers:
		(l1, l2, l3) = (num[0], num[1], num[2])
		if l1 == l2:
			if l3 % 2 == 0:
				print('YES')
			else:
				print('NO')
			continue
		elif l2 == l3:
			if l1 % 2 == 0:
				print('YES')
			else:
				print('NO')
			continue
		elif l1 == l3:
			if l2 % 2 == 0:
				print('YES')
			else:
				print('NO')
			continue
		if l1 + l2 == l3:
			print('YES')
		elif l2 + l3 == l1:
			print('YES')
		elif l3 + l1 == l2:
			print('YES')
		else:
			print('NO')
		continue
solve()


from __future__ import division, print_function
import math
import sys
import os
from io import BytesIO, IOBase
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')

def print(*args, **kwargs):
	(sep, file) = (kwargs.pop('sep', ' '), kwargs.pop('file', sys.stdout))
	at_start = True
	for x in args:
		if not at_start:
			file.write(sep)
		file.write(str(x))
		at_start = False
	file.write(kwargs.pop('end', '\n'))
	if kwargs.pop('flush', False):
		file.flush()
if sys.version_info[0] < 3:
	(sys.stdin, sys.stdout) = (FastIO(sys.stdin), FastIO(sys.stdout))
else:
	(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')

def I():
	return int(input())

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

def insr():
	s = input().strip()
	return list(s[:len(s)])

def invr():
	return map(int, input().split())
import itertools
from sys import maxsize, stdout, stdin, stderr
mod = int(1000000000.0 + 7)
import sys

def S():
	return list(map(str, input().strip()))

def grid(r, c):
	return [lint() for i in range(r)]
from collections import defaultdict, Counter, deque
import math
import heapq
from heapq import heappop, heappush
import bisect
from math import factorial, inf
from itertools import groupby
from itertools import permutations as comb
mod = 1000000007
MOD = 998244353

def gcd(a, b):
	while b:
		a %= b
		tmp = a
		a = b
		b = tmp
	return a

def lcm(a, b):
	return a // gcd(a, b) * b

def check_prime(n):
	for i in range(2, int(n ** (1 / 2)) + 1):
		if not n % i:
			return False
	return True

def primefactors(n):
	num = 0
	while n % 2 == 0:
		num += 1
		n = n / 2
	for i in range(3, int(math.sqrt(n)) + 1, 2):
		while n % i == 0:
			num += 1
			n = n // i
	if n > 2:
		num += 1
	return num

def ask(a, b, c):
	print(c, a, b, flush=True)
	n = I()
	return n

def linear_sieve(n):
	is_composite = [False] * n
	prime = []
	for i in range(2, n):
		if not is_composite[i]:
			prime.append(i)
		for j in prime:
			is_composite[i * j] = True
			if i % prime == 0:
				break
	return prime

def primeFactors(n):
	l = []
	while n % 2 == 0:
		l.append(2)
		n = n // 2
	for i in range(3, int(math.sqrt(n)) + 1, 2):
		while n % i == 0:
			l.append(i)
			n = n // i
	if n > 2:
		l.append(n)
	return l

def binpow(a, b, c):
	res = 1
	a = a % c
	while b > 0:
		if b & 1:
			res = res * a % c
		b = b >> 1
		a = a * a % c
	return res
d = []
primes = []
prim = [0] * (10 ** 5 + 1)

def sieve(n):
	for i in range(n):
		d.append(i)
	for i in range(2, n):
		if d[i] == i:
			prim[i] = 1
			primes.append(i)
		j = 0
		while j < len(primes) and primes[j] <= d[i] and (primes[j] * i < n):
			d[i * primes[j]] = primes[j]
			j += 1

def primeFactors(n):
	factors = []
	while n != 1:
		factors.append(d[n])
		n //= d[n]
	return factors
t = 1
t = I()
for _ in range(t):
	s = lint()
	s.sort()
	(a, b, c) = s
	if a + b == c:
		print('YES')
	elif a == b and c % 2 == 0:
		print('YES')
	elif b == c and a % 2 == 0:
		print('YES')
	else:
		print('NO')


for _ in range(int(input())):
	arr = sorted([int(a) for a in input().split()], reverse=True)
	(l1, l2, l3) = (arr[0], arr[1], arr[2])
	if l1 == l2 and l2 == l3 and (l1 % 2 == 0):
		print('YES')
	elif l2 == l3 and (not l1 % 2):
		print('YES')
	elif l1 == l2 and (not l3 % 2):
		print('YES')
	elif l1 == l2 + l3:
		print('YES')
	else:
		print('NO')


n = int(input())
for i in range(0, n):
	(l1, l2, l3) = map(int, input().split())
	maxx = max([l1, l2, l3])
	minn = min([l1, l2, l3])
	mid = l1 + l2 + l3 - maxx - minn
	if l1 != l2 and l2 != l3 and (l1 != l3):
		if maxx == minn + mid:
			print('YES')
			continue
	else:
		if l1 == l2:
			tmp = l3
			if tmp % 2 == 0:
				print('YES')
				continue
		if l1 == l3:
			tmp = l2
			if tmp % 2 == 0:
				print('YES')
				continue
		if l3 == l2:
			tmp = l1
			if tmp % 2 == 0:
				print('YES')
				continue
	print('NO')


from sys import stdin, stdout
input = stdin.readline

def output(answer):
	stdout.write('{}\n'.format(answer))
for _ in range(int(input())):
	arr = list(map(int, input().split()))
	arr.sort()
	flag = False
	if arr[2] == arr[1] + arr[0]:
		flag = True
	if arr[0] == arr[1] and arr[2] % 2 == 0:
		flag = True
	if arr[1] == arr[2] and arr[0] % 2 == 0:
		flag = True
	if flag:
		output('YES')
	else:
		output('NO')