jiahuimbzuai/CoQuIR huggingface dataset:
//  [java]
import java.util.*; 
public class Main {

	public static void main(String[] args) {
		Scanner sc=new Scanner(System.in);
		int a=sc.nextInt(), b=sc.nextInt(); 
		if(a==0 || b==0 || a*b<0) System.out.println("Zero");
		else if(a>0 && b>0) System.out.println("Positive");
		else System.out.println(((b-a+1)%2==0)?"Positive":"Negative");
		sc.close(); 
	}

}
//  [java]
import java.util.*; 
public class Main {

	public static void main(String[] args) {
		Scanner sc=new Scanner(System.in);
		int a=sc.nextInt(), b=sc.nextInt(); 
		if(a*b<=0) System.out.println("Zero");
		else if(a>0 && b>0) System.out.println("Positive");
		else System.out.println(((b-a+1)%2==0)?"Positive":"Negative");
		sc.close(); 
	}

}
//  [java]
import java.util.*;
public class Main {
    
    static Set<Integer> m = new HashSet<Integer>();
    static void solve(){
        Scanner sc = new Scanner(System.in);
        sc.nextInt(); int NOC = sc.nextInt(), count=0;
        m.add(1);
        while (NOC-->0) {
            int s = sc.nextInt(), e = sc.nextInt();
            if(m.contains(s)) {
                if(s==1) m.remove(1); // Special case   
                if(!m.contains(e)) m.add(e);
                else m.remove(s);
            }
        }
        System.out.println(m.size());
        sc.close();
    }
  
    public static void main(String args[]) {
        solve();
    }

}
//  [cpp]
#include <cstdio>
#include <cmath>

int main() {
    long long a, b;
    int result;
    scanf("%lld %lld", &a, &b);
    if (a <= 0 && b >= 0)
        puts("Zero");
    else if (a > 0)
        puts("Positive");
    else {
        if ((b - a + 1) % 2LL == 0)
            puts("Positive");
        else
            puts("Negative");
    }
    return 0;
}
//  [cpp]
#include<cstdio>
#include<algorithm>
using namespace std;
int main(void)
{
	long long int a,b;
	while(scanf("%lld%lld",&a,&b)!=EOF)
	{
		if(a>0&&b>0)
		printf("Positive\n");
		else if(a<0&&b>0)
		printf("Zero\n");
		else if(a==0||b==0)
		printf("Zero\n");
		else  if(a<0&&b<0)
		{
			if((b-a+1)%2==0)
			printf("Positive\n");
			else
			printf("Negative\n");
		}
		
	}
	return 0;
}
//  [cpp]
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;

int a,b;

int main()
{
	scanf("%d %d",&a,&b);
	if(a<=0 && b>=0)
		puts("Zero");
	else if(a>0 && b>0)
		puts("Positive");
	else
		puts((b-a)&1?"Positive":"Negative");
	return 0;
}
//  [cpp]
#include <bits/stdc++.h>

#define rep(i,a,n) for (int i=a;i<=n;i++)
#define per(i,a,n) for (int i=n;i>=a;i--)
#define vi vector<int>
#define pii pair<int,int>
#define pb push_back
#define mp make_pair
#define eb emplace_back
#define all(x) (x).begin(),(x).end()
#define fi first
#define se second
#define sz(x) ((int)(x).size())
#define mod(x) ((x)%MOD)
#define o(X) (1<<(X))
#define oL(X) (1LL<<(X))
#define LL long long
#define ppt(x) __builtin_popcount(x)
using namespace std;
const int INF=0x3f3f3f3f,N=1e6+5,MOD=1e9+7;
const LL INF_LL=0x3f3f3f3f3f3f3f3fLL;

template<typename T>
inline int getplc(T x,int y) { return (x>>y)&1; }
template<typename T>
T square(T x) {return x*x;}

LL qpow(LL a,LL b=MOD-2,LL _MOD=MOD){
	LL res=1;
	for(;b;b>>=1,a=a*a%_MOD){
		if(b&1)res=res*a%_MOD;
	}
	return res;
}

template <typename T>
T Smax(T x) { return x; }
template<typename T, typename... Args>
T Smax(T a, Args... args) {
	return max(a, Smax(args...));
}
template <typename T>
T Smin(T x) { return x; }
template<typename T, typename... Args>
T Smin(T a, Args... args) {
	return min(a, Smin(args...));
}

template <typename T>
#define errorl(args...) {  \
	string _s = #args;   \
	replace(_s.begin(), _s.end(), ',', ' ');  \
    stringstream _ss(_s);  \
    istream_iterator<string> _it(_ss);  \
    errl(_it, args);  \
}
void errl(istream_iterator<string> it) {}
template<typename T, typename... Args>
void errl(istream_iterator<string> it, T a, Args... args) {
	cerr << *it << " = " << a << endl;
	errl(++it, args...);
}
#define error(args...) {  \
    string _s = #args;  \
    replace(_s.begin(), _s.end(), ',', ' ');  \
    stringstream _ss(_s);  \
    istream_iterator<string> _it(_ss);  \
    err(_it, args);  \
    cerr<<endl; \
}
void err(istream_iterator<string> it) {}
template<typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
	cerr << *it << "=" << a << " # ";
	err(++it, args...);
}

void Solve() {
	int l,r;
	cin>>l>>r;
	if(l<=0&&0<=r){
		cout<<"Zero\n";
	}
	else if(max(0,min(0,r)-l)&1)cout<<"Negative\n";
	else cout<<"Positive\n";
}


int main() {
#ifndef ONLINE_JUDGE
	freopen("in.txt","r",stdin);
//  freopen("o1.txt","w",stdout);
#endif
	ios::sync_with_stdio(false);cin.tie(0),cout.tie(0);
	Solve();
	return 0;
}
//  [cpp]
#include <bits/stdc++.h>

#define rep(i,a,n) for (int i=a;i<=n;i++)
#define per(i,a,n) for (int i=n;i>=a;i--)
#define vi vector<int>
#define pii pair<int,int>
#define pb push_back
#define mp make_pair
#define eb emplace_back
#define all(x) (x).begin(),(x).end()
#define fi first
#define se second
#define sz(x) ((int)(x).size())
#define mod(x) ((x)%MOD)
#define o(X) (1<<(X))
#define oL(X) (1LL<<(X))
#define LL long long
#define ppt(x) __builtin_popcount(x)
using namespace std;
const int INF=0x3f3f3f3f,N=1e6+5,MOD=1e9+7;
const LL INF_LL=0x3f3f3f3f3f3f3f3fLL;

template<typename T>
inline int getplc(T x,int y) { return (x>>y)&1; }
template<typename T>
T square(T x) {return x*x;}

LL qpow(LL a,LL b=MOD-2,LL _MOD=MOD){
	LL res=1;
	for(;b;b>>=1,a=a*a%_MOD){
		if(b&1)res=res*a%_MOD;
	}
	return res;
}

template <typename T>
T Smax(T x) { return x; }
template<typename T, typename... Args>
T Smax(T a, Args... args) {
	return max(a, Smax(args...));
}
template <typename T>
T Smin(T x) { return x; }
template<typename T, typename... Args>
T Smin(T a, Args... args) {
	return min(a, Smin(args...));
}

template <typename T>
#define errorl(args...) {  \
	string _s = #args;   \
	replace(_s.begin(), _s.end(), ',', ' ');  \
    stringstream _ss(_s);  \
    istream_iterator<string> _it(_ss);  \
    errl(_it, args);  \
}
void errl(istream_iterator<string> it) {}
template<typename T, typename... Args>
void errl(istream_iterator<string> it, T a, Args... args) {
	cerr << *it << " = " << a << endl;
	errl(++it, args...);
}
#define error(args...) {  \
    string _s = #args;  \
    replace(_s.begin(), _s.end(), ',', ' ');  \
    stringstream _ss(_s);  \
    istream_iterator<string> _it(_ss);  \
    err(_it, args);  \
    cerr<<endl; \
}
void err(istream_iterator<string> it) {}
template<typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
	cerr << *it << "=" << a << " # ";
	err(++it, args...);
}

void Solve() {
	int l,r;
	cin>>l>>r;
	if(l<=0&&0<=r){
		cout<<"Zero\n";
	}
	else if(max(0,0-l)&1)cout<<"Negative\n";
	else cout<<"Positive\n";
}


int main() {
#ifndef ONLINE_JUDGE
	freopen("in.txt","r",stdin);
//  freopen("o1.txt","w",stdout);
#endif
	ios::sync_with_stdio(false);cin.tie(0),cout.tie(0);
	Solve();
	return 0;
}
//  [cpp]
#include <bits/stdc++.h>
using namespace std;

int main(){
  long long int a, b, ans=1, p=0, m=0;
  cin >> a >> b;
  if(a>0){
    cout << "Positive";
  }
  else if(a<0 && a%2!=0){
    cout << "Negative";
  }
  else if(a<0 && a%2==0){
    cout << "Positive";
  }
  else cout << "Zero";
}
//  [c]
#include <stdio.h>
#define abs(a) ((a)<0 ? -(a) : (a))
int main(){
  int a, b;  scanf("%d%d", &a, &b);

  if(a > 0 && b > 0)
    printf("Positive\n");
  else if(a==0 || b==0 || (a<0 && 0<b))
    printf("Zero\n");
  else if(abs(b-a) % 2)
    printf("Positive\n");
  else
    printf("Negative\n");
  return 0;
}
//  [c]
#include <stdio.h>

int main()
{
	int a, b;
	scanf("%d %d", &a, &b);
	
	if (a > 0) printf("Positive\n");
	else if (b >= 0) printf("Zero\n");
	else if ((b - a) % 2 == 1) printf("Positive\n");
	else printf("Negative\n");
	fflush(stdout);
	return 0;
}
//  [c]
#include <stdio.h>

int main(void) {
	int a, b;
	if (scanf("%d%d", &a, &b) != 2) return 1;
	if (a <= 0 && 0 <= b) puts("Zero");
	else if (a > 0 || ((-a) - (-b) + 1) % 2 == 0) puts("Positive");
	else puts("Negative");
	return 0;
}
//  [c]
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

typedef long long ll;
typedef int keytype;

int gcd(int a, int b){ return (a % b) ? gcd(b, a % b) : b;}
int lcm(int a, int b){ return (a / gcd(a, b)) * b;}

/* a[0], ..., a[n-1] の数の最大公約数 */
int ngcd(int n, int a[])
{
    int i, d;

    d = a[0];
    for (i = 1; i < n && d != 1; i++)
        d = gcd(a[i], d);
    return d;
}

void quicksort(keytype a[], int first, int last)
{
    int i, j;
    keytype x, t;

    x = a[(first + last) / 2];
    i = first;  j = last;
    for ( ; ; ) {
        while (a[i] < x) i++;
        while (x < a[j]) j--;
        if (i >= j) break;
        t = a[i];  a[i] = a[j];  a[j] = t;
        i++;  j--;
    }
    if (first  < i - 1) quicksort(a, first , i - 1);
    if (j + 1 < last) quicksort(a, j + 1, last);
}

int is_prime(int x){
    if(x <= 1) return 0;
    for(int i = 2; i * i <= x; i++){
        if(x % i == 0) return 0;
    }
    return 1;
}

int is_substr(char s[], char t[], int i){
    int flag = 1;

    if(s[i] == '\0') flag = 0;

    for(int j = 0; j < strlen(t); ++j, ++i){
        if(s[i] != t[j]){
            flag = 0;
            break;
        }
    }
    return flag;
}

// factor list, number of factors, natural number
void factorize(int ftr[], int *num, int n){
    int a = 2, cnt = 0;

    while(n >= a){
        if(n % a == 0){
            n = n / a;
            ftr[cnt++] = a;
        }else{
            a++;
        }
    }
    *num = cnt;
}

//#define N 5
//int p[N + 1];
// list, end_index
int nextperm(int p[], int end)  /* 辞書式順序で次の順列 */
{
    int i, j, t;

    i = end - 1;
    p[0] = 0;  /* 番人 */
    while (p[i] >= p[i + 1]) i--;
    if (i == 0) return 0;  /* 完了 */
    j = end;
    while (p[i] >= p[j]) j--;
    t = p[i];  p[i] = p[j];  p[j] = t;
    i++;  j = end;
    while (i < j) {
        t = p[i];  p[i] = p[j];  p[j] = t;  i++;  j--;
    }
    return 1;  /* 未了 */
}

void comb(int size1, int size2, int v[size1][size2]){
  for(int i = 0; i < size1; i++){
    v[i][0] = 1;
    v[i][i] = 1;
  }
  for(int k = 1; k < size1; k++){
    for(int j = 1; j < k; j++){
      v[k][j] = (v[k-1][j-1] + v[k-1][j]);
    }
  }
}

int abs_val(int a, int b){
    if(a > b) return a - b;
    else return b - a;
}

const int inf = 1012345678;
int main(){
    int a, b;

    scanf("%d %d", &a, &b);

    if((a * b) <= 0){
        puts("Zero");
    }else if(a > 0 && b> 0){
        puts("Positive");
    }else if((b - a + 1) % 2 == 1){
        puts("Negative");
    }else{
        puts("Positive");
    }

    return 0;
}
//  [c]
#include <stdio.h>
int main(void){
    // Your code here!
    long int a,b;
    scanf("%ld %ld",&a,&b);
    if(a<=0 && b>=0){
        printf("Zero\n");
    }else if(a<0 && b<0){
        if((a-b)%2==0)printf("Negative\n");
        if((a-b)%2==1)printf("Positive\n");
    }else if(a>0 && b>0){
        printf("Positive\n");
    }
}
//  [c]
#include <stdio.h>
#define abs(a) ((a)<0 ? -(a) : (a))
int main(){
  int a, b;  scanf("%d%d", &a, &b);

  if(a > 0 && b > 0)
    printf("Positive\n");
  else if(a==0 || b==0 || (b<0 && 0<a))
    printf("Zero\n");
  else if(abs(b-a) % 2)
    printf("Positive\n");
  else
    printf("Negative\n");
  return 0;
}
//  [javascript]
const main = (input) =>  {
  const data = input.split(/\n|\s/).map((a) => parseInt(a, 10));
  const a = data[0];
  const b = data[1];
  if (a <= 0 && 0 <= b) {
    return "Zero"
  }

  if ((b - a) % 2  || a > 0) {
    return "Positive";
  } else {
    return "Negative";
  }
}

console.log(main(require("fs").readFileSync("/dev/stdin", "utf8")))
//  [javascript]
function Main(input) {
	input = input.trim().split(" ").map((a)=>Number(a));
  var A = input[0];
  var B = input[1];
  if((B > 0 && B - A > B) || A == 0 || B == 0){
     console.log("Zero");
  }else if(A > 0 && B > 0){
     console.log("Positive");
  }else{
       if((B - A) % 2 == 1){
          console.log("Positive");
       }else{
          console.log("Negative");
       }
	}
}

Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
"use strict";
    
const main = arg => {
    arg = arg.trim().split("\n");
    const a = parseInt(arg[0].split(" ")[0]);
    const b = parseInt(arg[0].split(" ")[1]);
    
    if(a < 0 && b >= 0) {
        console.log("Zero");
        return;
    }
    
    if(a > 0 && b > 0) {
        console.log("Positive");
        return;
    }
    
    if((b - a) % 2 === 0) {
        console.log("Negative");
        return;
    }

    console.log("Positive");
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [javascript]
function Main(input) {
	input = input.trim();
  var N = parseInt(input.split("\n")[0].split(" ")[0]);
  var M = parseInt(input.split("\n")[0].split(" ")[1]);
  var list = new Array(N).fill(1);//それぞれの箱の中にあるボールの個数（赤の場所は不問）
  var redVisited = [0];//赤が入った場所。赤が入ったことある場所の個数が0になるとbefore値がなくなる
  var lastRed = 0;//全ての操作で赤が可能な限り選ばれた場合の最後の場所
  for(var i = 1; i <= M; i++){
    var before = parseInt(input.split("\n")[i].split(" ")[0]) - 1;
    var after = parseInt(input.split("\n")[i].split(" ")[1]) - 1;
    list[before]--;
    list[after]++;
    if(list[before] == 0 && redVisited.indexOf(before) != -1){
       redVisited.splice(redVisited.indexOf(before),1);
    }
    if(lastRed == before){
      lastRed = after;
      if(redVisited.indexOf(after) == -1){
      	redVisited.push(after);
      }
    }
  }
  //console.log(list);
  console.log(redVisited.length);
  //console.log(lastRed);
}

Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [go]
package main

import "fmt"

func main() {
	var A, B int
	fmt.Scan(&A, &B)
	if 0 < A {
		fmt.Println("Positive")
	} else if (A < 0 && 0 < B) || A == 0 || B == 0 {
		fmt.Println("Zero")
	} else if B < 0 {
		if (B-A)%2 == 0 {
			fmt.Println("Negative")
		} else {
			fmt.Println("Positive")
		}
	}
}
//  [go]
package main

import (
        "fmt"
)

func solution(a, b int) string {
        out := ""
        switch {
        case a > 0:
                out = "Positive"
        case a < 0 && b > 0:
                out = "Zero"
        case b < 0:
                if (b-a+1)%2 == 0 {
                        out = "Positive"
                } else {
                        out = "Negative"
                }
        }
        return out
}

func main() {
        var a, b int
        fmt.Scan(&a, &b)
        fmt.Println(solution(a, b))
}
//  [go]
package main

import "fmt"

func main() {
	var a, b int
	fmt.Scan(&a, &b)

	if a <= 0 && b >= 0 {
		fmt.Println("Zero")
	} else if a > 0 || (b-a+1)%2 == 0 {
		fmt.Println("Positive")
	} else {
		fmt.Println("Negative")
	}
}
//  [ruby]
a,b = gets.split.map(&:to_i)
if a <= 0 && b >= 0 then
    puts "Zero"
elsif a > 0 && b > 0 then
    puts "Positive"
else
    puts (a-b).abs.odd? ? "Positive" : "Negative"
end
//  [ruby]
a, b = gets.split.map &:to_i
if a <= 0 && b >= 0
  puts :Zero
elsif (a < 0 && b < 0)
  if (b-a).odd?
    puts :Positive
  else
    puts :Negative
  end
elsif (a > 0 && b > 0)
  puts :Positive
else
  puts :Negative
end
//  [ruby]
def get_i() #空白区切の入力を数値(整数)の配列で返す
  return gets.chomp.split(" ").map(&:to_i)
end
def get_f() #空白区切の入力を数値(実数)の配列で返す
  return gets.chomp.split(" ").map(&:to_f)
end
def get() #空白区切の入力を文字列の配列で返す
  return gets.chomp.split(" ")
end
def get_nsp() #入力されたものを一文字ずつに区切った文字列の配列で返す
  return gets.chomp.split("")
end
def yn_judge(bool,y="Yes",n="No") #boolに真偽を投げることで、trueならy、falseならnの値を出力する
  return bool ? y : n 
end
def array(size1,init=nil,size2=-1) #size2に二次元配列時の最初の要素数、size1に次の配列の大きさ、initに初期値を投げることでその配列を返す
  if size2==-1
    return Array.new(size1){init}
  else
    return Array.new(size2){Array.new(size1){init}}
  end
end

a,b=get_i
if a>0 and b>0
    puts "Positive"
elsif a<0 and b<0
    if (b-a+1).even?
        puts "Positive"
    else
        puts "Negative"
    end
else
    puts "Zero"
end
//  [ruby]
a, b = gets.split.map(&:to_i)

case
when a == 0 || b == 0 || (a < 0 && 0 < b)
  puts 'Zero'
when 0 < a || (a != b && a.even?)
  puts 'Positive'
else
  puts 'Negative'
end
//  [ruby]
a, b = gets.split.map(&:to_i)

case
when a == 0 || b == 0 || (a < 0 && 0 < b)
  puts 'Zero'
when 0 < a || a.even?
  puts 'Positive'
else
  puts 'Negative'
end
//  [ruby]
a, b = gets.split.map(&:to_i)

case
when a == 0 || b == 0 || (a < 0 && 0 < b)
  puts 'Zero'
when 0 < a || b < 0
  puts 'Positive'
else
  puts 'Negative'
end
//  [rust]
macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut iter = $s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
    ($($r:tt)*) => {
        let s = {
            use std::io::Read;
            let mut s = String::new();
            std::io::stdin().read_to_string(&mut s).unwrap();
            s
        };
        let mut iter = s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
}

macro_rules! input_inner {
    ($iter:expr) => {};
    ($iter:expr, ) => {};

    ($iter:expr, $var:ident : $t:tt $($r:tt)*) => {
        let $var = read_value!($iter, $t);
        input_inner!{$iter $($r)*}
    };
}

macro_rules! read_value {
    ($iter:expr, ( $($t:tt),* )) => {
        ( $(read_value!($iter, $t)),* )
    };

    ($iter:expr, [ $t:tt ; $len:expr ]) => {
        (0..$len).map(|_| read_value!($iter, $t)).collect::<Vec<_>>()
    };

    ($iter:expr, chars) => {
        read_value!($iter, String).chars().collect::<Vec<char>>()
    };

    ($iter:expr, usize1) => {
        read_value!($iter, usize) - 1
    };

    ($iter:expr, $t:ty) => {
        $iter.next().unwrap().parse::<$t>().expect("Parse error")
    };
}

#[allow(unused_imports)]
use std::io::{stdout, Write, BufWriter};
#[allow(unused_imports)]
use std::cmp::{max, min} ;

fn main() {
    input! {
        a: i64,
        b: i64,
    }

    if a*b <= 0 { println!("Zero") }
    else if a > 0 || (b-a) % 2 == 1 || a == b { println!("Positive") }
    else { println!("Negative") }
}
//  [rust]
use proconio::{input, fastout};

#[fastout]
fn main() {
    input! {
        a: i64,
        b: i64,
    };


    println!("{}",
        match (a..=b).collect::<Vec<i64>>().iter().product::<i64>() {
            0 => "Zero",
            n if n < 0 => "Negative",
            _ => "Positive",
        }
    );
}
//  [rust]
use proconio::{fastout, input};

#[fastout]
fn main() {
    input! {a: i128, b:i128};
    let mut sum: i128 = 1;

    for i in a..b {
        sum *= i;
    }

    if sum < 0 {
        println!("Negative")
    } else if sum == 0 {
        println!("Zero")
    } else {
        println!("Positive")
    }
}
//  [rust]
#![allow(unused, non_snake_case, dead_code, non_upper_case_globals)]
use {
    proconio::{marker::*, *},
    std::{cmp::*, collections::*, mem::*},
};
fn main() {
    input! {
        a:i64,b:i64,
    }

    if a > 0 {
        println!("Positive");
    } else if a <= 0 {
        if b >= 0 {
            println!("Zero");
        } else {
            if (a.abs() - b.abs()) % 2 == 0 {
                println!("Positive");
            } else {
                println!("Negative");
            }
        }
    }
}
const INF: i64 = 1 << 60;
//  [swift]
let input = readLine()!.characters.split(" ").map{Int(String($0))!}
let a = input[0]
let b = input[1]
if (a...b)~=0 {
  print("Zero")
} else if a<0 && (a...min(b,-1)).count%2>0 {
  print("Negative")
} else {
  print("Positive")
}
//  [swift]
let input = readLine()!.characters.split(" ").map{Int(String($0))!}
let a = input[0]
let b = input[1]
if (a...b)~=0 {
  print("Zero")
} else if a<0 && (b-a+1)%2>0 {
  print("Negative")
} else {
  print("Positive")
}
//  [swift]
let input = readLine()!.characters.split(" ").map{Int(String($0))!}
let a = input[0]
let b = input[1]
if (a...b)~=0 {
  print("Zero")
} else if a<0 && a-min(b-1,0)%2<0 {
  print("Negative")
} else {
  print("Positive")
}
//  [swift]
let input = readLine()!.characters.split(" ").map{Int(String($0))!}
let a = input[0]
let b = input[1]
if a<=0 && 0<=b {
  print("Zero")
} else if a-min(b-1,0)%2>0 {
  print("Negative")
} else {
  print("Positive")
}
//  [swift]
let input = readLine()!.characters.split(" ").map{Int(String($0))!}
let a = input[0]
let b = input[1]
if a<=0 && 0<=b {
  print("Zero")
} else if a-min(b-1,0)%2>0 {
  print("Negative")
} else {
  pritn("Positive")
}
//  [typescript]
function Main(input) {
	const input = input.split("\n");
    const tmp = input[0].split(" ");
	const a = parseInt(tmp[0], 10);
	const b = parseInt(tmp[1], 10);
	const n = b-a+1;
	if ((a<=0&&b>=0)||a==0||b==0) {
        console.log("Zero");
	} else {
		if (a>0||n%2==0) {
    	    console.log("Positive");
		} else {
    	    console.log("Negative");
		}
	}
}
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [typescript]
class NormalInput {
  input: string[];
  pointer: number;
  constructor(raw: string) {
    this.input = raw.split(/ |\n/);
    this.pointer = 0;
  }
  read<T>(parser: (v: string) => T): () => T {
    return () => {
      const ret = parser(this.input[this.pointer]);
      this.pointer++;
      return ret;
    };
  }
  int = this.read(str => parseInt(str, 10));
  ints = (length: number): number[] => {
    let ret: number[] = [];
    for (let i = 0; i < length; i++) {
      ret.push(this.int());
    }
    return ret;
  };
  str = (): string => {
    const ret = this.input[this.pointer];
    this.pointer++;
    return ret;
  };
  strs = (length: number): string[] => {
    let ret: string[] = [];
    for (let i = 0; i < length; i++) {
      ret.push(this.str());
    }
    return ret;
  };
  bint = (): bigint => {
    const ret = BigInt(this.input[this.pointer]);
    this.pointer++;
    return ret;
  };
  bints = (length: number): bigint[] => {
    let ret: bigint[] = [];
    for (let i = 0; i < length; i++) {
      ret.push(this.bint());
    }
    return ret;
  };
}
function rep(a: number, b: number) {
  let arr = [];
  for (let i = a; i < b; i++) arr.push(i);
  return arr;
}

function Main({ int, str, strs, ints, bint, bints }: NormalInput) {
  const [a, b] = ints(2);
  let ans: number = 1;
  for (let i = a; i <= b; ++i) {
    ans *= i;
  }
  if (ans > 0) {
    console.log(`${"Positive"}`);
  } else if (ans === 0) {
    console.log(`${"Zero"}`);
  } else {
    console.log(`${"Negative"}`);
  }
}
Main(new NormalInput(require("fs").readFileSync("/dev/stdin", "utf8")));
//  [typescript]
function Main(input) {
	const input = input.split("\n");
    const tmp = input[0].split(" ");
	const a = parseInt(tmp[0], 10);
	const b = parseInt(tmp[1], 10);
	const n = b-a+1;
	if ((a<=0&&b>=0)||a==0||b==0) {
        console.log("Zero");
	} else {
		if (a>0&&n%2==0) {
    	    console.log("Positive");
		} else {
    	    console.log("Negative");
		}
	}
}
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [python]
def solve():
	_,*l=map(int,open(0).read().split())
	print("YNeos"[any((t+x+y)%2+(t<x+y)for t,x,y in zip(*[iter(l)]*3))::2])

if __name__=="__main__":
	solve()
//  [python]
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)

n = int(input())
prev_time = 0
prev_point = (0, 0)
for i in range(n):
    t, x, y = map(int, input().split())
    dist = abs(x - prev_point[0]) + abs(y - prev_point[1])
    if dist > (t - prev_time):
        print('No')
        sys.exit(0)

    if (t - prev_time) % 2 != dist % 2:
        print('No')
        sys.exit(0)
    prev_time = t
    prev_point = (x, y)
print('Yes')
//  [python]
_,*l=map(int,open(0).read().split());print("YNeos"[any((t+x+y)%2+(t<x+y)for t,x,y in zip(*[iter(l)]*3))::2])
//  [python]
N = int(input())
l = []
now = [0,0,0]
ans = 'Yes'
for _ in range(N):
    inp = list(map(int,input().split()))
    l.append(inp)

for i in range(N):
    shortest = abs(l[i][1] - now[0]) + abs(l[i][2] - now[1])
    if shortest > l[i][0] - now[0]:
        ans = 'No'
        break
    a = l[i][0] - shortest
    if a % 2 !=0:
        ans = 'No'
        break
    else:
        now = l[i]
print(ans)
//  [python]
N = int(input())
l = []
now = [0,0,0]
ans = 'Yes'
for _ in range(N):
    inp = list(map(int,input().split()))
    l.append(inp)
for i in range(N):
    shortest = abs(l[i][1] - now[0]) + abs(l[i][2] - now[1])
    if shortest > l[i][0]:
        ans = 'No'
        break
    a = l[i][0] - shortest
    if a % 2 !=0:
        ans = 'No'
        break
    else:
        now = l[i]
print(ans)
//  [python]
n=int(input())
for i in range(n):
  t,x,y=map(int,input().split())
  if x + y > t or (x+y)%2!=t%2:
    print("No")
    break
else:
  print("Yes")
//  [java]
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.io.DataInputStream;
import java.io.IOException;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        Read in = new Read(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskC solver = new TaskC();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskC {
        public void solve(int testNumber, Read in, PrintWriter out) {
            int n = in.nextInt();
            boolean cd = true;
            int pt = 0, px = 0, py = 0, ct = 0, cy = 0, cx = 0;
            for (int i = 0; i < n; i++) {
                ct = in.nextInt();
                cx = in.nextInt();
                cy = in.nextInt();
                int p = Math.abs(cx - px) + Math.abs(cy - py);
                if (cd && ((p > (ct - pt)) || (p & 1) != ((ct - pt) & 1))) {
                    cd = false;
                }
                pt = ct;
                px = cx;
                py = cy;
            }
            if (cd) {
                out.println("Yes");
            } else {
                out.println("No");
            }
        }

    }

    static class Read {
        final private int BUFFER_SIZE = 1 << 16;
        private DataInputStream din;
        private byte[] buffer;
        private int bufferPointer;
        private int bytesRead;

        public Read(InputStream inputStream) {
            din = new DataInputStream(inputStream);
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }

        public Read(String file_name) {
            try {
                din = new DataInputStream(new FileInputStream(file_name));
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            }
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }

        public int nextInt() {
            int ret = 0;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();
            do {
                ret = ret * 10 + c - '0';
            } while ((c = read()) >= '0' && c <= '9');

            if (neg)
                return -ret;
            return ret;
        }

        private void fillBuffer() {
            try {
                bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
            } catch (IOException e) {
                e.printStackTrace();
            }
            if (bytesRead == -1)
                buffer[0] = -1;
        }

        private byte read() {
            if (bufferPointer == bytesRead)
                fillBuffer();
            return buffer[bufferPointer++];
        }

    }
}
//  [java]
import java.util.*;
 
public class Main{
  public static void main(String[] args){
    Scanner sc = new Scanner(System.in);
    int num = sc.nextInt();
    int x = 0;
    int y = 0;
    for(int i = 0;i < num;i++){
      int sec = sc.nextInt();
      int mx = sc.nextInt();
      int my = sc.nextInt();
      int move = Math.abs(mx - x) + Math.abs(my - y);
      if(move <= sec){
        sec -= move;
        if(sec % 2 != 0){
          System.out.println("No");
          System.exit(0);
        }
      }
      else{
        System.out.println("No");
        System.exit(0);
      }
    }
    System.out.println("Yes");
  }
}
//  [java]
import java.util.*;
 
public class Main{
  public static void main(String[] args){
    Scanner sc = new Scanner(System.in);
    int num = sc.nextInt();
    int x = 0;
    int y = 0;
    for(int i = 0;i < num;i++){
      int sec = sc.nextInt();
      int mx = sc.nextInt();
      int my = sc.nextInt();
      int move = Math.abs(mx - x) + Math.abs(my - y);
      if(move <= sec){
        move -= sec;
        if(move % 2 != 0){
          System.out.println("No");
          System.exit(0);
        }
      }
      else{
        System.out.println("No");
        System.exit(0);
      }
    }
    System.out.println("Yes");
  }
}
//  [java]
import java.util.*;
 
public class Main{
  public static void main(String[] args){
    Scanner sc = new Scanner(System.in);
    int num = sc.nextInt();
    int x = 0;
    int y = 0;
    for(int i = 0;i < num;i++){
      int sec = sc.nextInt();
      int mx = sc.nextInt();
      int my = sc.nextInt();
      int move = Math.abs(mx - x) + Math.abs(my - y);
      if(move >= sec){
        move -= sec;
        if(move % 2 != 0){
          System.out.println("No");
          System.exit(0);
        }
      }
      else{
        System.out.println("No");
        System.exit(0);
      }
    }
    System.out.println("Yes");
  }
}
//  [cpp]
#include <bits/stdc++.h>
#define M_PI           3.14159265358979323846  /* pi */
using namespace std;
using  ll = long long;

int main() {
    ll n;
    cin >> n;

    vector<ll>t(n + 1, 0);
    vector<ll>x(n + 1, 0);
    vector<ll>y(n + 1, 0);

    for (ll i = 1; i <= n; i++) {
        cin >> t.at(i) >> x.at(i) >> y.at(i);
    }
    ll tnow;
    ll xynow;
    bool result = true;

    for (ll i = 1; i <= n; i++) {
        tnow = (t.at(i) - t.at(i - 1));
        xynow = fabs(x.at(i) - x.at(i - 1) + fabs(y.at(i) - (y.at(i - 1))));

        if (tnow < xynow)result = false;
        if (xynow % 2 != tnow % 2)result = false;
    }
    if (result == true)cout << "Yes" << endl;
    else cout << "No" << endl;
}
//  [cpp]
#include <bits/stdc++.h>
#define M_PI           3.14159265358979323846  /* pi */
using namespace std;
using  ll = long long;

int main() {
    ll n;
    cin >> n;

    vector<ll>t(n + 1, 0);
    vector<ll>x(n + 1, 0);
    vector<ll>y(n + 1, 0);

    for (ll i = 1; i <= n; i++) {
        cin >> t.at(i) >> x.at(i) >> y.at(i);
    }
    ll tnow;
    ll xynow;
    bool result = true;

    for (ll i = 1; i <= n; i++) {
        tnow = (t.at(i) - t.at(i - 1));
        xynow = abs(x.at(i) - x.at(i - 1) + abs(y.at(i) - (y.at(i - 1))));

        if (tnow < xynow)result = false;
        if (xynow % 2 != tnow % 2)result = false;
    }
    if (result == true)cout << "Yes" << endl;
    else cout << "No" << endl;
}
//  [cpp]
#include <bits/stdc++.h>
#define M_PI           3.14159265358979323846  /* pi */
using namespace std;
using  ll = long long;

int main() {
	ll n;
	cin >> n;

	vector<ll>t(n + 1, 0);
	vector<ll>x(n + 1, 0);
	vector<ll>y(n + 1, 0);

	for (ll i = 1; i <= n; i++) {
		cin >> t.at(i) >> x.at(i) >> y.at(i);
	}
	ll tnow;
	ll xynow;
	bool result = true;

	for (ll i = 1; i <= n; i++) {
		tnow = (t.at(i) - t.at(i - 1));
		xynow = abs(x.at(i) - x.at(i - 1) + abs(y.at(i) - (y.at(i - 1))));

		if (tnow < xynow)result = false;
		if (xynow % 2 != tnow % 2)result = false;
	}
	if (result == true)cout << "Yes" << endl;
	else cout << "No" << endl;
}
//  [c]
#include <stdio.h>
#include <stdlib.h>

int main(void){
  long N;
  scanf("%ld",&N);

  long x,y,t;
  long px = 0,py = 0,pt = 0;

  for(int i = 0;i < N;i++){
    scanf("%ld%ld%ld",&t,&x,&y);
    long distance = abs(x-px)+abs(y-py);
    if(distance <= t-pt){
      distance -= (t-pt);
      if(distance%2 != 0){
        printf("No\n");
        return 0;
      }
    }else{
      printf("No\n");
      return 0;
    }
  }

  printf("Yes\n");
  return 0;
}
//  [c]
#include <stdio.h>
#include <stdlib.h>
#include <math.h>

int main()
{
	int flag = 1;
	long i, N, t_old, t_new, x_old, x_new, y_old, y_new, dt, dx, dy;
	scanf("%ld",&N);
	t_old = x_old = y_old = 0;
	for(i=1; i<=N;i++)
	{
		scanf("%ld %ld %ld", &t_new, &x_new, &y_new);
		dt = t_new-t_old;
		dx = (x_new - x_old > 0)? x_new-x_old:x_old-x_new;
		dy = (y_new - y_old > 0)? y_new-y_old:y_old-y_new;
		if(dx+dy <= dt)
		{
			if((dt-(dx+dy))%2 != 0)
			{
				flag = 0;
				break;
			}
			else
			{
				x_old = x_new;
				y_old = y_new;
				t_old = t_new;
			}
		}
		else
		{
			flag = 0;
			break;
		}
	}
	printf("%s\n",(flag == 1)? "Yes":"No");
	return 0;
}
//  [c]
#include <stdio.h>

int main(void){
	int n, t, x, y;
	int flag;
	int i;

	scanf("%d", &n);

	flag = 0;
	i = 0;
	while (i < n)
	{
		scanf("%d %d %d", &t, &x, &y);
		if ((x + y + t) % 2 != 0 || t < x + y)
		{
			flag = 1;
		}
		i++;
	}

	if (flag)
	{
		printf("No");
	}
	else
	{
		printf("Yes");
	}

	return 0;
}
//  [c]
#include <bits/stdc++.h>
using namespace std;

// これ以降の行は変更しなくてよい

int main() {
  int n;
  cin >> n;
  vector<int> t(n), x(n), y(n);
  for (int i = 0; i < n; i++) cin >> t[i] >> x[i] >> y[i];

  for (int i = 0; i < n; i++) {
    int ti, xi, yi;
    if (i == 0) {
      ti = t[i];
      xi = x[i];
      yi = y[i];
    }
    else{
      ti = t[i] - t[i-1];
      xi = x[i] - x[i-1];
      yi = y[i] - y[i-1];
    }

    // cout << ti << " " << xi << " "<< yi << " " << endl;

    if ((abs(xi+yi) <= ti) && (abs(xi+yi-ti)%2 == 0)) continue;
    else {cout << "No" << endl; return 0;}
  }
  cout << "Yes" << endl;
  return 0;
}
//  [c]
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string.h>

#define ll long long

void swap (int *x, int *y) {
  int temp;

  temp = *x;
  *x = *y;
  *y = temp;

  return;
}


int gcd(int a, int b){
  int c;

  while (b > 0){
    c = a % b;
    a = b;
    b = c;
  }

  return a;
}

int upll(const void*a, const void*b){
  return*(ll*)a<*(ll*)b?-1:*(ll*)a>*(ll*)b?1:0;
}

int downll(const void*a, const void*b){
  return*(ll*)a<*(ll*)b?1:*(ll*)a>*(ll*)b?-1:0;
}

void sortup(ll*a,int n){
  qsort(a,n,sizeof(ll),upll);
}

void sortdown(ll*a,int n){
  qsort(a,n,sizeof(ll),downll);
}

long int modpow(long int a,long int n,long int mod){
  long int ans=1;
  while(n>0){
    if(n & 1){
      ans=ans*a%mod;
    }
    a=a*a%mod;
    n/=2;
  }
  return ans;
}

long int modinv(long int a,long int mod){
  return modpow(a,mod-2,mod);
}

int max(int a,int b){
  if(a<b){
    return b;
  }
  else{
    return a;
  }
}

int min(int a,int b){
  if(a<b){
    return a;
  }
  else{
    return b;
  }
}

void chmax(int *a,int b){
  if(*a < b){
    *a = b;
  }

  return;
}

void chmin(int *a,int b){
  if(*a > b){
    *a =b;
  }

  return;
}


/****************************************\
| Thank you for viewing my code:)        |
| Written by RedSpica a.k.a. RanseMirage |
| Twitter:@asakaakasaka                  | 
\****************************************/

int main(void){
  int n;
  scanf("%d",&n);

  int T=0;
  int X=0;
  int Y=0;

  int can=1;

  for(int i=0;i<n;i++){
    int t,x,y;
    scanf("%d%d%d",&t,&x,&y);

    int d=abs(x-X)+abs(y-Y);
    if(d>t-T){
      can=0;
    }

    if(d%2!=(t-T)%2){
      can=0;
    }
  }

  if(can){
    printf("Yes\n");
  }
  else{
    printf("No\n");
  }

  return 0;
}
//  [c]
#include<stdio.h>

int main(){

  int N,t1=0,t2,x1=0,x2,y1=0,y2,ans=0;
  scanf("%d",&N);
  for (int i = 0; i < N; i++)
  {
    scanf("%d%d%d",&t2,&x2,&y2);
    if (t2-t1>=x2-x1+y2-y1)
    {
      if(((t2-t1)-(x1-x2+y1-y2))%2==0){
        t1=t2; x1=x2; y1=y2;
        continue;
      }else{
        ans=1;
        break;
      } 
    }else{
      ans=1;
      break;
    }
  }

  ans > 0 ? puts("No"):puts("Yes");

  return 0;
}
//  [javascript]
'use strict'

function main(input) {
  const inputList = input.split('\n');
  const n = inputList[0]
  const list = inputList.slice(1)
  let result = true 

  let prevt = 0
  let prevx = 0
  let prevy = 0
  let nextt = 0
  let nextx = 0
  let nexty = 0

  for (let i=0; i<list.length; i++) {
    const tmpList = list[i].split(' ')
    nextt = tmpList[0]
    nextx = tmpList[1]
    nexty = tmpList[2]

    const difft = nextt - prevt
    const diffx = nextx - prevx 
    const diffy = nexty - prevy
    const tmp = difft - (diffx+diffy)
    if ( tmp<0 || tmp%2 === 1) {
      result = false 
      break
    }
  }

  if (result) {
    console.log('Yes')
  } else {
    console.log('No')
  }
}

main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function main(input) {
    const args = input.split('\n');
    const N = parseInt(args[0], 10);
    const nums = args.slice(1, N + 1);
    const isValid = nums.every((n) => {
        var ns = n.split(' ');
        var t = parseInt(ns[0], 10),
            x = parseInt(ns[1], 10),
            y = parseInt(ns[2], 10);
        var sum = x + y;

        return (t >= sum) && ((t % 2) === (sum % 2));
    });

    if (isValid) {
        console.log('Yes');
    } else {
        console.log('No');
    }
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [javascript]
const main = input => {
  const inputList = input.split('\n')
  const count = parseInt(inputList[0], 10)
  const nums = inputList.slice(1, count + 1)
  const result = nums.every(n => {
    const arr = n.split(' ')
    const time = parseInt(arr[0], 10)
    const x = parseInt(arr[1], 10)
    const y = parseInt(arr[2], 10)
    const sum = x + y

    return (
      time >= sum &&
      time%2 === sum%2
    )
  })
  
  if (result) {
    console.log('Yes')
  } else {
  	console.log('No')
  }
}

main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [javascript]
const input = require("fs").readFileSync("/dev/stdin", "utf8")
;(input => {
  
    const lines = input.split('\n')
    const N = lines[0] - 0

    const T = []
    for (let i = 1; i <= N; i++) {
         T.push(lines[i].split(' ').map(Number))
    }
  
    const f = (a, b) => {
      const dist = Math.abs(a[1] + a[2] - b[1] - b[2])
      const t = b[0] - a[0]
      if (t < dist) {
        return false
      } else if ((t - dist) % 2) {
        return false
      }
      return true
    }
    
    let ans = 'Yes'
    let t = null
    let p = [0, 0, 0]
    while (T.pop()) {
    }

    console.log(ans)
  
})(input)
//  [javascript]
const input = require("fs").readFileSync("/dev/stdin", "utf8")
;(input => {
  
    const lines = input.split('\n')
    const N = lines[0] - 0

    const T = []
    for (let i = 1; i <= N; i++) {
         T.push(lines[i].split(' ').map(Number))
    }
  
    const f = (a, b) => {
      const dist = Math.abs(a[1] + a[2] - b[1] - b[2])
      const t = b[0] - a[0]
      if (t < dist) {
        return false
      } else if ((t - dist) % 2) {
        return false
      }
      return true
    }
    
    let ans = 'Yes'
    let t = null
    let p = [0, 0, 0]
    while (T.shift()) {
    }

    console.log(ans)
  
})(input)
//  [javascript]
const input = require("fs").readFileSync("/dev/stdin", "utf8")
;(input => {
  
    const lines = input.split('\n')
    const N = lines[0] - 0

    const T = []
    for (let i = 1; i <= N; i++) {
         T.push(lines[i].split(' ').map(Number))
    }
  
    const f = (a, b) => {
      const dist = Math.abs(a[1] + a[2] - b[1] - b[2])
      const t = b[0] - a[0]
      if (t < dist) {
        return false
      } else if ((t - dist) % 2) {
        return false
      }
      return true
    }
    
    let ans = 'Yes'
    let t = null
    let p = [0, 0, 0]
    while (t = T.shift()) {
	    if (f(p, t)) {
            p = t
        } else {
            ans = 'No'
            break
        }
    }

    console.log(ans)
  
})(input)
//  [go]
package main

import (
	"bufio"
	"fmt"
	"os"
)

var sc = bufio.NewScanner(os.Stdin)

func r() (n int) {
	sc.Scan()
	for _, v := range sc.Bytes() {
		n = n*10 + int(v-48)
	}
	return
}

func abs(x int) int {
	if x < 0 {
		return -x
	} else {
		return x
	}
}

func main() {
	sc.Split(bufio.ScanWords)
	n := r()

	t, x, y := 0, 0, 0
	var tn, xn, yn int
	flg := true
	for i := 0; i < n; i++ {
		tn, xn, yn = r(), r(), r()
		dt, dx, dy := abs(tn-t), abs(xn-x), abs(yn-y)
		if !(dx+dy <= dt && (dx+dy)%2 == dt%2) {
			flg = false
		}
		t, x, y = tn, xn, yn
	}
	if flg {
		fmt.Println("Yes")
	} else {
		fmt.Println("No")
	}
}
//  [go]
package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
)

var sc = bufio.NewScanner(os.Stdin)

func Scan() string {
	sc.Scan()
	return sc.Text()
}
func iScan() int {
	n, _ := strconv.Atoi(Scan())
	return n
}
func fScan() float64 {
	n, _ := strconv.ParseFloat(Scan(), 64)
	return n
}
func stringToInt(s string) int {
	n, _ := strconv.Atoi(s)
	return n
}
func SScan(n int) []string {
	a := make([]string, n)
	for i := 0; i < n; i++ {
		a[i] = Scan()
	}
	return a
}
func iSScan(n int) []int {
	a := make([]int, n)
	for i := 0; i < n; i++ {
		a[i] = iScan()
	}
	return a
}
func abs(x int) int {
	if x < 0 {
		x = -x
	}
	return x
}
func larger(a, b int) int {
	if a < b {
		return b
	} else {
		return a
	}
}
func smaller(a, b int) int {
	if a > b {
		return b
	} else {
		return a
	}
}
func max(a []int) int {
	x := a[0]
	for i := 0; i < len(a); i++ {
		if x < a[i] {
			x = a[i]
		}
	}
	return x
}
func min(a []int) int {
	x := a[0]
	for i := 0; i < len(a); i++ {
		if x > a[i] {
			x = a[i]
		}
	}
	return x
}
func sum(a []int) int {
	x := 0
	for _, v := range a {
		x += v
	}
	return x
}

var mod int = 1000000007

func main() {
	buf := make([]byte, 0)
	sc.Buffer(buf, mod)
	sc.Split(bufio.ScanWords)
	n := iScan()
	t, x, y := 0, 0, 0
	f := true
	for i := 0; i < n; i++ {
		p, q, r := iScan(), iScan(), iScan()
		c := abs(p - t)
		d := abs(q-x) + abs(r-y)
		if c%2 != d%2 || d > c {
			f = false
		}
		t, x, y = p, q, r
	}
	if f {
		fmt.Println("Yes")
	} else {
		fmt.Println("No")
	}
}
//  [go]
package main

import(
	"fmt"
)

func main(){
  var num int
  var slct, slcx, slcy []int
  var ans bool
  var i int = 0

	num = fmt.Scanf("%d\n", &num)
  	for num > i {
    	fmt.Scanf("%d %d %d\n", &slct[i], &slcx[i], &slcy[i])
    	i++
	}
  
  var diff int = slct[num] - slcx[num] - slcy[num]
  i = 0
  for num > i {
    if diff % 2 != 0 {
		ans = false
      	break
    }
    i++
  }
  fmt.Println(ans)
}
//  [go]
package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
)

var (
	sc = bufio.NewReader(os.Stdin)
)

type pos struct {
	t, x, y int
}

func (p *pos) arrive(p2 *pos) bool {
	t := p.t - p2.t
	x := p.x - p2.x
	y := p.y - p2.y
	if x+y == t {
		return true
	}
	if x+y < t {
		if (t-(x+y))%2 == 0 {
			return true
		} else {
			return false
		}
	}
	if t < x+y {
		return false
	}
	return true
}

func main() {
	N := scanInt()
	c := &pos{t: 0, x: 0, y: 0}
	for i := 0; i < N; i++ {
		n := &pos{t: scanInt(), x: scanInt(), y: scanInt()}
		if !n.arrive(c) {
			fmt.Println("No")
			return
		}
		c = n
	}
	fmt.Println("Yes")
}

func scan(a ...interface{}) { _, err := fmt.Fscan(sc, a...); pnc(err) }
func scanStr() (s string)   { scan(&s); return }
func scanInt() int          { i, err := strconv.Atoi(scanStr()); pnc(err); return i }
func scanFloat() float64    { f, err := strconv.ParseFloat(scanStr(), 64); pnc(err); return f }
func pnc(err error) {
	if err != nil {
		panic(err)
	}
}
//  [go]
package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
)

var (
	sc = bufio.NewReader(os.Stdin)
)

type pos struct {
	t, x, y int
}

func (p *pos) arrive(p2 *pos) bool {
	t := p.t - p2.t
	x := p.x - p2.x
	y := p.y - p2.y
	if x+y == t {
		return true
	}
	if x+y < t && (t-(x+y))%2 == 0 {
		return true
	}
	if x+y < t && (t-(x+y))%2 == 1 {
		return false
	}
	if x+y == 1 && t%2 == 0 {
		return false
	}
	if x+y > t {
		return false
	}
	return true
}

func main() {
	N := scanInt()
	c := &pos{t: 0, x: 0, y: 0}
	for i := 0; i < N; i++ {
		n := &pos{t: scanInt(), x: scanInt(), y: scanInt()}
		if !n.arrive(c) {
			fmt.Println("No")
			return
		}
		if !rec(c, n) {
			fmt.Println("No")
			return
		}
		c = n
	}
	fmt.Println("Yes")
}

func rec(c, n *pos) bool {
	if !n.arrive(c) {
		return false
	}
	if c.t == n.t {
		if c.x == n.x && c.y == n.y {
			return true
		} else {
			return false
		}
	}
	// x+1, y
	if rec(&pos{t: c.t + 1, x: c.x + 1, y: c.y}, n) {
		return true
	}
	// x-1, y
	if rec(&pos{t: c.t + 1, x: c.x - 1, y: c.y}, n) {
		return true
	}
	// x, y+1
	if rec(&pos{t: c.t + 1, x: c.x, y: c.y + 1}, n) {
		return true
	}
	// x, y-1
	if rec(&pos{t: c.t + 1, x: c.x, y: c.y - 1}, n) {
		return true
	}

	return false
}

func scan(a ...interface{}) { _, err := fmt.Fscan(sc, a...); pnc(err) }
func scanStr() (s string)   { scan(&s); return }
func scanInt() int          { i, err := strconv.Atoi(scanStr()); pnc(err); return i }
func scanFloat() float64    { f, err := strconv.ParseFloat(scanStr(), 64); pnc(err); return f }
func pnc(err error) {
	if err != nil {
		panic(err)
	}
}
//  [ruby]
# n
# t x y

n = gets.to_i
t = []
x = []
y = []

t << 0
x << 0
y << 0
n.times do 
  t_temp, x_temp, y_temp = gets.split
  t << t_temp.to_i
  x << x_temp.to_i
  y << y_temp.to_i
end

def move_enable?(t_from, t_to, x_from, x_to, y_from, y_to)
  t_dif = t_to - t_from
  x_dif = (x_to - x_from).abs
  y_dif = (y_to - y_from).abs
  if t_dif < x_dif + y_dif
    return false
  elsif t_dif == x_dif + y_dif
    return true
  elsif ( t_dif - (x_dif + y_dif) ).even?
    return true
  else
    return false
  end
end

flag = "No"
n.times do |i|
  flag_temp = move_enable?(t[i], t[i+1], x[i], x[i+1], y[i], y[i+1])
  break unless flag_temp
  flag = "Yes" if i == n-1
end

puts flag
//  [ruby]
N=gets.to_i
px=py=pt=0
r=true
N.times{
    t,x,y=gets.split.map(&:to_i)
    dx=(x-px).abs
    dy=(y-py).abs
    dt=(t-pt).abs
    if dx+dy>dt
        r=false
    end
    if (dx+dy) % 2 != dt % 2
        r=false
    end
    px=x
    py=y
    pt=t
}
puts r ? "Yes" : "No"
//  [ruby]
gets
current = [0, 0, 0]
ARGF.each do |line|
  t, x, y = line.split.map(&:to_i)
  d = (current[1] - x).abs + (current[2] -y).abs 
  if t - current[0] < d
	  puts 'No'
  	  exit
  else
    unless t.even? == (x + y).even?
      puts 'No'
      exit
    end
  end
end
puts 'Yes'
//  [ruby]
N = gets.to_i
t,x,y = N.times.map{gets.split.map(&:to_i)}.transpose
nowx = 0
nowy = 0
nowt = 0
N.times do |i|
  d = (x[i]-nowx).abs + (y[i]-nowy).abs
  nowt = t[i] - nowt
  if (nowt.odd? && d.even?) || (nowt.even? && d.odd?) || nowt < d
    puts "No"
    exit
  end
  nowx = x[i]
  nowy = y[i]
end
puts "Yes"
//  [ruby]
# n
# t x y

n = gets.to_i
t = []
x = []
y = []

t << 0
x << 0
y << 0
n.times do 
  t_temp, x_temp, y_temp = gets.split
  t << t_temp.to_i
  x << x_temp.to_i
  y << y_temp.to_i
end

def move_enable?(t_from, t_to, x_from, x_to, y_from, y_to)
  t_dif = t_to - t_from
  x_dif = x_to - x_from
  y_dif = y_to - y_from
  if t_dif < x_dif + y_dif
    return false
  elsif t_dif == x_dif + y_dif
    return true
  elsif ( t_dif - (x_dif + y_dif) ).even?
    return true
  else
    return false
  end
end

flag = "No"
n.times do |i|
  flag_temp = move_enable?(t[i], t[i+1], x[i], x[i+1], y[i], y[i+1])
  break unless flag_temp
  flag = "Yes" if i == n-1
end

puts flag
//  [ruby]
# n
# t x y

n = gets.to_i
t = []
x = []
y = []

t << 0
x << 0
y << 0
n.times do 
  t_temp, x_temp, y_temp = gets.split
  t << t_temp.to_i
  x << x_temp.to_i
  y << y_temp.to_i
end

def move_enable?(t_from, t_to, x_from, x_to, y_from, y_to)
  t_dif = t_to - t_from
  x_dif = x_to - x_from
  y_dif = y_to - y_from
  if t_dif < x_dif + y_dif
    return false
  elsif t_dif == x_dif + y_dif
    return true
  elsif ( t_dif - (x_dif - y_dif) ).even?
    return true
  else
    return false
  end
end

flag = "No"
n.times do |i|
  flag_temp = move_enable?(t[i], t[i+1], x[i], x[i+1], y[i], y[i+1])
  break unless flag_temp
  flag = "Yes" if i == n-1
end

puts flag