description: 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.
solution: import sys
  # from abc import abstractmethod
  # from collections import deque
  import math
  # from typing import AnyStr 
  import heapq
  # import random
  # import copy
  # from decimal import Decimal
  # from collections import defaultdict
  # from typing import AnyStr
  
  INF = int(1e15 + 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):
      # 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)
      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):
      # print(left , right , 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
      # return lazy_seg_sum(left , mid , node * 2 , start , end) + lazy_seg_sum(mid + 1 , right , node * 2 + 1 , start,  end) 
          
  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())
  # li = list(map(int, read().strip().split()))
  
  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)))