import java.util.*;

public class Main {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		int[] x = new int[n];
		int[] y = new int[n];
		int[] t = new int[n];
		for(int i=0; i<n; i++) {
			t[i] = sc.nextInt(); x[i] = sc.nextInt(); y[i] = sc.nextInt();
		}
		int nowx = 0; int nowy = 0; int nowt = 0;
		for(int i=0; i<n; i++) {
			int d = Math.abs(nowx-x[i])+Math.abs(nowy-y[i]);
			int dt = t[i]-nowt;
			if(d<=dt && (d-dt)%2==0) {
				nowx = x[i]; nowy = y[i]; nowt = t[i];
			} else {
				System.out.println("No");
				return;
			}
		}
		System.out.println("Yes");
	}
	
	static int binarySearch(int[] A, int x) {
		int l = 0;
		int r = A.length;
		while(l<r) {
			int mid = (l+r)/2;
			if(A[mid] == x) return mid;
			else if(x<A[mid]) r = mid;
			else l = mid+1;
		}
		return -1;
	}
	
	static long upper_bound(int[] A, int b) {
		// bよりおおきい値がはじめて出てくるindexを返す
		return lower_bound(A, b+1);
	}

	static long lower_bound(int[] A, int b) {
		// b以上の値がはじめて出てくるindexを返す
		int lb=0;
		int ub=A.length;
		while(ub>lb) {
			int mid = (lb+ub)/2;
			if(A[mid]>=b) ub = mid;
			else lb = mid+1;
		}
		return lb;
	}
	
	// union find lib
	// usage:
	// 最初にinitを呼ぶ
	// root: 直接は呼ばないで
	// unite: まとめる
	// same: グループ判定
	static void init(int par[], int N) {
		for(int i=0; i<N; i++) {
			par[i] = i;
		}
	}
	
	static int root(int x, int [] par) {
		if(par[x] == x) {
			return x;
		} else {
			return (par[x] = root(par[x], par));
		}
	}
	
	static boolean same(int x, int y, int[] par) {
		return root(x, par) == root(y, par);
	}
	
	static void unite(int x, int y, int[] par) {
		x = root(x, par);
		y = root(y, par);
		if(x == y) return;
		par[x] = y;
	}
	
	// end union find lib
	
	// number lib
	
	static int max(int...ls) {
		int ans = Integer.MIN_VALUE;
		for(int i=0; i<ls.length; i++) {
			ans = Math.max(ans, ls[i]);
		}
		return ans;
	}
	
	static int min(int...ls) {
		int ans = Integer.MAX_VALUE;
		for(int i=0; i<ls.length; i++) {
			ans = Math.min(ans, ls[i]);
		}
		return ans;
	}
	
	static long lcm(long a, long b) {
		return a*(b/gcd(a, b));
	}
	
	static long gcd(long a, long b) {
		long ta = Math.max(a, b);
		long tb = Math.min(a, b);
		long tmp;
		while((tmp = ta%tb) != 0) {
			ta = tb;
			tb = tmp;
		}
		return tb;
	}
	
	static long modcomb(long n, long k, long mod) {
		if(k==1) {
			return n;
		}
		
		long ans = 1;
		for(long i=n; i>=n-k+1; i--) {
			ans = (ans * i)%mod;
		}
		for(long i=k; 0<i; i--) {
			ans = (ans * modpow(i, mod-2, mod)) % mod;
		}
		return ans;
	}
	
	static long modpow(long a, long b, long mod) {
		if(b==0) return 1;
		if(b%2==0) {
			long d = modpow(a, b/2, mod);
			return (d*d)%mod;
		} else {
			return (a*modpow(a, b-1, mod))%mod;
		}
	}
	
	static int disit(long a, long d) {
		int count = 0;
		while(a!=0) {
			a = a/d;
			count++;
		}
		return count;
	}
	
	// end number lib
} import java.util.*; util.* java public class Main {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		int[] x = new int[n];
		int[] y = new int[n];
		int[] t = new int[n];
		for(int i=0; i<n; i++) {
			t[i] = sc.nextInt(); x[i] = sc.nextInt(); y[i] = sc.nextInt();
		}
		int nowx = 0; int nowy = 0; int nowt = 0;
		for(int i=0; i<n; i++) {
			int d = Math.abs(nowx-x[i])+Math.abs(nowy-y[i]);
			int dt = t[i]-nowt;
			if(d<=dt && (d-dt)%2==0) {
				nowx = x[i]; nowy = y[i]; nowt = t[i];
			} else {
				System.out.println("No");
				return;
			}
		}
		System.out.println("Yes");
	}
	
	static int binarySearch(int[] A, int x) {
		int l = 0;
		int r = A.length;
		while(l<r) {
			int mid = (l+r)/2;
			if(A[mid] == x) return mid;
			else if(x<A[mid]) r = mid;
			else l = mid+1;
		}
		return -1;
	}
	
	static long upper_bound(int[] A, int b) {
		// bよりおおきい値がはじめて出てくるindexを返す
		return lower_bound(A, b+1);
	}

	static long lower_bound(int[] A, int b) {
		// b以上の値がはじめて出てくるindexを返す
		int lb=0;
		int ub=A.length;
		while(ub>lb) {
			int mid = (lb+ub)/2;
			if(A[mid]>=b) ub = mid;
			else lb = mid+1;
		}
		return lb;
	}
	
	// union find lib
	// usage:
	// 最初にinitを呼ぶ
	// root: 直接は呼ばないで
	// unite: まとめる
	// same: グループ判定
	static void init(int par[], int N) {
		for(int i=0; i<N; i++) {
			par[i] = i;
		}
	}
	
	static int root(int x, int [] par) {
		if(par[x] == x) {
			return x;
		} else {
			return (par[x] = root(par[x], par));
		}
	}
	
	static boolean same(int x, int y, int[] par) {
		return root(x, par) == root(y, par);
	}
	
	static void unite(int x, int y, int[] par) {
		x = root(x, par);
		y = root(y, par);
		if(x == y) return;
		par[x] = y;
	}
	
	// end union find lib
	
	// number lib
	
	static int max(int...ls) {
		int ans = Integer.MIN_VALUE;
		for(int i=0; i<ls.length; i++) {
			ans = Math.max(ans, ls[i]);
		}
		return ans;
	}
	
	static int min(int...ls) {
		int ans = Integer.MAX_VALUE;
		for(int i=0; i<ls.length; i++) {
			ans = Math.min(ans, ls[i]);
		}
		return ans;
	}
	
	static long lcm(long a, long b) {
		return a*(b/gcd(a, b));
	}
	
	static long gcd(long a, long b) {
		long ta = Math.max(a, b);
		long tb = Math.min(a, b);
		long tmp;
		while((tmp = ta%tb) != 0) {
			ta = tb;
			tb = tmp;
		}
		return tb;
	}
	
	static long modcomb(long n, long k, long mod) {
		if(k==1) {
			return n;
		}
		
		long ans = 1;
		for(long i=n; i>=n-k+1; i--) {
			ans = (ans * i)%mod;
		}
		for(long i=k; 0<i; i--) {
			ans = (ans * modpow(i, mod-2, mod)) % mod;
		}
		return ans;
	}
	
	static long modpow(long a, long b, long mod) {
		if(b==0) return 1;
		if(b%2==0) {
			long d = modpow(a, b/2, mod);
			return (d*d)%mod;
		} else {
			return (a*modpow(a, b-1, mod))%mod;
		}
	}
	
	static int disit(long a, long d) {
		int count = 0;
		while(a!=0) {
			a = a/d;
			count++;
		}
		return count;
	}
	
	// end number lib
} Main public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		int[] x = new int[n];
		int[] y = new int[n];
		int[] t = new int[n];
		for(int i=0; i<n; i++) {
			t[i] = sc.nextInt(); x[i] = sc.nextInt(); y[i] = sc.nextInt();
		}
		int nowx = 0; int nowy = 0; int nowt = 0;
		for(int i=0; i<n; i++) {
			int d = Math.abs(nowx-x[i])+Math.abs(nowy-y[i]);
			int dt = t[i]-nowt;
			if(d<=dt && (d-dt)%2==0) {
				nowx = x[i]; nowy = y[i]; nowt = t[i];
			} else {
				System.out.println("No");
				return;
			}
		}
		System.out.println("Yes");
	} main {
		// TODO Auto-generated method stub
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		int[] x = new int[n];
		int[] y = new int[n];
		int[] t = new int[n];
		for(int i=0; i<n; i++) {
			t[i] = sc.nextInt(); x[i] = sc.nextInt(); y[i] = sc.nextInt();
		}
		int nowx = 0; int nowy = 0; int nowt = 0;
		for(int i=0; i<n; i++) {
			int d = Math.abs(nowx-x[i])+Math.abs(nowy-y[i]);
			int dt = t[i]-nowt;
			if(d<=dt && (d-dt)%2==0) {
				nowx = x[i]; nowy = y[i]; nowt = t[i];
			} else {
				System.out.println("No");
				return;
			}
		}
		System.out.println("Yes");
	} Scanner sc = new Scanner(System.in); sc new Scanner(System.in) int n = sc.nextInt(); n sc.nextInt() sc.nextInt sc int[] x = new int[n]; x new int[n] n int[] y = new int[n]; y new int[n] n int[] t = new int[n]; t new int[n] n for(int i=0; i<n; i++) {
			t[i] = sc.nextInt(); x[i] = sc.nextInt(); y[i] = sc.nextInt();
		} int i=0; int i=0; i 0 i<n i n i++ i++ i {
			t[i] = sc.nextInt(); x[i] = sc.nextInt(); y[i] = sc.nextInt();
		} {
			t[i] = sc.nextInt(); x[i] = sc.nextInt(); y[i] = sc.nextInt();
		} t[i] = sc.nextInt() t[i] t i sc.nextInt() sc.nextInt sc x[i] = sc.nextInt() x[i] x i sc.nextInt() sc.nextInt sc y[i] = sc.nextInt() y[i] y i sc.nextInt() sc.nextInt sc int nowx = 0; nowx 0 int nowy = 0; nowy 0 int nowt = 0; nowt 0 for(int i=0; i<n; i++) {
			int d = Math.abs(nowx-x[i])+Math.abs(nowy-y[i]);
			int dt = t[i]-nowt;
			if(d<=dt && (d-dt)%2==0) {
				nowx = x[i]; nowy = y[i]; nowt = t[i];
			} else {
				System.out.println("No");
				return;
			}
		} int i=0; int i=0; i 0 i<n i n i++ i++ i {
			int d = Math.abs(nowx-x[i])+Math.abs(nowy-y[i]);
			int dt = t[i]-nowt;
			if(d<=dt && (d-dt)%2==0) {
				nowx = x[i]; nowy = y[i]; nowt = t[i];
			} else {
				System.out.println("No");
				return;
			}
		} {
			int d = Math.abs(nowx-x[i])+Math.abs(nowy-y[i]);
			int dt = t[i]-nowt;
			if(d<=dt && (d-dt)%2==0) {
				nowx = x[i]; nowy = y[i]; nowt = t[i];
			} else {
				System.out.println("No");
				return;
			}
		} int d = Math.abs(nowx-x[i])+Math.abs(nowy-y[i]); d Math.abs(nowx-x[i])+Math.abs(nowy-y[i]) Math.abs(nowx-x[i]) Math.abs Math nowx-x[i] nowx x[i] x i Math.abs(nowy-y[i]) Math.abs Math nowy-y[i] nowy y[i] y i int dt = t[i]-nowt; dt t[i]-nowt t[i] t i nowt if(d<=dt && (d-dt)%2==0) {
				nowx = x[i]; nowy = y[i]; nowt = t[i];
			} else {
				System.out.println("No");
				return;
			} d<=dt && (d-dt)%2==0 d<=dt d dt (d-dt)%2==0 (d-dt)%2 (d-dt) d dt 2 0 {
				nowx = x[i]; nowy = y[i]; nowt = t[i];
			} nowx = x[i] nowx x[i] x i nowy = y[i] nowy y[i] y i nowt = t[i] nowt t[i] t i {
				System.out.println("No");
				return;
			} System.out.println("No") System.out.println System.out System System.out "No" return; System.out.println("Yes") System.out.println System.out System System.out "Yes" String[] args args static int binarySearch(int[] A, int x) {
		int l = 0;
		int r = A.length;
		while(l<r) {
			int mid = (l+r)/2;
			if(A[mid] == x) return mid;
			else if(x<A[mid]) r = mid;
			else l = mid+1;
		}
		return -1;
	} binarySearch {
		int l = 0;
		int r = A.length;
		while(l<r) {
			int mid = (l+r)/2;
			if(A[mid] == x) return mid;
			else if(x<A[mid]) r = mid;
			else l = mid+1;
		}
		return -1;
	} int l = 0; l 0 int r = A.length; r A.length A A.length while(l<r) {
			int mid = (l+r)/2;
			if(A[mid] == x) return mid;
			else if(x<A[mid]) r = mid;
			else l = mid+1;
		} l<r l r {
			int mid = (l+r)/2;
			if(A[mid] == x) return mid;
			else if(x<A[mid]) r = mid;
			else l = mid+1;
		} int mid = (l+r)/2; mid (l+r)/2 (l+r) l r 2 if(A[mid] == x) return mid;
			else if(x<A[mid]) r = mid;
			else l = mid+1; A[mid] == x A[mid] A mid x return mid; mid if(x<A[mid]) r = mid;
			else l = mid+1; x<A[mid] x A[mid] A mid r = mid r mid l = mid+1 l mid+1 mid 1 return -1; -1 1 int[] A A int x x static long upper_bound(int[] A, int b) {
		// bよりおおきい値がはじめて出てくるindexを返す
		return lower_bound(A, b+1);
	} upper_bound {
		// bよりおおきい値がはじめて出てくるindexを返す
		return lower_bound(A, b+1);
	} return lower_bound(A, b+1); lower_bound(A, b+1) lower_bound A b+1 b 1 int[] A A int b b static long lower_bound(int[] A, int b) {
		// b以上の値がはじめて出てくるindexを返す
		int lb=0;
		int ub=A.length;
		while(ub>lb) {
			int mid = (lb+ub)/2;
			if(A[mid]>=b) ub = mid;
			else lb = mid+1;
		}
		return lb;
	} lower_bound {
		// b以上の値がはじめて出てくるindexを返す
		int lb=0;
		int ub=A.length;
		while(ub>lb) {
			int mid = (lb+ub)/2;
			if(A[mid]>=b) ub = mid;
			else lb = mid+1;
		}
		return lb;
	} int lb=0; lb 0 int ub=A.length; ub A.length A A.length while(ub>lb) {
			int mid = (lb+ub)/2;
			if(A[mid]>=b) ub = mid;
			else lb = mid+1;
		} ub>lb ub lb {
			int mid = (lb+ub)/2;
			if(A[mid]>=b) ub = mid;
			else lb = mid+1;
		} int mid = (lb+ub)/2; mid (lb+ub)/2 (lb+ub) lb ub 2 if(A[mid]>=b) ub = mid;
			else lb = mid+1; A[mid]>=b A[mid] A mid b ub = mid ub mid lb = mid+1 lb mid+1 mid 1 return lb; lb int[] A A int b b // union find lib
	// usage:
	// 最初にinitを呼ぶ
	// root: 直接は呼ばないで
	// unite: まとめる
	// same: グループ判定
	static void init(int par[], int N) {
		for(int i=0; i<N; i++) {
			par[i] = i;
		}
	} init {
		for(int i=0; i<N; i++) {
			par[i] = i;
		}
	} for(int i=0; i<N; i++) {
			par[i] = i;
		} int i=0; int i=0; i 0 i<N i N i++ i++ i {
			par[i] = i;
		} {
			par[i] = i;
		} par[i] = i par[i] par i i int par[] par int N N static int root(int x, int [] par) {
		if(par[x] == x) {
			return x;
		} else {
			return (par[x] = root(par[x], par));
		}
	} root {
		if(par[x] == x) {
			return x;
		} else {
			return (par[x] = root(par[x], par));
		}
	} if(par[x] == x) {
			return x;
		} else {
			return (par[x] = root(par[x], par));
		} par[x] == x par[x] par x x {
			return x;
		} return x; x {
			return (par[x] = root(par[x], par));
		} return (par[x] = root(par[x], par)); (par[x] = root(par[x], par)) par[x] par x root(par[x], par) root par[x] par x par int x x int [] par par static boolean same(int x, int y, int[] par) {
		return root(x, par) == root(y, par);
	} same {
		return root(x, par) == root(y, par);
	} return root(x, par) == root(y, par); root(x, par) == root(y, par) root(x, par) root x par root(y, par) root y par int x x int y y int[] par par static void unite(int x, int y, int[] par) {
		x = root(x, par);
		y = root(y, par);
		if(x == y) return;
		par[x] = y;
	} unite {
		x = root(x, par);
		y = root(y, par);
		if(x == y) return;
		par[x] = y;
	} x = root(x, par) x root(x, par) root x par y = root(y, par) y root(y, par) root y par if(x == y) return; x == y x y return; par[x] = y par[x] par x y int x x int y y int[] par par static int max(int...ls) {
		int ans = Integer.MIN_VALUE;
		for(int i=0; i<ls.length; i++) {
			ans = Math.max(ans, ls[i]);
		}
		return ans;
	} max {
		int ans = Integer.MIN_VALUE;
		for(int i=0; i<ls.length; i++) {
			ans = Math.max(ans, ls[i]);
		}
		return ans;
	} int ans = Integer.MIN_VALUE; ans Integer.MIN_VALUE Integer Integer.MIN_VALUE for(int i=0; i<ls.length; i++) {
			ans = Math.max(ans, ls[i]);
		} int i=0; int i=0; i 0 i<ls.length i ls.length ls ls.length i++ i++ i {
			ans = Math.max(ans, ls[i]);
		} {
			ans = Math.max(ans, ls[i]);
		} ans = Math.max(ans, ls[i]) ans Math.max(ans, ls[i]) Math.max Math ans ls[i] ls i return ans; ans int...ls ls static int min(int...ls) {
		int ans = Integer.MAX_VALUE;
		for(int i=0; i<ls.length; i++) {
			ans = Math.min(ans, ls[i]);
		}
		return ans;
	} min {
		int ans = Integer.MAX_VALUE;
		for(int i=0; i<ls.length; i++) {
			ans = Math.min(ans, ls[i]);
		}
		return ans;
	} int ans = Integer.MAX_VALUE; ans Integer.MAX_VALUE Integer Integer.MAX_VALUE for(int i=0; i<ls.length; i++) {
			ans = Math.min(ans, ls[i]);
		} int i=0; int i=0; i 0 i<ls.length i ls.length ls ls.length i++ i++ i {
			ans = Math.min(ans, ls[i]);
		} {
			ans = Math.min(ans, ls[i]);
		} ans = Math.min(ans, ls[i]) ans Math.min(ans, ls[i]) Math.min Math ans ls[i] ls i return ans; ans int...ls ls static long lcm(long a, long b) {
		return a*(b/gcd(a, b));
	} lcm {
		return a*(b/gcd(a, b));
	} return a*(b/gcd(a, b)); a*(b/gcd(a, b)) a (b/gcd(a, b)) b gcd(a, b) gcd a b long a a long b b static long gcd(long a, long b) {
		long ta = Math.max(a, b);
		long tb = Math.min(a, b);
		long tmp;
		while((tmp = ta%tb) != 0) {
			ta = tb;
			tb = tmp;
		}
		return tb;
	} gcd {
		long ta = Math.max(a, b);
		long tb = Math.min(a, b);
		long tmp;
		while((tmp = ta%tb) != 0) {
			ta = tb;
			tb = tmp;
		}
		return tb;
	} long ta = Math.max(a, b); ta Math.max(a, b) Math.max Math a b long tb = Math.min(a, b); tb Math.min(a, b) Math.min Math a b long tmp; tmp while((tmp = ta%tb) != 0) {
			ta = tb;
			tb = tmp;
		} (tmp = ta%tb) != 0 (tmp = ta%tb) tmp ta%tb ta tb 0 {
			ta = tb;
			tb = tmp;
		} ta = tb ta tb tb = tmp tb tmp return tb; tb long a a long b b static long modcomb(long n, long k, long mod) {
		if(k==1) {
			return n;
		}
		
		long ans = 1;
		for(long i=n; i>=n-k+1; i--) {
			ans = (ans * i)%mod;
		}
		for(long i=k; 0<i; i--) {
			ans = (ans * modpow(i, mod-2, mod)) % mod;
		}
		return ans;
	} modcomb {
		if(k==1) {
			return n;
		}
		
		long ans = 1;
		for(long i=n; i>=n-k+1; i--) {
			ans = (ans * i)%mod;
		}
		for(long i=k; 0<i; i--) {
			ans = (ans * modpow(i, mod-2, mod)) % mod;
		}
		return ans;
	} if(k==1) {
			return n;
		} k==1 k 1 {
			return n;
		} return n; n long ans = 1; ans 1 for(long i=n; i>=n-k+1; i--) {
			ans = (ans * i)%mod;
		} long i=n; long i=n; i n i>=n-k+1 i n-k+1 n-k n k 1 i-- i-- i {
			ans = (ans * i)%mod;
		} {
			ans = (ans * i)%mod;
		} ans = (ans * i)%mod ans (ans * i)%mod (ans * i) ans i mod for(long i=k; 0<i; i--) {
			ans = (ans * modpow(i, mod-2, mod)) % mod;
		} long i=k; long i=k; i k 0<i 0 i i-- i-- i {
			ans = (ans * modpow(i, mod-2, mod)) % mod;
		} {
			ans = (ans * modpow(i, mod-2, mod)) % mod;
		} ans = (ans * modpow(i, mod-2, mod)) % mod ans (ans * modpow(i, mod-2, mod)) % mod (ans * modpow(i, mod-2, mod)) ans modpow(i, mod-2, mod) modpow i mod-2 mod 2 mod mod return ans; ans long n n long k k long mod mod static long modpow(long a, long b, long mod) {
		if(b==0) return 1;
		if(b%2==0) {
			long d = modpow(a, b/2, mod);
			return (d*d)%mod;
		} else {
			return (a*modpow(a, b-1, mod))%mod;
		}
	} modpow {
		if(b==0) return 1;
		if(b%2==0) {
			long d = modpow(a, b/2, mod);
			return (d*d)%mod;
		} else {
			return (a*modpow(a, b-1, mod))%mod;
		}
	} if(b==0) return 1; b==0 b 0 return 1; 1 if(b%2==0) {
			long d = modpow(a, b/2, mod);
			return (d*d)%mod;
		} else {
			return (a*modpow(a, b-1, mod))%mod;
		} b%2==0 b%2 b 2 0 {
			long d = modpow(a, b/2, mod);
			return (d*d)%mod;
		} long d = modpow(a, b/2, mod); d modpow(a, b/2, mod) modpow a b/2 b 2 mod return (d*d)%mod; (d*d)%mod (d*d) d d mod {
			return (a*modpow(a, b-1, mod))%mod;
		} return (a*modpow(a, b-1, mod))%mod; (a*modpow(a, b-1, mod))%mod (a*modpow(a, b-1, mod)) a modpow(a, b-1, mod) modpow a b-1 b 1 mod mod long a a long b b long mod mod static int disit(long a, long d) {
		int count = 0;
		while(a!=0) {
			a = a/d;
			count++;
		}
		return count;
	} disit {
		int count = 0;
		while(a!=0) {
			a = a/d;
			count++;
		}
		return count;
	} int count = 0; count 0 while(a!=0) {
			a = a/d;
			count++;
		} a!=0 a 0 {
			a = a/d;
			count++;
		} a = a/d a a/d a d count++ count return count; count long a a long d d public class Main {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		int[] x = new int[n];
		int[] y = new int[n];
		int[] t = new int[n];
		for(int i=0; i<n; i++) {
			t[i] = sc.nextInt(); x[i] = sc.nextInt(); y[i] = sc.nextInt();
		}
		int nowx = 0; int nowy = 0; int nowt = 0;
		for(int i=0; i<n; i++) {
			int d = Math.abs(nowx-x[i])+Math.abs(nowy-y[i]);
			int dt = t[i]-nowt;
			if(d<=dt && (d-dt)%2==0) {
				nowx = x[i]; nowy = y[i]; nowt = t[i];
			} else {
				System.out.println("No");
				return;
			}
		}
		System.out.println("Yes");
	}
	
	static int binarySearch(int[] A, int x) {
		int l = 0;
		int r = A.length;
		while(l<r) {
			int mid = (l+r)/2;
			if(A[mid] == x) return mid;
			else if(x<A[mid]) r = mid;
			else l = mid+1;
		}
		return -1;
	}
	
	static long upper_bound(int[] A, int b) {
		// bよりおおきい値がはじめて出てくるindexを返す
		return lower_bound(A, b+1);
	}

	static long lower_bound(int[] A, int b) {
		// b以上の値がはじめて出てくるindexを返す
		int lb=0;
		int ub=A.length;
		while(ub>lb) {
			int mid = (lb+ub)/2;
			if(A[mid]>=b) ub = mid;
			else lb = mid+1;
		}
		return lb;
	}
	
	// union find lib
	// usage:
	// 最初にinitを呼ぶ
	// root: 直接は呼ばないで
	// unite: まとめる
	// same: グループ判定
	static void init(int par[], int N) {
		for(int i=0; i<N; i++) {
			par[i] = i;
		}
	}
	
	static int root(int x, int [] par) {
		if(par[x] == x) {
			return x;
		} else {
			return (par[x] = root(par[x], par));
		}
	}
	
	static boolean same(int x, int y, int[] par) {
		return root(x, par) == root(y, par);
	}
	
	static void unite(int x, int y, int[] par) {
		x = root(x, par);
		y = root(y, par);
		if(x == y) return;
		par[x] = y;
	}
	
	// end union find lib
	
	// number lib
	
	static int max(int...ls) {
		int ans = Integer.MIN_VALUE;
		for(int i=0; i<ls.length; i++) {
			ans = Math.max(ans, ls[i]);
		}
		return ans;
	}
	
	static int min(int...ls) {
		int ans = Integer.MAX_VALUE;
		for(int i=0; i<ls.length; i++) {
			ans = Math.min(ans, ls[i]);
		}
		return ans;
	}
	
	static long lcm(long a, long b) {
		return a*(b/gcd(a, b));
	}
	
	static long gcd(long a, long b) {
		long ta = Math.max(a, b);
		long tb = Math.min(a, b);
		long tmp;
		while((tmp = ta%tb) != 0) {
			ta = tb;
			tb = tmp;
		}
		return tb;
	}
	
	static long modcomb(long n, long k, long mod) {
		if(k==1) {
			return n;
		}
		
		long ans = 1;
		for(long i=n; i>=n-k+1; i--) {
			ans = (ans * i)%mod;
		}
		for(long i=k; 0<i; i--) {
			ans = (ans * modpow(i, mod-2, mod)) % mod;
		}
		return ans;
	}
	
	static long modpow(long a, long b, long mod) {
		if(b==0) return 1;
		if(b%2==0) {
			long d = modpow(a, b/2, mod);
			return (d*d)%mod;
		} else {
			return (a*modpow(a, b-1, mod))%mod;
		}
	}
	
	static int disit(long a, long d) {
		int count = 0;
		while(a!=0) {
			a = a/d;
			count++;
		}
		return count;
	}
	
	// end number lib
} public class Main {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		int[] x = new int[n];
		int[] y = new int[n];
		int[] t = new int[n];
		for(int i=0; i<n; i++) {
			t[i] = sc.nextInt(); x[i] = sc.nextInt(); y[i] = sc.nextInt();
		}
		int nowx = 0; int nowy = 0; int nowt = 0;
		for(int i=0; i<n; i++) {
			int d = Math.abs(nowx-x[i])+Math.abs(nowy-y[i]);
			int dt = t[i]-nowt;
			if(d<=dt && (d-dt)%2==0) {
				nowx = x[i]; nowy = y[i]; nowt = t[i];
			} else {
				System.out.println("No");
				return;
			}
		}
		System.out.println("Yes");
	}
	
	static int binarySearch(int[] A, int x) {
		int l = 0;
		int r = A.length;
		while(l<r) {
			int mid = (l+r)/2;
			if(A[mid] == x) return mid;
			else if(x<A[mid]) r = mid;
			else l = mid+1;
		}
		return -1;
	}
	
	static long upper_bound(int[] A, int b) {
		// bよりおおきい値がはじめて出てくるindexを返す
		return lower_bound(A, b+1);
	}

	static long lower_bound(int[] A, int b) {
		// b以上の値がはじめて出てくるindexを返す
		int lb=0;
		int ub=A.length;
		while(ub>lb) {
			int mid = (lb+ub)/2;
			if(A[mid]>=b) ub = mid;
			else lb = mid+1;
		}
		return lb;
	}
	
	// union find lib
	// usage:
	// 最初にinitを呼ぶ
	// root: 直接は呼ばないで
	// unite: まとめる
	// same: グループ判定
	static void init(int par[], int N) {
		for(int i=0; i<N; i++) {
			par[i] = i;
		}
	}
	
	static int root(int x, int [] par) {
		if(par[x] == x) {
			return x;
		} else {
			return (par[x] = root(par[x], par));
		}
	}
	
	static boolean same(int x, int y, int[] par) {
		return root(x, par) == root(y, par);
	}
	
	static void unite(int x, int y, int[] par) {
		x = root(x, par);
		y = root(y, par);
		if(x == y) return;
		par[x] = y;
	}
	
	// end union find lib
	
	// number lib
	
	static int max(int...ls) {
		int ans = Integer.MIN_VALUE;
		for(int i=0; i<ls.length; i++) {
			ans = Math.max(ans, ls[i]);
		}
		return ans;
	}
	
	static int min(int...ls) {
		int ans = Integer.MAX_VALUE;
		for(int i=0; i<ls.length; i++) {
			ans = Math.min(ans, ls[i]);
		}
		return ans;
	}
	
	static long lcm(long a, long b) {
		return a*(b/gcd(a, b));
	}
	
	static long gcd(long a, long b) {
		long ta = Math.max(a, b);
		long tb = Math.min(a, b);
		long tmp;
		while((tmp = ta%tb) != 0) {
			ta = tb;
			tb = tmp;
		}
		return tb;
	}
	
	static long modcomb(long n, long k, long mod) {
		if(k==1) {
			return n;
		}
		
		long ans = 1;
		for(long i=n; i>=n-k+1; i--) {
			ans = (ans * i)%mod;
		}
		for(long i=k; 0<i; i--) {
			ans = (ans * modpow(i, mod-2, mod)) % mod;
		}
		return ans;
	}
	
	static long modpow(long a, long b, long mod) {
		if(b==0) return 1;
		if(b%2==0) {
			long d = modpow(a, b/2, mod);
			return (d*d)%mod;
		} else {
			return (a*modpow(a, b-1, mod))%mod;
		}
	}
	
	static int disit(long a, long d) {
		int count = 0;
		while(a!=0) {
			a = a/d;
			count++;
		}
		return count;
	}
	
	// end number lib
} Main
import java.util.*;

public class Main {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		int[] x = new int[n];
		int[] y = new int[n];
		int[] t = new int[n];
		for(int i=0; i<n; i++) {
			t[i] = sc.nextInt(); x[i] = sc.nextInt(); y[i] = sc.nextInt();
		}
		int nowx = 0; int nowy = 0; int nowt = 0;
		for(int i=0; i<n; i++) {
			int d = Math.abs(nowx-x[i])+Math.abs(nowy-y[i]);
			int dt = t[i]-nowt;
			if(d<=dt && (d-dt)%2==0) {
				nowx = x[i]; nowy = y[i]; nowt = t[i];
			} else {
				System.out.println("No");
				return;
			}
		}
		System.out.println("Yes");
	}
	
	static int binarySearch(int[] A, int x) {
		int l = 0;
		int r = A.length;
		while(l<r) {
			int mid = (l+r)/2;
			if(A[mid] == x) return mid;
			else if(x<A[mid]) r = mid;
			else l = mid+1;
		}
		return -1;
	}
	
	static long upper_bound(int[] A, int b) {
		// bよりおおきい値がはじめて出てくるindexを返す
		return lower_bound(A, b+1);
	}

	static long lower_bound(int[] A, int b) {
		// b以上の値がはじめて出てくるindexを返す
		int lb=0;
		int ub=A.length;
		while(ub>lb) {
			int mid = (lb+ub)/2;
			if(A[mid]>=b) ub = mid;
			else lb = mid+1;
		}
		return lb;
	}
	
	// union find lib
	// usage:
	// 最初にinitを呼ぶ
	// root: 直接は呼ばないで
	// unite: まとめる
	// same: グループ判定
	static void init(int par[], int N) {
		for(int i=0; i<N; i++) {
			par[i] = i;
		}
	}
	
	static int root(int x, int [] par) {
		if(par[x] == x) {
			return x;
		} else {
			return (par[x] = root(par[x], par));
		}
	}
	
	static boolean same(int x, int y, int[] par) {
		return root(x, par) == root(y, par);
	}
	
	static void unite(int x, int y, int[] par) {
		x = root(x, par);
		y = root(y, par);
		if(x == y) return;
		par[x] = y;
	}
	
	// end union find lib
	
	// number lib
	
	static int max(int...ls) {
		int ans = Integer.MIN_VALUE;
		for(int i=0; i<ls.length; i++) {
			ans = Math.max(ans, ls[i]);
		}
		return ans;
	}
	
	static int min(int...ls) {
		int ans = Integer.MAX_VALUE;
		for(int i=0; i<ls.length; i++) {
			ans = Math.min(ans, ls[i]);
		}
		return ans;
	}
	
	static long lcm(long a, long b) {
		return a*(b/gcd(a, b));
	}
	
	static long gcd(long a, long b) {
		long ta = Math.max(a, b);
		long tb = Math.min(a, b);
		long tmp;
		while((tmp = ta%tb) != 0) {
			ta = tb;
			tb = tmp;
		}
		return tb;
	}
	
	static long modcomb(long n, long k, long mod) {
		if(k==1) {
			return n;
		}
		
		long ans = 1;
		for(long i=n; i>=n-k+1; i--) {
			ans = (ans * i)%mod;
		}
		for(long i=k; 0<i; i--) {
			ans = (ans * modpow(i, mod-2, mod)) % mod;
		}
		return ans;
	}
	
	static long modpow(long a, long b, long mod) {
		if(b==0) return 1;
		if(b%2==0) {
			long d = modpow(a, b/2, mod);
			return (d*d)%mod;
		} else {
			return (a*modpow(a, b-1, mod))%mod;
		}
	}
	
	static int disit(long a, long d) {
		int count = 0;
		while(a!=0) {
			a = a/d;
			count++;
		}
		return count;
	}
	
	// end number lib
}
