import java.util.ArrayList;
import java.util.Scanner;

class location {
	int x;
	int y;
	int ti;

	public location(int x, int y, int ti) {
		this.x = x;
		this.y = y;
		this.ti = ti;
	}

	public void print_member_value() {
		System.out.println("ti:" + String.valueOf(this.ti) +",x:" + String.valueOf(this.x) + ", y:" + String.valueOf(this.y) );

	}

}


public class Main {

	public static void main(String[] args) {
		// TODO 自動生成されたメソッド・スタブ


		//input
		//	総step数N
		//	時刻tにおける位置(xi,yi)

		Scanner scan = new Scanner(System.in);
		ArrayList<location> points =  new ArrayList<location>();
		int N = scan.nextInt();

		location start_point = new location(0,0,0);
		points.add(start_point);

		for(int i = 0; i < N ; i ++) {
			int ti= scan.nextInt();
			int x = scan.nextInt();
			int y = scan.nextInt();

			location point = new location(x,y,ti);
			//point.print_member_value();
			points.add(point);

		}

		//logic
		//★①
		//		A.xiからxi+1へ行くには最低何step必要か求める
		//		B.yiからyi+1へ行くには最低何step必要か求める
		//		AとBの合計がNを超えたらまずアウト
		//		AとBの合計 = NならOK
		//		AとBの合計 < Nでも、行ったり来たりをしてstep数を稼げば問題ない
		//			ではデータも持ち方をどうするか
		//			→クラスのインスタンス化して、動的配列に順番に格納。インデックスの隣のインスタンス間を比較して、移動が可能かどうか判断
		//				→判断の途中、一つでも移動が不可能な場合があったらbreak

		//②tiの地点から、指定されたstep数で移動できる地点を全部洗いだして、目的の地点と比較して移動できるかどうか判断
		// →計算量が少なくない

		//③


		boolean possible = solve_1(points);


		//output
		//	step Nで、移動可能な範囲であるかどうかの判断結果

		if(possible) {
			System.out.println("Yes");
		}else {
			System.out.println("No");
		}

		//

	}

	public static boolean solve_1(ArrayList<location> points) {

		boolean possible = true;

		for(int j = 0; j < points.size()-1; j ++) {
			//debug pring
			//points.get(j).print_member_value();

			location pre_point = points.get(j);
			location next_point = points.get(j+1);

			int step = next_point.ti - pre_point.ti;
			int x_must_step = next_point.x - pre_point.x;
			int y_must_step = next_point.y - pre_point.y;

			int must_step = x_must_step + y_must_step;
			int surplus_step = step - must_step;

			if(must_step > step) {//1つでも、不可能な旅程が存在した時点で、「No」判定
				possible = false;
				break;
			}else if(must_step == step) {
				continue;
			}else if(must_step < step && (surplus_step % 2 == 0)){//同じ場所に行ったり来たりしてstep数を無駄に稼げばいける(但し、偶数ステップ数でないと、指定時間に元の位置に戻れない)
				continue;
			}else {
				possible = false;
				break;
			}


		}

		return possible;
	}

} import java.util.ArrayList; ArrayList java.util import java.util.Scanner; Scanner java.util class location {
	int x;
	int y;
	int ti;

	public location(int x, int y, int ti) {
		this.x = x;
		this.y = y;
		this.ti = ti;
	}

	public void print_member_value() {
		System.out.println("ti:" + String.valueOf(this.ti) +",x:" + String.valueOf(this.x) + ", y:" + String.valueOf(this.y) );

	}

} location int x; x int y; y int ti; ti public location(int x, int y, int ti) {
		this.x = x;
		this.y = y;
		this.ti = ti;
	} location {
		this.x = x;
		this.y = y;
		this.ti = ti;
	} this.x = x this.x this this.x x this.y = y this.y this this.y y this.ti = ti this.ti this this.ti ti int x x int y y int ti ti public void print_member_value() {
		System.out.println("ti:" + String.valueOf(this.ti) +",x:" + String.valueOf(this.x) + ", y:" + String.valueOf(this.y) );

	} print_member_value {
		System.out.println("ti:" + String.valueOf(this.ti) +",x:" + String.valueOf(this.x) + ", y:" + String.valueOf(this.y) );

	} System.out.println("ti:" + String.valueOf(this.ti) +",x:" + String.valueOf(this.x) + ", y:" + String.valueOf(this.y) ) System.out.println System.out System System.out "ti:" + String.valueOf(this.ti) +",x:" + String.valueOf(this.x) + ", y:" + String.valueOf(this.y) ", y:" String.valueOf(this.x) ",x:" "ti:" + String.valueOf(this.ti) +",x:" + String.valueOf(this.x) + ", y:" + String.valueOf(this.y) "ti:" String.valueOf(this.ti) String.valueOf String this.ti this this.ti ",x:" String.valueOf(this.x) String.valueOf String this.x this this.x ", y:" String.valueOf(this.y) String.valueOf String this.y this this.y public class Main {

	public static void main(String[] args) {
		// TODO 自動生成されたメソッド・スタブ


		//input
		//	総step数N
		//	時刻tにおける位置(xi,yi)

		Scanner scan = new Scanner(System.in);
		ArrayList<location> points =  new ArrayList<location>();
		int N = scan.nextInt();

		location start_point = new location(0,0,0);
		points.add(start_point);

		for(int i = 0; i < N ; i ++) {
			int ti= scan.nextInt();
			int x = scan.nextInt();
			int y = scan.nextInt();

			location point = new location(x,y,ti);
			//point.print_member_value();
			points.add(point);

		}

		//logic
		//★①
		//		A.xiからxi+1へ行くには最低何step必要か求める
		//		B.yiからyi+1へ行くには最低何step必要か求める
		//		AとBの合計がNを超えたらまずアウト
		//		AとBの合計 = NならOK
		//		AとBの合計 < Nでも、行ったり来たりをしてstep数を稼げば問題ない
		//			ではデータも持ち方をどうするか
		//			→クラスのインスタンス化して、動的配列に順番に格納。インデックスの隣のインスタンス間を比較して、移動が可能かどうか判断
		//				→判断の途中、一つでも移動が不可能な場合があったらbreak

		//②tiの地点から、指定されたstep数で移動できる地点を全部洗いだして、目的の地点と比較して移動できるかどうか判断
		// →計算量が少なくない

		//③


		boolean possible = solve_1(points);


		//output
		//	step Nで、移動可能な範囲であるかどうかの判断結果

		if(possible) {
			System.out.println("Yes");
		}else {
			System.out.println("No");
		}

		//

	}

	public static boolean solve_1(ArrayList<location> points) {

		boolean possible = true;

		for(int j = 0; j < points.size()-1; j ++) {
			//debug pring
			//points.get(j).print_member_value();

			location pre_point = points.get(j);
			location next_point = points.get(j+1);

			int step = next_point.ti - pre_point.ti;
			int x_must_step = next_point.x - pre_point.x;
			int y_must_step = next_point.y - pre_point.y;

			int must_step = x_must_step + y_must_step;
			int surplus_step = step - must_step;

			if(must_step > step) {//1つでも、不可能な旅程が存在した時点で、「No」判定
				possible = false;
				break;
			}else if(must_step == step) {
				continue;
			}else if(must_step < step && (surplus_step % 2 == 0)){//同じ場所に行ったり来たりしてstep数を無駄に稼げばいける(但し、偶数ステップ数でないと、指定時間に元の位置に戻れない)
				continue;
			}else {
				possible = false;
				break;
			}


		}

		return possible;
	}

} Main public static void main(String[] args) {
		// TODO 自動生成されたメソッド・スタブ


		//input
		//	総step数N
		//	時刻tにおける位置(xi,yi)

		Scanner scan = new Scanner(System.in);
		ArrayList<location> points =  new ArrayList<location>();
		int N = scan.nextInt();

		location start_point = new location(0,0,0);
		points.add(start_point);

		for(int i = 0; i < N ; i ++) {
			int ti= scan.nextInt();
			int x = scan.nextInt();
			int y = scan.nextInt();

			location point = new location(x,y,ti);
			//point.print_member_value();
			points.add(point);

		}

		//logic
		//★①
		//		A.xiからxi+1へ行くには最低何step必要か求める
		//		B.yiからyi+1へ行くには最低何step必要か求める
		//		AとBの合計がNを超えたらまずアウト
		//		AとBの合計 = NならOK
		//		AとBの合計 < Nでも、行ったり来たりをしてstep数を稼げば問題ない
		//			ではデータも持ち方をどうするか
		//			→クラスのインスタンス化して、動的配列に順番に格納。インデックスの隣のインスタンス間を比較して、移動が可能かどうか判断
		//				→判断の途中、一つでも移動が不可能な場合があったらbreak

		//②tiの地点から、指定されたstep数で移動できる地点を全部洗いだして、目的の地点と比較して移動できるかどうか判断
		// →計算量が少なくない

		//③


		boolean possible = solve_1(points);


		//output
		//	step Nで、移動可能な範囲であるかどうかの判断結果

		if(possible) {
			System.out.println("Yes");
		}else {
			System.out.println("No");
		}

		//

	} main {
		// TODO 自動生成されたメソッド・スタブ


		//input
		//	総step数N
		//	時刻tにおける位置(xi,yi)

		Scanner scan = new Scanner(System.in);
		ArrayList<location> points =  new ArrayList<location>();
		int N = scan.nextInt();

		location start_point = new location(0,0,0);
		points.add(start_point);

		for(int i = 0; i < N ; i ++) {
			int ti= scan.nextInt();
			int x = scan.nextInt();
			int y = scan.nextInt();

			location point = new location(x,y,ti);
			//point.print_member_value();
			points.add(point);

		}

		//logic
		//★①
		//		A.xiからxi+1へ行くには最低何step必要か求める
		//		B.yiからyi+1へ行くには最低何step必要か求める
		//		AとBの合計がNを超えたらまずアウト
		//		AとBの合計 = NならOK
		//		AとBの合計 < Nでも、行ったり来たりをしてstep数を稼げば問題ない
		//			ではデータも持ち方をどうするか
		//			→クラスのインスタンス化して、動的配列に順番に格納。インデックスの隣のインスタンス間を比較して、移動が可能かどうか判断
		//				→判断の途中、一つでも移動が不可能な場合があったらbreak

		//②tiの地点から、指定されたstep数で移動できる地点を全部洗いだして、目的の地点と比較して移動できるかどうか判断
		// →計算量が少なくない

		//③


		boolean possible = solve_1(points);


		//output
		//	step Nで、移動可能な範囲であるかどうかの判断結果

		if(possible) {
			System.out.println("Yes");
		}else {
			System.out.println("No");
		}

		//

	} Scanner scan = new Scanner(System.in); scan new Scanner(System.in) ArrayList<location> points =  new ArrayList<location>(); points new ArrayList<location>() int N = scan.nextInt(); N scan.nextInt() scan.nextInt scan location start_point = new location(0,0,0); start_point new location(0,0,0) points.add(start_point) points.add points start_point for(int i = 0; i < N ; i ++) {
			int ti= scan.nextInt();
			int x = scan.nextInt();
			int y = scan.nextInt();

			location point = new location(x,y,ti);
			//point.print_member_value();
			points.add(point);

		} int i = 0; int i = 0; i 0 i < N i N i ++ i ++ i {
			int ti= scan.nextInt();
			int x = scan.nextInt();
			int y = scan.nextInt();

			location point = new location(x,y,ti);
			//point.print_member_value();
			points.add(point);

		} {
			int ti= scan.nextInt();
			int x = scan.nextInt();
			int y = scan.nextInt();

			location point = new location(x,y,ti);
			//point.print_member_value();
			points.add(point);

		} int ti= scan.nextInt(); ti scan.nextInt() scan.nextInt scan int x = scan.nextInt(); x scan.nextInt() scan.nextInt scan int y = scan.nextInt(); y scan.nextInt() scan.nextInt scan location point = new location(x,y,ti); point new location(x,y,ti) points.add(point) points.add points point boolean possible = solve_1(points); possible solve_1(points) solve_1 points if(possible) {
			System.out.println("Yes");
		}else {
			System.out.println("No");
		} possible {
			System.out.println("Yes");
		} System.out.println("Yes") System.out.println System.out System System.out "Yes" {
			System.out.println("No");
		} System.out.println("No") System.out.println System.out System System.out "No" String[] args args public static boolean solve_1(ArrayList<location> points) {

		boolean possible = true;

		for(int j = 0; j < points.size()-1; j ++) {
			//debug pring
			//points.get(j).print_member_value();

			location pre_point = points.get(j);
			location next_point = points.get(j+1);

			int step = next_point.ti - pre_point.ti;
			int x_must_step = next_point.x - pre_point.x;
			int y_must_step = next_point.y - pre_point.y;

			int must_step = x_must_step + y_must_step;
			int surplus_step = step - must_step;

			if(must_step > step) {//1つでも、不可能な旅程が存在した時点で、「No」判定
				possible = false;
				break;
			}else if(must_step == step) {
				continue;
			}else if(must_step < step && (surplus_step % 2 == 0)){//同じ場所に行ったり来たりしてstep数を無駄に稼げばいける(但し、偶数ステップ数でないと、指定時間に元の位置に戻れない)
				continue;
			}else {
				possible = false;
				break;
			}


		}

		return possible;
	} solve_1 {

		boolean possible = true;

		for(int j = 0; j < points.size()-1; j ++) {
			//debug pring
			//points.get(j).print_member_value();

			location pre_point = points.get(j);
			location next_point = points.get(j+1);

			int step = next_point.ti - pre_point.ti;
			int x_must_step = next_point.x - pre_point.x;
			int y_must_step = next_point.y - pre_point.y;

			int must_step = x_must_step + y_must_step;
			int surplus_step = step - must_step;

			if(must_step > step) {//1つでも、不可能な旅程が存在した時点で、「No」判定
				possible = false;
				break;
			}else if(must_step == step) {
				continue;
			}else if(must_step < step && (surplus_step % 2 == 0)){//同じ場所に行ったり来たりしてstep数を無駄に稼げばいける(但し、偶数ステップ数でないと、指定時間に元の位置に戻れない)
				continue;
			}else {
				possible = false;
				break;
			}


		}

		return possible;
	} boolean possible = true; possible true for(int j = 0; j < points.size()-1; j ++) {
			//debug pring
			//points.get(j).print_member_value();

			location pre_point = points.get(j);
			location next_point = points.get(j+1);

			int step = next_point.ti - pre_point.ti;
			int x_must_step = next_point.x - pre_point.x;
			int y_must_step = next_point.y - pre_point.y;

			int must_step = x_must_step + y_must_step;
			int surplus_step = step - must_step;

			if(must_step > step) {//1つでも、不可能な旅程が存在した時点で、「No」判定
				possible = false;
				break;
			}else if(must_step == step) {
				continue;
			}else if(must_step < step && (surplus_step % 2 == 0)){//同じ場所に行ったり来たりしてstep数を無駄に稼げばいける(但し、偶数ステップ数でないと、指定時間に元の位置に戻れない)
				continue;
			}else {
				possible = false;
				break;
			}


		} int j = 0; int j = 0; j 0 j < points.size()-1 j points.size()-1 points.size() points.size points 1 j ++ j ++ j {
			//debug pring
			//points.get(j).print_member_value();

			location pre_point = points.get(j);
			location next_point = points.get(j+1);

			int step = next_point.ti - pre_point.ti;
			int x_must_step = next_point.x - pre_point.x;
			int y_must_step = next_point.y - pre_point.y;

			int must_step = x_must_step + y_must_step;
			int surplus_step = step - must_step;

			if(must_step > step) {//1つでも、不可能な旅程が存在した時点で、「No」判定
				possible = false;
				break;
			}else if(must_step == step) {
				continue;
			}else if(must_step < step && (surplus_step % 2 == 0)){//同じ場所に行ったり来たりしてstep数を無駄に稼げばいける(但し、偶数ステップ数でないと、指定時間に元の位置に戻れない)
				continue;
			}else {
				possible = false;
				break;
			}


		} {
			//debug pring
			//points.get(j).print_member_value();

			location pre_point = points.get(j);
			location next_point = points.get(j+1);

			int step = next_point.ti - pre_point.ti;
			int x_must_step = next_point.x - pre_point.x;
			int y_must_step = next_point.y - pre_point.y;

			int must_step = x_must_step + y_must_step;
			int surplus_step = step - must_step;

			if(must_step > step) {//1つでも、不可能な旅程が存在した時点で、「No」判定
				possible = false;
				break;
			}else if(must_step == step) {
				continue;
			}else if(must_step < step && (surplus_step % 2 == 0)){//同じ場所に行ったり来たりしてstep数を無駄に稼げばいける(但し、偶数ステップ数でないと、指定時間に元の位置に戻れない)
				continue;
			}else {
				possible = false;
				break;
			}


		} location pre_point = points.get(j); pre_point points.get(j) points.get points j location next_point = points.get(j+1); next_point points.get(j+1) points.get points j+1 j 1 int step = next_point.ti - pre_point.ti; step next_point.ti - pre_point.ti next_point.ti next_point next_point.ti pre_point.ti pre_point pre_point.ti int x_must_step = next_point.x - pre_point.x; x_must_step next_point.x - pre_point.x next_point.x next_point next_point.x pre_point.x pre_point pre_point.x int y_must_step = next_point.y - pre_point.y; y_must_step next_point.y - pre_point.y next_point.y next_point next_point.y pre_point.y pre_point pre_point.y int must_step = x_must_step + y_must_step; must_step x_must_step + y_must_step x_must_step y_must_step int surplus_step = step - must_step; surplus_step step - must_step step must_step if(must_step > step) {//1つでも、不可能な旅程が存在した時点で、「No」判定
				possible = false;
				break;
			}else if(must_step == step) {
				continue;
			}else if(must_step < step && (surplus_step % 2 == 0)){//同じ場所に行ったり来たりしてstep数を無駄に稼げばいける(但し、偶数ステップ数でないと、指定時間に元の位置に戻れない)
				continue;
			}else {
				possible = false;
				break;
			} must_step > step must_step step {//1つでも、不可能な旅程が存在した時点で、「No」判定
				possible = false;
				break;
			} possible = false possible false break; if(must_step == step) {
				continue;
			}else if(must_step < step && (surplus_step % 2 == 0)){//同じ場所に行ったり来たりしてstep数を無駄に稼げばいける(但し、偶数ステップ数でないと、指定時間に元の位置に戻れない)
				continue;
			}else {
				possible = false;
				break;
			} must_step == step must_step step {
				continue;
			} continue; if(must_step < step && (surplus_step % 2 == 0)){//同じ場所に行ったり来たりしてstep数を無駄に稼げばいける(但し、偶数ステップ数でないと、指定時間に元の位置に戻れない)
				continue;
			}else {
				possible = false;
				break;
			} must_step < step && (surplus_step % 2 == 0) must_step < step must_step step (surplus_step % 2 == 0) surplus_step % 2 surplus_step 2 0 {//同じ場所に行ったり来たりしてstep数を無駄に稼げばいける(但し、偶数ステップ数でないと、指定時間に元の位置に戻れない)
				continue;
			} continue; {
				possible = false;
				break;
			} possible = false possible false break; return possible; possible ArrayList<location> points points public class Main {

	public static void main(String[] args) {
		// TODO 自動生成されたメソッド・スタブ


		//input
		//	総step数N
		//	時刻tにおける位置(xi,yi)

		Scanner scan = new Scanner(System.in);
		ArrayList<location> points =  new ArrayList<location>();
		int N = scan.nextInt();

		location start_point = new location(0,0,0);
		points.add(start_point);

		for(int i = 0; i < N ; i ++) {
			int ti= scan.nextInt();
			int x = scan.nextInt();
			int y = scan.nextInt();

			location point = new location(x,y,ti);
			//point.print_member_value();
			points.add(point);

		}

		//logic
		//★①
		//		A.xiからxi+1へ行くには最低何step必要か求める
		//		B.yiからyi+1へ行くには最低何step必要か求める
		//		AとBの合計がNを超えたらまずアウト
		//		AとBの合計 = NならOK
		//		AとBの合計 < Nでも、行ったり来たりをしてstep数を稼げば問題ない
		//			ではデータも持ち方をどうするか
		//			→クラスのインスタンス化して、動的配列に順番に格納。インデックスの隣のインスタンス間を比較して、移動が可能かどうか判断
		//				→判断の途中、一つでも移動が不可能な場合があったらbreak

		//②tiの地点から、指定されたstep数で移動できる地点を全部洗いだして、目的の地点と比較して移動できるかどうか判断
		// →計算量が少なくない

		//③


		boolean possible = solve_1(points);


		//output
		//	step Nで、移動可能な範囲であるかどうかの判断結果

		if(possible) {
			System.out.println("Yes");
		}else {
			System.out.println("No");
		}

		//

	}

	public static boolean solve_1(ArrayList<location> points) {

		boolean possible = true;

		for(int j = 0; j < points.size()-1; j ++) {
			//debug pring
			//points.get(j).print_member_value();

			location pre_point = points.get(j);
			location next_point = points.get(j+1);

			int step = next_point.ti - pre_point.ti;
			int x_must_step = next_point.x - pre_point.x;
			int y_must_step = next_point.y - pre_point.y;

			int must_step = x_must_step + y_must_step;
			int surplus_step = step - must_step;

			if(must_step > step) {//1つでも、不可能な旅程が存在した時点で、「No」判定
				possible = false;
				break;
			}else if(must_step == step) {
				continue;
			}else if(must_step < step && (surplus_step % 2 == 0)){//同じ場所に行ったり来たりしてstep数を無駄に稼げばいける(但し、偶数ステップ数でないと、指定時間に元の位置に戻れない)
				continue;
			}else {
				possible = false;
				break;
			}


		}

		return possible;
	}

} public class Main {

	public static void main(String[] args) {
		// TODO 自動生成されたメソッド・スタブ


		//input
		//	総step数N
		//	時刻tにおける位置(xi,yi)

		Scanner scan = new Scanner(System.in);
		ArrayList<location> points =  new ArrayList<location>();
		int N = scan.nextInt();

		location start_point = new location(0,0,0);
		points.add(start_point);

		for(int i = 0; i < N ; i ++) {
			int ti= scan.nextInt();
			int x = scan.nextInt();
			int y = scan.nextInt();

			location point = new location(x,y,ti);
			//point.print_member_value();
			points.add(point);

		}

		//logic
		//★①
		//		A.xiからxi+1へ行くには最低何step必要か求める
		//		B.yiからyi+1へ行くには最低何step必要か求める
		//		AとBの合計がNを超えたらまずアウト
		//		AとBの合計 = NならOK
		//		AとBの合計 < Nでも、行ったり来たりをしてstep数を稼げば問題ない
		//			ではデータも持ち方をどうするか
		//			→クラスのインスタンス化して、動的配列に順番に格納。インデックスの隣のインスタンス間を比較して、移動が可能かどうか判断
		//				→判断の途中、一つでも移動が不可能な場合があったらbreak

		//②tiの地点から、指定されたstep数で移動できる地点を全部洗いだして、目的の地点と比較して移動できるかどうか判断
		// →計算量が少なくない

		//③


		boolean possible = solve_1(points);


		//output
		//	step Nで、移動可能な範囲であるかどうかの判断結果

		if(possible) {
			System.out.println("Yes");
		}else {
			System.out.println("No");
		}

		//

	}

	public static boolean solve_1(ArrayList<location> points) {

		boolean possible = true;

		for(int j = 0; j < points.size()-1; j ++) {
			//debug pring
			//points.get(j).print_member_value();

			location pre_point = points.get(j);
			location next_point = points.get(j+1);

			int step = next_point.ti - pre_point.ti;
			int x_must_step = next_point.x - pre_point.x;
			int y_must_step = next_point.y - pre_point.y;

			int must_step = x_must_step + y_must_step;
			int surplus_step = step - must_step;

			if(must_step > step) {//1つでも、不可能な旅程が存在した時点で、「No」判定
				possible = false;
				break;
			}else if(must_step == step) {
				continue;
			}else if(must_step < step && (surplus_step % 2 == 0)){//同じ場所に行ったり来たりしてstep数を無駄に稼げばいける(但し、偶数ステップ数でないと、指定時間に元の位置に戻れない)
				continue;
			}else {
				possible = false;
				break;
			}


		}

		return possible;
	}

} Main
import java.util.ArrayList;
import java.util.Scanner;

class location {
	int x;
	int y;
	int ti;

	public location(int x, int y, int ti) {
		this.x = x;
		this.y = y;
		this.ti = ti;
	}

	public void print_member_value() {
		System.out.println("ti:" + String.valueOf(this.ti) +",x:" + String.valueOf(this.x) + ", y:" + String.valueOf(this.y) );

	}

}


public class Main {

	public static void main(String[] args) {
		// TODO 自動生成されたメソッド・スタブ


		//input
		//	総step数N
		//	時刻tにおける位置(xi,yi)

		Scanner scan = new Scanner(System.in);
		ArrayList<location> points =  new ArrayList<location>();
		int N = scan.nextInt();

		location start_point = new location(0,0,0);
		points.add(start_point);

		for(int i = 0; i < N ; i ++) {
			int ti= scan.nextInt();
			int x = scan.nextInt();
			int y = scan.nextInt();

			location point = new location(x,y,ti);
			//point.print_member_value();
			points.add(point);

		}

		//logic
		//★①
		//		A.xiからxi+1へ行くには最低何step必要か求める
		//		B.yiからyi+1へ行くには最低何step必要か求める
		//		AとBの合計がNを超えたらまずアウト
		//		AとBの合計 = NならOK
		//		AとBの合計 < Nでも、行ったり来たりをしてstep数を稼げば問題ない
		//			ではデータも持ち方をどうするか
		//			→クラスのインスタンス化して、動的配列に順番に格納。インデックスの隣のインスタンス間を比較して、移動が可能かどうか判断
		//				→判断の途中、一つでも移動が不可能な場合があったらbreak

		//②tiの地点から、指定されたstep数で移動できる地点を全部洗いだして、目的の地点と比較して移動できるかどうか判断
		// →計算量が少なくない

		//③


		boolean possible = solve_1(points);


		//output
		//	step Nで、移動可能な範囲であるかどうかの判断結果

		if(possible) {
			System.out.println("Yes");
		}else {
			System.out.println("No");
		}

		//

	}

	public static boolean solve_1(ArrayList<location> points) {

		boolean possible = true;

		for(int j = 0; j < points.size()-1; j ++) {
			//debug pring
			//points.get(j).print_member_value();

			location pre_point = points.get(j);
			location next_point = points.get(j+1);

			int step = next_point.ti - pre_point.ti;
			int x_must_step = next_point.x - pre_point.x;
			int y_must_step = next_point.y - pre_point.y;

			int must_step = x_must_step + y_must_step;
			int surplus_step = step - must_step;

			if(must_step > step) {//1つでも、不可能な旅程が存在した時点で、「No」判定
				possible = false;
				break;
			}else if(must_step == step) {
				continue;
			}else if(must_step < step && (surplus_step % 2 == 0)){//同じ場所に行ったり来たりしてstep数を無駄に稼げばいける(但し、偶数ステップ数でないと、指定時間に元の位置に戻れない)
				continue;
			}else {
				possible = false;
				break;
			}


		}

		return possible;
	}

}
