Problem:
Score : 300 points

Problem Statement

AtCoDeer the deer is going on a trip in a two-dimensional plane.
In his plan, he will depart from point (0, 0) at time 0, then for each i between 1 and N (inclusive), he will visit point (x_i,y_i) at time t_i.

If AtCoDeer is at point (x, y) at time t, he can be at one of the following points at time t+1: (x+1,y), (x-1,y), (x,y+1) and (x,y-1).
Note that he cannot stay at his place.
Determine whether he can carry out his plan.

Constraints

1 ≤ N ≤ 10^5

0 ≤ x_i ≤ 10^5

0 ≤ y_i ≤ 10^5

1 ≤ t_i ≤ 10^5

t_i < t_{i+1} (1 ≤ i ≤ N-1)

All input values are integers.

Input

Input is given from Standard Input in the following format:

N
t_1 x_1 y_1
t_2 x_2 y_2
:
t_N x_N y_N

Output

If AtCoDeer can carry out his plan, print Yes; if he cannot, print No.

Sample Input 1

2
3 1 2
6 1 1

Sample Output 1

Yes

For example, he can travel as follows: (0,0), (0,1), (1,1), (1,2), (1,1), (1,0), then (1,1).

Sample Input 2

1
2 100 100

Sample Output 2

No

It is impossible to be at (100,100) two seconds after being at (0,0).

Sample Input 3

2
5 1 1
100 1 1

Sample Output 3

No

Solution in C++14 (GCC 5.4.1) (judge verdict: Time Limit Exceeded)

# include <bits/stdc++.h>
# define rep(i, n) for(int i=0, i##_len=(n); i<i##_len; ++i)
# define reps(i, n) for(int i=1, i##_len=(n); i<=i##_len; ++i)
# define rrep(i, n) for(int i=((int)(n)-1); i>=0; --i)
# define rreps(i, n) for(int i=((int)(n)); i>0; --i)
# define ALL(x) (x).begin(), (x).end()
# define SZ(x) ((int)(x).size())
# define pb push_back
# define optimize_cin() cin.tie(0); ios::sync_with_stdio(false)
using namespace std;
using lint = long long;
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }

struct Point
{
    Point() = default;
    Point(const Point& p)
        : x(p.x)
        , y(p.y)
    {
    }
    Point(int _x, int _y)
        : x(_x)
        , y(_y)
    {
    }

    Point move(int _dx, int _dy)
    {
        x += _dx;
        y += _dy;
        return *this;
    }

    Point right()
    {
        x += 1;
        return *this;
    }
    Point left()
    {
        x -= 1;
        return *this;
    }
    Point up()
    {
        y += 1;
        return *this;
    }
    Point down()
    {
        y -= 1;
        return *this;
    }

    Point operator -(const Point& other) const
    {
        return {x - other.x, y - other.y};
    }

    int x, y;
};

int main()
{
    optimize_cin();
    Point pos(0, 0);
    int N;
    vector<int> t;
    vector<Point> targets;

    cin >> N;
    t.resize(N);
    targets.resize(N);
    rep (i, N) { cin >> t[i] >> targets[i].x >> targets[i].y; }

    bool can = false;

    rep (i, N)
    {
        int cnt = 0;
        Point dp = targets[i] - pos;
        cnt = abs(dp.x) + abs(dp.y);
        while (cnt < t[i])
        {
            cnt += 2;
        }
        if (cnt == t[i])
        {
            can = true;
            pos = targets[i];
            for (int k = i; k < N - 1; ++k)
            {
                t[k+1] -= t[i];
            }
        }
        else
        {
            can = false;
            break;
        }
    }

    cout << (can ? "Yes" : "No") << "\n";

    return 0;
}