Datasets:

---

codefuse-ai

/

GALLa

like 1

Follow

CodeFuse AI 145

[ 7, 15, 13, 0, 13, 18, 18, 13, 13, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 14, 2, 2, 13, 17, 2, 13, 17, 4, 13, 17, 14, 40, 2, 13, 13, 17, 4, 13, 17, 14, 2, 2, 2, 13, 13, 17, 17, 4, 13, 17, 4, 13, 17, 10, 4, 13, 10, 4, 13, 10, 18, 13 ]

[ [ 62, 4 ], [ 59, 11 ], [ 63, 18 ], [ 59, 20 ], [ 57, 24 ], [ 60, 27 ], [ 57, 35 ], [ 60, 36 ], [ 60, 45 ], [ 57, 46 ], [ 59, 57 ], [ 59, 60 ], [ 62, 63 ] ]

[ "# n, m, l = map(int, input().split())\n\n# list_n = list(map(int, input().split()))\n\n# n = input()\n# list = [input() for i in range(N)\n\n# list = [[i for i in range(N)] for _ in range(M)]\n\nimport sys\ninput = sys.stdin.readline\n\na, b = map(int, input().split())\n\nif a > 0 and b > 0:\n print(\"Positive\")\nelif a * b <= 0:\n print(\"Zero\")\nelif (b - a) % 2 == 1:\n print(\"Positive\")\nelse:\n print(\"Negative\")", "import sys", "sys", "input = sys.stdin.readline", "input", "sys.stdin.readline", "sys.stdin", "sys", "stdin", "readline", "a, b = map(int, input().split())", "a", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "if a > 0 and b > 0:\n print(\"Positive\")\nelif a * b <= 0:\n print(\"Zero\")\nelif (b - a) % 2 == 1:\n print(\"Positive\")\nelse:\n print(\"Negative\")", "a > 0 and b > 0", "a > 0", "a", "0", "b > 0", "b", "0", "print(\"Positive\")", "print", "\"Positive\"", "elif a * b <= 0:\n print(\"Zero\")", "a * b <= 0", "a * b", "a", "b", "0", "print(\"Zero\")", "print", "\"Zero\"", "elif (b - a) % 2 == 1:\n print(\"Positive\")", "(b - a) % 2 == 1", "(b - a) % 2", "b - a", "b", "a", "2", "1", "print(\"Positive\")", "print", "\"Positive\"", "print(\"Negative\")", "print", "\"Negative\"", "a, b = map(int, input().split())", "map(int, input().split())", "a", "b = map(int, input().split())", "map(int, input().split())", "b", "input = sys.stdin.readline", "sys.stdin.readline", "input" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 14, 2, 40, 13, 17, 40, 13, 17, 4, 13, 17, 14, 2, 13, 17, 14, 2, 2, 2, 13, 13, 17, 17, 4, 13, 17, 4, 13, 17, 14, 2, 13, 17, 4, 13, 17, 10, 4, 13, 10, 4, 13 ]

[ [ 52, 2 ], [ 52, 11 ], [ 50, 15 ], [ 53, 18 ], [ 53, 25 ], [ 53, 31 ], [ 50, 32 ], [ 50, 43 ], [ 52, 50 ], [ 52, 53 ] ]

[ "a, b = map(int, input().split())\n\nif a <= 0 and b >= 0:\n print('Zero')\nif b < 0:\n if (b - a) % 2 == 0:\n print('Negative')\n else:\n print('Positive')\nif a > 0:\n print('Positive')", "a, b = map(int, input().split())", "a", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "if a <= 0 and b >= 0:\n print('Zero')", "a <= 0 and b >= 0", "a <= 0", "a", "0", "b >= 0", "b", "0", "print('Zero')", "print", "'Zero'", "if b < 0:\n if (b - a) % 2 == 0:\n print('Negative')\n else:\n print('Positive')", "b < 0", "b", "0", "if (b - a) % 2 == 0:\n print('Negative')\n else:\n print('Positive')", "(b - a) % 2 == 0", "(b - a) % 2", "b - a", "b", "a", "2", "0", "print('Negative')", "print", "'Negative'", "print('Positive')", "print", "'Positive'", "if a > 0:\n print('Positive')", "a > 0", "a", "0", "print('Positive')", "print", "'Positive'", "a, b = map(int, input().split())", "map(int, input().split())", "a", "b = map(int, input().split())", "map(int, input().split())", "b" ]

[ 7, 15, 13, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 14, 2, 40, 13, 17, 40, 13, 17, 4, 13, 17, 4, 18, 13, 13, 14, 2, 2, 13, 17, 2, 13, 17, 14, 2, 2, 2, 40, 2, 13, 13, 17, 17, 17, 4, 13, 17, 4, 18, 13, 13, 4, 13, 17, 4, 18, 13, 13, 14, 2, 2, 13, 17, 2, 13, 17, 4, 13, 17, 4, 18, 13, 13, 14, 2, 2, 13, 17, 2, 13, 17, 4, 13, 17, 4, 18, 13, 13, 14, 2, 2, 40, 13, 17, 17, 4, 13, 17, 4, 13, 17, 10, 4, 13, 10, 4, 13 ]

[ [ 111, 4 ], [ 111, 15 ], [ 109, 19 ], [ 112, 22 ], [ 109, 34 ], [ 112, 37 ], [ 109, 45 ], [ 112, 46 ], [ 109, 67 ], [ 112, 70 ], [ 109, 82 ], [ 112, 85 ], [ 109, 98 ], [ 111, 109 ], [ 111, 112 ] ]

[ "import sys\na,b = list(map(int, input().split()))\n\nif a<=0 and b>= 0:\n print(\"Zero\")\n sys.exit()\nelif a < 0 and b < 0:\n if (-(a-b)+1)%2 == 0:\n print(\"Positive\")\n sys.exit()\n else:\n print(\"Negative\")\n sys.exit()\nelif a==0 or b==0:\n print(\"Zero\")\n sys.exit()\nelif a>0 and b>0:\n print(\"Positive\")\n sys.exit()\nelse:\n if (-a)%2 == 0:\n print(\"Positive\")\n else:\n print(\"Negative\")", "import sys", "sys", "a,b = list(map(int, input().split()))", "a", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "if a<=0 and b>= 0:\n print(\"Zero\")\n sys.exit()\nelif a < 0 and b < 0:\n if (-(a-b)+1)%2 == 0:\n print(\"Positive\")\n sys.exit()\n else:\n print(\"Negative\")\n sys.exit()\nelif a==0 or b==0:\n print(\"Zero\")\n sys.exit()\nelif a>0 and b>0:\n print(\"Positive\")\n sys.exit()\nelse:\n if (-a)%2 == 0:\n print(\"Positive\")\n else:\n print(\"Negative\")", "a<=0 and b>= 0", "a<=0", "a", "0", "b>= 0", "b", "0", "print(\"Zero\")", "print", "\"Zero\"", "sys.exit()", "sys.exit", "sys", "exit", "elif a < 0 and b < 0:\n if (-(a-b)+1)%2 == 0:\n print(\"Positive\")\n sys.exit()\n else:\n print(\"Negative\")\n sys.exit()", "a < 0 and b < 0", "a < 0", "a", "0", "b < 0", "b", "0", "if (-(a-b)+1)%2 == 0:\n print(\"Positive\")\n sys.exit()\n else:\n print(\"Negative\")\n sys.exit()", "(-(a-b)+1)%2 == 0", "(-(a-b)+1)%2", "-(a-b)+1", "-(a-b)", "a-b", "a", "b", "1", "2", "0", "print(\"Positive\")", "print", "\"Positive\"", "sys.exit()", "sys.exit", "sys", "exit", "print(\"Negative\")", "print", "\"Negative\"", "sys.exit()", "sys.exit", "sys", "exit", "elif a==0 or b==0:\n print(\"Zero\")\n sys.exit()", "a==0 or b==0", "a==0", "a", "0", "b==0", "b", "0", "print(\"Zero\")", "print", "\"Zero\"", "sys.exit()", "sys.exit", "sys", "exit", "elif a>0 and b>0:\n print(\"Positive\")\n sys.exit()", "a>0 and b>0", "a>0", "a", "0", "b>0", "b", "0", "print(\"Positive\")", "print", "\"Positive\"", "sys.exit()", "sys.exit", "sys", "exit", "if (-a)%2 == 0:\n print(\"Positive\")\n else:\n print(\"Negative\")", "(-a)%2 == 0", "(-a)%2", "-a", "a", "2", "0", "print(\"Positive\")", "print", "\"Positive\"", "print(\"Negative\")", "print", "\"Negative\"", "a,b = list(map(int, input().split()))", "list(map(int, input().split()))", "a", "b = list(map(int, input().split()))", "list(map(int, input().split()))", "b" ]

[ 7, 41, 28, 13, 4, 18, 4, 13, 13, 4, 4, 13, 13, 0, 13, 13, 13, 14, 40, 40, 13, 17, 13, 4, 13, 17, 14, 2, 17, 13, 4, 13, 17, 14, 2, 2, 2, 2, 13, 13, 17, 17, 17, 4, 13, 17, 4, 13, 17, 10, 13, 13, 10, 13, 13 ]

[ [ 4, 3 ], [ 3, 12 ], [ 53, 14 ], [ 53, 16 ], [ 51, 20 ], [ 54, 22 ], [ 51, 29 ], [ 54, 38 ], [ 51, 39 ], [ 53, 51 ], [ 53, 54 ] ]

[ "a,b = [int(i) for i in input().split()]\nif a <= 0 <= b:\n print(\"Zero\")\nelif 0 < a:\n print(\"Positive\")\nelse:\n if (b - a + 1)%2 == 0:\n print(\"Positive\")\n else:\n print(\"Negative\")", "int(i) for i in input().split()", "for i in input().split()", "i", "input().split()", "().split", "()", "input", "split", "for i in input().split()", "int(i)", "int", "i", "a,b = [int(i) for i in input().split()]", "a", "[int(i) for i in input().split()]", "b", "if a <= 0 <= b:\n print(\"Zero\")\nelif 0 < a:\n print(\"Positive\")\nelse:\n if (b - a + 1)%2 == 0:\n print(\"Positive\")\n else:\n print(\"Negative\")", "a <= 0 <= b", "a <= 0", "a", "0", "b", "print(\"Zero\")", "print", "\"Zero\"", "elif 0 < a:\n print(\"Positive\")", "0 < a", "0", "a", "print(\"Positive\")", "print", "\"Positive\"", "if (b - a + 1)%2 == 0:\n print(\"Positive\")\n else:\n print(\"Negative\")", "(b - a + 1)%2 == 0", "(b - a + 1)%2", "b - a + 1", "b - a", "b", "a", "1", "2", "0", "print(\"Positive\")", "print", "\"Positive\"", "print(\"Negative\")", "print", "\"Negative\"", "a,b = [int(i) for i in input().split()]", "[int(i) for i in input().split()]", "a", "b = [int(i) for i in input().split()]", "[int(i) for i in input().split()]", "b" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 18, 4, 13, 13, 13, 17, 13, 14, 40, 2, 13, 13, 17, 4, 13, 17, 14, 2, 13, 17, 4, 13, 17, 14, 2, 2, 2, 2, 13, 13, 17, 17, 17, 4, 13, 17, 4, 13, 17, 10, 4, 13, 10, 4, 13 ]

[ [ 52, 2 ], [ 52, 15 ], [ 53, 19 ], [ 50, 20 ], [ 53, 27 ], [ 50, 37 ], [ 53, 38 ], [ 52, 50 ], [ 52, 53 ] ]

[ "a,b=map(int,input().rstrip().split(' '))\nif(a*b<=0):\n print(\"Zero\")\nelse:\n if(a>0):\n print(\"Positive\")\n else:\n if((b-a+1)%2==0):\n print(\"Positive\")\n else:\n print(\"Negative\")", "a,b=map(int,input().rstrip().split(' '))", "a", "map(int,input().rstrip().split(' '))", "map", "int", "input().rstrip().split(' ')", "().rstrip().split", "().rstrip()", "().rstrip", "()", "input", "rstrip", "split", "' '", "b", "if(a*b<=0):\n print(\"Zero\")\nelse:\n if(a>0):\n print(\"Positive\")\n else:\n if((b-a+1)%2==0):\n print(\"Positive\")\n else:\n print(\"Negative\")", "a*b<=0", "a*b", "a", "b", "0", "print(\"Zero\")", "print", "\"Zero\"", "if(a>0):\n print(\"Positive\")\n else:\n if((b-a+1)%2==0):\n print(\"Positive\")\n else:\n print(\"Negative\")", "a>0", "a", "0", "print(\"Positive\")", "print", "\"Positive\"", "if((b-a+1)%2==0):\n print(\"Positive\")\n else:\n print(\"Negative\")", "(b-a+1)%2==0", "(b-a+1)%2", "b-a+1", "b-a", "b", "a", "1", "2", "0", "print(\"Positive\")", "print", "\"Positive\"", "print(\"Negative\")", "print", "\"Negative\"", "b=map(int,input().rstrip().split(' '))", "map(int,input().rstrip().split(' '))", "b", "a,b=map(int,input().rstrip().split(' '))", "map(int,input().rstrip().split(' '))", "a" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 18, 4, 13, 17, 13, 13, 13, 14, 2, 13, 17, 4, 13, 17, 14, 2, 2, 13, 17, 2, 13, 17, 4, 13, 17, 14, 2, 2, 13, 17, 2, 13, 17, 4, 13, 17, 14, 2, 2, 2, 13, 13, 17, 17, 4, 13, 17, 4, 13, 17, 10, 4, 13, 10, 4, 13 ]

[ [ 63, 2 ], [ 63, 15 ], [ 61, 18 ], [ 61, 26 ], [ 64, 29 ], [ 61, 37 ], [ 64, 40 ], [ 64, 49 ], [ 61, 50 ], [ 63, 61 ], [ 63, 64 ] ]

[ "a, b = map(int, open(0).read().split())\n\nif a > 0:\n print('Positive')\nelif a == 0 or b == 0:\n print('Zero')\nelif a < 0 and b > 0:\n print('Zero')\nelif (b-a)%2 == 1:\n print('Positive')\nelse:\n print('Negative')", "a, b = map(int, open(0).read().split())", "a", "map(int, open(0).read().split())", "map", "int", "open(0).read().split()", "(0).read().split", "(0).read()", "(0).read", "(0)", "open", "0", "read", "split", "b", "if a > 0:\n print('Positive')\nelif a == 0 or b == 0:\n print('Zero')\nelif a < 0 and b > 0:\n print('Zero')\nelif (b-a)%2 == 1:\n print('Positive')\nelse:\n print('Negative')", "a > 0", "a", "0", "print('Positive')", "print", "'Positive'", "elif a == 0 or b == 0:\n print('Zero')", "a == 0 or b == 0", "a == 0", "a", "0", "b == 0", "b", "0", "print('Zero')", "print", "'Zero'", "elif a < 0 and b > 0:\n print('Zero')", "a < 0 and b > 0", "a < 0", "a", "0", "b > 0", "b", "0", "print('Zero')", "print", "'Zero'", "elif (b-a)%2 == 1:\n print('Positive')", "(b-a)%2 == 1", "(b-a)%2", "b-a", "b", "a", "2", "1", "print('Positive')", "print", "'Positive'", "print('Negative')", "print", "'Negative'", "a, b = map(int, open(0).read().split())", "map(int, open(0).read().split())", "a", "b = map(int, open(0).read().split())", "map(int, open(0).read().split())", "b" ]

[ 7, 15, 13, 13, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 12, 13, 12, 13, 12, 13, 12, 13, 41, 28, 13, 4, 13, 13, 4, 4, 13, 12, 13, 23, 13, 4, 18, 13, 13, 2, 17, 17, 0, 13, 4, 13, 17, 0, 13, 2, 2, 17, 17, 17, 0, 13, 4, 13, 13, 14, 40, 40, 13, 17, 13, 4, 13, 17, 14, 2, 13, 17, 4, 13, 8, 2, 2, 2, 2, 13, 13, 17, 17, 17, 17, 17, 4, 13, 17, 10, 12, 13, 10, 12, 13, 10, 4, 13, 10, 4, 13, 10, 12, 13, 10, 12, 13, 10, 4, 13, 10, 12, 13, 10, 2, 13 ]

[ [ 25, 24 ], [ 106, 30 ], [ 34, 34 ], [ 99, 43 ], [ 114, 48 ], [ 108, 55 ], [ 106, 57 ], [ 108, 58 ], [ 97, 62 ], [ 109, 64 ], [ 109, 70 ], [ 109, 79 ], [ 97, 80 ], [ 108, 97 ], [ 99, 100 ], [ 108, 109 ], [ 114, 115 ] ]

[ "import sys, re\nfrom collections import deque, defaultdict, Counter\nfrom math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians\nfrom itertools import accumulate, permutations, combinations, product\nfrom operator import itemgetter, mul\nfrom copy import deepcopy\nfrom string import ascii_lowercase, ascii_uppercase, digits\nfrom bisect import bisect, bisect_left\nfrom fractions import gcd\nfrom heapq import heappush, heappop\nfrom functools import reduce\ndef input(): return sys.stdin.readline().strip()\ndef INT(): return int(input())\ndef MAP(): return map(int, input().split())\ndef LIST(): return list(map(int, input().split()))\ndef ZIP(n): return zip(*(MAP() for _ in range(n)))\nsys.setrecursionlimit(10 ** 9)\nINF = float('inf')\nmod = 10 ** 9 + 7\n\na, b = MAP()\n\nif a <= 0 <= b:\n\tprint(\"Zero\")\nelif b < 0:\n\tprint(\"Positive\" if (b-a+1)%2 == 0 else \"Negative\")\nelse:\n\tprint(\"Positive\")", "import sys, re", "sys", "re", "from collections import deque, defaultdict, Counter", "from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians", "from itertools import accumulate, permutations, combinations, product", "from operator import itemgetter, mul", "from copy import deepcopy", "from string import ascii_lowercase, ascii_uppercase, digits", "from bisect import bisect, bisect_left", "from fractions import gcd", "from heapq import heappush, heappop", "from functools import reduce", "def input(): return sys.stdin.readline().strip()", "input", "def INT(): return int(input())", "INT", "def MAP(): return map(int, input().split())", "MAP", "def LIST(): return list(map(int, input().split()))", "LIST", "MAP() for _ in range(n)", "for _ in range(n)", "_", "range(n)", "range", "n", "for _ in range(n)", "MAP()", "MAP", "def ZIP(n): return zip(*(MAP() for _ in range(n)))", "ZIP", "n", "n", "sys.setrecursionlimit(10 ** 9)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "10 ** 9", "10", "9", "INF = float('inf')", "INF", "float('inf')", "float", "'inf'", "mod = 10 ** 9 + 7", "mod", "10 ** 9 + 7", "10 ** 9", "10", "9", "7", "a, b = MAP()", "a", "MAP()", "MAP", "b", "if a <= 0 <= b:\n\tprint(\"Zero\")\nelif b < 0:\n\tprint(\"Positive\" if (b-a+1)%2 == 0 else \"Negative\")\nelse:\n\tprint(\"Positive\")", "a <= 0 <= b", "a <= 0", "a", "0", "b", "print(\"Zero\")", "print", "\"Zero\"", "elif b < 0:\n\tprint(\"Positive\" if (b-a+1)%2 == 0 else \"Negative\")", "b < 0", "b", "0", "print(\"Positive\" if (b-a+1)%2 == 0 else \"Negative\")", "print", "\"Positive\" if (b-a+1)%2 == 0 else \"Negative\"", "(b-a+1)%2 == 0", "(b-a+1)%2", "b-a+1", "b-a", "b", "a", "1", "2", "0", "\"Positive\"", "\"Negative\"", "print(\"Positive\")", "print", "\"Positive\"", "def INT(): return int(input())", "def INT(): return int(input())", "INT", "def LIST(): return list(map(int, input().split()))", "def LIST(): return list(map(int, input().split()))", "LIST", "a, b = MAP()", "MAP()", "a", "INF = float('inf')", "float('inf')", "INF", "def ZIP(n): return zip(*(MAP() for _ in range(n)))", "def ZIP(n): return zip(*(MAP() for _ in range(n)))", "ZIP", "def MAP(): return map(int, input().split())", "def MAP(): return map(int, input().split())", "MAP", "b = MAP()", "MAP()", "b", "def input(): return sys.stdin.readline().strip()", "def input(): return sys.stdin.readline().strip()", "input", "mod = 10 ** 9 + 7", "10 ** 9 + 7", "mod" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 17, 4, 13, 8, 2, 17, 13, 13, 8, 2, 2, 13, 17, 13, 17, 8, 2, 2, 13, 17, 2, 40, 40, 2, 13, 13, 17, 17, 13, 10, 4, 13, 10, 17, 13, 10, 4, 13 ]

[ [ 50, 2 ], [ 50, 11 ], [ 47, 13 ], [ 45, 20 ], [ 48, 21 ], [ 45, 25 ], [ 51, 27 ], [ 51, 32 ], [ 51, 38 ], [ 45, 39 ], [ 48, 42 ], [ 50, 45 ], [ 47, 48 ], [ 50, 51 ] ]

[ "a, b = map(int, input().split())\np = \"Positive\"\nprint(p if 0<a else \"Zero\" if a<0<b else \"Negative\" if b<0 and -~(b-a)%2 else p)", "a, b = map(int, input().split())", "a", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "p = \"Positive\"", "p", "\"Positive\"", "print(p if 0<a else \"Zero\" if a<0<b else \"Negative\" if b<0 and -~(b-a)%2 else p)", "print", "p if 0<a else \"Zero\" if a<0<b else \"Negative\" if b<0 and -~(b-a)%2 else p", "0<a", "0", "a", "p", "\"Zero\" if a<0<b else \"Negative\" if b<0 and -~(b-a)%2 else p", "a<0<b", "a<0", "a", "0", "b", "\"Zero\"", "\"Negative\" if b<0 and -~(b-a)%2 else p", "b<0 and -~(b-a)%2", "b<0", "b", "0", "-~(b-a)%2", "-~(b-a)", "~(b-a)", "b-a", "b", "a", "2", "\"Negative\"", "p", "a, b = map(int, input().split())", "map(int, input().split())", "a", "p = \"Positive\"", "\"Positive\"", "p", "b = map(int, input().split())", "map(int, input().split())", "b" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 14, 2, 40, 13, 17, 40, 13, 17, 4, 13, 17, 14, 2, 13, 17, 8, 2, 2, 2, 2, 13, 13, 17, 17, 17, 4, 13, 17, 4, 13, 17, 4, 13, 17, 10, 4, 13, 10, 4, 13 ]

[ [ 50, 2 ], [ 50, 11 ], [ 51, 15 ], [ 48, 18 ], [ 48, 25 ], [ 48, 32 ], [ 51, 33 ], [ 50, 48 ], [ 50, 51 ] ]

[ "a,b = map(int,input().split())\n\nif a <= 0 and b >= 0:\n\tprint(\"Zero\")\nelif b < 0: \n\tprint(\"Positive\") if (b - a + 1) % 2 == 0 else print(\"Negative\")\nelse:\n\tprint(\"Positive\")", "a,b = map(int,input().split())", "a", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "if a <= 0 and b >= 0:\n\tprint(\"Zero\")\nelif b < 0: \n\tprint(\"Positive\") if (b - a + 1) % 2 == 0 else print(\"Negative\")\nelse:\n\tprint(\"Positive\")", "a <= 0 and b >= 0", "a <= 0", "a", "0", "b >= 0", "b", "0", "print(\"Zero\")", "print", "\"Zero\"", "elif b < 0: \n\tprint(\"Positive\") if (b - a + 1) % 2 == 0 else print(\"Negative\")", "b < 0", "b", "0", "print(\"Positive\") if (b - a + 1) % 2 == 0 else print(\"Negative\")", "(b - a + 1) % 2 == 0", "(b - a + 1) % 2", "b - a + 1", "b - a", "b", "a", "1", "2", "0", "print(\"Positive\")", "print", "\"Positive\"", "print(\"Negative\")", "print", "\"Negative\"", "print(\"Positive\")", "print", "\"Positive\"", "b = map(int,input().split())", "map(int,input().split())", "b", "a,b = map(int,input().split())", "map(int,input().split())", "a" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 17, 14, 2, 40, 13, 17, 40, 17, 13, 4, 13, 17, 14, 2, 13, 17, 14, 2, 13, 17, 0, 13, 2, 2, 13, 13, 17, 0, 13, 4, 13, 13, 14, 2, 13, 17, 4, 13, 17, 4, 13, 17, 4, 13, 17, 10, 4, 13, 10, 4, 13, 10, 17, 13, 10, 2, 13, 10, 4, 13 ]

[ [ 72, 2 ], [ 72, 11 ], [ 66, 13 ], [ 61, 18 ], [ 73, 22 ], [ 61, 28 ], [ 73, 32 ], [ 69, 35 ], [ 61, 38 ], [ 73, 39 ], [ 63, 42 ], [ 61, 45 ], [ 64, 48 ], [ 70, 48 ], [ 67, 48 ], [ 72, 61 ], [ 63, 64 ], [ 66, 67 ], [ 69, 70 ], [ 72, 73 ] ]

[ "a,b = map(int,input().split())\nm = 0\nif a<=0 and 0<=b:\n print('Zero')\nelif a<0:\n if b < 0:\n m = a-b+1\n else:\n m = abs(a)\n if m%2:\n print('Negative')\n else:\n print('Positive')\nelse:\n print('Positive')", "a,b = map(int,input().split())", "a", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "m = 0", "m", "0", "if a<=0 and 0<=b:\n print('Zero')\nelif a<0:\n if b < 0:\n m = a-b+1\n else:\n m = abs(a)\n if m%2:\n print('Negative')\n else:\n print('Positive')\nelse:\n print('Positive')", "a<=0 and 0<=b", "a<=0", "a", "0", "0<=b", "0", "b", "print('Zero')", "print", "'Zero'", "elif a<0:\n if b < 0:\n m = a-b+1\n else:\n m = abs(a)\n if m%2:\n print('Negative')\n else:\n print('Positive')", "a<0", "a", "0", "if b < 0:\n m = a-b+1\n else:\n m = abs(a)\n ", "b < 0", "b", "0", "m = a-b+1", "m", "a-b+1", "a-b", "a", "b", "1", "m = abs(a)", "m", "abs(a)", "abs", "a", "if m%2:\n print('Negative')\n else:\n print('Positive')", "m%2", "m", "2", "print('Negative')", "print", "'Negative'", "print('Positive')", "print", "'Positive'", "print('Positive')", "print", "'Positive'", "a,b = map(int,input().split())", "map(int,input().split())", "a", "m = abs(a)", "abs(a)", "m", "m = 0", "0", "m", "m = a-b+1", "a-b+1", "m", "b = map(int,input().split())", "map(int,input().split())", "b" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 14, 40, 40, 13, 17, 13, 4, 13, 17, 14, 2, 2, 4, 13, 17, 13, 13, 17, 4, 13, 17, 4, 13, 17, 10, 4, 13, 10, 4, 13 ]

[ [ 40, 2 ], [ 40, 11 ], [ 41, 15 ], [ 38, 17 ], [ 38, 27 ], [ 41, 28 ], [ 40, 38 ], [ 40, 41 ] ]

[ "a,b=map(int,input().split())\nif a<=0<=b:\n print (\"Zero\")\nelif (min(0,b)-a)%2:\n print (\"Positive\")\nelse:\n print (\"Negative\")", "a,b=map(int,input().split())", "a", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "if a<=0<=b:\n print (\"Zero\")\nelif (min(0,b)-a)%2:\n print (\"Positive\")\nelse:\n print (\"Negative\")", "a<=0<=b", "a<=0", "a", "0", "b", "print (\"Zero\")", "print", "\"Zero\"", "elif (min(0,b)-a)%2:\n print (\"Positive\")", "(min(0,b)-a)%2", "min(0,b)-a", "min(0,b)", "min", "0", "b", "a", "2", "print (\"Positive\")", "print", "\"Positive\"", "print (\"Negative\")", "print", "\"Negative\"", "b=map(int,input().split())", "map(int,input().split())", "b", "a,b=map(int,input().split())", "map(int,input().split())", "a" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 14, 40, 2, 13, 13, 17, 4, 13, 17, 14, 2, 2, 13, 17, 2, 13, 13, 4, 13, 17, 14, 2, 2, 4, 13, 2, 13, 13, 17, 17, 4, 13, 17, 4, 13, 17, 10, 4, 13, 10, 4, 13 ]

[ [ 52, 2 ], [ 52, 11 ], [ 50, 15 ], [ 53, 16 ], [ 50, 24 ], [ 50, 27 ], [ 53, 28 ], [ 50, 38 ], [ 53, 39 ], [ 52, 50 ], [ 52, 53 ] ]

[ "a,b=map(int,input().split())\nif a*b<=0:\n print(\"Zero\")\nelif a>0 or a==b:\n print(\"Positive\")\nelse:\n if abs(a-b) % 2 == 0:\n print(\"Negative\")\n else:\n print(\"Positive\")", "a,b=map(int,input().split())", "a", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "if a*b<=0:\n print(\"Zero\")\nelif a>0 or a==b:\n print(\"Positive\")\nelse:\n if abs(a-b) % 2 == 0:\n print(\"Negative\")\n else:\n print(\"Positive\")", "a*b<=0", "a*b", "a", "b", "0", "print(\"Zero\")", "print", "\"Zero\"", "elif a>0 or a==b:\n print(\"Positive\")", "a>0 or a==b", "a>0", "a", "0", "a==b", "a", "b", "print(\"Positive\")", "print", "\"Positive\"", "if abs(a-b) % 2 == 0:\n print(\"Negative\")\n else:\n print(\"Positive\")", "abs(a-b) % 2 == 0", "abs(a-b) % 2", "abs(a-b)", "abs", "a-b", "a", "b", "2", "0", "print(\"Negative\")", "print", "\"Negative\"", "print(\"Positive\")", "print", "\"Positive\"", "a,b=map(int,input().split())", "map(int,input().split())", "a", "b=map(int,input().split())", "map(int,input().split())", "b" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 14, 2, 2, 13, 17, 2, 13, 17, 4, 13, 17, 14, 2, 40, 13, 17, 40, 13, 17, 4, 13, 17, 14, 2, 2, 2, 4, 13, 2, 13, 13, 17, 17, 17, 4, 13, 17, 14, 2, 2, 2, 4, 13, 2, 13, 13, 17, 17, 17, 4, 13, 17, 10, 4, 13, 10, 4, 13 ]

[ [ 68, 2 ], [ 68, 11 ], [ 69, 15 ], [ 66, 18 ], [ 69, 26 ], [ 66, 29 ], [ 66, 41 ], [ 69, 42 ], [ 66, 56 ], [ 69, 57 ], [ 68, 66 ], [ 68, 69 ] ]

[ "a,b=map(int,input().split())\nif a>0 and b>0:\n print(\"Positive\")\nelif a<=0 and b>=0:\n print(\"Zero\")\nelif (abs(b-a)+1)%2==0:\n print(\"Positive\")\nelif (abs(b-a)+1)%2==1:\n print(\"Negative\")", "a,b=map(int,input().split())", "a", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "if a>0 and b>0:\n print(\"Positive\")\nelif a<=0 and b>=0:\n print(\"Zero\")\nelif (abs(b-a)+1)%2==0:\n print(\"Positive\")\nelif (abs(b-a)+1)%2==1:\n print(\"Negative\")", "a>0 and b>0", "a>0", "a", "0", "b>0", "b", "0", "print(\"Positive\")", "print", "\"Positive\"", "elif a<=0 and b>=0:\n print(\"Zero\")", "a<=0 and b>=0", "a<=0", "a", "0", "b>=0", "b", "0", "print(\"Zero\")", "print", "\"Zero\"", "elif (abs(b-a)+1)%2==0:\n print(\"Positive\")", "(abs(b-a)+1)%2==0", "(abs(b-a)+1)%2", "abs(b-a)+1", "abs(b-a)", "abs", "b-a", "b", "a", "1", "2", "0", "print(\"Positive\")", "print", "\"Positive\"", "elif (abs(b-a)+1)%2==1:\n print(\"Negative\")", "(abs(b-a)+1)%2==1", "(abs(b-a)+1)%2", "abs(b-a)+1", "abs(b-a)", "abs", "b-a", "b", "a", "1", "2", "1", "print(\"Negative\")", "print", "\"Negative\"", "b=map(int,input().split())", "map(int,input().split())", "b", "a,b=map(int,input().split())", "map(int,input().split())", "a" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 14, 2, 13, 17, 4, 13, 17, 14, 40, 40, 13, 17, 13, 4, 13, 17, 14, 2, 2, 2, 2, 13, 13, 17, 17, 17, 4, 13, 17, 4, 13, 17, 10, 4, 13, 10, 4, 13 ]

[ [ 48, 2 ], [ 48, 11 ], [ 46, 14 ], [ 49, 22 ], [ 46, 24 ], [ 49, 33 ], [ 46, 34 ], [ 48, 46 ], [ 48, 49 ] ]

[ "a,b = map(int,input().split())\n\nif a>0:\n print(\"Positive\")\nelif b >= 0 >= a:\n print(\"Zero\")\nelif (b-a+1)%2==0:\n print(\"Positive\")\nelse:\n print(\"Negative\")", "a,b = map(int,input().split())", "a", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "if a>0:\n print(\"Positive\")\nelif b >= 0 >= a:\n print(\"Zero\")\nelif (b-a+1)%2==0:\n print(\"Positive\")\nelse:\n print(\"Negative\")", "a>0", "a", "0", "print(\"Positive\")", "print", "\"Positive\"", "elif b >= 0 >= a:\n print(\"Zero\")", "b >= 0 >= a", "b >= 0", "b", "0", "a", "print(\"Zero\")", "print", "\"Zero\"", "elif (b-a+1)%2==0:\n print(\"Positive\")", "(b-a+1)%2==0", "(b-a+1)%2", "b-a+1", "b-a", "b", "a", "1", "2", "0", "print(\"Positive\")", "print", "\"Positive\"", "print(\"Negative\")", "print", "\"Negative\"", "a,b = map(int,input().split())", "map(int,input().split())", "a", "b = map(int,input().split())", "map(int,input().split())", "b" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 14, 2, 13, 17, 4, 13, 17, 14, 40, 2, 13, 13, 17, 4, 13, 17, 14, 2, 13, 17, 14, 2, 2, 2, 13, 13, 17, 17, 4, 13, 17, 4, 13, 17, 10, 4, 13, 10, 4, 13 ]

[ [ 50, 2 ], [ 50, 11 ], [ 51, 14 ], [ 51, 22 ], [ 48, 23 ], [ 48, 30 ], [ 48, 36 ], [ 51, 37 ], [ 50, 48 ], [ 50, 51 ] ]

[ "a, b = map(int, input().split())\n\nif a > 0:\n print('Positive')\nelif a * b <= 0:\n print('Zero')\nelif b < 0:\n if (b - a) % 2 == 0:\n print('Negative')\n else:\n print('Positive')", "a, b = map(int, input().split())", "a", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "if a > 0:\n print('Positive')\nelif a * b <= 0:\n print('Zero')\nelif b < 0:\n if (b - a) % 2 == 0:\n print('Negative')\n else:\n print('Positive')", "a > 0", "a", "0", "print('Positive')", "print", "'Positive'", "elif a * b <= 0:\n print('Zero')", "a * b <= 0", "a * b", "a", "b", "0", "print('Zero')", "print", "'Zero'", "elif b < 0:\n if (b - a) % 2 == 0:\n print('Negative')\n else:\n print('Positive')", "b < 0", "b", "0", "if (b - a) % 2 == 0:\n print('Negative')\n else:\n print('Positive')", "(b - a) % 2 == 0", "(b - a) % 2", "b - a", "b", "a", "2", "0", "print('Negative')", "print", "'Negative'", "print('Positive')", "print", "'Positive'", "b = map(int, input().split())", "map(int, input().split())", "b", "a, b = map(int, input().split())", "map(int, input().split())", "a" ]

[ 7, 41, 28, 13, 4, 18, 4, 13, 13, 4, 4, 13, 13, 0, 13, 13, 13, 14, 2, 13, 17, 4, 13, 17, 14, 2, 2, 13, 17, 2, 13, 17, 4, 13, 17, 14, 2, 2, 2, 13, 13, 17, 17, 4, 13, 17, 4, 13, 17, 10, 13, 13, 10, 13, 13 ]

[ [ 4, 3 ], [ 3, 12 ], [ 53, 14 ], [ 53, 16 ], [ 51, 19 ], [ 51, 27 ], [ 54, 30 ], [ 54, 39 ], [ 51, 40 ], [ 53, 51 ], [ 53, 54 ] ]

[ "a,b = [int(i) for i in input().split()]\n\nif a>0:\n print('Positive')\n\nelif a<0 and b>0:\n print('Zero')\n\nelif (b-a)%2 == 0:\n print('Negative')\nelse:\n print('Positive')", "int(i) for i in input().split()", "for i in input().split()", "i", "input().split()", "().split", "()", "input", "split", "for i in input().split()", "int(i)", "int", "i", "a,b = [int(i) for i in input().split()]", "a", "[int(i) for i in input().split()]", "b", "if a>0:\n print('Positive')\n\nelif a<0 and b>0:\n print('Zero')\n\nelif (b-a)%2 == 0:\n print('Negative')\nelse:\n print('Positive')", "a>0", "a", "0", "print('Positive')", "print", "'Positive'", "elif a<0 and b>0:\n print('Zero')", "a<0 and b>0", "a<0", "a", "0", "b>0", "b", "0", "print('Zero')", "print", "'Zero'", "elif (b-a)%2 == 0:\n print('Negative')", "(b-a)%2 == 0", "(b-a)%2", "b-a", "b", "a", "2", "0", "print('Negative')", "print", "'Negative'", "print('Positive')", "print", "'Positive'", "a,b = [int(i) for i in input().split()]", "[int(i) for i in input().split()]", "a", "b = [int(i) for i in input().split()]", "[int(i) for i in input().split()]", "b" ]

[ 7, 15, 13, 15, 13, 0, 13, 12, 2, 4, 13, 13, 17, 23, 0, 13, 18, 18, 18, 13, 13, 13, 13, 0, 13, 18, 18, 18, 13, 13, 13, 13, 0, 13, 18, 18, 18, 13, 13, 13, 13, 4, 18, 13, 13, 17, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 14, 2, 40, 13, 17, 40, 13, 17, 4, 13, 17, 14, 2, 13, 17, 4, 13, 17, 8, 2, 2, 2, 2, 13, 13, 17, 17, 17, 4, 13, 17, 4, 13, 17, 10, 18, 13, 10, 4, 13, 10, 18, 13, 10, 4, 13, 10, 18, 13, 10, 12, 13 ]

[ [ 107, 6 ], [ 98, 15 ], [ 104, 24 ], [ 92, 33 ], [ 101, 47 ], [ 105, 54 ], [ 101, 56 ], [ 102, 60 ], [ 96, 63 ], [ 102, 70 ], [ 96, 80 ], [ 102, 81 ], [ 92, 93 ], [ 101, 96 ], [ 98, 99 ], [ 101, 102 ], [ 104, 105 ], [ 107, 108 ] ]

[ "#! /usr/bin/env python3\n\nimport sys\nimport numpy as np\nint1 = lambda x: int(x) - 1\nread = sys.stdin.buffer.read\nreadline = sys.stdin.buffer.readline\nreadlines = sys.stdin.buffer.readlines\nsys.setrecursionlimit(500000)\n\nA, B = map(int, readline().split())\n\nif A <= 0 and B >= 0:\n print(\"Zero\")\nelif A > 0:\n print(\"Positive\")\nelse:\n print(\"Positive\") if (B - A + 1) % 2 == 0 else print(\"Negative\")", "import sys", "sys", "import numpy as np", "numpy", "int1 = lambda x: int(x) - 1", "int1", "lambda x: int(x) - 1", "int(x) - 1", "int(x)", "int", "x", "1", "x", "read = sys.stdin.buffer.read", "read", "sys.stdin.buffer.read", "sys.stdin.buffer", "sys.stdin", "sys", "stdin", "buffer", "read", "readline = sys.stdin.buffer.readline", "readline", "sys.stdin.buffer.readline", "sys.stdin.buffer", "sys.stdin", "sys", "stdin", "buffer", "readline", "readlines = sys.stdin.buffer.readlines", "readlines", "sys.stdin.buffer.readlines", "sys.stdin.buffer", "sys.stdin", "sys", "stdin", "buffer", "readlines", "sys.setrecursionlimit(500000)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "500000", "A, B = map(int, readline().split())", "A", "map(int, readline().split())", "map", "int", "readline().split()", "().split", "()", "readline", "split", "B", "if A <= 0 and B >= 0:\n print(\"Zero\")\nelif A > 0:\n print(\"Positive\")\nelse:\n print(\"Positive\") if (B - A + 1) % 2 == 0 else print(\"Negative\")", "A <= 0 and B >= 0", "A <= 0", "A", "0", "B >= 0", "B", "0", "print(\"Zero\")", "print", "\"Zero\"", "elif A > 0:\n print(\"Positive\")", "A > 0", "A", "0", "print(\"Positive\")", "print", "\"Positive\"", "print(\"Positive\") if (B - A + 1) % 2 == 0 else print(\"Negative\")", "(B - A + 1) % 2 == 0", "(B - A + 1) % 2", "B - A + 1", "B - A", "B", "A", "1", "2", "0", "print(\"Positive\")", "print", "\"Positive\"", "print(\"Negative\")", "print", "\"Negative\"", "readlines = sys.stdin.buffer.readlines", "sys.stdin.buffer.readlines", "readlines", "B = map(int, readline().split())", "map(int, readline().split())", "B", "read = sys.stdin.buffer.read", "sys.stdin.buffer.read", "read", "A, B = map(int, readline().split())", "map(int, readline().split())", "A", "readline = sys.stdin.buffer.readline", "sys.stdin.buffer.readline", "readline", "int1 = lambda x: int(x) - 1", "lambda x: int(x) - 1", "int1" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 17, 14, 40, 13, 17, 14, 40, 13, 17, 0, 13, 17, 0, 13, 17, 14, 2, 2, 2, 13, 13, 17, 17, 0, 13, 17, 0, 13, 17, 4, 13, 13, 10, 4, 13, 10, 17, 13, 10, 4, 13, 10, 17, 13, 10, 17, 13, 10, 17, 13, 10, 17, 13 ]

[ [ 53, 2 ], [ 53, 11 ], [ 59, 13 ], [ 48, 17 ], [ 54, 21 ], [ 65, 24 ], [ 56, 27 ], [ 48, 33 ], [ 54, 34 ], [ 62, 38 ], [ 50, 41 ], [ 51, 45 ], [ 63, 45 ], [ 57, 45 ], [ 66, 45 ], [ 60, 45 ], [ 53, 48 ], [ 50, 51 ], [ 53, 54 ], [ 56, 57 ], [ 59, 60 ], [ 62, 63 ], [ 65, 66 ] ]

[ "a, b = map(int, input().split())\nres = ''\nif b >= 0:\n if a <= 0:\n res = 'Zero'\n else:\n res = 'Positive'\nelse:\n if (b - a) % 2 == 0:\n res = 'Negative'\n else:\n res = 'Positive'\nprint(res)", "a, b = map(int, input().split())", "a", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "res = ''", "res", "''", "if b >= 0:\n if a <= 0:\n res = 'Zero'\n else:\n res = 'Positive'\nelse:\n if (b - a) % 2 == 0:\n res = 'Negative'\n else:\n res = 'Positive'", "b >= 0", "b", "0", "if a <= 0:\n res = 'Zero'\n else:\n res = 'Positive'", "a <= 0", "a", "0", "res = 'Zero'", "res", "'Zero'", "res = 'Positive'", "res", "'Positive'", "if (b - a) % 2 == 0:\n res = 'Negative'\n else:\n res = 'Positive'", "(b - a) % 2 == 0", "(b - a) % 2", "b - a", "b", "a", "2", "0", "res = 'Negative'", "res", "'Negative'", "res = 'Positive'", "res", "'Positive'", "print(res)", "print", "res", "b = map(int, input().split())", "map(int, input().split())", "b", "res = 'Positive'", "'Positive'", "res", "a, b = map(int, input().split())", "map(int, input().split())", "a", "res = 'Positive'", "'Positive'", "res", "res = ''", "''", "res", "res = 'Negative'", "'Negative'", "res", "res = 'Zero'", "'Zero'", "res" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 14, 2, 17, 13, 4, 13, 17, 14, 2, 2, 13, 17, 40, 17, 13, 4, 13, 17, 0, 13, 4, 13, 2, 2, 13, 13, 17, 14, 2, 2, 13, 17, 17, 4, 13, 17, 4, 13, 17, 10, 4, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 55, 2 ], [ 55, 11 ], [ 56, 15 ], [ 56, 22 ], [ 53, 26 ], [ 58, 31 ], [ 56, 36 ], [ 53, 37 ], [ 59, 42 ], [ 55, 53 ], [ 55, 56 ], [ 58, 59 ] ]

[ "a, b = map(int, input().split())\n\nif 0 < a:\n print(\"Positive\")\nelif a == 0 or 0 <= b:\n print(\"Zero\")\nelse:\n length = abs(a + b + 1)\n if length % 2 == 0:\n print(\"Positive\")\n else:\n print(\"Negative\")", "a, b = map(int, input().split())", "a", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "if 0 < a:\n print(\"Positive\")\nelif a == 0 or 0 <= b:\n print(\"Zero\")\nelse:\n length = abs(a + b + 1)\n if length % 2 == 0:\n print(\"Positive\")\n else:\n print(\"Negative\")", "0 < a", "0", "a", "print(\"Positive\")", "print", "\"Positive\"", "elif a == 0 or 0 <= b:\n print(\"Zero\")", "a == 0 or 0 <= b", "a == 0", "a", "0", "0 <= b", "0", "b", "print(\"Zero\")", "print", "\"Zero\"", "length = abs(a + b + 1)", "length", "abs(a + b + 1)", "abs", "a + b + 1", "a + b", "a", "b", "1", "if length % 2 == 0:\n print(\"Positive\")\n else:\n print(\"Negative\")", "length % 2 == 0", "length % 2", "length", "2", "0", "print(\"Positive\")", "print", "\"Positive\"", "print(\"Negative\")", "print", "\"Negative\"", "b = map(int, input().split())", "map(int, input().split())", "b", "a, b = map(int, input().split())", "map(int, input().split())", "a", "length = abs(a + b + 1)", "abs(a + b + 1)", "length" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 14, 2, 2, 13, 17, 2, 13, 17, 4, 13, 17, 14, 2, 40, 13, 17, 40, 13, 17, 4, 13, 17, 14, 2, 2, 2, 2, 13, 13, 17, 17, 17, 4, 13, 17, 4, 13, 17, 10, 4, 13, 10, 4, 13 ]

[ [ 54, 2 ], [ 54, 11 ], [ 55, 15 ], [ 52, 18 ], [ 55, 26 ], [ 52, 29 ], [ 52, 39 ], [ 55, 40 ], [ 54, 52 ], [ 54, 55 ] ]

[ "a, b = map(int, input().split())\n\nif (a > 0) & (b > 0):\n print('Positive')\nelif (a <= 0) & (b >= 0):\n print('Zero')\nelse:\n if (b - a + 1) % 2 == 1:\n print('Negative')\n else:\n print('Positive')", "a, b = map(int, input().split())", "a", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "if (a > 0) & (b > 0):\n print('Positive')\nelif (a <= 0) & (b >= 0):\n print('Zero')\nelse:\n if (b - a + 1) % 2 == 1:\n print('Negative')\n else:\n print('Positive')", "(a > 0) & (b > 0)", "a > 0", "a", "0", "b > 0", "b", "0", "print('Positive')", "print", "'Positive'", "elif (a <= 0) & (b >= 0):\n print('Zero')", "(a <= 0) & (b >= 0)", "a <= 0", "a", "0", "b >= 0", "b", "0", "print('Zero')", "print", "'Zero'", "if (b - a + 1) % 2 == 1:\n print('Negative')\n else:\n print('Positive')", "(b - a + 1) % 2 == 1", "(b - a + 1) % 2", "b - a + 1", "b - a", "b", "a", "1", "2", "1", "print('Negative')", "print", "'Negative'", "print('Positive')", "print", "'Positive'", "b = map(int, input().split())", "map(int, input().split())", "b", "a, b = map(int, input().split())", "map(int, input().split())", "a" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 14, 2, 40, 13, 17, 40, 13, 17, 4, 13, 17, 4, 13, 14, 2, 13, 17, 4, 13, 17, 4, 13, 0, 13, 17, 28, 13, 4, 13, 13, 2, 13, 17, 0, 13, 17, 14, 2, 2, 13, 17, 17, 4, 13, 17, 4, 13, 17, 10, 4, 13, 10, 17, 13, 10, 4, 13, 10, 17, 13 ]

[ [ 67, 2 ], [ 67, 11 ], [ 68, 15 ], [ 62, 18 ], [ 68, 27 ], [ 70, 35 ], [ 39, 38 ], [ 68, 41 ], [ 62, 43 ], [ 64, 46 ], [ 65, 51 ], [ 71, 51 ], [ 67, 62 ], [ 64, 65 ], [ 67, 68 ], [ 70, 71 ] ]

[ "a,b=map(int,input().split())\nif a<=0 and b>=0:\n print(\"Zero\")\n exit()\nif a>0:\n print(\"Positive\")\n exit()\ntmp=0\nfor i in range(a,b+1):\n tmp+=1\nif tmp%2==0:\n print(\"Positive\")\nelse:\n print(\"Negative\")", "a,b=map(int,input().split())", "a", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "if a<=0 and b>=0:\n print(\"Zero\")\n exit()", "a<=0 and b>=0", "a<=0", "a", "0", "b>=0", "b", "0", "print(\"Zero\")", "print", "\"Zero\"", "exit()", "exit", "if a>0:\n print(\"Positive\")\n exit()", "a>0", "a", "0", "print(\"Positive\")", "print", "\"Positive\"", "exit()", "exit", "tmp=0", "tmp", "0", "for i in range(a,b+1):\n tmp+=1", "i", "range(a,b+1)", "range", "a", "b+1", "b", "1", "tmp+=1", "tmp", "1", "if tmp%2==0:\n print(\"Positive\")\nelse:\n print(\"Negative\")", "tmp%2==0", "tmp%2", "tmp", "2", "0", "print(\"Positive\")", "print", "\"Positive\"", "print(\"Negative\")", "print", "\"Negative\"", "b=map(int,input().split())", "map(int,input().split())", "b", "tmp+=1", "1", "tmp", "a,b=map(int,input().split())", "map(int,input().split())", "a", "tmp=0", "0", "tmp" ]

[ 7, 15, 13, 0, 13, 18, 18, 13, 13, 13, 4, 18, 13, 13, 2, 17, 17, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 14, 2, 13, 17, 4, 13, 17, 4, 18, 13, 13, 17, 14, 2, 13, 17, 4, 13, 17, 4, 18, 13, 13, 17, 14, 2, 13, 17, 14, 40, 13, 17, 4, 13, 17, 4, 18, 13, 13, 17, 14, 2, 13, 17, 0, 13, 2, 2, 13, 13, 17, 14, 2, 2, 13, 17, 17, 4, 13, 17, 4, 13, 17, 10, 4, 13, 10, 4, 13, 10, 2, 13, 10, 18, 13 ]

[ [ 101, 4 ], [ 95, 18 ], [ 102, 25 ], [ 95, 27 ], [ 93, 30 ], [ 93, 42 ], [ 93, 54 ], [ 96, 58 ], [ 96, 70 ], [ 98, 73 ], [ 96, 76 ], [ 93, 77 ], [ 99, 82 ], [ 95, 93 ], [ 95, 96 ], [ 98, 99 ], [ 101, 102 ] ]

[ "import sys\ninput = sys.stdin.readline\nsys.setrecursionlimit(10 ** 7)\n\na, b = map(int, input().split())\n\nif a > 0:\n print('Positive')\n sys.exit(0)\nif a == 0:\n print('Zero')\n sys.exit(0)\nif a < 0:\n if b >= 0:\n print('Zero')\n sys.exit(0)\n if b < 0:\n diff = (b - a) + 1\n if diff % 2 == 0:\n print('Positive')\n else:\n print('Negative')", "import sys", "sys", "input = sys.stdin.readline", "input", "sys.stdin.readline", "sys.stdin", "sys", "stdin", "readline", "sys.setrecursionlimit(10 ** 7)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "10 ** 7", "10", "7", "a, b = map(int, input().split())", "a", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "if a > 0:\n print('Positive')\n sys.exit(0)", "a > 0", "a", "0", "print('Positive')", "print", "'Positive'", "sys.exit(0)", "sys.exit", "sys", "exit", "0", "if a == 0:\n print('Zero')\n sys.exit(0)", "a == 0", "a", "0", "print('Zero')", "print", "'Zero'", "sys.exit(0)", "sys.exit", "sys", "exit", "0", "if a < 0:\n if b >= 0:\n print('Zero')\n sys.exit(0)\n if b < 0:\n diff = (b - a) + 1\n if diff % 2 == 0:\n print('Positive')\n else:\n print('Negative')", "a < 0", "a", "0", "if b >= 0:\n print('Zero')\n sys.exit(0)\n ", "b >= 0", "b", "0", "print('Zero')", "print", "'Zero'", "sys.exit(0)", "sys.exit", "sys", "exit", "0", "if b < 0:\n diff = (b - a) + 1\n if diff % 2 == 0:\n print('Positive')\n else:\n print('Negative')", "b < 0", "b", "0", "diff = (b - a) + 1", "diff", "(b - a) + 1", "b - a", "b", "a", "1", "if diff % 2 == 0:\n print('Positive')\n else:\n print('Negative')", "diff % 2 == 0", "diff % 2", "diff", "2", "0", "print('Positive')", "print", "'Positive'", "print('Negative')", "print", "'Negative'", "a, b = map(int, input().split())", "map(int, input().split())", "a", "b = map(int, input().split())", "map(int, input().split())", "b", "diff = (b - a) + 1", "(b - a) + 1", "diff", "input = sys.stdin.readline", "sys.stdin.readline", "input" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 14, 2, 40, 13, 17, 40, 13, 17, 4, 13, 17, 14, 2, 2, 13, 17, 2, 13, 17, 4, 13, 17, 14, 2, 2, 2, 2, 13, 13, 17, 17, 17, 4, 13, 17, 4, 13, 17, 10, 4, 13, 10, 4, 13 ]

[ [ 54, 2 ], [ 54, 11 ], [ 52, 15 ], [ 55, 18 ], [ 52, 26 ], [ 55, 29 ], [ 55, 39 ], [ 52, 40 ], [ 54, 52 ], [ 54, 55 ] ]

[ "a,b=map(int,input().split())\nif (a<=0)&(b>=0):\n print(\"Zero\")\nelif(a>0)&(b>0):\n print(\"Positive\")\nelse:\n if (b-a+1)%2==0:\n print(\"Positive\")\n else:\n print(\"Negative\")", "a,b=map(int,input().split())", "a", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "if (a<=0)&(b>=0):\n print(\"Zero\")\nelif(a>0)&(b>0):\n print(\"Positive\")\nelse:\n if (b-a+1)%2==0:\n print(\"Positive\")\n else:\n print(\"Negative\")", "(a<=0)&(b>=0)", "a<=0", "a", "0", "b>=0", "b", "0", "print(\"Zero\")", "print", "\"Zero\"", "elif(a>0)&(b>0):\n print(\"Positive\")", "(a>0)&(b>0)", "a>0", "a", "0", "b>0", "b", "0", "print(\"Positive\")", "print", "\"Positive\"", "if (b-a+1)%2==0:\n print(\"Positive\")\n else:\n print(\"Negative\")", "(b-a+1)%2==0", "(b-a+1)%2", "b-a+1", "b-a", "b", "a", "1", "2", "0", "print(\"Positive\")", "print", "\"Positive\"", "print(\"Negative\")", "print", "\"Negative\"", "a,b=map(int,input().split())", "map(int,input().split())", "a", "b=map(int,input().split())", "map(int,input().split())", "b" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 14, 2, 2, 13, 17, 2, 13, 17, 4, 13, 17, 14, 2, 2, 13, 17, 2, 13, 17, 4, 13, 17, 14, 2, 2, 13, 17, 2, 13, 17, 4, 13, 17, 14, 2, 2, 13, 17, 2, 13, 17, 14, 2, 2, 13, 13, 17, 4, 13, 17, 14, 2, 2, 2, 2, 13, 13, 17, 17, 17, 4, 13, 17, 4, 13, 17, 10, 4, 13, 10, 4, 13 ]

[ [ 82, 2 ], [ 82, 11 ], [ 83, 15 ], [ 80, 18 ], [ 83, 26 ], [ 80, 29 ], [ 83, 37 ], [ 80, 40 ], [ 83, 48 ], [ 80, 51 ], [ 80, 56 ], [ 83, 57 ], [ 80, 67 ], [ 83, 68 ], [ 82, 80 ], [ 82, 83 ] ]

[ "a,b = map(int,input().split())\n\nif(a == 0 or b == 0):\n print(\"Zero\")\nelif(a<0 and b>0):\n print(\"Zero\")\nelif(a>0 and b>0):\n print(\"Positive\")\nelif(a<0 and b<0):\n if(b-a == 1):\n print(\"Positive\")\n elif((b-a+1)%2 == 0):\n print(\"Positive\")\n else:\n print(\"Negative\")", "a,b = map(int,input().split())", "a", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "if(a == 0 or b == 0):\n print(\"Zero\")\nelif(a<0 and b>0):\n print(\"Zero\")\nelif(a>0 and b>0):\n print(\"Positive\")\nelif(a<0 and b<0):\n if(b-a == 1):\n print(\"Positive\")\n elif((b-a+1)%2 == 0):\n print(\"Positive\")\n else:\n print(\"Negative\")", "a == 0 or b == 0", "a == 0", "a", "0", "b == 0", "b", "0", "print(\"Zero\")", "print", "\"Zero\"", "elif(a<0 and b>0):\n print(\"Zero\")", "a<0 and b>0", "a<0", "a", "0", "b>0", "b", "0", "print(\"Zero\")", "print", "\"Zero\"", "elif(a>0 and b>0):\n print(\"Positive\")", "a>0 and b>0", "a>0", "a", "0", "b>0", "b", "0", "print(\"Positive\")", "print", "\"Positive\"", "elif(a<0 and b<0):\n if(b-a == 1):\n print(\"Positive\")\n elif((b-a+1)%2 == 0):\n print(\"Positive\")\n else:\n print(\"Negative\")", "a<0 and b<0", "a<0", "a", "0", "b<0", "b", "0", "if(b-a == 1):\n print(\"Positive\")\n elif((b-a+1)%2 == 0):\n print(\"Positive\")\n else:\n print(\"Negative\")", "b-a == 1", "b-a", "b", "a", "1", "print(\"Positive\")", "print", "\"Positive\"", "elif((b-a+1)%2 == 0):\n print(\"Positive\")\n ", "(b-a+1)%2 == 0", "(b-a+1)%2", "b-a+1", "b-a", "b", "a", "1", "2", "0", "print(\"Positive\")", "print", "\"Positive\"", "print(\"Negative\")", "print", "\"Negative\"", "b = map(int,input().split())", "map(int,input().split())", "b", "a,b = map(int,input().split())", "map(int,input().split())", "a" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 14, 2, 40, 13, 17, 40, 13, 17, 4, 13, 17, 14, 2, 13, 17, 14, 2, 2, 2, 4, 13, 2, 13, 17, 17, 13, 17, 17, 4, 13, 17, 4, 13, 17, 4, 13, 17, 10, 4, 13, 10, 4, 13 ]

[ [ 53, 2 ], [ 53, 11 ], [ 54, 15 ], [ 51, 18 ], [ 54, 25 ], [ 51, 34 ], [ 54, 37 ], [ 53, 51 ], [ 53, 54 ] ]

[ "a, b = map(int,input().split())\nif a <= 0 and b >= 0:\n print('Zero')\nelse:\n if a < 0:\n if (min(b+1, 0)-a)%2==0:\n print('Positive')\n else:\n print('Negative')\n\n else:\n print('Positive')", "a, b = map(int,input().split())", "a", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "if a <= 0 and b >= 0:\n print('Zero')\nelse:\n if a < 0:\n if (min(b+1, 0)-a)%2==0:\n print('Positive')\n else:\n print('Negative')\n\n else:\n print('Positive')", "a <= 0 and b >= 0", "a <= 0", "a", "0", "b >= 0", "b", "0", "print('Zero')", "print", "'Zero'", "if a < 0:\n if (min(b+1, 0)-a)%2==0:\n print('Positive')\n else:\n print('Negative')\n\n else:\n print('Positive')", "a < 0", "a", "0", "if (min(b+1, 0)-a)%2==0:\n print('Positive')\n else:\n print('Negative')\n\n ", "(min(b+1, 0)-a)%2==0", "(min(b+1, 0)-a)%2", "min(b+1, 0)-a", "min(b+1, 0)", "min", "b+1", "b", "1", "0", "a", "2", "0", "print('Positive')", "print", "'Positive'", "print('Negative')", "print", "'Negative'", "print('Positive')", "print", "'Positive'", "b = map(int,input().split())", "map(int,input().split())", "b", "a, b = map(int,input().split())", "map(int,input().split())", "a" ]

[ 7, 15, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 17, 13, 14, 2, 2, 4, 18, 13, 13, 13, 17, 2, 4, 18, 13, 13, 13, 17, 4, 13, 17, 14, 2, 2, 4, 18, 13, 13, 13, 17, 2, 4, 18, 13, 13, 13, 17, 4, 13, 17, 14, 2, 2, 4, 18, 13, 13, 13, 17, 2, 4, 18, 13, 13, 13, 17, 14, 2, 2, 2, 2, 13, 13, 17, 17, 17, 4, 13, 17, 4, 13, 17, 10, 4, 13, 10, 4, 13 ]

[ [ 89, 4 ], [ 89, 14 ], [ 90, 22 ], [ 87, 29 ], [ 90, 41 ], [ 87, 48 ], [ 90, 60 ], [ 87, 67 ], [ 87, 74 ], [ 90, 75 ], [ 89, 87 ], [ 89, 90 ] ]

[ "import numpy as np\na,b = map(int,input().split(' '))\nif np.sign(a)==1 and np.sign(b) == 1:\n print('Positive')\nelif np.sign(a) == -1 and np.sign(b) == 1:\n print('Zero')\nelif np.sign(a) == -1 and np.sign(b) == -1:\n if (b - a + 1) % 2 == 0:\n print('Positive')\n else:\n print('Negative')", "import numpy as np", "numpy", "a,b = map(int,input().split(' '))", "a", "map(int,input().split(' '))", "map", "int", "input().split(' ')", "().split", "()", "input", "split", "' '", "b", "if np.sign(a)==1 and np.sign(b) == 1:\n print('Positive')\nelif np.sign(a) == -1 and np.sign(b) == 1:\n print('Zero')\nelif np.sign(a) == -1 and np.sign(b) == -1:\n if (b - a + 1) % 2 == 0:\n print('Positive')\n else:\n print('Negative')", "np.sign(a)==1 and np.sign(b) == 1", "np.sign(a)==1", "np.sign(a)", "np.sign", "np", "sign", "a", "1", "np.sign(b) == 1", "np.sign(b)", "np.sign", "np", "sign", "b", "1", "print('Positive')", "print", "'Positive'", "elif np.sign(a) == -1 and np.sign(b) == 1:\n print('Zero')", "np.sign(a) == -1 and np.sign(b) == 1", "np.sign(a) == -1", "np.sign(a)", "np.sign", "np", "sign", "a", "-1", "np.sign(b) == 1", "np.sign(b)", "np.sign", "np", "sign", "b", "1", "print('Zero')", "print", "'Zero'", "elif np.sign(a) == -1 and np.sign(b) == -1:\n if (b - a + 1) % 2 == 0:\n print('Positive')\n else:\n print('Negative')", "np.sign(a) == -1 and np.sign(b) == -1", "np.sign(a) == -1", "np.sign(a)", "np.sign", "np", "sign", "a", "-1", "np.sign(b) == -1", "np.sign(b)", "np.sign", "np", "sign", "b", "-1", "if (b - a + 1) % 2 == 0:\n print('Positive')\n else:\n print('Negative')", "(b - a + 1) % 2 == 0", "(b - a + 1) % 2", "b - a + 1", "b - a", "b", "a", "1", "2", "0", "print('Positive')", "print", "'Positive'", "print('Negative')", "print", "'Negative'", "b = map(int,input().split(' '))", "map(int,input().split(' '))", "b", "a,b = map(int,input().split(' '))", "map(int,input().split(' '))", "a" ]

[ 7, 0, 13, 17, 0, 13, 2, 17, 17, 12, 13, 15, 13, 0, 13, 18, 18, 13, 13, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 14, 40, 2, 13, 13, 17, 4, 13, 17, 14, 2, 13, 17, 4, 13, 17, 14, 2, 2, 13, 13, 17, 4, 13, 17, 4, 13, 17, 14, 2, 13, 17, 4, 13, 10, 12, 13, 10, 2, 13, 10, 17, 13 ]

[ [ 72, 2 ], [ 69, 5 ], [ 15, 14 ], [ 22, 21 ], [ 14, 28 ], [ 22, 30 ], [ 21, 34 ], [ 30, 35 ], [ 21, 42 ], [ 30, 50 ], [ 21, 51 ], [ 67, 64 ], [ 69, 70 ], [ 72, 73 ] ]

[ "mod = 1000000007\neps = 10**-9\n\n\ndef main():\n import sys\n input = sys.stdin.readline\n\n a, b = map(int, input().split())\n if a * b <= 0:\n print(\"Zero\")\n else:\n if a > 0:\n print(\"Positive\")\n else:\n if (b - a) & 1:\n print(\"Positive\")\n else:\n print(\"Negative\")\n\n\nif __name__ == '__main__':\n main()", "mod = 1000000007", "mod", "1000000007", "eps = 10**-9", "eps", "10**-9", "10", "-9", "def main():\n import sys\n input = sys.stdin.readline\n\n a, b = map(int, input().split())\n if a * b <= 0:\n print(\"Zero\")\n else:\n if a > 0:\n print(\"Positive\")\n else:\n if (b - a) & 1:\n print(\"Positive\")\n else:\n print(\"Negative\")", "main", "import sys", "sys", "input = sys.stdin.readline", "input", "sys.stdin.readline", "sys.stdin", "sys", "stdin", "readline", "a, b = map(int, input().split())", "a", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "if a * b <= 0:\n print(\"Zero\")\n else:\n if a > 0:\n print(\"Positive\")\n else:\n if (b - a) & 1:\n print(\"Positive\")\n else:\n print(\"Negative\")", "a * b <= 0", "a * b", "a", "b", "0", "print(\"Zero\")", "print", "\"Zero\"", "if a > 0:\n print(\"Positive\")\n else:\n if (b - a) & 1:\n print(\"Positive\")\n else:\n print(\"Negative\")", "a > 0", "a", "0", "print(\"Positive\")", "print", "\"Positive\"", "if (b - a) & 1:\n print(\"Positive\")\n else:\n print(\"Negative\")", "(b - a) & 1", "b - a", "b", "a", "1", "print(\"Positive\")", "print", "\"Positive\"", "print(\"Negative\")", "print", "\"Negative\"", "if __name__ == '__main__':\n main()", "__name__ == '__main__'", "__name__", "'__main__'", "main()", "main", "def main():\n import sys\n input = sys.stdin.readline\n\n a, b = map(int, input().split())\n if a * b <= 0:\n print(\"Zero\")\n else:\n if a > 0:\n print(\"Positive\")\n else:\n if (b - a) & 1:\n print(\"Positive\")\n else:\n print(\"Negative\")", "def main():\n import sys\n input = sys.stdin.readline\n\n a, b = map(int, input().split())\n if a * b <= 0:\n print(\"Zero\")\n else:\n if a > 0:\n print(\"Positive\")\n else:\n if (b - a) & 1:\n print(\"Positive\")\n else:\n print(\"Negative\")", "main", "eps = 10**-9", "10**-9", "eps", "mod = 1000000007", "1000000007", "mod" ]

[ 7, 12, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 14, 2, 13, 17, 4, 13, 17, 29, 14, 2, 2, 13, 17, 40, 13, 17, 4, 13, 17, 29, 4, 13, 8, 2, 2, 2, 2, 13, 13, 17, 17, 17, 17, 17, 14, 2, 13, 17, 4, 13, 10, 12, 13 ]

[ [ 5, 4 ], [ 5, 13 ], [ 4, 16 ], [ 13, 25 ], [ 4, 28 ], [ 13, 41 ], [ 4, 42 ], [ 56, 53 ] ]

[ "def main():\n a, b = map(int, input().split())\n\n if a > 0:\n print(\"Positive\")\n return\n\n if b > 0 and a <= 0:\n print(\"Zero\")\n return\n\n print(\"Positive\" if(b - a + 1) % 2 == 0 else \"Negative\")\n\n\nif __name__ == '__main__':\n main()", "def main():\n a, b = map(int, input().split())\n\n if a > 0:\n print(\"Positive\")\n return\n\n if b > 0 and a <= 0:\n print(\"Zero\")\n return\n\n print(\"Positive\" if(b - a + 1) % 2 == 0 else \"Negative\")", "main", "a, b = map(int, input().split())", "a", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "if a > 0:\n print(\"Positive\")\n return\n\n ", "a > 0", "a", "0", "print(\"Positive\")", "print", "\"Positive\"", "return", "if b > 0 and a <= 0:\n print(\"Zero\")\n return\n\n ", "b > 0 and a <= 0", "b > 0", "b", "0", "a <= 0", "a", "0", "print(\"Zero\")", "print", "\"Zero\"", "return", "print(\"Positive\" if(b - a + 1) % 2 == 0 else \"Negative\")", "print", "\"Positive\" if(b - a + 1) % 2 == 0 else \"Negative\"", "(b - a + 1) % 2 == 0", "(b - a + 1) % 2", "b - a + 1", "b - a", "b", "a", "1", "2", "0", "\"Positive\"", "\"Negative\"", "if __name__ == '__main__':\n main()", "__name__ == '__main__'", "__name__", "'__main__'", "main()", "main", "def main():\n a, b = map(int, input().split())\n\n if a > 0:\n print(\"Positive\")\n return\n\n if b > 0 and a <= 0:\n print(\"Zero\")\n return\n\n print(\"Positive\" if(b - a + 1) % 2 == 0 else \"Negative\")", "def main():\n a, b = map(int, input().split())\n\n if a > 0:\n print(\"Positive\")\n return\n\n if b > 0 and a <= 0:\n print(\"Zero\")\n return\n\n print(\"Positive\" if(b - a + 1) % 2 == 0 else \"Negative\")", "main" ]

[ 7, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 14, 2, 40, 13, 17, 40, 13, 17, 4, 13, 17, 4, 13, 14, 2, 13, 17, 4, 13, 17, 4, 13, 14, 2, 2, 2, 13, 13, 17, 17, 4, 13, 17, 4, 13, 17, 10, 4, 13, 10, 4, 13 ]

[ [ 54, 2 ], [ 54, 13 ], [ 52, 17 ], [ 55, 20 ], [ 52, 29 ], [ 55, 40 ], [ 52, 41 ], [ 54, 52 ], [ 54, 55 ] ]

[ "a, b = list(map(int, input().split()))\n\nif a <= 0 and b >= 0:\n print(\"Zero\")\n exit()\n\nif a > 0:\n print(\"Positive\")\n exit()\n\nif (b - a + 1) % 2:\n print(\"Negative\")\nelse:\n print(\"Positive\")", "a, b = list(map(int, input().split()))", "a", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "if a <= 0 and b >= 0:\n print(\"Zero\")\n exit()", "a <= 0 and b >= 0", "a <= 0", "a", "0", "b >= 0", "b", "0", "print(\"Zero\")", "print", "\"Zero\"", "exit()", "exit", "if a > 0:\n print(\"Positive\")\n exit()", "a > 0", "a", "0", "print(\"Positive\")", "print", "\"Positive\"", "exit()", "exit", "if (b - a + 1) % 2:\n print(\"Negative\")\nelse:\n print(\"Positive\")", "(b - a + 1) % 2", "b - a + 1", "b - a", "b", "a", "1", "2", "print(\"Negative\")", "print", "\"Negative\"", "print(\"Positive\")", "print", "\"Positive\"", "a, b = list(map(int, input().split()))", "list(map(int, input().split()))", "a", "b = list(map(int, input().split()))", "list(map(int, input().split()))", "b" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 14, 40, 13, 17, 4, 13, 8, 40, 13, 17, 17, 17, 14, 2, 2, 13, 17, 2, 13, 17, 4, 13, 17, 14, 40, 13, 17, 14, 2, 13, 17, 4, 13, 17, 14, 2, 2, 2, 2, 13, 13, 17, 17, 17, 4, 13, 17, 4, 13, 17, 10, 4, 13, 10, 4, 13 ]

[ [ 66, 2 ], [ 66, 11 ], [ 64, 14 ], [ 64, 20 ], [ 64, 27 ], [ 67, 30 ], [ 67, 37 ], [ 67, 41 ], [ 64, 51 ], [ 67, 52 ], [ 66, 64 ], [ 66, 67 ] ]

[ "a,b=map(int,input().split())\nif a>=0:\n print(\"Positive\" if a!=0 else \"Zero\")\nif a<0 and b>0:\n print(\"Zero\")\nif b<=0:\n if b==0:\n print(\"Zero\")\n else:\n if (a-b+1)%2==0:\n print(\"Positive\")\n else:\n print(\"Negative\")", "a,b=map(int,input().split())", "a", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "if a>=0:\n print(\"Positive\" if a!=0 else \"Zero\")", "a>=0", "a", "0", "print(\"Positive\" if a!=0 else \"Zero\")", "print", "\"Positive\" if a!=0 else \"Zero\"", "a!=0", "a", "0", "\"Positive\"", "\"Zero\"", "if a<0 and b>0:\n print(\"Zero\")", "a<0 and b>0", "a<0", "a", "0", "b>0", "b", "0", "print(\"Zero\")", "print", "\"Zero\"", "if b<=0:\n if b==0:\n print(\"Zero\")\n else:\n if (a-b+1)%2==0:\n print(\"Positive\")\n else:\n print(\"Negative\")", "b<=0", "b", "0", "if b==0:\n print(\"Zero\")\n else:\n if (a-b+1)%2==0:\n print(\"Positive\")\n else:\n print(\"Negative\")", "b==0", "b", "0", "print(\"Zero\")", "print", "\"Zero\"", "if (a-b+1)%2==0:\n print(\"Positive\")\n else:\n print(\"Negative\")", "(a-b+1)%2==0", "(a-b+1)%2", "a-b+1", "a-b", "a", "b", "1", "2", "0", "print(\"Positive\")", "print", "\"Positive\"", "print(\"Negative\")", "print", "\"Negative\"", "a,b=map(int,input().split())", "map(int,input().split())", "a", "b=map(int,input().split())", "map(int,input().split())", "b" ]

[ 7, 41, 28, 13, 4, 18, 4, 18, 4, 13, 13, 13, 4, 4, 13, 13, 0, 13, 13, 13, 14, 2, 40, 13, 17, 40, 17, 13, 4, 13, 17, 14, 2, 13, 17, 4, 13, 17, 14, 2, 2, 13, 13, 17, 4, 13, 17, 4, 13, 17, 10, 13, 13, 10, 13, 13 ]

[ [ 4, 3 ], [ 3, 15 ], [ 54, 17 ], [ 54, 19 ], [ 55, 23 ], [ 52, 27 ], [ 55, 33 ], [ 52, 41 ], [ 55, 42 ], [ 54, 52 ], [ 54, 55 ] ]

[ "a, b = [int(x) for x in input().strip().split()]\nif a <= 0 and 0 <= b:\n print('Zero')\nelif a > 0:\n print('Positive')\nelse:\n if (b - a) % 2:\n print('Positive')\n else:\n print('Negative')", "int(x) for x in input().strip().split()", "for x in input().strip().split()", "x", "input().strip().split()", "().strip().split", "().strip()", "().strip", "()", "input", "strip", "split", "for x in input().strip().split()", "int(x)", "int", "x", "a, b = [int(x) for x in input().strip().split()]", "a", "[int(x) for x in input().strip().split()]", "b", "if a <= 0 and 0 <= b:\n print('Zero')\nelif a > 0:\n print('Positive')\nelse:\n if (b - a) % 2:\n print('Positive')\n else:\n print('Negative')", "a <= 0 and 0 <= b", "a <= 0", "a", "0", "0 <= b", "0", "b", "print('Zero')", "print", "'Zero'", "elif a > 0:\n print('Positive')", "a > 0", "a", "0", "print('Positive')", "print", "'Positive'", "if (b - a) % 2:\n print('Positive')\n else:\n print('Negative')", "(b - a) % 2", "b - a", "b", "a", "2", "print('Positive')", "print", "'Positive'", "print('Negative')", "print", "'Negative'", "b = [int(x) for x in input().strip().split()]", "[int(x) for x in input().strip().split()]", "b", "a, b = [int(x) for x in input().strip().split()]", "[int(x) for x in input().strip().split()]", "a" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 17, 14, 2, 40, 13, 17, 40, 13, 17, 0, 13, 17, 14, 2, 13, 17, 14, 2, 2, 2, 2, 13, 13, 17, 17, 17, 0, 13, 17, 0, 13, 17, 0, 13, 17, 4, 13, 13, 10, 4, 13, 10, 17, 13, 10, 17, 13, 10, 4, 13, 10, 17, 13, 10, 17, 13, 10, 17, 13 ]

[ [ 62, 2 ], [ 62, 11 ], [ 68, 13 ], [ 54, 18 ], [ 63, 21 ], [ 65, 24 ], [ 63, 28 ], [ 63, 35 ], [ 54, 36 ], [ 56, 41 ], [ 59, 44 ], [ 71, 47 ], [ 72, 51 ], [ 60, 51 ], [ 57, 51 ], [ 66, 51 ], [ 69, 51 ], [ 62, 54 ], [ 56, 57 ], [ 59, 60 ], [ 62, 63 ], [ 65, 66 ], [ 68, 69 ], [ 71, 72 ] ]

[ "a, b=map(int, input().split())\nans=''\n\nif a<=0 and b>=0:\n ans='Zero'\nelif b<0:\n if (b-a+1)%2==0:\n ans='Positive'\n else:\n ans='Negative'\nelse:\n ans='Positive'\nprint(ans)", "a, b=map(int, input().split())", "a", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "ans=''", "ans", "''", "if a<=0 and b>=0:\n ans='Zero'\nelif b<0:\n if (b-a+1)%2==0:\n ans='Positive'\n else:\n ans='Negative'\nelse:\n ans='Positive'", "a<=0 and b>=0", "a<=0", "a", "0", "b>=0", "b", "0", "ans='Zero'", "ans", "'Zero'", "elif b<0:\n if (b-a+1)%2==0:\n ans='Positive'\n else:\n ans='Negative'", "b<0", "b", "0", "if (b-a+1)%2==0:\n ans='Positive'\n else:\n ans='Negative'", "(b-a+1)%2==0", "(b-a+1)%2", "b-a+1", "b-a", "b", "a", "1", "2", "0", "ans='Positive'", "ans", "'Positive'", "ans='Negative'", "ans", "'Negative'", "ans='Positive'", "ans", "'Positive'", "print(ans)", "print", "ans", "a, b=map(int, input().split())", "map(int, input().split())", "a", "ans='Positive'", "'Positive'", "ans", "ans='Negative'", "'Negative'", "ans", "b=map(int, input().split())", "map(int, input().split())", "b", "ans='Zero'", "'Zero'", "ans", "ans=''", "''", "ans", "ans='Positive'", "'Positive'", "ans" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 14, 2, 40, 13, 17, 40, 13, 17, 4, 13, 17, 14, 2, 2, 13, 17, 2, 13, 17, 14, 40, 2, 2, 2, 13, 13, 17, 17, 17, 4, 13, 17, 4, 13, 17, 14, 2, 13, 17, 14, 40, 2, 40, 13, 17, 17, 4, 13, 17, 4, 13, 17, 4, 13, 17, 10, 4, 13, 10, 4, 13 ]

[ [ 71, 2 ], [ 71, 11 ], [ 69, 15 ], [ 72, 18 ], [ 69, 26 ], [ 72, 29 ], [ 69, 36 ], [ 72, 37 ], [ 69, 49 ], [ 69, 55 ], [ 71, 69 ], [ 71, 72 ] ]

[ "a,b = map(int,input().split())\n\nif a <= 0 and b >= 0:\n print(\"Zero\")\nelif a < 0 and b < 0:\n if (a-b+2)%2 != 0:\n print(\"Positive\")\n else:\n print(\"Negative\")\nelif a < 0:\n if -a%2 != 0:\n print(\"Positive\")\n else:\n print(\"Negative\")\nelse:\n print(\"Positive\")", "a,b = map(int,input().split())", "a", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "if a <= 0 and b >= 0:\n print(\"Zero\")\nelif a < 0 and b < 0:\n if (a-b+2)%2 != 0:\n print(\"Positive\")\n else:\n print(\"Negative\")\nelif a < 0:\n if -a%2 != 0:\n print(\"Positive\")\n else:\n print(\"Negative\")\nelse:\n print(\"Positive\")", "a <= 0 and b >= 0", "a <= 0", "a", "0", "b >= 0", "b", "0", "print(\"Zero\")", "print", "\"Zero\"", "elif a < 0 and b < 0:\n if (a-b+2)%2 != 0:\n print(\"Positive\")\n else:\n print(\"Negative\")", "a < 0 and b < 0", "a < 0", "a", "0", "b < 0", "b", "0", "if (a-b+2)%2 != 0:\n print(\"Positive\")\n else:\n print(\"Negative\")", "(a-b+2)%2 != 0", "(a-b+2)%2", "a-b+2", "a-b", "a", "b", "2", "2", "0", "print(\"Positive\")", "print", "\"Positive\"", "print(\"Negative\")", "print", "\"Negative\"", "elif a < 0:\n if -a%2 != 0:\n print(\"Positive\")\n else:\n print(\"Negative\")", "a < 0", "a", "0", "if -a%2 != 0:\n print(\"Positive\")\n else:\n print(\"Negative\")", "-a%2 != 0", "-a%2", "-a", "a", "2", "0", "print(\"Positive\")", "print", "\"Positive\"", "print(\"Negative\")", "print", "\"Negative\"", "print(\"Positive\")", "print", "\"Positive\"", "a,b = map(int,input().split())", "map(int,input().split())", "a", "b = map(int,input().split())", "map(int,input().split())", "b" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 14, 2, 13, 13, 0, 13, 13, 13, 13, 14, 2, 40, 13, 17, 40, 13, 17, 4, 13, 17, 14, 2, 2, 13, 17, 2, 13, 17, 4, 13, 17, 14, 2, 2, 2, 40, 13, 13, 17, 17, 4, 13, 17, 4, 13, 17, 10, 4, 13, 10, 4, 13, 10, 13, 13, 10, 13, 13 ]

[ [ 62, 2 ], [ 62, 11 ], [ 60, 14 ], [ 63, 15 ], [ 65, 17 ], [ 63, 18 ], [ 68, 19 ], [ 66, 20 ], [ 60, 20 ], [ 66, 24 ], [ 60, 24 ], [ 69, 27 ], [ 63, 27 ], [ 66, 35 ], [ 60, 35 ], [ 69, 38 ], [ 63, 38 ], [ 66, 48 ], [ 60, 48 ], [ 69, 49 ], [ 63, 49 ], [ 62, 60 ], [ 62, 63 ], [ 63, 65 ], [ 65, 66 ], [ 66, 68 ], [ 60, 68 ], [ 68, 69 ] ]

[ "a, b = map(int, input().split())\n\nif a > b:\n a, b = b, a\n\nif a <= 0 and b >= 0:\n print('Zero')\nelif a > 0 and b > 0:\n print('Positive')\nelse:\n if (- a - b) % 2 == 0:\n print('Negative')\n else:\n print('Positive')", "a, b = map(int, input().split())", "a", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "if a > b:\n a, b = b, a", "a > b", "a", "b", "a, b = b, a", "a", "b", "b", "a", "if a <= 0 and b >= 0:\n print('Zero')\nelif a > 0 and b > 0:\n print('Positive')\nelse:\n if (- a - b) % 2 == 0:\n print('Negative')\n else:\n print('Positive')", "a <= 0 and b >= 0", "a <= 0", "a", "0", "b >= 0", "b", "0", "print('Zero')", "print", "'Zero'", "elif a > 0 and b > 0:\n print('Positive')", "a > 0 and b > 0", "a > 0", "a", "0", "b > 0", "b", "0", "print('Positive')", "print", "'Positive'", "if (- a - b) % 2 == 0:\n print('Negative')\n else:\n print('Positive')", "(- a - b) % 2 == 0", "(- a - b) % 2", "- a - b", "- a", "a", "b", "2", "0", "print('Negative')", "print", "'Negative'", "print('Positive')", "print", "'Positive'", "a, b = map(int, input().split())", "map(int, input().split())", "a", "b = map(int, input().split())", "map(int, input().split())", "b", "a, b = b, a", "b", "a", "b = b, a", "a", "b" ]

[ 7, 15, 13, 12, 13, 14, 40, 40, 13, 17, 13, 4, 13, 17, 29, 14, 2, 17, 13, 4, 13, 17, 29, 14, 2, 2, 2, 4, 13, 2, 13, 13, 17, 17, 17, 4, 13, 17, 29, 4, 13, 17, 29, 23, 13, 23, 13, 12, 13, 12, 13, 28, 13, 18, 13, 13, 28, 13, 4, 18, 13, 13, 27, 13, 0, 13, 4, 13, 0, 13, 4, 13, 4, 13, 13, 0, 13, 4, 13, 4, 13, 13, 4, 13, 13, 13, 14, 2, 13, 17, 4, 13, 10, 12, 13, 10, 12, 13 ]

[ [ 44, 8 ], [ 46, 10 ], [ 44, 18 ], [ 44, 30 ], [ 46, 31 ], [ 44, 44 ], [ 46, 46 ], [ 53, 52 ], [ 58, 57 ], [ 52, 60 ], [ 57, 63 ], [ 66, 65 ], [ 50, 67 ], [ 70, 69 ], [ 65, 74 ], [ 77, 76 ], [ 65, 81 ], [ 97, 83 ], [ 69, 84 ], [ 76, 85 ], [ 94, 91 ] ]

[ "#!/usr/bin/env python3\nimport sys\n\n\ndef solve(a: int, b: int):\n if a <= 0 <= b:\n print(\"Zero\")\n return\n if 0 < a:\n print(\"Positive\")\n return\n if (abs(a-b)+1) % 2 == 1:\n print(\"Negative\")\n return\n print(\"Positive\")\n\n return\n\n\n# Generated by 1.1.7.1 https://github.com/kyuridenamida/atcoder-tools (tips: You use the default template now. You can remove this line by using your custom template)\ndef main():\n def iterate_tokens():\n for line in sys.stdin:\n for word in line.split():\n yield word\n tokens = iterate_tokens()\n a = int(next(tokens)) # type: int\n b = int(next(tokens)) # type: int\n solve(a, b)\n\nif __name__ == '__main__':\n main()", "import sys", "sys", "def solve(a: int, b: int):\n if a <= 0 <= b:\n print(\"Zero\")\n return\n if 0 < a:\n print(\"Positive\")\n return\n if (abs(a-b)+1) % 2 == 1:\n print(\"Negative\")\n return\n print(\"Positive\")\n\n return\n\n\n# Generated by 1.1.7.1 https://github.com/kyuridenamida/atcoder-tools (tips: You use the default template now. You can remove this line by using your custom template)", "solve", "if a <= 0 <= b:\n print(\"Zero\")\n return\n ", "a <= 0 <= b", "a <= 0", "a", "0", "b", "print(\"Zero\")", "print", "\"Zero\"", "return", "if 0 < a:\n print(\"Positive\")\n return\n ", "0 < a", "0", "a", "print(\"Positive\")", "print", "\"Positive\"", "return", "if (abs(a-b)+1) % 2 == 1:\n print(\"Negative\")\n return\n ", "(abs(a-b)+1) % 2 == 1", "(abs(a-b)+1) % 2", "abs(a-b)+1", "abs(a-b)", "abs", "a-b", "a", "b", "1", "2", "1", "print(\"Negative\")", "print", "\"Negative\"", "return", "print(\"Positive\")", "print", "\"Positive\"", "return", "a: int", "a", "b: int", "b", "def main():\n def iterate_tokens():\n for line in sys.stdin:\n for word in line.split():\n yield word\n tokens = iterate_tokens()\n a = int(next(tokens)) # type: int\n b = int(next(tokens)) # type: int\n solve(a, b)", "main", "def iterate_tokens():\n for line in sys.stdin:\n for word in line.split():\n yield word\n ", "iterate_tokens", "for line in sys.stdin:\n for word in line.split():\n yield word\n ", "line", "sys.stdin", "sys", "stdin", "for word in line.split():\n yield word\n ", "word", "line.split()", "line.split", "line", "split", "yield word", "word", "tokens = iterate_tokens()", "tokens", "iterate_tokens()", "iterate_tokens", "a = int(next(tokens))", "a", "int(next(tokens))", "int", "next(tokens)", "next", "tokens", "b = int(next(tokens))", "b", "int(next(tokens))", "int", "next(tokens)", "next", "tokens", "solve(a, b)", "solve", "a", "b", "if __name__ == '__main__':\n main()", "__name__ == '__main__'", "__name__", "'__main__'", "main()", "main", "def main():\n def iterate_tokens():\n for line in sys.stdin:\n for word in line.split():\n yield word\n tokens = iterate_tokens()\n a = int(next(tokens)) # type: int\n b = int(next(tokens)) # type: int\n solve(a, b)", "def main():\n def iterate_tokens():\n for line in sys.stdin:\n for word in line.split():\n yield word\n tokens = iterate_tokens()\n a = int(next(tokens)) # type: int\n b = int(next(tokens)) # type: int\n solve(a, b)", "main", "def solve(a: int, b: int):\n if a <= 0 <= b:\n print(\"Zero\")\n return\n if 0 < a:\n print(\"Positive\")\n return\n if (abs(a-b)+1) % 2 == 1:\n print(\"Negative\")\n return\n print(\"Positive\")\n\n return\n\n\n# Generated by 1.1.7.1 https://github.com/kyuridenamida/atcoder-tools (tips: You use the default template now. You can remove this line by using your custom template)", "def solve(a: int, b: int):\n if a <= 0 <= b:\n print(\"Zero\")\n return\n if 0 < a:\n print(\"Positive\")\n return\n if (abs(a-b)+1) % 2 == 1:\n print(\"Negative\")\n return\n print(\"Positive\")\n\n return\n\n\n# Generated by 1.1.7.1 https://github.com/kyuridenamida/atcoder-tools (tips: You use the default template now. You can remove this line by using your custom template)", "solve" ]

[ 7, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 14, 2, 17, 13, 4, 13, 17, 4, 13, 14, 2, 40, 17, 13, 40, 13, 17, 4, 13, 17, 4, 13, 14, 2, 13, 17, 14, 2, 2, 4, 13, 2, 13, 13, 17, 17, 4, 13, 17, 4, 13, 4, 13, 17, 4, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 64, 2 ], [ 64, 13 ], [ 62, 17 ], [ 65, 27 ], [ 62, 29 ], [ 65, 38 ], [ 62, 46 ], [ 65, 47 ], [ 64, 62 ], [ 64, 65 ] ]

[ "a,b= list(map(int,input().split()))\nif 0 < a:\n print(\"Positive\")\n exit()\nelif 0<=b and a<=0:\n print(\"Zero\")\n exit()\nelif b < 0:\n if abs(a-b)%2==0:\n print(\"Negative\")\n exit()\n else:\n print(\"Positive\")\n exit()", "a,b= list(map(int,input().split()))", "a", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "if 0 < a:\n print(\"Positive\")\n exit()\nelif 0<=b and a<=0:\n print(\"Zero\")\n exit()\nelif b < 0:\n if abs(a-b)%2==0:\n print(\"Negative\")\n exit()\n else:\n print(\"Positive\")\n exit()", "0 < a", "0", "a", "print(\"Positive\")", "print", "\"Positive\"", "exit()", "exit", "elif 0<=b and a<=0:\n print(\"Zero\")\n exit()", "0<=b and a<=0", "0<=b", "0", "b", "a<=0", "a", "0", "print(\"Zero\")", "print", "\"Zero\"", "exit()", "exit", "elif b < 0:\n if abs(a-b)%2==0:\n print(\"Negative\")\n exit()\n else:\n print(\"Positive\")\n exit()", "b < 0", "b", "0", "if abs(a-b)%2==0:\n print(\"Negative\")\n exit()\n else:\n print(\"Positive\")\n exit()", "abs(a-b)%2==0", "abs(a-b)%2", "abs(a-b)", "abs", "a-b", "a", "b", "2", "0", "print(\"Negative\")", "print", "\"Negative\"", "exit()", "exit", "print(\"Positive\")", "print", "\"Positive\"", "exit()", "exit", "a,b= list(map(int,input().split()))", "list(map(int,input().split()))", "a", "b= list(map(int,input().split()))", "list(map(int,input().split()))", "b" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 14, 2, 2, 13, 17, 2, 2, 2, 2, 13, 13, 17, 17, 17, 4, 13, 17, 14, 2, 2, 13, 17, 2, 2, 2, 2, 13, 13, 17, 17, 17, 4, 13, 17, 14, 2, 2, 13, 17, 40, 13, 17, 4, 13, 17, 14, 2, 13, 17, 4, 13, 17, 14, 2, 13, 17, 4, 13, 17, 10, 4, 13, 10, 4, 13 ]

[ [ 75, 2 ], [ 75, 11 ], [ 73, 15 ], [ 73, 21 ], [ 76, 22 ], [ 73, 32 ], [ 73, 38 ], [ 76, 39 ], [ 76, 49 ], [ 73, 52 ], [ 76, 59 ], [ 76, 66 ], [ 75, 73 ], [ 75, 76 ] ]

[ "a,b = map(int,input().split())\nif b<0 and (b-a+1)%2==0:\n print(\"Positive\")\nelif b<0 and (b-a+1)%2==1:\n print(\"Negative\")\nelif a<0 and b>=0:\n print(\"Zero\")\nelif a==0:\n print(\"Zero\")\nelif a>0:\n print(\"Positive\")", "a,b = map(int,input().split())", "a", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "if b<0 and (b-a+1)%2==0:\n print(\"Positive\")\nelif b<0 and (b-a+1)%2==1:\n print(\"Negative\")\nelif a<0 and b>=0:\n print(\"Zero\")\nelif a==0:\n print(\"Zero\")\nelif a>0:\n print(\"Positive\")", "b<0 and (b-a+1)%2==0", "b<0", "b", "0", "(b-a+1)%2==0", "(b-a+1)%2", "b-a+1", "b-a", "b", "a", "1", "2", "0", "print(\"Positive\")", "print", "\"Positive\"", "elif b<0 and (b-a+1)%2==1:\n print(\"Negative\")", "b<0 and (b-a+1)%2==1", "b<0", "b", "0", "(b-a+1)%2==1", "(b-a+1)%2", "b-a+1", "b-a", "b", "a", "1", "2", "1", "print(\"Negative\")", "print", "\"Negative\"", "elif a<0 and b>=0:\n print(\"Zero\")", "a<0 and b>=0", "a<0", "a", "0", "b>=0", "b", "0", "print(\"Zero\")", "print", "\"Zero\"", "elif a==0:\n print(\"Zero\")", "a==0", "a", "0", "print(\"Zero\")", "print", "\"Zero\"", "elif a>0:\n print(\"Positive\")", "a>0", "a", "0", "print(\"Positive\")", "print", "\"Positive\"", "b = map(int,input().split())", "map(int,input().split())", "b", "a,b = map(int,input().split())", "map(int,input().split())", "a" ]

[ 7, 12, 13, 29, 4, 13, 4, 13, 12, 13, 29, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 12, 13, 0, 13, 4, 13, 29, 4, 13, 18, 13, 39, 4, 13, 13, 12, 13, 29, 4, 13, 13, 4, 18, 4, 13, 13, 0, 13, 4, 13, 13, 0, 13, 17, 14, 2, 2, 17, 13, 40, 13, 13, 0, 13, 17, 14, 2, 40, 13, 13, 2, 13, 17, 0, 13, 2, 2, 13, 13, 17, 14, 2, 2, 13, 17, 17, 0, 13, 17, 0, 13, 17, 14, 2, 40, 13, 17, 40, 13, 17, 0, 13, 17, 4, 13, 13, 10, 17, 13, 10, 12, 13, 10, 2, 13, 10, 17, 13, 10, 17, 13, 10, 12, 13, 10, 12, 13, 10, 17, 13, 10, 4, 13, 10, 12, 13, 10, 4, 13, 10, 17, 13 ]

[ [ 25, 24 ], [ 24, 31 ], [ 24, 35 ], [ 138, 48 ], [ 124, 50 ], [ 138, 51 ], [ 120, 53 ], [ 133, 59 ], [ 133, 61 ], [ 139, 62 ], [ 129, 64 ], [ 133, 69 ], [ 139, 70 ], [ 139, 72 ], [ 114, 75 ], [ 139, 78 ], [ 133, 79 ], [ 115, 84 ], [ 141, 88 ], [ 108, 91 ], [ 133, 96 ], [ 139, 99 ], [ 117, 102 ], [ 118, 106 ], [ 109, 106 ], [ 142, 106 ], [ 130, 106 ], [ 121, 106 ], [ 108, 109 ], [ 114, 115 ], [ 117, 118 ], [ 120, 121 ], [ 129, 130 ], [ 138, 133 ], [ 138, 139 ], [ 141, 142 ] ]

[ "# For taking integer inputs.\ndef inp():\n return(int(input()))\n\n\n# For taking List inputs.\ndef inlist():\n return(list(map(int, input().split())))\n\n\n# For taking string inputs. Actually it returns a List of Characters, instead of a string, which is easier to use in Python, because in Python, Strings are Immutable.\ndef instr():\n s = input()\n return(list(s[:len(s)]))\n\n\n# For taking space seperated integer variable inputs.\ndef invr():\n return(map(int, input().split()))\n\n\na, b = invr()\nres = \"Negative\"\n\nif 0 < a and a <= b:\n res = \"Positive\"\nif a <= b and b < 0:\n temp = (b-a)+1\n if temp % 2 == 0:\n res = \"Positive\"\n else:\n res = \"Negative\"\nif a <= 0 and b >= 0:\n res = \"Zero\"\n\nprint(res)", "def inp():\n return(int(input()))\n\n\n# For taking List inputs.", "inp", "return(int(input()))", "int(input())", "int", "input()", "input", "def inlist():\n return(list(map(int, input().split())))\n\n\n# For taking string inputs. Actually it returns a List of Characters, instead of a string, which is easier to use in Python, because in Python, Strings are Immutable.", "inlist", "return(list(map(int, input().split())))", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "def instr():\n s = input()\n return(list(s[:len(s)]))\n\n\n# For taking space seperated integer variable inputs.", "instr", "s = input()", "s", "input()", "input", "return(list(s[:len(s)]))", "list(s[:len(s)])", "list", "s[:len(s)]", "s", ":len(s)", "len(s)", "len", "s", "def invr():\n return(map(int, input().split()))", "invr", "return(map(int, input().split()))", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "a, b = invr()", "a", "invr()", "invr", "b", "res = \"Negative\"", "res", "\"Negative\"", "if 0 < a and a <= b:\n res = \"Positive\"", "0 < a and a <= b", "0 < a", "0", "a", "a <= b", "a", "b", "res = \"Positive\"", "res", "\"Positive\"", "if a <= b and b < 0:\n temp = (b-a)+1\n if temp % 2 == 0:\n res = \"Positive\"\n else:\n res = \"Negative\"", "a <= b and b < 0", "a <= b", "a", "b", "b < 0", "b", "0", "temp = (b-a)+1", "temp", "(b-a)+1", "b-a", "b", "a", "1", "if temp % 2 == 0:\n res = \"Positive\"\n else:\n res = \"Negative\"", "temp % 2 == 0", "temp % 2", "temp", "2", "0", "res = \"Positive\"", "res", "\"Positive\"", "res = \"Negative\"", "res", "\"Negative\"", "if a <= 0 and b >= 0:\n res = \"Zero\"", "a <= 0 and b >= 0", "a <= 0", "a", "0", "b >= 0", "b", "0", "res = \"Zero\"", "res", "\"Zero\"", "print(res)", "print", "res", "res = \"Negative\"", "\"Negative\"", "res", "def inp():\n return(int(input()))\n\n\n# For taking List inputs.", "def inp():\n return(int(input()))\n\n\n# For taking List inputs.", "inp", "temp = (b-a)+1", "(b-a)+1", "temp", "res = \"Zero\"", "\"Zero\"", "res", "res = \"Negative\"", "\"Negative\"", "res", "def invr():\n return(map(int, input().split()))", "def invr():\n return(map(int, input().split()))", "invr", "def instr():\n s = input()\n return(list(s[:len(s)]))\n\n\n# For taking space seperated integer variable inputs.", "def instr():\n s = input()\n return(list(s[:len(s)]))\n\n\n# For taking space seperated integer variable inputs.", "instr", "res = \"Positive\"", "\"Positive\"", "res", "a, b = invr()", "invr()", "a", "def inlist():\n return(list(map(int, input().split())))\n\n\n# For taking string inputs. Actually it returns a List of Characters, instead of a string, which is easier to use in Python, because in Python, Strings are Immutable.", "def inlist():\n return(list(map(int, input().split())))\n\n\n# For taking string inputs. Actually it returns a List of Characters, instead of a string, which is easier to use in Python, because in Python, Strings are Immutable.", "inlist", "b = invr()", "invr()", "b", "res = \"Positive\"", "\"Positive\"", "res" ]

[ 7, 15, 13, 0, 13, 18, 18, 18, 13, 13, 13, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 14, 2, 13, 17, 4, 13, 17, 4, 13, 17, 14, 2, 40, 13, 17, 40, 17, 13, 4, 13, 17, 4, 13, 17, 14, 2, 2, 13, 17, 2, 13, 17, 0, 13, 2, 2, 13, 13, 17, 14, 2, 2, 13, 17, 17, 4, 13, 17, 4, 13, 17, 4, 13, 17, 4, 13, 17, 10, 2, 13, 10, 18, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 84, 4 ], [ 90, 13 ], [ 85, 20 ], [ 90, 22 ], [ 91, 25 ], [ 91, 36 ], [ 88, 40 ], [ 91, 50 ], [ 88, 53 ], [ 81, 56 ], [ 88, 59 ], [ 91, 60 ], [ 82, 65 ], [ 81, 82 ], [ 84, 85 ], [ 90, 88 ], [ 90, 91 ] ]

[ "import sys\ninput = sys.stdin.buffer.readline\na,b=map(int,input().split())\nif a>0:\n print(\"Positive\")\n exit(0)\nelif a<=0 and 0<=b:\n print(\"Zero\")\n exit(0)\nelif a<0 and b<0:\n num=b-a+1\n if num%2==0:\n print(\"Positive\")\n exit(0)\n else:\n print(\"Negative\")\n exit(0)", "import sys", "sys", "input = sys.stdin.buffer.readline", "input", "sys.stdin.buffer.readline", "sys.stdin.buffer", "sys.stdin", "sys", "stdin", "buffer", "readline", "a,b=map(int,input().split())", "a", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "if a>0:\n print(\"Positive\")\n exit(0)\nelif a<=0 and 0<=b:\n print(\"Zero\")\n exit(0)\nelif a<0 and b<0:\n num=b-a+1\n if num%2==0:\n print(\"Positive\")\n exit(0)\n else:\n print(\"Negative\")\n exit(0)", "a>0", "a", "0", "print(\"Positive\")", "print", "\"Positive\"", "exit(0)", "exit", "0", "elif a<=0 and 0<=b:\n print(\"Zero\")\n exit(0)", "a<=0 and 0<=b", "a<=0", "a", "0", "0<=b", "0", "b", "print(\"Zero\")", "print", "\"Zero\"", "exit(0)", "exit", "0", "elif a<0 and b<0:\n num=b-a+1\n if num%2==0:\n print(\"Positive\")\n exit(0)\n else:\n print(\"Negative\")\n exit(0)", "a<0 and b<0", "a<0", "a", "0", "b<0", "b", "0", "num=b-a+1", "num", "b-a+1", "b-a", "b", "a", "1", "if num%2==0:\n print(\"Positive\")\n exit(0)\n else:\n print(\"Negative\")\n exit(0)", "num%2==0", "num%2", "num", "2", "0", "print(\"Positive\")", "print", "\"Positive\"", "exit(0)", "exit", "0", "print(\"Negative\")", "print", "\"Negative\"", "exit(0)", "exit", "0", "num=b-a+1", "b-a+1", "num", "input = sys.stdin.buffer.readline", "sys.stdin.buffer.readline", "input", "b=map(int,input().split())", "map(int,input().split())", "b", "a,b=map(int,input().split())", "map(int,input().split())", "a" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 14, 2, 2, 2, 13, 17, 2, 13, 17, 2, 2, 13, 17, 2, 13, 17, 4, 13, 17, 4, 13, 17, 14, 2, 2, 13, 17, 2, 13, 17, 4, 13, 17, 4, 13, 17, 14, 2, 2, 2, 2, 13, 13, 17, 17, 17, 4, 13, 17, 4, 13, 17, 4, 13, 17, 10, 4, 13, 10, 4, 13 ]

[ [ 71, 2 ], [ 71, 11 ], [ 72, 16 ], [ 69, 19 ], [ 72, 23 ], [ 69, 26 ], [ 72, 37 ], [ 69, 40 ], [ 69, 53 ], [ 72, 54 ], [ 71, 69 ], [ 71, 72 ] ]

[ "a, b = map(int, input().split())\n\n# == 0\nif ((a == 0) or (b == 0) or (a < 0 and b > 0)):\n print(\"Zero\")\n exit(0)\n\n# > 0\nif (a > 0 and b > 0):\n print(\"Positive\")\n exit(0)\n\nif (b - a + 1) % 2 == 0:\n print(\"Positive\")\n exit(0)\n\n# < 0\nprint(\"Negative\")", "a, b = map(int, input().split())", "a", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "if ((a == 0) or (b == 0) or (a < 0 and b > 0)):\n print(\"Zero\")\n exit(0)\n\n# > 0", "(a == 0) or (b == 0) or (a < 0 and b > 0)", "(a == 0) or (b == 0)", "a == 0", "a", "0", "b == 0", "b", "0", "a < 0 and b > 0", "a < 0", "a", "0", "b > 0", "b", "0", "print(\"Zero\")", "print", "\"Zero\"", "exit(0)", "exit", "0", "if (a > 0 and b > 0):\n print(\"Positive\")\n exit(0)", "a > 0 and b > 0", "a > 0", "a", "0", "b > 0", "b", "0", "print(\"Positive\")", "print", "\"Positive\"", "exit(0)", "exit", "0", "if (b - a + 1) % 2 == 0:\n print(\"Positive\")\n exit(0)\n\n# < 0", "(b - a + 1) % 2 == 0", "(b - a + 1) % 2", "b - a + 1", "b - a", "b", "a", "1", "2", "0", "print(\"Positive\")", "print", "\"Positive\"", "exit(0)", "exit", "0", "print(\"Negative\")", "print", "\"Negative\"", "b = map(int, input().split())", "map(int, input().split())", "b", "a, b = map(int, input().split())", "map(int, input().split())", "a" ]

[ 7, 12, 13, 41, 28, 13, 4, 18, 4, 13, 13, 4, 4, 13, 13, 0, 13, 13, 13, 14, 40, 2, 13, 13, 17, 4, 13, 17, 14, 2, 17, 13, 4, 13, 17, 14, 2, 2, 2, 2, 13, 13, 17, 17, 17, 4, 13, 17, 4, 13, 17, 14, 2, 13, 17, 4, 13, 10, 12, 13 ]

[ [ 6, 5 ], [ 5, 14 ], [ 17, 16 ], [ 17, 18 ], [ 16, 22 ], [ 18, 23 ], [ 16, 31 ], [ 18, 40 ], [ 16, 41 ], [ 59, 56 ] ]

[ "def main():\n a, b = (int(i) for i in input().split())\n if a*b <= 0:\n print(\"Zero\")\n elif 0 < a:\n print(\"Positive\")\n else:\n if (b-a+1) % 2 == 0:\n print(\"Positive\")\n else:\n print(\"Negative\")\n\n\nif __name__ == '__main__':\n main()", "def main():\n a, b = (int(i) for i in input().split())\n if a*b <= 0:\n print(\"Zero\")\n elif 0 < a:\n print(\"Positive\")\n else:\n if (b-a+1) % 2 == 0:\n print(\"Positive\")\n else:\n print(\"Negative\")", "main", "int(i) for i in input().split()", "for i in input().split()", "i", "input().split()", "().split", "()", "input", "split", "for i in input().split()", "int(i)", "int", "i", "a, b = (int(i) for i in input().split())", "a", "(int(i) for i in input().split())", "b", "if a*b <= 0:\n print(\"Zero\")\n elif 0 < a:\n print(\"Positive\")\n else:\n if (b-a+1) % 2 == 0:\n print(\"Positive\")\n else:\n print(\"Negative\")", "a*b <= 0", "a*b", "a", "b", "0", "print(\"Zero\")", "print", "\"Zero\"", "elif 0 < a:\n print(\"Positive\")\n ", "0 < a", "0", "a", "print(\"Positive\")", "print", "\"Positive\"", "if (b-a+1) % 2 == 0:\n print(\"Positive\")\n else:\n print(\"Negative\")", "(b-a+1) % 2 == 0", "(b-a+1) % 2", "b-a+1", "b-a", "b", "a", "1", "2", "0", "print(\"Positive\")", "print", "\"Positive\"", "print(\"Negative\")", "print", "\"Negative\"", "if __name__ == '__main__':\n main()", "__name__ == '__main__'", "__name__", "'__main__'", "main()", "main", "def main():\n a, b = (int(i) for i in input().split())\n if a*b <= 0:\n print(\"Zero\")\n elif 0 < a:\n print(\"Positive\")\n else:\n if (b-a+1) % 2 == 0:\n print(\"Positive\")\n else:\n print(\"Negative\")", "def main():\n a, b = (int(i) for i in input().split())\n if a*b <= 0:\n print(\"Zero\")\n elif 0 < a:\n print(\"Positive\")\n else:\n if (b-a+1) % 2 == 0:\n print(\"Positive\")\n else:\n print(\"Negative\")", "main" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 14, 2, 2, 13, 17, 40, 13, 17, 0, 13, 17, 14, 2, 2, 2, 13, 17, 2, 13, 17, 2, 2, 4, 13, 2, 13, 13, 17, 17, 0, 13, 17, 0, 13, 17, 4, 13, 13, 10, 4, 13, 10, 17, 13, 10, 17, 13, 10, 17, 13, 10, 4, 13 ]

[ [ 63, 2 ], [ 63, 11 ], [ 64, 15 ], [ 52, 18 ], [ 60, 21 ], [ 64, 27 ], [ 52, 30 ], [ 64, 37 ], [ 52, 38 ], [ 54, 42 ], [ 57, 45 ], [ 58, 49 ], [ 55, 49 ], [ 61, 49 ], [ 63, 52 ], [ 54, 55 ], [ 57, 58 ], [ 60, 61 ], [ 63, 64 ] ]

[ "a,b = map(int,input().split())\n\nif a < 0 and b >= 0:\n ans = 'Zero'\nelif a < 0 and b < 0 and abs(a-b) % 2 == 0:\n ans = 'Negative'\nelse:\n ans = 'Positive'\n\nprint(ans)", "a,b = map(int,input().split())", "a", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "if a < 0 and b >= 0:\n ans = 'Zero'\nelif a < 0 and b < 0 and abs(a-b) % 2 == 0:\n ans = 'Negative'\nelse:\n ans = 'Positive'", "a < 0 and b >= 0", "a < 0", "a", "0", "b >= 0", "b", "0", "ans = 'Zero'", "ans", "'Zero'", "elif a < 0 and b < 0 and abs(a-b) % 2 == 0:\n ans = 'Negative'", "a < 0 and b < 0 and abs(a-b) % 2 == 0", "a < 0 and b < 0", "a < 0", "a", "0", "b < 0", "b", "0", "abs(a-b) % 2 == 0", "abs(a-b) % 2", "abs(a-b)", "abs", "a-b", "a", "b", "2", "0", "ans = 'Negative'", "ans", "'Negative'", "ans = 'Positive'", "ans", "'Positive'", "print(ans)", "print", "ans", "b = map(int,input().split())", "map(int,input().split())", "b", "ans = 'Negative'", "'Negative'", "ans", "ans = 'Positive'", "'Positive'", "ans", "ans = 'Zero'", "'Zero'", "ans", "a,b = map(int,input().split())", "map(int,input().split())", "a" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 14, 2, 2, 2, 13, 13, 17, 2, 2, 13, 17, 13, 0, 13, 17, 14, 2, 2, 13, 17, 2, 13, 17, 0, 13, 17, 14, 2, 2, 2, 13, 13, 17, 17, 0, 13, 17, 0, 13, 17, 4, 13, 13, 10, 17, 13, 10, 4, 13, 10, 17, 13, 10, 17, 13, 10, 4, 13, 10, 17, 13 ]

[ [ 68, 2 ], [ 68, 11 ], [ 60, 16 ], [ 69, 17 ], [ 60, 21 ], [ 69, 23 ], [ 56, 25 ], [ 60, 30 ], [ 69, 33 ], [ 65, 36 ], [ 69, 42 ], [ 60, 43 ], [ 62, 47 ], [ 71, 50 ], [ 72, 54 ], [ 63, 54 ], [ 66, 54 ], [ 57, 54 ], [ 56, 57 ], [ 68, 60 ], [ 62, 63 ], [ 65, 66 ], [ 68, 69 ], [ 71, 72 ] ]

[ "a, b = map(int, input().split())\nif a*b == 0 or a < 0 < b:\n ans = 'Zero'\nelif a > 0 and b > 0:\n ans = 'Positive'\nelse:\n if (b - a) % 2 == 0:\n ans = 'Negative'\n else:\n ans = 'Positive'\n\nprint(ans)", "a, b = map(int, input().split())", "a", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "if a*b == 0 or a < 0 < b:\n ans = 'Zero'\nelif a > 0 and b > 0:\n ans = 'Positive'\nelse:\n if (b - a) % 2 == 0:\n ans = 'Negative'\n else:\n ans = 'Positive'", "a*b == 0 or a < 0 < b", "a*b == 0", "a*b", "a", "b", "0", "a < 0 < b", "a < 0", "a", "0", "b", "ans = 'Zero'", "ans", "'Zero'", "elif a > 0 and b > 0:\n ans = 'Positive'", "a > 0 and b > 0", "a > 0", "a", "0", "b > 0", "b", "0", "ans = 'Positive'", "ans", "'Positive'", "if (b - a) % 2 == 0:\n ans = 'Negative'\n else:\n ans = 'Positive'", "(b - a) % 2 == 0", "(b - a) % 2", "b - a", "b", "a", "2", "0", "ans = 'Negative'", "ans", "'Negative'", "ans = 'Positive'", "ans", "'Positive'", "print(ans)", "print", "ans", "ans = 'Zero'", "'Zero'", "ans", "a, b = map(int, input().split())", "map(int, input().split())", "a", "ans = 'Negative'", "'Negative'", "ans", "ans = 'Positive'", "'Positive'", "ans", "b = map(int, input().split())", "map(int, input().split())", "b", "ans = 'Positive'", "'Positive'", "ans" ]

[ 7, 15, 13, 15, 13, 15, 13, 15, 13, 15, 13, 41, 28, 13, 4, 18, 4, 13, 13, 4, 4, 13, 13, 0, 13, 13, 0, 13, 18, 13, 17, 0, 13, 18, 13, 17, 14, 40, 2, 13, 13, 17, 4, 13, 17, 14, 2, 2, 13, 17, 2, 13, 17, 4, 13, 17, 14, 2, 2, 4, 13, 2, 13, 13, 17, 17, 4, 13, 17, 4, 13, 17, 10, 13, 13, 10, 18, 13, 10, 18, 13 ]

[ [ 14, 13 ], [ 13, 22 ], [ 73, 24 ], [ 76, 27 ], [ 74, 29 ], [ 79, 32 ], [ 74, 34 ], [ 77, 39 ], [ 80, 40 ], [ 77, 48 ], [ 80, 51 ], [ 80, 62 ], [ 77, 63 ], [ 73, 74 ], [ 76, 77 ], [ 79, 80 ] ]

[ "import sys\nimport copy\nimport math\nimport itertools\nimport numpy as np\nl = [int(c) for c in input().split()]\na = l[0]\nb = l[1]\nif a*b <= 0:\n print(\"Zero\")\nelif a > 0 and b > 0:\n print(\"Positive\")\nelse:\n if abs(b-a)%2==1:\n print(\"Positive\")\n else:\n print(\"Negative\")", "import sys", "sys", "import copy", "copy", "import math", "math", "import itertools", "itertools", "import numpy as np", "numpy", "int(c) for c in input().split()", "for c in input().split()", "c", "input().split()", "().split", "()", "input", "split", "for c in input().split()", "int(c)", "int", "c", "l = [int(c) for c in input().split()]", "l", "[int(c) for c in input().split()]", "a = l[0]", "a", "l[0]", "l", "0", "b = l[1]", "b", "l[1]", "l", "1", "if a*b <= 0:\n print(\"Zero\")\nelif a > 0 and b > 0:\n print(\"Positive\")\nelse:\n if abs(b-a)%2==1:\n print(\"Positive\")\n else:\n print(\"Negative\")", "a*b <= 0", "a*b", "a", "b", "0", "print(\"Zero\")", "print", "\"Zero\"", "elif a > 0 and b > 0:\n print(\"Positive\")", "a > 0 and b > 0", "a > 0", "a", "0", "b > 0", "b", "0", "print(\"Positive\")", "print", "\"Positive\"", "if abs(b-a)%2==1:\n print(\"Positive\")\n else:\n print(\"Negative\")", "abs(b-a)%2==1", "abs(b-a)%2", "abs(b-a)", "abs", "b-a", "b", "a", "2", "1", "print(\"Positive\")", "print", "\"Positive\"", "print(\"Negative\")", "print", "\"Negative\"", "l = [int(c) for c in input().split()]", "[int(c) for c in input().split()]", "l", "a = l[0]", "l[0]", "a", "b = l[1]", "l[1]", "b" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 14, 2, 13, 17, 4, 13, 17, 14, 40, 13, 17, 4, 13, 17, 0, 13, 2, 2, 13, 13, 17, 14, 2, 2, 13, 17, 17, 4, 13, 17, 4, 13, 17, 10, 2, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 52, 2 ], [ 52, 11 ], [ 50, 14 ], [ 53, 21 ], [ 46, 27 ], [ 53, 30 ], [ 50, 31 ], [ 47, 36 ], [ 46, 47 ], [ 52, 50 ], [ 52, 53 ] ]

[ "a, b = map(int, input().split())\nif a > 0:\n print('Positive')\nelif b >= 0:\n print('Zero')\nelse:\n cnt = b - a + 1\n if cnt % 2 == 0:\n print('Positive')\n else:\n print('Negative')", "a, b = map(int, input().split())", "a", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "if a > 0:\n print('Positive')\nelif b >= 0:\n print('Zero')\nelse:\n cnt = b - a + 1\n if cnt % 2 == 0:\n print('Positive')\n else:\n print('Negative')", "a > 0", "a", "0", "print('Positive')", "print", "'Positive'", "elif b >= 0:\n print('Zero')", "b >= 0", "b", "0", "print('Zero')", "print", "'Zero'", "cnt = b - a + 1", "cnt", "b - a + 1", "b - a", "b", "a", "1", "if cnt % 2 == 0:\n print('Positive')\n else:\n print('Negative')", "cnt % 2 == 0", "cnt % 2", "cnt", "2", "0", "print('Positive')", "print", "'Positive'", "print('Negative')", "print", "'Negative'", "cnt = b - a + 1", "b - a + 1", "cnt", "a, b = map(int, input().split())", "map(int, input().split())", "a", "b = map(int, input().split())", "map(int, input().split())", "b" ]

[ 7, 15, 13, 0, 13, 18, 18, 13, 13, 13, 12, 13, 12, 13, 12, 13, 12, 13, 0, 13, 2, 2, 17, 17, 17, 0, 13, 4, 13, 13, 14, 40, 40, 13, 17, 13, 4, 13, 17, 14, 2, 2, 13, 17, 2, 13, 17, 4, 13, 17, 14, 2, 13, 17, 0, 13, 17, 0, 13, 2, 2, 13, 13, 17, 14, 2, 2, 13, 17, 17, 4, 13, 17, 4, 13, 17, 4, 13, 10, 12, 13, 10, 12, 13, 10, 12, 13, 10, 18, 13, 10, 12, 13 ]

[ [ 88, 4 ], [ 20, 19 ], [ 27, 26 ], [ 92, 28 ], [ 27, 29 ], [ 26, 33 ], [ 29, 35 ], [ 26, 42 ], [ 29, 45 ], [ 29, 52 ], [ 56, 55 ], [ 59, 58 ], [ 55, 61 ], [ 29, 61 ], [ 26, 62 ], [ 58, 67 ], [ 86, 77 ], [ 88, 89 ] ]

[ "import sys\ninput = sys.stdin.readline\n\ndef I(): return int(input())\ndef MI(): return map(int, input().split())\ndef LI(): return list(map(int, input().split()))\n\ndef main():\n mod=10**9+7\n a,b=MI()\n \n if a<=0<=b:\n print(\"Zero\")\n \n elif a>0 and b>0:\n print(\"Positive\")\n else:\n if b>0:\n b=-1\n n=(b-a+1)\n if n%2==0:\n print(\"Positive\")\n else:\n print(\"Negative\")\n\nmain()", "import sys", "sys", "input = sys.stdin.readline", "input", "sys.stdin.readline", "sys.stdin", "sys", "stdin", "readline", "def I(): return int(input())", "I", "def MI(): return map(int, input().split())", "MI", "def LI(): return list(map(int, input().split()))", "LI", "def main():\n mod=10**9+7\n a,b=MI()\n \n if a<=0<=b:\n print(\"Zero\")\n \n elif a>0 and b>0:\n print(\"Positive\")\n else:\n if b>0:\n b=-1\n n=(b-a+1)\n if n%2==0:\n print(\"Positive\")\n else:\n print(\"Negative\")", "main", "mod=10**9+7", "mod", "10**9+7", "10**9", "10", "9", "7", "a,b=MI()", "a", "MI()", "MI", "b", "if a<=0<=b:\n print(\"Zero\")\n \n elif a>0 and b>0:\n print(\"Positive\")\n else:\n if b>0:\n b=-1\n n=(b-a+1)\n if n%2==0:\n print(\"Positive\")\n else:\n print(\"Negative\")", "a<=0<=b", "a<=0", "a", "0", "b", "print(\"Zero\")", "print", "\"Zero\"", "elif a>0 and b>0:\n print(\"Positive\")\n ", "a>0 and b>0", "a>0", "a", "0", "b>0", "b", "0", "print(\"Positive\")", "print", "\"Positive\"", "if b>0:\n b=-1\n ", "b>0", "b", "0", "b=-1", "b", "-1", "n=(b-a+1)", "n", "b-a+1", "b-a", "b", "a", "1", "if n%2==0:\n print(\"Positive\")\n else:\n print(\"Negative\")", "n%2==0", "n%2", "n", "2", "0", "print(\"Positive\")", "print", "\"Positive\"", "print(\"Negative\")", "print", "\"Negative\"", "main()", "main", "def I(): return int(input())", "def I(): return int(input())", "I", "def LI(): return list(map(int, input().split()))", "def LI(): return list(map(int, input().split()))", "LI", "def main():\n mod=10**9+7\n a,b=MI()\n \n if a<=0<=b:\n print(\"Zero\")\n \n elif a>0 and b>0:\n print(\"Positive\")\n else:\n if b>0:\n b=-1\n n=(b-a+1)\n if n%2==0:\n print(\"Positive\")\n else:\n print(\"Negative\")", "def main():\n mod=10**9+7\n a,b=MI()\n \n if a<=0<=b:\n print(\"Zero\")\n \n elif a>0 and b>0:\n print(\"Positive\")\n else:\n if b>0:\n b=-1\n n=(b-a+1)\n if n%2==0:\n print(\"Positive\")\n else:\n print(\"Negative\")", "main", "input = sys.stdin.readline", "sys.stdin.readline", "input", "def MI(): return map(int, input().split())", "def MI(): return map(int, input().split())", "MI" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 14, 2, 13, 17, 4, 13, 17, 14, 2, 13, 17, 14, 2, 2, 2, 13, 13, 17, 17, 4, 13, 17, 4, 13, 17, 4, 13, 17, 10, 4, 13, 10, 4, 13 ]

[ [ 44, 2 ], [ 44, 11 ], [ 42, 14 ], [ 45, 21 ], [ 45, 27 ], [ 42, 28 ], [ 44, 42 ], [ 44, 45 ] ]

[ "A,B = map(int, input().split())\nif A > 0:\n print(\"Positive\")\nelif B<0:\n if((B-A)%2 == 0):\n print(\"Negative\")\n else:\n print(\"Positive\")\nelse:\n print(\"Zero\")", "A,B = map(int, input().split())", "A", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "B", "if A > 0:\n print(\"Positive\")\nelif B<0:\n if((B-A)%2 == 0):\n print(\"Negative\")\n else:\n print(\"Positive\")\nelse:\n print(\"Zero\")", "A > 0", "A", "0", "print(\"Positive\")", "print", "\"Positive\"", "elif B<0:\n if((B-A)%2 == 0):\n print(\"Negative\")\n else:\n print(\"Positive\")", "B<0", "B", "0", "if((B-A)%2 == 0):\n print(\"Negative\")\n else:\n print(\"Positive\")", "(B-A)%2 == 0", "(B-A)%2", "B-A", "B", "A", "2", "0", "print(\"Negative\")", "print", "\"Negative\"", "print(\"Positive\")", "print", "\"Positive\"", "print(\"Zero\")", "print", "\"Zero\"", "A,B = map(int, input().split())", "map(int, input().split())", "A", "B = map(int, input().split())", "map(int, input().split())", "B" ]

[ 7, 15, 13, 13, 13, 13, 13, 13, 13, 13, 15, 13, 12, 13, 12, 13, 12, 13, 12, 13, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 18, 4, 18, 18, 13, 13, 13, 13, 13, 13, 14, 2, 13, 17, 4, 13, 17, 14, 2, 40, 13, 17, 40, 13, 17, 4, 13, 17, 14, 2, 2, 2, 13, 13, 17, 17, 4, 13, 17, 4, 13, 17, 10, 12, 13, 10, 4, 13, 10, 4, 13, 10, 12, 13, 10, 12, 13, 10, 12, 13 ]

[ [ 79, 21 ], [ 79, 39 ], [ 77, 42 ], [ 77, 50 ], [ 80, 53 ], [ 77, 62 ], [ 80, 63 ], [ 79, 77 ], [ 79, 80 ] ]

[ "import bisect,collections,copy,heapq,itertools,math,numpy,string\nimport sys\ndef S(): return sys.stdin.readline().rstrip()\ndef I(): return int(sys.stdin.readline().rstrip())\ndef LI(): return list(map(int,sys.stdin.readline().rstrip().split()))\ndef LS(): return list(sys.stdin.readline().rstrip().split())\n#N = I()\n#A = [LI() for _ in range(N)]\n\na, b = list(map(int,sys.stdin.readline().rstrip().split()))\n\nif a > 0:\n print('Positive')\nelif a <= 0 and b >= 0:\n print('Zero')\nelse:\n if (a+b)%2 == 0:\n print('Negative')\n else:\n print('Positive')", "import bisect,collections,copy,heapq,itertools,math,numpy,string", "bisect", "collections", "copy", "heapq", "itertools", "math", "numpy", "string", "import sys", "sys", "def S(): return sys.stdin.readline().rstrip()", "S", "def I(): return int(sys.stdin.readline().rstrip())", "I", "def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))", "LI", "def LS(): return list(sys.stdin.readline().rstrip().split())\n#N = I()\n#A = [LI() for _ in range(N)]", "LS", "a, b = list(map(int,sys.stdin.readline().rstrip().split()))", "a", "list(map(int,sys.stdin.readline().rstrip().split()))", "list", "map(int,sys.stdin.readline().rstrip().split())", "map", "int", "sys.stdin.readline().rstrip().split()", "sys.stdin.readline().rstrip().split", "sys.stdin.readline().rstrip()", "sys.stdin.readline().rstrip", "sys.stdin.readline()", "sys.stdin.readline", "sys.stdin", "sys", "stdin", "readline", "rstrip", "split", "b", "if a > 0:\n print('Positive')\nelif a <= 0 and b >= 0:\n print('Zero')\nelse:\n if (a+b)%2 == 0:\n print('Negative')\n else:\n print('Positive')", "a > 0", "a", "0", "print('Positive')", "print", "'Positive'", "elif a <= 0 and b >= 0:\n print('Zero')", "a <= 0 and b >= 0", "a <= 0", "a", "0", "b >= 0", "b", "0", "print('Zero')", "print", "'Zero'", "if (a+b)%2 == 0:\n print('Negative')\n else:\n print('Positive')", "(a+b)%2 == 0", "(a+b)%2", "a+b", "a", "b", "2", "0", "print('Negative')", "print", "'Negative'", "print('Positive')", "print", "'Positive'", "def S(): return sys.stdin.readline().rstrip()", "def S(): return sys.stdin.readline().rstrip()", "S", "a, b = list(map(int,sys.stdin.readline().rstrip().split()))", "list(map(int,sys.stdin.readline().rstrip().split()))", "a", "b = list(map(int,sys.stdin.readline().rstrip().split()))", "list(map(int,sys.stdin.readline().rstrip().split()))", "b", "def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))", "def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))", "LI", "def I(): return int(sys.stdin.readline().rstrip())", "def I(): return int(sys.stdin.readline().rstrip())", "I", "def LS(): return list(sys.stdin.readline().rstrip().split())\n#N = I()\n#A = [LI() for _ in range(N)]", "def LS(): return list(sys.stdin.readline().rstrip().split())\n#N = I()\n#A = [LI() for _ in range(N)]", "LS" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 14, 2, 2, 13, 17, 2, 13, 17, 4, 13, 17, 14, 2, 2, 13, 17, 2, 13, 17, 4, 13, 17, 14, 2, 2, 13, 17, 2, 13, 17, 4, 13, 17, 14, 2, 2, 13, 17, 2, 13, 17, 14, 2, 2, 2, 13, 13, 17, 17, 4, 13, 17, 4, 13, 17, 10, 4, 13, 10, 4, 13 ]

[ [ 71, 2 ], [ 71, 11 ], [ 72, 15 ], [ 69, 18 ], [ 72, 26 ], [ 69, 29 ], [ 72, 37 ], [ 69, 40 ], [ 72, 48 ], [ 69, 51 ], [ 72, 57 ], [ 69, 58 ], [ 71, 69 ], [ 71, 72 ] ]

[ "a,b=map(int,input().split())\nif a>0 and b>0:\n print('Positive')\nelif a==0 or b==0:\n print('Zero')\nelse:\n if a<0 and b>0:\n print('Zero')\n elif a<0 and b<0:\n if (a-b)%2==0:\n print('Negative')\n else:\n print('Positive')", "a,b=map(int,input().split())", "a", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "if a>0 and b>0:\n print('Positive')\nelif a==0 or b==0:\n print('Zero')\nelse:\n if a<0 and b>0:\n print('Zero')\n elif a<0 and b<0:\n if (a-b)%2==0:\n print('Negative')\n else:\n print('Positive')", "a>0 and b>0", "a>0", "a", "0", "b>0", "b", "0", "print('Positive')", "print", "'Positive'", "elif a==0 or b==0:\n print('Zero')", "a==0 or b==0", "a==0", "a", "0", "b==0", "b", "0", "print('Zero')", "print", "'Zero'", "if a<0 and b>0:\n print('Zero')\n elif a<0 and b<0:\n if (a-b)%2==0:\n print('Negative')\n else:\n print('Positive')", "a<0 and b>0", "a<0", "a", "0", "b>0", "b", "0", "print('Zero')", "print", "'Zero'", "elif a<0 and b<0:\n if (a-b)%2==0:\n print('Negative')\n else:\n print('Positive')", "a<0 and b<0", "a<0", "a", "0", "b<0", "b", "0", "if (a-b)%2==0:\n print('Negative')\n else:\n print('Positive')", "(a-b)%2==0", "(a-b)%2", "a-b", "a", "b", "2", "0", "print('Negative')", "print", "'Negative'", "print('Positive')", "print", "'Positive'", "b=map(int,input().split())", "map(int,input().split())", "b", "a,b=map(int,input().split())", "map(int,input().split())", "a" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 2, 2, 2, 2, 13, 2, 17, 13, 17, 2, 2, 13, 17, 2, 17, 13, 2, 2, 13, 17, 2, 17, 13, 0, 13, 2, 2, 2, 13, 17, 2, 17, 13, 40, 2, 2, 2, 13, 13, 17, 17, 17, 0, 13, 2, 2, 2, 13, 2, 17, 13, 17, 40, 2, 2, 2, 13, 13, 17, 17, 17, 14, 13, 4, 13, 17, 14, 2, 13, 13, 4, 13, 17, 4, 13, 17, 10, 4, 13, 10, 2, 13, 10, 2, 13, 10, 4, 13, 10, 2, 13 ]

[ [ 100, 2 ], [ 100, 11 ], [ 103, 13 ], [ 92, 18 ], [ 101, 21 ], [ 92, 25 ], [ 101, 29 ], [ 101, 32 ], [ 92, 36 ], [ 97, 38 ], [ 92, 42 ], [ 101, 46 ], [ 92, 51 ], [ 101, 52 ], [ 94, 57 ], [ 92, 61 ], [ 101, 64 ], [ 92, 70 ], [ 101, 71 ], [ 98, 82 ], [ 95, 83 ], [ 100, 92 ], [ 94, 95 ], [ 97, 98 ], [ 100, 101 ], [ 103, 104 ] ]

[ "a, b = map(int, input().split())\nzero = (a == 0 | b == 0) | (a < 0 and 0 < b) | (b < 0 and 0 < a)\nnegative_a = (a < 0 and 0 < b) and (a + b + 1) % 2 != 0\nnegative_b = (a < 0 | b < 0) and (a + b + 1) % 2 != 0\nif zero:\n print(\"Zero\")\nelif negative_a | negative_b:\n print(\"Negative\")\nelse:\n print(\"Positive\")", "a, b = map(int, input().split())", "a", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "zero = (a == 0 | b == 0) | (a < 0 and 0 < b) | (b < 0 and 0 < a)", "zero", "(a == 0 | b == 0) | (a < 0 and 0 < b) | (b < 0 and 0 < a)", "(a == 0 | b == 0) | (a < 0 and 0 < b)", "a == 0 | b == 0", "a == 0 | b", "a", "0 | b", "0", "b", "0", "a < 0 and 0 < b", "a < 0", "a", "0", "0 < b", "0", "b", "b < 0 and 0 < a", "b < 0", "b", "0", "0 < a", "0", "a", "negative_a = (a < 0 and 0 < b) and (a + b + 1) % 2 != 0", "negative_a", "(a < 0 and 0 < b) and (a + b + 1) % 2 != 0", "a < 0 and 0 < b", "a < 0", "a", "0", "0 < b", "0", "b", "(a + b + 1) % 2 != 0", "(a + b + 1) % 2", "a + b + 1", "a + b", "a", "b", "1", "2", "0", "negative_b = (a < 0 | b < 0) and (a + b + 1) % 2 != 0", "negative_b", "(a < 0 | b < 0) and (a + b + 1) % 2 != 0", "a < 0 | b < 0", "a < 0 | b", "a", "0 | b", "0", "b", "0", "(a + b + 1) % 2 != 0", "(a + b + 1) % 2", "a + b + 1", "a + b", "a", "b", "1", "2", "0", "if zero:\n print(\"Zero\")\nelif negative_a | negative_b:\n print(\"Negative\")\nelse:\n print(\"Positive\")", "zero", "print(\"Zero\")", "print", "\"Zero\"", "elif negative_a | negative_b:\n print(\"Negative\")", "negative_a | negative_b", "negative_a", "negative_b", "print(\"Negative\")", "print", "\"Negative\"", "print(\"Positive\")", "print", "\"Positive\"", "a, b = map(int, input().split())", "map(int, input().split())", "a", "negative_b = (a < 0 | b < 0) and (a + b + 1) % 2 != 0", "(a < 0 | b < 0) and (a + b + 1) % 2 != 0", "negative_b", "negative_a = (a < 0 and 0 < b) and (a + b + 1) % 2 != 0", "(a < 0 and 0 < b) and (a + b + 1) % 2 != 0", "negative_a", "b = map(int, input().split())", "map(int, input().split())", "b", "zero = (a == 0 | b == 0) | (a < 0 and 0 < b) | (b < 0 and 0 < a)", "(a == 0 | b == 0) | (a < 0 and 0 < b) | (b < 0 and 0 < a)", "zero" ]

[ 7, 15, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 14, 40, 13, 17, 4, 13, 17, 4, 18, 13, 13, 14, 40, 13, 17, 4, 13, 17, 4, 18, 13, 13, 14, 2, 2, 4, 13, 2, 13, 13, 17, 17, 4, 13, 17, 4, 13, 17, 10, 4, 13, 10, 4, 13 ]

[ [ 56, 4 ], [ 56, 13 ], [ 54, 16 ], [ 57, 27 ], [ 54, 42 ], [ 57, 43 ], [ 56, 54 ], [ 56, 57 ] ]

[ "import sys\na,b=map(int,input().split())\nif a>=0:\n print(\"Positive\")\n sys.exit()\nif b>=0:\n print(\"Zero\")\n sys.exit()\nif abs(a-b)%2==0:\n print(\"Negative\")\nelse:\n print(\"Positive\")", "import sys", "sys", "a,b=map(int,input().split())", "a", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "if a>=0:\n print(\"Positive\")\n sys.exit()", "a>=0", "a", "0", "print(\"Positive\")", "print", "\"Positive\"", "sys.exit()", "sys.exit", "sys", "exit", "if b>=0:\n print(\"Zero\")\n sys.exit()", "b>=0", "b", "0", "print(\"Zero\")", "print", "\"Zero\"", "sys.exit()", "sys.exit", "sys", "exit", "if abs(a-b)%2==0:\n print(\"Negative\")\nelse:\n print(\"Positive\")", "abs(a-b)%2==0", "abs(a-b)%2", "abs(a-b)", "abs", "a-b", "a", "b", "2", "0", "print(\"Negative\")", "print", "\"Negative\"", "print(\"Positive\")", "print", "\"Positive\"", "a,b=map(int,input().split())", "map(int,input().split())", "a", "b=map(int,input().split())", "map(int,input().split())", "b" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 14, 2, 13, 17, 4, 13, 17, 4, 13, 17, 14, 2, 2, 2, 13, 17, 2, 13, 17, 2, 2, 13, 17, 2, 13, 17, 4, 13, 17, 4, 13, 17, 14, 2, 13, 13, 4, 13, 17, 4, 13, 17, 14, 2, 2, 2, 13, 13, 17, 17, 4, 13, 17, 4, 13, 17, 10, 4, 13, 10, 4, 13 ]

[ [ 72, 2 ], [ 72, 11 ], [ 73, 14 ], [ 73, 26 ], [ 70, 29 ], [ 73, 33 ], [ 70, 36 ], [ 73, 46 ], [ 70, 47 ], [ 73, 58 ], [ 70, 59 ], [ 72, 70 ], [ 72, 73 ] ]

[ "a,b = map(int,input().split())\n\nif a > 0:\n print(\"Positive\")\n exit(0)\n \nif (a == 0 or b == 0) or (a < 0 and b > 0):\n print(\"Zero\")\n exit(0)\n \n# only negative a,b cases left from this point on\nif (a == b):\n print(\"Negative\")\n exit(0)\n \nif (a - b) % 2 == 1:\n print(\"Positive\")\nelse:\n print(\"Negative\")", "a,b = map(int,input().split())", "a", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "if a > 0:\n print(\"Positive\")\n exit(0)\n ", "a > 0", "a", "0", "print(\"Positive\")", "print", "\"Positive\"", "exit(0)", "exit", "0", "if (a == 0 or b == 0) or (a < 0 and b > 0):\n print(\"Zero\")\n exit(0)\n \n# only negative a,b cases left from this point on", "(a == 0 or b == 0) or (a < 0 and b > 0)", "a == 0 or b == 0", "a == 0", "a", "0", "b == 0", "b", "0", "a < 0 and b > 0", "a < 0", "a", "0", "b > 0", "b", "0", "print(\"Zero\")", "print", "\"Zero\"", "exit(0)", "exit", "0", "if (a == b):\n print(\"Negative\")\n exit(0)\n ", "a == b", "a", "b", "print(\"Negative\")", "print", "\"Negative\"", "exit(0)", "exit", "0", "if (a - b) % 2 == 1:\n print(\"Positive\")\nelse:\n print(\"Negative\")", "(a - b) % 2 == 1", "(a - b) % 2", "a - b", "a", "b", "2", "1", "print(\"Positive\")", "print", "\"Positive\"", "print(\"Negative\")", "print", "\"Negative\"", "b = map(int,input().split())", "map(int,input().split())", "b", "a,b = map(int,input().split())", "map(int,input().split())", "a" ]

[ 7, 0, 13, 4, 18, 4, 13, 13, 17, 0, 13, 4, 13, 18, 13, 17, 0, 13, 4, 13, 18, 13, 17, 14, 2, 13, 17, 4, 13, 17, 14, 2, 40, 13, 17, 40, 13, 17, 4, 13, 17, 0, 13, 2, 2, 13, 13, 17, 14, 2, 2, 13, 17, 17, 4, 13, 17, 4, 13, 17, 10, 4, 13, 10, 2, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 61, 2 ], [ 67, 10 ], [ 62, 14 ], [ 70, 17 ], [ 62, 21 ], [ 68, 25 ], [ 68, 33 ], [ 71, 36 ], [ 64, 42 ], [ 71, 45 ], [ 68, 46 ], [ 65, 51 ], [ 61, 62 ], [ 64, 65 ], [ 67, 68 ], [ 70, 71 ] ]

[ "line = input().split(\" \")\na = int(line[0])\nb = int(line[1])\n\nif a > 0:\n print(\"Positive\")\nelif a <= 0 and b >= 0:\n print(\"Zero\")\nelse:\n c = b - a + 1\n if c % 2 == 0:\n print(\"Positive\")\n else:\n print(\"Negative\")", "line = input().split(\" \")", "line", "input().split(\" \")", "().split", "()", "input", "split", "\" \"", "a = int(line[0])", "a", "int(line[0])", "int", "line[0]", "line", "0", "b = int(line[1])", "b", "int(line[1])", "int", "line[1]", "line", "1", "if a > 0:\n print(\"Positive\")\nelif a <= 0 and b >= 0:\n print(\"Zero\")\nelse:\n c = b - a + 1\n if c % 2 == 0:\n print(\"Positive\")\n else:\n print(\"Negative\")", "a > 0", "a", "0", "print(\"Positive\")", "print", "\"Positive\"", "elif a <= 0 and b >= 0:\n print(\"Zero\")", "a <= 0 and b >= 0", "a <= 0", "a", "0", "b >= 0", "b", "0", "print(\"Zero\")", "print", "\"Zero\"", "c = b - a + 1", "c", "b - a + 1", "b - a", "b", "a", "1", "if c % 2 == 0:\n print(\"Positive\")\n else:\n print(\"Negative\")", "c % 2 == 0", "c % 2", "c", "2", "0", "print(\"Positive\")", "print", "\"Positive\"", "print(\"Negative\")", "print", "\"Negative\"", "line = input().split(\" \")", "input().split(\" \")", "line", "c = b - a + 1", "b - a + 1", "c", "a = int(line[0])", "int(line[0])", "a", "b = int(line[1])", "int(line[1])", "b" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 14, 2, 17, 13, 0, 13, 17, 14, 2, 2, 2, 13, 13, 17, 2, 2, 13, 13, 17, 0, 13, 17, 14, 2, 13, 13, 0, 13, 17, 14, 2, 2, 2, 13, 13, 17, 17, 0, 13, 17, 0, 13, 17, 4, 13, 13, 10, 4, 13, 10, 17, 13, 10, 17, 13, 10, 17, 13, 10, 17, 13, 10, 4, 13, 10, 17, 13 ]

[ [ 74, 2 ], [ 74, 11 ], [ 75, 15 ], [ 62, 17 ], [ 75, 23 ], [ 60, 24 ], [ 75, 28 ], [ 60, 29 ], [ 65, 32 ], [ 75, 36 ], [ 60, 37 ], [ 68, 39 ], [ 60, 45 ], [ 75, 46 ], [ 77, 50 ], [ 71, 53 ], [ 72, 57 ], [ 78, 57 ], [ 69, 57 ], [ 66, 57 ], [ 63, 57 ], [ 74, 60 ], [ 62, 63 ], [ 65, 66 ], [ 68, 69 ], [ 71, 72 ], [ 74, 75 ], [ 77, 78 ] ]

[ "a, b = map(int, input().split())\nif (0 < a):\n res = \"Positive\"\n\nelif (a * b == 0) or (a * b < 0):\n res = \"Zero\"\n\nelse:\n if a == b:\n res = \"Positive\"\n elif (b-a) % 2 == 1:\n res = \"Positive\"\n else:\n res = \"Negative\"\nprint(res)", "a, b = map(int, input().split())", "a", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "if (0 < a):\n res = \"Positive\"\n\nelif (a * b == 0) or (a * b < 0):\n res = \"Zero\"\n\nelse:\n if a == b:\n res = \"Positive\"\n elif (b-a) % 2 == 1:\n res = \"Positive\"\n else:\n res = \"Negative\"", "0 < a", "0", "a", "res = \"Positive\"", "res", "\"Positive\"", "elif (a * b == 0) or (a * b < 0):\n res = \"Zero\"", "(a * b == 0) or (a * b < 0)", "a * b == 0", "a * b", "a", "b", "0", "a * b < 0", "a * b", "a", "b", "0", "res = \"Zero\"", "res", "\"Zero\"", "if a == b:\n res = \"Positive\"\n elif (b-a) % 2 == 1:\n res = \"Positive\"\n else:\n res = \"Negative\"", "a == b", "a", "b", "res = \"Positive\"", "res", "\"Positive\"", "elif (b-a) % 2 == 1:\n res = \"Positive\"\n ", "(b-a) % 2 == 1", "(b-a) % 2", "b-a", "b", "a", "2", "1", "res = \"Positive\"", "res", "\"Positive\"", "res = \"Negative\"", "res", "\"Negative\"", "print(res)", "print", "res", "b = map(int, input().split())", "map(int, input().split())", "b", "res = \"Positive\"", "\"Positive\"", "res", "res = \"Zero\"", "\"Zero\"", "res", "res = \"Positive\"", "\"Positive\"", "res", "res = \"Negative\"", "\"Negative\"", "res", "a, b = map(int, input().split())", "map(int, input().split())", "a", "res = \"Positive\"", "\"Positive\"", "res" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 4, 13, 13, 2, 13, 17, 14, 2, 13, 17, 4, 13, 17, 14, 2, 2, 13, 17, 2, 13, 17, 4, 13, 17, 4, 13, 8, 40, 2, 2, 13, 13, 17, 17, 17, 17, 10, 4, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 57, 2 ], [ 57, 11 ], [ 51, 13 ], [ 55, 16 ], [ 58, 18 ], [ 55, 22 ], [ 55, 30 ], [ 58, 33 ], [ 58, 44 ], [ 55, 45 ], [ 51, 52 ], [ 57, 55 ], [ 57, 58 ] ]

[ "a, b = map(int, input().split())\nX = range(a, b+1)\n\nif a > 0:\n print('Positive')\nelif a < 0 and b > 0:\n print('Zero')\nelse:\n print('Positive' if (b - a) % 2 != 0 else 'Negative')", "a, b = map(int, input().split())", "a", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "X = range(a, b+1)", "X", "range(a, b+1)", "range", "a", "b+1", "b", "1", "if a > 0:\n print('Positive')\nelif a < 0 and b > 0:\n print('Zero')\nelse:\n print('Positive' if (b - a) % 2 != 0 else 'Negative')", "a > 0", "a", "0", "print('Positive')", "print", "'Positive'", "elif a < 0 and b > 0:\n print('Zero')", "a < 0 and b > 0", "a < 0", "a", "0", "b > 0", "b", "0", "print('Zero')", "print", "'Zero'", "print('Positive' if (b - a) % 2 != 0 else 'Negative')", "print", "'Positive' if (b - a) % 2 != 0 else 'Negative'", "(b - a) % 2 != 0", "(b - a) % 2", "b - a", "b", "a", "2", "0", "'Positive'", "'Negative'", "X = range(a, b+1)", "range(a, b+1)", "X", "a, b = map(int, input().split())", "map(int, input().split())", "a", "b = map(int, input().split())", "map(int, input().split())", "b" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 17, 14, 2, 2, 13, 17, 2, 13, 17, 4, 13, 17, 14, 2, 13, 17, 4, 13, 17, 14, 2, 2, 13, 17, 2, 13, 17, 4, 13, 17, 14, 2, 13, 17, 4, 13, 17, 14, 2, 2, 13, 17, 2, 13, 17, 0, 13, 2, 13, 13, 14, 2, 2, 13, 17, 17, 4, 13, 17, 14, 40, 2, 13, 17, 17, 4, 13, 17, 10, 17, 13, 10, 2, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 92, 2 ], [ 92, 11 ], [ 83, 13 ], [ 93, 18 ], [ 90, 21 ], [ 93, 28 ], [ 93, 36 ], [ 90, 39 ], [ 90, 46 ], [ 93, 54 ], [ 90, 57 ], [ 86, 60 ], [ 90, 62 ], [ 93, 63 ], [ 87, 67 ], [ 87, 76 ], [ 83, 84 ], [ 86, 87 ], [ 92, 90 ], [ 92, 93 ] ]

[ "a, b = map(int, input().split())\nans = 1\n\nif a > 0 and b > 0:\n print(\"Positive\")\nelif a == 0:\n print(\"Zero\")\nelif a < 0 and b > 0:\n print(\"Zero\")\nelif b == 0:\n print(\"Zero\")\nelif a < 0 and b < 0:\n diff = b - a\n if diff % 2 == 0:\n print(\"Negative\")\n elif diff % 2 != 0:\n print(\"Positive\")", "a, b = map(int, input().split())", "a", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "ans = 1", "ans", "1", "if a > 0 and b > 0:\n print(\"Positive\")\nelif a == 0:\n print(\"Zero\")\nelif a < 0 and b > 0:\n print(\"Zero\")\nelif b == 0:\n print(\"Zero\")\nelif a < 0 and b < 0:\n diff = b - a\n if diff % 2 == 0:\n print(\"Negative\")\n elif diff % 2 != 0:\n print(\"Positive\")", "a > 0 and b > 0", "a > 0", "a", "0", "b > 0", "b", "0", "print(\"Positive\")", "print", "\"Positive\"", "elif a == 0:\n print(\"Zero\")", "a == 0", "a", "0", "print(\"Zero\")", "print", "\"Zero\"", "elif a < 0 and b > 0:\n print(\"Zero\")", "a < 0 and b > 0", "a < 0", "a", "0", "b > 0", "b", "0", "print(\"Zero\")", "print", "\"Zero\"", "elif b == 0:\n print(\"Zero\")", "b == 0", "b", "0", "print(\"Zero\")", "print", "\"Zero\"", "elif a < 0 and b < 0:\n diff = b - a\n if diff % 2 == 0:\n print(\"Negative\")\n elif diff % 2 != 0:\n print(\"Positive\")", "a < 0 and b < 0", "a < 0", "a", "0", "b < 0", "b", "0", "diff = b - a", "diff", "b - a", "b", "a", "if diff % 2 == 0:\n print(\"Negative\")\n elif diff % 2 != 0:\n print(\"Positive\")", "diff % 2 == 0", "diff % 2", "diff", "2", "0", "print(\"Negative\")", "print", "\"Negative\"", "elif diff % 2 != 0:\n print(\"Positive\")", "diff % 2 != 0", "diff % 2", "diff", "2", "0", "print(\"Positive\")", "print", "\"Positive\"", "ans = 1", "1", "ans", "diff = b - a", "b - a", "diff", "b = map(int, input().split())", "map(int, input().split())", "b", "a, b = map(int, input().split())", "map(int, input().split())", "a" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 14, 2, 40, 13, 17, 40, 13, 17, 0, 13, 17, 14, 2, 13, 17, 0, 13, 17, 14, 2, 2, 2, 13, 13, 17, 17, 0, 13, 17, 0, 13, 17, 4, 13, 13, 10, 17, 13, 10, 17, 13, 10, 4, 13, 10, 17, 13, 10, 17, 13, 10, 4, 13 ]

[ [ 63, 2 ], [ 63, 11 ], [ 55, 15 ], [ 64, 18 ], [ 48, 21 ], [ 55, 25 ], [ 60, 28 ], [ 64, 34 ], [ 55, 35 ], [ 57, 39 ], [ 51, 42 ], [ 52, 46 ], [ 58, 46 ], [ 61, 46 ], [ 49, 46 ], [ 48, 49 ], [ 51, 52 ], [ 63, 55 ], [ 57, 58 ], [ 60, 61 ], [ 63, 64 ] ]

[ "a, b = map(int, input().split())\nif a<=0 and b>=0:\n ans = 'Zero'\nelif a>0:\n ans = 'Positive'\nelse:\n if (b-a)%2 == 0:\n ans = 'Negative'\n else:\n ans = 'Positive'\nprint(ans)", "a, b = map(int, input().split())", "a", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "if a<=0 and b>=0:\n ans = 'Zero'\nelif a>0:\n ans = 'Positive'\nelse:\n if (b-a)%2 == 0:\n ans = 'Negative'\n else:\n ans = 'Positive'", "a<=0 and b>=0", "a<=0", "a", "0", "b>=0", "b", "0", "ans = 'Zero'", "ans", "'Zero'", "elif a>0:\n ans = 'Positive'", "a>0", "a", "0", "ans = 'Positive'", "ans", "'Positive'", "if (b-a)%2 == 0:\n ans = 'Negative'\n else:\n ans = 'Positive'", "(b-a)%2 == 0", "(b-a)%2", "b-a", "b", "a", "2", "0", "ans = 'Negative'", "ans", "'Negative'", "ans = 'Positive'", "ans", "'Positive'", "print(ans)", "print", "ans", "ans = 'Zero'", "'Zero'", "ans", "ans = 'Positive'", "'Positive'", "ans", "a, b = map(int, input().split())", "map(int, input().split())", "a", "ans = 'Negative'", "'Negative'", "ans", "ans = 'Positive'", "'Positive'", "ans", "b = map(int, input().split())", "map(int, input().split())", "b" ]

[ 7, 15, 13, 12, 13, 12, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 14, 2, 13, 17, 4, 13, 17, 14, 2, 2, 13, 17, 2, 13, 17, 4, 13, 17, 14, 2, 2, 13, 17, 2, 13, 17, 4, 13, 17, 14, 2, 2, 13, 17, 2, 2, 2, 13, 13, 17, 17, 4, 13, 17, 4, 13, 17, 4, 13, 10, 12, 13, 10, 12, 13 ]

[ [ 9, 8 ], [ 69, 15 ], [ 9, 17 ], [ 8, 20 ], [ 8, 28 ], [ 17, 31 ], [ 8, 39 ], [ 17, 42 ], [ 17, 50 ], [ 17, 55 ], [ 8, 56 ], [ 72, 66 ] ]

[ "import sys\ndef input(): return sys.stdin.readline().strip()\n\ndef resolve():\n a,b=map(int, input().split())\n if a>0:\n print('Positive')\n elif a==0 or b==0:\n print('Zero')\n elif a<0 and b>0:\n print('Zero')\n elif b<0 and (b-a)%2==0:\n print('Negative')\n else:\n print('Positive')\nresolve()", "import sys", "sys", "def input(): return sys.stdin.readline().strip()", "input", "def resolve():\n a,b=map(int, input().split())\n if a>0:\n print('Positive')\n elif a==0 or b==0:\n print('Zero')\n elif a<0 and b>0:\n print('Zero')\n elif b<0 and (b-a)%2==0:\n print('Negative')\n else:\n print('Positive')", "resolve", "a,b=map(int, input().split())", "a", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "if a>0:\n print('Positive')\n elif a==0 or b==0:\n print('Zero')\n elif a<0 and b>0:\n print('Zero')\n elif b<0 and (b-a)%2==0:\n print('Negative')\n else:\n print('Positive')", "a>0", "a", "0", "print('Positive')", "print", "'Positive'", "elif a==0 or b==0:\n print('Zero')\n ", "a==0 or b==0", "a==0", "a", "0", "b==0", "b", "0", "print('Zero')", "print", "'Zero'", "elif a<0 and b>0:\n print('Zero')\n ", "a<0 and b>0", "a<0", "a", "0", "b>0", "b", "0", "print('Zero')", "print", "'Zero'", "elif b<0 and (b-a)%2==0:\n print('Negative')\n ", "b<0 and (b-a)%2==0", "b<0", "b", "0", "(b-a)%2==0", "(b-a)%2", "b-a", "b", "a", "2", "0", "print('Negative')", "print", "'Negative'", "print('Positive')", "print", "'Positive'", "resolve()", "resolve", "def input(): return sys.stdin.readline().strip()", "def input(): return sys.stdin.readline().strip()", "input", "def resolve():\n a,b=map(int, input().split())\n if a>0:\n print('Positive')\n elif a==0 or b==0:\n print('Zero')\n elif a<0 and b>0:\n print('Zero')\n elif b<0 and (b-a)%2==0:\n print('Negative')\n else:\n print('Positive')", "def resolve():\n a,b=map(int, input().split())\n if a>0:\n print('Positive')\n elif a==0 or b==0:\n print('Zero')\n elif a<0 and b>0:\n print('Zero')\n elif b<0 and (b-a)%2==0:\n print('Negative')\n else:\n print('Positive')", "resolve" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 4, 13, 13, 13, 0, 13, 4, 13, 13, 13, 14, 40, 13, 4, 13, 13, 14, 2, 13, 4, 13, 13, 14, 2, 2, 2, 13, 13, 17, 17, 14, 2, 13, 17, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 55, 2 ], [ 55, 11 ], [ 58, 13 ], [ 56, 16 ], [ 53, 17 ], [ 49, 19 ], [ 59, 22 ], [ 56, 22 ], [ 53, 23 ], [ 59, 26 ], [ 56, 26 ], [ 59, 29 ], [ 56, 29 ], [ 50, 32 ], [ 53, 32 ], [ 50, 35 ], [ 53, 35 ], [ 50, 40 ], [ 53, 40 ], [ 59, 41 ], [ 56, 41 ], [ 59, 46 ], [ 56, 46 ], [ 49, 50 ], [ 55, 53 ], [ 55, 56 ], [ 58, 59 ] ]

[ "a, b = map(int,input().split())\na = min(a,b)\nb = max(a,b)\nif a != abs(a):\n if b == abs(b): print(\"Zero\")\n elif (b - a) % 2 == 0: print(\"Negative\")\n else: print(\"Positive\")\nelif a == 0: print(\"Zero\")\nelse: print(\"Positive\") ", "a, b = map(int,input().split())", "a", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "a = min(a,b)", "a", "min(a,b)", "min", "a", "b", "b = max(a,b)", "b", "max(a,b)", "max", "a", "b", "if a != abs(a):\n if b == abs(b): print(\"Zero\")\n elif (b - a) % 2 == 0: print(\"Negative\")\n else: print(\"Positive\")\nelif a == 0: print(\"Zero\")\nelse: print(\"Positive\") ", "a != abs(a)", "a", "abs(a)", "abs", "a", "if b == abs(b): print(\"Zero\")\n elif (b - a) % 2 == 0: print(\"Negative\")\n else: print(\"Positive\")", "b == abs(b)", "b", "abs(b)", "abs", "b", "elif (b - a) % 2 == 0: print(\"Negative\")\n ", "(b - a) % 2 == 0", "(b - a) % 2", "b - a", "b", "a", "2", "0", "elif a == 0: print(\"Zero\")", "a == 0", "a", "0", "b = max(a,b)", "max(a,b)", "b", "b = map(int,input().split())", "map(int,input().split())", "b", "a, b = map(int,input().split())", "map(int,input().split())", "a", "a = min(a,b)", "min(a,b)", "a" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 14, 2, 2, 13, 17, 2, 13, 17, 4, 13, 17, 14, 2, 2, 2, 13, 17, 2, 13, 17, 40, 2, 2, 2, 4, 13, 13, 4, 13, 13, 17, 17, 17, 4, 13, 17, 14, 2, 2, 2, 13, 17, 2, 13, 17, 2, 2, 2, 2, 4, 13, 13, 4, 13, 13, 17, 17, 17, 4, 13, 17, 4, 13, 17, 10, 4, 13, 10, 4, 13 ]

[ [ 80, 2 ], [ 80, 11 ], [ 78, 15 ], [ 81, 18 ], [ 78, 27 ], [ 81, 30 ], [ 78, 38 ], [ 81, 41 ], [ 78, 52 ], [ 81, 55 ], [ 78, 63 ], [ 81, 66 ], [ 80, 78 ], [ 80, 81 ] ]

[ "a,b=map(int,input().split())\nif a>0 and b>0:\n print('Positive')\nelif a<0 and b<0 and (abs(a)-abs(b)+1)%2 != 0:\n print('Negative')\nelif a<0 and b<0 and (abs(a)-abs(b)+1)%2==0:\n print('Positive')\nelse:\n print('Zero')", "a,b=map(int,input().split())", "a", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "if a>0 and b>0:\n print('Positive')\nelif a<0 and b<0 and (abs(a)-abs(b)+1)%2 != 0:\n print('Negative')\nelif a<0 and b<0 and (abs(a)-abs(b)+1)%2==0:\n print('Positive')\nelse:\n print('Zero')", "a>0 and b>0", "a>0", "a", "0", "b>0", "b", "0", "print('Positive')", "print", "'Positive'", "elif a<0 and b<0 and (abs(a)-abs(b)+1)%2 != 0:\n print('Negative')", "a<0 and b<0 and (abs(a)-abs(b)+1)%2 != 0", "a<0 and b<0", "a<0", "a", "0", "b<0", "b", "0", "(abs(a)-abs(b)+1)%2 != 0", "(abs(a)-abs(b)+1)%2", "abs(a)-abs(b)+1", "abs(a)-abs(b)", "abs(a)", "abs", "a", "abs(b)", "abs", "b", "1", "2", "0", "print('Negative')", "print", "'Negative'", "elif a<0 and b<0 and (abs(a)-abs(b)+1)%2==0:\n print('Positive')", "a<0 and b<0 and (abs(a)-abs(b)+1)%2==0", "a<0 and b<0", "a<0", "a", "0", "b<0", "b", "0", "(abs(a)-abs(b)+1)%2==0", "(abs(a)-abs(b)+1)%2", "abs(a)-abs(b)+1", "abs(a)-abs(b)", "abs(a)", "abs", "a", "abs(b)", "abs", "b", "1", "2", "0", "print('Positive')", "print", "'Positive'", "print('Zero')", "print", "'Zero'", "a,b=map(int,input().split())", "map(int,input().split())", "a", "b=map(int,input().split())", "map(int,input().split())", "b" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 14, 2, 40, 13, 17, 40, 13, 17, 4, 13, 17, 14, 2, 13, 17, 4, 13, 17, 14, 2, 2, 13, 17, 2, 13, 17, 14, 2, 2, 4, 13, 13, 17, 17, 4, 13, 17, 4, 13, 17, 14, 2, 2, 2, 13, 13, 17, 17, 4, 13, 17, 4, 13, 17, 10, 4, 13, 10, 4, 13 ]

[ [ 70, 2 ], [ 70, 11 ], [ 71, 15 ], [ 68, 18 ], [ 71, 25 ], [ 71, 33 ], [ 68, 36 ], [ 71, 43 ], [ 68, 56 ], [ 71, 57 ], [ 70, 68 ], [ 70, 71 ] ]

[ "a,b=map(int,input().split())\nif a<=0 and b>=0:\n print('Zero')\nelif a>0:\n print('Positive')\nelif a<0 and b>0:\n if abs(a)%2==0:\n print('Positive')\n else:\n print('Negative')\nelse:\n if (b-a)%2==0:\n print('Negative')\n else:\n print('Positive')", "a,b=map(int,input().split())", "a", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "if a<=0 and b>=0:\n print('Zero')\nelif a>0:\n print('Positive')\nelif a<0 and b>0:\n if abs(a)%2==0:\n print('Positive')\n else:\n print('Negative')\nelse:\n if (b-a)%2==0:\n print('Negative')\n else:\n print('Positive')", "a<=0 and b>=0", "a<=0", "a", "0", "b>=0", "b", "0", "print('Zero')", "print", "'Zero'", "elif a>0:\n print('Positive')", "a>0", "a", "0", "print('Positive')", "print", "'Positive'", "elif a<0 and b>0:\n if abs(a)%2==0:\n print('Positive')\n else:\n print('Negative')", "a<0 and b>0", "a<0", "a", "0", "b>0", "b", "0", "if abs(a)%2==0:\n print('Positive')\n else:\n print('Negative')", "abs(a)%2==0", "abs(a)%2", "abs(a)", "abs", "a", "2", "0", "print('Positive')", "print", "'Positive'", "print('Negative')", "print", "'Negative'", "if (b-a)%2==0:\n print('Negative')\n else:\n print('Positive')", "(b-a)%2==0", "(b-a)%2", "b-a", "b", "a", "2", "0", "print('Negative')", "print", "'Negative'", "print('Positive')", "print", "'Positive'", "b=map(int,input().split())", "map(int,input().split())", "b", "a,b=map(int,input().split())", "map(int,input().split())", "a" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 14, 2, 2, 13, 13, 17, 0, 13, 17, 14, 2, 13, 17, 0, 13, 17, 0, 13, 8, 2, 2, 2, 2, 13, 13, 17, 17, 17, 17, 17, 4, 13, 13, 10, 4, 13, 10, 17, 13, 10, 17, 13, 10, 8, 13, 10, 4, 13 ]

[ [ 58, 2 ], [ 58, 11 ], [ 47, 15 ], [ 59, 16 ], [ 52, 19 ], [ 47, 23 ], [ 49, 26 ], [ 55, 29 ], [ 59, 35 ], [ 47, 36 ], [ 56, 44 ], [ 50, 44 ], [ 53, 44 ], [ 58, 47 ], [ 49, 50 ], [ 52, 53 ], [ 55, 56 ], [ 58, 59 ] ]

[ "a, b = map(int, input().split())\n\nif a*b < 1:\n ans = \"Zero\"\nelif a > 0:\n ans = \"Positive\"\nelse:\n ans = \"Positive\" if (b-a+1) % 2 == 0 else \"Negative\"\n\nprint(ans)", "a, b = map(int, input().split())", "a", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "if a*b < 1:\n ans = \"Zero\"\nelif a > 0:\n ans = \"Positive\"\nelse:\n ans = \"Positive\" if (b-a+1) % 2 == 0 else \"Negative\"", "a*b < 1", "a*b", "a", "b", "1", "ans = \"Zero\"", "ans", "\"Zero\"", "elif a > 0:\n ans = \"Positive\"", "a > 0", "a", "0", "ans = \"Positive\"", "ans", "\"Positive\"", "ans = \"Positive\" if (b-a+1) % 2 == 0 else \"Negative\"", "ans", "\"Positive\" if (b-a+1) % 2 == 0 else \"Negative\"", "(b-a+1) % 2 == 0", "(b-a+1) % 2", "b-a+1", "b-a", "b", "a", "1", "2", "0", "\"Positive\"", "\"Negative\"", "print(ans)", "print", "ans", "a, b = map(int, input().split())", "map(int, input().split())", "a", "ans = \"Positive\"", "\"Positive\"", "ans", "ans = \"Zero\"", "\"Zero\"", "ans", "ans = \"Positive\" if (b-a+1) % 2 == 0 else \"Negative\"", "\"Positive\" if (b-a+1) % 2 == 0 else \"Negative\"", "ans", "b = map(int, input().split())", "map(int, input().split())", "b" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 14, 40, 40, 13, 17, 13, 4, 13, 17, 14, 2, 2, 2, 13, 17, 2, 13, 17, 2, 2, 4, 13, 2, 13, 13, 17, 17, 4, 13, 17, 4, 13, 17, 10, 4, 13, 10, 4, 13 ]

[ [ 49, 2 ], [ 49, 11 ], [ 47, 15 ], [ 50, 17 ], [ 47, 25 ], [ 50, 28 ], [ 50, 35 ], [ 47, 36 ], [ 49, 47 ], [ 49, 50 ] ]

[ "a,b = map(int, input().split())\n\nif a <= 0 <= b:\n print(\"Zero\")\nelif (a>0 and b>0) or (abs(b-a)%2==1):\n print(\"Positive\")\nelse:\n print(\"Negative\")", "a,b = map(int, input().split())", "a", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "if a <= 0 <= b:\n print(\"Zero\")\nelif (a>0 and b>0) or (abs(b-a)%2==1):\n print(\"Positive\")\nelse:\n print(\"Negative\")", "a <= 0 <= b", "a <= 0", "a", "0", "b", "print(\"Zero\")", "print", "\"Zero\"", "elif (a>0 and b>0) or (abs(b-a)%2==1):\n print(\"Positive\")", "(a>0 and b>0) or (abs(b-a)%2==1)", "a>0 and b>0", "a>0", "a", "0", "b>0", "b", "0", "abs(b-a)%2==1", "abs(b-a)%2", "abs(b-a)", "abs", "b-a", "b", "a", "2", "1", "print(\"Positive\")", "print", "\"Positive\"", "print(\"Negative\")", "print", "\"Negative\"", "a,b = map(int, input().split())", "map(int, input().split())", "a", "b = map(int, input().split())", "map(int, input().split())", "b" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 14, 2, 13, 17, 4, 13, 17, 14, 2, 2, 13, 17, 2, 13, 17, 4, 13, 17, 4, 13, 8, 2, 2, 13, 13, 17, 17, 17, 10, 4, 13, 10, 4, 13 ]

[ [ 44, 2 ], [ 44, 11 ], [ 42, 14 ], [ 42, 22 ], [ 45, 25 ], [ 45, 35 ], [ 42, 36 ], [ 44, 42 ], [ 44, 45 ] ]

[ "a,b=map(int,input().split())\nif a>0:\n print(\"Positive\")\nelif a<0 and b>0:\n print(\"Zero\")\nelse:\n print(\"Positive\" if (b-a)%2 else \"Negative\")", "a,b=map(int,input().split())", "a", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "if a>0:\n print(\"Positive\")\nelif a<0 and b>0:\n print(\"Zero\")\nelse:\n print(\"Positive\" if (b-a)%2 else \"Negative\")", "a>0", "a", "0", "print(\"Positive\")", "print", "\"Positive\"", "elif a<0 and b>0:\n print(\"Zero\")", "a<0 and b>0", "a<0", "a", "0", "b>0", "b", "0", "print(\"Zero\")", "print", "\"Zero\"", "print(\"Positive\" if (b-a)%2 else \"Negative\")", "print", "\"Positive\" if (b-a)%2 else \"Negative\"", "(b-a)%2", "b-a", "b", "a", "2", "\"Positive\"", "\"Negative\"", "a,b=map(int,input().split())", "map(int,input().split())", "a", "b=map(int,input().split())", "map(int,input().split())", "b" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 17, 14, 2, 2, 2, 2, 13, 17, 17, 2, 2, 13, 17, 17, 2, 2, 2, 13, 17, 17, 2, 2, 13, 17, 17, 0, 13, 17, 14, 2, 2, 2, 13, 17, 2, 13, 17, 2, 2, 2, 13, 17, 2, 13, 17, 2, 13, 17, 4, 13, 17, 14, 2, 2, 2, 2, 13, 17, 2, 13, 17, 2, 13, 17, 2, 2, 13, 17, 2, 13, 17, 4, 13, 17, 4, 13, 17, 10, 4, 13, 10, 17, 13, 10, 17, 13, 10, 4, 13 ]

[ [ 101, 2 ], [ 101, 11 ], [ 95, 13 ], [ 102, 20 ], [ 93, 25 ], [ 102, 31 ], [ 93, 36 ], [ 98, 40 ], [ 102, 46 ], [ 93, 49 ], [ 102, 54 ], [ 93, 57 ], [ 99, 60 ], [ 96, 60 ], [ 102, 70 ], [ 93, 73 ], [ 99, 76 ], [ 96, 76 ], [ 102, 80 ], [ 93, 83 ], [ 101, 93 ], [ 95, 96 ], [ 98, 99 ], [ 101, 102 ] ]

[ "a,b=map(int,input().split())\nnum=0\n\nif a%2==0 and b%2==1 or a%2==1 and b%2==0:\n num=1\n \nif a>0 and b>0 or a<0 and b<0 and num==1:\n print(\"Positive\")\n \nelif a<0 and b<0 and num==0 or a<0 and b<0:\n print(\"Negative\")\n \nelse:\n print(\"Zero\")", "a,b=map(int,input().split())", "a", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "num=0", "num", "0", "if a%2==0 and b%2==1 or a%2==1 and b%2==0:\n num=1\n ", "a%2==0 and b%2==1 or a%2==1 and b%2==0", "a%2==0 and b%2==1", "a%2==0", "a%2", "a", "2", "0", "b%2==1", "b%2", "b", "2", "1", "a%2==1 and b%2==0", "a%2==1", "a%2", "a", "2", "1", "b%2==0", "b%2", "b", "2", "0", "num=1", "num", "1", "if a>0 and b>0 or a<0 and b<0 and num==1:\n print(\"Positive\")\n \nelif a<0 and b<0 and num==0 or a<0 and b<0:\n print(\"Negative\")\n \nelse:\n print(\"Zero\")", "a>0 and b>0 or a<0 and b<0 and num==1", "a>0 and b>0", "a>0", "a", "0", "b>0", "b", "0", "a<0 and b<0 and num==1", "a<0 and b<0", "a<0", "a", "0", "b<0", "b", "0", "num==1", "num", "1", "print(\"Positive\")", "print", "\"Positive\"", "elif a<0 and b<0 and num==0 or a<0 and b<0:\n print(\"Negative\")\n ", "a<0 and b<0 and num==0 or a<0 and b<0", "a<0 and b<0 and num==0", "a<0 and b<0", "a<0", "a", "0", "b<0", "b", "0", "num==0", "num", "0", "a<0 and b<0", "a<0", "a", "0", "b<0", "b", "0", "print(\"Negative\")", "print", "\"Negative\"", "print(\"Zero\")", "print", "\"Zero\"", "b=map(int,input().split())", "map(int,input().split())", "b", "num=0", "0", "num", "num=1", "1", "num", "a,b=map(int,input().split())", "map(int,input().split())", "a" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 2, 2, 4, 13, 17, 13, 4, 13, 17, 13, 17, 14, 40, 40, 13, 17, 13, 4, 13, 17, 14, 2, 2, 13, 17, 17, 4, 13, 17, 4, 13, 17, 10, 4, 13, 10, 4, 13, 10, 2, 13 ]

[ [ 50, 2 ], [ 50, 11 ], [ 53, 13 ], [ 48, 19 ], [ 51, 23 ], [ 51, 28 ], [ 48, 30 ], [ 54, 37 ], [ 50, 48 ], [ 50, 51 ], [ 53, 54 ] ]

[ "a, b = map(int, input().split())\n\n# p = max(1, b) - max(1, a) + 1\nn = min(-1, b) - min(0, a) + 1\n\nif a <= 0 <= b:\n print(\"Zero\")\nelif n % 2 == 0:\n print(\"Positive\")\nelse:\n print(\"Negative\")", "a, b = map(int, input().split())", "a", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "n = min(-1, b) - min(0, a) + 1", "n", "min(-1, b) - min(0, a) + 1", "min(-1, b) - min(0, a)", "min(-1, b)", "min", "-1", "b", "min(0, a)", "min", "0", "a", "1", "if a <= 0 <= b:\n print(\"Zero\")\nelif n % 2 == 0:\n print(\"Positive\")\nelse:\n print(\"Negative\")", "a <= 0 <= b", "a <= 0", "a", "0", "b", "print(\"Zero\")", "print", "\"Zero\"", "elif n % 2 == 0:\n print(\"Positive\")", "n % 2 == 0", "n % 2", "n", "2", "0", "print(\"Positive\")", "print", "\"Positive\"", "print(\"Negative\")", "print", "\"Negative\"", "b = map(int, input().split())", "map(int, input().split())", "b", "a, b = map(int, input().split())", "map(int, input().split())", "a", "n = min(-1, b) - min(0, a) + 1", "min(-1, b) - min(0, a) + 1", "n" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 14, 2, 17, 13, 0, 13, 17, 14, 2, 13, 17, 0, 13, 8, 2, 2, 2, 13, 13, 17, 17, 17, 17, 0, 13, 17, 4, 13, 13, 10, 17, 13, 10, 8, 13, 10, 4, 13, 10, 17, 13, 10, 4, 13 ]

[ [ 54, 2 ], [ 54, 11 ], [ 55, 15 ], [ 42, 17 ], [ 49, 21 ], [ 45, 24 ], [ 49, 29 ], [ 55, 30 ], [ 51, 36 ], [ 52, 40 ], [ 46, 40 ], [ 43, 40 ], [ 42, 43 ], [ 45, 46 ], [ 54, 49 ], [ 51, 52 ], [ 54, 55 ] ]

[ "a,b = map(int,input().split())\nif 0<a:\n ans = 'Positive'\nelif b<0:\n ans = 'Positive' if (b-a)%2==1 else 'Negative'\nelse:\n ans = 'Zero'\nprint(ans)", "a,b = map(int,input().split())", "a", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "if 0<a:\n ans = 'Positive'\nelif b<0:\n ans = 'Positive' if (b-a)%2==1 else 'Negative'\nelse:\n ans = 'Zero'", "0<a", "0", "a", "ans = 'Positive'", "ans", "'Positive'", "elif b<0:\n ans = 'Positive' if (b-a)%2==1 else 'Negative'", "b<0", "b", "0", "ans = 'Positive' if (b-a)%2==1 else 'Negative'", "ans", "'Positive' if (b-a)%2==1 else 'Negative'", "(b-a)%2==1", "(b-a)%2", "b-a", "b", "a", "2", "1", "'Positive'", "'Negative'", "ans = 'Zero'", "ans", "'Zero'", "print(ans)", "print", "ans", "ans = 'Positive'", "'Positive'", "ans", "ans = 'Positive' if (b-a)%2==1 else 'Negative'", "'Positive' if (b-a)%2==1 else 'Negative'", "ans", "b = map(int,input().split())", "map(int,input().split())", "b", "ans = 'Zero'", "'Zero'", "ans", "a,b = map(int,input().split())", "map(int,input().split())", "a" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 14, 2, 2, 13, 17, 2, 13, 17, 14, 2, 2, 2, 4, 13, 13, 13, 4, 13, 13, 13, 17, 17, 4, 13, 17, 4, 13, 17, 14, 40, 2, 13, 13, 17, 4, 13, 17, 4, 13, 17, 10, 4, 13, 10, 4, 13 ]

[ [ 56, 2 ], [ 56, 11 ], [ 54, 15 ], [ 57, 18 ], [ 54, 26 ], [ 57, 27 ], [ 54, 30 ], [ 57, 31 ], [ 54, 43 ], [ 57, 44 ], [ 56, 54 ], [ 56, 57 ] ]

[ "a, b = map(int, input().split())\nif a < 0 and b < 0:\n if (max(a, b) - min(a, b) + 1) % 2:\n print('Negative')\n else:\n print('Positive')\nelse:\n if a * b <= 0:\n print(\"Zero\")\n else:\n print('Positive')", "a, b = map(int, input().split())", "a", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "if a < 0 and b < 0:\n if (max(a, b) - min(a, b) + 1) % 2:\n print('Negative')\n else:\n print('Positive')\nelse:\n if a * b <= 0:\n print(\"Zero\")\n else:\n print('Positive')", "a < 0 and b < 0", "a < 0", "a", "0", "b < 0", "b", "0", "if (max(a, b) - min(a, b) + 1) % 2:\n print('Negative')\n else:\n print('Positive')", "(max(a, b) - min(a, b) + 1) % 2", "max(a, b) - min(a, b) + 1", "max(a, b) - min(a, b)", "max(a, b)", "max", "a", "b", "min(a, b)", "min", "a", "b", "1", "2", "print('Negative')", "print", "'Negative'", "print('Positive')", "print", "'Positive'", "if a * b <= 0:\n print(\"Zero\")\n else:\n print('Positive')", "a * b <= 0", "a * b", "a", "b", "0", "print(\"Zero\")", "print", "\"Zero\"", "print('Positive')", "print", "'Positive'", "a, b = map(int, input().split())", "map(int, input().split())", "a", "b = map(int, input().split())", "map(int, input().split())", "b" ]

[ 7, 41, 28, 13, 4, 18, 4, 13, 13, 4, 4, 13, 13, 0, 13, 13, 13, 14, 2, 13, 17, 4, 13, 17, 14, 2, 40, 13, 17, 40, 13, 17, 4, 13, 17, 14, 2, 2, 2, 2, 13, 13, 17, 17, 17, 4, 13, 17, 4, 13, 17, 10, 13, 13, 10, 13, 13 ]

[ [ 4, 3 ], [ 3, 12 ], [ 55, 14 ], [ 55, 16 ], [ 53, 19 ], [ 53, 27 ], [ 56, 30 ], [ 56, 40 ], [ 53, 41 ], [ 55, 53 ], [ 55, 56 ] ]

[ "a, b = (int(x) for x in input().split())\nif a > 0:\n print('Positive')\nelif a <= 0 and b >= 0:\n print('Zero')\nelse:\n if (b - a + 1) % 2 == 0:\n print('Positive')\n else:\n print('Negative')", "int(x) for x in input().split()", "for x in input().split()", "x", "input().split()", "().split", "()", "input", "split", "for x in input().split()", "int(x)", "int", "x", "a, b = (int(x) for x in input().split())", "a", "(int(x) for x in input().split())", "b", "if a > 0:\n print('Positive')\nelif a <= 0 and b >= 0:\n print('Zero')\nelse:\n if (b - a + 1) % 2 == 0:\n print('Positive')\n else:\n print('Negative')", "a > 0", "a", "0", "print('Positive')", "print", "'Positive'", "elif a <= 0 and b >= 0:\n print('Zero')", "a <= 0 and b >= 0", "a <= 0", "a", "0", "b >= 0", "b", "0", "print('Zero')", "print", "'Zero'", "if (b - a + 1) % 2 == 0:\n print('Positive')\n else:\n print('Negative')", "(b - a + 1) % 2 == 0", "(b - a + 1) % 2", "b - a + 1", "b - a", "b", "a", "1", "2", "0", "print('Positive')", "print", "'Positive'", "print('Negative')", "print", "'Negative'", "a, b = (int(x) for x in input().split())", "(int(x) for x in input().split())", "a", "b = (int(x) for x in input().split())", "(int(x) for x in input().split())", "b" ]

[ 7, 41, 28, 13, 4, 18, 4, 13, 13, 4, 4, 13, 13, 0, 13, 13, 13, 14, 40, 2, 13, 13, 17, 4, 13, 17, 14, 2, 13, 17, 4, 13, 17, 14, 2, 2, 2, 13, 13, 17, 17, 4, 13, 17, 4, 13, 17, 10, 13, 13, 10, 13, 13 ]

[ [ 4, 3 ], [ 3, 12 ], [ 51, 14 ], [ 51, 16 ], [ 49, 20 ], [ 52, 21 ], [ 49, 28 ], [ 49, 37 ], [ 52, 38 ], [ 51, 49 ], [ 51, 52 ] ]

[ "a, b = [int(w) for w in input().split()]\n\nif a * b <= 0:\n print(\"Zero\")\nelif a > 0:\n print(\"Positive\")\nelse:\n if (a - b) % 2 == 0:\n print(\"Negative\")\n else:\n print(\"Positive\")", "int(w) for w in input().split()", "for w in input().split()", "w", "input().split()", "().split", "()", "input", "split", "for w in input().split()", "int(w)", "int", "w", "a, b = [int(w) for w in input().split()]", "a", "[int(w) for w in input().split()]", "b", "if a * b <= 0:\n print(\"Zero\")\nelif a > 0:\n print(\"Positive\")\nelse:\n if (a - b) % 2 == 0:\n print(\"Negative\")\n else:\n print(\"Positive\")", "a * b <= 0", "a * b", "a", "b", "0", "print(\"Zero\")", "print", "\"Zero\"", "elif a > 0:\n print(\"Positive\")", "a > 0", "a", "0", "print(\"Positive\")", "print", "\"Positive\"", "if (a - b) % 2 == 0:\n print(\"Negative\")\n else:\n print(\"Positive\")", "(a - b) % 2 == 0", "(a - b) % 2", "a - b", "a", "b", "2", "0", "print(\"Negative\")", "print", "\"Negative\"", "print(\"Positive\")", "print", "\"Positive\"", "a, b = [int(w) for w in input().split()]", "[int(w) for w in input().split()]", "a", "b = [int(w) for w in input().split()]", "[int(w) for w in input().split()]", "b" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 14, 2, 40, 13, 17, 40, 13, 17, 4, 13, 17, 14, 2, 2, 2, 4, 13, 40, 13, 17, 4, 13, 2, 40, 13, 17, 17, 17, 17, 4, 13, 17, 4, 13, 17, 10, 4, 13, 10, 4, 13 ]

[ [ 51, 2 ], [ 51, 11 ], [ 49, 15 ], [ 52, 18 ], [ 49, 30 ], [ 52, 36 ], [ 51, 49 ], [ 51, 52 ] ]

[ "# A - Range Product\na,b = map(int,input().split())\nif a<=0 and b>=0:\n print('Zero')\nelif (max(-a,0)-max(-b-1,0))%2==0:\n print('Positive')\nelse:\n print('Negative')", "a,b = map(int,input().split())", "a", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "if a<=0 and b>=0:\n print('Zero')\nelif (max(-a,0)-max(-b-1,0))%2==0:\n print('Positive')\nelse:\n print('Negative')", "a<=0 and b>=0", "a<=0", "a", "0", "b>=0", "b", "0", "print('Zero')", "print", "'Zero'", "elif (max(-a,0)-max(-b-1,0))%2==0:\n print('Positive')", "(max(-a,0)-max(-b-1,0))%2==0", "(max(-a,0)-max(-b-1,0))%2", "max(-a,0)-max(-b-1,0)", "max(-a,0)", "max", "-a", "a", "0", "max(-b-1,0)", "max", "-b-1", "-b", "b", "1", "0", "2", "0", "print('Positive')", "print", "'Positive'", "print('Negative')", "print", "'Negative'", "a,b = map(int,input().split())", "map(int,input().split())", "a", "b = map(int,input().split())", "map(int,input().split())", "b" ]

[ 7, 41, 28, 13, 4, 18, 4, 13, 13, 4, 4, 13, 13, 0, 13, 13, 13, 14, 2, 13, 17, 4, 13, 17, 14, 2, 13, 17, 14, 2, 2, 2, 2, 13, 13, 17, 17, 17, 4, 13, 17, 4, 13, 17, 14, 40, 40, 13, 17, 13, 4, 13, 17, 10, 13, 13, 10, 13, 13 ]

[ [ 4, 3 ], [ 3, 12 ], [ 57, 14 ], [ 57, 16 ], [ 55, 19 ], [ 58, 26 ], [ 58, 33 ], [ 55, 34 ], [ 55, 47 ], [ 58, 49 ], [ 57, 55 ], [ 57, 58 ] ]

[ "# AGC 002: A – Range Product\na, b = [int(s) for s in input().split()]\n\nif a > 0:\n print('Positive')\nelif b < 0:\n if (b - a + 1) % 2 == 0:\n print('Positive')\n else:\n print('Negative')\nelif a <= 0 <= b:\n print('Zero')", "int(s) for s in input().split()", "for s in input().split()", "s", "input().split()", "().split", "()", "input", "split", "for s in input().split()", "int(s)", "int", "s", "a, b = [int(s) for s in input().split()]", "a", "[int(s) for s in input().split()]", "b", "if a > 0:\n print('Positive')\nelif b < 0:\n if (b - a + 1) % 2 == 0:\n print('Positive')\n else:\n print('Negative')\nelif a <= 0 <= b:\n print('Zero')", "a > 0", "a", "0", "print('Positive')", "print", "'Positive'", "elif b < 0:\n if (b - a + 1) % 2 == 0:\n print('Positive')\n else:\n print('Negative')", "b < 0", "b", "0", "if (b - a + 1) % 2 == 0:\n print('Positive')\n else:\n print('Negative')", "(b - a + 1) % 2 == 0", "(b - a + 1) % 2", "b - a + 1", "b - a", "b", "a", "1", "2", "0", "print('Positive')", "print", "'Positive'", "print('Negative')", "print", "'Negative'", "elif a <= 0 <= b:\n print('Zero')", "a <= 0 <= b", "a <= 0", "a", "0", "b", "print('Zero')", "print", "'Zero'", "a, b = [int(s) for s in input().split()]", "[int(s) for s in input().split()]", "a", "b = [int(s) for s in input().split()]", "[int(s) for s in input().split()]", "b" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 14, 40, 40, 13, 17, 13, 4, 13, 17, 14, 40, 2, 17, 13, 13, 4, 13, 17, 14, 2, 2, 13, 17, 2, 17, 13, 14, 2, 2, 13, 17, 17, 4, 13, 17, 4, 13, 17, 14, 2, 2, 2, 13, 13, 17, 17, 4, 13, 17, 4, 13, 17, 10, 4, 13, 10, 4, 13 ]

[ [ 68, 2 ], [ 68, 11 ], [ 69, 15 ], [ 66, 17 ], [ 69, 25 ], [ 66, 26 ], [ 69, 33 ], [ 66, 37 ], [ 69, 41 ], [ 66, 54 ], [ 69, 55 ], [ 68, 66 ], [ 68, 69 ] ]

[ "a, b = map(int, input().split())\n\nif a <= 0 <= b:\n print(\"Zero\")\nelif 0 < a <= b:\n print(\"Positive\")\nelif a < 0 and 0 < b:\n if a % 2 == 0:\n print(\"Positive\")\n else:\n print(\"Negative\")\nelse:\n if (b - a) % 2 == 0:\n print(\"Negative\")\n else:\n print(\"Positive\")", "a, b = map(int, input().split())", "a", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "if a <= 0 <= b:\n print(\"Zero\")\nelif 0 < a <= b:\n print(\"Positive\")\nelif a < 0 and 0 < b:\n if a % 2 == 0:\n print(\"Positive\")\n else:\n print(\"Negative\")\nelse:\n if (b - a) % 2 == 0:\n print(\"Negative\")\n else:\n print(\"Positive\")", "a <= 0 <= b", "a <= 0", "a", "0", "b", "print(\"Zero\")", "print", "\"Zero\"", "elif 0 < a <= b:\n print(\"Positive\")", "0 < a <= b", "0 < a", "0", "a", "b", "print(\"Positive\")", "print", "\"Positive\"", "elif a < 0 and 0 < b:\n if a % 2 == 0:\n print(\"Positive\")\n else:\n print(\"Negative\")", "a < 0 and 0 < b", "a < 0", "a", "0", "0 < b", "0", "b", "if a % 2 == 0:\n print(\"Positive\")\n else:\n print(\"Negative\")", "a % 2 == 0", "a % 2", "a", "2", "0", "print(\"Positive\")", "print", "\"Positive\"", "print(\"Negative\")", "print", "\"Negative\"", "if (b - a) % 2 == 0:\n print(\"Negative\")\n else:\n print(\"Positive\")", "(b - a) % 2 == 0", "(b - a) % 2", "b - a", "b", "a", "2", "0", "print(\"Negative\")", "print", "\"Negative\"", "print(\"Positive\")", "print", "\"Positive\"", "b = map(int, input().split())", "map(int, input().split())", "b", "a, b = map(int, input().split())", "map(int, input().split())", "a" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 14, 2, 2, 40, 13, 17, 40, 13, 17, 2, 40, 13, 17, 40, 13, 17, 4, 13, 17, 14, 2, 13, 17, 4, 13, 17, 14, 2, 13, 17, 8, 2, 2, 2, 4, 13, 2, 13, 13, 17, 17, 17, 4, 13, 17, 4, 13, 17, 10, 4, 13, 10, 4, 13 ]

[ [ 64, 2 ], [ 64, 11 ], [ 62, 16 ], [ 65, 19 ], [ 62, 23 ], [ 65, 26 ], [ 62, 33 ], [ 65, 40 ], [ 65, 49 ], [ 62, 50 ], [ 64, 62 ], [ 64, 65 ] ]

[ "a, b = map(int, input().split())\nif (a <= 0 and b >= 0) or (a >= 0 and b <= 0):\n print(\"Zero\")\nelif a > 0:\n print(\"Positive\")\nelif b < 0:\n print(\"Negative\") if (abs(b-a)+1) % 2 == 1 else print(\"Positive\")", "a, b = map(int, input().split())", "a", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "if (a <= 0 and b >= 0) or (a >= 0 and b <= 0):\n print(\"Zero\")\nelif a > 0:\n print(\"Positive\")\nelif b < 0:\n print(\"Negative\") if (abs(b-a)+1) % 2 == 1 else print(\"Positive\")", "(a <= 0 and b >= 0) or (a >= 0 and b <= 0)", "a <= 0 and b >= 0", "a <= 0", "a", "0", "b >= 0", "b", "0", "a >= 0 and b <= 0", "a >= 0", "a", "0", "b <= 0", "b", "0", "print(\"Zero\")", "print", "\"Zero\"", "elif a > 0:\n print(\"Positive\")", "a > 0", "a", "0", "print(\"Positive\")", "print", "\"Positive\"", "elif b < 0:\n print(\"Negative\") if (abs(b-a)+1) % 2 == 1 else print(\"Positive\")", "b < 0", "b", "0", "print(\"Negative\") if (abs(b-a)+1) % 2 == 1 else print(\"Positive\")", "(abs(b-a)+1) % 2 == 1", "(abs(b-a)+1) % 2", "abs(b-a)+1", "abs(b-a)", "abs", "b-a", "b", "a", "1", "2", "1", "print(\"Negative\")", "print", "\"Negative\"", "print(\"Positive\")", "print", "\"Positive\"", "a, b = map(int, input().split())", "map(int, input().split())", "a", "b = map(int, input().split())", "map(int, input().split())", "b" ]

[ 7, 15, 13, 13, 13, 15, 15, 15, 15, 15, 15, 15, 12, 13, 12, 13, 12, 13, 12, 13, 12, 13, 12, 13, 4, 18, 13, 13, 2, 17, 17, 0, 13, 4, 13, 17, 0, 13, 2, 2, 17, 17, 17, 0, 13, 4, 13, 13, 41, 28, 13, 4, 13, 13, 4, 4, 13, 0, 13, 13, 0, 13, 2, 39, 17, 13, 0, 13, 2, 39, 17, 13, 0, 18, 13, 17, 17, 28, 13, 13, 13, 14, 2, 18, 13, 2, 13, 17, 17, 0, 18, 13, 2, 13, 17, 17, 9, 0, 18, 13, 2, 13, 17, 17, 0, 18, 13, 2, 13, 17, 17, 0, 18, 13, 2, 13, 17, 2, 18, 13, 2, 13, 17, 18, 13, 2, 13, 17, 14, 2, 18, 13, 2, 13, 17, 17, 0, 18, 13, 2, 13, 17, 17, 4, 13, 4, 13, 13, 10, 12, 13, 10, 4, 13, 10, 4, 13, 10, 13, 13, 10, 12, 13, 10, 2, 13, 10, 12, 13, 10, 4, 13, 10, 12, 13, 10, 2, 13, 10, 2, 13, 10, 12, 13, 10, 12, 13 ]

[ [ 170, 32 ], [ 164, 37 ], [ 155, 44 ], [ 150, 46 ], [ 155, 47 ], [ 51, 50 ], [ 156, 53 ], [ 186, 56 ], [ 158, 58 ], [ 176, 61 ], [ 153, 65 ], [ 179, 67 ], [ 153, 71 ], [ 76, 73 ], [ 180, 74 ], [ 177, 84 ], [ 95, 90 ], [ 180, 91 ], [ 103, 98 ], [ 177, 99 ], [ 110, 105 ], [ 177, 106 ], [ 117, 112 ], [ 180, 113 ], [ 180, 119 ], [ 180, 124 ], [ 177, 131 ], [ 142, 137 ], [ 180, 138 ], [ 180, 147 ], [ 155, 153 ], [ 155, 156 ], [ 158, 159 ], [ 164, 165 ], [ 170, 171 ], [ 176, 177 ], [ 179, 180 ] ]

[ "import sys, re, os\nfrom collections import deque, defaultdict, Counter\nfrom math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians\nfrom itertools import permutations, combinations, product, accumulate\nfrom operator import itemgetter, mul\nfrom copy import deepcopy\nfrom string import ascii_lowercase, ascii_uppercase, digits\nfrom heapq import heapify, heappop, heappush\n \ndef input(): return sys.stdin.readline().strip()\ndef INT(): return int(input())\ndef MAP(): return map(int, input().split())\ndef S_MAP(): return map(str, input().split())\ndef LIST(): return list(map(int, input().split()))\ndef S_LIST(): return list(map(str, input().split()))\n \nsys.setrecursionlimit(10 ** 9)\nINF = float('inf')\nmod = 10 ** 9 + 7\n\nN, M = MAP()\nL = [LIST() for i in range(M)]\n\nnum = [1] * N\nred = [False] * N\nred[0] = True\n\nfor a, b in L:\n if num[a-1] == 0:\n # 水がない\n red[a-1] = False\n continue\n else:\n num[b-1] += 1\n num[a-1] -= 1\n red[b-1] = red[b-1] or red[a-1]\n if num[a-1] == 0:\n red[a-1] = False\n \nprint(sum(red))\n# print(sum(num))\n", "import sys, re, os", "sys", "re", "os", "from collections import deque, defaultdict, Counter", "from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians", "from itertools import permutations, combinations, product, accumulate", "from operator import itemgetter, mul", "from copy import deepcopy", "from string import ascii_lowercase, ascii_uppercase, digits", "from heapq import heapify, heappop, heappush", "def input(): return sys.stdin.readline().strip()", "input", "def INT(): return int(input())", "INT", "def MAP(): return map(int, input().split())", "MAP", "def S_MAP(): return map(str, input().split())", "S_MAP", "def LIST(): return list(map(int, input().split()))", "LIST", "def S_LIST(): return list(map(str, input().split()))\n ", "S_LIST", "sys.setrecursionlimit(10 ** 9)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "10 ** 9", "10", "9", "INF = float('inf')", "INF", "float('inf')", "float", "'inf'", "mod = 10 ** 9 + 7", "mod", "10 ** 9 + 7", "10 ** 9", "10", "9", "7", "N, M = MAP()", "N", "MAP()", "MAP", "M", "LIST() for i in range(M)", "for i in range(M)", "i", "range(M)", "range", "M", "for i in range(M)", "LIST()", "LIST", "L = [LIST() for i in range(M)]", "L", "[LIST() for i in range(M)]", "num = [1] * N", "num", "[1] * N", "[1]", "1", "N", "red = [False] * N", "red", "[False] * N", "[False]", "False", "N", "red[0] = True", "red[0]", "red", "0", "True", "for a, b in L:\n if num[a-1] == 0:\n # 水がない\n red[a-1] = False\n continue\n else:\n num[b-1] += 1\n num[a-1] -= 1\n red[b-1] = red[b-1] or red[a-1]\n if num[a-1] == 0:\n red[a-1] = False\n ", "a", "b", "L", "if num[a-1] == 0:\n # 水がない\n red[a-1] = False\n continue\n else:\n num[b-1] += 1\n num[a-1] -= 1\n red[b-1] = red[b-1] or red[a-1]\n if num[a-1] == 0:\n red[a-1] = False\n ", "num[a-1] == 0", "num[a-1]", "num", "a-1", "a", "1", "0", "red[a-1] = False", "red[a-1]", "red", "a-1", "a", "1", "False", "continue", "num[b-1] += 1", "num[b-1]", "num", "b-1", "b", "1", "1", "num[a-1] -= 1", "num[a-1]", "num", "a-1", "a", "1", "1", "red[b-1] = red[b-1] or red[a-1]", "red[b-1]", "red", "b-1", "b", "1", "red[b-1] or red[a-1]", "red[b-1]", "red", "b-1", "b", "1", "red[a-1]", "red", "a-1", "a", "1", "if num[a-1] == 0:\n red[a-1] = False\n ", "num[a-1] == 0", "num[a-1]", "num", "a-1", "a", "1", "0", "red[a-1] = False", "red[a-1]", "red", "a-1", "a", "1", "False", "print(sum(red))", "print", "sum(red)", "sum", "red", "def MAP(): return map(int, input().split())", "def MAP(): return map(int, input().split())", "MAP", "N, M = MAP()", "MAP()", "N", "M = MAP()", "MAP()", "M", "L = [LIST() for i in range(M)]", "[LIST() for i in range(M)]", "L", "def INT(): return int(input())", "def INT(): return int(input())", "INT", "mod = 10 ** 9 + 7", "10 ** 9 + 7", "mod", "def S_LIST(): return list(map(str, input().split()))\n ", "def S_LIST(): return list(map(str, input().split()))\n ", "S_LIST", "INF = float('inf')", "float('inf')", "INF", "def S_MAP(): return map(str, input().split())", "def S_MAP(): return map(str, input().split())", "S_MAP", "num = [1] * N", "[1] * N", "num", "red = [False] * N", "[False] * N", "red", "def input(): return sys.stdin.readline().strip()", "def input(): return sys.stdin.readline().strip()", "input", "def LIST(): return list(map(int, input().split()))", "def LIST(): return list(map(int, input().split()))", "LIST" ]

[ 7, 12, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 2, 39, 17, 2, 39, 17, 13, 0, 13, 2, 39, 17, 2, 13, 17, 0, 18, 13, 17, 17, 28, 13, 4, 13, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 18, 13, 13, 17, 0, 18, 13, 13, 17, 14, 18, 13, 13, 0, 18, 13, 13, 17, 14, 2, 18, 13, 13, 17, 0, 18, 13, 13, 17, 0, 13, 17, 28, 13, 13, 14, 13, 0, 13, 17, 4, 13, 13, 14, 2, 13, 17, 4, 13, 10, 12, 13 ]

[ [ 5, 4 ], [ 5, 13 ], [ 16, 15 ], [ 4, 22 ], [ 25, 24 ], [ 4, 29 ], [ 35, 32 ], [ 24, 33 ], [ 38, 37 ], [ 13, 40 ], [ 43, 42 ], [ 43, 51 ], [ 56, 53 ], [ 15, 54 ], [ 42, 55 ], [ 61, 58 ], [ 15, 59 ], [ 51, 60 ], [ 24, 64 ], [ 42, 65 ], [ 70, 67 ], [ 24, 68 ], [ 51, 69 ], [ 53, 73 ], [ 15, 74 ], [ 42, 75 ], [ 81, 78 ], [ 24, 79 ], [ 42, 80 ], [ 84, 83 ], [ 87, 86 ], [ 24, 86 ], [ 92, 91 ], [ 91, 95 ], [ 83, 95 ], [ 104, 101 ] ]

[ "def main():\n N,M = map(int,(input().split()))\n BOX = [0]+[1]*N\n RED = [False]*(N+1)\n RED[1] = True\n\n for _ in range(M):\n x,y = map(int,(input().split()))\n BOX[x] -=1\n BOX[y] +=1\n if RED[x]:\n RED[y]=True\n if BOX[x]==0:\n RED[x]=False\n cnt = 0\n for r in RED:\n if r:\n cnt +=1\n print(cnt)\n\n\n\nif __name__ == '__main__':\n main()", "def main():\n N,M = map(int,(input().split()))\n BOX = [0]+[1]*N\n RED = [False]*(N+1)\n RED[1] = True\n\n for _ in range(M):\n x,y = map(int,(input().split()))\n BOX[x] -=1\n BOX[y] +=1\n if RED[x]:\n RED[y]=True\n if BOX[x]==0:\n RED[x]=False\n cnt = 0\n for r in RED:\n if r:\n cnt +=1\n print(cnt)", "main", "N,M = map(int,(input().split()))", "N", "map(int,(input().split()))", "map", "int", "input().split()", "().split", "()", "input", "split", "M", "BOX = [0]+[1]*N", "BOX", "[0]+[1]*N", "[0]", "0", "[1]*N", "[1]", "1", "N", "RED = [False]*(N+1)", "RED", "[False]*(N+1)", "[False]", "False", "N+1", "N", "1", "RED[1] = True", "RED[1]", "RED", "1", "True", "for _ in range(M):\n x,y = map(int,(input().split()))\n BOX[x] -=1\n BOX[y] +=1\n if RED[x]:\n RED[y]=True\n if BOX[x]==0:\n RED[x]=False\n ", "_", "range(M)", "range", "M", "x,y = map(int,(input().split()))", "x", "map(int,(input().split()))", "map", "int", "input().split()", "().split", "()", "input", "split", "y", "BOX[x] -=1", "BOX[x]", "BOX", "x", "1", "BOX[y] +=1", "BOX[y]", "BOX", "y", "1", "if RED[x]:\n RED[y]=True\n ", "RED[x]", "RED", "x", "RED[y]=True", "RED[y]", "RED", "y", "True", "if BOX[x]==0:\n RED[x]=False\n ", "BOX[x]==0", "BOX[x]", "BOX", "x", "0", "RED[x]=False", "RED[x]", "RED", "x", "False", "cnt = 0", "cnt", "0", "for r in RED:\n if r:\n cnt +=1\n ", "r", "RED", "if r:\n cnt +=1\n ", "r", "cnt +=1", "cnt", "1", "print(cnt)", "print", "cnt", "if __name__ == '__main__':\n main()", "__name__ == '__main__'", "__name__", "'__main__'", "main()", "main", "def main():\n N,M = map(int,(input().split()))\n BOX = [0]+[1]*N\n RED = [False]*(N+1)\n RED[1] = True\n\n for _ in range(M):\n x,y = map(int,(input().split()))\n BOX[x] -=1\n BOX[y] +=1\n if RED[x]:\n RED[y]=True\n if BOX[x]==0:\n RED[x]=False\n cnt = 0\n for r in RED:\n if r:\n cnt +=1\n print(cnt)", "def main():\n N,M = map(int,(input().split()))\n BOX = [0]+[1]*N\n RED = [False]*(N+1)\n RED[1] = True\n\n for _ in range(M):\n x,y = map(int,(input().split()))\n BOX[x] -=1\n BOX[y] +=1\n if RED[x]:\n RED[y]=True\n if BOX[x]==0:\n RED[x]=False\n cnt = 0\n for r in RED:\n if r:\n cnt +=1\n print(cnt)", "main" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 2, 39, 17, 13, 0, 13, 4, 13, 4, 18, 13, 13, 17, 28, 13, 4, 13, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 18, 13, 2, 13, 17, 17, 0, 18, 13, 2, 13, 17, 17, 14, 2, 13, 13, 4, 18, 13, 13, 13, 14, 2, 18, 13, 2, 13, 17, 17, 4, 18, 13, 13, 13, 0, 13, 17, 28, 13, 13, 14, 40, 18, 13, 2, 13, 17, 17, 4, 13, 13, 10, 4, 13, 10, 4, 13, 10, 2, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 17, 13 ]

[ [ 112, 2 ], [ 112, 11 ], [ 103, 13 ], [ 98, 17 ], [ 106, 19 ], [ 107, 24 ], [ 29, 28 ], [ 113, 31 ], [ 109, 33 ], [ 109, 42 ], [ 49, 44 ], [ 104, 45 ], [ 110, 47 ], [ 56, 51 ], [ 104, 52 ], [ 101, 54 ], [ 110, 59 ], [ 107, 60 ], [ 107, 63 ], [ 101, 65 ], [ 104, 69 ], [ 110, 71 ], [ 107, 76 ], [ 110, 78 ], [ 115, 80 ], [ 84, 83 ], [ 107, 83 ], [ 104, 88 ], [ 83, 90 ], [ 116, 95 ], [ 112, 98 ], [ 109, 101 ], [ 103, 104 ], [ 106, 107 ], [ 109, 110 ], [ 112, 113 ], [ 115, 116 ] ]

[ "n,m = map(int,input().split())\nl = [1] * n\nd = set()\nd.add(1)\n\nfor i in range(m):\n x,y = map(int,input().split())\n l[x-1] -= 1\n l[y-1] += 1\n if(x in d):\n d.add(y)\n if(l[x-1] == 0):\n d.remove(x)\n\ns = 0\nfor i in d:\n if(l[i-1] != 0):s += 1\nprint(s)", "n,m = map(int,input().split())", "n", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "m", "l = [1] * n", "l", "[1] * n", "[1]", "1", "n", "d = set()", "d", "set()", "set", "d.add(1)", "d.add", "d", "add", "1", "for i in range(m):\n x,y = map(int,input().split())\n l[x-1] -= 1\n l[y-1] += 1\n if(x in d):\n d.add(y)\n if(l[x-1] == 0):\n d.remove(x)", "i", "range(m)", "range", "m", "x,y = map(int,input().split())", "x", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "y", "l[x-1] -= 1", "l[x-1]", "l", "x-1", "x", "1", "1", "l[y-1] += 1", "l[y-1]", "l", "y-1", "y", "1", "1", "if(x in d):\n d.add(y)\n if(l[x-1] == 0):\n d.remove(x)", "x in d", "x", "d", "d.add(y)", "d.add", "d", "add", "y", "if(l[x-1] == 0):\n d.remove(x)", "l[x-1] == 0", "l[x-1]", "l", "x-1", "x", "1", "0", "d.remove(x)", "d.remove", "d", "remove", "x", "s = 0", "s", "0", "for i in d:\n if(l[i-1] != 0):s += 1", "i", "d", "if(l[i-1] != 0):s ", "l[i-1] != 0", "l[i-1]", "l", "i-1", "i", "1", "0", "print(s)", "print", "s", "n,m = map(int,input().split())", "map(int,input().split())", "n", "y = map(int,input().split())", "map(int,input().split())", "y", "l = [1] * n", "[1] * n", "l", "d = set()", "set()", "d", "x,y = map(int,input().split())", "map(int,input().split())", "x", "m = map(int,input().split())", "map(int,input().split())", "m", "s = 0", "0", "s" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 17, 0, 18, 13, 17, 17, 0, 13, 2, 39, 17, 2, 13, 17, 0, 13, 17, 28, 13, 4, 13, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 14, 2, 13, 13, 0, 18, 13, 13, 17, 0, 18, 13, 13, 17, 0, 18, 13, 13, 17, 0, 18, 13, 13, 17, 0, 18, 13, 13, 17, 14, 2, 18, 13, 13, 17, 14, 2, 13, 13, 24, 18, 13, 13, 28, 13, 4, 13, 17, 2, 13, 17, 14, 2, 18, 13, 13, 17, 9, 14, 2, 13, 13, 0, 13, 17, 4, 13, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 17, 13, 10, 2, 13, 10, 4, 13, 10, 17, 13, 10, 17, 13 ]

[ [ 122, 2 ], [ 122, 11 ], [ 125, 13 ], [ 19, 16 ], [ 126, 17 ], [ 128, 21 ], [ 120, 26 ], [ 137, 29 ], [ 33, 32 ], [ 123, 35 ], [ 131, 37 ], [ 131, 46 ], [ 117, 49 ], [ 126, 50 ], [ 55, 52 ], [ 126, 53 ], [ 132, 54 ], [ 60, 57 ], [ 129, 58 ], [ 117, 59 ], [ 65, 62 ], [ 129, 63 ], [ 132, 64 ], [ 70, 67 ], [ 129, 68 ], [ 117, 69 ], [ 75, 72 ], [ 129, 73 ], [ 132, 74 ], [ 67, 78 ], [ 57, 78 ], [ 129, 79 ], [ 117, 80 ], [ 117, 84 ], [ 126, 85 ], [ 126, 88 ], [ 117, 89 ], [ 92, 91 ], [ 120, 96 ], [ 129, 101 ], [ 91, 102 ], [ 91, 107 ], [ 126, 108 ], [ 134, 110 ], [ 135, 114 ], [ 138, 114 ], [ 131, 117 ], [ 122, 120 ], [ 122, 123 ], [ 125, 126 ], [ 128, 129 ], [ 131, 132 ], [ 134, 135 ], [ 137, 138 ] ]

[ "N, M = map(int, input().split())\nkouho = {}\nkouho[1]=True\nNlist = [1]*(N+1)\nans = 0\nfor i in range(M):\n x, y = map(int, input().split())\n if x in kouho:\n kouho[y] = True\n Nlist[x] -= 1\n Nlist[y] += 1\n else:\n Nlist[x] -= 1\n Nlist[y] += 1\n if Nlist[x]==0:\n if x in kouho:\n del kouho[x]\n\nfor i in range(1, N+1):\n if Nlist[i] == 0:\n continue\n if i in kouho:\n ans += 1\n\nprint(ans)", "N, M = map(int, input().split())", "N", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "M", "kouho = {}", "kouho", "{}", "kouho[1]=True", "kouho[1]", "kouho", "1", "True", "Nlist = [1]*(N+1)", "Nlist", "[1]*(N+1)", "[1]", "1", "N+1", "N", "1", "ans = 0", "ans", "0", "for i in range(M):\n x, y = map(int, input().split())\n if x in kouho:\n kouho[y] = True\n Nlist[x] -= 1\n Nlist[y] += 1\n else:\n Nlist[x] -= 1\n Nlist[y] += 1\n if Nlist[x]==0:\n if x in kouho:\n del kouho[x]", "i", "range(M)", "range", "M", "x, y = map(int, input().split())", "x", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "y", "if x in kouho:\n kouho[y] = True\n Nlist[x] -= 1\n Nlist[y] += 1\n else:\n Nlist[x] -= 1\n Nlist[y] += 1\n ", "x in kouho", "x", "kouho", "kouho[y] = True", "kouho[y]", "kouho", "y", "True", "Nlist[x] -= 1", "Nlist[x]", "Nlist", "x", "1", "Nlist[y] += 1", "Nlist[y]", "Nlist", "y", "1", "Nlist[x] -= 1", "Nlist[x]", "Nlist", "x", "1", "Nlist[y] += 1", "Nlist[y]", "Nlist", "y", "1", "if Nlist[x]==0:\n if x in kouho:\n del kouho[x]", "Nlist[x]==0", "Nlist[x]", "Nlist", "x", "0", "if x in kouho:\n del kouho[x]", "x in kouho", "x", "kouho", "del kouho[x]", "kouho[x]", "kouho", "x", "for i in range(1, N+1):\n if Nlist[i] == 0:\n continue\n if i in kouho:\n ans += 1", "i", "range(1, N+1)", "range", "1", "N+1", "N", "1", "if Nlist[i] == 0:\n continue\n ", "Nlist[i] == 0", "Nlist[i]", "Nlist", "i", "0", "continue", "if i in kouho:\n ans += 1", "i in kouho", "i", "kouho", "ans += 1", "ans", "1", "print(ans)", "print", "ans", "x, y = map(int, input().split())", "map(int, input().split())", "x", "N, M = map(int, input().split())", "map(int, input().split())", "N", "M = map(int, input().split())", "map(int, input().split())", "M", "kouho = {}", "{}", "kouho", "Nlist = [1]*(N+1)", "[1]*(N+1)", "Nlist", "y = map(int, input().split())", "map(int, input().split())", "y", "ans += 1", "1", "ans", "ans = 0", "0", "ans" ]

[ 7, 15, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 4, 18, 13, 13, 2, 39, 17, 13, 0, 13, 4, 18, 13, 13, 2, 39, 17, 13, 0, 18, 13, 17, 17, 28, 13, 4, 13, 13, 0, 13, 4, 13, 12, 2, 4, 13, 13, 17, 23, 4, 18, 4, 13, 13, 13, 0, 18, 13, 13, 17, 0, 18, 13, 13, 17, 14, 18, 13, 13, 0, 18, 13, 13, 17, 14, 2, 18, 13, 13, 17, 0, 18, 13, 13, 17, 0, 13, 4, 18, 13, 13, 2, 13, 17, 17, 17, 4, 13, 4, 13, 2, 13, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 122, 4 ], [ 122, 13 ], [ 125, 15 ], [ 120, 23 ], [ 110, 25 ], [ 120, 33 ], [ 38, 35 ], [ 111, 36 ], [ 41, 40 ], [ 123, 43 ], [ 128, 45 ], [ 128, 60 ], [ 65, 62 ], [ 126, 63 ], [ 129, 64 ], [ 70, 67 ], [ 126, 68 ], [ 114, 69 ], [ 111, 73 ], [ 129, 74 ], [ 79, 76 ], [ 111, 77 ], [ 114, 78 ], [ 62, 82 ], [ 126, 83 ], [ 129, 84 ], [ 90, 87 ], [ 111, 88 ], [ 129, 89 ], [ 116, 92 ], [ 126, 98 ], [ 111, 107 ], [ 117, 108 ], [ 126, 108 ], [ 110, 111 ], [ 128, 114 ], [ 116, 117 ], [ 122, 120 ], [ 122, 123 ], [ 125, 126 ], [ 128, 129 ] ]

[ "import numpy as np\n\nN, M = map(int,input().split())\n\nbox = np.array([1]*N)#個数\npos = np.array([0]*N)#ありえるか\npos[0] = 1\n\nfor i in range(M):\n x, y = map(lambda x:int(x)-1,input().split())\n box[x] -= 1\n box[y] += 1\n if pos[x]:\n pos[y] = 1\n if box[x] == 0:\n pos[x] = 0\n\n#print(box)\n#print(pos)\n\nbox = np.where(box > 0, 1, 0)\nprint(sum(pos*box))", "import numpy as np", "numpy", "N, M = map(int,input().split())", "N", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "M", "box = np.array([1]*N)", "box", "np.array([1]*N)", "np.array", "np", "array", "[1]*N", "[1]", "1", "N", "pos = np.array([0]*N)", "pos", "np.array([0]*N)", "np.array", "np", "array", "[0]*N", "[0]", "0", "N", "pos[0] = 1", "pos[0]", "pos", "0", "1", "for i in range(M):\n x, y = map(lambda x:int(x)-1,input().split())\n box[x] -= 1\n box[y] += 1\n if pos[x]:\n pos[y] = 1\n if box[x] == 0:\n pos[x] = 0\n\n#print(box)\n#print(pos)", "i", "range(M)", "range", "M", "x, y = map(lambda x:int(x)-1,input().split())", "x", "map(lambda x:int(x)-1,input().split())", "map", "lambda x:int(x)-1", "int(x)-1", "int(x)", "int", "x", "1", "x", "input().split()", "().split", "()", "input", "split", "y", "box[x] -= 1", "box[x]", "box", "x", "1", "box[y] += 1", "box[y]", "box", "y", "1", "if pos[x]:\n pos[y] = 1\n if box[x] == 0:\n pos[x] = 0\n\n#print(box)\n#print(pos)", "pos[x]", "pos", "x", "pos[y] = 1", "pos[y]", "pos", "y", "1", "if box[x] == 0:\n pos[x] = 0\n\n#print(box)\n#print(pos)", "box[x] == 0", "box[x]", "box", "x", "0", "pos[x] = 0", "pos[x]", "pos", "x", "0", "box = np.where(box > 0, 1, 0)", "box", "np.where(box > 0, 1, 0)", "np.where", "np", "where", "box > 0", "box", "0", "1", "0", "print(sum(pos*box))", "print", "sum(pos*box)", "sum", "pos*box", "pos", "box", "pos = np.array([0]*N)", "np.array([0]*N)", "pos", "y = map(lambda x:int(x)-1,input().split())", "map(lambda x:int(x)-1,input().split())", "y", "box = np.where(box > 0, 1, 0)", "np.where(box > 0, 1, 0)", "box", "N, M = map(int,input().split())", "map(int,input().split())", "N", "M = map(int,input().split())", "map(int,input().split())", "M", "box = np.array([1]*N)", "np.array([1]*N)", "box", "x, y = map(lambda x:int(x)-1,input().split())", "map(lambda x:int(x)-1,input().split())", "x" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 41, 28, 13, 4, 13, 13, 4, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 0, 13, 13, 41, 28, 13, 4, 13, 2, 13, 17, 4, 39, 17, 17, 0, 13, 13, 0, 18, 18, 13, 17, 17, 17, 28, 13, 13, 13, 0, 18, 18, 13, 13, 17, 17, 0, 18, 18, 13, 13, 17, 17, 14, 2, 18, 18, 13, 13, 17, 17, 0, 18, 18, 13, 13, 17, 17, 14, 2, 18, 18, 13, 13, 17, 17, 0, 18, 18, 13, 13, 17, 17, 4, 13, 4, 13, 18, 13, 17, 10, 4, 13, 10, 4, 13, 10, 13, 13, 10, 13, 13 ]

[ [ 113, 2 ], [ 113, 11 ], [ 15, 14 ], [ 111, 17 ], [ 119, 30 ], [ 35, 34 ], [ 114, 38 ], [ 116, 45 ], [ 53, 48 ], [ 117, 50 ], [ 64, 59 ], [ 117, 61 ], [ 71, 66 ], [ 117, 68 ], [ 117, 76 ], [ 86, 81 ], [ 117, 83 ], [ 117, 91 ], [ 101, 96 ], [ 117, 98 ], [ 113, 111 ], [ 113, 114 ], [ 116, 117 ], [ 119, 120 ] ]

[ "# B - Box and Ball\nN,M = map(int,input().split())\nmove = [list(map(int,input().split())) for _ in range(M)]\nbox = [[1,0] for _ in range(N+1)]\nbox[1][1] = 1\nfor x,y in move:\n box[x][0] -= 1\n box[y][0] += 1\n if box[x][1]==1:\n box[y][1] = 1\n if box[x][0]==0:\n box[x][1] = 0\nprint(sum(b[1] for b in box))", "N,M = map(int,input().split())", "N", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "M", "list(map(int,input().split())) for _ in range(M)", "for _ in range(M)", "_", "range(M)", "range", "M", "for _ in range(M)", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "move = [list(map(int,input().split())) for _ in range(M)]", "move", "[list(map(int,input().split())) for _ in range(M)]", "[1,0] for _ in range(N+1)", "for _ in range(N+1)", "_", "range(N+1)", "range", "N+1", "N", "1", "for _ in range(N+1)", "[1,0]", "1", "0", "box = [[1,0] for _ in range(N+1)]", "box", "[[1,0] for _ in range(N+1)]", "box[1][1] = 1", "box[1][1]", "[1]", "box", "1", "1", "1", "for x,y in move:\n box[x][0] -= 1\n box[y][0] += 1\n if box[x][1]==1:\n box[y][1] = 1\n if box[x][0]==0:\n box[x][1] = 0", "x", "y", "move", "box[x][0] -= 1", "box[x][0]", "[x]", "box", "x", "0", "1", "box[y][0] += 1", "box[y][0]", "[y]", "box", "y", "0", "1", "if box[x][1]==1:\n box[y][1] = 1\n if box[x][0]==0:\n box[x][1] = 0", "box[x][1]==1", "box[x][1]", "[x]", "box", "x", "1", "1", "box[y][1] = 1", "box[y][1]", "[y]", "box", "y", "1", "1", "if box[x][0]==0:\n box[x][1] = 0", "box[x][0]==0", "box[x][0]", "[x]", "box", "x", "0", "0", "box[x][1] = 0", "box[x][1]", "[x]", "box", "x", "1", "0", "print(sum(b[1] for b in box))", "print", "sum(b[1] for b in box)", "sum", "b[1]", "b", "1", "M = map(int,input().split())", "map(int,input().split())", "M", "N,M = map(int,input().split())", "map(int,input().split())", "N", "box = [[1,0] for _ in range(N+1)]", "[[1,0] for _ in range(N+1)]", "box", "move = [list(map(int,input().split())) for _ in range(M)]", "[list(map(int,input().split())) for _ in range(M)]", "move" ]

[ 7, 41, 28, 13, 4, 18, 4, 13, 13, 4, 4, 13, 13, 0, 13, 13, 13, 0, 13, 2, 39, 17, 13, 0, 13, 2, 39, 17, 13, 0, 18, 13, 17, 17, 28, 13, 4, 13, 13, 41, 28, 13, 4, 18, 4, 13, 13, 4, 4, 13, 13, 0, 13, 13, 13, 14, 2, 18, 13, 2, 13, 17, 17, 14, 2, 18, 13, 2, 13, 17, 17, 0, 18, 13, 2, 13, 17, 17, 0, 18, 13, 2, 13, 17, 17, 4, 13, 4, 18, 13, 13, 17, 10, 13, 13, 10, 13, 13, 10, 13, 13, 10, 2, 13, 10, 13, 13, 10, 2, 13 ]

[ [ 4, 3 ], [ 3, 12 ], [ 99, 14 ], [ 99, 16 ], [ 102, 18 ], [ 94, 22 ], [ 108, 24 ], [ 94, 28 ], [ 33, 30 ], [ 103, 31 ], [ 36, 35 ], [ 100, 38 ], [ 42, 41 ], [ 41, 50 ], [ 105, 52 ], [ 105, 54 ], [ 103, 58 ], [ 97, 60 ], [ 109, 66 ], [ 97, 68 ], [ 77, 72 ], [ 109, 73 ], [ 97, 75 ], [ 84, 79 ], [ 109, 80 ], [ 106, 82 ], [ 103, 89 ], [ 99, 94 ], [ 105, 97 ], [ 99, 100 ], [ 102, 103 ], [ 105, 106 ], [ 108, 109 ] ]

[ "n, m = [int(i) for i in input().split()]\ndata = [0] * n\ncnt = [1] * n\ndata[0] = 1\nfor i in range(m):\n x, y = [int(i) for i in input().split()]\n if data[x-1] == 1: data[y-1] = 1\n if cnt[x-1] == 1: data[x-1] = 0\n cnt[x-1] -= 1\n cnt[y-1] += 1\nprint(data.count(1))", "int(i) for i in input().split()", "for i in input().split()", "i", "input().split()", "().split", "()", "input", "split", "for i in input().split()", "int(i)", "int", "i", "n, m = [int(i) for i in input().split()]", "n", "[int(i) for i in input().split()]", "m", "data = [0] * n", "data", "[0] * n", "[0]", "0", "n", "cnt = [1] * n", "cnt", "[1] * n", "[1]", "1", "n", "data[0] = 1", "data[0]", "data", "0", "1", "for i in range(m):\n x, y = [int(i) for i in input().split()]\n if data[x-1] == 1: data[y-1] = 1\n if cnt[x-1] == 1: data[x-1] = 0\n cnt[x-1] -= 1\n cnt[y-1] += 1", "i", "range(m)", "range", "m", "int(i) for i in input().split()", "for i in input().split()", "i", "input().split()", "().split", "()", "input", "split", "for i in input().split()", "int(i)", "int", "i", "x, y = [int(i) for i in input().split()]", "x", "[int(i) for i in input().split()]", "y", "if data[x-1] == 1: data[y-1] = 1\n ", "data[x-1] == 1", "data[x-1]", "data", "x-1", "x", "1", "1", "if cnt[x-1] == 1: data[x-1] = 0\n ", "cnt[x-1] == 1", "cnt[x-1]", "cnt", "x-1", "x", "1", "1", "cnt[x-1] -= 1", "cnt[x-1]", "cnt", "x-1", "x", "1", "1", "cnt[y-1] += 1", "cnt[y-1]", "cnt", "y-1", "y", "1", "1", "print(data.count(1))", "print", "data.count(1)", "data.count", "data", "count", "1", "n, m = [int(i) for i in input().split()]", "[int(i) for i in input().split()]", "n", "x, y = [int(i) for i in input().split()]", "[int(i) for i in input().split()]", "x", "m = [int(i) for i in input().split()]", "[int(i) for i in input().split()]", "m", "data = [0] * n", "[0] * n", "data", "y = [int(i) for i in input().split()]", "[int(i) for i in input().split()]", "y", "cnt = [1] * n", "[1] * n", "cnt" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 41, 28, 13, 4, 13, 13, 4, 17, 0, 13, 13, 41, 28, 13, 4, 13, 13, 4, 17, 0, 13, 13, 0, 18, 13, 17, 17, 28, 13, 4, 13, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 17, 0, 13, 17, 14, 2, 18, 13, 13, 40, 18, 13, 13, 17, 0, 18, 13, 13, 17, 0, 18, 13, 13, 17, 0, 18, 13, 13, 17, 14, 40, 18, 13, 13, 17, 0, 18, 13, 13, 17, 14, 18, 13, 13, 0, 18, 13, 13, 17, 0, 18, 13, 13, 17, 4, 13, 4, 18, 13, 13, 17, 10, 17, 13, 10, 4, 13, 10, 17, 13, 10, 4, 13, 10, 13, 13, 10, 4, 13, 10, 13, 13, 10, 4, 13 ]

[ [ 128, 2 ], [ 128, 11 ], [ 15, 14 ], [ 123, 17 ], [ 131, 21 ], [ 26, 25 ], [ 123, 28 ], [ 137, 32 ], [ 38, 35 ], [ 138, 36 ], [ 41, 40 ], [ 129, 43 ], [ 140, 45 ], [ 140, 54 ], [ 119, 56 ], [ 125, 59 ], [ 93, 63 ], [ 138, 64 ], [ 120, 65 ], [ 135, 65 ], [ 102, 67 ], [ 77, 67 ], [ 132, 68 ], [ 120, 69 ], [ 135, 69 ], [ 75, 72 ], [ 138, 73 ], [ 126, 74 ], [ 141, 74 ], [ 80, 77 ], [ 132, 78 ], [ 120, 79 ], [ 135, 79 ], [ 85, 82 ], [ 132, 83 ], [ 126, 84 ], [ 141, 84 ], [ 77, 88 ], [ 102, 88 ], [ 132, 89 ], [ 120, 90 ], [ 135, 90 ], [ 96, 93 ], [ 138, 94 ], [ 120, 95 ], [ 135, 95 ], [ 132, 99 ], [ 120, 100 ], [ 135, 100 ], [ 105, 102 ], [ 132, 103 ], [ 120, 104 ], [ 135, 104 ], [ 110, 107 ], [ 132, 108 ], [ 126, 109 ], [ 141, 109 ], [ 138, 115 ], [ 119, 120 ], [ 128, 123 ], [ 125, 126 ], [ 128, 129 ], [ 131, 132 ], [ 140, 135 ], [ 137, 138 ], [ 140, 141 ] ]

[ "N, M = map(int, input().split())\n\nnum = [1 for i in range(N)]\nred = [False for i in range(N)]\nred[0] = True\n\nfor i in range(M):\n x, y = map(int, input().split()) \n x -= 1\n y -= 1\n \n if(red[x] and num[x] >= 1):\n red[y] = True\n num[x] -= 1\n num[y] += 1\n if(num[x] <= 0):\n red[x] = False\n else:\n if(num[x]):\n num[x] -= 1\n num[y] += 1\n\nprint(red.count(True)) ", "N, M = map(int, input().split())", "N", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "M", "1 for i in range(N)", "for i in range(N)", "i", "range(N)", "range", "N", "for i in range(N)", "1", "num = [1 for i in range(N)]", "num", "[1 for i in range(N)]", "False for i in range(N)", "for i in range(N)", "i", "range(N)", "range", "N", "for i in range(N)", "False", "red = [False for i in range(N)]", "red", "[False for i in range(N)]", "red[0] = True", "red[0]", "red", "0", "True", "for i in range(M):\n x, y = map(int, input().split()) \n x -= 1\n y -= 1\n \n if(red[x] and num[x] >= 1):\n red[y] = True\n num[x] -= 1\n num[y] += 1\n if(num[x] <= 0):\n red[x] = False\n else:\n if(num[x]):\n num[x] -= 1\n num[y] += 1", "i", "range(M)", "range", "M", "x, y = map(int, input().split())", "x", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "y", "x -= 1", "x", "1", "y -= 1", "y", "1", "if(red[x] and num[x] >= 1):\n red[y] = True\n num[x] -= 1\n num[y] += 1\n if(num[x] <= 0):\n red[x] = False\n else:\n if(num[x]):\n num[x] -= 1\n num[y] += 1", "red[x] and num[x] >= 1", "red[x]", "red", "x", "num[x] >= 1", "num[x]", "num", "x", "1", "red[y] = True", "red[y]", "red", "y", "True", "num[x] -= 1", "num[x]", "num", "x", "1", "num[y] += 1", "num[y]", "num", "y", "1", "if(num[x] <= 0):\n red[x] = False\n ", "num[x] <= 0", "num[x]", "num", "x", "0", "red[x] = False", "red[x]", "red", "x", "False", "if(num[x]):\n num[x] -= 1\n num[y] += 1", "num[x]", "num", "x", "num[x] -= 1", "num[x]", "num", "x", "1", "num[y] += 1", "num[y]", "num", "y", "1", "print(red.count(True))", "print", "red.count(True)", "red.count", "red", "count", "True", "x -= 1", "1", "x", "N, M = map(int, input().split())", "map(int, input().split())", "N", "y -= 1", "1", "y", "M = map(int, input().split())", "map(int, input().split())", "M", "num = [1 for i in range(N)]", "[1 for i in range(N)]", "num", "x, y = map(int, input().split())", "map(int, input().split())", "x", "red = [False for i in range(N)]", "[False for i in range(N)]", "red", "y = map(int, input().split())", "map(int, input().split())", "y" ]

[ 7, 15, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 39, 28, 13, 4, 13, 13, 4, 18, 13, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 0, 13, 2, 39, 17, 13, 0, 13, 2, 39, 17, 13, 0, 18, 13, 17, 17, 28, 13, 4, 13, 13, 0, 13, 18, 13, 13, 13, 14, 18, 13, 2, 13, 17, 14, 2, 18, 13, 2, 13, 17, 17, 0, 18, 13, 2, 13, 17, 17, 0, 18, 13, 2, 13, 17, 17, 0, 18, 13, 2, 13, 17, 17, 0, 18, 13, 2, 13, 17, 17, 0, 18, 13, 2, 13, 17, 17, 0, 18, 13, 2, 13, 17, 17, 4, 13, 4, 13, 13, 10, 2, 13, 10, 18, 13, 10, 4, 13, 10, 4, 13, 10, 39, 13, 10, 18, 13, 10, 2, 13 ]

[ [ 135, 4 ], [ 135, 13 ], [ 138, 15 ], [ 19, 18 ], [ 136, 21 ], [ 139, 24 ], [ 126, 37 ], [ 133, 41 ], [ 144, 43 ], [ 133, 47 ], [ 52, 49 ], [ 145, 50 ], [ 55, 54 ], [ 136, 57 ], [ 141, 59 ], [ 139, 61 ], [ 54, 62 ], [ 141, 63 ], [ 145, 66 ], [ 142, 68 ], [ 127, 73 ], [ 142, 75 ], [ 84, 79 ], [ 145, 80 ], [ 142, 82 ], [ 91, 86 ], [ 145, 87 ], [ 130, 89 ], [ 98, 93 ], [ 145, 94 ], [ 142, 96 ], [ 105, 100 ], [ 145, 101 ], [ 130, 103 ], [ 112, 107 ], [ 127, 108 ], [ 142, 110 ], [ 119, 114 ], [ 127, 115 ], [ 130, 117 ], [ 145, 124 ], [ 126, 127 ], [ 141, 130 ], [ 135, 133 ], [ 135, 136 ], [ 138, 139 ], [ 141, 142 ], [ 144, 145 ] ]

[ "import sys\n\nN,M=map(int,input().split())\nope=[]\nfor i in range(M):\n ope.append(tuple(map(int,input().split())))\n\nstate=[1]*N\nred=[0]*N\nred[0]=1\nfor i in range(M):\n x,y=ope[i]\n if red[x-1]:\n if state[x-1]>1:\n red[x-1]=1\n red[y-1]=1\n else:\n red[x-1]=0\n red[y-1]=1\n state[x-1]-=1\n state[y-1]+=1\n\nprint(sum(red))", "import sys", "sys", "N,M=map(int,input().split())", "N", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "M", "ope=[]", "ope", "[]", "for i in range(M):\n ope.append(tuple(map(int,input().split())))", "i", "range(M)", "range", "M", "ope.append(tuple(map(int,input().split())))", "ope.append", "ope", "append", "tuple(map(int,input().split()))", "tuple", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "state=[1]*N", "state", "[1]*N", "[1]", "1", "N", "red=[0]*N", "red", "[0]*N", "[0]", "0", "N", "red[0]=1", "red[0]", "red", "0", "1", "for i in range(M):\n x,y=ope[i]\n if red[x-1]:\n if state[x-1]>1:\n red[x-1]=1\n red[y-1]=1\n else:\n red[x-1]=0\n red[y-1]=1\n state[x-1]-=1\n state[y-1]+=1", "i", "range(M)", "range", "M", "x,y=ope[i]", "x", "ope[i]", "ope", "i", "y", "if red[x-1]:\n if state[x-1]>1:\n red[x-1]=1\n red[y-1]=1\n else:\n red[x-1]=0\n red[y-1]=1\n ", "red[x-1]", "red", "x-1", "x", "1", "if state[x-1]>1:\n red[x-1]=1\n red[y-1]=1\n else:\n red[x-1]=0\n red[y-1]=1\n ", "state[x-1]>1", "state[x-1]", "state", "x-1", "x", "1", "1", "red[x-1]=1", "red[x-1]", "red", "x-1", "x", "1", "1", "red[y-1]=1", "red[y-1]", "red", "y-1", "y", "1", "1", "red[x-1]=0", "red[x-1]", "red", "x-1", "x", "1", "0", "red[y-1]=1", "red[y-1]", "red", "y-1", "y", "1", "1", "state[x-1]-=1", "state[x-1]", "state", "x-1", "x", "1", "1", "state[y-1]+=1", "state[y-1]", "state", "y-1", "y", "1", "1", "print(sum(red))", "print", "sum(red)", "sum", "red", "state=[1]*N", "[1]*N", "state", "y=ope[i]", "ope[i]", "y", "N,M=map(int,input().split())", "map(int,input().split())", "N", "M=map(int,input().split())", "map(int,input().split())", "M", "ope=[]", "[]", "ope", "x,y=ope[i]", "ope[i]", "x", "red=[0]*N", "[0]*N", "red" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 41, 28, 13, 4, 13, 13, 4, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 0, 13, 13, 0, 13, 2, 39, 17, 13, 0, 18, 13, 17, 17, 0, 13, 2, 39, 17, 13, 28, 13, 13, 13, 0, 13, 2, 13, 17, 13, 2, 13, 17, 0, 18, 13, 13, 17, 0, 18, 13, 13, 17, 14, 18, 13, 13, 0, 18, 13, 13, 17, 14, 2, 18, 13, 13, 2, 18, 13, 13, 17, 0, 18, 13, 13, 17, 4, 13, 4, 13, 13, 10, 2, 13, 10, 2, 13, 10, 4, 13, 10, 2, 13, 10, 4, 13, 10, 13, 13, 10, 2, 13 ]

[ [ 114, 2 ], [ 114, 11 ], [ 15, 14 ], [ 115, 17 ], [ 117, 30 ], [ 111, 33 ], [ 109, 37 ], [ 42, 39 ], [ 112, 40 ], [ 105, 44 ], [ 109, 48 ], [ 102, 54 ], [ 103, 56 ], [ 120, 58 ], [ 121, 60 ], [ 66, 63 ], [ 106, 64 ], [ 103, 65 ], [ 71, 68 ], [ 106, 69 ], [ 121, 70 ], [ 112, 74 ], [ 103, 75 ], [ 80, 77 ], [ 112, 78 ], [ 121, 79 ], [ 92, 83 ], [ 112, 84 ], [ 103, 85 ], [ 63, 87 ], [ 106, 88 ], [ 103, 89 ], [ 95, 92 ], [ 112, 93 ], [ 103, 94 ], [ 112, 100 ], [ 102, 103 ], [ 105, 106 ], [ 114, 109 ], [ 111, 112 ], [ 114, 115 ], [ 117, 118 ], [ 120, 121 ] ]

[ "N, M = map(int, input().split())\nXY = [list(map(int, input().split())) for _ in range(M)]\n\nstatus = [False]*N\nstatus[0] = True\nball = [1]*N\n\nfor x, y in XY:\n x, y = x-1, y-1\n ball[x] -= 1\n ball[y] += 1\n if status[x]:\n status[y] = True\n if status[x] and ball[x] == 0:\n status[x] = False\n\nprint(sum(status))", "N, M = map(int, input().split())", "N", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "M", "list(map(int, input().split())) for _ in range(M)", "for _ in range(M)", "_", "range(M)", "range", "M", "for _ in range(M)", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "XY = [list(map(int, input().split())) for _ in range(M)]", "XY", "[list(map(int, input().split())) for _ in range(M)]", "status = [False]*N", "status", "[False]*N", "[False]", "False", "N", "status[0] = True", "status[0]", "status", "0", "True", "ball = [1]*N", "ball", "[1]*N", "[1]", "1", "N", "for x, y in XY:\n x, y = x-1, y-1\n ball[x] -= 1\n ball[y] += 1\n if status[x]:\n status[y] = True\n if status[x] and ball[x] == 0:\n status[x] = False", "x", "y", "XY", "x, y = x-1, y-1", "x", "x-1", "x", "1", "y", "y-1", "y", "1", "ball[x] -= 1", "ball[x]", "ball", "x", "1", "ball[y] += 1", "ball[y]", "ball", "y", "1", "if status[x]:\n status[y] = True\n ", "status[x]", "status", "x", "status[y] = True", "status[y]", "status", "y", "True", "if status[x] and ball[x] == 0:\n status[x] = False", "status[x] and ball[x] == 0", "status[x]", "status", "x", "ball[x] == 0", "ball[x]", "ball", "x", "0", "status[x] = False", "status[x]", "status", "x", "False", "print(sum(status))", "print", "sum(status)", "sum", "status", "x, y = x-1, y-1", "x-1", "x", "ball = [1]*N", "[1]*N", "ball", "N, M = map(int, input().split())", "map(int, input().split())", "N", "status = [False]*N", "[False]*N", "status", "M = map(int, input().split())", "map(int, input().split())", "M", "XY = [list(map(int, input().split())) for _ in range(M)]", "[list(map(int, input().split())) for _ in range(M)]", "XY", "y = x-1, y-1", "y-1", "y" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 41, 28, 13, 4, 13, 2, 13, 17, 4, 17, 0, 13, 13, 41, 28, 13, 4, 13, 2, 13, 17, 4, 17, 0, 13, 13, 0, 18, 13, 17, 17, 28, 13, 4, 13, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 18, 13, 13, 17, 0, 18, 13, 13, 17, 14, 2, 18, 13, 13, 17, 0, 18, 13, 13, 17, 14, 2, 2, 18, 13, 13, 17, 2, 18, 13, 13, 17, 0, 18, 13, 13, 17, 4, 13, 4, 13, 13, 10, 4, 13, 10, 4, 13, 10, 13, 13, 10, 13, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 115, 2 ], [ 115, 11 ], [ 15, 14 ], [ 104, 18 ], [ 112, 23 ], [ 28, 27 ], [ 104, 31 ], [ 109, 36 ], [ 42, 39 ], [ 110, 40 ], [ 45, 44 ], [ 116, 47 ], [ 118, 49 ], [ 118, 58 ], [ 63, 60 ], [ 113, 61 ], [ 107, 62 ], [ 68, 65 ], [ 113, 66 ], [ 119, 67 ], [ 93, 71 ], [ 110, 72 ], [ 107, 73 ], [ 79, 76 ], [ 110, 77 ], [ 119, 78 ], [ 93, 83 ], [ 110, 84 ], [ 107, 85 ], [ 60, 88 ], [ 113, 89 ], [ 107, 90 ], [ 96, 93 ], [ 110, 94 ], [ 107, 95 ], [ 110, 101 ], [ 115, 104 ], [ 118, 107 ], [ 109, 110 ], [ 112, 113 ], [ 115, 116 ], [ 118, 119 ] ]

[ "n, m = map(int, input().split())\nchecker = [1 for _i in range(n+1)]\nr = [0 for i in range(n+1)]\nr[1] = 1\nfor _i in range(m):\n x, y = map(int, input().split())\n checker[x] -= 1\n checker[y] += 1\n if r[x]>0:\n r[y] = 1\n if (r[x]>0) and (checker[x]==0):\n r[x] = 0\nprint(sum(r))", "n, m = map(int, input().split())", "n", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "m", "1 for _i in range(n+1)", "for _i in range(n+1)", "_i", "range(n+1)", "range", "n+1", "n", "1", "for _i in range(n+1)", "1", "checker = [1 for _i in range(n+1)]", "checker", "[1 for _i in range(n+1)]", "0 for i in range(n+1)", "for i in range(n+1)", "i", "range(n+1)", "range", "n+1", "n", "1", "for i in range(n+1)", "0", "r = [0 for i in range(n+1)]", "r", "[0 for i in range(n+1)]", "r[1] = 1", "r[1]", "r", "1", "1", "for _i in range(m):\n x, y = map(int, input().split())\n checker[x] -= 1\n checker[y] += 1\n if r[x]>0:\n r[y] = 1\n if (r[x]>0) and (checker[x]==0):\n r[x] = 0", "_i", "range(m)", "range", "m", "x, y = map(int, input().split())", "x", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "y", "checker[x] -= 1", "checker[x]", "checker", "x", "1", "checker[y] += 1", "checker[y]", "checker", "y", "1", "if r[x]>0:\n r[y] = 1\n ", "r[x]>0", "r[x]", "r", "x", "0", "r[y] = 1", "r[y]", "r", "y", "1", "if (r[x]>0) and (checker[x]==0):\n r[x] = 0", "(r[x]>0) and (checker[x]==0)", "r[x]>0", "r[x]", "r", "x", "0", "checker[x]==0", "checker[x]", "checker", "x", "0", "r[x] = 0", "r[x]", "r", "x", "0", "print(sum(r))", "print", "sum(r)", "sum", "r", "n, m = map(int, input().split())", "map(int, input().split())", "n", "x, y = map(int, input().split())", "map(int, input().split())", "x", "r = [0 for i in range(n+1)]", "[0 for i in range(n+1)]", "r", "checker = [1 for _i in range(n+1)]", "[1 for _i in range(n+1)]", "checker", "m = map(int, input().split())", "map(int, input().split())", "m", "y = map(int, input().split())", "map(int, input().split())", "y" ]

[ 7, 41, 28, 13, 4, 18, 4, 13, 13, 4, 4, 13, 13, 0, 13, 13, 13, 0, 13, 39, 28, 13, 4, 13, 13, 41, 28, 13, 4, 18, 4, 13, 13, 4, 4, 13, 13, 4, 18, 13, 13, 13, 0, 13, 2, 39, 17, 2, 13, 17, 0, 13, 2, 39, 17, 2, 13, 17, 0, 18, 13, 17, 17, 28, 13, 4, 13, 13, 14, 2, 18, 13, 18, 18, 13, 13, 17, 17, 0, 18, 13, 18, 18, 13, 13, 17, 17, 14, 2, 18, 13, 18, 18, 13, 13, 17, 17, 0, 18, 13, 18, 18, 13, 13, 17, 17, 0, 18, 13, 18, 18, 13, 13, 17, 17, 0, 18, 13, 18, 18, 13, 13, 17, 17, 0, 13, 17, 28, 13, 4, 13, 2, 13, 17, 14, 2, 18, 13, 13, 17, 0, 13, 17, 4, 13, 13, 10, 13, 13, 10, 17, 13, 10, 17, 13, 10, 39, 13, 10, 2, 13, 10, 13, 13, 10, 2, 13 ]

[ [ 4, 3 ], [ 3, 12 ], [ 162, 14 ], [ 162, 16 ], [ 156, 18 ], [ 22, 21 ], [ 148, 24 ], [ 28, 27 ], [ 27, 36 ], [ 157, 39 ], [ 159, 43 ], [ 163, 48 ], [ 165, 51 ], [ 163, 56 ], [ 62, 59 ], [ 166, 60 ], [ 65, 64 ], [ 148, 67 ], [ 166, 71 ], [ 157, 74 ], [ 64, 75 ], [ 86, 79 ], [ 166, 80 ], [ 157, 83 ], [ 64, 84 ], [ 160, 90 ], [ 157, 93 ], [ 64, 94 ], [ 105, 98 ], [ 166, 99 ], [ 157, 102 ], [ 64, 103 ], [ 114, 107 ], [ 160, 108 ], [ 157, 111 ], [ 64, 112 ], [ 123, 116 ], [ 160, 117 ], [ 157, 120 ], [ 64, 121 ], [ 153, 125 ], [ 129, 128 ], [ 163, 132 ], [ 166, 137 ], [ 128, 138 ], [ 150, 141 ], [ 151, 145 ], [ 154, 145 ], [ 162, 148 ], [ 150, 151 ], [ 153, 154 ], [ 156, 157 ], [ 159, 160 ], [ 162, 163 ], [ 165, 166 ] ]

[ "n,m = [int(x) for x in input().split()]\nx = []\nfor i in range(m):\n x.append([int(x) for x in input().split()])\ncount = [1] * (n+1)\nflag = [0] * (n+1)\nflag[1] = 1\nfor i in range(m):\n if flag[x[i][0]] == 1:\n flag[x[i][1]] = 1\n if count[x[i][0]] == 1:\n flag[x[i][0]] = 0\n count[x[i][0]] -= 1\n count[x[i][1]] += 1\n\nres = 0\nfor i in range(n+1):\n if flag[i] == 1:\n res += 1\n \nprint(res)", "int(x) for x in input().split()", "for x in input().split()", "x", "input().split()", "().split", "()", "input", "split", "for x in input().split()", "int(x)", "int", "x", "n,m = [int(x) for x in input().split()]", "n", "[int(x) for x in input().split()]", "m", "x = []", "x", "[]", "for i in range(m):\n x.append([int(x) for x in input().split()])", "i", "range(m)", "range", "m", "int(x) for x in input().split()", "for x in input().split()", "x", "input().split()", "().split", "()", "input", "split", "for x in input().split()", "int(x)", "int", "x", "x.append([int(x) for x in input().split()])", "x.append", "x", "append", "[int(x) for x in input().split()]", "count = [1] * (n+1)", "count", "[1] * (n+1)", "[1]", "1", "n+1", "n", "1", "flag = [0] * (n+1)", "flag", "[0] * (n+1)", "[0]", "0", "n+1", "n", "1", "flag[1] = 1", "flag[1]", "flag", "1", "1", "for i in range(m):\n if flag[x[i][0]] == 1:\n flag[x[i][1]] = 1\n if count[x[i][0]] == 1:\n flag[x[i][0]] = 0\n count[x[i][0]] -= 1\n count[x[i][1]] += 1", "i", "range(m)", "range", "m", "if flag[x[i][0]] == 1:\n flag[x[i][1]] = 1\n ", "flag[x[i][0]] == 1", "flag[x[i][0]]", "flag", "x[i][0]", "[i]", "x", "i", "0", "1", "flag[x[i][1]] = 1", "flag[x[i][1]]", "flag", "x[i][1]", "[i]", "x", "i", "1", "1", "if count[x[i][0]] == 1:\n flag[x[i][0]] = 0\n ", "count[x[i][0]] == 1", "count[x[i][0]]", "count", "x[i][0]", "[i]", "x", "i", "0", "1", "flag[x[i][0]] = 0", "flag[x[i][0]]", "flag", "x[i][0]", "[i]", "x", "i", "0", "0", "count[x[i][0]] -= 1", "count[x[i][0]]", "count", "x[i][0]", "[i]", "x", "i", "0", "1", "count[x[i][1]] += 1", "count[x[i][1]]", "count", "x[i][1]", "[i]", "x", "i", "1", "1", "res = 0", "res", "0", "for i in range(n+1):\n if flag[i] == 1:\n res += 1\n ", "i", "range(n+1)", "range", "n+1", "n", "1", "if flag[i] == 1:\n res += 1\n ", "flag[i] == 1", "flag[i]", "flag", "i", "1", "res += 1", "res", "1", "print(res)", "print", "res", "m = [int(x) for x in input().split()]", "[int(x) for x in input().split()]", "m", "res += 1", "1", "res", "res = 0", "0", "res", "x = []", "[]", "x", "count = [1] * (n+1)", "[1] * (n+1)", "count", "n,m = [int(x) for x in input().split()]", "[int(x) for x in input().split()]", "n", "flag = [0] * (n+1)", "[0] * (n+1)", "flag" ]

[ 7, 17, 12, 13, 0, 13, 17, 0, 13, 2, 39, 17, 13, 28, 13, 13, 4, 13, 13, 13, 14, 2, 2, 13, 17, 13, 14, 2, 18, 13, 2, 13, 17, 17, 4, 18, 13, 13, 2, 13, 17, 4, 18, 13, 13, 2, 13, 17, 0, 18, 13, 2, 13, 17, 17, 0, 18, 13, 2, 13, 17, 17, 29, 4, 13, 13, 23, 13, 23, 13, 23, 13, 23, 13, 12, 13, 29, 12, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 39, 0, 13, 39, 28, 13, 4, 13, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 4, 18, 13, 13, 13, 4, 18, 13, 13, 13, 4, 13, 4, 13, 13, 13, 13, 13, 14, 2, 13, 17, 4, 13, 10, 12, 13, 10, 12, 13, 10, 12, 13 ]

[ [ 6, 5 ], [ 9, 8 ], [ 67, 12 ], [ 71, 18 ], [ 73, 19 ], [ 5, 25 ], [ 8, 29 ], [ 5, 36 ], [ 5, 43 ], [ 54, 49 ], [ 8, 50 ], [ 61, 56 ], [ 8, 57 ], [ 5, 65 ], [ 67, 67 ], [ 69, 69 ], [ 71, 71 ], [ 73, 73 ], [ 81, 80 ], [ 81, 89 ], [ 92, 91 ], [ 95, 94 ], [ 98, 97 ], [ 89, 100 ], [ 103, 102 ], [ 103, 111 ], [ 91, 114 ], [ 102, 116 ], [ 94, 119 ], [ 111, 121 ], [ 144, 125 ], [ 80, 126 ], [ 89, 127 ], [ 91, 128 ], [ 94, 129 ], [ 138, 135 ] ]

[ "'''\nAccepted 　:No\ndifficult 　: \nペナルティ　 　:5分\n実際の回答時間 :分\nWAの回数　 :回\n合計時間　　 　:分\n'''\n\ndef myAnswer(N:int,M:int,X:list,Y:list) -> int:\n ans = {0}\n box = [1] * N\n for x,y in zip(X,Y):\n if(x-1 in ans):\n if(box[x - 1]==1):\n ans.remove(x-1)\n ans.add(y-1)\n box[x-1] -= 1\n box[y-1] += 1\n return len(ans)\n\ndef modelAnswer():\n return\ndef main():\n N,M = map(int,input().split())\n X = []\n Y = []\n for _ in range(M):\n x,y=map(int,input().split())\n X.append(x)\n Y.append(y)\n print(myAnswer(N,M,X,Y))\nif __name__ == '__main__':\n main()", "'''\nAccepted 　:No\ndifficult 　: \nペナルティ　 　:5分\n実際の回答時間 :分\nWAの回数　 :回\n合計時間　　 　:分\n'''", "def myAnswer(N:int,M:int,X:list,Y:list) -> int:\n ans = {0}\n box = [1] * N\n for x,y in zip(X,Y):\n if(x-1 in ans):\n if(box[x - 1]==1):\n ans.remove(x-1)\n ans.add(y-1)\n box[x-1] -= 1\n box[y-1] += 1\n return len(ans)", "myAnswer", "ans = {0}", "ans", "{0}", "box = [1] * N", "box", "[1] * N", "[1]", "1", "N", "for x,y in zip(X,Y):\n if(x-1 in ans):\n if(box[x - 1]==1):\n ans.remove(x-1)\n ans.add(y-1)\n box[x-1] -= 1\n box[y-1] += 1\n ", "x", "y", "zip(X,Y)", "zip", "X", "Y", "if(x-1 in ans):\n if(box[x - 1]==1):\n ans.remove(x-1)\n ans.add(y-1)\n ", "x-1 in ans", "x-1", "x", "1", "ans", "if(box[x - 1]==1):\n ans.remove(x-1)\n ", "box[x - 1]==1", "box[x - 1]", "box", "x - 1", "x", "1", "1", "ans.remove(x-1)", "ans.remove", "ans", "remove", "x-1", "x", "1", "ans.add(y-1)", "ans.add", "ans", "add", "y-1", "y", "1", "box[x-1] -= 1", "box[x-1]", "box", "x-1", "x", "1", "1", "box[y-1] += 1", "box[y-1]", "box", "y-1", "y", "1", "1", "return len(ans)", "len(ans)", "len", "ans", "N:int", "N", "M:int", "M", "X:list", "X", "Y:list", "Y", "def modelAnswer():\n return", "modelAnswer", "return", "def main():\n N,M = map(int,input().split())\n X = []\n Y = []\n for _ in range(M):\n x,y=map(int,input().split())\n X.append(x)\n Y.append(y)\n print(myAnswer(N,M,X,Y))", "main", "N,M = map(int,input().split())", "N", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "M", "X = []", "X", "[]", "Y = []", "Y", "[]", "for _ in range(M):\n x,y=map(int,input().split())\n X.append(x)\n Y.append(y)\n ", "_", "range(M)", "range", "M", "x,y=map(int,input().split())", "x", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "y", "X.append(x)", "X.append", "X", "append", "x", "Y.append(y)", "Y.append", "Y", "append", "y", "print(myAnswer(N,M,X,Y))", "print", "myAnswer(N,M,X,Y)", "myAnswer", "N", "M", "X", "Y", "if __name__ == '__main__':\n main()", "__name__ == '__main__'", "__name__", "'__main__'", "main()", "main", "def main():\n N,M = map(int,input().split())\n X = []\n Y = []\n for _ in range(M):\n x,y=map(int,input().split())\n X.append(x)\n Y.append(y)\n print(myAnswer(N,M,X,Y))", "def main():\n N,M = map(int,input().split())\n X = []\n Y = []\n for _ in range(M):\n x,y=map(int,input().split())\n X.append(x)\n Y.append(y)\n print(myAnswer(N,M,X,Y))", "main", "def modelAnswer():\n return", "def modelAnswer():\n return", "modelAnswer", "def myAnswer(N:int,M:int,X:list,Y:list) -> int:\n ans = {0}\n box = [1] * N\n for x,y in zip(X,Y):\n if(x-1 in ans):\n if(box[x - 1]==1):\n ans.remove(x-1)\n ans.add(y-1)\n box[x-1] -= 1\n box[y-1] += 1\n return len(ans)", "def myAnswer(N:int,M:int,X:list,Y:list) -> int:\n ans = {0}\n box = [1] * N\n for x,y in zip(X,Y):\n if(x-1 in ans):\n if(box[x - 1]==1):\n ans.remove(x-1)\n ans.add(y-1)\n box[x-1] -= 1\n box[y-1] += 1\n return len(ans)", "myAnswer" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 17, 13, 0, 13, 2, 39, 17, 13, 0, 13, 2, 39, 17, 2, 39, 17, 2, 13, 17, 28, 13, 4, 13, 13, 0, 13, 4, 13, 12, 2, 4, 13, 13, 17, 23, 4, 18, 4, 13, 13, 17, 13, 0, 18, 13, 13, 17, 0, 18, 13, 13, 17, 14, 2, 18, 13, 13, 18, 13, 13, 0, 18, 13, 13, 17, 14, 2, 18, 13, 13, 40, 18, 13, 13, 0, 18, 13, 13, 17, 0, 18, 13, 13, 17, 4, 13, 4, 13, 13, 10, 4, 13, 10, 2, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 2, 13 ]

[ [ 113, 2 ], [ 113, 12 ], [ 116, 14 ], [ 114, 18 ], [ 104, 20 ], [ 114, 28 ], [ 32, 31 ], [ 111, 34 ], [ 107, 36 ], [ 107, 52 ], [ 57, 54 ], [ 117, 55 ], [ 102, 56 ], [ 62, 59 ], [ 117, 60 ], [ 108, 61 ], [ 86, 65 ], [ 105, 66 ], [ 102, 67 ], [ 54, 68 ], [ 117, 69 ], [ 102, 70 ], [ 75, 72 ], [ 105, 73 ], [ 108, 74 ], [ 86, 78 ], [ 105, 79 ], [ 102, 80 ], [ 54, 82 ], [ 117, 83 ], [ 102, 84 ], [ 89, 86 ], [ 105, 87 ], [ 102, 88 ], [ 94, 91 ], [ 105, 92 ], [ 108, 93 ], [ 105, 99 ], [ 107, 102 ], [ 104, 105 ], [ 107, 108 ], [ 113, 111 ], [ 113, 114 ], [ 116, 117 ] ]

[ "N,M=map(int,input().split(' '))\nB = [1]*N\nR = [1]+[0]*(N-1)\nfor i in range(M):\n x,y=map(lambda x:int(x)-1,input().split(' '))\n B[x]-=1\n B[y]+=1\n if R[x] and B[x]:\n R[y]=1\n elif R[x] and not B[x]:\n R[x]=0\n R[y]=1\nprint(sum(R))", "N,M=map(int,input().split(' '))", "N", "map(int,input().split(' '))", "map", "int", "input().split(' ')", "().split", "()", "input", "split", "' '", "M", "B = [1]*N", "B", "[1]*N", "[1]", "1", "N", "R = [1]+[0]*(N-1)", "R", "[1]+[0]*(N-1)", "[1]", "1", "[0]*(N-1)", "[0]", "0", "N-1", "N", "1", "for i in range(M):\n x,y=map(lambda x:int(x)-1,input().split(' '))\n B[x]-=1\n B[y]+=1\n if R[x] and B[x]:\n R[y]=1\n elif R[x] and not B[x]:\n R[x]=0\n R[y]=1", "i", "range(M)", "range", "M", "x,y=map(lambda x:int(x)-1,input().split(' '))", "x", "map(lambda x:int(x)-1,input().split(' '))", "map", "lambda x:int(x)-1", "int(x)-1", "int(x)", "int", "x", "1", "x", "input().split(' ')", "().split", "()", "input", "split", "' '", "y", "B[x]-=1", "B[x]", "B", "x", "1", "B[y]+=1", "B[y]", "B", "y", "1", "if R[x] and B[x]:\n R[y]=1\n elif R[x] and not B[x]:\n R[x]=0\n R[y]=1", "R[x] and B[x]", "R[x]", "R", "x", "B[x]", "B", "x", "R[y]=1", "R[y]", "R", "y", "1", "elif R[x] and not B[x]:\n R[x]=0\n R[y]=1", "R[x] and not B[x]", "R[x]", "R", "x", "not B[x]", "B[x]", "B", "x", "R[x]=0", "R[x]", "R", "x", "0", "R[y]=1", "R[y]", "R", "y", "1", "print(sum(R))", "print", "sum(R)", "sum", "R", "x,y=map(lambda x:int(x)-1,input().split(' '))", "map(lambda x:int(x)-1,input().split(' '))", "x", "R = [1]+[0]*(N-1)", "[1]+[0]*(N-1)", "R", "y=map(lambda x:int(x)-1,input().split(' '))", "map(lambda x:int(x)-1,input().split(' '))", "y", "M=map(int,input().split(' '))", "map(int,input().split(' '))", "M", "N,M=map(int,input().split(' '))", "map(int,input().split(' '))", "N", "B = [1]*N", "[1]*N", "B" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 2, 39, 17, 13, 0, 13, 2, 39, 17, 13, 0, 18, 13, 17, 17, 28, 13, 4, 13, 13, 0, 13, 4, 13, 12, 2, 4, 13, 13, 17, 23, 4, 18, 4, 13, 13, 13, 0, 18, 13, 13, 18, 13, 13, 0, 18, 13, 13, 17, 0, 18, 13, 13, 17, 14, 2, 18, 13, 13, 17, 0, 18, 13, 13, 17, 0, 13, 17, 28, 13, 4, 13, 13, 14, 2, 18, 13, 13, 2, 18, 13, 13, 17, 0, 13, 17, 4, 13, 13, 10, 4, 13, 10, 4, 13, 10, 17, 13, 10, 4, 13, 10, 2, 13, 10, 4, 13, 10, 2, 13, 10, 17, 13 ]

[ [ 119, 2 ], [ 119, 11 ], [ 116, 13 ], [ 114, 17 ], [ 122, 19 ], [ 114, 23 ], [ 28, 25 ], [ 117, 26 ], [ 31, 30 ], [ 120, 33 ], [ 107, 35 ], [ 107, 50 ], [ 55, 52 ], [ 117, 53 ], [ 105, 54 ], [ 75, 55 ], [ 117, 56 ], [ 108, 57 ], [ 62, 59 ], [ 123, 60 ], [ 105, 61 ], [ 67, 64 ], [ 123, 65 ], [ 108, 66 ], [ 64, 70 ], [ 123, 71 ], [ 108, 72 ], [ 78, 75 ], [ 117, 76 ], [ 108, 77 ], [ 125, 80 ], [ 84, 83 ], [ 114, 86 ], [ 117, 90 ], [ 83, 91 ], [ 123, 94 ], [ 83, 95 ], [ 110, 98 ], [ 111, 102 ], [ 126, 102 ], [ 107, 105 ], [ 107, 108 ], [ 110, 111 ], [ 119, 114 ], [ 116, 117 ], [ 119, 120 ], [ 122, 123 ], [ 125, 126 ] ]

[ "N,M=map(int,input().split())\nRed=[False]*N\nCnt=[1]*N\nRed[0]=True\nfor i in range(M):\n x,y=map(lambda x:int(x)-1,input().split())\n Red[y]|=Red[x]\n Cnt[y]+=1\n Cnt[x]-=1\n if Cnt[x]==0:\n Red[x]=False\nans=0\nfor i in range(N):\n if Red[i] and Cnt[i]>0:\n ans+=1\nprint(ans)", "N,M=map(int,input().split())", "N", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "M", "Red=[False]*N", "Red", "[False]*N", "[False]", "False", "N", "Cnt=[1]*N", "Cnt", "[1]*N", "[1]", "1", "N", "Red[0]=True", "Red[0]", "Red", "0", "True", "for i in range(M):\n x,y=map(lambda x:int(x)-1,input().split())\n Red[y]|=Red[x]\n Cnt[y]+=1\n Cnt[x]-=1\n if Cnt[x]==0:\n Red[x]=False", "i", "range(M)", "range", "M", "x,y=map(lambda x:int(x)-1,input().split())", "x", "map(lambda x:int(x)-1,input().split())", "map", "lambda x:int(x)-1", "int(x)-1", "int(x)", "int", "x", "1", "x", "input().split()", "().split", "()", "input", "split", "y", "Red[y]|=Red[x]", "Red[y]", "Red", "y", "Red[x]", "Red", "x", "Cnt[y]+=1", "Cnt[y]", "Cnt", "y", "1", "Cnt[x]-=1", "Cnt[x]", "Cnt", "x", "1", "if Cnt[x]==0:\n Red[x]=False", "Cnt[x]==0", "Cnt[x]", "Cnt", "x", "0", "Red[x]=False", "Red[x]", "Red", "x", "False", "ans=0", "ans", "0", "for i in range(N):\n if Red[i] and Cnt[i]>0:\n ans+=1", "i", "range(N)", "range", "N", "if Red[i] and Cnt[i]>0:\n ans+=1", "Red[i] and Cnt[i]>0", "Red[i]", "Red", "i", "Cnt[i]>0", "Cnt[i]", "Cnt", "i", "0", "ans+=1", "ans", "1", "print(ans)", "print", "ans", "y=map(lambda x:int(x)-1,input().split())", "map(lambda x:int(x)-1,input().split())", "y", "x,y=map(lambda x:int(x)-1,input().split())", "map(lambda x:int(x)-1,input().split())", "x", "ans+=1", "1", "ans", "N,M=map(int,input().split())", "map(int,input().split())", "N", "Red=[False]*N", "[False]*N", "Red", "M=map(int,input().split())", "map(int,input().split())", "M", "Cnt=[1]*N", "[1]*N", "Cnt", "ans=0", "0", "ans" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 2, 39, 17, 13, 13, 2, 39, 17, 13, 0, 13, 2, 39, 17, 13, 41, 28, 13, 4, 13, 13, 4, 17, 0, 13, 13, 0, 18, 13, 17, 17, 28, 13, 4, 13, 13, 0, 18, 13, 13, 4, 13, 13, 4, 18, 4, 13, 13, 18, 13, 13, 14, 2, 2, 18, 13, 2, 18, 13, 13, 17, 17, 2, 18, 13, 2, 18, 13, 13, 17, 17, 0, 18, 13, 2, 18, 13, 13, 17, 17, 0, 18, 13, 2, 18, 13, 13, 17, 17, 14, 2, 2, 18, 13, 2, 18, 13, 13, 17, 17, 2, 18, 13, 2, 18, 13, 13, 17, 17, 0, 18, 13, 2, 18, 13, 13, 17, 17, 0, 18, 13, 2, 18, 13, 13, 17, 17, 0, 18, 13, 2, 18, 13, 13, 17, 17, 0, 18, 13, 2, 18, 13, 13, 17, 18, 13, 2, 18, 13, 13, 17, 14, 2, 2, 18, 13, 2, 18, 13, 13, 17, 17, 2, 18, 13, 2, 18, 13, 13, 17, 17, 0, 18, 13, 2, 18, 13, 13, 17, 17, 0, 18, 13, 2, 18, 13, 13, 17, 17, 0, 18, 13, 2, 18, 13, 13, 17, 18, 13, 2, 18, 13, 13, 17, 14, 2, 2, 18, 13, 2, 18, 13, 13, 17, 17, 2, 18, 13, 2, 18, 13, 13, 17, 17, 0, 18, 13, 2, 18, 13, 13, 17, 17, 0, 18, 13, 2, 18, 13, 13, 17, 17, 0, 18, 13, 2, 18, 13, 13, 17, 17, 0, 18, 13, 2, 18, 13, 13, 17, 18, 13, 2, 18, 13, 13, 17, 0, 13, 17, 28, 13, 13, 14, 2, 13, 17, 0, 13, 17, 4, 13, 13, 10, 13, 13, 10, 4, 13, 10, 17, 13, 10, 17, 13, 10, 2, 13, 10, 4, 13, 10, 2, 13, 10, 2, 13 ]

[ [ 312, 2 ], [ 312, 11 ], [ 315, 13 ], [ 301, 17 ], [ 309, 18 ], [ 301, 22 ], [ 318, 24 ], [ 313, 28 ], [ 32, 31 ], [ 313, 34 ], [ 297, 38 ], [ 44, 41 ], [ 298, 42 ], [ 47, 46 ], [ 301, 49 ], [ 54, 51 ], [ 316, 52 ], [ 46, 53 ], [ 54, 62 ], [ 310, 63 ], [ 46, 64 ], [ 298, 69 ], [ 51, 71 ], [ 316, 72 ], [ 46, 73 ], [ 298, 78 ], [ 62, 80 ], [ 310, 81 ], [ 46, 82 ], [ 93, 86 ], [ 319, 87 ], [ 51, 89 ], [ 316, 90 ], [ 46, 91 ], [ 102, 95 ], [ 319, 96 ], [ 62, 98 ], [ 310, 99 ], [ 46, 100 ], [ 298, 107 ], [ 51, 109 ], [ 316, 110 ], [ 46, 111 ], [ 298, 116 ], [ 62, 118 ], [ 310, 119 ], [ 46, 120 ], [ 131, 124 ], [ 319, 125 ], [ 51, 127 ], [ 316, 128 ], [ 46, 129 ], [ 140, 133 ], [ 298, 134 ], [ 51, 136 ], [ 316, 137 ], [ 46, 138 ], [ 149, 142 ], [ 319, 143 ], [ 62, 145 ], [ 310, 146 ], [ 46, 147 ], [ 158, 151 ], [ 298, 152 ], [ 62, 154 ], [ 310, 155 ], [ 46, 156 ], [ 319, 159 ], [ 62, 161 ], [ 310, 162 ], [ 46, 163 ], [ 298, 169 ], [ 51, 171 ], [ 316, 172 ], [ 46, 173 ], [ 298, 178 ], [ 62, 180 ], [ 310, 181 ], [ 46, 182 ], [ 193, 186 ], [ 319, 187 ], [ 51, 189 ], [ 316, 190 ], [ 46, 191 ], [ 202, 195 ], [ 319, 196 ], [ 62, 198 ], [ 310, 199 ], [ 46, 200 ], [ 211, 204 ], [ 298, 205 ], [ 62, 207 ], [ 310, 208 ], [ 46, 209 ], [ 319, 212 ], [ 62, 214 ], [ 310, 215 ], [ 46, 216 ], [ 298, 222 ], [ 51, 224 ], [ 316, 225 ], [ 46, 226 ], [ 298, 231 ], [ 62, 233 ], [ 310, 234 ], [ 46, 235 ], [ 246, 239 ], [ 319, 240 ], [ 51, 242 ], [ 316, 243 ], [ 46, 244 ], [ 255, 248 ], [ 298, 249 ], [ 51, 251 ], [ 316, 252 ], [ 46, 253 ], [ 264, 257 ], [ 319, 258 ], [ 62, 260 ], [ 310, 261 ], [ 46, 262 ], [ 273, 266 ], [ 298, 267 ], [ 62, 269 ], [ 310, 270 ], [ 46, 271 ], [ 319, 274 ], [ 62, 276 ], [ 310, 277 ], [ 46, 278 ], [ 306, 281 ], [ 285, 284 ], [ 298, 284 ], [ 284, 288 ], [ 303, 291 ], [ 304, 295 ], [ 307, 295 ], [ 297, 298 ], [ 312, 301 ], [ 303, 304 ], [ 306, 307 ], [ 309, 310 ], [ 312, 313 ], [ 315, 316 ], [ 318, 319 ] ]

[ "n,m=map(int,input().split())\nx,y=[0]*m,[0]*m\nres=[1]*n\nred=[0 for i in range(n)]\nred[0]=1\nfor i in range(m):\n x[i],y[i]=map(int,input().split())\n if red[x[i]-1]==0 and red[y[i]-1]==0:\n res[x[i]-1]-=1\n res[y[i]-1]+=1\n elif red[x[i]-1]>0 and red[y[i]-1]==0:\n res[x[i]-1]-=1\n red[x[i]-1]-=1\n res[y[i]-1]+=1\n red[y[i]-1]=res[y[i]-1]\n elif red[x[i]-1]==0 and red[y[i]-1]>0:\n res[x[i]-1]-=1\n res[y[i]-1]+=1\n red[y[i]-1]=res[y[i]-1]\n elif red[x[i]-1]>0 and red[y[i]-1]>0:\n res[x[i]-1]-=1\n red[x[i]-1]-=1\n res[y[i]-1]+=1\n red[y[i]-1]=res[y[i]-1]\ncnt=0\nfor p in red:\n if p>0:\n cnt+=1\nprint(cnt)", "n,m=map(int,input().split())", "n", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "m", "x,y=[0]*m,[0]*m", "x", "[0]*m", "[0]", "0", "m", "y", "[0]*m", "[0]", "0", "m", "res=[1]*n", "res", "[1]*n", "[1]", "1", "n", "0 for i in range(n)", "for i in range(n)", "i", "range(n)", "range", "n", "for i in range(n)", "0", "red=[0 for i in range(n)]", "red", "[0 for i in range(n)]", "red[0]=1", "red[0]", "red", "0", "1", "for i in range(m):\n x[i],y[i]=map(int,input().split())\n if red[x[i]-1]==0 and red[y[i]-1]==0:\n res[x[i]-1]-=1\n res[y[i]-1]+=1\n elif red[x[i]-1]>0 and red[y[i]-1]==0:\n res[x[i]-1]-=1\n red[x[i]-1]-=1\n res[y[i]-1]+=1\n red[y[i]-1]=res[y[i]-1]\n elif red[x[i]-1]==0 and red[y[i]-1]>0:\n res[x[i]-1]-=1\n res[y[i]-1]+=1\n red[y[i]-1]=res[y[i]-1]\n elif red[x[i]-1]>0 and red[y[i]-1]>0:\n res[x[i]-1]-=1\n red[x[i]-1]-=1\n res[y[i]-1]+=1\n red[y[i]-1]=res[y[i]-1]", "i", "range(m)", "range", "m", "x[i],y[i]=map(int,input().split())", "x[i]", "x", "i", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "y[i]", "y", "i", "if red[x[i]-1]==0 and red[y[i]-1]==0:\n res[x[i]-1]-=1\n res[y[i]-1]+=1\n elif red[x[i]-1]>0 and red[y[i]-1]==0:\n res[x[i]-1]-=1\n red[x[i]-1]-=1\n res[y[i]-1]+=1\n red[y[i]-1]=res[y[i]-1]\n elif red[x[i]-1]==0 and red[y[i]-1]>0:\n res[x[i]-1]-=1\n res[y[i]-1]+=1\n red[y[i]-1]=res[y[i]-1]\n elif red[x[i]-1]>0 and red[y[i]-1]>0:\n res[x[i]-1]-=1\n red[x[i]-1]-=1\n res[y[i]-1]+=1\n red[y[i]-1]=res[y[i]-1]", "red[x[i]-1]==0 and red[y[i]-1]==0", "red[x[i]-1]==0", "red[x[i]-1]", "red", "x[i]-1", "x[i]", "x", "i", "1", "0", "red[y[i]-1]==0", "red[y[i]-1]", "red", "y[i]-1", "y[i]", "y", "i", "1", "0", "res[x[i]-1]-=1", "res[x[i]-1]", "res", "x[i]-1", "x[i]", "x", "i", "1", "1", "res[y[i]-1]+=1", "res[y[i]-1]", "res", "y[i]-1", "y[i]", "y", "i", "1", "1", "elif red[x[i]-1]>0 and red[y[i]-1]==0:\n res[x[i]-1]-=1\n red[x[i]-1]-=1\n res[y[i]-1]+=1\n red[y[i]-1]=res[y[i]-1]\n ", "red[x[i]-1]>0 and red[y[i]-1]==0", "red[x[i]-1]>0", "red[x[i]-1]", "red", "x[i]-1", "x[i]", "x", "i", "1", "0", "red[y[i]-1]==0", "red[y[i]-1]", "red", "y[i]-1", "y[i]", "y", "i", "1", "0", "res[x[i]-1]-=1", "res[x[i]-1]", "res", "x[i]-1", "x[i]", "x", "i", "1", "1", "red[x[i]-1]-=1", "red[x[i]-1]", "red", "x[i]-1", "x[i]", "x", "i", "1", "1", "res[y[i]-1]+=1", "res[y[i]-1]", "res", "y[i]-1", "y[i]", "y", "i", "1", "1", "red[y[i]-1]=res[y[i]-1]", "red[y[i]-1]", "red", "y[i]-1", "y[i]", "y", "i", "1", "res[y[i]-1]", "res", "y[i]-1", "y[i]", "y", "i", "1", "elif red[x[i]-1]==0 and red[y[i]-1]>0:\n res[x[i]-1]-=1\n res[y[i]-1]+=1\n red[y[i]-1]=res[y[i]-1]\n ", "red[x[i]-1]==0 and red[y[i]-1]>0", "red[x[i]-1]==0", "red[x[i]-1]", "red", "x[i]-1", "x[i]", "x", "i", "1", "0", "red[y[i]-1]>0", "red[y[i]-1]", "red", "y[i]-1", "y[i]", "y", "i", "1", "0", "res[x[i]-1]-=1", "res[x[i]-1]", "res", "x[i]-1", "x[i]", "x", "i", "1", "1", "res[y[i]-1]+=1", "res[y[i]-1]", "res", "y[i]-1", "y[i]", "y", "i", "1", "1", "red[y[i]-1]=res[y[i]-1]", "red[y[i]-1]", "red", "y[i]-1", "y[i]", "y", "i", "1", "res[y[i]-1]", "res", "y[i]-1", "y[i]", "y", "i", "1", "elif red[x[i]-1]>0 and red[y[i]-1]>0:\n res[x[i]-1]-=1\n red[x[i]-1]-=1\n res[y[i]-1]+=1\n red[y[i]-1]=res[y[i]-1]", "red[x[i]-1]>0 and red[y[i]-1]>0", "red[x[i]-1]>0", "red[x[i]-1]", "red", "x[i]-1", "x[i]", "x", "i", "1", "0", "red[y[i]-1]>0", "red[y[i]-1]", "red", "y[i]-1", "y[i]", "y", "i", "1", "0", "res[x[i]-1]-=1", "res[x[i]-1]", "res", "x[i]-1", "x[i]", "x", "i", "1", "1", "red[x[i]-1]-=1", "red[x[i]-1]", "red", "x[i]-1", "x[i]", "x", "i", "1", "1", "res[y[i]-1]+=1", "res[y[i]-1]", "res", "y[i]-1", "y[i]", "y", "i", "1", "1", "red[y[i]-1]=res[y[i]-1]", "red[y[i]-1]", "red", "y[i]-1", "y[i]", "y", "i", "1", "res[y[i]-1]", "res", "y[i]-1", "y[i]", "y", "i", "1", "cnt=0", "cnt", "0", "for p in red:\n if p>0:\n cnt+=1", "p", "red", "if p>0:\n cnt+=1", "p>0", "p", "0", "cnt+=1", "cnt", "1", "print(cnt)", "print", "cnt", "red=[0 for i in range(n)]", "[0 for i in range(n)]", "red", "m=map(int,input().split())", "map(int,input().split())", "m", "cnt+=1", "1", "cnt", "cnt=0", "0", "cnt", "y=[0]*m,[0]*m", "[0]*m", "y", "n,m=map(int,input().split())", "map(int,input().split())", "n", "x,y=[0]*m,[0]*m", "[0]*m", "x", "res=[1]*n", "[1]*n", "res" ]

[ 7, 41, 28, 13, 4, 13, 17, 4, 4, 13, 13, 4, 18, 13, 13, 0, 39, 13, 13, 13, 31, 13, 0, 13, 2, 39, 17, 13, 0, 13, 2, 39, 17, 13, 0, 18, 13, 17, 17, 28, 13, 13, 13, 0, 13, 17, 0, 13, 17, 0, 18, 13, 13, 17, 0, 18, 13, 13, 17, 14, 18, 13, 13, 0, 18, 13, 13, 17, 14, 2, 18, 13, 13, 17, 0, 18, 13, 13, 17, 4, 13, 4, 13, 13, 10, 17, 13, 10, 2, 13, 10, 17, 13, 10, 2, 13 ]

[ [ 4, 3 ], [ 3, 13 ], [ 19, 16 ], [ 19, 20 ], [ 88, 23 ], [ 94, 29 ], [ 38, 35 ], [ 95, 36 ], [ 85, 44 ], [ 91, 47 ], [ 53, 50 ], [ 89, 51 ], [ 86, 52 ], [ 58, 55 ], [ 89, 56 ], [ 92, 57 ], [ 95, 61 ], [ 86, 62 ], [ 67, 64 ], [ 95, 65 ], [ 92, 66 ], [ 50, 70 ], [ 89, 71 ], [ 86, 72 ], [ 78, 75 ], [ 95, 76 ], [ 86, 77 ], [ 95, 83 ], [ 85, 86 ], [ 88, 89 ], [ 91, 92 ], [ 94, 95 ] ]

[ "(N, M), *AB = [map(int, s.split()) for s in open(0)]\ncnt = [1] * N\npossibly_red = [False] * N\npossibly_red[0] = True\nfor a, b in AB:\n a -= 1\n b -= 1\n cnt[a] -= 1\n cnt[b] += 1\n if possibly_red[a]:\n possibly_red[b] = True\n if cnt[a] == 0:\n possibly_red[a] = False\nprint(sum(possibly_red))", "map(int, s.split()) for s in open(0)", "for s in open(0)", "s", "open(0)", "open", "0", "for s in open(0)", "map(int, s.split())", "map", "int", "s.split()", "s.split", "s", "split", "(N, M), *AB = [map(int, s.split()) for s in open(0)]", "(N, M)", "N", "M", "[map(int, s.split()) for s in open(0)]", "*AB", "AB", "cnt = [1] * N", "cnt", "[1] * N", "[1]", "1", "N", "possibly_red = [False] * N", "possibly_red", "[False] * N", "[False]", "False", "N", "possibly_red[0] = True", "possibly_red[0]", "possibly_red", "0", "True", "for a, b in AB:\n a -= 1\n b -= 1\n cnt[a] -= 1\n cnt[b] += 1\n if possibly_red[a]:\n possibly_red[b] = True\n if cnt[a] == 0:\n possibly_red[a] = False", "a", "b", "AB", "a -= 1", "a", "1", "b -= 1", "b", "1", "cnt[a] -= 1", "cnt[a]", "cnt", "a", "1", "cnt[b] += 1", "cnt[b]", "cnt", "b", "1", "if possibly_red[a]:\n possibly_red[b] = True\n if cnt[a] == 0:\n possibly_red[a] = False", "possibly_red[a]", "possibly_red", "a", "possibly_red[b] = True", "possibly_red[b]", "possibly_red", "b", "True", "if cnt[a] == 0:\n possibly_red[a] = False", "cnt[a] == 0", "cnt[a]", "cnt", "a", "0", "possibly_red[a] = False", "possibly_red[a]", "possibly_red", "a", "False", "print(sum(possibly_red))", "print", "sum(possibly_red)", "sum", "possibly_red", "a -= 1", "1", "a", "cnt = [1] * N", "[1] * N", "cnt", "b -= 1", "1", "b", "possibly_red = [False] * N", "[False] * N", "possibly_red" ]

[ 7, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 13, 15, 13, 4, 18, 13, 13, 2, 17, 17, 12, 13, 12, 13, 12, 13, 12, 13, 0, 13, 4, 13, 13, 0, 13, 39, 28, 13, 4, 13, 13, 0, 13, 4, 13, 13, 4, 18, 13, 13, 39, 2, 13, 17, 2, 13, 17, 0, 13, 2, 39, 17, 13, 0, 13, 2, 39, 17, 13, 0, 13, 2, 39, 17, 13, 0, 18, 13, 17, 17, 0, 18, 13, 17, 17, 28, 13, 13, 0, 18, 13, 18, 13, 17, 17, 0, 18, 13, 18, 13, 17, 17, 14, 2, 2, 18, 13, 18, 13, 17, 17, 2, 18, 13, 18, 13, 17, 17, 0, 18, 13, 18, 13, 17, 17, 0, 18, 13, 18, 13, 17, 17, 14, 2, 2, 18, 13, 18, 13, 17, 17, 2, 18, 13, 18, 13, 17, 17, 0, 18, 13, 18, 13, 17, 17, 0, 18, 13, 18, 13, 17, 17, 14, 2, 2, 18, 13, 18, 13, 17, 17, 2, 18, 13, 18, 13, 17, 17, 0, 18, 13, 18, 13, 17, 17, 0, 18, 13, 18, 13, 17, 17, 14, 2, 18, 13, 18, 13, 17, 17, 0, 18, 13, 18, 13, 17, 17, 0, 18, 13, 18, 13, 17, 17, 0, 13, 4, 13, 13, 4, 13, 13, 10, 12, 13, 10, 39, 13, 10, 4, 13, 10, 2, 13, 10, 4, 13, 10, 12, 13, 10, 12, 13, 10, 4, 13, 10, 2, 13, 10, 12, 13, 10, 4, 13, 10, 2, 13, 10, 4, 13 ]

[ [ 246, 31 ], [ 241, 33 ], [ 246, 34 ], [ 228, 36 ], [ 40, 39 ], [ 238, 42 ], [ 255, 44 ], [ 241, 46 ], [ 255, 47 ], [ 229, 50 ], [ 256, 54 ], [ 232, 57 ], [ 249, 60 ], [ 247, 64 ], [ 258, 66 ], [ 247, 70 ], [ 234, 72 ], [ 247, 76 ], [ 81, 78 ], [ 250, 79 ], [ 86, 83 ], [ 259, 84 ], [ 89, 88 ], [ 229, 88 ], [ 96, 91 ], [ 235, 92 ], [ 88, 94 ], [ 103, 98 ], [ 235, 99 ], [ 88, 101 ], [ 250, 108 ], [ 88, 110 ], [ 259, 115 ], [ 88, 117 ], [ 126, 121 ], [ 250, 122 ], [ 88, 124 ], [ 133, 128 ], [ 250, 129 ], [ 88, 131 ], [ 250, 138 ], [ 88, 140 ], [ 259, 145 ], [ 88, 147 ], [ 156, 151 ], [ 259, 152 ], [ 88, 154 ], [ 163, 158 ], [ 259, 159 ], [ 88, 161 ], [ 250, 168 ], [ 88, 170 ], [ 259, 175 ], [ 88, 177 ], [ 186, 181 ], [ 250, 182 ], [ 88, 184 ], [ 193, 188 ], [ 259, 189 ], [ 88, 191 ], [ 235, 197 ], [ 88, 199 ], [ 215, 203 ], [ 250, 204 ], [ 88, 206 ], [ 215, 210 ], [ 259, 211 ], [ 88, 213 ], [ 261, 217 ], [ 250, 220 ], [ 262, 223 ], [ 228, 229 ], [ 255, 232 ], [ 234, 235 ], [ 246, 238 ], [ 246, 247 ], [ 249, 250 ], [ 255, 256 ], [ 258, 259 ], [ 261, 262 ] ]

[ "from math import ceil,floor,factorial,gcd,sqrt,log2,cos,sin,tan,acos,asin,atan,degrees,radians,pi,inf,comb\nfrom itertools import accumulate,groupby,permutations,combinations,product,combinations_with_replacement\nfrom collections import deque,defaultdict,Counter\nfrom bisect import bisect_left,bisect_right\nfrom operator import itemgetter\nfrom heapq import heapify,heappop,heappush\nfrom queue import Queue,LifoQueue,PriorityQueue\nfrom copy import deepcopy\nfrom time import time\nfrom functools import reduce\nimport string\nimport sys\nsys.setrecursionlimit(10 ** 7)\ndef input() : return sys.stdin.readline().strip()\ndef INT() : return int(input())\ndef MAP() : return map(int,input().split())\ndef LIST() : return list(MAP())\n\nn, m = MAP()\nx = []\nfor i in range(m):\n x0, x1 = MAP()\n x.append([x0-1, x1-1])\n\nr = [0]*n\nw = [1]*n\nt = [1]*n\nr[0] = 1\nw[0] = 0\n\nfor y in x:\n t[y[0]] -= 1\n t[y[1]] += 1\n\n if r[y[0]] > 0 and w[y[0]] == 0:\n r[y[0]] = 0\n r[y[1]] = 1\n elif r[y[0]] == 0 and w[y[0]] > 0:\n w[y[0]] -= 1\n w[y[1]] += 1\n elif r[y[0]] > 0 and w[y[0]] > 0:\n r[y[1]] = 1\n w[y[1]] += 1\n if t[y[0]] == 0:\n r[y[0]] = w[y[0]] = 0\n\nans = sum(r)\nprint(ans)", "from math import ceil,floor,factorial,gcd,sqrt,log2,cos,sin,tan,acos,asin,atan,degrees,radians,pi,inf,comb", "from itertools import accumulate,groupby,permutations,combinations,product,combinations_with_replacement", "from collections import deque,defaultdict,Counter", "from bisect import bisect_left,bisect_right", "from operator import itemgetter", "from heapq import heapify,heappop,heappush", "from queue import Queue,LifoQueue,PriorityQueue", "from copy import deepcopy", "from time import time", "from functools import reduce", "import string", "string", "import sys", "sys", "sys.setrecursionlimit(10 ** 7)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "10 ** 7", "10", "7", "def input() : return sys.stdin.readline().strip()", "input", "def INT() : return int(input())", "INT", "def MAP() : return map(int,input().split())", "MAP", "def LIST() : return list(MAP())", "LIST", "n, m = MAP()", "n", "MAP()", "MAP", "m", "x = []", "x", "[]", "for i in range(m):\n x0, x1 = MAP()\n x.append([x0-1, x1-1])", "i", "range(m)", "range", "m", "x0, x1 = MAP()", "x0", "MAP()", "MAP", "x1", "x.append([x0-1, x1-1])", "x.append", "x", "append", "[x0-1, x1-1]", "x0-1", "x0", "1", "x1-1", "x1", "1", "r = [0]*n", "r", "[0]*n", "[0]", "0", "n", "w = [1]*n", "w", "[1]*n", "[1]", "1", "n", "t = [1]*n", "t", "[1]*n", "[1]", "1", "n", "r[0] = 1", "r[0]", "r", "0", "1", "w[0] = 0", "w[0]", "w", "0", "0", "for y in x:\n t[y[0]] -= 1\n t[y[1]] += 1\n\n if r[y[0]] > 0 and w[y[0]] == 0:\n r[y[0]] = 0\n r[y[1]] = 1\n elif r[y[0]] == 0 and w[y[0]] > 0:\n w[y[0]] -= 1\n w[y[1]] += 1\n elif r[y[0]] > 0 and w[y[0]] > 0:\n r[y[1]] = 1\n w[y[1]] += 1\n if t[y[0]] == 0:\n r[y[0]] = w[y[0]] = 0", "y", "x", "t[y[0]] -= 1", "t[y[0]]", "t", "y[0]", "y", "0", "1", "t[y[1]] += 1", "t[y[1]]", "t", "y[1]", "y", "1", "1", "if r[y[0]] > 0 and w[y[0]] == 0:\n r[y[0]] = 0\n r[y[1]] = 1\n elif r[y[0]] == 0 and w[y[0]] > 0:\n w[y[0]] -= 1\n w[y[1]] += 1\n elif r[y[0]] > 0 and w[y[0]] > 0:\n r[y[1]] = 1\n w[y[1]] += 1\n ", "r[y[0]] > 0 and w[y[0]] == 0", "r[y[0]] > 0", "r[y[0]]", "r", "y[0]", "y", "0", "0", "w[y[0]] == 0", "w[y[0]]", "w", "y[0]", "y", "0", "0", "r[y[0]] = 0", "r[y[0]]", "r", "y[0]", "y", "0", "0", "r[y[1]] = 1", "r[y[1]]", "r", "y[1]", "y", "1", "1", "elif r[y[0]] == 0 and w[y[0]] > 0:\n w[y[0]] -= 1\n w[y[1]] += 1\n ", "r[y[0]] == 0 and w[y[0]] > 0", "r[y[0]] == 0", "r[y[0]]", "r", "y[0]", "y", "0", "0", "w[y[0]] > 0", "w[y[0]]", "w", "y[0]", "y", "0", "0", "w[y[0]] -= 1", "w[y[0]]", "w", "y[0]", "y", "0", "1", "w[y[1]] += 1", "w[y[1]]", "w", "y[1]", "y", "1", "1", "elif r[y[0]] > 0 and w[y[0]] > 0:\n r[y[1]] = 1\n w[y[1]] += 1\n ", "r[y[0]] > 0 and w[y[0]] > 0", "r[y[0]] > 0", "r[y[0]]", "r", "y[0]", "y", "0", "0", "w[y[0]] > 0", "w[y[0]]", "w", "y[0]", "y", "0", "0", "r[y[1]] = 1", "r[y[1]]", "r", "y[1]", "y", "1", "1", "w[y[1]] += 1", "w[y[1]]", "w", "y[1]", "y", "1", "1", "if t[y[0]] == 0:\n r[y[0]] = w[y[0]] = 0", "t[y[0]] == 0", "t[y[0]]", "t", "y[0]", "y", "0", "0", "r[y[0]] = w[y[0]] = 0", "r[y[0]]", "r", "y[0]", "y", "0", "0", "= w[y[0]] = 0", "w[y[0]]", "w", "y[0]", "y", "0", "0", "ans = sum(r)", "ans", "sum(r)", "sum", "r", "print(ans)", "print", "ans", "def INT() : return int(input())", "def INT() : return int(input())", "INT", "x = []", "[]", "x", "x1 = MAP()", "MAP()", "x1", "t = [1]*n", "[1]*n", "t", "m = MAP()", "MAP()", "m", "def MAP() : return map(int,input().split())", "def MAP() : return map(int,input().split())", "MAP", "def LIST() : return list(MAP())", "def LIST() : return list(MAP())", "LIST", "n, m = MAP()", "MAP()", "n", "r = [0]*n", "[0]*n", "r", "def input() : return sys.stdin.readline().strip()", "def input() : return sys.stdin.readline().strip()", "input", "x0, x1 = MAP()", "MAP()", "x0", "w = [1]*n", "[1]*n", "w", "ans = sum(r)", "sum(r)", "ans" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 2, 39, 17, 13, 0, 18, 13, 17, 17, 0, 13, 2, 39, 17, 13, 28, 13, 4, 13, 13, 0, 13, 4, 13, 12, 2, 4, 13, 13, 17, 23, 4, 18, 4, 13, 13, 13, 0, 18, 13, 13, 2, 18, 13, 13, 18, 13, 13, 0, 18, 13, 13, 17, 0, 18, 13, 13, 17, 14, 2, 18, 13, 13, 17, 0, 18, 13, 13, 17, 4, 13, 4, 13, 13, 10, 4, 13, 10, 4, 13, 10, 2, 13, 10, 4, 13, 10, 2, 13, 10, 4, 13 ]

[ [ 98, 2 ], [ 98, 11 ], [ 95, 13 ], [ 99, 17 ], [ 22, 19 ], [ 96, 20 ], [ 101, 24 ], [ 99, 28 ], [ 31, 30 ], [ 93, 33 ], [ 104, 35 ], [ 104, 50 ], [ 55, 52 ], [ 96, 53 ], [ 105, 54 ], [ 52, 56 ], [ 96, 57 ], [ 105, 58 ], [ 79, 59 ], [ 96, 60 ], [ 90, 61 ], [ 66, 63 ], [ 102, 64 ], [ 105, 65 ], [ 71, 68 ], [ 102, 69 ], [ 90, 70 ], [ 68, 74 ], [ 102, 75 ], [ 90, 76 ], [ 82, 79 ], [ 96, 80 ], [ 90, 81 ], [ 96, 87 ], [ 104, 90 ], [ 98, 93 ], [ 95, 96 ], [ 98, 99 ], [ 101, 102 ], [ 104, 105 ] ]

[ "N,M = map(int,input().split())\n\ndp = [False]*N\ndp[0] = True\ncnt = [1]*N\n\nfor _ in range(M):\n x,y = map(lambda x:int(x)-1,input().split())\n dp[y] = dp[y] or dp[x]\n cnt[y] += 1\n cnt[x] -= 1\n if cnt[x] == 0:\n dp[x] = False\n\nprint(sum(dp))", "N,M = map(int,input().split())", "N", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "M", "dp = [False]*N", "dp", "[False]*N", "[False]", "False", "N", "dp[0] = True", "dp[0]", "dp", "0", "True", "cnt = [1]*N", "cnt", "[1]*N", "[1]", "1", "N", "for _ in range(M):\n x,y = map(lambda x:int(x)-1,input().split())\n dp[y] = dp[y] or dp[x]\n cnt[y] += 1\n cnt[x] -= 1\n if cnt[x] == 0:\n dp[x] = False", "_", "range(M)", "range", "M", "x,y = map(lambda x:int(x)-1,input().split())", "x", "map(lambda x:int(x)-1,input().split())", "map", "lambda x:int(x)-1", "int(x)-1", "int(x)", "int", "x", "1", "x", "input().split()", "().split", "()", "input", "split", "y", "dp[y] = dp[y] or dp[x]", "dp[y]", "dp", "y", "dp[y] or dp[x]", "dp[y]", "dp", "y", "dp[x]", "dp", "x", "cnt[y] += 1", "cnt[y]", "cnt", "y", "1", "cnt[x] -= 1", "cnt[x]", "cnt", "x", "1", "if cnt[x] == 0:\n dp[x] = False", "cnt[x] == 0", "cnt[x]", "cnt", "x", "0", "dp[x] = False", "dp[x]", "dp", "x", "False", "print(sum(dp))", "print", "sum(dp)", "sum", "dp", "x,y = map(lambda x:int(x)-1,input().split())", "map(lambda x:int(x)-1,input().split())", "x", "M = map(int,input().split())", "map(int,input().split())", "M", "dp = [False]*N", "[False]*N", "dp", "N,M = map(int,input().split())", "map(int,input().split())", "N", "cnt = [1]*N", "[1]*N", "cnt", "y = map(lambda x:int(x)-1,input().split())", "map(lambda x:int(x)-1,input().split())", "y" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 41, 28, 13, 4, 13, 13, 4, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 0, 13, 13, 0, 13, 2, 39, 17, 13, 0, 18, 13, 17, 17, 0, 13, 2, 39, 17, 13, 28, 13, 13, 13, 0, 13, 17, 0, 13, 17, 14, 2, 18, 13, 13, 17, 0, 18, 13, 13, 17, 0, 18, 13, 13, 17, 0, 18, 13, 13, 17, 14, 2, 18, 13, 13, 17, 0, 18, 13, 13, 17, 0, 13, 17, 28, 13, 13, 14, 2, 13, 17, 0, 13, 17, 4, 13, 13, 10, 17, 13, 10, 2, 13, 10, 4, 13, 10, 4, 13, 10, 17, 13, 10, 17, 13, 10, 13, 13, 10, 17, 13, 10, 2, 13 ]

[ [ 117, 2 ], [ 117, 11 ], [ 15, 14 ], [ 118, 17 ], [ 126, 30 ], [ 132, 33 ], [ 115, 37 ], [ 42, 39 ], [ 133, 40 ], [ 111, 44 ], [ 115, 48 ], [ 108, 54 ], [ 120, 57 ], [ 87, 61 ], [ 133, 62 ], [ 109, 63 ], [ 69, 66 ], [ 133, 67 ], [ 121, 68 ], [ 74, 71 ], [ 112, 72 ], [ 109, 73 ], [ 79, 76 ], [ 112, 77 ], [ 121, 78 ], [ 71, 82 ], [ 112, 83 ], [ 109, 84 ], [ 90, 87 ], [ 133, 88 ], [ 109, 89 ], [ 123, 92 ], [ 96, 95 ], [ 133, 95 ], [ 95, 99 ], [ 129, 102 ], [ 130, 106 ], [ 124, 106 ], [ 108, 109 ], [ 111, 112 ], [ 117, 115 ], [ 117, 118 ], [ 120, 121 ], [ 123, 124 ], [ 126, 127 ], [ 129, 130 ], [ 132, 133 ] ]

[ "n, m = map(int, input().split())\nmat = [list(map(int, input().split())) for _ in range(m)]\n\nred = [False]*n\nred[0] = True\nballs = [1]*n\n\nfor x, y in mat:\n x -= 1\n y -= 1\n if red[x] is True:\n red[y] = True\n balls[x] -= 1\n balls[y] += 1\n if balls[x] == 0:\n red[x] = False\n\nans = 0\nfor r in red:\n if r is True:\n ans += 1\nprint(ans)", "n, m = map(int, input().split())", "n", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "m", "list(map(int, input().split())) for _ in range(m)", "for _ in range(m)", "_", "range(m)", "range", "m", "for _ in range(m)", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "mat = [list(map(int, input().split())) for _ in range(m)]", "mat", "[list(map(int, input().split())) for _ in range(m)]", "red = [False]*n", "red", "[False]*n", "[False]", "False", "n", "red[0] = True", "red[0]", "red", "0", "True", "balls = [1]*n", "balls", "[1]*n", "[1]", "1", "n", "for x, y in mat:\n x -= 1\n y -= 1\n if red[x] is True:\n red[y] = True\n balls[x] -= 1\n balls[y] += 1\n if balls[x] == 0:\n red[x] = False", "x", "y", "mat", "x -= 1", "x", "1", "y -= 1", "y", "1", "if red[x] is True:\n red[y] = True\n ", "red[x] is True", "red[x]", "red", "x", "True", "red[y] = True", "red[y]", "red", "y", "True", "balls[x] -= 1", "balls[x]", "balls", "x", "1", "balls[y] += 1", "balls[y]", "balls", "y", "1", "if balls[x] == 0:\n red[x] = False", "balls[x] == 0", "balls[x]", "balls", "x", "0", "red[x] = False", "red[x]", "red", "x", "False", "ans = 0", "ans", "0", "for r in red:\n if r is True:\n ans += 1", "r", "red", "if r is True:\n ans += 1", "r is True", "r", "True", "ans += 1", "ans", "1", "print(ans)", "print", "ans", "x -= 1", "1", "x", "balls = [1]*n", "[1]*n", "balls", "n, m = map(int, input().split())", "map(int, input().split())", "n", "m = map(int, input().split())", "map(int, input().split())", "m", "y -= 1", "1", "y", "ans = 0", "0", "ans", "mat = [list(map(int, input().split())) for _ in range(m)]", "[list(map(int, input().split())) for _ in range(m)]", "mat", "ans += 1", "1", "ans", "red = [False]*n", "[False]*n", "red" ]

[ 7, 12, 13, 0, 13, 4, 13, 4, 13, 12, 2, 13, 17, 23, 13, 0, 13, 4, 13, 4, 13, 12, 2, 13, 17, 23, 13, 0, 13, 2, 39, 17, 13, 0, 18, 13, 17, 17, 0, 13, 2, 39, 17, 13, 28, 13, 4, 13, 13, 14, 2, 18, 13, 18, 13, 13, 17, 14, 2, 18, 13, 18, 13, 13, 17, 0, 18, 13, 18, 13, 13, 17, 14, 2, 18, 13, 18, 13, 13, 17, 0, 18, 13, 18, 13, 13, 17, 0, 18, 13, 18, 13, 13, 17, 0, 18, 13, 18, 13, 13, 17, 0, 18, 13, 18, 13, 13, 17, 29, 4, 13, 13, 23, 13, 23, 13, 23, 13, 23, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 2, 39, 17, 13, 0, 13, 2, 39, 17, 13, 28, 13, 4, 13, 13, 0, 18, 13, 13, 4, 13, 13, 4, 18, 4, 13, 13, 18, 13, 13, 4, 13, 4, 13, 13, 13, 13, 13, 10, 2, 13, 10, 12, 13, 10, 4, 13, 10, 2, 13, 10, 4, 13 ]

[ [ 5, 4 ], [ 117, 14 ], [ 17, 16 ], [ 119, 26 ], [ 29, 28 ], [ 113, 32 ], [ 37, 34 ], [ 28, 35 ], [ 40, 39 ], [ 113, 43 ], [ 46, 45 ], [ 115, 48 ], [ 95, 51 ], [ 39, 52 ], [ 4, 54 ], [ 117, 54 ], [ 45, 55 ], [ 88, 59 ], [ 28, 60 ], [ 4, 62 ], [ 117, 62 ], [ 45, 63 ], [ 71, 66 ], [ 28, 67 ], [ 16, 69 ], [ 119, 69 ], [ 45, 70 ], [ 88, 74 ], [ 28, 75 ], [ 4, 77 ], [ 117, 77 ], [ 45, 78 ], [ 86, 81 ], [ 28, 82 ], [ 16, 84 ], [ 119, 84 ], [ 45, 85 ], [ 93, 88 ], [ 28, 89 ], [ 4, 91 ], [ 117, 91 ], [ 45, 92 ], [ 100, 95 ], [ 39, 96 ], [ 4, 98 ], [ 117, 98 ], [ 45, 99 ], [ 107, 102 ], [ 39, 103 ], [ 16, 105 ], [ 119, 105 ], [ 45, 106 ], [ 28, 111 ], [ 113, 113 ], [ 115, 115 ], [ 117, 117 ], [ 119, 119 ], [ 184, 121 ], [ 184, 130 ], [ 181, 132 ], [ 179, 136 ], [ 172, 138 ], [ 179, 142 ], [ 145, 144 ], [ 179, 147 ], [ 152, 149 ], [ 182, 150 ], [ 144, 151 ], [ 152, 160 ], [ 173, 161 ], [ 144, 162 ], [ 176, 166 ], [ 185, 167 ], [ 179, 168 ], [ 182, 169 ], [ 173, 170 ], [ 172, 173 ], [ 184, 179 ], [ 181, 182 ], [ 184, 185 ] ]

[ "def solve(n, m, x, y):\n x = list(map(lambda _:_-1, x))\n y = list(map(lambda _:_-1, y))\n p = [0] * n\n p[0] = 1\n c = [1] * n\n for i in range(m):\n if c[x[i]] > 1:\n if p[x[i]] == 1:\n p[y[i]] = 1\n else:\n if p[x[i]] == 1:\n p[y[i]] = 1\n p[x[i]] = 0\n c[x[i]] -= 1\n c[y[i]] += 1\n return sum(p)\n\nn, m = map(int, input().split())\nx = [0] * m\ny = [0] * m\nfor i in range(m):\n x[i], y[i] = map(int, input().split())\nprint(solve(n, m, x, y))", "def solve(n, m, x, y):\n x = list(map(lambda _:_-1, x))\n y = list(map(lambda _:_-1, y))\n p = [0] * n\n p[0] = 1\n c = [1] * n\n for i in range(m):\n if c[x[i]] > 1:\n if p[x[i]] == 1:\n p[y[i]] = 1\n else:\n if p[x[i]] == 1:\n p[y[i]] = 1\n p[x[i]] = 0\n c[x[i]] -= 1\n c[y[i]] += 1\n return sum(p)", "solve", "x = list(map(lambda _:_-1, x))", "x", "list(map(lambda _:_-1, x))", "list", "map(lambda _:_-1, x)", "map", "lambda _:_-1", "_-1", "_", "1", "_", "x", "y = list(map(lambda _:_-1, y))", "y", "list(map(lambda _:_-1, y))", "list", "map(lambda _:_-1, y)", "map", "lambda _:_-1", "_-1", "_", "1", "_", "y", "p = [0] * n", "p", "[0] * n", "[0]", "0", "n", "p[0] = 1", "p[0]", "p", "0", "1", "c = [1] * n", "c", "[1] * n", "[1]", "1", "n", "for i in range(m):\n if c[x[i]] > 1:\n if p[x[i]] == 1:\n p[y[i]] = 1\n else:\n if p[x[i]] == 1:\n p[y[i]] = 1\n p[x[i]] = 0\n c[x[i]] -= 1\n c[y[i]] += 1\n ", "i", "range(m)", "range", "m", "if c[x[i]] > 1:\n if p[x[i]] == 1:\n p[y[i]] = 1\n else:\n if p[x[i]] == 1:\n p[y[i]] = 1\n p[x[i]] = 0\n ", "c[x[i]] > 1", "c[x[i]]", "c", "x[i]", "x", "i", "1", "if p[x[i]] == 1:\n p[y[i]] = 1\n ", "p[x[i]] == 1", "p[x[i]]", "p", "x[i]", "x", "i", "1", "p[y[i]] = 1", "p[y[i]]", "p", "y[i]", "y", "i", "1", "if p[x[i]] == 1:\n p[y[i]] = 1\n ", "p[x[i]] == 1", "p[x[i]]", "p", "x[i]", "x", "i", "1", "p[y[i]] = 1", "p[y[i]]", "p", "y[i]", "y", "i", "1", "p[x[i]] = 0", "p[x[i]]", "p", "x[i]", "x", "i", "0", "c[x[i]] -= 1", "c[x[i]]", "c", "x[i]", "x", "i", "1", "c[y[i]] += 1", "c[y[i]]", "c", "y[i]", "y", "i", "1", "return sum(p)", "sum(p)", "sum", "p", "n", "n", "m", "m", "x", "x", "y", "y", "n, m = map(int, input().split())", "n", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "m", "x = [0] * m", "x", "[0] * m", "[0]", "0", "m", "y = [0] * m", "y", "[0] * m", "[0]", "0", "m", "for i in range(m):\n x[i], y[i] = map(int, input().split())", "i", "range(m)", "range", "m", "x[i], y[i] = map(int, input().split())", "x[i]", "x", "i", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "y[i]", "y", "i", "print(solve(n, m, x, y))", "print", "solve(n, m, x, y)", "solve", "n", "m", "x", "y", "y = [0] * m", "[0] * m", "y", "def solve(n, m, x, y):\n x = list(map(lambda _:_-1, x))\n y = list(map(lambda _:_-1, y))\n p = [0] * n\n p[0] = 1\n c = [1] * n\n for i in range(m):\n if c[x[i]] > 1:\n if p[x[i]] == 1:\n p[y[i]] = 1\n else:\n if p[x[i]] == 1:\n p[y[i]] = 1\n p[x[i]] = 0\n c[x[i]] -= 1\n c[y[i]] += 1\n return sum(p)", "def solve(n, m, x, y):\n x = list(map(lambda _:_-1, x))\n y = list(map(lambda _:_-1, y))\n p = [0] * n\n p[0] = 1\n c = [1] * n\n for i in range(m):\n if c[x[i]] > 1:\n if p[x[i]] == 1:\n p[y[i]] = 1\n else:\n if p[x[i]] == 1:\n p[y[i]] = 1\n p[x[i]] = 0\n c[x[i]] -= 1\n c[y[i]] += 1\n return sum(p)", "solve", "m = map(int, input().split())", "map(int, input().split())", "m", "x = [0] * m", "[0] * m", "x", "n, m = map(int, input().split())", "map(int, input().split())", "n" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 2, 39, 17, 13, 0, 13, 2, 39, 17, 13, 0, 18, 13, 17, 17, 28, 13, 4, 13, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 17, 0, 13, 17, 14, 2, 18, 13, 13, 17, 14, 2, 18, 13, 13, 17, 0, 18, 13, 13, 17, 0, 18, 13, 13, 17, 0, 18, 13, 13, 17, 0, 18, 13, 13, 17, 0, 18, 13, 13, 17, 0, 13, 17, 28, 13, 4, 13, 13, 14, 2, 18, 13, 13, 17, 0, 13, 17, 4, 13, 13, 10, 2, 13, 10, 4, 13, 10, 4, 13, 10, 17, 13, 10, 17, 13, 10, 2, 13, 10, 17, 13, 10, 4, 13, 10, 4, 13, 10, 17, 13 ]

[ [ 133, 2 ], [ 133, 11 ], [ 124, 13 ], [ 134, 17 ], [ 109, 19 ], [ 134, 23 ], [ 28, 25 ], [ 110, 26 ], [ 31, 30 ], [ 113, 33 ], [ 130, 35 ], [ 130, 44 ], [ 118, 46 ], [ 136, 49 ], [ 64, 53 ], [ 110, 54 ], [ 119, 55 ], [ 116, 55 ], [ 79, 59 ], [ 125, 60 ], [ 119, 61 ], [ 116, 61 ], [ 67, 64 ], [ 110, 65 ], [ 119, 66 ], [ 116, 66 ], [ 72, 69 ], [ 110, 70 ], [ 137, 71 ], [ 131, 71 ], [ 77, 74 ], [ 110, 75 ], [ 137, 76 ], [ 131, 76 ], [ 82, 79 ], [ 125, 80 ], [ 119, 81 ], [ 116, 81 ], [ 87, 84 ], [ 125, 85 ], [ 137, 86 ], [ 131, 86 ], [ 121, 89 ], [ 93, 92 ], [ 134, 95 ], [ 110, 99 ], [ 92, 100 ], [ 127, 103 ], [ 128, 107 ], [ 122, 107 ], [ 109, 110 ], [ 133, 113 ], [ 130, 116 ], [ 118, 119 ], [ 121, 122 ], [ 124, 125 ], [ 127, 128 ], [ 130, 131 ], [ 133, 134 ], [ 136, 137 ] ]

[ "n_box, n_move = map(int,input().split())\nnum_balls = [1] * n_box\ncan_red = [0] * n_box\ncan_red[0] = 1\nfor i in range(n_move):\n From, to = map(int,input().split())\n From -= 1\n to -= 1\n if can_red[From] == 1:\n if num_balls[From] == 1:\n can_red[From] = 0\n can_red[to] = 1\n else:\n can_red[to] = 1\n num_balls[From] -= 1\n num_balls[to] += 1\n\nans = 0\nfor i in range(n_box):\n if can_red[i] == 1:\n ans += 1\nprint(ans)\n", "n_box, n_move = map(int,input().split())", "n_box", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "n_move", "num_balls = [1] * n_box", "num_balls", "[1] * n_box", "[1]", "1", "n_box", "can_red = [0] * n_box", "can_red", "[0] * n_box", "[0]", "0", "n_box", "can_red[0] = 1", "can_red[0]", "can_red", "0", "1", "for i in range(n_move):\n From, to = map(int,input().split())\n From -= 1\n to -= 1\n if can_red[From] == 1:\n if num_balls[From] == 1:\n can_red[From] = 0\n can_red[to] = 1\n else:\n can_red[to] = 1\n num_balls[From] -= 1\n num_balls[to] += 1", "i", "range(n_move)", "range", "n_move", "From, to = map(int,input().split())", "From", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "to", "From -= 1", "From", "1", "to -= 1", "to", "1", "if can_red[From] == 1:\n if num_balls[From] == 1:\n can_red[From] = 0\n can_red[to] = 1\n else:\n can_red[to] = 1\n ", "can_red[From] == 1", "can_red[From]", "can_red", "From", "1", "if num_balls[From] == 1:\n can_red[From] = 0\n can_red[to] = 1\n else:\n can_red[to] = 1\n ", "num_balls[From] == 1", "num_balls[From]", "num_balls", "From", "1", "can_red[From] = 0", "can_red[From]", "can_red", "From", "0", "can_red[to] = 1", "can_red[to]", "can_red", "to", "1", "can_red[to] = 1", "can_red[to]", "can_red", "to", "1", "num_balls[From] -= 1", "num_balls[From]", "num_balls", "From", "1", "num_balls[to] += 1", "num_balls[to]", "num_balls", "to", "1", "ans = 0", "ans", "0", "for i in range(n_box):\n if can_red[i] == 1:\n ans += 1", "i", "range(n_box)", "range", "n_box", "if can_red[i] == 1:\n ans += 1", "can_red[i] == 1", "can_red[i]", "can_red", "i", "1", "ans += 1", "ans", "1", "print(ans)", "print", "ans", "can_red = [0] * n_box", "[0] * n_box", "can_red", "n_move = map(int,input().split())", "map(int,input().split())", "n_move", "From, to = map(int,input().split())", "map(int,input().split())", "From", "From -= 1", "1", "From", "ans = 0", "0", "ans", "num_balls = [1] * n_box", "[1] * n_box", "num_balls", "ans += 1", "1", "ans", "to = map(int,input().split())", "map(int,input().split())", "to", "n_box, n_move = map(int,input().split())", "map(int,input().split())", "n_box", "to -= 1", "1", "to" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 39, 28, 13, 4, 13, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 4, 18, 13, 13, 39, 13, 13, 0, 13, 2, 39, 17, 13, 0, 13, 2, 39, 17, 13, 0, 18, 13, 17, 17, 28, 13, 4, 13, 13, 14, 40, 18, 13, 2, 18, 18, 13, 13, 17, 17, 17, 14, 2, 18, 13, 2, 18, 18, 13, 13, 17, 17, 17, 0, 18, 13, 2, 18, 18, 13, 13, 17, 17, 17, 0, 18, 13, 2, 18, 18, 13, 13, 17, 17, 17, 0, 18, 13, 2, 18, 18, 13, 13, 17, 17, 17, 0, 18, 13, 2, 18, 18, 13, 13, 17, 17, 17, 0, 13, 2, 4, 13, 13, 4, 18, 13, 13, 17, 4, 13, 13, 10, 2, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 2, 13, 10, 2, 13, 10, 39, 13 ]

[ [ 155, 2 ], [ 155, 11 ], [ 164, 13 ], [ 17, 16 ], [ 147, 19 ], [ 152, 21 ], [ 152, 30 ], [ 165, 33 ], [ 143, 39 ], [ 156, 43 ], [ 158, 45 ], [ 156, 49 ], [ 54, 51 ], [ 159, 52 ], [ 57, 56 ], [ 147, 59 ], [ 159, 63 ], [ 165, 67 ], [ 56, 68 ], [ 144, 75 ], [ 165, 79 ], [ 56, 80 ], [ 94, 85 ], [ 159, 86 ], [ 165, 90 ], [ 56, 91 ], [ 105, 96 ], [ 159, 97 ], [ 165, 101 ], [ 56, 102 ], [ 116, 107 ], [ 144, 108 ], [ 165, 112 ], [ 56, 113 ], [ 127, 118 ], [ 144, 119 ], [ 165, 123 ], [ 56, 124 ], [ 161, 129 ], [ 159, 133 ], [ 159, 136 ], [ 162, 141 ], [ 143, 144 ], [ 155, 147 ], [ 152, 150 ], [ 152, 153 ], [ 155, 156 ], [ 158, 159 ], [ 161, 162 ], [ 164, 165 ] ]

[ "n,m=map(int,input().split())\nxy=[]\nfor _ in range(m):\n x,y=map(int,input().split())\n xy.append([x,y])\n\nball=[1]*n\nred=[0]*n\nred[0]+=1\n\nfor i in range(m):\n if red[xy[i][0]-1]>=1:\n if ball[xy[i][0]-1]==1:\n red[xy[i][0]-1]=0\n red[xy[i][1]-1]+=1\n ball[xy[i][0]-1]-=1\n ball[xy[i][1]-1]+=1\n\nans=len(red)-red.count(0) \nprint(ans)", "n,m=map(int,input().split())", "n", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "m", "xy=[]", "xy", "[]", "for _ in range(m):\n x,y=map(int,input().split())\n xy.append([x,y])", "_", "range(m)", "range", "m", "x,y=map(int,input().split())", "x", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "y", "xy.append([x,y])", "xy.append", "xy", "append", "[x,y]", "x", "y", "ball=[1]*n", "ball", "[1]*n", "[1]", "1", "n", "red=[0]*n", "red", "[0]*n", "[0]", "0", "n", "red[0]+=1", "red[0]", "red", "0", "1", "for i in range(m):\n if red[xy[i][0]-1]>=1:\n if ball[xy[i][0]-1]==1:\n red[xy[i][0]-1]=0\n red[xy[i][1]-1]+=1\n ball[xy[i][0]-1]-=1\n ball[xy[i][1]-1]+=1", "i", "range(m)", "range", "m", "if red[xy[i][0]-1]>=1:\n if ball[xy[i][0]-1]==1:\n red[xy[i][0]-1]=0\n red[xy[i][1]-1]+=1\n ", "red[xy[i][0]-1]>=1", "red[xy[i][0]-1]", "red", "xy[i][0]-1", "xy[i][0]", "[i]", "xy", "i", "0", "1", "1", "if ball[xy[i][0]-1]==1:\n red[xy[i][0]-1]=0\n ", "ball[xy[i][0]-1]==1", "ball[xy[i][0]-1]", "ball", "xy[i][0]-1", "xy[i][0]", "[i]", "xy", "i", "0", "1", "1", "red[xy[i][0]-1]=0", "red[xy[i][0]-1]", "red", "xy[i][0]-1", "xy[i][0]", "[i]", "xy", "i", "0", "1", "0", "red[xy[i][1]-1]+=1", "red[xy[i][1]-1]", "red", "xy[i][1]-1", "xy[i][1]", "[i]", "xy", "i", "1", "1", "1", "ball[xy[i][0]-1]-=1", "ball[xy[i][0]-1]", "ball", "xy[i][0]-1", "xy[i][0]", "[i]", "xy", "i", "0", "1", "1", "ball[xy[i][1]-1]+=1", "ball[xy[i][1]-1]", "ball", "xy[i][1]-1", "xy[i][1]", "[i]", "xy", "i", "1", "1", "1", "ans=len(red)-red.count(0)", "ans", "len(red)-red.count(0)", "len(red)", "len", "red", "red.count(0)", "red.count", "red", "count", "0", "print(ans)", "print", "ans", "ball=[1]*n", "[1]*n", "ball", "m=map(int,input().split())", "map(int,input().split())", "m", "x,y=map(int,input().split())", "map(int,input().split())", "x", "y=map(int,input().split())", "map(int,input().split())", "y", "n,m=map(int,input().split())", "map(int,input().split())", "n", "red=[0]*n", "[0]*n", "red", "ans=len(red)-red.count(0)", "len(red)-red.count(0)", "ans", "xy=[]", "[]", "xy" ]

[ 7, 12, 13, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 41, 28, 13, 4, 13, 13, 4, 4, 13, 4, 13, 12, 2, 4, 13, 13, 17, 23, 4, 18, 4, 13, 13, 0, 13, 13, 0, 13, 2, 39, 17, 13, 0, 13, 2, 39, 17, 13, 0, 18, 13, 17, 17, 28, 13, 13, 13, 14, 2, 18, 13, 13, 17, 14, 2, 18, 13, 13, 17, 0, 18, 13, 13, 17, 0, 18, 13, 13, 17, 0, 18, 13, 13, 17, 0, 18, 13, 13, 17, 4, 13, 4, 13, 13, 14, 2, 13, 17, 4, 13, 10, 12, 13 ]

[ [ 5, 4 ], [ 5, 15 ], [ 19, 18 ], [ 15, 21 ], [ 41, 40 ], [ 44, 43 ], [ 4, 47 ], [ 50, 49 ], [ 4, 53 ], [ 58, 55 ], [ 49, 56 ], [ 76, 65 ], [ 49, 66 ], [ 86, 71 ], [ 43, 72 ], [ 79, 76 ], [ 49, 77 ], [ 84, 81 ], [ 49, 82 ], [ 89, 86 ], [ 43, 87 ], [ 94, 91 ], [ 43, 92 ], [ 49, 99 ], [ 108, 105 ] ]

[ "def main():\n N, M = list(map(int, input().split()))\n proc_list = [list(map(lambda z: int(z) - 1, input().split())) for _ in range(M)]\n counter = [1] * N\n red_flag = [0] * N\n red_flag[0] = 1\n for from_box, to_box in proc_list:\n if red_flag[from_box] == 1:\n if counter[from_box] == 1:\n red_flag[from_box] = 0\n red_flag[to_box] = 1\n counter[from_box] -= 1\n counter[to_box] += 1\n print(sum(red_flag))\n\n\nif __name__ == '__main__':\n main()", "def main():\n N, M = list(map(int, input().split()))\n proc_list = [list(map(lambda z: int(z) - 1, input().split())) for _ in range(M)]\n counter = [1] * N\n red_flag = [0] * N\n red_flag[0] = 1\n for from_box, to_box in proc_list:\n if red_flag[from_box] == 1:\n if counter[from_box] == 1:\n red_flag[from_box] = 0\n red_flag[to_box] = 1\n counter[from_box] -= 1\n counter[to_box] += 1\n print(sum(red_flag))", "main", "N, M = list(map(int, input().split()))", "N", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "M", "list(map(lambda z: int(z) - 1, input().split())) for _ in range(M)", "for _ in range(M)", "_", "range(M)", "range", "M", "for _ in range(M)", "list(map(lambda z: int(z) - 1, input().split()))", "list", "map(lambda z: int(z) - 1, input().split())", "map", "lambda z: int(z) - 1", "int(z) - 1", "int(z)", "int", "z", "1", "z", "input().split()", "().split", "()", "input", "split", "proc_list = [list(map(lambda z: int(z) - 1, input().split())) for _ in range(M)]", "proc_list", "[list(map(lambda z: int(z) - 1, input().split())) for _ in range(M)]", "counter = [1] * N", "counter", "[1] * N", "[1]", "1", "N", "red_flag = [0] * N", "red_flag", "[0] * N", "[0]", "0", "N", "red_flag[0] = 1", "red_flag[0]", "red_flag", "0", "1", "for from_box, to_box in proc_list:\n if red_flag[from_box] == 1:\n if counter[from_box] == 1:\n red_flag[from_box] = 0\n red_flag[to_box] = 1\n counter[from_box] -= 1\n counter[to_box] += 1\n ", "from_box", "to_box", "proc_list", "if red_flag[from_box] == 1:\n if counter[from_box] == 1:\n red_flag[from_box] = 0\n red_flag[to_box] = 1\n ", "red_flag[from_box] == 1", "red_flag[from_box]", "red_flag", "from_box", "1", "if counter[from_box] == 1:\n red_flag[from_box] = 0\n ", "counter[from_box] == 1", "counter[from_box]", "counter", "from_box", "1", "red_flag[from_box] = 0", "red_flag[from_box]", "red_flag", "from_box", "0", "red_flag[to_box] = 1", "red_flag[to_box]", "red_flag", "to_box", "1", "counter[from_box] -= 1", "counter[from_box]", "counter", "from_box", "1", "counter[to_box] += 1", "counter[to_box]", "counter", "to_box", "1", "print(sum(red_flag))", "print", "sum(red_flag)", "sum", "red_flag", "if __name__ == '__main__':\n main()", "__name__ == '__main__'", "__name__", "'__main__'", "main()", "main", "def main():\n N, M = list(map(int, input().split()))\n proc_list = [list(map(lambda z: int(z) - 1, input().split())) for _ in range(M)]\n counter = [1] * N\n red_flag = [0] * N\n red_flag[0] = 1\n for from_box, to_box in proc_list:\n if red_flag[from_box] == 1:\n if counter[from_box] == 1:\n red_flag[from_box] = 0\n red_flag[to_box] = 1\n counter[from_box] -= 1\n counter[to_box] += 1\n print(sum(red_flag))", "def main():\n N, M = list(map(int, input().split()))\n proc_list = [list(map(lambda z: int(z) - 1, input().split())) for _ in range(M)]\n counter = [1] * N\n red_flag = [0] * N\n red_flag[0] = 1\n for from_box, to_box in proc_list:\n if red_flag[from_box] == 1:\n if counter[from_box] == 1:\n red_flag[from_box] = 0\n red_flag[to_box] = 1\n counter[from_box] -= 1\n counter[to_box] += 1\n print(sum(red_flag))", "main" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 17, 0, 13, 2, 39, 17, 13, 28, 13, 4, 13, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 18, 13, 2, 13, 17, 17, 0, 18, 13, 2, 13, 17, 17, 14, 2, 13, 13, 14, 2, 18, 13, 2, 13, 17, 17, 4, 13, 4, 13, 13, 10, 4, 13, 10, 17, 13, 10, 4, 13, 10, 2, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 81, 2 ], [ 81, 11 ], [ 72, 13 ], [ 78, 16 ], [ 76, 20 ], [ 23, 22 ], [ 82, 25 ], [ 84, 27 ], [ 84, 36 ], [ 43, 38 ], [ 79, 39 ], [ 85, 41 ], [ 50, 45 ], [ 79, 46 ], [ 70, 48 ], [ 85, 53 ], [ 73, 54 ], [ 79, 58 ], [ 85, 60 ], [ 73, 67 ], [ 84, 70 ], [ 72, 73 ], [ 81, 76 ], [ 78, 79 ], [ 81, 82 ], [ 84, 85 ] ]

[ "n, m = map(int, input().split())\n\nans = {1}\nl = [1] * n\n\nfor i in range(m):\n x, y = map(int, input().split())\n l[x - 1] -= 1\n l[y - 1] += 1\n\n if x in ans:\n if l[x - 1] == 0: ans.remove(x); ans.add(y)\n else: ans.add(y)\nprint(len(ans))", "n, m = map(int, input().split())", "n", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "m", "ans = {1}", "ans", "{1}", "l = [1] * n", "l", "[1] * n", "[1]", "1", "n", "for i in range(m):\n x, y = map(int, input().split())\n l[x - 1] -= 1\n l[y - 1] += 1\n\n if x in ans:\n if l[x - 1] == 0: ans.remove(x); ans.add(y)\n else: ans.add(y)", "i", "range(m)", "range", "m", "x, y = map(int, input().split())", "x", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "y", "l[x - 1] -= 1", "l[x - 1]", "l", "x - 1", "x", "1", "1", "l[y - 1] += 1", "l[y - 1]", "l", "y - 1", "y", "1", "1", "if x in ans:\n if l[x - 1] == 0: ans.remove(x); ans.add(y)\n else: ans.add(y)", "x in ans", "x", "ans", "if l[x - 1] == 0: ans.remove(x); ans.add(y)\n else: ans.add(y)", "l[x - 1] == 0", "l[x - 1]", "l", "x - 1", "x", "1", "0", "print(len(ans))", "print", "len(ans)", "len", "ans", "y = map(int, input().split())", "map(int, input().split())", "y", "ans = {1}", "{1}", "ans", "n, m = map(int, input().split())", "map(int, input().split())", "n", "l = [1] * n", "[1] * n", "l", "m = map(int, input().split())", "map(int, input().split())", "m", "x, y = map(int, input().split())", "map(int, input().split())", "x" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 2, 39, 17, 13, 0, 13, 2, 39, 17, 2, 39, 17, 2, 13, 17, 28, 13, 4, 13, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 14, 2, 18, 13, 2, 13, 17, 17, 0, 18, 13, 2, 13, 17, 17, 0, 18, 13, 2, 13, 17, 17, 0, 18, 13, 2, 13, 17, 17, 14, 2, 18, 13, 2, 13, 17, 17, 0, 18, 13, 2, 13, 17, 17, 41, 28, 13, 13, 4, 13, 13, 13, 2, 2, 13, 13, 17, 4, 2, 13, 13, 0, 13, 4, 13, 13, 4, 13, 13, 10, 4, 13, 10, 2, 13, 10, 2, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 124, 2 ], [ 124, 11 ], [ 118, 13 ], [ 116, 17 ], [ 121, 19 ], [ 116, 27 ], [ 31, 30 ], [ 125, 33 ], [ 133, 35 ], [ 133, 44 ], [ 122, 48 ], [ 128, 50 ], [ 59, 54 ], [ 122, 55 ], [ 134, 57 ], [ 66, 61 ], [ 119, 62 ], [ 128, 64 ], [ 73, 68 ], [ 119, 69 ], [ 134, 71 ], [ 119, 77 ], [ 128, 79 ], [ 88, 83 ], [ 122, 84 ], [ 128, 86 ], [ 119, 95 ], [ 122, 96 ], [ 128, 99 ], [ 134, 100 ], [ 128, 104 ], [ 134, 105 ], [ 130, 107 ], [ 131, 113 ], [ 124, 116 ], [ 118, 119 ], [ 121, 122 ], [ 124, 125 ], [ 133, 128 ], [ 130, 131 ], [ 133, 134 ] ]

[ "n, m = map(int, input().split())\n\n# ボール個数、赤いボールがある可能性を管理\nb = [1] * n\nred = [1] + [0] * (n - 1)\n\nfor i in range(m):\n x, y = map(int, input().split())\n\n # 移す元に赤いボールがある可能性があれば、移す先に赤いボールが渡る可能性がある\n if red[x - 1] == 1:\n red[y - 1] = 1\n\n # ボール数の足し引き\n b[x - 1] -= 1\n b[y - 1] += 1\n\n # xのボールが0になったら赤いボールがある可能性が消える\n if b[x - 1] == 0:\n red[x - 1] = 0\n\nans = len([x * y for x, y in zip(b, red) if x * y > 0])\n\nprint(ans)", "n, m = map(int, input().split())", "n", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "m", "b = [1] * n", "b", "[1] * n", "[1]", "1", "n", "red = [1] + [0] * (n - 1)", "red", "[1] + [0] * (n - 1)", "[1]", "1", "[0] * (n - 1)", "[0]", "0", "n - 1", "n", "1", "for i in range(m):\n x, y = map(int, input().split())\n\n # 移す元に赤いボールがある可能性があれば、移す先に赤いボールが渡る可能性がある\n if red[x - 1] == 1:\n red[y - 1] = 1\n\n # ボール数の足し引き\n b[x - 1] -= 1\n b[y - 1] += 1\n\n # xのボールが0になったら赤いボールがある可能性が消える\n if b[x - 1] == 0:\n red[x - 1] = 0", "i", "range(m)", "range", "m", "x, y = map(int, input().split())", "x", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "y", "if red[x - 1] == 1:\n red[y - 1] = 1\n\n # ボール数の足し引き\n ", "red[x - 1] == 1", "red[x - 1]", "red", "x - 1", "x", "1", "1", "red[y - 1] = 1", "red[y - 1]", "red", "y - 1", "y", "1", "1", "b[x - 1] -= 1", "b[x - 1]", "b", "x - 1", "x", "1", "1", "b[y - 1] += 1", "b[y - 1]", "b", "y - 1", "y", "1", "1", "if b[x - 1] == 0:\n red[x - 1] = 0", "b[x - 1] == 0", "b[x - 1]", "b", "x - 1", "x", "1", "0", "red[x - 1] = 0", "red[x - 1]", "red", "x - 1", "x", "1", "0", "x * y for x, y in zip(b, red) if x * y > 0", "for x, y in zip(b, red) if x * y > 0", "x", "y", "zip(b, red)", "zip", "b", "red", "x * y > 0", "x * y", "x", "y", "0", "if x * y > 0", "x * y", "x", "y", "ans = len([x * y for x, y in zip(b, red) if x * y > 0])", "ans", "len([x * y for x, y in zip(b, red) if x * y > 0])", "len", "[x * y for x, y in zip(b, red) if x * y > 0]", "print(ans)", "print", "ans", "n, m = map(int, input().split())", "map(int, input().split())", "n", "b = [1] * n", "[1] * n", "b", "red = [1] + [0] * (n - 1)", "[1] + [0] * (n - 1)", "red", "m = map(int, input().split())", "map(int, input().split())", "m", "x, y = map(int, input().split())", "map(int, input().split())", "x", "ans = len([x * y for x, y in zip(b, red) if x * y > 0])", "len([x * y for x, y in zip(b, red) if x * y > 0])", "ans", "y = map(int, input().split())", "map(int, input().split())", "y" ]