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

//done by varunmaddipati
//template credits : kal013 (https://codeforces.com/contest/1569/submission/128296960)
//comment optimisations for interactive problems (use endl)
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math,O3")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,fma")

#include "bits/stdc++.h"
#include "ext/pb_ds/assoc_container.hpp"
#include "ext/pb_ds/tree_policy.hpp"
using namespace __gnu_pbds;
using namespace std;

template<class T>
using ordered_set = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update> ;

template<class key, class value, class cmp = std::less<key>>
using ordered_map = tree<key, value, cmp, rb_tree_tag, tree_order_statistics_node_update>;
// find_by_order(k)  returns iterator to kth element starting from 0;
// order_of_key(k) returns count of elements strictly smaller than k;

template<class T>
using min_heap = priority_queue<T, vector<T>, greater<T> >;

//--------------------------------IO(Debugging)-----------------------------//
template<class T> istream& operator >> (istream &is, vector<T>& V) {
	for (auto &e : V)
		is >> e;
	return is;
}
template<class T, size_t N> istream& operator >> (istream &is, array<T, N>& V) {
	for (auto &e : V)
		is >> e;
	return is;
}
template<class T1, class T2> istream& operator >> (istream &is, pair<T1, T2>& V) {
	is >> V.first >> V.second;
	return is;
}
#ifdef __SIZEOF_INT128__
ostream& operator << (ostream &os, __int128 const& value) {
	static char buffer[64];
	int index = 0;
	__uint128_t T = (value < 0) ? (-(value + 1)) + __uint128_t(1) : value;
	if (value < 0)
		os << '-';
	else if (T == 0)
		return os << '0';
	for (; T > 0; ++index) {
		buffer[index] = static_cast<char>('0' + (T % 10));
		T /= 10;
	}
	while (index > 0)
		os << buffer[--index];
	return os;
}
istream& operator >> (istream& is, __int128& T) {
	static char buffer[64];
	is >> buffer;
	size_t len = strlen(buffer), index = 0;
	T = 0; int mul = 1;
	if (buffer[index] == '-')
		++index, mul *= -1;
	for (; index < len; ++index)
		T = T * 10 + static_cast<int>(buffer[index] - '0');
	T *= mul;
	return is;
}
#endif
template<typename CharT, typename Traits, typename T>
ostream& _containerprint(std::basic_ostream<CharT, Traits> &out, T const &val) {
	return (out << val << " ");
}
template<typename CharT, typename Traits, typename T1, typename T2>
ostream& _containerprint(std::basic_ostream<CharT, Traits> &out, pair<T1, T2> const &val) {
	return (out << "(" << val.first << "," << val.second << ") ");
}
template<typename CharT, typename Traits, template<typename, typename...> class TT, typename... Args>
ostream& operator << (std::basic_ostream<CharT, Traits> &out, TT<Args...> const &cont) {
	out << "[ ";
	for (auto && elem : cont) _containerprint(out, elem);
	return (out << "]");
}
template<class L, class R> ostream& operator << (ostream& out, pair<L, R> const &val) {
	return (out << "(" << val.first << "," << val.second << ") ");
}
template<typename L, size_t N> ostream& operator << (ostream& out, array<L, N> const &cont) {
	out << "[ ";
	for (auto && elem : cont) _containerprint(out, elem);
	return (out << "]");
}
template<class T> ostream& operator<<(ostream &out, ordered_set<T> const& S) {
	out << "{ ";
	for (const auto& s : S) out << s << " ";
	return (out << "}");
}
template<class L, class R, class chash = std::hash<L> > ostream & operator << (ostream &out, gp_hash_table<L, R, chash> const& M) {
	out << "{ ";
	for (const auto& m : M) out << "(" << m.first << ":" << m.second << ") ";
	return (out << "}");
}
template<class P, class Q = vector<P>, class R = less<P> > ostream & operator << (ostream& out, priority_queue<P, Q, R> const& M) {
	static priority_queue<P, Q, R> U;
	U = M;
	out << "{ ";
	while (!U.empty())
		out << U.top() << " ", U.pop();
	return (out << "}");
}
template<class P> ostream& operator << (ostream& out, queue<P> const& M) {
	static queue<P> U;
	U = M;
	out << "{ ";
	while (!U.empty())
		out << U.front() << " ", U.pop();
	return (out << "}");
}
#define TRACE
#ifdef TRACE
#define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
	cerr << name << " : " << arg1 << endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
	const char* comma = strchr(names + 1, ',');
	cerr.write(names, comma - names) << " : " << arg1 << " | ";
	__f(comma + 1, args...);
}
#else
#define trace(...) 1
#endif

//------------------------------------RNG-----------------------------------//
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
inline int64_t random_long(long long l = LLONG_MIN, long long r = LLONG_MAX) {
	uniform_int_distribution<int64_t> generator(l, r);
	return generator(rng);
}
struct custom_hash { // Credits: https://codeforces.com/blog/entry/62393
	static uint64_t splitmix64(uint64_t x) {
		// http://xorshift.di.unimi.it/splitmix64.c
		x += 0x9e3779b97f4a7c15;
		x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
		x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
		return x ^ (x >> 31);
	}
	size_t operator()(uint64_t x) const {
		static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count();
		return splitmix64(x + FIXED_RANDOM);
	}
	template<typename L, typename R>
	size_t operator()(pair<L, R> const& Y) const {
		static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count();
		return splitmix64(Y.first * 31ull + Y.second + FIXED_RANDOM);
	}
};

//------------------------------------Defines-------------------------------//
#define ll long long
#define ull unsigned long long
#define ld long double
// #define int long long
#define all(x) x.begin(), x.end()
#define getline_clear cin.ignore()
#define merge_arrays(a,b,c) merge(all(a),all(b),back_inserter(c))
#define sz(x) ((int)(x).size())
#define uid(a, b) uniform_int_distribution<int>(a, b)
#define pb push_back
#define eb emplace_back
#define F first
#define S second

//---------------------Global Constants and Functions-----------------------//
const int primesLength = 1e5 + 5;
vector<int> primes, lowestFactor(primesLength);

ll mPow(ll base, ll exp, ll MOD);
vector<int> randonPermutation(int n);
vector<string> readDataFromFile(string s);
vector<string> splitString(string s, char c);
void sieve(void);


//-----------------------------Code begins----------------------------------//

void testCase() {
	vector<int> v(3); cin>>v;
	sort(all(v));
	if(v[2]==v[1]+v[0] || (v[2]==v[1] && v[0]%2==0)) cout<<"YES\n";
	else cout<<"NO\n";
}

void preProcess() {
	return;
}

signed main() {
	ios_base::sync_with_stdio(false), cin.tie(NULL);

//#ifndef ONLINE_JUDGE
	//freopen("~/Downloads/cp/inp", "r", stdin);
	//freopen("~/Downloads/cp/outp", "w", stdout);
	//freopen("~/Downloads/cp/err", "w", stderr);
//#endif

	preProcess();

	int T = 1;
	cin >> T;
	for (int t = 1; t <= T; t++) {
		//cout << "Case #" << t << ": ";
		testCase();
	}
}

ll mPow(ll base, ll exponent, ll moduloNumber) {
	base %= moduloNumber;
	ll basePowerExponent = 1;
	while (exponent > 0) {
		if (exponent & 1) {
			basePowerExponent = (basePowerExponent * base) % moduloNumber;
		}
		base = (base * base) % moduloNumber;
		exponent >>= 1;
	}
	return basePowerExponent;
}

vector<int> randonPermutation(int permutationLength) {
	vector<int> permutation(permutationLength); iota(all(permutation), 1);
	for (int i = permutationLength - 1; i >= 0; i--) {
		int ind = rng() % (i + 1);
		swap(permutation[ind], permutation[i]);
	}
	return permutation;
}

void sieve(void) {
	iota(all(lowestFactor), 0);
	for (ll i = 2; i < primesLength; i++) {
		if (lowestFactor[i] == i) primes.pb(i);
		for (ll j = 0; j < (ll)primes.size() && i * primes[j] < primesLength; j++) {
			lowestFactor[i * primes[j]] = primes[j];
			if (i % primes[j] == 0) break;
		}
	}
}

vector<string> readDataFromFile(string fileName) {
	vector<string> fileData;
	string currentLine;
	ifstream inFile;
	inFile.open(fileName);
	while (getline(inFile, currentLine)) {
		fileData.push_back(currentLine);
	}
	return fileData;
}

vector<string> splitString(string currentLine, char delimeter) {
	vector<string> splitResult;
	stringstream inLine(currentLine);
	while (inLine.good()) {
		string currentWord;
		getline(inLine, currentWord, delimeter);
		splitResult.pb(currentWord);
	}
	return splitResult;
}
