#include <bits/stdc++.h>
using namespace std;

namespace bread {

struct Unionfind {
    vector<int> p;
    explicit Unionfind(int n) : p(n, -1) {}
    int root(int x) {if(p[x] < 0) return x; return p[x] = root(p[x]);} 
    bool same(int x, int y) {return root(x) == root(y);}
    int size(int x) {return -p[root(x)];}
    bool unite(int x, int y) {x = root(x), y = root(y); if(x == y) return 0;
        if(p[x] > p[y]) swap(x, y); p[x] += p[y], p[y] = x; return 1;}
};

template<class T> struct fenwick_tree {
    int N; vector<T> v; 
    explicit fenwick_tree(int n) : N(n), v(N + 1, T{}) {}
    void add(int p, T x) {assert(0 <= p && p < N); for(++p; p <= N; p += p & -p) v[p] += x;}
    T sum(int p) const {T s{}; for(; p > 0; p -= p & -p) s += v[p]; return s;}
    T sum(int l, int r) const {assert(0 <= l && l <= r && r <= N); return sum(r) - sum(l);}
};

template<class T, auto op, auto e> struct segtree {
    int N; vector<T> v;
    explicit segtree(int n, T x) : N(n), v(N * 2, x) {}
    explicit segtree(const vector<T> &vec) : N(vec.size()), v(N * 2, e()) {
        for(int i = 0; i < N; ++i) v[N + i] = vec[i]; for(int i = N; --i;) v[i] = op(v[i * 2], v[i * 2 + 1]);}
    void set(int i, T x) {assert(0 <= i && i < N); for(v[i += N] = x; i > 1; i /= 2) v[i / 2] = op(v[i & ~1], v[i | 1]);}
    const T& operator[](int i) const {assert(0 <= i && i < N); return v[N + i];}
    T prod(int l, int r) const {assert(0 <= l && l <= r && r <= N); T L = e(), R = e();
        for(l += N, r += N; l < r; l *= 2, r *= 2) {if(l & 1) L = op(L, v[l++]); if(r & 1) R = op(v[--r], R);} return op(L, R);}
};

struct mint {
    inline static int64_t mod = 998244353;
    mint() : v(0) {}
    mint(int64_t val) {v = val % mod; if(v < 0) v += mod;}
    mint& operator+=(const mint& r) {v += r.v; if(v >= mod) v -= mod; return *this;}
    mint& operator-=(const mint& r) {v -= r.v; if(v < 0) v += mod; return *this;}
    mint& operator*=(const mint& r) {v = v * r.v % mod; return *this;}
    mint& operator/=(const mint& r) {return *this *= r.inv();}
    mint operator-() const {return mint() - *this;}
    mint pow(int64_t n) const {assert(0 <= n); mint x = v, r = 1; while(n) {if(n & 1) r *= x; x *= x; n /= 2;} return r;}
    mint inv() const {assert(v); return pow(mod - 2);}
    friend mint operator+(const mint& l, const mint& r) {return mint(l) += r;}
    friend mint operator-(const mint& l, const mint& r) {return mint(l) -= r;}
    friend mint operator*(const mint& l, const mint& r) {return mint(l) *= r;}
    friend mint operator/(const mint& l, const mint& r) {return mint(l) /= r;}
    friend bool operator==(const mint& l, const mint& r) {return l.v == r.v;}
    friend bool operator!=(const mint& l, const mint& r) {return l.v != r.v;}
    friend bool operator<(const mint& l, const mint& r) {return l.v < r.v;}
    friend istream& operator>>(istream& is, mint& x) {int64_t v; is >> v; x = mint(v); return is;}
    friend ostream& operator<<(ostream& os, const mint& x) {return os << x.v;}
    private: int64_t v;
};

struct com_calc {
    int siz; vector<mint> fac, inv, finv;
    com_calc(int N) : siz(N), fac(siz + 1), inv(siz + 1), finv(siz + 1) {
        fac[0] = fac[1] = inv[1] = finv[0] = finv[1] = 1; for(int i = 2; i <= siz; ++i) 
        fac[i] = fac[i - 1] * i, inv[i] = -inv[mint::mod % i] * (mint::mod / i), finv[i] = finv[i - 1] * inv[i];}
    mint operator()(const int n, const int k) const {
        if(n < 0 or k < 0 or n < k) return 0;
        assert(n <= siz); return fac[n] * finv[k] * finv[n - k];}
};

} using namespace bread;

#include <atcoder/all>
using namespace atcoder;

#define int long long
#define rep(i, n) for(int i = 0; i < (int)(n); ++i)

const int M = 60;
bool dp[M + 5][M + 5][M + 5];

int solve() {
    int A, B, C;
    cin >> A >> B >> C;
    
    A %= M, B %= M, C %= M;
    cout << (dp[A][B][C] ? "Yes" : "No") << "\n";
    
    return 0;
}

signed main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    cout.tie(nullptr);
    
    dp[0][0][0] = 1;
    rep(i, M) rep(j, M) rep(k, M) if(dp[i][j][k]) {
    	dp[i + 1][j + 1][k + 1] = 1;
    	dp[i][j + 2][k + 1] = 1;
    	dp[i + 2][j][k + 1] = 1;
    	dp[i + 2][j][k] = 1;
    	dp[i][j + 2][k] = 1;
    	dp[i][j][k + 2] = 1;
    }
    
    int Testcases = 1;
    cin >> Testcases;
    while(Testcases--) if(solve()) return 1;
    
    return 0;
}