Datasets:

---

codefuse-ai

/

GALLa

like 1

Follow

CodeFuse AI 145

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

[ [ 66, 2 ], [ 66, 5 ], [ 9, 8 ], [ 75, 16 ], [ 75, 25 ], [ 57, 27 ], [ 64, 34 ], [ 61, 34 ], [ 70, 35 ], [ 67, 40 ], [ 73, 40 ], [ 76, 41 ], [ 60, 43 ], [ 70, 45 ], [ 58, 46 ], [ 72, 47 ], [ 76, 49 ], [ 58, 50 ], [ 61, 54 ], [ 64, 54 ], [ 73, 55 ], [ 67, 55 ], [ 57, 58 ], [ 60, 61 ], [ 66, 64 ], [ 66, 67 ], [ 75, 70 ], [ 72, 73 ], [ 75, 76 ] ]

[ "a=b=1\nfor _ in range(int(input())):\n c,d=map(int,input().split())\n m=max(0--a//c,0--b//d)\n a,b=c*m,d*m\nprint(a+b)", "a=b=1", "a", "1", "=b=1", "b", "1", "for _ in range(int(input())):\n c,d=map(int,input().split())\n m=max(0--a//c,0--b//d)\n a,b=c*m,d*m", "_", "range(int(input()))", "range", "int(input())", "int", "input()", "input", "c,d=map(int,input().split())", "c", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "d", "m=max(0--a//c,0--b//d)", "m", "max(0--a//c,0--b//d)", "max", "0--a//c", "0", "-a//c", "-a", "a", "c", "0--b//d", "0", "-b//d", "-b", "b", "d", "a,b=c*m,d*m", "a", "c*m", "c", "m", "b", "d*m", "d", "m", "print(a+b)", "print", "a+b", "a", "b", "m=max(0--a//c,0--b//d)", "max(0--a//c,0--b//d)", "m", "a,b=c*m,d*m", "c*m", "a", "a=b=1", "1", "a", "b=1", "1", "b", "c,d=map(int,input().split())", "map(int,input().split())", "c", "b=c*m,d*m", "d*m", "b", "d=map(int,input().split())", "map(int,input().split())", "d" ]

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

[ [ 85, 4 ], [ 76, 10 ], [ 67, 12 ], [ 16, 15 ], [ 86, 18 ], [ 82, 20 ], [ 82, 29 ], [ 64, 31 ], [ 77, 37 ], [ 71, 37 ], [ 80, 40 ], [ 68, 44 ], [ 74, 44 ], [ 83, 47 ], [ 70, 49 ], [ 65, 51 ], [ 80, 52 ], [ 73, 54 ], [ 65, 56 ], [ 83, 57 ], [ 71, 61 ], [ 77, 61 ], [ 74, 62 ], [ 68, 62 ], [ 64, 65 ], [ 67, 68 ], [ 70, 71 ], [ 73, 74 ], [ 76, 77 ], [ 82, 80 ], [ 82, 83 ], [ 85, 86 ] ]

[ "from decimal import Decimal,getcontext\nfrom math import ceil\n\nN = int(input())\n\ntakahashi,aoki = 1,1\n\nfor _ in range(N):\n a,b = map(int,input().split())\n c = max(ceil(takahashi/Decimal(a)),ceil(aoki/Decimal(b)))\n takahashi = c*a\n aoki = c*b\n\nprint(takahashi+aoki)", "from decimal import Decimal,getcontext", "from math import ceil", "N = int(input())", "N", "int(input())", "int", "input()", "input", "takahashi,aoki = 1,1", "takahashi", "1", "aoki", "1", "for _ in range(N):\n a,b = map(int,input().split())\n c = max(ceil(takahashi/Decimal(a)),ceil(aoki/Decimal(b)))\n takahashi = c*a\n aoki = c*b", "_", "range(N)", "range", "N", "a,b = map(int,input().split())", "a", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "c = max(ceil(takahashi/Decimal(a)),ceil(aoki/Decimal(b)))", "c", "max(ceil(takahashi/Decimal(a)),ceil(aoki/Decimal(b)))", "max", "ceil(takahashi/Decimal(a))", "ceil", "takahashi/Decimal(a)", "takahashi", "Decimal(a)", "Decimal", "a", "ceil(aoki/Decimal(b))", "ceil", "aoki/Decimal(b)", "aoki", "Decimal(b)", "Decimal", "b", "takahashi = c*a", "takahashi", "c*a", "c", "a", "aoki = c*b", "aoki", "c*b", "c", "b", "print(takahashi+aoki)", "print", "takahashi+aoki", "takahashi", "aoki", "c = max(ceil(takahashi/Decimal(a)),ceil(aoki/Decimal(b)))", "max(ceil(takahashi/Decimal(a)),ceil(aoki/Decimal(b)))", "c", "aoki = 1,1", "1", "aoki", "takahashi = c*a", "c*a", "takahashi", "aoki = c*b", "c*b", "aoki", "takahashi,aoki = 1,1", "1", "takahashi", "a,b = map(int,input().split())", "map(int,input().split())", "a", "b = map(int,input().split())", "map(int,input().split())", "b", "N = int(input())", "int(input())", "N" ]

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

[ [ 78, 2 ], [ 69, 8 ], [ 63, 11 ], [ 15, 14 ], [ 79, 17 ], [ 72, 19 ], [ 72, 28 ], [ 75, 30 ], [ 70, 36 ], [ 85, 36 ], [ 67, 37 ], [ 67, 39 ], [ 64, 43 ], [ 82, 43 ], [ 73, 44 ], [ 73, 46 ], [ 84, 48 ], [ 76, 50 ], [ 67, 51 ], [ 81, 53 ], [ 76, 55 ], [ 73, 56 ], [ 85, 60 ], [ 70, 60 ], [ 82, 61 ], [ 64, 61 ], [ 63, 64 ], [ 72, 67 ], [ 69, 70 ], [ 72, 73 ], [ 75, 76 ], [ 78, 79 ], [ 81, 82 ], [ 84, 85 ] ]

[ "n = int(input())\na = 1\nb = 1\nfor i in range(n):\n c,d = map(int,input().split())\n \n num = max((a+c-1)//c,(b+d-1)//d)\n\n a = num*c\n b = num*d\nprint(a+b)", "n = int(input())", "n", "int(input())", "int", "input()", "input", "a = 1", "a", "1", "b = 1", "b", "1", "for i in range(n):\n c,d = map(int,input().split())\n \n num = max((a+c-1)//c,(b+d-1)//d)\n\n a = num*c\n b = num*d", "i", "range(n)", "range", "n", "c,d = map(int,input().split())", "c", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "d", "num = max((a+c-1)//c,(b+d-1)//d)", "num", "max((a+c-1)//c,(b+d-1)//d)", "max", "(a+c-1)//c", "a+c-1", "a+c", "a", "c", "1", "c", "(b+d-1)//d", "b+d-1", "b+d", "b", "d", "1", "d", "a = num*c", "a", "num*c", "num", "c", "b = num*d", "b", "num*d", "num", "d", "print(a+b)", "print", "a+b", "a", "b", "b = 1", "1", "b", "c,d = map(int,input().split())", "map(int,input().split())", "c", "a = 1", "1", "a", "d = map(int,input().split())", "map(int,input().split())", "d", "num = max((a+c-1)//c,(b+d-1)//d)", "max((a+c-1)//c,(b+d-1)//d)", "num", "n = int(input())", "int(input())", "n", "b = num*d", "num*d", "b", "a = num*c", "num*c", "a" ]

[ 7, 0, 13, 4, 13, 4, 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, 18, 13, 17, 13, 28, 13, 4, 13, 17, 13, 0, 13, 18, 13, 13, 13, 14, 2, 2, 13, 13, 2, 13, 13, 0, 13, 4, 13, 2, 2, 13, 13, 40, 2, 13, 13, 17, 2, 2, 13, 13, 40, 2, 13, 13, 17, 0, 13, 2, 13, 13, 13, 2, 13, 13, 0, 13, 13, 13, 13, 4, 13, 2, 13, 13, 10, 18, 13, 10, 39, 13, 10, 4, 13, 10, 2, 13, 10, 18, 13, 10, 18, 13, 10, 4, 13, 10, 13, 13, 10, 18, 13, 10, 13, 13, 10, 2, 13 ]

[ [ 118, 2 ], [ 103, 8 ], [ 12, 11 ], [ 119, 14 ], [ 18, 17 ], [ 17, 26 ], [ 104, 29 ], [ 124, 33 ], [ 104, 35 ], [ 124, 37 ], [ 40, 39 ], [ 119, 43 ], [ 115, 45 ], [ 104, 47 ], [ 39, 48 ], [ 115, 49 ], [ 113, 53 ], [ 125, 54 ], [ 122, 54 ], [ 110, 54 ], [ 116, 56 ], [ 101, 57 ], [ 128, 57 ], [ 131, 57 ], [ 106, 59 ], [ 125, 64 ], [ 122, 64 ], [ 110, 64 ], [ 113, 65 ], [ 125, 68 ], [ 122, 68 ], [ 110, 68 ], [ 113, 69 ], [ 101, 73 ], [ 128, 73 ], [ 131, 73 ], [ 116, 74 ], [ 101, 77 ], [ 128, 77 ], [ 131, 77 ], [ 116, 78 ], [ 109, 81 ], [ 113, 83 ], [ 107, 84 ], [ 130, 85 ], [ 116, 87 ], [ 107, 88 ], [ 121, 90 ], [ 113, 91 ], [ 127, 92 ], [ 116, 93 ], [ 122, 97 ], [ 110, 97 ], [ 125, 97 ], [ 128, 98 ], [ 131, 98 ], [ 101, 98 ], [ 124, 101 ], [ 103, 104 ], [ 106, 107 ], [ 109, 110 ], [ 115, 113 ], [ 115, 116 ], [ 118, 119 ], [ 113, 121 ], [ 121, 122 ], [ 124, 125 ], [ 116, 127 ], [ 127, 128 ], [ 130, 131 ] ]

[ "N = int(input())\nTA = []\n \nfor _ in range(N):\n TA.append([int(x) for x in input().split()])\n \nx, y = TA[0]\n \nfor i in range(1, N):\n X, Y = TA[i]\n if X < x or Y < y:\n mul = max(x // X + (x % X != 0), y // Y + (y % Y != 0))\n x, y = X * mul, Y * mul\n else:\n x, y = X, Y\n #print(x, y)\n \nprint(x + y)", "N = int(input())", "N", "int(input())", "int", "input()", "input", "TA = []", "TA", "[]", "for _ in range(N):\n TA.append([int(x) for x in input().split()])\n ", "_", "range(N)", "range", "N", "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", "TA.append([int(x) for x in input().split()])", "TA.append", "TA", "append", "[int(x) for x in input().split()]", "x, y = TA[0]", "x", "TA[0]", "TA", "0", "y", "for i in range(1, N):\n X, Y = TA[i]\n if X < x or Y < y:\n mul = max(x // X + (x % X != 0), y // Y + (y % Y != 0))\n x, y = X * mul, Y * mul\n else:\n x, y = X, Y\n #print(x, y)\n ", "i", "range(1, N)", "range", "1", "N", "X, Y = TA[i]", "X", "TA[i]", "TA", "i", "Y", "if X < x or Y < y:\n mul = max(x // X + (x % X != 0), y // Y + (y % Y != 0))\n x, y = X * mul, Y * mul\n else:\n x, y = X, Y\n #print(x, y)\n ", "X < x or Y < y", "X < x", "X", "x", "Y < y", "Y", "y", "mul = max(x // X + (x % X != 0), y // Y + (y % Y != 0))", "mul", "max(x // X + (x % X != 0), y // Y + (y % Y != 0))", "max", "x // X + (x % X != 0)", "x // X", "x", "X", "x % X != 0", "x % X", "x", "X", "0", "y // Y + (y % Y != 0)", "y // Y", "y", "Y", "y % Y != 0", "y % Y", "y", "Y", "0", "x, y = X * mul, Y * mul", "x", "X * mul", "X", "mul", "y", "Y * mul", "Y", "mul", "x, y = X, Y", "x", "X", "y", "Y", "print(x + y)", "print", "x + y", "x", "y", "y = TA[0]", "TA[0]", "y", "TA = []", "[]", "TA", "mul = max(x // X + (x % X != 0), y // Y + (y % Y != 0))", "max(x // X + (x % X != 0), y // Y + (y % Y != 0))", "mul", "x, y = X * mul, Y * mul", "X * mul", "x", "X, Y = TA[i]", "TA[i]", "X", "Y = TA[i]", "TA[i]", "Y", "N = int(input())", "int(input())", "N", "x, y = X, Y", "X", "x", "x, y = TA[0]", "TA[0]", "x", "y = X, Y", "Y", "y", "y = X * mul, Y * mul", "Y * mul", "y" ]

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

[ [ 79, 2 ], [ 10, 9 ], [ 80, 12 ], [ 85, 25 ], [ 91, 28 ], [ 88, 37 ], [ 92, 38 ], [ 77, 38 ], [ 88, 39 ], [ 73, 41 ], [ 83, 47 ], [ 89, 54 ], [ 76, 59 ], [ 74, 62 ], [ 74, 65 ], [ 77, 71 ], [ 92, 71 ], [ 73, 74 ], [ 76, 77 ], [ 79, 80 ], [ 92, 82 ], [ 77, 82 ], [ 88, 83 ], [ 85, 86 ], [ 92, 88 ], [ 77, 88 ], [ 88, 89 ], [ 91, 92 ] ]

[ "n = int(input())\nratio_array = [tuple(map(int, input().split())) for _ in range(n)]\n\nvotes_numｓ = (1, 1)\n\nfor x, y in ratio_array:\n t, a = votes_numｓ\n m = max((t+x-1)//x, (a+y-1)//y)\n votes_numｓ = (m*x, m*y)\n\nprint(sum(votes_numｓ))", "n = int(input())", "n", "int(input())", "int", "input()", "input", "tuple(map(int, input().split())) for _ in range(n)", "for _ in range(n)", "_", "range(n)", "range", "n", "for _ in range(n)", "tuple(map(int, input().split()))", "tuple", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "ratio_array = [tuple(map(int, input().split())) for _ in range(n)]", "ratio_array", "[tuple(map(int, input().split())) for _ in range(n)]", "votes_numｓ = (1, 1)", "votes_numｓ", "(1, 1)", "1", "1", "for x, y in ratio_array:\n t, a = votes_numｓ\n m = max((t+x-1)//x, (a+y-1)//y)\n votes_numｓ = (m*x, m*y)", "x", "y", "ratio_array", "t, a = votes_numｓ", "t", "votes_numｓ", "a", "m = max((t+x-1)//x, (a+y-1)//y)", "m", "max((t+x-1)//x, (a+y-1)//y)", "max", "(t+x-1)//x", "t+x-1", "t+x", "t", "x", "1", "x", "(a+y-1)//y", "a+y-1", "a+y", "a", "y", "1", "y", "votes_numｓ = (m*x, m*y)", "votes_numｓ", "(m*x, m*y)", "m*x", "m", "x", "m*y", "m", "y", "print(sum(votes_numｓ))", "print", "sum(votes_numｓ)", "sum", "votes_numｓ", "m = max((t+x-1)//x, (a+y-1)//y)", "max((t+x-1)//x, (a+y-1)//y)", "m", "votes_numｓ = (m*x, m*y)", "(m*x, m*y)", "votes_numｓ", "n = int(input())", "int(input())", "n", "t, a = votes_numｓ", "votes_numｓ", "t", "ratio_array = [tuple(map(int, input().split())) for _ in range(n)]", "[tuple(map(int, input().split())) for _ in range(n)]", "ratio_array", "a = votes_numｓ", "votes_numｓ", "a", "votes_numｓ = (1, 1)", "(1, 1)", "votes_numｓ" ]

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

[ [ 109, 6 ], [ 121, 12 ], [ 121, 21 ], [ 115, 23 ], [ 122, 24 ], [ 112, 25 ], [ 104, 26 ], [ 29, 28 ], [ 110, 32 ], [ 124, 35 ], [ 124, 44 ], [ 118, 47 ], [ 116, 56 ], [ 107, 56 ], [ 92, 57 ], [ 113, 64 ], [ 98, 64 ], [ 125, 65 ], [ 94, 67 ], [ 119, 71 ], [ 95, 71 ], [ 106, 73 ], [ 92, 75 ], [ 95, 76 ], [ 119, 76 ], [ 97, 78 ], [ 125, 80 ], [ 95, 81 ], [ 119, 81 ], [ 100, 83 ], [ 107, 85 ], [ 116, 85 ], [ 98, 86 ], [ 113, 86 ], [ 101, 89 ], [ 124, 92 ], [ 94, 95 ], [ 97, 98 ], [ 100, 101 ], [ 121, 104 ], [ 106, 107 ], [ 109, 110 ], [ 104, 112 ], [ 112, 113 ], [ 122, 115 ], [ 115, 116 ], [ 118, 119 ], [ 121, 122 ], [ 124, 125 ] ]

[ "import math\nfrom fractions import Fraction\nfrom decimal import *\n# ex) Fraction(2,6) > 1/3 > 0.33333\n\nn = int(input())\nx, y = map(int, input().split())\nt, a = x, y\n\nfor _ in range(n - 1):\n tt, aa = map(int, input().split())\n\n # c = 1\n '''\n if (t >= a):\n c = math.ceil(tt / t)\n\n else:\n c = math.ceil(aa / a)\n '''\n # c = math.ceil(max(t / tt, a / aa))\n # c = math.ceil(max(Fraction(t + tt - 1, tt), Fraction(a + aa - 1 / aa)))\n c = max(math.ceil(Fraction(t, tt)), math.ceil(Fraction(a, aa)))\n c = max(1, c)\n\n t = tt * c\n a = aa * c\n\n\nans = t + a\nprint(ans)", "import math", "math", "from fractions import Fraction", "from decimal import *", "n = int(input())", "n", "int(input())", "int", "input()", "input", "x, y = map(int, input().split())", "x", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "y", "t, a = x, y", "t", "x", "a", "y", "for _ in range(n - 1):\n tt, aa = map(int, input().split())\n\n # c = 1\n '''\n if (t >= a):\n c = math.ceil(tt / t)\n\n else:\n c = math.ceil(aa / a)\n '''\n # c = math.ceil(max(t / tt, a / aa))\n # c = math.ceil(max(Fraction(t + tt - 1, tt), Fraction(a + aa - 1 / aa)))\n c = max(math.ceil(Fraction(t, tt)), math.ceil(Fraction(a, aa)))\n c = max(1, c)\n\n t = tt * c\n a = aa * c", "_", "range(n - 1)", "range", "n - 1", "n", "1", "tt, aa = map(int, input().split())", "tt", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "aa", "'''\n if (t >= a):\n c = math.ceil(tt / t)\n\n else:\n c = math.ceil(aa / a)\n '''", "c = max(math.ceil(Fraction(t, tt)), math.ceil(Fraction(a, aa)))", "c", "max(math.ceil(Fraction(t, tt)), math.ceil(Fraction(a, aa)))", "max", "math.ceil(Fraction(t, tt))", "math.ceil", "math", "ceil", "Fraction(t, tt)", "Fraction", "t", "tt", "math.ceil(Fraction(a, aa))", "math.ceil", "math", "ceil", "Fraction(a, aa)", "Fraction", "a", "aa", "c = max(1, c)", "c", "max(1, c)", "max", "1", "c", "t = tt * c", "t", "tt * c", "tt", "c", "a = aa * c", "a", "aa * c", "aa", "c", "ans = t + a", "ans", "t + a", "t", "a", "print(ans)", "print", "ans", "tt, aa = map(int, input().split())", "map(int, input().split())", "tt", "c = max(1, c)", "max(1, c)", "c", "a = aa * c", "aa * c", "a", "ans = t + a", "t + a", "ans", "y = map(int, input().split())", "map(int, input().split())", "y", "t = tt * c", "tt * c", "t", "n = int(input())", "int(input())", "n", "a = x, y", "y", "a", "t, a = x, y", "x", "t", "c = max(math.ceil(Fraction(t, tt)), math.ceil(Fraction(a, aa)))", "max(math.ceil(Fraction(t, tt)), math.ceil(Fraction(a, aa)))", "c", "x, y = map(int, input().split())", "map(int, input().split())", "x", "aa = map(int, input().split())", "map(int, input().split())", "aa" ]

[ 7, 0, 13, 4, 13, 4, 13, 0, 13, 2, 39, 17, 13, 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, 0, 13, 18, 13, 17, 13, 18, 13, 17, 28, 13, 4, 13, 17, 13, 0, 13, 2, 18, 13, 13, 4, 13, 2, 2, 2, 13, 18, 13, 13, 17, 18, 13, 13, 2, 2, 2, 13, 18, 13, 13, 17, 18, 13, 13, 0, 13, 2, 18, 13, 13, 4, 13, 2, 2, 2, 13, 18, 13, 13, 17, 18, 13, 13, 2, 2, 2, 13, 18, 13, 13, 17, 18, 13, 13, 4, 13, 2, 13, 13, 10, 4, 13, 10, 2, 13, 10, 18, 13, 10, 2, 13, 10, 2, 13, 10, 18, 13, 10, 2, 13 ]

[ [ 119, 2 ], [ 131, 8 ], [ 120, 12 ], [ 128, 13 ], [ 120, 17 ], [ 20, 19 ], [ 120, 22 ], [ 27, 24 ], [ 132, 25 ], [ 19, 26 ], [ 27, 35 ], [ 129, 36 ], [ 19, 37 ], [ 134, 39 ], [ 132, 41 ], [ 125, 43 ], [ 129, 45 ], [ 49, 48 ], [ 120, 52 ], [ 137, 54 ], [ 24, 56 ], [ 132, 57 ], [ 48, 58 ], [ 135, 64 ], [ 138, 64 ], [ 24, 65 ], [ 132, 66 ], [ 48, 67 ], [ 24, 69 ], [ 132, 70 ], [ 48, 71 ], [ 126, 75 ], [ 123, 75 ], [ 35, 76 ], [ 129, 77 ], [ 48, 78 ], [ 35, 80 ], [ 129, 81 ], [ 48, 82 ], [ 122, 84 ], [ 35, 86 ], [ 129, 87 ], [ 48, 88 ], [ 138, 94 ], [ 135, 94 ], [ 24, 95 ], [ 132, 96 ], [ 48, 97 ], [ 24, 99 ], [ 132, 100 ], [ 48, 101 ], [ 126, 105 ], [ 123, 105 ], [ 35, 106 ], [ 129, 107 ], [ 48, 108 ], [ 35, 110 ], [ 129, 111 ], [ 48, 112 ], [ 123, 116 ], [ 126, 116 ], [ 138, 117 ], [ 135, 117 ], [ 119, 120 ], [ 122, 123 ], [ 125, 126 ], [ 128, 129 ], [ 131, 132 ], [ 134, 135 ], [ 137, 138 ] ]

[ "n=int(input())\nt,a=[0]*n,[0]*n\nfor i in range(n):\n t[i],a[i]=map(int,input().split())\ntt,aa=t[0],a[0]\nfor i in range(1,n):\n tt=t[i]*max((tt+t[i]-1)//t[i],(aa+a[i]-1)//a[i])\n aa=a[i]*max((tt+t[i]-1)//t[i],(aa+a[i]-1)//a[i])\nprint(aa+tt)", "n=int(input())", "n", "int(input())", "int", "input()", "input", "t,a=[0]*n,[0]*n", "t", "[0]*n", "[0]", "0", "n", "a", "[0]*n", "[0]", "0", "n", "for i in range(n):\n t[i],a[i]=map(int,input().split())", "i", "range(n)", "range", "n", "t[i],a[i]=map(int,input().split())", "t[i]", "t", "i", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "a[i]", "a", "i", "tt,aa=t[0],a[0]", "tt", "t[0]", "t", "0", "aa", "a[0]", "a", "0", "for i in range(1,n):\n tt=t[i]*max((tt+t[i]-1)//t[i],(aa+a[i]-1)//a[i])\n aa=a[i]*max((tt+t[i]-1)//t[i],(aa+a[i]-1)//a[i])", "i", "range(1,n)", "range", "1", "n", "tt=t[i]*max((tt+t[i]-1)//t[i],(aa+a[i]-1)//a[i])", "tt", "t[i]*max((tt+t[i]-1)//t[i],(aa+a[i]-1)//a[i])", "t[i]", "t", "i", "max((tt+t[i]-1)//t[i],(aa+a[i]-1)//a[i])", "max", "(tt+t[i]-1)//t[i]", "tt+t[i]-1", "tt+t[i]", "tt", "t[i]", "t", "i", "1", "t[i]", "t", "i", "(aa+a[i]-1)//a[i]", "aa+a[i]-1", "aa+a[i]", "aa", "a[i]", "a", "i", "1", "a[i]", "a", "i", "aa=a[i]*max((tt+t[i]-1)//t[i],(aa+a[i]-1)//a[i])", "aa", "a[i]*max((tt+t[i]-1)//t[i],(aa+a[i]-1)//a[i])", "a[i]", "a", "i", "max((tt+t[i]-1)//t[i],(aa+a[i]-1)//a[i])", "max", "(tt+t[i]-1)//t[i]", "tt+t[i]-1", "tt+t[i]", "tt", "t[i]", "t", "i", "1", "t[i]", "t", "i", "(aa+a[i]-1)//a[i]", "aa+a[i]-1", "aa+a[i]", "aa", "a[i]", "a", "i", "1", "a[i]", "a", "i", "print(aa+tt)", "print", "aa+tt", "aa", "tt", "n=int(input())", "int(input())", "n", "aa=a[i]*max((tt+t[i]-1)//t[i],(aa+a[i]-1)//a[i])", "a[i]*max((tt+t[i]-1)//t[i],(aa+a[i]-1)//a[i])", "aa", "aa=t[0],a[0]", "a[0]", "aa", "a=[0]*n,[0]*n", "[0]*n", "a", "t,a=[0]*n,[0]*n", "[0]*n", "t", "tt,aa=t[0],a[0]", "t[0]", "tt", "tt=t[i]*max((tt+t[i]-1)//t[i],(aa+a[i]-1)//a[i])", "t[i]*max((tt+t[i]-1)//t[i],(aa+a[i]-1)//a[i])", "tt" ]

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

[ [ 86, 2 ], [ 10, 9 ], [ 87, 12 ], [ 80, 25 ], [ 83, 28 ], [ 89, 30 ], [ 34, 33 ], [ 87, 36 ], [ 92, 38 ], [ 81, 40 ], [ 33, 41 ], [ 92, 42 ], [ 95, 44 ], [ 84, 50 ], [ 99, 50 ], [ 93, 51 ], [ 93, 53 ], [ 90, 57 ], [ 102, 57 ], [ 78, 58 ], [ 78, 60 ], [ 98, 62 ], [ 96, 64 ], [ 93, 65 ], [ 101, 67 ], [ 96, 69 ], [ 78, 70 ], [ 99, 74 ], [ 84, 74 ], [ 102, 75 ], [ 90, 75 ], [ 92, 78 ], [ 80, 81 ], [ 83, 84 ], [ 86, 87 ], [ 89, 90 ], [ 92, 93 ], [ 95, 96 ], [ 98, 99 ], [ 101, 102 ] ]

[ "n = int(input())\nta = [list(map(int, input().split())) for _ in range(n)]\npt, pa = 1, 1\nfor i in range(n):\n t, a = ta[i]\n v = max((pt + t - 1) // t, (pa + a - 1) // a)\n pt = v * t\n pa = v * a\n\nprint(pt + pa)", "n = int(input())", "n", "int(input())", "int", "input()", "input", "list(map(int, input().split())) for _ in range(n)", "for _ in range(n)", "_", "range(n)", "range", "n", "for _ in range(n)", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "ta = [list(map(int, input().split())) for _ in range(n)]", "ta", "[list(map(int, input().split())) for _ in range(n)]", "pt, pa = 1, 1", "pt", "1", "pa", "1", "for i in range(n):\n t, a = ta[i]\n v = max((pt + t - 1) // t, (pa + a - 1) // a)\n pt = v * t\n pa = v * a", "i", "range(n)", "range", "n", "t, a = ta[i]", "t", "ta[i]", "ta", "i", "a", "v = max((pt + t - 1) // t, (pa + a - 1) // a)", "v", "max((pt + t - 1) // t, (pa + a - 1) // a)", "max", "(pt + t - 1) // t", "pt + t - 1", "pt + t", "pt", "t", "1", "t", "(pa + a - 1) // a", "pa + a - 1", "pa + a", "pa", "a", "1", "a", "pt = v * t", "pt", "v * t", "v", "t", "pa = v * a", "pa", "v * a", "v", "a", "print(pt + pa)", "print", "pt + pa", "pt", "pa", "a = ta[i]", "ta[i]", "a", "ta = [list(map(int, input().split())) for _ in range(n)]", "[list(map(int, input().split())) for _ in range(n)]", "ta", "pt, pa = 1, 1", "1", "pt", "n = int(input())", "int(input())", "n", "pa = 1, 1", "1", "pa", "t, a = ta[i]", "ta[i]", "t", "v = max((pt + t - 1) // t, (pa + a - 1) // a)", "max((pt + t - 1) // t, (pa + a - 1) // a)", "v", "pt = v * t", "v * t", "pt", "pa = v * a", "v * a", "pa" ]

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

[ [ 82, 6 ], [ 88, 12 ], [ 73, 14 ], [ 18, 17 ], [ 83, 20 ], [ 24, 23 ], [ 23, 33 ], [ 76, 35 ], [ 76, 37 ], [ 70, 39 ], [ 89, 45 ], [ 86, 45 ], [ 68, 46 ], [ 74, 50 ], [ 80, 50 ], [ 77, 51 ], [ 85, 53 ], [ 71, 55 ], [ 68, 56 ], [ 79, 57 ], [ 71, 59 ], [ 77, 60 ], [ 86, 64 ], [ 89, 64 ], [ 80, 65 ], [ 74, 65 ], [ 76, 68 ], [ 70, 71 ], [ 73, 74 ], [ 76, 77 ], [ 79, 80 ], [ 82, 83 ], [ 85, 86 ], [ 88, 89 ] ]

[ "import io\nimport math\n\ndata = int(input())\nnim,mike = 1,1\nfor _ in range(data):\n n,m = [int(_) for _ in input().split(\" \")]\n l = max(-(-nim//n), -(-mike//m))\n nim,mike = l*n,l*m\nprint(nim+mike)", "import io", "io", "import math", "math", "data = int(input())", "data", "int(input())", "int", "input()", "input", "nim,mike = 1,1", "nim", "1", "mike", "1", "for _ in range(data):\n n,m = [int(_) for _ in input().split(\" \")]\n l = max(-(-nim//n), -(-mike//m))\n nim,mike = l*n,l*m", "_", "range(data)", "range", "data", "int(_) for _ in input().split(\" \")", "for _ in input().split(\" \")", "_", "input().split(\" \")", "().split", "()", "input", "split", "\" \"", "for _ in input().split(\" \")", "int(_)", "int", "_", "n,m = [int(_) for _ in input().split(\" \")]", "n", "[int(_) for _ in input().split(\" \")]", "m", "l = max(-(-nim//n), -(-mike//m))", "l", "max(-(-nim//n), -(-mike//m))", "max", "-(-nim//n)", "-nim//n", "-nim", "nim", "n", "-(-mike//m)", "-mike//m", "-mike", "mike", "m", "nim,mike = l*n,l*m", "nim", "l*n", "l", "n", "mike", "l*m", "l", "m", "print(nim+mike)", "print", "nim+mike", "nim", "mike", "n,m = [int(_) for _ in input().split(\" \")]", "[int(_) for _ in input().split(\" \")]", "n", "l = max(-(-nim//n), -(-mike//m))", "max(-(-nim//n), -(-mike//m))", "l", "mike = 1,1", "1", "mike", "m = [int(_) for _ in input().split(\" \")]", "[int(_) for _ in input().split(\" \")]", "m", "mike = l*n,l*m", "l*m", "mike", "data = int(input())", "int(input())", "data", "nim,mike = l*n,l*m", "l*n", "nim", "nim,mike = 1,1", "1", "nim" ]

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

[ [ 244, 2 ], [ 199, 8 ], [ 232, 10 ], [ 14, 13 ], [ 245, 16 ], [ 241, 18 ], [ 226, 21 ], [ 226, 30 ], [ 13, 33 ], [ 253, 36 ], [ 197, 37 ], [ 229, 38 ], [ 227, 39 ], [ 254, 44 ], [ 200, 44 ], [ 212, 44 ], [ 257, 44 ], [ 239, 44 ], [ 203, 44 ], [ 260, 44 ], [ 197, 45 ], [ 230, 47 ], [ 233, 47 ], [ 215, 47 ], [ 248, 47 ], [ 224, 47 ], [ 251, 47 ], [ 209, 47 ], [ 227, 48 ], [ 259, 50 ], [ 197, 51 ], [ 208, 52 ], [ 227, 53 ], [ 254, 57 ], [ 200, 57 ], [ 212, 57 ], [ 257, 57 ], [ 239, 57 ], [ 203, 57 ], [ 260, 57 ], [ 197, 58 ], [ 227, 60 ], [ 230, 61 ], [ 233, 61 ], [ 215, 61 ], [ 248, 61 ], [ 224, 61 ], [ 251, 61 ], [ 209, 61 ], [ 230, 65 ], [ 233, 65 ], [ 215, 65 ], [ 248, 65 ], [ 224, 65 ], [ 251, 65 ], [ 209, 65 ], [ 227, 66 ], [ 220, 69 ], [ 202, 72 ], [ 197, 74 ], [ 209, 77 ], [ 230, 77 ], [ 233, 77 ], [ 215, 77 ], [ 248, 77 ], [ 224, 77 ], [ 251, 77 ], [ 227, 78 ], [ 221, 79 ], [ 242, 79 ], [ 236, 79 ], [ 218, 79 ], [ 206, 79 ], [ 250, 81 ], [ 227, 83 ], [ 209, 86 ], [ 230, 86 ], [ 233, 86 ], [ 215, 86 ], [ 248, 86 ], [ 224, 86 ], [ 251, 86 ], [ 227, 87 ], [ 221, 88 ], [ 242, 88 ], [ 236, 88 ], [ 218, 88 ], [ 206, 88 ], [ 197, 92 ], [ 254, 93 ], [ 200, 93 ], [ 212, 93 ], [ 257, 93 ], [ 239, 93 ], [ 203, 93 ], [ 260, 93 ], [ 230, 95 ], [ 233, 95 ], [ 215, 95 ], [ 248, 95 ], [ 224, 95 ], [ 251, 95 ], [ 209, 95 ], [ 197, 96 ], [ 254, 100 ], [ 200, 100 ], [ 212, 100 ], [ 257, 100 ], [ 239, 100 ], [ 203, 100 ], [ 260, 100 ], [ 197, 101 ], [ 205, 104 ], [ 223, 107 ], [ 227, 109 ], [ 203, 112 ], [ 260, 112 ], [ 254, 112 ], [ 200, 112 ], [ 212, 112 ], [ 257, 112 ], [ 239, 112 ], [ 197, 113 ], [ 206, 114 ], [ 221, 114 ], [ 242, 114 ], [ 236, 114 ], [ 218, 114 ], [ 238, 116 ], [ 197, 118 ], [ 203, 121 ], [ 260, 121 ], [ 254, 121 ], [ 200, 121 ], [ 212, 121 ], [ 257, 121 ], [ 239, 121 ], [ 197, 122 ], [ 206, 123 ], [ 221, 123 ], [ 242, 123 ], [ 236, 123 ], [ 218, 123 ], [ 254, 128 ], [ 200, 128 ], [ 212, 128 ], [ 257, 128 ], [ 239, 128 ], [ 203, 128 ], [ 260, 128 ], [ 197, 129 ], [ 230, 133 ], [ 233, 133 ], [ 215, 133 ], [ 248, 133 ], [ 224, 133 ], [ 251, 133 ], [ 209, 133 ], [ 227, 134 ], [ 230, 139 ], [ 233, 139 ], [ 215, 139 ], [ 248, 139 ], [ 224, 139 ], [ 251, 139 ], [ 209, 139 ], [ 227, 140 ], [ 217, 143 ], [ 256, 146 ], [ 197, 148 ], [ 224, 151 ], [ 251, 151 ], [ 209, 151 ], [ 230, 151 ], [ 233, 151 ], [ 215, 151 ], [ 248, 151 ], [ 227, 152 ], [ 218, 153 ], [ 206, 153 ], [ 221, 153 ], [ 242, 153 ], [ 236, 153 ], [ 247, 155 ], [ 227, 157 ], [ 224, 160 ], [ 251, 160 ], [ 209, 160 ], [ 230, 160 ], [ 233, 160 ], [ 215, 160 ], [ 248, 160 ], [ 227, 161 ], [ 218, 162 ], [ 206, 162 ], [ 221, 162 ], [ 242, 162 ], [ 236, 162 ], [ 254, 166 ], [ 200, 166 ], [ 212, 166 ], [ 257, 166 ], [ 239, 166 ], [ 203, 166 ], [ 260, 166 ], [ 197, 167 ], [ 235, 170 ], [ 214, 173 ], [ 227, 175 ], [ 257, 178 ], [ 239, 178 ], [ 203, 178 ], [ 260, 178 ], [ 254, 178 ], [ 200, 178 ], [ 212, 178 ], [ 197, 179 ], [ 236, 180 ], [ 218, 180 ], [ 206, 180 ], [ 221, 180 ], [ 242, 180 ], [ 211, 182 ], [ 197, 184 ], [ 257, 187 ], [ 239, 187 ], [ 203, 187 ], [ 260, 187 ], [ 254, 187 ], [ 200, 187 ], [ 212, 187 ], [ 197, 188 ], [ 236, 189 ], [ 218, 189 ], [ 206, 189 ], [ 221, 189 ], [ 242, 189 ], [ 212, 193 ], [ 257, 193 ], [ 239, 193 ], [ 203, 193 ], [ 260, 193 ], [ 254, 193 ], [ 200, 193 ], [ 215, 194 ], [ 248, 194 ], [ 224, 194 ], [ 251, 194 ], [ 209, 194 ], [ 230, 194 ], [ 233, 194 ], [ 226, 197 ], [ 199, 200 ], [ 202, 203 ], [ 205, 206 ], [ 227, 208 ], [ 208, 209 ], [ 211, 212 ], [ 214, 215 ], [ 217, 218 ], [ 220, 221 ], [ 223, 224 ], [ 226, 227 ], [ 227, 229 ], [ 229, 230 ], [ 232, 233 ], [ 235, 236 ], [ 238, 239 ], [ 241, 242 ], [ 244, 245 ], [ 247, 248 ], [ 250, 251 ], [ 197, 253 ], [ 253, 254 ], [ 256, 257 ], [ 197, 259 ], [ 259, 260 ] ]

[ "N=int(input())\nx,y=0,0\nfor i in range(N):\n p=0\n T,A=map(int,input().split())\n if i==0:\n x,y=T,A\n continue\n if x<=T and y<=A:\n x,y=T,A\n elif x<=T and A<y:\n if y%A!=0:\n p=1\n x=T*(y//A+p)\n y=A*(y//A+p)\n elif T<x and y<=T:\n if x%T!=0:\n p=1\n y=A*(x//T+p)\n x=T*(x//T+p)\n else:\n if (x//T+1)<=(y//A+1):\n if y%A!=0:\n p=1\n x=T*(y//A+p)\n y=A*(y//A+p)\n else:\n if x%T!=0:\n p=1\n y=A*(x//T+p)\n x=T*(x//T+p)\nprint(x+y)", "N=int(input())", "N", "int(input())", "int", "input()", "input", "x,y=0,0", "x", "0", "y", "0", "for i in range(N):\n p=0\n T,A=map(int,input().split())\n if i==0:\n x,y=T,A\n continue\n if x<=T and y<=A:\n x,y=T,A\n elif x<=T and A<y:\n if y%A!=0:\n p=1\n x=T*(y//A+p)\n y=A*(y//A+p)\n elif T<x and y<=T:\n if x%T!=0:\n p=1\n y=A*(x//T+p)\n x=T*(x//T+p)\n else:\n if (x//T+1)<=(y//A+1):\n if y%A!=0:\n p=1\n x=T*(y//A+p)\n y=A*(y//A+p)\n else:\n if x%T!=0:\n p=1\n y=A*(x//T+p)\n x=T*(x//T+p)", "i", "range(N)", "range", "N", "p=0", "p", "0", "T,A=map(int,input().split())", "T", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "A", "if i==0:\n x,y=T,A\n continue\n ", "i==0", "i", "0", "x,y=T,A", "x", "T", "y", "A", "continue", "if x<=T and y<=A:\n x,y=T,A\n elif x<=T and A<y:\n if y%A!=0:\n p=1\n x=T*(y//A+p)\n y=A*(y//A+p)\n elif T<x and y<=T:\n if x%T!=0:\n p=1\n y=A*(x//T+p)\n x=T*(x//T+p)\n else:\n if (x//T+1)<=(y//A+1):\n if y%A!=0:\n p=1\n x=T*(y//A+p)\n y=A*(y//A+p)\n else:\n if x%T!=0:\n p=1\n y=A*(x//T+p)\n x=T*(x//T+p)", "x<=T and y<=A", "x<=T", "x", "T", "y<=A", "y", "A", "x,y=T,A", "x", "T", "y", "A", "elif x<=T and A<y:\n if y%A!=0:\n p=1\n x=T*(y//A+p)\n y=A*(y//A+p)\n ", "x<=T and A<y", "x<=T", "x", "T", "A<y", "A", "y", "if y%A!=0:\n p=1\n ", "y%A!=0", "y%A", "y", "A", "0", "p=1", "p", "1", "x=T*(y//A+p)", "x", "T*(y//A+p)", "T", "y//A+p", "y//A", "y", "A", "p", "y=A*(y//A+p)", "y", "A*(y//A+p)", "A", "y//A+p", "y//A", "y", "A", "p", "elif T<x and y<=T:\n if x%T!=0:\n p=1\n y=A*(x//T+p)\n x=T*(x//T+p)\n ", "T<x and y<=T", "T<x", "T", "x", "y<=T", "y", "T", "if x%T!=0:\n p=1\n ", "x%T!=0", "x%T", "x", "T", "0", "p=1", "p", "1", "y=A*(x//T+p)", "y", "A*(x//T+p)", "A", "x//T+p", "x//T", "x", "T", "p", "x=T*(x//T+p)", "x", "T*(x//T+p)", "T", "x//T+p", "x//T", "x", "T", "p", "if (x//T+1)<=(y//A+1):\n if y%A!=0:\n p=1\n x=T*(y//A+p)\n y=A*(y//A+p)\n else:\n if x%T!=0:\n p=1\n y=A*(x//T+p)\n x=T*(x//T+p)", "(x//T+1)<=(y//A+1)", "x//T+1", "x//T", "x", "T", "1", "y//A+1", "y//A", "y", "A", "1", "if y%A!=0:\n p=1\n ", "y%A!=0", "y%A", "y", "A", "0", "p=1", "p", "1", "x=T*(y//A+p)", "x", "T*(y//A+p)", "T", "y//A+p", "y//A", "y", "A", "p", "y=A*(y//A+p)", "y", "A*(y//A+p)", "A", "y//A+p", "y//A", "y", "A", "p", "if x%T!=0:\n p=1\n ", "x%T!=0", "x%T", "x", "T", "0", "p=1", "p", "1", "y=A*(x//T+p)", "y", "A*(x//T+p)", "A", "x//T+p", "x//T", "x", "T", "p", "x=T*(x//T+p)", "x", "T*(x//T+p)", "T", "x//T+p", "x//T", "x", "T", "p", "print(x+y)", "print", "x+y", "x", "y", "T,A=map(int,input().split())", "map(int,input().split())", "T", "x,y=0,0", "0", "x", "x=T*(y//A+p)", "T*(y//A+p)", "x", "p=1", "1", "p", "y=T,A", "A", "y", "x=T*(x//T+p)", "T*(x//T+p)", "x", "y=A*(x//T+p)", "A*(x//T+p)", "y", "p=1", "1", "p", "p=1", "1", "p", "y=A*(x//T+p)", "A*(x//T+p)", "y", "A=map(int,input().split())", "map(int,input().split())", "A", "y=T,A", "A", "y", "y=0,0", "0", "y", "p=1", "1", "p", "x=T*(x//T+p)", "T*(x//T+p)", "x", "p=0", "0", "p", "N=int(input())", "int(input())", "N", "y=A*(y//A+p)", "A*(y//A+p)", "y", "y=A*(y//A+p)", "A*(y//A+p)", "y", "x,y=T,A", "T", "x", "x=T*(y//A+p)", "T*(y//A+p)", "x", "x,y=T,A", "T", "x" ]

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

[ [ 74, 2 ], [ 10, 9 ], [ 75, 12 ], [ 77, 25 ], [ 83, 29 ], [ 86, 38 ], [ 84, 46 ], [ 81, 46 ], [ 84, 55 ], [ 81, 55 ], [ 80, 60 ], [ 87, 63 ], [ 87, 66 ], [ 81, 72 ], [ 84, 72 ], [ 74, 75 ], [ 77, 78 ], [ 80, 81 ], [ 83, 84 ], [ 86, 87 ] ]

[ "N = int(input())\nRatio = [tuple(map(int, input().split())) for _ in range(N)]\nfrom math import ceil\nVote = (1, 1)\nfor t,a in Ratio:\n p = max((t+Vote[0]-1)//t, (a+Vote[1]-1)//a)\n Vote = (p*t, p*a)\nprint(sum(Vote))", "N = int(input())", "N", "int(input())", "int", "input()", "input", "tuple(map(int, input().split())) for _ in range(N)", "for _ in range(N)", "_", "range(N)", "range", "N", "for _ in range(N)", "tuple(map(int, input().split()))", "tuple", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "Ratio = [tuple(map(int, input().split())) for _ in range(N)]", "Ratio", "[tuple(map(int, input().split())) for _ in range(N)]", "from math import ceil", "Vote = (1, 1)", "Vote", "(1, 1)", "1", "1", "for t,a in Ratio:\n p = max((t+Vote[0]-1)//t, (a+Vote[1]-1)//a)\n Vote = (p*t, p*a)", "t", "a", "Ratio", "p = max((t+Vote[0]-1)//t, (a+Vote[1]-1)//a)", "p", "max((t+Vote[0]-1)//t, (a+Vote[1]-1)//a)", "max", "(t+Vote[0]-1)//t", "t+Vote[0]-1", "t+Vote[0]", "t", "Vote[0]", "Vote", "0", "1", "t", "(a+Vote[1]-1)//a", "a+Vote[1]-1", "a+Vote[1]", "a", "Vote[1]", "Vote", "1", "1", "a", "Vote = (p*t, p*a)", "Vote", "(p*t, p*a)", "p*t", "p", "t", "p*a", "p", "a", "print(sum(Vote))", "print", "sum(Vote)", "sum", "Vote", "N = int(input())", "int(input())", "N", "Ratio = [tuple(map(int, input().split())) for _ in range(N)]", "[tuple(map(int, input().split())) for _ in range(N)]", "Ratio", "Vote = (p*t, p*a)", "(p*t, p*a)", "Vote", "Vote = (1, 1)", "(1, 1)", "Vote", "p = max((t+Vote[0]-1)//t, (a+Vote[1]-1)//a)", "max((t+Vote[0]-1)//t, (a+Vote[1]-1)//a)", "p" ]

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

[ [ 108, 2 ], [ 10, 9 ], [ 109, 12 ], [ 111, 25 ], [ 114, 28 ], [ 120, 31 ], [ 37, 36 ], [ 58, 42 ], [ 62, 43 ], [ 60, 47 ], [ 64, 48 ], [ 36, 52 ], [ 62, 53 ], [ 36, 55 ], [ 64, 56 ], [ 58, 58 ], [ 60, 60 ], [ 62, 62 ], [ 64, 64 ], [ 67, 66 ], [ 109, 69 ], [ 117, 71 ], [ 106, 73 ], [ 115, 74 ], [ 103, 74 ], [ 121, 75 ], [ 124, 75 ], [ 112, 78 ], [ 66, 79 ], [ 112, 83 ], [ 66, 84 ], [ 102, 87 ], [ 118, 89 ], [ 123, 92 ], [ 118, 94 ], [ 103, 99 ], [ 115, 99 ], [ 124, 100 ], [ 121, 100 ], [ 102, 103 ], [ 108, 109 ], [ 111, 112 ], [ 114, 115 ], [ 117, 118 ], [ 120, 121 ], [ 123, 124 ] ]

[ "N=int(input())\nTA=[list(map(int,input().split())) for i in range(N)]\nTaka=1\nAoki=1\n\ndef UP(V1,V2,R1,R2):\n n=max(-(-V1//R1),-(-V2//R2))\n return(n*R1,n*R2)\n\nfor i in range(N):\n up=UP(Taka,Aoki,TA[i][0],TA[i][1])\n# print(up)\n Taka=up[0]\n Aoki=up[1]\n\nprint(Taka+Aoki)", "N=int(input())", "N", "int(input())", "int", "input()", "input", "list(map(int,input().split())) for i in range(N)", "for i in range(N)", "i", "range(N)", "range", "N", "for i in range(N)", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "TA=[list(map(int,input().split())) for i in range(N)]", "TA", "[list(map(int,input().split())) for i in range(N)]", "Taka=1", "Taka", "1", "Aoki=1", "Aoki", "1", "def UP(V1,V2,R1,R2):\n n=max(-(-V1//R1),-(-V2//R2))\n return(n*R1,n*R2)", "UP", "n=max(-(-V1//R1),-(-V2//R2))", "n", "max(-(-V1//R1),-(-V2//R2))", "max", "-(-V1//R1)", "-V1//R1", "-V1", "V1", "R1", "-(-V2//R2)", "-V2//R2", "-V2", "V2", "R2", "return(n*R1,n*R2)", "(n*R1,n*R2)", "n*R1", "n", "R1", "n*R2", "n", "R2", "V1", "V1", "V2", "V2", "R1", "R1", "R2", "R2", "for i in range(N):\n up=UP(Taka,Aoki,TA[i][0],TA[i][1])\n# print(up)\n Taka=up[0]\n Aoki=up[1]", "i", "range(N)", "range", "N", "up=UP(Taka,Aoki,TA[i][0],TA[i][1])", "up", "UP(Taka,Aoki,TA[i][0],TA[i][1])", "UP", "Taka", "Aoki", "TA[i][0]", "[i]", "TA", "i", "0", "TA[i][1]", "[i]", "TA", "i", "1", "Taka=up[0]", "Taka", "up[0]", "up", "0", "Aoki=up[1]", "Aoki", "up[1]", "up", "1", "print(Taka+Aoki)", "print", "Taka+Aoki", "Taka", "Aoki", "Taka=up[0]", "up[0]", "Taka", "def UP(V1,V2,R1,R2):\n n=max(-(-V1//R1),-(-V2//R2))\n return(n*R1,n*R2)", "def UP(V1,V2,R1,R2):\n n=max(-(-V1//R1),-(-V2//R2))\n return(n*R1,n*R2)", "UP", "N=int(input())", "int(input())", "N", "TA=[list(map(int,input().split())) for i in range(N)]", "[list(map(int,input().split())) for i in range(N)]", "TA", "Taka=1", "1", "Taka", "up=UP(Taka,Aoki,TA[i][0],TA[i][1])", "UP(Taka,Aoki,TA[i][0],TA[i][1])", "up", "Aoki=1", "1", "Aoki", "Aoki=up[1]", "up[1]", "Aoki" ]

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

[ [ 111, 2 ], [ 10, 9 ], [ 112, 12 ], [ 132, 25 ], [ 141, 28 ], [ 133, 31 ], [ 35, 34 ], [ 112, 38 ], [ 156, 40 ], [ 142, 42 ], [ 34, 44 ], [ 156, 46 ], [ 144, 48 ], [ 133, 50 ], [ 34, 51 ], [ 144, 52 ], [ 153, 54 ], [ 157, 57 ], [ 145, 58 ], [ 127, 58 ], [ 153, 59 ], [ 135, 61 ], [ 115, 64 ], [ 130, 65 ], [ 121, 65 ], [ 135, 66 ], [ 154, 69 ], [ 117, 72 ], [ 136, 76 ], [ 147, 79 ], [ 150, 82 ], [ 118, 85 ], [ 139, 85 ], [ 148, 86 ], [ 124, 86 ], [ 126, 88 ], [ 145, 90 ], [ 127, 90 ], [ 151, 91 ], [ 120, 92 ], [ 130, 94 ], [ 121, 94 ], [ 151, 95 ], [ 142, 98 ], [ 142, 108 ], [ 111, 112 ], [ 156, 115 ], [ 117, 118 ], [ 120, 121 ], [ 135, 124 ], [ 126, 127 ], [ 144, 130 ], [ 132, 133 ], [ 135, 136 ], [ 153, 139 ], [ 141, 142 ], [ 144, 145 ], [ 147, 148 ], [ 150, 151 ], [ 153, 154 ], [ 156, 157 ] ]

[ "n = int(input())\nTA = [list(map(int, input().split())) for _ in range(n)]\n\nXY = [TA[0]]\n\nfor i in range(1, n):\n x0, y0 = XY[i-1]\n x1, y1 = TA[i]\n xq, xr = divmod(x0, x1)\n yq, yr = divmod(y0, y1)\n if xr != 0:\n xq += 1\n if yr != 0:\n yq += 1\n q = max(xq, yq)\n x1, y1 = x1*q, y1*q\n XY.append([x1, y1])\n \nprint(sum(XY[-1]))", "n = int(input())", "n", "int(input())", "int", "input()", "input", "list(map(int, input().split())) for _ in range(n)", "for _ in range(n)", "_", "range(n)", "range", "n", "for _ in range(n)", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "TA = [list(map(int, input().split())) for _ in range(n)]", "TA", "[list(map(int, input().split())) for _ in range(n)]", "XY = [TA[0]]", "XY", "[TA[0]]", "TA[0]", "TA", "0", "for i in range(1, n):\n x0, y0 = XY[i-1]\n x1, y1 = TA[i]\n xq, xr = divmod(x0, x1)\n yq, yr = divmod(y0, y1)\n if xr != 0:\n xq += 1\n if yr != 0:\n yq += 1\n q = max(xq, yq)\n x1, y1 = x1*q, y1*q\n XY.append([x1, y1])\n ", "i", "range(1, n)", "range", "1", "n", "x0, y0 = XY[i-1]", "x0", "XY[i-1]", "XY", "i-1", "i", "1", "y0", "x1, y1 = TA[i]", "x1", "TA[i]", "TA", "i", "y1", "xq, xr = divmod(x0, x1)", "xq", "divmod(x0, x1)", "divmod", "x0", "x1", "xr", "yq, yr = divmod(y0, y1)", "yq", "divmod(y0, y1)", "divmod", "y0", "y1", "yr", "if xr != 0:\n xq += 1\n ", "xr != 0", "xr", "0", "xq += 1", "xq", "1", "if yr != 0:\n yq += 1\n ", "yr != 0", "yr", "0", "yq += 1", "yq", "1", "q = max(xq, yq)", "q", "max(xq, yq)", "max", "xq", "yq", "x1, y1 = x1*q, y1*q", "x1", "x1*q", "x1", "q", "y1", "y1*q", "y1", "q", "XY.append([x1, y1])", "XY.append", "XY", "append", "[x1, y1]", "x1", "y1", "print(sum(XY[-1]))", "print", "sum(XY[-1])", "sum", "XY[-1]", "XY", "-1", "n = int(input())", "int(input())", "n", "y0 = XY[i-1]", "XY[i-1]", "y0", "xq += 1", "1", "xq", "y1 = x1*q, y1*q", "y1*q", "y1", "yq, yr = divmod(y0, y1)", "divmod(y0, y1)", "yq", "x1, y1 = x1*q, y1*q", "x1*q", "x1", "y1 = TA[i]", "TA[i]", "y1", "TA = [list(map(int, input().split())) for _ in range(n)]", "[list(map(int, input().split())) for _ in range(n)]", "TA", "yr = divmod(y0, y1)", "divmod(y0, y1)", "yr", "xq, xr = divmod(x0, x1)", "divmod(x0, x1)", "xq", "XY = [TA[0]]", "[TA[0]]", "XY", "x1, y1 = TA[i]", "TA[i]", "x1", "yq += 1", "1", "yq", "q = max(xq, yq)", "max(xq, yq)", "q", "xr = divmod(x0, x1)", "divmod(x0, x1)", "xr", "x0, y0 = XY[i-1]", "XY[i-1]", "x0" ]

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

[ [ 80, 2 ], [ 68, 8 ], [ 71, 10 ], [ 14, 13 ], [ 81, 16 ], [ 77, 18 ], [ 77, 27 ], [ 83, 29 ], [ 69, 35 ], [ 66, 35 ], [ 75, 36 ], [ 75, 38 ], [ 72, 42 ], [ 63, 42 ], [ 78, 43 ], [ 78, 45 ], [ 65, 47 ], [ 84, 49 ], [ 75, 50 ], [ 62, 52 ], [ 84, 54 ], [ 78, 55 ], [ 66, 59 ], [ 69, 59 ], [ 63, 60 ], [ 72, 60 ], [ 62, 63 ], [ 65, 66 ], [ 68, 69 ], [ 71, 72 ], [ 77, 75 ], [ 77, 78 ], [ 80, 81 ], [ 83, 84 ] ]

[ "N = int(input())\na, b = 1, 1\nfor i in range(N):\n x, y = map(int, input().split())\n n = max((a + x - 1) // x, (b + y - 1) // y)\n a = n * x\n b = n * y\nprint(a + b)", "N = int(input())", "N", "int(input())", "int", "input()", "input", "a, b = 1, 1", "a", "1", "b", "1", "for i in range(N):\n x, y = map(int, input().split())\n n = max((a + x - 1) // x, (b + y - 1) // y)\n a = n * x\n b = n * y", "i", "range(N)", "range", "N", "x, y = map(int, input().split())", "x", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "y", "n = max((a + x - 1) // x, (b + y - 1) // y)", "n", "max((a + x - 1) // x, (b + y - 1) // y)", "max", "(a + x - 1) // x", "a + x - 1", "a + x", "a", "x", "1", "x", "(b + y - 1) // y", "b + y - 1", "b + y", "b", "y", "1", "y", "a = n * x", "a", "n * x", "n", "x", "b = n * y", "b", "n * y", "n", "y", "print(a + b)", "print", "a + b", "a", "b", "b = n * y", "n * y", "b", "a = n * x", "n * x", "a", "a, b = 1, 1", "1", "a", "b = 1, 1", "1", "b", "x, y = map(int, input().split())", "map(int, input().split())", "x", "y = map(int, input().split())", "map(int, input().split())", "y", "N = int(input())", "int(input())", "N", "n = max((a + x - 1) // x, (b + y - 1) // y)", "max((a + x - 1) // x, (b + y - 1) // y)", "n" ]

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

[ [ 82, 2 ], [ 79, 8 ], [ 91, 11 ], [ 15, 14 ], [ 83, 17 ], [ 103, 19 ], [ 103, 28 ], [ 80, 32 ], [ 98, 32 ], [ 89, 32 ], [ 101, 33 ], [ 92, 35 ], [ 95, 35 ], [ 86, 35 ], [ 104, 36 ], [ 88, 38 ], [ 80, 43 ], [ 98, 43 ], [ 89, 43 ], [ 104, 44 ], [ 104, 46 ], [ 104, 47 ], [ 85, 49 ], [ 89, 52 ], [ 80, 52 ], [ 98, 52 ], [ 104, 53 ], [ 101, 54 ], [ 94, 56 ], [ 92, 61 ], [ 95, 61 ], [ 86, 61 ], [ 101, 62 ], [ 101, 64 ], [ 101, 65 ], [ 97, 67 ], [ 95, 70 ], [ 92, 70 ], [ 86, 70 ], [ 101, 71 ], [ 104, 72 ], [ 98, 76 ], [ 89, 76 ], [ 80, 76 ], [ 95, 77 ], [ 86, 77 ], [ 92, 77 ], [ 79, 80 ], [ 82, 83 ], [ 85, 86 ], [ 88, 89 ], [ 91, 92 ], [ 94, 95 ], [ 97, 98 ], [ 103, 101 ], [ 103, 104 ] ]

[ "n = int(input())\n\nt_vote = 1\na_vote = 1\n\nfor _ in range(n):\n t,a = map(int,input().split())\n if t_vote*a > a_vote*t:\n t_vote = (t_vote + t-1)//t*t\n a_vote = t_vote//t*a\n else:\n a_vote = (a_vote + a-1)//a*a\n t_vote = a_vote//a*t\nprint(t_vote+a_vote)", "n = int(input())", "n", "int(input())", "int", "input()", "input", "t_vote = 1", "t_vote", "1", "a_vote = 1", "a_vote", "1", "for _ in range(n):\n t,a = map(int,input().split())\n if t_vote*a > a_vote*t:\n t_vote = (t_vote + t-1)//t*t\n a_vote = t_vote//t*a\n else:\n a_vote = (a_vote + a-1)//a*a\n t_vote = a_vote//a*t", "_", "range(n)", "range", "n", "t,a = map(int,input().split())", "t", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "a", "if t_vote*a > a_vote*t:\n t_vote = (t_vote + t-1)//t*t\n a_vote = t_vote//t*a\n else:\n a_vote = (a_vote + a-1)//a*a\n t_vote = a_vote//a*t", "t_vote*a > a_vote*t", "t_vote*a", "t_vote", "a", "a_vote*t", "a_vote", "t", "t_vote = (t_vote + t-1)//t*t", "t_vote", "(t_vote + t-1)//t*t", "(t_vote + t-1)//t", "t_vote + t-1", "t_vote + t", "t_vote", "t", "1", "t", "t", "a_vote = t_vote//t*a", "a_vote", "t_vote//t*a", "t_vote//t", "t_vote", "t", "a", "a_vote = (a_vote + a-1)//a*a", "a_vote", "(a_vote + a-1)//a*a", "(a_vote + a-1)//a", "a_vote + a-1", "a_vote + a", "a_vote", "a", "1", "a", "a", "t_vote = a_vote//a*t", "t_vote", "a_vote//a*t", "a_vote//a", "a_vote", "a", "t", "print(t_vote+a_vote)", "print", "t_vote+a_vote", "t_vote", "a_vote", "t_vote = 1", "1", "t_vote", "n = int(input())", "int(input())", "n", "a_vote = t_vote//t*a", "t_vote//t*a", "a_vote", "t_vote = (t_vote + t-1)//t*t", "(t_vote + t-1)//t*t", "t_vote", "a_vote = 1", "1", "a_vote", "a_vote = (a_vote + a-1)//a*a", "(a_vote + a-1)//a*a", "a_vote", "t_vote = a_vote//a*t", "a_vote//a*t", "t_vote", "a = map(int,input().split())", "map(int,input().split())", "a", "t,a = map(int,input().split())", "map(int,input().split())", "t" ]

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

[ [ 81, 4 ], [ 60, 10 ], [ 75, 13 ], [ 17, 16 ], [ 82, 19 ], [ 69, 21 ], [ 69, 30 ], [ 63, 32 ], [ 61, 38 ], [ 79, 38 ], [ 67, 39 ], [ 76, 43 ], [ 73, 43 ], [ 70, 44 ], [ 78, 46 ], [ 67, 48 ], [ 64, 49 ], [ 72, 50 ], [ 70, 52 ], [ 64, 53 ], [ 79, 57 ], [ 61, 57 ], [ 73, 58 ], [ 76, 58 ], [ 60, 61 ], [ 63, 64 ], [ 69, 67 ], [ 69, 70 ], [ 72, 73 ], [ 75, 76 ], [ 78, 79 ], [ 81, 82 ] ]

[ "import math\n\n#in1 = '5'\n#in2 = ['1 2','2 1','1 1','3 1','1 1']\n#n = int(in1)\nn = int(input())\n\ntall = 1\naall = 1\nfor idx1 in range(n):\n t, a = map(int, input().split())\n #t, a = map(int, in2[idx1].split())\n mul = max(-(-tall // t), -(-aall // a))\n tall, aall = t * mul, a * mul\n #print(tall, aall)\n\nprint(tall + aall)", "import math", "math", "n = int(input())", "n", "int(input())", "int", "input()", "input", "tall = 1", "tall", "1", "aall = 1", "aall", "1", "for idx1 in range(n):\n t, a = map(int, input().split())\n #t, a = map(int, in2[idx1].split())\n mul = max(-(-tall // t), -(-aall // a))\n tall, aall = t * mul, a * mul\n #print(tall, aall)", "idx1", "range(n)", "range", "n", "t, a = map(int, input().split())", "t", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "a", "mul = max(-(-tall // t), -(-aall // a))", "mul", "max(-(-tall // t), -(-aall // a))", "max", "-(-tall // t)", "-tall // t", "-tall", "tall", "t", "-(-aall // a)", "-aall // a", "-aall", "aall", "a", "tall, aall = t * mul, a * mul", "tall", "t * mul", "t", "mul", "aall", "a * mul", "a", "mul", "print(tall + aall)", "print", "tall + aall", "tall", "aall", "tall = 1", "1", "tall", "mul = max(-(-tall // t), -(-aall // a))", "max(-(-tall // t), -(-aall // a))", "mul", "t, a = map(int, input().split())", "map(int, input().split())", "t", "a = map(int, input().split())", "map(int, input().split())", "a", "aall = t * mul, a * mul", "a * mul", "aall", "aall = 1", "1", "aall", "tall, aall = t * mul, a * mul", "t * mul", "tall", "n = int(input())", "int(input())", "n" ]

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

[ [ 89, 2 ], [ 101, 8 ], [ 104, 11 ], [ 15, 14 ], [ 90, 17 ], [ 116, 19 ], [ 116, 28 ], [ 93, 31 ], [ 110, 34 ], [ 102, 35 ], [ 114, 35 ], [ 98, 37 ], [ 102, 41 ], [ 114, 41 ], [ 93, 43 ], [ 117, 47 ], [ 107, 50 ], [ 105, 51 ], [ 84, 51 ], [ 95, 53 ], [ 105, 57 ], [ 84, 57 ], [ 117, 59 ], [ 86, 62 ], [ 99, 65 ], [ 111, 65 ], [ 96, 66 ], [ 108, 66 ], [ 113, 68 ], [ 87, 70 ], [ 93, 71 ], [ 83, 73 ], [ 87, 75 ], [ 117, 76 ], [ 114, 80 ], [ 102, 80 ], [ 84, 81 ], [ 105, 81 ], [ 83, 84 ], [ 86, 87 ], [ 89, 90 ], [ 116, 93 ], [ 95, 96 ], [ 98, 99 ], [ 101, 102 ], [ 104, 105 ], [ 105, 107 ], [ 84, 107 ], [ 107, 108 ], [ 102, 110 ], [ 114, 110 ], [ 110, 111 ], [ 113, 114 ], [ 116, 117 ] ]

[ "n=int(input())\nans_t=1\nans_a=1\nfor i in range(n):\n t,a=map(int,input().split())\n if t==1:\n k1=ans_t\n else:\n \tk1=(ans_t-1)//t+1\n if a==1:\n k2=ans_a\n else:\n \tk2=(ans_a-1)//a+1\n k=max(k1,k2)\n ans_t=k*t\n ans_a=k*a\nprint(ans_t+ans_a)", "n=int(input())", "n", "int(input())", "int", "input()", "input", "ans_t=1", "ans_t", "1", "ans_a=1", "ans_a", "1", "for i in range(n):\n t,a=map(int,input().split())\n if t==1:\n k1=ans_t\n else:\n \tk1=(ans_t-1)//t+1\n if a==1:\n k2=ans_a\n else:\n \tk2=(ans_a-1)//a+1\n k=max(k1,k2)\n ans_t=k*t\n ans_a=k*a", "i", "range(n)", "range", "n", "t,a=map(int,input().split())", "t", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "a", "if t==1:\n k1=ans_t\n else:\n \tk1=(ans_t-1)//t+1\n ", "t==1", "t", "1", "k1=ans_t", "k1", "ans_t", "k1=(ans_t-1)//t+1", "k1", "(ans_t-1)//t+1", "(ans_t-1)//t", "ans_t-1", "ans_t", "1", "t", "1", "if a==1:\n k2=ans_a\n else:\n \tk2=(ans_a-1)//a+1\n ", "a==1", "a", "1", "k2=ans_a", "k2", "ans_a", "k2=(ans_a-1)//a+1", "k2", "(ans_a-1)//a+1", "(ans_a-1)//a", "ans_a-1", "ans_a", "1", "a", "1", "k=max(k1,k2)", "k", "max(k1,k2)", "max", "k1", "k2", "ans_t=k*t", "ans_t", "k*t", "k", "t", "ans_a=k*a", "ans_a", "k*a", "k", "a", "print(ans_t+ans_a)", "print", "ans_t+ans_a", "ans_t", "ans_a", "ans_a=k*a", "k*a", "ans_a", "k=max(k1,k2)", "max(k1,k2)", "k", "n=int(input())", "int(input())", "n", "t,a=map(int,input().split())", "map(int,input().split())", "t", "k2=(ans_a-1)//a+1", "(ans_a-1)//a+1", "k2", "k1=(ans_t-1)//t+1", "(ans_t-1)//t+1", "k1", "ans_t=1", "1", "ans_t", "ans_a=1", "1", "ans_a", "k2=ans_a", "ans_a", "k2", "k1=ans_t", "ans_t", "k1", "ans_t=k*t", "k*t", "ans_t", "a=map(int,input().split())", "map(int,input().split())", "a" ]

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

[ [ 103, 2 ], [ 106, 8 ], [ 118, 11 ], [ 15, 14 ], [ 104, 17 ], [ 21, 20 ], [ 20, 29 ], [ 121, 31 ], [ 121, 33 ], [ 97, 35 ], [ 107, 39 ], [ 116, 39 ], [ 89, 41 ], [ 91, 44 ], [ 89, 46 ], [ 98, 47 ], [ 101, 47 ], [ 124, 49 ], [ 122, 51 ], [ 98, 52 ], [ 101, 52 ], [ 119, 55 ], [ 113, 55 ], [ 125, 56 ], [ 110, 56 ], [ 100, 58 ], [ 119, 62 ], [ 113, 62 ], [ 122, 64 ], [ 94, 67 ], [ 89, 69 ], [ 101, 70 ], [ 98, 70 ], [ 109, 72 ], [ 122, 74 ], [ 101, 75 ], [ 98, 75 ], [ 115, 77 ], [ 95, 78 ], [ 92, 78 ], [ 112, 80 ], [ 110, 81 ], [ 125, 81 ], [ 113, 85 ], [ 119, 85 ], [ 116, 86 ], [ 107, 86 ], [ 121, 89 ], [ 91, 92 ], [ 94, 95 ], [ 97, 98 ], [ 100, 101 ], [ 103, 104 ], [ 106, 107 ], [ 109, 110 ], [ 110, 112 ], [ 125, 112 ], [ 112, 113 ], [ 95, 115 ], [ 92, 115 ], [ 115, 116 ], [ 118, 119 ], [ 121, 122 ], [ 124, 125 ] ]

[ "n = int(input())\ntvote = 1\navote = 1\n\nfor i in range(n):\n\tt, a = [int(n) for n in input().split()]\n\tk = (tvote-1)//t + 1\n\ttnow = t * k\n\tanow = a * k\n\tif avote > anow:\n\t\tk = (avote-1)//a + 1\n\t\ttnow = t * k\n\t\tanow = a * k\n\ttvote = tnow\n\tavote = anow\n\t\nprint(avote+tvote)", "n = int(input())", "n", "int(input())", "int", "input()", "input", "tvote = 1", "tvote", "1", "avote = 1", "avote", "1", "for i in range(n):\n\tt, a = [int(n) for n in input().split()]\n\tk = (tvote-1)//t + 1\n\ttnow = t * k\n\tanow = a * k\n\tif avote > anow:\n\t\tk = (avote-1)//a + 1\n\t\ttnow = t * k\n\t\tanow = a * k\n\ttvote = tnow\n\tavote = anow\n\t", "i", "range(n)", "range", "n", "int(n) for n in input().split()", "for n in input().split()", "n", "input().split()", "().split", "()", "input", "split", "for n in input().split()", "int(n)", "int", "n", "t, a = [int(n) for n in input().split()]", "t", "[int(n) for n in input().split()]", "a", "k = (tvote-1)//t + 1", "k", "(tvote-1)//t + 1", "(tvote-1)//t", "tvote-1", "tvote", "1", "t", "1", "tnow = t * k", "tnow", "t * k", "t", "k", "anow = a * k", "anow", "a * k", "a", "k", "if avote > anow:\n\t\tk = (avote-1)//a + 1\n\t\ttnow = t * k\n\t\tanow = a * k\n\t", "avote > anow", "avote", "anow", "k = (avote-1)//a + 1", "k", "(avote-1)//a + 1", "(avote-1)//a", "avote-1", "avote", "1", "a", "1", "tnow = t * k", "tnow", "t * k", "t", "k", "anow = a * k", "anow", "a * k", "a", "k", "tvote = tnow", "tvote", "tnow", "avote = anow", "avote", "anow", "print(avote+tvote)", "print", "avote+tvote", "avote", "tvote", "t, a = [int(n) for n in input().split()]", "[int(n) for n in input().split()]", "t", "tnow = t * k", "t * k", "tnow", "tnow = t * k", "t * k", "tnow", "k = (tvote-1)//t + 1", "(tvote-1)//t + 1", "k", "k = (avote-1)//a + 1", "(avote-1)//a + 1", "k", "n = int(input())", "int(input())", "n", "tvote = 1", "1", "tvote", "anow = a * k", "a * k", "anow", "avote = anow", "anow", "avote", "tvote = tnow", "tnow", "tvote", "avote = 1", "1", "avote", "a = [int(n) for n in input().split()]", "[int(n) for n in input().split()]", "a", "anow = a * k", "a * k", "anow" ]

[ 7, 0, 13, 4, 13, 4, 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, 0, 13, 39, 18, 13, 17, 18, 13, 17, 28, 13, 4, 13, 17, 13, 0, 13, 4, 13, 40, 2, 40, 18, 13, 17, 18, 13, 13, 40, 2, 40, 18, 13, 17, 18, 13, 13, 0, 18, 13, 17, 2, 13, 18, 13, 13, 0, 18, 13, 17, 2, 13, 18, 13, 13, 4, 13, 2, 18, 13, 17, 18, 13, 17, 10, 4, 13, 10, 39, 13, 10, 2, 13, 10, 4, 13, 10, 2, 13 ]

[ [ 113, 2 ], [ 110, 8 ], [ 114, 12 ], [ 116, 14 ], [ 114, 18 ], [ 21, 20 ], [ 114, 23 ], [ 28, 25 ], [ 111, 26 ], [ 20, 27 ], [ 28, 36 ], [ 117, 37 ], [ 20, 38 ], [ 107, 40 ], [ 111, 43 ], [ 117, 46 ], [ 50, 49 ], [ 114, 53 ], [ 104, 55 ], [ 108, 62 ], [ 25, 64 ], [ 111, 65 ], [ 49, 66 ], [ 108, 71 ], [ 36, 73 ], [ 117, 74 ], [ 49, 75 ], [ 80, 77 ], [ 108, 78 ], [ 105, 81 ], [ 25, 82 ], [ 111, 83 ], [ 49, 84 ], [ 89, 86 ], [ 108, 87 ], [ 105, 90 ], [ 36, 91 ], [ 117, 92 ], [ 49, 93 ], [ 108, 98 ], [ 108, 101 ], [ 104, 105 ], [ 107, 108 ], [ 110, 111 ], [ 113, 114 ], [ 116, 117 ] ]

[ "n = int(input())\nT = [0]*n\nA = [0]*n\n\nfor i in range(n):\n T[i],A[i] = map(int,input().split())\n\nvotes = [T[0],A[0]]\n\nfor i in range(1,n):\n m = max(-(-votes[0]//T[i]),-(-votes[1]//A[i]))\n votes[0] = m*T[i]\n votes[1] = m*A[i]\n\nprint(votes[0]+votes[1])\n\n#floatで正確に表示できるのは15桁程度", "n = int(input())", "n", "int(input())", "int", "input()", "input", "T = [0]*n", "T", "[0]*n", "[0]", "0", "n", "A = [0]*n", "A", "[0]*n", "[0]", "0", "n", "for i in range(n):\n T[i],A[i] = map(int,input().split())", "i", "range(n)", "range", "n", "T[i],A[i] = map(int,input().split())", "T[i]", "T", "i", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "A[i]", "A", "i", "votes = [T[0],A[0]]", "votes", "[T[0],A[0]]", "T[0]", "T", "0", "A[0]", "A", "0", "for i in range(1,n):\n m = max(-(-votes[0]//T[i]),-(-votes[1]//A[i]))\n votes[0] = m*T[i]\n votes[1] = m*A[i]", "i", "range(1,n)", "range", "1", "n", "m = max(-(-votes[0]//T[i]),-(-votes[1]//A[i]))", "m", "max(-(-votes[0]//T[i]),-(-votes[1]//A[i]))", "max", "-(-votes[0]//T[i])", "-votes[0]//T[i]", "-votes[0]", "votes[0]", "votes", "0", "T[i]", "T", "i", "-(-votes[1]//A[i])", "-votes[1]//A[i]", "-votes[1]", "votes[1]", "votes", "1", "A[i]", "A", "i", "votes[0] = m*T[i]", "votes[0]", "votes", "0", "m*T[i]", "m", "T[i]", "T", "i", "votes[1] = m*A[i]", "votes[1]", "votes", "1", "m*A[i]", "m", "A[i]", "A", "i", "print(votes[0]+votes[1])", "print", "votes[0]+votes[1]", "votes[0]", "votes", "0", "votes[1]", "votes", "1", "m = max(-(-votes[0]//T[i]),-(-votes[1]//A[i]))", "max(-(-votes[0]//T[i]),-(-votes[1]//A[i]))", "m", "votes = [T[0],A[0]]", "[T[0],A[0]]", "votes", "T = [0]*n", "[0]*n", "T", "n = int(input())", "int(input())", "n", "A = [0]*n", "[0]*n", "A" ]

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

[ [ 172, 4 ], [ 16, 15 ], [ 173, 19 ], [ 23, 22 ], [ 15, 25 ], [ 173, 35 ], [ 39, 38 ], [ 42, 41 ], [ 38, 44 ], [ 48, 47 ], [ 38, 50 ], [ 55, 54 ], [ 15, 58 ], [ 62, 61 ], [ 65, 64 ], [ 38, 67 ], [ 61, 68 ], [ 54, 68 ], [ 71, 70 ], [ 38, 73 ], [ 61, 74 ], [ 54, 74 ], [ 64, 79 ], [ 41, 80 ], [ 152, 80 ], [ 129, 80 ], [ 105, 80 ], [ 85, 80 ], [ 70, 82 ], [ 47, 83 ], [ 156, 83 ], [ 133, 83 ], [ 109, 83 ], [ 87, 83 ], [ 86, 85 ], [ 64, 86 ], [ 88, 87 ], [ 70, 88 ], [ 64, 92 ], [ 41, 93 ], [ 152, 93 ], [ 129, 93 ], [ 105, 93 ], [ 85, 93 ], [ 70, 95 ], [ 47, 96 ], [ 156, 96 ], [ 133, 96 ], [ 109, 96 ], [ 87, 96 ], [ 99, 98 ], [ 41, 102 ], [ 152, 102 ], [ 129, 102 ], [ 105, 102 ], [ 85, 102 ], [ 64, 103 ], [ 106, 105 ], [ 64, 107 ], [ 98, 108 ], [ 122, 108 ], [ 110, 109 ], [ 70, 111 ], [ 98, 112 ], [ 122, 112 ], [ 64, 116 ], [ 41, 117 ], [ 152, 117 ], [ 129, 117 ], [ 105, 117 ], [ 85, 117 ], [ 70, 119 ], [ 47, 120 ], [ 156, 120 ], [ 133, 120 ], [ 109, 120 ], [ 87, 120 ], [ 123, 122 ], [ 47, 126 ], [ 156, 126 ], [ 133, 126 ], [ 109, 126 ], [ 87, 126 ], [ 70, 127 ], [ 130, 129 ], [ 64, 131 ], [ 122, 132 ], [ 98, 132 ], [ 134, 133 ], [ 70, 135 ], [ 122, 136 ], [ 98, 136 ], [ 139, 138 ], [ 41, 144 ], [ 152, 144 ], [ 129, 144 ], [ 105, 144 ], [ 85, 144 ], [ 64, 145 ], [ 47, 149 ], [ 156, 149 ], [ 133, 149 ], [ 109, 149 ], [ 87, 149 ], [ 70, 150 ], [ 153, 152 ], [ 64, 154 ], [ 138, 155 ], [ 157, 156 ], [ 70, 158 ], [ 138, 159 ], [ 152, 163 ], [ 129, 163 ], [ 105, 163 ], [ 85, 163 ], [ 41, 163 ], [ 156, 164 ], [ 133, 164 ], [ 109, 164 ], [ 87, 164 ], [ 47, 164 ], [ 176, 170 ], [ 172, 173 ] ]

[ "import sys\ninput = sys.stdin.buffer.readline\n\ndef main():\n N = int(input())\n X = [list(map(int,input().split())) for _ in range(N)]\n na,nb = X[0][0],X[0][1]\n for i in range(N-1):\n i += 1\n x,y = X[i][0],X[i][1]\n if (x >= na and y >= nb):\n na,nb = x,y\n elif (x < na and y >= nb):\n q = -(-na//x)\n na,nb = x*q,y*q\n elif (x >= na and y < nb):\n q = -(-nb//y)\n na,nb = x*q,y*q\n else:\n use = max(-(-na//x),-(-nb//y))\n na,nb = x*use,y*use\n \n print(na+nb)\n \nif __name__ == \"__main__\":\n main()", "import sys", "sys", "input = sys.stdin.buffer.readline", "input", "sys.stdin.buffer.readline", "sys.stdin.buffer", "sys.stdin", "sys", "stdin", "buffer", "readline", "def main():\n N = int(input())\n X = [list(map(int,input().split())) for _ in range(N)]\n na,nb = X[0][0],X[0][1]\n for i in range(N-1):\n i += 1\n x,y = X[i][0],X[i][1]\n if (x >= na and y >= nb):\n na,nb = x,y\n elif (x < na and y >= nb):\n q = -(-na//x)\n na,nb = x*q,y*q\n elif (x >= na and y < nb):\n q = -(-nb//y)\n na,nb = x*q,y*q\n else:\n use = max(-(-na//x),-(-nb//y))\n na,nb = x*use,y*use\n \n print(na+nb)\n ", "main", "N = int(input())", "N", "int(input())", "int", "input()", "input", "list(map(int,input().split())) for _ in range(N)", "for _ in range(N)", "_", "range(N)", "range", "N", "for _ in range(N)", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "X = [list(map(int,input().split())) for _ in range(N)]", "X", "[list(map(int,input().split())) for _ in range(N)]", "na,nb = X[0][0],X[0][1]", "na", "X[0][0]", "[0]", "X", "0", "0", "nb", "X[0][1]", "[0]", "X", "0", "1", "for i in range(N-1):\n i += 1\n x,y = X[i][0],X[i][1]\n if (x >= na and y >= nb):\n na,nb = x,y\n elif (x < na and y >= nb):\n q = -(-na//x)\n na,nb = x*q,y*q\n elif (x >= na and y < nb):\n q = -(-nb//y)\n na,nb = x*q,y*q\n else:\n use = max(-(-na//x),-(-nb//y))\n na,nb = x*use,y*use\n \n ", "i", "range(N-1)", "range", "N-1", "N", "1", "i += 1", "i", "1", "x,y = X[i][0],X[i][1]", "x", "X[i][0]", "[i]", "X", "i", "0", "y", "X[i][1]", "[i]", "X", "i", "1", "if (x >= na and y >= nb):\n na,nb = x,y\n elif (x < na and y >= nb):\n q = -(-na//x)\n na,nb = x*q,y*q\n elif (x >= na and y < nb):\n q = -(-nb//y)\n na,nb = x*q,y*q\n else:\n use = max(-(-na//x),-(-nb//y))\n na,nb = x*use,y*use\n \n ", "x >= na and y >= nb", "x >= na", "x", "na", "y >= nb", "y", "nb", "na,nb = x,y", "na", "x", "nb", "y", "elif (x < na and y >= nb):\n q = -(-na//x)\n na,nb = x*q,y*q\n ", "x < na and y >= nb", "x < na", "x", "na", "y >= nb", "y", "nb", "q = -(-na//x)", "q", "-(-na//x)", "-na//x", "-na", "na", "x", "na,nb = x*q,y*q", "na", "x*q", "x", "q", "nb", "y*q", "y", "q", "elif (x >= na and y < nb):\n q = -(-nb//y)\n na,nb = x*q,y*q\n ", "x >= na and y < nb", "x >= na", "x", "na", "y < nb", "y", "nb", "q = -(-nb//y)", "q", "-(-nb//y)", "-nb//y", "-nb", "nb", "y", "na,nb = x*q,y*q", "na", "x*q", "x", "q", "nb", "y*q", "y", "q", "use = max(-(-na//x),-(-nb//y))", "use", "max(-(-na//x),-(-nb//y))", "max", "-(-na//x)", "-na//x", "-na", "na", "x", "-(-nb//y)", "-nb//y", "-nb", "nb", "y", "na,nb = x*use,y*use", "na", "x*use", "x", "use", "nb", "y*use", "y", "use", "print(na+nb)", "print", "na+nb", "na", "nb", "if __name__ == \"__main__\":\n main()", "__name__ == \"__main__\"", "__name__", "\"__main__\"", "main()", "main", "input = sys.stdin.buffer.readline", "sys.stdin.buffer.readline", "input", "def main():\n N = int(input())\n X = [list(map(int,input().split())) for _ in range(N)]\n na,nb = X[0][0],X[0][1]\n for i in range(N-1):\n i += 1\n x,y = X[i][0],X[i][1]\n if (x >= na and y >= nb):\n na,nb = x,y\n elif (x < na and y >= nb):\n q = -(-na//x)\n na,nb = x*q,y*q\n elif (x >= na and y < nb):\n q = -(-nb//y)\n na,nb = x*q,y*q\n else:\n use = max(-(-na//x),-(-nb//y))\n na,nb = x*use,y*use\n \n print(na+nb)\n ", "def main():\n N = int(input())\n X = [list(map(int,input().split())) for _ in range(N)]\n na,nb = X[0][0],X[0][1]\n for i in range(N-1):\n i += 1\n x,y = X[i][0],X[i][1]\n if (x >= na and y >= nb):\n na,nb = x,y\n elif (x < na and y >= nb):\n q = -(-na//x)\n na,nb = x*q,y*q\n elif (x >= na and y < nb):\n q = -(-nb//y)\n na,nb = x*q,y*q\n else:\n use = max(-(-na//x),-(-nb//y))\n na,nb = x*use,y*use\n \n print(na+nb)\n ", "main" ]

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

[ [ 104, 2 ], [ 128, 8 ], [ 128, 17 ], [ 101, 19 ], [ 137, 21 ], [ 110, 23 ], [ 27, 26 ], [ 105, 30 ], [ 119, 33 ], [ 119, 42 ], [ 134, 44 ], [ 129, 48 ], [ 123, 48 ], [ 120, 49 ], [ 129, 51 ], [ 123, 51 ], [ 129, 55 ], [ 123, 55 ], [ 120, 56 ], [ 120, 58 ], [ 131, 60 ], [ 114, 64 ], [ 108, 64 ], [ 117, 65 ], [ 114, 67 ], [ 108, 67 ], [ 114, 71 ], [ 108, 71 ], [ 117, 72 ], [ 117, 74 ], [ 125, 76 ], [ 135, 80 ], [ 138, 80 ], [ 120, 81 ], [ 132, 83 ], [ 111, 83 ], [ 117, 84 ], [ 122, 86 ], [ 120, 88 ], [ 126, 89 ], [ 102, 89 ], [ 107, 91 ], [ 117, 93 ], [ 126, 94 ], [ 102, 94 ], [ 123, 98 ], [ 129, 98 ], [ 108, 99 ], [ 114, 99 ], [ 101, 102 ], [ 104, 105 ], [ 107, 108 ], [ 110, 111 ], [ 128, 114 ], [ 119, 117 ], [ 119, 120 ], [ 122, 123 ], [ 125, 126 ], [ 128, 129 ], [ 131, 132 ], [ 134, 135 ], [ 137, 138 ] ]

[ "n=int(input())\nb,u=map(int,input().split())\nx,c,v=1,1,1\nfor i in range(n-1):\n a,t=map(int,input().split())\n c=b if b%a==0 else (b//a+1)*a\n v=u if u%t==0 else (u//t+1)*t\n x=max(c//a,v//t)\n b=a*x\n u=t*x\nprint(b+u)", "n=int(input())", "n", "int(input())", "int", "input()", "input", "b,u=map(int,input().split())", "b", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "u", "x,c,v=1,1,1", "x", "1", "c", "1", "v", "1", "for i in range(n-1):\n a,t=map(int,input().split())\n c=b if b%a==0 else (b//a+1)*a\n v=u if u%t==0 else (u//t+1)*t\n x=max(c//a,v//t)\n b=a*x\n u=t*x", "i", "range(n-1)", "range", "n-1", "n", "1", "a,t=map(int,input().split())", "a", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "t", "c=b if b%a==0 else (b//a+1)*a", "c", "b if b%a==0 else (b//a+1)*a", "b%a==0", "b%a", "b", "a", "0", "b", "(b//a+1)*a", "b//a+1", "b//a", "b", "a", "1", "a", "v=u if u%t==0 else (u//t+1)*t", "v", "u if u%t==0 else (u//t+1)*t", "u%t==0", "u%t", "u", "t", "0", "u", "(u//t+1)*t", "u//t+1", "u//t", "u", "t", "1", "t", "x=max(c//a,v//t)", "x", "max(c//a,v//t)", "max", "c//a", "c", "a", "v//t", "v", "t", "b=a*x", "b", "a*x", "a", "x", "u=t*x", "u", "t*x", "t", "x", "print(b+u)", "print", "b+u", "b", "u", "x,c,v=1,1,1", "1", "x", "n=int(input())", "int(input())", "n", "u=t*x", "t*x", "u", "v=1,1,1", "1", "v", "u=map(int,input().split())", "map(int,input().split())", "u", "t=map(int,input().split())", "map(int,input().split())", "t", "a,t=map(int,input().split())", "map(int,input().split())", "a", "b=a*x", "a*x", "b", "x=max(c//a,v//t)", "max(c//a,v//t)", "x", "b,u=map(int,input().split())", "map(int,input().split())", "b", "v=u if u%t==0 else (u//t+1)*t", "u if u%t==0 else (u//t+1)*t", "v", "c=b if b%a==0 else (b//a+1)*a", "b if b%a==0 else (b//a+1)*a", "c", "c,v=1,1,1", "1", "c" ]

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

[ [ 102, 2 ], [ 111, 8 ], [ 111, 17 ], [ 20, 19 ], [ 103, 23 ], [ 108, 26 ], [ 108, 35 ], [ 112, 39 ], [ 94, 39 ], [ 115, 39 ], [ 97, 40 ], [ 109, 42 ], [ 106, 43 ], [ 100, 43 ], [ 91, 43 ], [ 112, 47 ], [ 94, 47 ], [ 115, 47 ], [ 97, 48 ], [ 109, 50 ], [ 106, 51 ], [ 100, 51 ], [ 91, 51 ], [ 90, 53 ], [ 106, 58 ], [ 100, 58 ], [ 91, 58 ], [ 97, 59 ], [ 97, 60 ], [ 114, 62 ], [ 91, 65 ], [ 106, 65 ], [ 100, 65 ], [ 97, 66 ], [ 109, 67 ], [ 93, 69 ], [ 112, 74 ], [ 94, 74 ], [ 115, 74 ], [ 109, 75 ], [ 109, 76 ], [ 99, 78 ], [ 94, 81 ], [ 112, 81 ], [ 115, 81 ], [ 109, 82 ], [ 97, 83 ], [ 100, 87 ], [ 91, 87 ], [ 106, 87 ], [ 94, 88 ], [ 115, 88 ], [ 112, 88 ], [ 90, 91 ], [ 93, 94 ], [ 108, 97 ], [ 99, 100 ], [ 102, 103 ], [ 111, 106 ], [ 108, 109 ], [ 111, 112 ], [ 114, 115 ] ]

[ "n = int(input())\n\nt1, a1 = map(int,input().split())\n\nfor i in range(n-1):\n t,a = map(int,input().split())\n if t1 * a == t * a1:\n pass\n elif t1 * a < t * a1:\n a1 = -(-a1 // a) * a\n t1 = a1 // a * t\n else:\n t1 = -(-t1 // t) * t\n a1 = t1 // t * a\n\nprint(a1+t1)", "n = int(input())", "n", "int(input())", "int", "input()", "input", "t1, a1 = map(int,input().split())", "t1", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "a1", "for i in range(n-1):\n t,a = map(int,input().split())\n if t1 * a == t * a1:\n pass\n elif t1 * a < t * a1:\n a1 = -(-a1 // a) * a\n t1 = a1 // a * t\n else:\n t1 = -(-t1 // t) * t\n a1 = t1 // t * a", "i", "range(n-1)", "range", "n-1", "n", "1", "t,a = map(int,input().split())", "t", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "a", "if t1 * a == t * a1:\n pass\n elif t1 * a < t * a1:\n a1 = -(-a1 // a) * a\n t1 = a1 // a * t\n else:\n t1 = -(-t1 // t) * t\n a1 = t1 // t * a", "t1 * a == t * a1", "t1 * a", "t1", "a", "t * a1", "t", "a1", "elif t1 * a < t * a1:\n a1 = -(-a1 // a) * a\n t1 = a1 // a * t\n ", "t1 * a < t * a1", "t1 * a", "t1", "a", "t * a1", "t", "a1", "a1 = -(-a1 // a) * a", "a1", "-(-a1 // a) * a", "-(-a1 // a)", "-a1 // a", "-a1", "a1", "a", "a", "t1 = a1 // a * t", "t1", "a1 // a * t", "a1 // a", "a1", "a", "t", "t1 = -(-t1 // t) * t", "t1", "-(-t1 // t) * t", "-(-t1 // t)", "-t1 // t", "-t1", "t1", "t", "t", "a1 = t1 // t * a", "a1", "t1 // t * a", "t1 // t", "t1", "t", "a", "print(a1+t1)", "print", "a1+t1", "a1", "t1", "a1 = -(-a1 // a) * a", "-(-a1 // a) * a", "a1", "t1 = -(-t1 // t) * t", "-(-t1 // t) * t", "t1", "a = map(int,input().split())", "map(int,input().split())", "a", "a1 = t1 // t * a", "t1 // t * a", "a1", "n = int(input())", "int(input())", "n", "a1 = map(int,input().split())", "map(int,input().split())", "a1", "t,a = map(int,input().split())", "map(int,input().split())", "t", "t1, a1 = map(int,input().split())", "map(int,input().split())", "t1", "t1 = a1 // a * t", "a1 // a * t", "t1" ]

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

[ [ 104, 2 ], [ 113, 8 ], [ 110, 11 ], [ 15, 14 ], [ 105, 17 ], [ 107, 19 ], [ 107, 28 ], [ 114, 34 ], [ 126, 34 ], [ 123, 34 ], [ 102, 35 ], [ 111, 39 ], [ 120, 39 ], [ 117, 39 ], [ 108, 40 ], [ 122, 42 ], [ 102, 44 ], [ 114, 50 ], [ 126, 50 ], [ 123, 50 ], [ 102, 51 ], [ 102, 53 ], [ 116, 55 ], [ 108, 57 ], [ 123, 63 ], [ 114, 63 ], [ 126, 63 ], [ 102, 64 ], [ 102, 66 ], [ 125, 68 ], [ 102, 70 ], [ 111, 76 ], [ 120, 76 ], [ 117, 76 ], [ 108, 77 ], [ 108, 79 ], [ 119, 81 ], [ 108, 83 ], [ 111, 89 ], [ 120, 89 ], [ 117, 89 ], [ 108, 90 ], [ 108, 92 ], [ 126, 98 ], [ 123, 98 ], [ 114, 98 ], [ 120, 99 ], [ 117, 99 ], [ 111, 99 ], [ 107, 102 ], [ 104, 105 ], [ 107, 108 ], [ 110, 111 ], [ 113, 114 ], [ 116, 117 ], [ 119, 120 ], [ 122, 123 ], [ 125, 126 ] ]

[ "N = int(input())\nansT = 1\nansA = 1\nfor i in range(N):\n T, A = map(int,input().split())\n if int(ansT / T) > int(ansA / A):\n ansT = T * int((ansT + T - 1) // T)\n ansA = A * int((ansT + T - 1) // T)\n else:\n ansT = T * int((ansA + A - 1) // A)\n ansA = A * int((ansA + A - 1) // A)\n\nprint(int(ansT + ansA))", "N = int(input())", "N", "int(input())", "int", "input()", "input", "ansT = 1", "ansT", "1", "ansA = 1", "ansA", "1", "for i in range(N):\n T, A = map(int,input().split())\n if int(ansT / T) > int(ansA / A):\n ansT = T * int((ansT + T - 1) // T)\n ansA = A * int((ansT + T - 1) // T)\n else:\n ansT = T * int((ansA + A - 1) // A)\n ansA = A * int((ansA + A - 1) // A)", "i", "range(N)", "range", "N", "T, A = map(int,input().split())", "T", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "A", "if int(ansT / T) > int(ansA / A):\n ansT = T * int((ansT + T - 1) // T)\n ansA = A * int((ansT + T - 1) // T)\n else:\n ansT = T * int((ansA + A - 1) // A)\n ansA = A * int((ansA + A - 1) // A)", "int(ansT / T) > int(ansA / A)", "int(ansT / T)", "int", "ansT / T", "ansT", "T", "int(ansA / A)", "int", "ansA / A", "ansA", "A", "ansT = T * int((ansT + T - 1) // T)", "ansT", "T * int((ansT + T - 1) // T)", "T", "int((ansT + T - 1) // T)", "int", "(ansT + T - 1) // T", "ansT + T - 1", "ansT + T", "ansT", "T", "1", "T", "ansA = A * int((ansT + T - 1) // T)", "ansA", "A * int((ansT + T - 1) // T)", "A", "int((ansT + T - 1) // T)", "int", "(ansT + T - 1) // T", "ansT + T - 1", "ansT + T", "ansT", "T", "1", "T", "ansT = T * int((ansA + A - 1) // A)", "ansT", "T * int((ansA + A - 1) // A)", "T", "int((ansA + A - 1) // A)", "int", "(ansA + A - 1) // A", "ansA + A - 1", "ansA + A", "ansA", "A", "1", "A", "ansA = A * int((ansA + A - 1) // A)", "ansA", "A * int((ansA + A - 1) // A)", "A", "int((ansA + A - 1) // A)", "int", "(ansA + A - 1) // A", "ansA + A - 1", "ansA + A", "ansA", "A", "1", "A", "print(int(ansT + ansA))", "print", "int(ansT + ansA)", "int", "ansT + ansA", "ansT", "ansA", "T, A = map(int,input().split())", "map(int,input().split())", "T", "N = int(input())", "int(input())", "N", "A = map(int,input().split())", "map(int,input().split())", "A", "ansA = 1", "1", "ansA", "ansT = 1", "1", "ansT", "ansA = A * int((ansT + T - 1) // T)", "A * int((ansT + T - 1) // T)", "ansA", "ansA = A * int((ansA + A - 1) // A)", "A * int((ansA + A - 1) // A)", "ansA", "ansT = T * int((ansT + T - 1) // T)", "T * int((ansT + T - 1) // T)", "ansT", "ansT = T * int((ansA + A - 1) // A)", "T * int((ansA + A - 1) // A)", "ansT" ]

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

[ [ 301, 11 ], [ 265, 18 ], [ 286, 25 ], [ 302, 40 ], [ 302, 51 ], [ 302, 59 ], [ 64, 63 ], [ 128, 69 ], [ 75, 74 ], [ 128, 76 ], [ 80, 79 ], [ 83, 82 ], [ 128, 88 ], [ 74, 92 ], [ 106, 92 ], [ 128, 94 ], [ 82, 96 ], [ 63, 100 ], [ 107, 106 ], [ 128, 108 ], [ 82, 110 ], [ 114, 113 ], [ 117, 116 ], [ 63, 120 ], [ 63, 126 ], [ 128, 128 ], [ 141, 139 ], [ 141, 141 ], [ 152, 150 ], [ 152, 152 ], [ 157, 156 ], [ 182, 161 ], [ 180, 162 ], [ 156, 166 ], [ 182, 169 ], [ 182, 172 ], [ 156, 173 ], [ 180, 174 ], [ 180, 180 ], [ 182, 182 ], [ 187, 186 ], [ 208, 192 ], [ 201, 192 ], [ 196, 195 ], [ 206, 196 ], [ 198, 196 ], [ 199, 198 ], [ 198, 199 ], [ 206, 199 ], [ 202, 201 ], [ 195, 204 ], [ 186, 204 ], [ 206, 206 ], [ 208, 208 ], [ 313, 211 ], [ 260, 213 ], [ 268, 215 ], [ 292, 217 ], [ 221, 220 ], [ 314, 223 ], [ 307, 225 ], [ 305, 227 ], [ 307, 228 ], [ 280, 230 ], [ 269, 236 ], [ 263, 236 ], [ 308, 237 ], [ 293, 241 ], [ 299, 241 ], [ 278, 242 ], [ 262, 244 ], [ 281, 246 ], [ 308, 247 ], [ 298, 249 ], [ 281, 251 ], [ 278, 252 ], [ 263, 256 ], [ 269, 256 ], [ 299, 257 ], [ 293, 257 ], [ 262, 263 ], [ 265, 266 ], [ 268, 269 ], [ 307, 278 ], [ 280, 281 ], [ 286, 287 ], [ 292, 293 ], [ 298, 299 ], [ 301, 302 ], [ 307, 308 ], [ 313, 314 ] ]

[ "import sys,collections as cl,bisect as bs\nsys.setrecursionlimit(100000)\ninput = sys.stdin.readline\nmod = 10**9+7\nMax = sys.maxsize\ndef l(): #intのlist\n return list(map(int,input().split()))\ndef m(): #複数文字\n return map(int,input().split())\ndef onem(): #Nとかの取得\n return int(input())\ndef s(x): #圧縮\n a = []\n if len(x) == 0:\n return []\n aa = x[0]\n su = 1\n for i in range(len(x)-1):\n if aa != x[i+1]:\n a.append([aa,su])\n aa = x[i+1]\n su = 1\n else:\n su += 1\n a.append([aa,su])\n return a\ndef jo(x): #listをスペースごとに分ける\n return \" \".join(map(str,x))\ndef max2(x): #他のときもどうように作成可能\n return max(map(max,x))\ndef In(x,a): #aがリスト(sorted)\n k = bs.bisect_left(a,x)\n if k != len(a) and a[k] == x:\n return True\n else:\n return False\n\ndef pow_k(x, n):\n ans = 1\n while n:\n if n % 2:\n ans *= x\n x *= x\n n >>= 1\n return ans\n\n\"\"\"\ndef nibu(x,n,r):\n ll = 0\n rr = r\n while True:\n mid = (ll+rr)//2\n\n if rr == mid:\n return ll\n if (ここに評価入れる):\n rr = mid\n else:\n ll = mid+1\n\"\"\"\nn = onem()\n\na,b = 1,1\n\nfor i in range(n):\n x,y = m()\n po = max(-(-a//x),-(-b//y))\n a = po*x\n b = po*y\n\nprint(a+b)\n\n", "import sys,collections as cl,bisect as bs", "sys", "collections", "bisect", "sys.setrecursionlimit(100000)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "100000", "input = sys.stdin.readline", "input", "sys.stdin.readline", "sys.stdin", "sys", "stdin", "readline", "mod = 10**9+7", "mod", "10**9+7", "10**9", "10", "9", "7", "Max = sys.maxsize", "Max", "sys.maxsize", "sys", "maxsize", "def l(): #intのlist\n return list(map(int,input().split()))", "l", "return list(map(int,input().split()))", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "def m(): #複数文字\n return map(int,input().split())", "m", "return map(int,input().split())", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "def onem(): #Nとかの取得\n return int(input())", "onem", "return int(input())", "int(input())", "int", "input()", "input", "def s(x): #圧縮\n a = []\n if len(x) == 0:\n return []\n aa = x[0]\n su = 1\n for i in range(len(x)-1):\n if aa != x[i+1]:\n a.append([aa,su])\n aa = x[i+1]\n su = 1\n else:\n su += 1\n a.append([aa,su])\n return a", "s", "a = []", "a", "[]", "if len(x) == 0:\n return []\n ", "len(x) == 0", "len(x)", "len", "x", "0", "return []", "[]", "aa = x[0]", "aa", "x[0]", "x", "0", "su = 1", "su", "1", "for i in range(len(x)-1):\n if aa != x[i+1]:\n a.append([aa,su])\n aa = x[i+1]\n su = 1\n else:\n su += 1\n ", "i", "range(len(x)-1)", "range", "len(x)-1", "len(x)", "len", "x", "1", "if aa != x[i+1]:\n a.append([aa,su])\n aa = x[i+1]\n su = 1\n else:\n su += 1\n ", "aa != x[i+1]", "aa", "x[i+1]", "x", "i+1", "i", "1", "a.append([aa,su])", "a.append", "a", "append", "[aa,su]", "aa", "su", "aa = x[i+1]", "aa", "x[i+1]", "x", "i+1", "i", "1", "su = 1", "su", "1", "su += 1", "su", "1", "a.append([aa,su])", "a.append", "a", "append", "[aa,su]", "aa", "su", "return a", "a", "x", "x", "def jo(x): #listをスペースごとに分ける\n return \" \".join(map(str,x))", "jo", "return \" \".join(map(str,x))", "\" \".join(map(str,x))", "\" \".join", "\" \"", "join", "map(str,x)", "map", "str", "x", "x", "x", "def max2(x): #他のときもどうように作成可能\n return max(map(max,x))", "max2", "return max(map(max,x))", "max(map(max,x))", "max", "map(max,x)", "map", "max", "x", "x", "x", "def In(x,a): #aがリスト(sorted)\n k = bs.bisect_left(a,x)\n if k != len(a) and a[k] == x:\n return True\n else:\n return False", "In", "k = bs.bisect_left(a,x)", "k", "bs.bisect_left(a,x)", "bs.bisect_left", "bs", "bisect_left", "a", "x", "if k != len(a) and a[k] == x:\n return True\n else:\n return False", "k != len(a) and a[k] == x", "k != len(a)", "k", "len(a)", "len", "a", "a[k] == x", "a[k]", "a", "k", "x", "return True", "True", "return False", "False", "x", "x", "a", "a", "def pow_k(x, n):\n ans = 1\n while n:\n if n % 2:\n ans *= x\n x *= x\n n >>= 1\n return ans", "pow_k", "ans = 1", "ans", "1", "while n:\n if n % 2:\n ans *= x\n x *= x\n n >>= 1\n ", "n", "if n % 2:\n ans *= x\n ", "n % 2", "n", "2", "ans *= x", "ans", "x", "x *= x", "x", "x", "n >>= 1", "n", "1", "return ans", "ans", "x", "x", "n", "n", "\"\"\"\ndef nibu(x,n,r):\n ll = 0\n rr = r\n while True:\n mid = (ll+rr)//2\n\n if rr == mid:\n return ll\n if (ここに評価入れる):\n rr = mid\n else:\n ll = mid+1\n\"\"\"", "n = onem()", "n", "onem()", "onem", "a,b = 1,1", "a", "1", "b", "1", "for i in range(n):\n x,y = m()\n po = max(-(-a//x),-(-b//y))\n a = po*x\n b = po*y", "i", "range(n)", "range", "n", "x,y = m()", "x", "m()", "m", "y", "po = max(-(-a//x),-(-b//y))", "po", "max(-(-a//x),-(-b//y))", "max", "-(-a//x)", "-a//x", "-a", "a", "x", "-(-b//y)", "-b//y", "-b", "b", "y", "a = po*x", "a", "po*x", "po", "x", "b = po*y", "b", "po*y", "po", "y", "print(a+b)", "print", "a+b", "a", "b", "def onem(): #Nとかの取得\n return int(input())", "def onem(): #Nとかの取得\n return int(input())", "onem", "a = po*x", "po*x", "a", "mod = 10**9+7", "10**9+7", "mod", "a,b = 1,1", "1", "a", "def jo(x): #listをスペースごとに分ける\n return \" \".join(map(str,x))", "def jo(x): #listをスペースごとに分ける\n return \" \".join(map(str,x))", "jo", "def s(x): #圧縮\n a = []\n if len(x) == 0:\n return []\n aa = x[0]\n su = 1\n for i in range(len(x)-1):\n if aa != x[i+1]:\n a.append([aa,su])\n aa = x[i+1]\n su = 1\n else:\n su += 1\n a.append([aa,su])\n return a", "def s(x): #圧縮\n a = []\n if len(x) == 0:\n return []\n aa = x[0]\n su = 1\n for i in range(len(x)-1):\n if aa != x[i+1]:\n a.append([aa,su])\n aa = x[i+1]\n su = 1\n else:\n su += 1\n a.append([aa,su])\n return a", "s", "y = m()", "m()", "y", "po = max(-(-a//x),-(-b//y))", "max(-(-a//x),-(-b//y))", "po", "def In(x,a): #aがリスト(sorted)\n k = bs.bisect_left(a,x)\n if k != len(a) and a[k] == x:\n return True\n else:\n return False", "def In(x,a): #aがリスト(sorted)\n k = bs.bisect_left(a,x)\n if k != len(a) and a[k] == x:\n return True\n else:\n return False", "In", "Max = sys.maxsize", "sys.maxsize", "Max", "def max2(x): #他のときもどうように作成可能\n return max(map(max,x))", "def max2(x): #他のときもどうように作成可能\n return max(map(max,x))", "max2", "b = 1,1", "1", "b", "def l(): #intのlist\n return list(map(int,input().split()))", "def l(): #intのlist\n return list(map(int,input().split()))", "l", "b = po*y", "po*y", "b", "input = sys.stdin.readline", "sys.stdin.readline", "input", "def m(): #複数文字\n return map(int,input().split())", "def m(): #複数文字\n return map(int,input().split())", "m", "x,y = m()", "m()", "x", "def pow_k(x, n):\n ans = 1\n while n:\n if n % 2:\n ans *= x\n x *= x\n n >>= 1\n return ans", "def pow_k(x, n):\n ans = 1\n while n:\n if n % 2:\n ans *= x\n x *= x\n n >>= 1\n return ans", "pow_k", "n = onem()", "onem()", "n" ]

[ 7, 15, 13, 15, 13, 12, 13, 0, 13, 39, 18, 13, 17, 18, 13, 17, 28, 13, 4, 13, 17, 13, 0, 13, 18, 13, 13, 0, 13, 18, 13, 13, 14, 2, 2, 18, 13, 17, 13, 2, 18, 13, 17, 13, 0, 13, 4, 13, 2, 2, 2, 18, 13, 17, 13, 17, 13, 2, 2, 2, 18, 13, 17, 13, 17, 13, 0, 13, 2, 13, 13, 0, 13, 2, 13, 13, 0, 18, 13, 17, 13, 0, 18, 13, 17, 13, 4, 13, 4, 13, 13, 29, 23, 13, 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, 2, 39, 4, 13, 13, 0, 13, 2, 39, 4, 13, 13, 28, 13, 4, 13, 13, 0, 18, 13, 13, 4, 13, 4, 13, 13, 0, 18, 13, 13, 4, 13, 4, 13, 13, 4, 13, 13, 13, 13, 14, 2, 13, 17, 4, 13, 10, 12, 13, 10, 12, 13 ]

[ [ 9, 8 ], [ 95, 11 ], [ 97, 14 ], [ 18, 17 ], [ 93, 21 ], [ 24, 23 ], [ 95, 25 ], [ 17, 26 ], [ 29, 28 ], [ 97, 30 ], [ 17, 31 ], [ 8, 36 ], [ 23, 38 ], [ 67, 38 ], [ 8, 41 ], [ 28, 43 ], [ 72, 43 ], [ 46, 45 ], [ 8, 52 ], [ 23, 54 ], [ 67, 54 ], [ 23, 56 ], [ 67, 56 ], [ 8, 61 ], [ 28, 63 ], [ 72, 63 ], [ 28, 65 ], [ 72, 65 ], [ 68, 67 ], [ 23, 69 ], [ 67, 69 ], [ 45, 70 ], [ 73, 72 ], [ 28, 74 ], [ 72, 74 ], [ 45, 75 ], [ 80, 77 ], [ 8, 78 ], [ 67, 80 ], [ 23, 80 ], [ 85, 82 ], [ 8, 83 ], [ 72, 85 ], [ 28, 85 ], [ 8, 90 ], [ 93, 93 ], [ 95, 95 ], [ 97, 97 ], [ 104, 103 ], [ 109, 108 ], [ 103, 111 ], [ 108, 114 ], [ 117, 116 ], [ 101, 118 ], [ 121, 120 ], [ 116, 125 ], [ 128, 127 ], [ 120, 132 ], [ 135, 134 ], [ 120, 139 ], [ 142, 141 ], [ 120, 144 ], [ 149, 146 ], [ 127, 147 ], [ 141, 148 ], [ 116, 153 ], [ 158, 155 ], [ 134, 156 ], [ 141, 157 ], [ 116, 162 ], [ 179, 164 ], [ 120, 165 ], [ 127, 166 ], [ 134, 167 ], [ 176, 173 ] ]

[ "#!/usr/bin/env python3\nimport sys\nimport math\n\ndef solve(N: int, T: \"List[int]\", A: \"List[int]\"):\n current = [T[0],A[0]]\n for i in range(1,N):\n t = T[i]\n a = A[i]\n if current[0]>t or current[1]>a:\n multi = max((current[0]+t-1)//t,(current[1]+a-1)//a)\n t = t*multi\n a = a*multi\n \n current[0]=t\n current[1]=a\n\n print(sum(current))\n return\n\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 N = int(next(tokens)) # type: int\n T = [int()] * (N) # type: \"List[int]\"\n A = [int()] * (N) # type: \"List[int]\"\n for i in range(N):\n T[i] = int(next(tokens))\n A[i] = int(next(tokens))\n solve(N, T, A)\n\nif __name__ == '__main__':\n main()", "import sys", "sys", "import math", "math", "def solve(N: int, T: \"List[int]\", A: \"List[int]\"):\n current = [T[0],A[0]]\n for i in range(1,N):\n t = T[i]\n a = A[i]\n if current[0]>t or current[1]>a:\n multi = max((current[0]+t-1)//t,(current[1]+a-1)//a)\n t = t*multi\n a = a*multi\n \n current[0]=t\n current[1]=a\n\n print(sum(current))\n return", "solve", "current = [T[0],A[0]]", "current", "[T[0],A[0]]", "T[0]", "T", "0", "A[0]", "A", "0", "for i in range(1,N):\n t = T[i]\n a = A[i]\n if current[0]>t or current[1]>a:\n multi = max((current[0]+t-1)//t,(current[1]+a-1)//a)\n t = t*multi\n a = a*multi\n \n current[0]=t\n current[1]=a\n\n ", "i", "range(1,N)", "range", "1", "N", "t = T[i]", "t", "T[i]", "T", "i", "a = A[i]", "a", "A[i]", "A", "i", "if current[0]>t or current[1]>a:\n multi = max((current[0]+t-1)//t,(current[1]+a-1)//a)\n t = t*multi\n a = a*multi\n \n ", "current[0]>t or current[1]>a", "current[0]>t", "current[0]", "current", "0", "t", "current[1]>a", "current[1]", "current", "1", "a", "multi = max((current[0]+t-1)//t,(current[1]+a-1)//a)", "multi", "max((current[0]+t-1)//t,(current[1]+a-1)//a)", "max", "(current[0]+t-1)//t", "current[0]+t-1", "current[0]+t", "current[0]", "current", "0", "t", "1", "t", "(current[1]+a-1)//a", "current[1]+a-1", "current[1]+a", "current[1]", "current", "1", "a", "1", "a", "t = t*multi", "t", "t*multi", "t", "multi", "a = a*multi", "a", "a*multi", "a", "multi", "current[0]=t", "current[0]", "current", "0", "t", "current[1]=a", "current[1]", "current", "1", "a", "print(sum(current))", "print", "sum(current)", "sum", "current", "return", "N: int", "N", "T: \"List[int]\"", "T", "A: \"List[int]\"", "A", "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 N = int(next(tokens)) # type: int\n T = [int()] * (N) # type: \"List[int]\"\n A = [int()] * (N) # type: \"List[int]\"\n for i in range(N):\n T[i] = int(next(tokens))\n A[i] = int(next(tokens))\n solve(N, T, A)", "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", "N = int(next(tokens))", "N", "int(next(tokens))", "int", "next(tokens)", "next", "tokens", "T = [int()] * (N)", "T", "[int()] * (N)", "[int()]", "int()", "int", "N", "A = [int()] * (N)", "A", "[int()] * (N)", "[int()]", "int()", "int", "N", "for i in range(N):\n T[i] = int(next(tokens))\n A[i] = int(next(tokens))\n ", "i", "range(N)", "range", "N", "T[i] = int(next(tokens))", "T[i]", "T", "i", "int(next(tokens))", "int", "next(tokens)", "next", "tokens", "A[i] = int(next(tokens))", "A[i]", "A", "i", "int(next(tokens))", "int", "next(tokens)", "next", "tokens", "solve(N, T, A)", "solve", "N", "T", "A", "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 N = int(next(tokens)) # type: int\n T = [int()] * (N) # type: \"List[int]\"\n A = [int()] * (N) # type: \"List[int]\"\n for i in range(N):\n T[i] = int(next(tokens))\n A[i] = int(next(tokens))\n solve(N, T, A)", "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 N = int(next(tokens)) # type: int\n T = [int()] * (N) # type: \"List[int]\"\n A = [int()] * (N) # type: \"List[int]\"\n for i in range(N):\n T[i] = int(next(tokens))\n A[i] = int(next(tokens))\n solve(N, T, A)", "main", "def solve(N: int, T: \"List[int]\", A: \"List[int]\"):\n current = [T[0],A[0]]\n for i in range(1,N):\n t = T[i]\n a = A[i]\n if current[0]>t or current[1]>a:\n multi = max((current[0]+t-1)//t,(current[1]+a-1)//a)\n t = t*multi\n a = a*multi\n \n current[0]=t\n current[1]=a\n\n print(sum(current))\n return", "def solve(N: int, T: \"List[int]\", A: \"List[int]\"):\n current = [T[0],A[0]]\n for i in range(1,N):\n t = T[i]\n a = A[i]\n if current[0]>t or current[1]>a:\n multi = max((current[0]+t-1)//t,(current[1]+a-1)//a)\n t = t*multi\n a = a*multi\n \n current[0]=t\n current[1]=a\n\n print(sum(current))\n return", "solve" ]

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

[ [ 19, 5 ], [ 17, 8 ], [ 19, 12 ], [ 17, 14 ], [ 19, 15 ], [ 17, 17 ], [ 19, 19 ], [ 32, 25 ], [ 34, 26 ], [ 255, 28 ], [ 32, 29 ], [ 34, 30 ], [ 32, 32 ], [ 34, 34 ], [ 293, 36 ], [ 266, 42 ], [ 236, 44 ], [ 48, 47 ], [ 294, 50 ], [ 248, 52 ], [ 245, 55 ], [ 245, 64 ], [ 47, 67 ], [ 257, 70 ], [ 231, 71 ], [ 290, 72 ], [ 246, 73 ], [ 258, 78 ], [ 267, 78 ], [ 279, 78 ], [ 234, 78 ], [ 252, 78 ], [ 285, 78 ], [ 270, 78 ], [ 231, 79 ], [ 291, 81 ], [ 237, 81 ], [ 240, 81 ], [ 276, 81 ], [ 297, 81 ], [ 273, 81 ], [ 243, 81 ], [ 246, 82 ], [ 269, 84 ], [ 231, 85 ], [ 242, 86 ], [ 246, 87 ], [ 258, 91 ], [ 267, 91 ], [ 279, 91 ], [ 234, 91 ], [ 252, 91 ], [ 285, 91 ], [ 270, 91 ], [ 231, 92 ], [ 246, 94 ], [ 291, 95 ], [ 237, 95 ], [ 240, 95 ], [ 276, 95 ], [ 297, 95 ], [ 273, 95 ], [ 243, 95 ], [ 291, 99 ], [ 237, 99 ], [ 240, 99 ], [ 276, 99 ], [ 297, 99 ], [ 273, 99 ], [ 243, 99 ], [ 246, 100 ], [ 260, 103 ], [ 284, 106 ], [ 231, 108 ], [ 243, 111 ], [ 291, 111 ], [ 237, 111 ], [ 240, 111 ], [ 276, 111 ], [ 297, 111 ], [ 273, 111 ], [ 246, 112 ], [ 261, 113 ], [ 249, 113 ], [ 264, 113 ], [ 282, 113 ], [ 288, 113 ], [ 272, 115 ], [ 246, 117 ], [ 243, 120 ], [ 291, 120 ], [ 237, 120 ], [ 240, 120 ], [ 276, 120 ], [ 297, 120 ], [ 273, 120 ], [ 246, 121 ], [ 261, 122 ], [ 249, 122 ], [ 264, 122 ], [ 282, 122 ], [ 288, 122 ], [ 231, 126 ], [ 258, 127 ], [ 267, 127 ], [ 279, 127 ], [ 234, 127 ], [ 252, 127 ], [ 285, 127 ], [ 270, 127 ], [ 291, 129 ], [ 237, 129 ], [ 240, 129 ], [ 276, 129 ], [ 297, 129 ], [ 273, 129 ], [ 243, 129 ], [ 231, 130 ], [ 258, 134 ], [ 267, 134 ], [ 279, 134 ], [ 234, 134 ], [ 252, 134 ], [ 285, 134 ], [ 270, 134 ], [ 231, 135 ], [ 287, 138 ], [ 296, 141 ], [ 246, 143 ], [ 285, 146 ], [ 270, 146 ], [ 258, 146 ], [ 267, 146 ], [ 279, 146 ], [ 234, 146 ], [ 252, 146 ], [ 231, 147 ], [ 288, 148 ], [ 261, 148 ], [ 249, 148 ], [ 264, 148 ], [ 282, 148 ], [ 251, 150 ], [ 231, 152 ], [ 285, 155 ], [ 270, 155 ], [ 258, 155 ], [ 267, 155 ], [ 279, 155 ], [ 234, 155 ], [ 252, 155 ], [ 231, 156 ], [ 288, 157 ], [ 261, 157 ], [ 249, 157 ], [ 264, 157 ], [ 282, 157 ], [ 258, 162 ], [ 267, 162 ], [ 279, 162 ], [ 234, 162 ], [ 252, 162 ], [ 285, 162 ], [ 270, 162 ], [ 231, 163 ], [ 291, 167 ], [ 237, 167 ], [ 240, 167 ], [ 276, 167 ], [ 297, 167 ], [ 273, 167 ], [ 243, 167 ], [ 246, 168 ], [ 291, 173 ], [ 237, 173 ], [ 240, 173 ], [ 276, 173 ], [ 297, 173 ], [ 273, 173 ], [ 243, 173 ], [ 246, 174 ], [ 281, 177 ], [ 233, 180 ], [ 231, 182 ], [ 297, 185 ], [ 273, 185 ], [ 243, 185 ], [ 291, 185 ], [ 237, 185 ], [ 240, 185 ], [ 276, 185 ], [ 246, 186 ], [ 282, 187 ], [ 288, 187 ], [ 261, 187 ], [ 249, 187 ], [ 264, 187 ], [ 275, 189 ], [ 246, 191 ], [ 297, 194 ], [ 273, 194 ], [ 243, 194 ], [ 291, 194 ], [ 237, 194 ], [ 240, 194 ], [ 276, 194 ], [ 246, 195 ], [ 282, 196 ], [ 288, 196 ], [ 261, 196 ], [ 249, 196 ], [ 264, 196 ], [ 258, 200 ], [ 267, 200 ], [ 279, 200 ], [ 234, 200 ], [ 252, 200 ], [ 285, 200 ], [ 270, 200 ], [ 231, 201 ], [ 263, 204 ], [ 239, 207 ], [ 246, 209 ], [ 234, 212 ], [ 252, 212 ], [ 285, 212 ], [ 270, 212 ], [ 258, 212 ], [ 267, 212 ], [ 279, 212 ], [ 231, 213 ], [ 264, 214 ], [ 282, 214 ], [ 288, 214 ], [ 261, 214 ], [ 249, 214 ], [ 278, 216 ], [ 231, 218 ], [ 234, 221 ], [ 252, 221 ], [ 285, 221 ], [ 270, 221 ], [ 258, 221 ], [ 267, 221 ], [ 279, 221 ], [ 231, 222 ], [ 264, 223 ], [ 282, 223 ], [ 288, 223 ], [ 261, 223 ], [ 249, 223 ], [ 279, 227 ], [ 234, 227 ], [ 252, 227 ], [ 285, 227 ], [ 270, 227 ], [ 258, 227 ], [ 267, 227 ], [ 240, 228 ], [ 276, 228 ], [ 297, 228 ], [ 273, 228 ], [ 243, 228 ], [ 291, 228 ], [ 237, 228 ], [ 245, 231 ], [ 233, 234 ], [ 236, 237 ], [ 239, 240 ], [ 246, 242 ], [ 242, 243 ], [ 245, 246 ], [ 248, 249 ], [ 251, 252 ], [ 231, 257 ], [ 257, 258 ], [ 260, 261 ], [ 263, 264 ], [ 266, 267 ], [ 231, 269 ], [ 269, 270 ], [ 272, 273 ], [ 275, 276 ], [ 278, 279 ], [ 281, 282 ], [ 284, 285 ], [ 287, 288 ], [ 246, 290 ], [ 290, 291 ], [ 293, 294 ], [ 296, 297 ] ]

[ "def gcd(x,y):\n if y==0:\n return x\n else:\n return gcd(y,x%y)\ndef lcm(x,y):\n return x*y//gcd(x,y)\nN=int(input())\nx,y=0,0\nfor i in range(N):\n p=0\n T,A=map(int,input().split())\n if i==0:\n x,y=T,A\n continue\n if x<=T and y<=A:\n x,y=T,A\n elif x<=T and A<y:\n if y%A!=0:\n p=1\n x=T*(y//A+p)\n y=A*(y//A+p)\n elif T<x and y<=T:\n if x%T!=0:\n p=1\n y=A*(x//T+p)\n x=T*(x//T+p)\n else:\n if (x//T+1)<=(y//A+1):\n if y%A!=0:\n p=1\n x=T*(y//A+p)\n y=A*(y//A+p)\n else:\n if x%T!=0:\n p=1\n y=A*(x//T+p)\n x=T*(x//T+p)\nprint(x+y)", "def gcd(x,y):\n if y==0:\n return x\n else:\n return gcd(y,x%y)", "gcd", "if y==0:\n return x\n else:\n return gcd(y,x%y)", "y==0", "y", "0", "return x", "x", "return gcd(y,x%y)", "gcd(y,x%y)", "gcd", "y", "x%y", "x", "y", "x", "x", "y", "y", "def lcm(x,y):\n return x*y//gcd(x,y)", "lcm", "return x*y//gcd(x,y)", "x*y//gcd(x,y)", "x*y", "x", "y", "gcd(x,y)", "gcd", "x", "y", "x", "x", "y", "y", "N=int(input())", "N", "int(input())", "int", "input()", "input", "x,y=0,0", "x", "0", "y", "0", "for i in range(N):\n p=0\n T,A=map(int,input().split())\n if i==0:\n x,y=T,A\n continue\n if x<=T and y<=A:\n x,y=T,A\n elif x<=T and A<y:\n if y%A!=0:\n p=1\n x=T*(y//A+p)\n y=A*(y//A+p)\n elif T<x and y<=T:\n if x%T!=0:\n p=1\n y=A*(x//T+p)\n x=T*(x//T+p)\n else:\n if (x//T+1)<=(y//A+1):\n if y%A!=0:\n p=1\n x=T*(y//A+p)\n y=A*(y//A+p)\n else:\n if x%T!=0:\n p=1\n y=A*(x//T+p)\n x=T*(x//T+p)", "i", "range(N)", "range", "N", "p=0", "p", "0", "T,A=map(int,input().split())", "T", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "A", "if i==0:\n x,y=T,A\n continue\n ", "i==0", "i", "0", "x,y=T,A", "x", "T", "y", "A", "continue", "if x<=T and y<=A:\n x,y=T,A\n elif x<=T and A<y:\n if y%A!=0:\n p=1\n x=T*(y//A+p)\n y=A*(y//A+p)\n elif T<x and y<=T:\n if x%T!=0:\n p=1\n y=A*(x//T+p)\n x=T*(x//T+p)\n else:\n if (x//T+1)<=(y//A+1):\n if y%A!=0:\n p=1\n x=T*(y//A+p)\n y=A*(y//A+p)\n else:\n if x%T!=0:\n p=1\n y=A*(x//T+p)\n x=T*(x//T+p)", "x<=T and y<=A", "x<=T", "x", "T", "y<=A", "y", "A", "x,y=T,A", "x", "T", "y", "A", "elif x<=T and A<y:\n if y%A!=0:\n p=1\n x=T*(y//A+p)\n y=A*(y//A+p)\n ", "x<=T and A<y", "x<=T", "x", "T", "A<y", "A", "y", "if y%A!=0:\n p=1\n ", "y%A!=0", "y%A", "y", "A", "0", "p=1", "p", "1", "x=T*(y//A+p)", "x", "T*(y//A+p)", "T", "y//A+p", "y//A", "y", "A", "p", "y=A*(y//A+p)", "y", "A*(y//A+p)", "A", "y//A+p", "y//A", "y", "A", "p", "elif T<x and y<=T:\n if x%T!=0:\n p=1\n y=A*(x//T+p)\n x=T*(x//T+p)\n ", "T<x and y<=T", "T<x", "T", "x", "y<=T", "y", "T", "if x%T!=0:\n p=1\n ", "x%T!=0", "x%T", "x", "T", "0", "p=1", "p", "1", "y=A*(x//T+p)", "y", "A*(x//T+p)", "A", "x//T+p", "x//T", "x", "T", "p", "x=T*(x//T+p)", "x", "T*(x//T+p)", "T", "x//T+p", "x//T", "x", "T", "p", "if (x//T+1)<=(y//A+1):\n if y%A!=0:\n p=1\n x=T*(y//A+p)\n y=A*(y//A+p)\n else:\n if x%T!=0:\n p=1\n y=A*(x//T+p)\n x=T*(x//T+p)", "(x//T+1)<=(y//A+1)", "x//T+1", "x//T", "x", "T", "1", "y//A+1", "y//A", "y", "A", "1", "if y%A!=0:\n p=1\n ", "y%A!=0", "y%A", "y", "A", "0", "p=1", "p", "1", "x=T*(y//A+p)", "x", "T*(y//A+p)", "T", "y//A+p", "y//A", "y", "A", "p", "y=A*(y//A+p)", "y", "A*(y//A+p)", "A", "y//A+p", "y//A", "y", "A", "p", "if x%T!=0:\n p=1\n ", "x%T!=0", "x%T", "x", "T", "0", "p=1", "p", "1", "y=A*(x//T+p)", "y", "A*(x//T+p)", "A", "x//T+p", "x//T", "x", "T", "p", "x=T*(x//T+p)", "x", "T*(x//T+p)", "T", "x//T+p", "x//T", "x", "T", "p", "print(x+y)", "print", "x+y", "x", "y", "T,A=map(int,input().split())", "map(int,input().split())", "T", "x=T*(y//A+p)", "T*(y//A+p)", "x", "y=0,0", "0", "y", "y=A*(x//T+p)", "A*(x//T+p)", "y", "y=T,A", "A", "y", "A=map(int,input().split())", "map(int,input().split())", "A", "p=0", "0", "p", "x=T*(x//T+p)", "T*(x//T+p)", "x", "def gcd(x,y):\n if y==0:\n return x\n else:\n return gcd(y,x%y)", "def gcd(x,y):\n if y==0:\n return x\n else:\n return gcd(y,x%y)", "gcd", "x,y=T,A", "T", "x", "p=1", "1", "p", "p=1", "1", "p", "x,y=0,0", "0", "x", "x,y=T,A", "T", "x", "y=A*(y//A+p)", "A*(y//A+p)", "y", "y=A*(y//A+p)", "A*(y//A+p)", "y", "x=T*(x//T+p)", "T*(x//T+p)", "x", "p=1", "1", "p", "x=T*(y//A+p)", "T*(y//A+p)", "x", "p=1", "1", "p", "y=T,A", "A", "y", "N=int(input())", "int(input())", "N", "y=A*(x//T+p)", "A*(x//T+p)", "y", "def lcm(x,y):\n return x*y//gcd(x,y)", "def lcm(x,y):\n return x*y//gcd(x,y)", "lcm" ]

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

[ [ 83, 4 ], [ 77, 11 ], [ 84, 15 ], [ 92, 17 ], [ 98, 20 ], [ 24, 23 ], [ 78, 26 ], [ 101, 28 ], [ 84, 35 ], [ 101, 37 ], [ 95, 39 ], [ 93, 43 ], [ 75, 43 ], [ 81, 44 ], [ 104, 46 ], [ 99, 50 ], [ 90, 50 ], [ 102, 51 ], [ 86, 53 ], [ 96, 56 ], [ 105, 57 ], [ 74, 59 ], [ 81, 61 ], [ 87, 62 ], [ 89, 64 ], [ 102, 66 ], [ 87, 67 ], [ 75, 71 ], [ 93, 71 ], [ 90, 72 ], [ 99, 72 ], [ 74, 75 ], [ 77, 78 ], [ 101, 81 ], [ 83, 84 ], [ 86, 87 ], [ 89, 90 ], [ 92, 93 ], [ 95, 96 ], [ 98, 99 ], [ 101, 102 ], [ 104, 105 ] ]

[ "import sys\ninput = sys.stdin.readline\nn=int(input())\nT=1\nA=1\n\nfor i in range(n):\n t,a=map(int,input().split())\n x=-(-T//t)\n y=-(-A//a)\n bai=max(x,y)\n T=t*bai\n A=a*bai\nprint(T+A)", "import sys", "sys", "input = sys.stdin.readline", "input", "sys.stdin.readline", "sys.stdin", "sys", "stdin", "readline", "n=int(input())", "n", "int(input())", "int", "input()", "input", "T=1", "T", "1", "A=1", "A", "1", "for i in range(n):\n t,a=map(int,input().split())\n x=-(-T//t)\n y=-(-A//a)\n bai=max(x,y)\n T=t*bai\n A=a*bai", "i", "range(n)", "range", "n", "t,a=map(int,input().split())", "t", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "a", "x=-(-T//t)", "x", "-(-T//t)", "-T//t", "-T", "T", "t", "y=-(-A//a)", "y", "-(-A//a)", "-A//a", "-A", "A", "a", "bai=max(x,y)", "bai", "max(x,y)", "max", "x", "y", "T=t*bai", "T", "t*bai", "t", "bai", "A=a*bai", "A", "a*bai", "a", "bai", "print(T+A)", "print", "T+A", "T", "A", "T=t*bai", "t*bai", "T", "n=int(input())", "int(input())", "n", "t,a=map(int,input().split())", "map(int,input().split())", "t", "input = sys.stdin.readline", "sys.stdin.readline", "input", "bai=max(x,y)", "max(x,y)", "bai", "A=a*bai", "a*bai", "A", "T=1", "1", "T", "x=-(-T//t)", "-(-T//t)", "x", "A=1", "1", "A", "a=map(int,input().split())", "map(int,input().split())", "a", "y=-(-A//a)", "-(-A//a)", "y" ]

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

[ [ 7, 6 ], [ 26, 25 ], [ 6, 29 ], [ 33, 32 ], [ 25, 35 ], [ 6, 45 ], [ 49, 48 ], [ 52, 51 ], [ 48, 53 ], [ 52, 55 ], [ 58, 57 ], [ 25, 61 ], [ 64, 63 ], [ 48, 65 ], [ 57, 66 ], [ 64, 67 ], [ 63, 71 ], [ 51, 72 ], [ 101, 72 ], [ 77, 72 ], [ 67, 74 ], [ 55, 75 ], [ 106, 75 ], [ 80, 75 ], [ 78, 77 ], [ 63, 78 ], [ 81, 80 ], [ 67, 81 ], [ 84, 83 ], [ 51, 89 ], [ 101, 89 ], [ 77, 89 ], [ 63, 90 ], [ 63, 92 ], [ 55, 96 ], [ 106, 96 ], [ 80, 96 ], [ 67, 97 ], [ 67, 99 ], [ 102, 101 ], [ 63, 103 ], [ 83, 104 ], [ 107, 106 ], [ 67, 108 ], [ 83, 109 ], [ 101, 113 ], [ 77, 113 ], [ 51, 113 ], [ 106, 114 ], [ 80, 114 ], [ 55, 114 ], [ 123, 120 ] ]

[ "def main():\n import sys\n input = sys.stdin.readline\n sys.setrecursionlimit(10**7)\n from collections import Counter, deque\n #from collections import defaultdict\n from itertools import combinations, permutations, accumulate, groupby\n #from itertools import product\n from bisect import bisect_left,bisect_right\n from heapq import heapify, heappop, heappush\n from math import floor, ceil\n #from operator import itemgetter\n\n #inf = 10**17\n #mod = 10**9 + 7\n\n n = int(input())\n at = [list(map(int, input().split())) for _ in range(n)]\n x, y = at[0]\n for i in range(1, n):\n nx, ny = at[i]\n if nx >= x and ny >= y:\n x = nx\n y = ny\n else:\n a = max((x+nx-1)//nx, (y+ny-1)//ny)\n x = nx * a\n y = ny * a\n print(x+y)\n\nif __name__ == '__main__':\n main()", "def main():\n import sys\n input = sys.stdin.readline\n sys.setrecursionlimit(10**7)\n from collections import Counter, deque\n #from collections import defaultdict\n from itertools import combinations, permutations, accumulate, groupby\n #from itertools import product\n from bisect import bisect_left,bisect_right\n from heapq import heapify, heappop, heappush\n from math import floor, ceil\n #from operator import itemgetter\n\n #inf = 10**17\n #mod = 10**9 + 7\n\n n = int(input())\n at = [list(map(int, input().split())) for _ in range(n)]\n x, y = at[0]\n for i in range(1, n):\n nx, ny = at[i]\n if nx >= x and ny >= y:\n x = nx\n y = ny\n else:\n a = max((x+nx-1)//nx, (y+ny-1)//ny)\n x = nx * a\n y = ny * a\n print(x+y)", "main", "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", "from collections import Counter, deque", "from itertools import combinations, permutations, accumulate, groupby", "from bisect import bisect_left,bisect_right", "from heapq import heapify, heappop, heappush", "from math import floor, ceil", "n = int(input())", "n", "int(input())", "int", "input()", "input", "list(map(int, input().split())) for _ in range(n)", "for _ in range(n)", "_", "range(n)", "range", "n", "for _ in range(n)", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "at = [list(map(int, input().split())) for _ in range(n)]", "at", "[list(map(int, input().split())) for _ in range(n)]", "x, y = at[0]", "x", "at[0]", "at", "0", "y", "for i in range(1, n):\n nx, ny = at[i]\n if nx >= x and ny >= y:\n x = nx\n y = ny\n else:\n a = max((x+nx-1)//nx, (y+ny-1)//ny)\n x = nx * a\n y = ny * a\n ", "i", "range(1, n)", "range", "1", "n", "nx, ny = at[i]", "nx", "at[i]", "at", "i", "ny", "if nx >= x and ny >= y:\n x = nx\n y = ny\n else:\n a = max((x+nx-1)//nx, (y+ny-1)//ny)\n x = nx * a\n y = ny * a\n ", "nx >= x and ny >= y", "nx >= x", "nx", "x", "ny >= y", "ny", "y", "x = nx", "x", "nx", "y = ny", "y", "ny", "a = max((x+nx-1)//nx, (y+ny-1)//ny)", "a", "max((x+nx-1)//nx, (y+ny-1)//ny)", "max", "(x+nx-1)//nx", "x+nx-1", "x+nx", "x", "nx", "1", "nx", "(y+ny-1)//ny", "y+ny-1", "y+ny", "y", "ny", "1", "ny", "x = nx * a", "x", "nx * a", "nx", "a", "y = ny * a", "y", "ny * a", "ny", "a", "print(x+y)", "print", "x+y", "x", "y", "if __name__ == '__main__':\n main()", "__name__ == '__main__'", "__name__", "'__main__'", "main()", "main", "def main():\n import sys\n input = sys.stdin.readline\n sys.setrecursionlimit(10**7)\n from collections import Counter, deque\n #from collections import defaultdict\n from itertools import combinations, permutations, accumulate, groupby\n #from itertools import product\n from bisect import bisect_left,bisect_right\n from heapq import heapify, heappop, heappush\n from math import floor, ceil\n #from operator import itemgetter\n\n #inf = 10**17\n #mod = 10**9 + 7\n\n n = int(input())\n at = [list(map(int, input().split())) for _ in range(n)]\n x, y = at[0]\n for i in range(1, n):\n nx, ny = at[i]\n if nx >= x and ny >= y:\n x = nx\n y = ny\n else:\n a = max((x+nx-1)//nx, (y+ny-1)//ny)\n x = nx * a\n y = ny * a\n print(x+y)", "def main():\n import sys\n input = sys.stdin.readline\n sys.setrecursionlimit(10**7)\n from collections import Counter, deque\n #from collections import defaultdict\n from itertools import combinations, permutations, accumulate, groupby\n #from itertools import product\n from bisect import bisect_left,bisect_right\n from heapq import heapify, heappop, heappush\n from math import floor, ceil\n #from operator import itemgetter\n\n #inf = 10**17\n #mod = 10**9 + 7\n\n n = int(input())\n at = [list(map(int, input().split())) for _ in range(n)]\n x, y = at[0]\n for i in range(1, n):\n nx, ny = at[i]\n if nx >= x and ny >= y:\n x = nx\n y = ny\n else:\n a = max((x+nx-1)//nx, (y+ny-1)//ny)\n x = nx * a\n y = ny * a\n print(x+y)", "main" ]

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

[ [ 113, 2 ], [ 146, 8 ], [ 125, 10 ], [ 14, 13 ], [ 114, 16 ], [ 155, 18 ], [ 155, 27 ], [ 13, 30 ], [ 143, 33 ], [ 156, 34 ], [ 128, 36 ], [ 117, 37 ], [ 156, 41 ], [ 147, 42 ], [ 132, 42 ], [ 153, 42 ], [ 144, 42 ], [ 117, 44 ], [ 126, 45 ], [ 150, 45 ], [ 120, 45 ], [ 129, 45 ], [ 152, 47 ], [ 156, 48 ], [ 119, 49 ], [ 117, 50 ], [ 110, 52 ], [ 122, 54 ], [ 137, 57 ], [ 147, 61 ], [ 132, 61 ], [ 153, 61 ], [ 144, 61 ], [ 156, 62 ], [ 147, 65 ], [ 132, 65 ], [ 153, 65 ], [ 144, 65 ], [ 156, 66 ], [ 147, 69 ], [ 132, 69 ], [ 153, 69 ], [ 144, 69 ], [ 156, 70 ], [ 134, 73 ], [ 126, 77 ], [ 150, 77 ], [ 120, 77 ], [ 129, 77 ], [ 117, 78 ], [ 126, 81 ], [ 150, 81 ], [ 120, 81 ], [ 129, 81 ], [ 117, 82 ], [ 126, 85 ], [ 150, 85 ], [ 120, 85 ], [ 129, 85 ], [ 117, 86 ], [ 140, 89 ], [ 138, 92 ], [ 111, 92 ], [ 135, 93 ], [ 123, 93 ], [ 131, 95 ], [ 156, 97 ], [ 141, 98 ], [ 149, 100 ], [ 117, 102 ], [ 141, 103 ], [ 132, 107 ], [ 153, 107 ], [ 144, 107 ], [ 147, 107 ], [ 150, 108 ], [ 120, 108 ], [ 129, 108 ], [ 126, 108 ], [ 110, 111 ], [ 113, 114 ], [ 155, 117 ], [ 117, 119 ], [ 119, 120 ], [ 122, 123 ], [ 125, 126 ], [ 117, 128 ], [ 128, 129 ], [ 131, 132 ], [ 134, 135 ], [ 137, 138 ], [ 140, 141 ], [ 156, 143 ], [ 143, 144 ], [ 146, 147 ], [ 149, 150 ], [ 156, 152 ], [ 152, 153 ], [ 155, 156 ] ]

[ "n = int(input())\nt_all, a_all = 0, 0\nfor i in range(n):\n t, a = map(int, input().split())\n if i == 0:\n t_all = t\n a_all = a\n else:\n if t >= t_all and a >= a_all:\n t_all, a_all = t, a\n else:\n diff1, diff2 = 0, 0\n diff1 = t_all // t if t_all % t == 0 else t_all // t + 1\n diff2 = a_all // a if a_all % a == 0 else a_all // a + 1\n max_diff = max(diff1, diff2)\n t_all = t * max_diff\n a_all = a * max_diff\nprint(t_all + a_all)\n ", "n = int(input())", "n", "int(input())", "int", "input()", "input", "t_all, a_all = 0, 0", "t_all", "0", "a_all", "0", "for i in range(n):\n t, a = map(int, input().split())\n if i == 0:\n t_all = t\n a_all = a\n else:\n if t >= t_all and a >= a_all:\n t_all, a_all = t, a\n else:\n diff1, diff2 = 0, 0\n diff1 = t_all // t if t_all % t == 0 else t_all // t + 1\n diff2 = a_all // a if a_all % a == 0 else a_all // a + 1\n max_diff = max(diff1, diff2)\n t_all = t * max_diff\n a_all = a * max_diff", "i", "range(n)", "range", "n", "t, a = map(int, input().split())", "t", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "a", "if i == 0:\n t_all = t\n a_all = a\n else:\n if t >= t_all and a >= a_all:\n t_all, a_all = t, a\n else:\n diff1, diff2 = 0, 0\n diff1 = t_all // t if t_all % t == 0 else t_all // t + 1\n diff2 = a_all // a if a_all % a == 0 else a_all // a + 1\n max_diff = max(diff1, diff2)\n t_all = t * max_diff\n a_all = a * max_diff", "i == 0", "i", "0", "t_all = t", "t_all", "t", "a_all = a", "a_all", "a", "if t >= t_all and a >= a_all:\n t_all, a_all = t, a\n else:\n diff1, diff2 = 0, 0\n diff1 = t_all // t if t_all % t == 0 else t_all // t + 1\n diff2 = a_all // a if a_all % a == 0 else a_all // a + 1\n max_diff = max(diff1, diff2)\n t_all = t * max_diff\n a_all = a * max_diff", "t >= t_all and a >= a_all", "t >= t_all", "t", "t_all", "a >= a_all", "a", "a_all", "t_all, a_all = t, a", "t_all", "t", "a_all", "a", "diff1, diff2 = 0, 0", "diff1", "0", "diff2", "0", "diff1 = t_all // t if t_all % t == 0 else t_all // t + 1", "diff1", "t_all // t if t_all % t == 0 else t_all // t + 1", "t_all % t == 0", "t_all % t", "t_all", "t", "0", "t_all // t", "t_all", "t", "t_all // t + 1", "t_all // t", "t_all", "t", "1", "diff2 = a_all // a if a_all % a == 0 else a_all // a + 1", "diff2", "a_all // a if a_all % a == 0 else a_all // a + 1", "a_all % a == 0", "a_all % a", "a_all", "a", "0", "a_all // a", "a_all", "a", "a_all // a + 1", "a_all // a", "a_all", "a", "1", "max_diff = max(diff1, diff2)", "max_diff", "max(diff1, diff2)", "max", "diff1", "diff2", "t_all = t * max_diff", "t_all", "t * max_diff", "t", "max_diff", "a_all = a * max_diff", "a_all", "a * max_diff", "a", "max_diff", "print(t_all + a_all)", "print", "t_all + a_all", "t_all", "a_all", "diff1, diff2 = 0, 0", "0", "diff1", "n = int(input())", "int(input())", "n", "a = map(int, input().split())", "map(int, input().split())", "a", "a_all = t, a", "a", "a_all", "diff2 = 0, 0", "0", "diff2", "a_all = 0, 0", "0", "a_all", "a_all = a", "a", "a_all", "t_all = t * max_diff", "t * max_diff", "t_all", "diff2 = a_all // a if a_all % a == 0 else a_all // a + 1", "a_all // a if a_all % a == 0 else a_all // a + 1", "diff2", "diff1 = t_all // t if t_all % t == 0 else t_all // t + 1", "t_all // t if t_all % t == 0 else t_all // t + 1", "diff1", "max_diff = max(diff1, diff2)", "max(diff1, diff2)", "max_diff", "t_all = t", "t", "t_all", "t_all, a_all = 0, 0", "0", "t_all", "a_all = a * max_diff", "a * max_diff", "a_all", "t_all, a_all = t, a", "t", "t_all", "t, a = map(int, input().split())", "map(int, input().split())", "t" ]

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

[ [ 79, 2 ], [ 85, 8 ], [ 85, 17 ], [ 20, 19 ], [ 80, 23 ], [ 73, 26 ], [ 73, 35 ], [ 82, 37 ], [ 65, 43 ], [ 77, 43 ], [ 74, 44 ], [ 86, 47 ], [ 71, 47 ], [ 68, 48 ], [ 76, 50 ], [ 74, 52 ], [ 83, 53 ], [ 70, 54 ], [ 68, 56 ], [ 83, 57 ], [ 77, 61 ], [ 65, 61 ], [ 71, 62 ], [ 86, 62 ], [ 85, 65 ], [ 73, 68 ], [ 70, 71 ], [ 73, 74 ], [ 76, 77 ], [ 79, 80 ], [ 82, 83 ], [ 85, 86 ] ]

[ "n = int(input())\na,b = map(int,input().split())\n\nfor i in range(n-1):\n c,d = map(int,input().split())\n x = -min((-a)//c,(-b)//d)\n a,b = c*x,d*x\nprint(a + b)", "n = int(input())", "n", "int(input())", "int", "input()", "input", "a,b = map(int,input().split())", "a", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "for i in range(n-1):\n c,d = map(int,input().split())\n x = -min((-a)//c,(-b)//d)\n a,b = c*x,d*x", "i", "range(n-1)", "range", "n-1", "n", "1", "c,d = map(int,input().split())", "c", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "d", "x = -min((-a)//c,(-b)//d)", "x", "-min((-a)//c,(-b)//d)", "min((-a)//c,(-b)//d)", "min", "(-a)//c", "-a", "a", "c", "(-b)//d", "-b", "b", "d", "a,b = c*x,d*x", "a", "c*x", "c", "x", "b", "d*x", "d", "x", "print(a + b)", "print", "a + b", "a", "b", "a,b = map(int,input().split())", "map(int,input().split())", "a", "d = map(int,input().split())", "map(int,input().split())", "d", "b = c*x,d*x", "d*x", "b", "c,d = map(int,input().split())", "map(int,input().split())", "c", "a,b = c*x,d*x", "c*x", "a", "n = int(input())", "int(input())", "n", "x = -min((-a)//c,(-b)//d)", "-min((-a)//c,(-b)//d)", "x", "b = map(int,input().split())", "map(int,input().split())", "b" ]

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

[ [ 79, 5 ], [ 88, 11 ], [ 76, 14 ], [ 18, 17 ], [ 80, 20 ], [ 94, 22 ], [ 94, 31 ], [ 85, 33 ], [ 95, 35 ], [ 89, 44 ], [ 86, 44 ], [ 95, 45 ], [ 77, 48 ], [ 83, 48 ], [ 92, 49 ], [ 82, 51 ], [ 92, 53 ], [ 86, 62 ], [ 89, 62 ], [ 95, 63 ], [ 77, 66 ], [ 83, 66 ], [ 92, 67 ], [ 86, 73 ], [ 89, 73 ], [ 83, 74 ], [ 77, 74 ], [ 76, 77 ], [ 79, 80 ], [ 82, 83 ], [ 85, 86 ], [ 88, 89 ], [ 94, 92 ], [ 94, 95 ] ]

[ "import math\nfrom fractions import Fraction\nn = int(input())\n# t0, a0 = map(int, input().split())\nanst = 1\nansa = 1\nfor _ in range(n):\n ti, ai = map(int, input().split())\n anst = ti * math.ceil(max(Fraction(anst, ti), Fraction(ansa, ai)))\n ansa = ai * math.ceil(max(Fraction(anst, ti), Fraction(ansa, ai)))\n # p\n # if math.ceil(anst/ti) < math.ceil(ansa/ai):\n # # if math.ceil(anst/ti)*ai >= ansa:\n # # anst = ti * math.ceil(anst/ti)\n # # ansa = ai * math.ceil(anst/ti)\n # # else:\n # ansa = ai * math.ceil(ansa/ai)\n # anst = ti * math.ceil(ansa/ai)\n # else:\n # # if math.ceil(ansa/ai)*ti >= anst:\n # # ansa = ai * math.ceil(ansa/ai)\n # # anst = ti * math.ceil(ansa/ai)\n # # else:\n # ansa = ai * math.ceil(anst/ti)\n # anst = ti * math.ceil(anst/ti)\n # # print(\"anst\", anst,\"ansa = \", ansa)\n \nprint(int(anst + ansa))\n ", "import math", "math", "from fractions import Fraction", "n = int(input())", "n", "int(input())", "int", "input()", "input", "anst = 1", "anst", "1", "ansa = 1", "ansa", "1", "for _ in range(n):\n ti, ai = map(int, input().split())\n anst = ti * math.ceil(max(Fraction(anst, ti), Fraction(ansa, ai)))\n ansa = ai * math.ceil(max(Fraction(anst, ti), Fraction(ansa, ai)))\n # p\n # if math.ceil(anst/ti) < math.ceil(ansa/ai):\n # # if math.ceil(anst/ti)*ai >= ansa:\n # # anst = ti * math.ceil(anst/ti)\n # # ansa = ai * math.ceil(anst/ti)\n # # else:\n # ansa = ai * math.ceil(ansa/ai)\n # anst = ti * math.ceil(ansa/ai)\n # else:\n # # if math.ceil(ansa/ai)*ti >= anst:\n # # ansa = ai * math.ceil(ansa/ai)\n # # anst = ti * math.ceil(ansa/ai)\n # # else:\n # ansa = ai * math.ceil(anst/ti)\n # anst = ti * math.ceil(anst/ti)\n # # print(\"anst\", anst,\"ansa = \", ansa)\n ", "_", "range(n)", "range", "n", "ti, ai = map(int, input().split())", "ti", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "ai", "anst = ti * math.ceil(max(Fraction(anst, ti), Fraction(ansa, ai)))", "anst", "ti * math.ceil(max(Fraction(anst, ti), Fraction(ansa, ai)))", "ti", "math.ceil(max(Fraction(anst, ti), Fraction(ansa, ai)))", "math.ceil", "math", "ceil", "max(Fraction(anst, ti), Fraction(ansa, ai))", "max", "Fraction(anst, ti)", "Fraction", "anst", "ti", "Fraction(ansa, ai)", "Fraction", "ansa", "ai", "ansa = ai * math.ceil(max(Fraction(anst, ti), Fraction(ansa, ai)))", "ansa", "ai * math.ceil(max(Fraction(anst, ti), Fraction(ansa, ai)))", "ai", "math.ceil(max(Fraction(anst, ti), Fraction(ansa, ai)))", "math.ceil", "math", "ceil", "max(Fraction(anst, ti), Fraction(ansa, ai))", "max", "Fraction(anst, ti)", "Fraction", "anst", "ti", "Fraction(ansa, ai)", "Fraction", "ansa", "ai", "print(int(anst + ansa))", "print", "int(anst + ansa)", "int", "anst + ansa", "anst", "ansa", "ansa = 1", "1", "ansa", "n = int(input())", "int(input())", "n", "ansa = ai * math.ceil(max(Fraction(anst, ti), Fraction(ansa, ai)))", "ai * math.ceil(max(Fraction(anst, ti), Fraction(ansa, ai)))", "ansa", "anst = ti * math.ceil(max(Fraction(anst, ti), Fraction(ansa, ai)))", "ti * math.ceil(max(Fraction(anst, ti), Fraction(ansa, ai)))", "anst", "anst = 1", "1", "anst", "ai = map(int, input().split())", "map(int, input().split())", "ai", "ti, ai = map(int, input().split())", "map(int, input().split())", "ti" ]

[ 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, 0, 13, 17, 0, 13, 17, 28, 13, 4, 13, 13, 0, 13, 4, 13, 13, 0, 13, 2, 2, 2, 13, 13, 17, 13, 0, 13, 2, 2, 2, 13, 13, 17, 13, 0, 13, 4, 13, 13, 13, 0, 13, 2, 13, 13, 0, 13, 2, 13, 13, 4, 13, 2, 13, 13, 4, 13, 10, 12, 13, 10, 12, 13, 10, 12, 13, 10, 18, 13, 10, 12, 13 ]

[ [ 96, 4 ], [ 20, 19 ], [ 27, 26 ], [ 88, 28 ], [ 31, 30 ], [ 34, 33 ], [ 37, 36 ], [ 26, 39 ], [ 42, 41 ], [ 91, 43 ], [ 42, 44 ], [ 47, 46 ], [ 30, 50 ], [ 70, 50 ], [ 41, 51 ], [ 41, 53 ], [ 56, 55 ], [ 33, 59 ], [ 75, 59 ], [ 44, 60 ], [ 44, 62 ], [ 65, 64 ], [ 46, 67 ], [ 55, 68 ], [ 71, 70 ], [ 41, 72 ], [ 64, 73 ], [ 76, 75 ], [ 44, 77 ], [ 64, 78 ], [ 70, 82 ], [ 30, 82 ], [ 75, 83 ], [ 33, 83 ], [ 100, 85 ], [ 96, 97 ] ]

[ "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 N=I()\n NT=1\n NA=1\n for i in range(N):\n T,A=MI()\n xt=(NT+T-1)//T\n xa=(NA+A-1)//A\n x=max(xt,xa)\n NT=T*x\n NA=A*x\n print(NT+NA)\n \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 N=I()\n NT=1\n NA=1\n for i in range(N):\n T,A=MI()\n xt=(NT+T-1)//T\n xa=(NA+A-1)//A\n x=max(xt,xa)\n NT=T*x\n NA=A*x\n print(NT+NA)\n ", "main", "mod=10**9+7", "mod", "10**9+7", "10**9", "10", "9", "7", "N=I()", "N", "I()", "I", "NT=1", "NT", "1", "NA=1", "NA", "1", "for i in range(N):\n T,A=MI()\n xt=(NT+T-1)//T\n xa=(NA+A-1)//A\n x=max(xt,xa)\n NT=T*x\n NA=A*x\n ", "i", "range(N)", "range", "N", "T,A=MI()", "T", "MI()", "MI", "A", "xt=(NT+T-1)//T", "xt", "(NT+T-1)//T", "NT+T-1", "NT+T", "NT", "T", "1", "T", "xa=(NA+A-1)//A", "xa", "(NA+A-1)//A", "NA+A-1", "NA+A", "NA", "A", "1", "A", "x=max(xt,xa)", "x", "max(xt,xa)", "max", "xt", "xa", "NT=T*x", "NT", "T*x", "T", "x", "NA=A*x", "NA", "A*x", "A", "x", "print(NT+NA)", "print", "NT+NA", "NT", "NA", "main()", "main", "def I(): return int(input())", "def I(): return int(input())", "I", "def MI(): return map(int, input().split())", "def MI(): return map(int, input().split())", "MI", "def LI(): return list(map(int, input().split()))", "def LI(): return list(map(int, input().split()))", "LI", "input = sys.stdin.readline", "sys.stdin.readline", "input", "def main():\n mod=10**9+7\n N=I()\n NT=1\n NA=1\n for i in range(N):\n T,A=MI()\n xt=(NT+T-1)//T\n xa=(NA+A-1)//A\n x=max(xt,xa)\n NT=T*x\n NA=A*x\n print(NT+NA)\n ", "def main():\n mod=10**9+7\n N=I()\n NT=1\n NA=1\n for i in range(N):\n T,A=MI()\n xt=(NT+T-1)//T\n xa=(NA+A-1)//A\n x=max(xt,xa)\n NT=T*x\n NA=A*x\n print(NT+NA)\n ", "main" ]

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

[ [ 73, 3 ], [ 67, 9 ], [ 76, 14 ], [ 18, 17 ], [ 74, 20 ], [ 85, 22 ], [ 85, 31 ], [ 70, 33 ], [ 68, 40 ], [ 83, 40 ], [ 80, 43 ], [ 68, 47 ], [ 83, 47 ], [ 86, 50 ], [ 82, 53 ], [ 80, 56 ], [ 71, 57 ], [ 77, 57 ], [ 86, 59 ], [ 71, 60 ], [ 77, 60 ], [ 83, 65 ], [ 68, 65 ], [ 67, 68 ], [ 70, 71 ], [ 73, 74 ], [ 76, 77 ], [ 85, 80 ], [ 82, 83 ], [ 85, 86 ] ]

[ "from math import ceil \nN = int(input())\nvotes = [1,1]\nrate = 1\nfor i in range(N):\n t,a = map(int,input().split())\n rate = max((votes[0] - 1) // t, (votes[1] - 1) // a) + 1\n # if t * rate >= votes[0] and a * rate >= votes[1]:\n votes = [t * rate, a * rate]\n\nprint(sum(votes))", "from math import ceil", "N = int(input())", "N", "int(input())", "int", "input()", "input", "votes = [1,1]", "votes", "[1,1]", "1", "1", "rate = 1", "rate", "1", "for i in range(N):\n t,a = map(int,input().split())\n rate = max((votes[0] - 1) // t, (votes[1] - 1) // a) + 1\n # if t * rate >= votes[0] and a * rate >= votes[1]:\n votes = [t * rate, a * rate]", "i", "range(N)", "range", "N", "t,a = map(int,input().split())", "t", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "a", "rate = max((votes[0] - 1) // t, (votes[1] - 1) // a) + 1", "rate", "max((votes[0] - 1) // t, (votes[1] - 1) // a) + 1", "max((votes[0] - 1) // t, (votes[1] - 1) // a)", "max", "(votes[0] - 1) // t", "votes[0] - 1", "votes[0]", "votes", "0", "1", "t", "(votes[1] - 1) // a", "votes[1] - 1", "votes[1]", "votes", "1", "1", "a", "1", "votes = [t * rate, a * rate]", "votes", "[t * rate, a * rate]", "t * rate", "t", "rate", "a * rate", "a", "rate", "print(sum(votes))", "print", "sum(votes)", "sum", "votes", "votes = [1,1]", "[1,1]", "votes", "rate = max((votes[0] - 1) // t, (votes[1] - 1) // a) + 1", "max((votes[0] - 1) // t, (votes[1] - 1) // a) + 1", "rate", "N = int(input())", "int(input())", "N", "rate = 1", "1", "rate", "t,a = map(int,input().split())", "map(int,input().split())", "t", "votes = [t * rate, a * rate]", "[t * rate, a * rate]", "votes", "a = map(int,input().split())", "map(int,input().split())", "a" ]

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

[ [ 97, 2 ], [ 100, 8 ], [ 91, 11 ], [ 17, 16 ], [ 98, 19 ], [ 94, 21 ], [ 106, 33 ], [ 92, 38 ], [ 95, 42 ], [ 103, 46 ], [ 92, 51 ], [ 95, 55 ], [ 88, 59 ], [ 107, 62 ], [ 104, 63 ], [ 68, 65 ], [ 92, 66 ], [ 95, 70 ], [ 89, 72 ], [ 77, 74 ], [ 92, 75 ], [ 95, 79 ], [ 89, 81 ], [ 92, 86 ], [ 88, 89 ], [ 91, 92 ], [ 94, 95 ], [ 97, 98 ], [ 100, 101 ], [ 103, 104 ], [ 106, 107 ] ]

[ "N=int(input())\nT=[]\n\nA=[1,1]\n\nfor i in range(N):\n\tt=list(map(int,input().split()))\n\t\n\tn0 = (A[0]-1)//t[0] + 1\n\tn1 = (A[1]-1)//t[1] + 1\n\tn = max(n0,n1)\n\n\tA[0]=t[0]*n\n\tA[1]=t[1]*n\n\n\nprint(sum(A))", "N=int(input())", "N", "int(input())", "int", "input()", "input", "T=[]", "T", "[]", "A=[1,1]", "A", "[1,1]", "1", "1", "for i in range(N):\n\tt=list(map(int,input().split()))\n\t\n\tn0 = (A[0]-1)//t[0] + 1\n\tn1 = (A[1]-1)//t[1] + 1\n\tn = max(n0,n1)\n\n\tA[0]=t[0]*n\n\tA[1]=t[1]*n", "i", "range(N)", "range", "N", "t=list(map(int,input().split()))", "t", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "n0 = (A[0]-1)//t[0] + 1", "n0", "(A[0]-1)//t[0] + 1", "(A[0]-1)//t[0]", "A[0]-1", "A[0]", "A", "0", "1", "t[0]", "t", "0", "1", "n1 = (A[1]-1)//t[1] + 1", "n1", "(A[1]-1)//t[1] + 1", "(A[1]-1)//t[1]", "A[1]-1", "A[1]", "A", "1", "1", "t[1]", "t", "1", "1", "n = max(n0,n1)", "n", "max(n0,n1)", "max", "n0", "n1", "A[0]=t[0]*n", "A[0]", "A", "0", "t[0]*n", "t[0]", "t", "0", "n", "A[1]=t[1]*n", "A[1]", "A", "1", "t[1]*n", "t[1]", "t", "1", "n", "print(sum(A))", "print", "sum(A)", "sum", "A", "n = max(n0,n1)", "max(n0,n1)", "n", "A=[1,1]", "[1,1]", "A", "t=list(map(int,input().split()))", "list(map(int,input().split()))", "t", "N=int(input())", "int(input())", "N", "T=[]", "[]", "T", "n1 = (A[1]-1)//t[1] + 1", "(A[1]-1)//t[1] + 1", "n1", "n0 = (A[0]-1)//t[0] + 1", "(A[0]-1)//t[0] + 1", "n0" ]

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

[ [ 83, 3 ], [ 11, 10 ], [ 84, 13 ], [ 86, 24 ], [ 89, 27 ], [ 98, 32 ], [ 92, 37 ], [ 45, 44 ], [ 101, 52 ], [ 93, 56 ], [ 90, 58 ], [ 96, 58 ], [ 93, 61 ], [ 99, 63 ], [ 105, 63 ], [ 95, 66 ], [ 102, 69 ], [ 104, 71 ], [ 102, 74 ], [ 96, 80 ], [ 90, 80 ], [ 105, 81 ], [ 99, 81 ], [ 83, 84 ], [ 86, 87 ], [ 89, 90 ], [ 92, 93 ], [ 95, 96 ], [ 98, 99 ], [ 101, 102 ], [ 104, 105 ] ]

[ "from decimal import Decimal, ROUND_CEILING\n\nN = int(input())\npairs = (map(Decimal, input().split()) for _ in range(N))\n\nt = Decimal('1')\na = Decimal('1')\nceil = lambda d: d.to_integral_exact(rounding=ROUND_CEILING)\n\nfor ti, ai in pairs:\n mul = max(ceil(t / ti), ceil(a / ai))\n t = ti * mul\n a = ai * mul\n\nprint(int(t + a))", "from decimal import Decimal, ROUND_CEILING", "N = int(input())", "N", "int(input())", "int", "input()", "input", "map(Decimal, input().split()) for _ in range(N)", "for _ in range(N)", "_", "range(N)", "range", "N", "for _ in range(N)", "map(Decimal, input().split())", "map", "Decimal", "input().split()", "().split", "()", "input", "split", "pairs = (map(Decimal, input().split()) for _ in range(N))", "pairs", "(map(Decimal, input().split()) for _ in range(N))", "t = Decimal('1')", "t", "Decimal('1')", "Decimal", "'1'", "a = Decimal('1')", "a", "Decimal('1')", "Decimal", "'1'", "ceil = lambda d: d.to_integral_exact(rounding=ROUND_CEILING)", "ceil", "lambda d: d.to_integral_exact(rounding=ROUND_CEILING)", "d.to_integral_exact(rounding=ROUND_CEILING)", "d.to_integral_exact", "d", "to_integral_exact", "rounding=ROUND_CEILING", "rounding", "ROUND_CEILING", "d", "for ti, ai in pairs:\n mul = max(ceil(t / ti), ceil(a / ai))\n t = ti * mul\n a = ai * mul", "ti", "ai", "pairs", "mul = max(ceil(t / ti), ceil(a / ai))", "mul", "max(ceil(t / ti), ceil(a / ai))", "max", "ceil(t / ti)", "ceil", "t / ti", "t", "ti", "ceil(a / ai)", "ceil", "a / ai", "a", "ai", "t = ti * mul", "t", "ti * mul", "ti", "mul", "a = ai * mul", "a", "ai * mul", "ai", "mul", "print(int(t + a))", "print", "int(t + a)", "int", "t + a", "t", "a", "N = int(input())", "int(input())", "N", "pairs = (map(Decimal, input().split()) for _ in range(N))", "(map(Decimal, input().split()) for _ in range(N))", "pairs", "t = Decimal('1')", "Decimal('1')", "t", "ceil = lambda d: d.to_integral_exact(rounding=ROUND_CEILING)", "lambda d: d.to_integral_exact(rounding=ROUND_CEILING)", "ceil", "t = ti * mul", "ti * mul", "t", "a = Decimal('1')", "Decimal('1')", "a", "mul = max(ceil(t / ti), ceil(a / ai))", "max(ceil(t / ti), ceil(a / ai))", "mul", "a = ai * mul", "ai * mul", "a" ]

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

[ [ 77, 2 ], [ 65, 8 ], [ 80, 10 ], [ 14, 13 ], [ 78, 16 ], [ 74, 18 ], [ 74, 27 ], [ 71, 29 ], [ 69, 35 ], [ 66, 36 ], [ 84, 36 ], [ 69, 38 ], [ 75, 42 ], [ 81, 43 ], [ 63, 43 ], [ 75, 45 ], [ 83, 47 ], [ 72, 49 ], [ 69, 50 ], [ 62, 52 ], [ 72, 54 ], [ 75, 55 ], [ 84, 59 ], [ 66, 59 ], [ 63, 60 ], [ 81, 60 ], [ 62, 63 ], [ 65, 66 ], [ 74, 69 ], [ 71, 72 ], [ 74, 75 ], [ 77, 78 ], [ 80, 81 ], [ 83, 84 ] ]

[ "n = int(input())\nvt, va = 1, 1\nfor i in range(n):\n t, a = map(int, input().split())\n d = max((t + vt - 1) // t, (a + va - 1) // a)\n vt = d * t\n va = d * a\nprint(vt + va)", "n = int(input())", "n", "int(input())", "int", "input()", "input", "vt, va = 1, 1", "vt", "1", "va", "1", "for i in range(n):\n t, a = map(int, input().split())\n d = max((t + vt - 1) // t, (a + va - 1) // a)\n vt = d * t\n va = d * a", "i", "range(n)", "range", "n", "t, a = map(int, input().split())", "t", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "a", "d = max((t + vt - 1) // t, (a + va - 1) // a)", "d", "max((t + vt - 1) // t, (a + va - 1) // a)", "max", "(t + vt - 1) // t", "t + vt - 1", "t + vt", "t", "vt", "1", "t", "(a + va - 1) // a", "a + va - 1", "a + va", "a", "va", "1", "a", "vt = d * t", "vt", "d * t", "d", "t", "va = d * a", "va", "d * a", "d", "a", "print(vt + va)", "print", "vt + va", "vt", "va", "va = d * a", "d * a", "va", "vt, va = 1, 1", "1", "vt", "t, a = map(int, input().split())", "map(int, input().split())", "t", "d = max((t + vt - 1) // t, (a + va - 1) // a)", "max((t + vt - 1) // t, (a + va - 1) // a)", "d", "a = map(int, input().split())", "map(int, input().split())", "a", "n = int(input())", "int(input())", "n", "va = 1, 1", "1", "va", "vt = d * t", "d * t", "vt" ]

[ 7, 0, 13, 4, 13, 4, 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, 0, 13, 17, 0, 13, 17, 28, 13, 4, 13, 13, 0, 13, 4, 13, 2, 2, 2, 13, 18, 13, 13, 17, 18, 13, 13, 2, 2, 2, 13, 18, 13, 13, 17, 18, 13, 13, 0, 13, 2, 13, 18, 13, 13, 0, 13, 2, 13, 18, 13, 13, 4, 13, 2, 13, 13, 10, 4, 13, 10, 2, 13, 10, 4, 13, 10, 17, 13, 10, 4, 13, 10, 2, 13, 10, 4, 13, 10, 39, 13, 10, 17, 13, 10, 39, 13 ]

[ [ 114, 2 ], [ 123, 8 ], [ 117, 11 ], [ 15, 14 ], [ 115, 17 ], [ 108, 19 ], [ 108, 28 ], [ 124, 31 ], [ 103, 33 ], [ 118, 36 ], [ 109, 38 ], [ 120, 40 ], [ 105, 43 ], [ 47, 46 ], [ 115, 49 ], [ 96, 51 ], [ 121, 57 ], [ 109, 57 ], [ 100, 57 ], [ 124, 59 ], [ 46, 60 ], [ 124, 63 ], [ 46, 64 ], [ 106, 68 ], [ 112, 68 ], [ 118, 70 ], [ 46, 71 ], [ 118, 74 ], [ 46, 75 ], [ 99, 77 ], [ 97, 79 ], [ 124, 81 ], [ 46, 82 ], [ 111, 84 ], [ 97, 86 ], [ 118, 88 ], [ 46, 89 ], [ 100, 93 ], [ 121, 93 ], [ 109, 93 ], [ 112, 94 ], [ 106, 94 ], [ 96, 97 ], [ 99, 100 ], [ 108, 103 ], [ 105, 106 ], [ 108, 109 ], [ 111, 112 ], [ 114, 115 ], [ 117, 118 ], [ 120, 121 ], [ 123, 124 ] ]

[ "N=int(input())\nT=[]\nA=[]\nfor i in range(N):\n t,a=map(int,input().split())\n T.append(t)\n A.append(a)\na=1\nb=1\nfor i in range(N):\n n=max((a+T[i]-1)//T[i], (b+A[i]-1)//A[i])\n a=n*T[i]\n b=n*A[i]\nprint(a+b)", "N=int(input())", "N", "int(input())", "int", "input()", "input", "T=[]", "T", "[]", "A=[]", "A", "[]", "for i in range(N):\n t,a=map(int,input().split())\n T.append(t)\n A.append(a)", "i", "range(N)", "range", "N", "t,a=map(int,input().split())", "t", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "a", "T.append(t)", "T.append", "T", "append", "t", "A.append(a)", "A.append", "A", "append", "a", "a=1", "a", "1", "b=1", "b", "1", "for i in range(N):\n n=max((a+T[i]-1)//T[i], (b+A[i]-1)//A[i])\n a=n*T[i]\n b=n*A[i]", "i", "range(N)", "range", "N", "n=max((a+T[i]-1)//T[i], (b+A[i]-1)//A[i])", "n", "max((a+T[i]-1)//T[i], (b+A[i]-1)//A[i])", "max", "(a+T[i]-1)//T[i]", "a+T[i]-1", "a+T[i]", "a", "T[i]", "T", "i", "1", "T[i]", "T", "i", "(b+A[i]-1)//A[i]", "b+A[i]-1", "b+A[i]", "b", "A[i]", "A", "i", "1", "A[i]", "A", "i", "a=n*T[i]", "a", "n*T[i]", "n", "T[i]", "T", "i", "b=n*A[i]", "b", "n*A[i]", "n", "A[i]", "A", "i", "print(a+b)", "print", "a+b", "a", "b", "n=max((a+T[i]-1)//T[i], (b+A[i]-1)//A[i])", "max((a+T[i]-1)//T[i], (b+A[i]-1)//A[i])", "n", "a=n*T[i]", "n*T[i]", "a", "t,a=map(int,input().split())", "map(int,input().split())", "t", "b=1", "1", "b", "a=map(int,input().split())", "map(int,input().split())", "a", "b=n*A[i]", "n*A[i]", "b", "N=int(input())", "int(input())", "N", "A=[]", "[]", "A", "a=1", "1", "a", "T=[]", "[]", "T" ]

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

[ [ 139, 2 ], [ 118, 8 ], [ 118, 17 ], [ 115, 19 ], [ 130, 21 ], [ 97, 24 ], [ 103, 26 ], [ 30, 29 ], [ 140, 33 ], [ 112, 36 ], [ 112, 45 ], [ 136, 47 ], [ 110, 52 ], [ 101, 52 ], [ 125, 52 ], [ 107, 53 ], [ 116, 53 ], [ 107, 55 ], [ 116, 55 ], [ 107, 56 ], [ 116, 56 ], [ 121, 58 ], [ 137, 61 ], [ 98, 61 ], [ 107, 62 ], [ 116, 62 ], [ 113, 63 ], [ 131, 63 ], [ 122, 66 ], [ 104, 66 ], [ 119, 67 ], [ 128, 67 ], [ 134, 67 ], [ 124, 69 ], [ 137, 70 ], [ 98, 70 ], [ 133, 71 ], [ 122, 72 ], [ 104, 72 ], [ 127, 74 ], [ 119, 79 ], [ 128, 79 ], [ 134, 79 ], [ 113, 80 ], [ 131, 80 ], [ 113, 82 ], [ 131, 82 ], [ 113, 83 ], [ 131, 83 ], [ 100, 85 ], [ 128, 88 ], [ 119, 88 ], [ 134, 88 ], [ 113, 89 ], [ 131, 89 ], [ 107, 90 ], [ 116, 90 ], [ 101, 94 ], [ 125, 94 ], [ 110, 94 ], [ 128, 95 ], [ 134, 95 ], [ 119, 95 ], [ 97, 98 ], [ 100, 101 ], [ 103, 104 ], [ 112, 107 ], [ 118, 110 ], [ 112, 113 ], [ 115, 116 ], [ 118, 119 ], [ 121, 122 ], [ 137, 124 ], [ 98, 124 ], [ 124, 125 ], [ 127, 128 ], [ 130, 131 ], [ 122, 133 ], [ 104, 133 ], [ 133, 134 ], [ 136, 137 ], [ 139, 140 ] ]

[ "N=int(input())\nX,Y=map(int,input().split())\nT,A=0,0\nb,c=0,0\nfor i in range(N-1):\n T,A=map(int,input().split())\n b=((X+T-1)//T)*T\n c=(b//T)*A\n if c>=Y:\n X,Y=b,c\n else:\n Y=((Y+A-1)//A)*A\n X=(Y//A)*T\nprint(X+Y)", "N=int(input())", "N", "int(input())", "int", "input()", "input", "X,Y=map(int,input().split())", "X", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "Y", "T,A=0,0", "T", "0", "A", "0", "b,c=0,0", "b", "0", "c", "0", "for i in range(N-1):\n T,A=map(int,input().split())\n b=((X+T-1)//T)*T\n c=(b//T)*A\n if c>=Y:\n X,Y=b,c\n else:\n Y=((Y+A-1)//A)*A\n X=(Y//A)*T", "i", "range(N-1)", "range", "N-1", "N", "1", "T,A=map(int,input().split())", "T", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "A", "b=((X+T-1)//T)*T", "b", "((X+T-1)//T)*T", "(X+T-1)//T", "X+T-1", "X+T", "X", "T", "1", "T", "T", "c=(b//T)*A", "c", "(b//T)*A", "b//T", "b", "T", "A", "if c>=Y:\n X,Y=b,c\n else:\n Y=((Y+A-1)//A)*A\n X=(Y//A)*T", "c>=Y", "c", "Y", "X,Y=b,c", "X", "b", "Y", "c", "Y=((Y+A-1)//A)*A", "Y", "((Y+A-1)//A)*A", "(Y+A-1)//A", "Y+A-1", "Y+A", "Y", "A", "1", "A", "A", "X=(Y//A)*T", "X", "(Y//A)*T", "Y//A", "Y", "A", "T", "print(X+Y)", "print", "X+Y", "X", "Y", "b,c=0,0", "0", "b", "X=(Y//A)*T", "(Y//A)*T", "X", "c=0,0", "0", "c", "T,A=map(int,input().split())", "map(int,input().split())", "T", "X,Y=map(int,input().split())", "map(int,input().split())", "X", "A=map(int,input().split())", "map(int,input().split())", "A", "T,A=0,0", "0", "T", "Y=map(int,input().split())", "map(int,input().split())", "Y", "c=(b//T)*A", "(b//T)*A", "c", "X,Y=b,c", "b", "X", "Y=((Y+A-1)//A)*A", "((Y+A-1)//A)*A", "Y", "A=0,0", "0", "A", "Y=b,c", "c", "Y", "b=((X+T-1)//T)*T", "((X+T-1)//T)*T", "b", "N=int(input())", "int(input())", "N" ]

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

[ [ 80, 2 ], [ 83, 8 ], [ 83, 17 ], [ 20, 19 ], [ 81, 23 ], [ 77, 26 ], [ 77, 35 ], [ 71, 37 ], [ 69, 43 ], [ 87, 43 ], [ 66, 44 ], [ 84, 48 ], [ 75, 48 ], [ 78, 49 ], [ 86, 51 ], [ 72, 53 ], [ 66, 54 ], [ 74, 55 ], [ 72, 57 ], [ 78, 58 ], [ 87, 62 ], [ 69, 62 ], [ 75, 63 ], [ 84, 63 ], [ 77, 66 ], [ 83, 69 ], [ 71, 72 ], [ 74, 75 ], [ 77, 78 ], [ 80, 81 ], [ 83, 84 ], [ 86, 87 ] ]

[ "N = int(input())\n# 初回は単純に人数として加算\nT, A = map(int, input().split())\n\nfor _ in range(N - 1):\n t_i, a_i = map(int, input().split())\n\n # 比率を考えると総人数は T, A = n*t_i, n*a_i の形になる\n # 必ず現在のT, A以上となるnの値を考える\n n = max(-(-T // t_i), -(-A // a_i))\n\n # 更新\n T, A = n * t_i, n * a_i\n\nprint(T + A)", "N = int(input())", "N", "int(input())", "int", "input()", "input", "T, A = map(int, input().split())", "T", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "A", "for _ in range(N - 1):\n t_i, a_i = map(int, input().split())\n\n # 比率を考えると総人数は T, A = n*t_i, n*a_i の形になる\n # 必ず現在のT, A以上となるnの値を考える\n n = max(-(-T // t_i), -(-A // a_i))\n\n # 更新\n T, A = n * t_i, n * a_i", "_", "range(N - 1)", "range", "N - 1", "N", "1", "t_i, a_i = map(int, input().split())", "t_i", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "a_i", "n = max(-(-T // t_i), -(-A // a_i))", "n", "max(-(-T // t_i), -(-A // a_i))", "max", "-(-T // t_i)", "-T // t_i", "-T", "T", "t_i", "-(-A // a_i)", "-A // a_i", "-A", "A", "a_i", "T, A = n * t_i, n * a_i", "T", "n * t_i", "n", "t_i", "A", "n * a_i", "n", "a_i", "print(T + A)", "print", "T + A", "T", "A", "t_i, a_i = map(int, input().split())", "map(int, input().split())", "t_i", "T, A = map(int, input().split())", "map(int, input().split())", "T", "n = max(-(-T // t_i), -(-A // a_i))", "max(-(-T // t_i), -(-A // a_i))", "n", "A = n * t_i, n * a_i", "n * a_i", "A", "a_i = map(int, input().split())", "map(int, input().split())", "a_i", "N = int(input())", "int(input())", "N", "A = map(int, input().split())", "map(int, input().split())", "A", "T, A = n * t_i, n * a_i", "n * t_i", "T" ]

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

[ [ 101, 2 ], [ 86, 8 ], [ 102, 12 ], [ 89, 14 ], [ 102, 18 ], [ 21, 20 ], [ 102, 23 ], [ 92, 25 ], [ 87, 27 ], [ 104, 30 ], [ 90, 32 ], [ 36, 35 ], [ 102, 39 ], [ 95, 41 ], [ 93, 47 ], [ 108, 47 ], [ 87, 49 ], [ 35, 50 ], [ 87, 53 ], [ 35, 54 ], [ 105, 58 ], [ 99, 58 ], [ 90, 60 ], [ 35, 61 ], [ 90, 64 ], [ 35, 65 ], [ 107, 67 ], [ 87, 70 ], [ 35, 71 ], [ 96, 72 ], [ 98, 74 ], [ 90, 77 ], [ 35, 78 ], [ 96, 79 ], [ 108, 83 ], [ 93, 83 ], [ 99, 84 ], [ 105, 84 ], [ 86, 87 ], [ 89, 90 ], [ 92, 93 ], [ 95, 96 ], [ 98, 99 ], [ 101, 102 ], [ 104, 105 ], [ 107, 108 ] ]

[ "n = int(input())\nt = [0]*n\na = [0]*n\nfor i in range(n): t[i],a[i] = map(int,input().split())\ntcnt = t[0]\nacnt = a[0]\nfor i in range(1,n):\n x = max((tcnt+t[i]-1)//t[i],(acnt+a[i]-1)//a[i])\n tcnt = t[i]*x\n acnt = a[i]*x\nprint(tcnt+acnt)", "n = int(input())", "n", "int(input())", "int", "input()", "input", "t = [0]*n", "t", "[0]*n", "[0]", "0", "n", "a = [0]*n", "a", "[0]*n", "[0]", "0", "n", "for i in range(n): t[i],a[i] = map(int,input().split())", "i", "range(n)", "range", "n", "tcnt = t[0]", "tcnt", "t[0]", "t", "0", "acnt = a[0]", "acnt", "a[0]", "a", "0", "for i in range(1,n):\n x = max((tcnt+t[i]-1)//t[i],(acnt+a[i]-1)//a[i])\n tcnt = t[i]*x\n acnt = a[i]*x", "i", "range(1,n)", "range", "1", "n", "x = max((tcnt+t[i]-1)//t[i],(acnt+a[i]-1)//a[i])", "x", "max((tcnt+t[i]-1)//t[i],(acnt+a[i]-1)//a[i])", "max", "(tcnt+t[i]-1)//t[i]", "tcnt+t[i]-1", "tcnt+t[i]", "tcnt", "t[i]", "t", "i", "1", "t[i]", "t", "i", "(acnt+a[i]-1)//a[i]", "acnt+a[i]-1", "acnt+a[i]", "acnt", "a[i]", "a", "i", "1", "a[i]", "a", "i", "tcnt = t[i]*x", "tcnt", "t[i]*x", "t[i]", "t", "i", "x", "acnt = a[i]*x", "acnt", "a[i]*x", "a[i]", "a", "i", "x", "print(tcnt+acnt)", "print", "tcnt+acnt", "tcnt", "acnt", "t = [0]*n", "[0]*n", "t", "a = [0]*n", "[0]*n", "a", "tcnt = t[0]", "t[0]", "tcnt", "x = max((tcnt+t[i]-1)//t[i],(acnt+a[i]-1)//a[i])", "max((tcnt+t[i]-1)//t[i],(acnt+a[i]-1)//a[i])", "x", "acnt = a[i]*x", "a[i]*x", "acnt", "n = int(input())", "int(input())", "n", "acnt = a[0]", "a[0]", "acnt", "tcnt = t[i]*x", "t[i]*x", "tcnt" ]

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

[ [ 107, 2 ], [ 98, 8 ], [ 21, 20 ], [ 108, 24 ], [ 110, 27 ], [ 95, 39 ], [ 99, 44 ], [ 114, 44 ], [ 111, 48 ], [ 101, 52 ], [ 99, 57 ], [ 114, 57 ], [ 111, 61 ], [ 104, 65 ], [ 113, 72 ], [ 105, 80 ], [ 111, 82 ], [ 114, 89 ], [ 99, 89 ], [ 114, 92 ], [ 99, 92 ], [ 95, 96 ], [ 98, 99 ], [ 101, 102 ], [ 104, 105 ], [ 107, 108 ], [ 110, 111 ], [ 113, 114 ] ]

[ "n = int(input())\nary = list(map(int, input().split()))\nfor i in range(n - 1):\n tmp_ary = list(map(int, input().split()))\n # 桁が大きいとceil, floorでは正しく判定ができない\n t_rate = (ary[0] - 1) // tmp_ary[0] + 1\n a_rate = (ary[1] - 1) // tmp_ary[1] + 1\n rate = max([t_rate, a_rate])\n ary = list(map(lambda x: x * rate, tmp_ary))\nprint(int(ary[0] + ary[1]))", "n = int(input())", "n", "int(input())", "int", "input()", "input", "ary = list(map(int, input().split()))", "ary", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "for i in range(n - 1):\n tmp_ary = list(map(int, input().split()))\n # 桁が大きいとceil, floorでは正しく判定ができない\n t_rate = (ary[0] - 1) // tmp_ary[0] + 1\n a_rate = (ary[1] - 1) // tmp_ary[1] + 1\n rate = max([t_rate, a_rate])\n ary = list(map(lambda x: x * rate, tmp_ary))", "i", "range(n - 1)", "range", "n - 1", "n", "1", "tmp_ary = list(map(int, input().split()))", "tmp_ary", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "t_rate = (ary[0] - 1) // tmp_ary[0] + 1", "t_rate", "(ary[0] - 1) // tmp_ary[0] + 1", "(ary[0] - 1) // tmp_ary[0]", "ary[0] - 1", "ary[0]", "ary", "0", "1", "tmp_ary[0]", "tmp_ary", "0", "1", "a_rate = (ary[1] - 1) // tmp_ary[1] + 1", "a_rate", "(ary[1] - 1) // tmp_ary[1] + 1", "(ary[1] - 1) // tmp_ary[1]", "ary[1] - 1", "ary[1]", "ary", "1", "1", "tmp_ary[1]", "tmp_ary", "1", "1", "rate = max([t_rate, a_rate])", "rate", "max([t_rate, a_rate])", "max", "[t_rate, a_rate]", "t_rate", "a_rate", "ary = list(map(lambda x: x * rate, tmp_ary))", "ary", "list(map(lambda x: x * rate, tmp_ary))", "list", "map(lambda x: x * rate, tmp_ary)", "map", "lambda x: x * rate", "x * rate", "x", "rate", "x", "tmp_ary", "print(int(ary[0] + ary[1]))", "print", "int(ary[0] + ary[1])", "int", "ary[0] + ary[1]", "ary[0]", "ary", "0", "ary[1]", "ary", "1", "t_rate = (ary[0] - 1) // tmp_ary[0] + 1", "(ary[0] - 1) // tmp_ary[0] + 1", "t_rate", "ary = list(map(int, input().split()))", "list(map(int, input().split()))", "ary", "a_rate = (ary[1] - 1) // tmp_ary[1] + 1", "(ary[1] - 1) // tmp_ary[1] + 1", "a_rate", "rate = max([t_rate, a_rate])", "max([t_rate, a_rate])", "rate", "n = int(input())", "int(input())", "n", "tmp_ary = list(map(int, input().split()))", "list(map(int, input().split()))", "tmp_ary", "ary = list(map(lambda x: x * rate, tmp_ary))", "list(map(lambda x: x * rate, tmp_ary))", "ary" ]

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

[ [ 91, 2 ], [ 10, 9 ], [ 92, 12 ], [ 76, 25 ], [ 82, 28 ], [ 88, 30 ], [ 94, 37 ], [ 83, 42 ], [ 86, 42 ], [ 79, 46 ], [ 89, 51 ], [ 98, 51 ], [ 100, 55 ], [ 95, 58 ], [ 80, 59 ], [ 85, 61 ], [ 101, 64 ], [ 97, 66 ], [ 101, 69 ], [ 86, 73 ], [ 83, 73 ], [ 98, 74 ], [ 89, 74 ], [ 76, 77 ], [ 79, 80 ], [ 82, 83 ], [ 85, 86 ], [ 88, 89 ], [ 91, 92 ], [ 94, 95 ], [ 97, 98 ], [ 100, 101 ] ]

[ "n=int(input())\nta=[list(map(int,input().split())) for _ in range(n)]\ntv,av=1,1\n#print('-----')\nfor t,a in ta:\n i=(t+tv-1)//t\n j=(a+av-1)//a\n k=max(i,j)\n tv=t*k\n av=a*k\nprint(tv+av)", "n=int(input())", "n", "int(input())", "int", "input()", "input", "list(map(int,input().split())) for _ in range(n)", "for _ in range(n)", "_", "range(n)", "range", "n", "for _ in range(n)", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "ta=[list(map(int,input().split())) for _ in range(n)]", "ta", "[list(map(int,input().split())) for _ in range(n)]", "tv,av=1,1", "tv", "1", "av", "1", "for t,a in ta:\n i=(t+tv-1)//t\n j=(a+av-1)//a\n k=max(i,j)\n tv=t*k\n av=a*k", "t", "a", "ta", "i=(t+tv-1)//t", "i", "(t+tv-1)//t", "t+tv-1", "t+tv", "t", "tv", "1", "t", "j=(a+av-1)//a", "j", "(a+av-1)//a", "a+av-1", "a+av", "a", "av", "1", "a", "k=max(i,j)", "k", "max(i,j)", "max", "i", "j", "tv=t*k", "tv", "t*k", "t", "k", "av=a*k", "av", "a*k", "a", "k", "print(tv+av)", "print", "tv+av", "tv", "av", "ta=[list(map(int,input().split())) for _ in range(n)]", "[list(map(int,input().split())) for _ in range(n)]", "ta", "j=(a+av-1)//a", "(a+av-1)//a", "j", "tv,av=1,1", "1", "tv", "tv=t*k", "t*k", "tv", "av=1,1", "1", "av", "n=int(input())", "int(input())", "n", "i=(t+tv-1)//t", "(t+tv-1)//t", "i", "av=a*k", "a*k", "av", "k=max(i,j)", "max(i,j)", "k" ]

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

[ [ 179, 2 ], [ 167, 8 ], [ 180, 12 ], [ 176, 14 ], [ 180, 18 ], [ 173, 20 ], [ 180, 24 ], [ 170, 26 ], [ 30, 29 ], [ 180, 32 ], [ 37, 34 ], [ 168, 35 ], [ 29, 36 ], [ 37, 45 ], [ 177, 46 ], [ 29, 47 ], [ 50, 49 ], [ 180, 53 ], [ 182, 55 ], [ 174, 57 ], [ 49, 59 ], [ 34, 63 ], [ 168, 64 ], [ 49, 65 ], [ 168, 68 ], [ 49, 70 ], [ 183, 72 ], [ 171, 72 ], [ 168, 78 ], [ 49, 80 ], [ 183, 82 ], [ 171, 82 ], [ 34, 83 ], [ 168, 84 ], [ 49, 85 ], [ 91, 88 ], [ 174, 89 ], [ 49, 90 ], [ 168, 94 ], [ 49, 96 ], [ 183, 98 ], [ 171, 98 ], [ 34, 99 ], [ 168, 100 ], [ 49, 101 ], [ 45, 105 ], [ 177, 106 ], [ 49, 107 ], [ 88, 108 ], [ 133, 108 ], [ 174, 109 ], [ 49, 110 ], [ 177, 113 ], [ 49, 115 ], [ 183, 117 ], [ 171, 117 ], [ 177, 123 ], [ 49, 125 ], [ 183, 127 ], [ 171, 127 ], [ 45, 128 ], [ 177, 129 ], [ 49, 130 ], [ 136, 133 ], [ 174, 134 ], [ 49, 135 ], [ 177, 139 ], [ 49, 141 ], [ 183, 143 ], [ 171, 143 ], [ 45, 144 ], [ 177, 145 ], [ 49, 146 ], [ 174, 151 ], [ 180, 153 ], [ 168, 157 ], [ 180, 159 ], [ 177, 162 ], [ 180, 164 ], [ 167, 168 ], [ 170, 171 ], [ 173, 174 ], [ 176, 177 ], [ 179, 180 ], [ 182, 183 ] ]

[ "N = int(input())\nT =[0]*N\nA =[0]*N\nCnt=[1]*N\nCnt_pre =1\nfor i in range(N):\n\tT[i],A[i] = map(int,input().split())\n\nfor i in range(1,N):\n\tCnt_pre = Cnt[i-1]\n\tif T[i]<T[i-1]*Cnt_pre:\n\t\tif (T[i-1]*Cnt_pre)%T[i]==0:\n\t\t\tCnt[i] = (T[i-1]*Cnt_pre)//T[i]\n\t\telse:Cnt[i]= (T[i-1]*Cnt_pre)//T[i] + 1\n\tif A[i]*Cnt[i]<A[i-1]*Cnt_pre:\n\t\tif (A[i-1]*Cnt_pre)%A[i]==0:\n\t\t\tCnt[i]=(A[i-1]*Cnt_pre)//A[i]\n\t\telse:Cnt[i]=(A[i-1]*Cnt_pre)//A[i]+1\nprint(Cnt[N-1]*(T[N-1]+A[N-1])) ", "N = int(input())", "N", "int(input())", "int", "input()", "input", "T =[0]*N", "T", "[0]*N", "[0]", "0", "N", "A =[0]*N", "A", "[0]*N", "[0]", "0", "N", "Cnt=[1]*N", "Cnt", "[1]*N", "[1]", "1", "N", "Cnt_pre =1", "Cnt_pre", "1", "for i in range(N):\n\tT[i],A[i] = map(int,input().split())", "i", "range(N)", "range", "N", "T[i],A[i] = map(int,input().split())", "T[i]", "T", "i", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "A[i]", "A", "i", "for i in range(1,N):\n\tCnt_pre = Cnt[i-1]\n\tif T[i]<T[i-1]*Cnt_pre:\n\t\tif (T[i-1]*Cnt_pre)%T[i]==0:\n\t\t\tCnt[i] = (T[i-1]*Cnt_pre)//T[i]\n\t\telse:Cnt[i]= (T[i-1]*Cnt_pre)//T[i] + 1\n\tif A[i]*Cnt[i]<A[i-1]*Cnt_pre:\n\t\tif (A[i-1]*Cnt_pre)%A[i]==0:\n\t\t\tCnt[i]=(A[i-1]*Cnt_pre)//A[i]\n\t\telse:Cnt[i]=(A[i-1]*Cnt_pre)//A[i]+1", "i", "range(1,N)", "range", "1", "N", "Cnt_pre = Cnt[i-1]", "Cnt_pre", "Cnt[i-1]", "Cnt", "i-1", "i", "1", "if T[i]<T[i-1]*Cnt_pre:\n\t\tif (T[i-1]*Cnt_pre)%T[i]==0:\n\t\t\tCnt[i] = (T[i-1]*Cnt_pre)//T[i]\n\t\telse:Cnt[i]= (T[i-1]*Cnt_pre)//T[i] + 1\n\t", "T[i]<T[i-1]*Cnt_pre", "T[i]", "T", "i", "T[i-1]*Cnt_pre", "T[i-1]", "T", "i-1", "i", "1", "Cnt_pre", "if (T[i-1]*Cnt_pre)%T[i]==0:\n\t\t\tCnt[i] = (T[i-1]*Cnt_pre)//T[i]\n\t\telse:Cnt[i]= (T[i-1]*Cnt_pre)//T[i] + 1\n\t", "(T[i-1]*Cnt_pre)%T[i]==0", "(T[i-1]*Cnt_pre)%T[i]", "T[i-1]*Cnt_pre", "T[i-1]", "T", "i-1", "i", "1", "Cnt_pre", "T[i]", "T", "i", "0", "Cnt[i] = (T[i-1]*Cnt_pre)//T[i]", "Cnt[i]", "Cnt", "i", "(T[i-1]*Cnt_pre)//T[i]", "T[i-1]*Cnt_pre", "T[i-1]", "T", "i-1", "i", "1", "Cnt_pre", "T[i]", "T", "i", "if A[i]*Cnt[i]<A[i-1]*Cnt_pre:\n\t\tif (A[i-1]*Cnt_pre)%A[i]==0:\n\t\t\tCnt[i]=(A[i-1]*Cnt_pre)//A[i]\n\t\telse:Cnt[i]=(A[i-1]*Cnt_pre)//A[i]+1", "A[i]*Cnt[i]<A[i-1]*Cnt_pre", "A[i]*Cnt[i]", "A[i]", "A", "i", "Cnt[i]", "Cnt", "i", "A[i-1]*Cnt_pre", "A[i-1]", "A", "i-1", "i", "1", "Cnt_pre", "if (A[i-1]*Cnt_pre)%A[i]==0:\n\t\t\tCnt[i]=(A[i-1]*Cnt_pre)//A[i]\n\t\telse:Cnt[i]=(A[i-1]*Cnt_pre)//A[i]+1", "(A[i-1]*Cnt_pre)%A[i]==0", "(A[i-1]*Cnt_pre)%A[i]", "A[i-1]*Cnt_pre", "A[i-1]", "A", "i-1", "i", "1", "Cnt_pre", "A[i]", "A", "i", "0", "Cnt[i]=(A[i-1]*Cnt_pre)//A[i]", "Cnt[i]", "Cnt", "i", "(A[i-1]*Cnt_pre)//A[i]", "A[i-1]*Cnt_pre", "A[i-1]", "A", "i-1", "i", "1", "Cnt_pre", "A[i]", "A", "i", "print(Cnt[N-1]*(T[N-1]+A[N-1]))", "print", "Cnt[N-1]*(T[N-1]+A[N-1])", "Cnt[N-1]", "Cnt", "N-1", "N", "1", "T[N-1]+A[N-1]", "T[N-1]", "T", "N-1", "N", "1", "A[N-1]", "A", "N-1", "N", "1", "T =[0]*N", "[0]*N", "T", "Cnt_pre =1", "1", "Cnt_pre", "Cnt=[1]*N", "[1]*N", "Cnt", "A =[0]*N", "[0]*N", "A", "N = int(input())", "int(input())", "N", "Cnt_pre = Cnt[i-1]", "Cnt[i-1]", "Cnt_pre" ]

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

[ [ 117, 4 ], [ 96, 13 ], [ 118, 17 ], [ 21, 20 ], [ 97, 23 ], [ 118, 33 ], [ 108, 36 ], [ 114, 39 ], [ 111, 41 ], [ 45, 44 ], [ 97, 47 ], [ 102, 49 ], [ 115, 57 ], [ 106, 57 ], [ 109, 60 ], [ 44, 61 ], [ 112, 66 ], [ 100, 66 ], [ 109, 69 ], [ 44, 70 ], [ 105, 73 ], [ 103, 75 ], [ 109, 78 ], [ 44, 79 ], [ 99, 82 ], [ 103, 84 ], [ 109, 87 ], [ 44, 88 ], [ 106, 93 ], [ 115, 93 ], [ 100, 94 ], [ 112, 94 ], [ 96, 97 ], [ 99, 100 ], [ 102, 103 ], [ 105, 106 ], [ 108, 109 ], [ 111, 112 ], [ 114, 115 ], [ 117, 118 ] ]

[ "# python3 (3.4.3)\nimport sys\ninput = sys.stdin.readline\n\n# main\nfrom math import ceil\nfrom decimal import *\nN = int(input())\nTA = [list(map(int,input().split())) for _ in range(N)]\n\n\nt,a = 1,1\nfor i in range(N):\n n = Decimal(max(ceil(t/TA[i][0]), ceil(a/TA[i][1])))\n t = n*TA[i][0]\n a = n*TA[i][1]\n\nprint(t+a)", "import sys", "sys", "input = sys.stdin.readline", "input", "sys.stdin.readline", "sys.stdin", "sys", "stdin", "readline", "from math import ceil", "from decimal import *", "N = int(input())", "N", "int(input())", "int", "input()", "input", "list(map(int,input().split())) for _ in range(N)", "for _ in range(N)", "_", "range(N)", "range", "N", "for _ in range(N)", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "TA = [list(map(int,input().split())) for _ in range(N)]", "TA", "[list(map(int,input().split())) for _ in range(N)]", "t,a = 1,1", "t", "1", "a", "1", "for i in range(N):\n n = Decimal(max(ceil(t/TA[i][0]), ceil(a/TA[i][1])))\n t = n*TA[i][0]\n a = n*TA[i][1]", "i", "range(N)", "range", "N", "n = Decimal(max(ceil(t/TA[i][0]), ceil(a/TA[i][1])))", "n", "Decimal(max(ceil(t/TA[i][0]), ceil(a/TA[i][1])))", "Decimal", "max(ceil(t/TA[i][0]), ceil(a/TA[i][1]))", "max", "ceil(t/TA[i][0])", "ceil", "t/TA[i][0]", "t", "TA[i][0]", "[i]", "TA", "i", "0", "ceil(a/TA[i][1])", "ceil", "a/TA[i][1]", "a", "TA[i][1]", "[i]", "TA", "i", "1", "t = n*TA[i][0]", "t", "n*TA[i][0]", "n", "TA[i][0]", "[i]", "TA", "i", "0", "a = n*TA[i][1]", "a", "n*TA[i][1]", "n", "TA[i][1]", "[i]", "TA", "i", "1", "print(t+a)", "print", "t+a", "t", "a", "N = int(input())", "int(input())", "N", "a = n*TA[i][1]", "n*TA[i][1]", "a", "n = Decimal(max(ceil(t/TA[i][0]), ceil(a/TA[i][1])))", "Decimal(max(ceil(t/TA[i][0]), ceil(a/TA[i][1])))", "n", "t = n*TA[i][0]", "n*TA[i][0]", "t", "TA = [list(map(int,input().split())) for _ in range(N)]", "[list(map(int,input().split())) for _ in range(N)]", "TA", "a = 1,1", "1", "a", "t,a = 1,1", "1", "t", "input = sys.stdin.readline", "sys.stdin.readline", "input" ]

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

[ [ 68, 2 ], [ 71, 8 ], [ 74, 10 ], [ 14, 13 ], [ 69, 16 ], [ 77, 18 ], [ 77, 27 ], [ 80, 29 ], [ 72, 35 ], [ 66, 35 ], [ 78, 37 ], [ 75, 42 ], [ 84, 42 ], [ 63, 44 ], [ 65, 47 ], [ 81, 49 ], [ 78, 50 ], [ 83, 52 ], [ 81, 54 ], [ 63, 55 ], [ 66, 59 ], [ 72, 59 ], [ 84, 60 ], [ 75, 60 ], [ 77, 63 ], [ 65, 66 ], [ 68, 69 ], [ 71, 72 ], [ 74, 75 ], [ 77, 78 ], [ 80, 81 ], [ 83, 84 ] ]

[ "N = int(input())\n\ntakahashi,aoki = 1,1\n\nfor _ in range(N):\n a,b = map(int,input().split())\n c = max((takahashi-1)//a+1,(aoki-1)//b+1)\n takahashi = c*a\n aoki = c*b\n\nprint(takahashi+aoki)", "N = int(input())", "N", "int(input())", "int", "input()", "input", "takahashi,aoki = 1,1", "takahashi", "1", "aoki", "1", "for _ in range(N):\n a,b = map(int,input().split())\n c = max((takahashi-1)//a+1,(aoki-1)//b+1)\n takahashi = c*a\n aoki = c*b", "_", "range(N)", "range", "N", "a,b = map(int,input().split())", "a", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "c = max((takahashi-1)//a+1,(aoki-1)//b+1)", "c", "max((takahashi-1)//a+1,(aoki-1)//b+1)", "max", "(takahashi-1)//a+1", "(takahashi-1)//a", "takahashi-1", "takahashi", "1", "a", "1", "(aoki-1)//b+1", "(aoki-1)//b", "aoki-1", "aoki", "1", "b", "1", "takahashi = c*a", "takahashi", "c*a", "c", "a", "aoki = c*b", "aoki", "c*b", "c", "b", "print(takahashi+aoki)", "print", "takahashi+aoki", "takahashi", "aoki", "b = map(int,input().split())", "map(int,input().split())", "b", "takahashi = c*a", "c*a", "takahashi", "N = int(input())", "int(input())", "N", "takahashi,aoki = 1,1", "1", "takahashi", "aoki = 1,1", "1", "aoki", "a,b = map(int,input().split())", "map(int,input().split())", "a", "c = max((takahashi-1)//a+1,(aoki-1)//b+1)", "max((takahashi-1)//a+1,(aoki-1)//b+1)", "c", "aoki = c*b", "c*b", "aoki" ]

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

[ [ 207, 2 ], [ 264, 8 ], [ 264, 17 ], [ 20, 19 ], [ 208, 23 ], [ 249, 26 ], [ 249, 35 ], [ 204, 37 ], [ 193, 41 ], [ 253, 41 ], [ 241, 41 ], [ 250, 42 ], [ 193, 46 ], [ 253, 46 ], [ 241, 46 ], [ 250, 47 ], [ 222, 50 ], [ 193, 52 ], [ 253, 52 ], [ 241, 52 ], [ 250, 53 ], [ 246, 55 ], [ 193, 58 ], [ 253, 58 ], [ 241, 58 ], [ 250, 59 ], [ 273, 62 ], [ 250, 64 ], [ 247, 65 ], [ 223, 65 ], [ 205, 65 ], [ 232, 65 ], [ 259, 65 ], [ 244, 65 ], [ 210, 67 ], [ 238, 69 ], [ 247, 70 ], [ 223, 70 ], [ 205, 70 ], [ 232, 70 ], [ 259, 70 ], [ 244, 70 ], [ 213, 72 ], [ 265, 76 ], [ 220, 76 ], [ 262, 76 ], [ 211, 77 ], [ 271, 77 ], [ 265, 81 ], [ 220, 81 ], [ 262, 81 ], [ 211, 82 ], [ 271, 82 ], [ 255, 85 ], [ 265, 87 ], [ 220, 87 ], [ 262, 87 ], [ 211, 88 ], [ 271, 88 ], [ 228, 90 ], [ 265, 93 ], [ 220, 93 ], [ 262, 93 ], [ 211, 94 ], [ 271, 94 ], [ 195, 97 ], [ 274, 99 ], [ 196, 99 ], [ 229, 100 ], [ 256, 100 ], [ 214, 100 ], [ 202, 100 ], [ 268, 100 ], [ 199, 100 ], [ 270, 102 ], [ 211, 104 ], [ 271, 104 ], [ 229, 105 ], [ 256, 105 ], [ 214, 105 ], [ 202, 105 ], [ 268, 105 ], [ 199, 105 ], [ 198, 107 ], [ 265, 111 ], [ 220, 111 ], [ 262, 111 ], [ 238, 112 ], [ 265, 116 ], [ 220, 116 ], [ 262, 116 ], [ 238, 117 ], [ 267, 120 ], [ 265, 122 ], [ 220, 122 ], [ 262, 122 ], [ 238, 123 ], [ 201, 125 ], [ 265, 128 ], [ 220, 128 ], [ 262, 128 ], [ 238, 129 ], [ 276, 132 ], [ 250, 134 ], [ 202, 135 ], [ 268, 135 ], [ 199, 135 ], [ 229, 135 ], [ 256, 135 ], [ 214, 135 ], [ 234, 137 ], [ 238, 139 ], [ 202, 140 ], [ 268, 140 ], [ 199, 140 ], [ 229, 140 ], [ 256, 140 ], [ 214, 140 ], [ 243, 142 ], [ 193, 146 ], [ 253, 146 ], [ 241, 146 ], [ 277, 147 ], [ 226, 147 ], [ 193, 151 ], [ 253, 151 ], [ 241, 151 ], [ 277, 152 ], [ 226, 152 ], [ 258, 155 ], [ 193, 157 ], [ 253, 157 ], [ 241, 157 ], [ 277, 158 ], [ 226, 158 ], [ 231, 160 ], [ 193, 163 ], [ 253, 163 ], [ 241, 163 ], [ 277, 164 ], [ 226, 164 ], [ 225, 167 ], [ 232, 168 ], [ 259, 168 ], [ 244, 168 ], [ 247, 168 ], [ 223, 168 ], [ 205, 168 ], [ 216, 170 ], [ 232, 171 ], [ 259, 171 ], [ 244, 171 ], [ 247, 171 ], [ 223, 171 ], [ 205, 171 ], [ 196, 174 ], [ 274, 174 ], [ 226, 175 ], [ 277, 175 ], [ 240, 177 ], [ 196, 178 ], [ 274, 178 ], [ 261, 179 ], [ 271, 180 ], [ 211, 180 ], [ 252, 182 ], [ 226, 183 ], [ 277, 183 ], [ 219, 184 ], [ 217, 185 ], [ 235, 185 ], [ 253, 189 ], [ 241, 189 ], [ 193, 189 ], [ 220, 190 ], [ 262, 190 ], [ 265, 190 ], [ 264, 193 ], [ 195, 196 ], [ 198, 199 ], [ 201, 202 ], [ 204, 205 ], [ 207, 208 ], [ 210, 211 ], [ 213, 214 ], [ 232, 216 ], [ 259, 216 ], [ 244, 216 ], [ 247, 216 ], [ 223, 216 ], [ 205, 216 ], [ 216, 217 ], [ 217, 219 ], [ 235, 219 ], [ 219, 220 ], [ 222, 223 ], [ 232, 225 ], [ 259, 225 ], [ 244, 225 ], [ 247, 225 ], [ 223, 225 ], [ 205, 225 ], [ 225, 226 ], [ 228, 229 ], [ 231, 232 ], [ 234, 235 ], [ 249, 238 ], [ 196, 240 ], [ 274, 240 ], [ 240, 241 ], [ 243, 244 ], [ 246, 247 ], [ 249, 250 ], [ 226, 252 ], [ 277, 252 ], [ 252, 253 ], [ 255, 256 ], [ 258, 259 ], [ 271, 261 ], [ 211, 261 ], [ 261, 262 ], [ 264, 265 ], [ 267, 268 ], [ 270, 271 ], [ 273, 274 ], [ 276, 277 ] ]

[ "N = int(input())\nt,a = map(int,input().split())\nfor _ in range(N-1):\n T,A = map(int,input().split())\n b = 1\n if t>T:\n if t%T==0:\n b = t//T\n else:\n b = t//T+1\n T0 = T*b\n A0 = A*b\n c = 1\n if a>A0:\n if a%A0==0:\n c = a//A0\n else:\n c = a//A0+1\n T0 = T0*c\n A0 = A0*c\n c = 1\n if a>A:\n if a%A==0:\n c = a//A\n else:\n c = a//A+1\n T1 = T*c\n A1 = A*c\n b = 1\n if t>T1:\n if t%T1==0:\n b = t//T1\n else:\n b = t//T1+1\n T1 *= b\n A1 *= b\n if T0<=T1:\n t,a = T0,A0\n else:\n t,a = T1,A1\nprint(t+a)", "N = int(input())", "N", "int(input())", "int", "input()", "input", "t,a = map(int,input().split())", "t", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "a", "for _ in range(N-1):\n T,A = map(int,input().split())\n b = 1\n if t>T:\n if t%T==0:\n b = t//T\n else:\n b = t//T+1\n T0 = T*b\n A0 = A*b\n c = 1\n if a>A0:\n if a%A0==0:\n c = a//A0\n else:\n c = a//A0+1\n T0 = T0*c\n A0 = A0*c\n c = 1\n if a>A:\n if a%A==0:\n c = a//A\n else:\n c = a//A+1\n T1 = T*c\n A1 = A*c\n b = 1\n if t>T1:\n if t%T1==0:\n b = t//T1\n else:\n b = t//T1+1\n T1 *= b\n A1 *= b\n if T0<=T1:\n t,a = T0,A0\n else:\n t,a = T1,A1", "_", "range(N-1)", "range", "N-1", "N", "1", "T,A = map(int,input().split())", "T", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "A", "b = 1", "b", "1", "if t>T:\n if t%T==0:\n b = t//T\n else:\n b = t//T+1\n ", "t>T", "t", "T", "if t%T==0:\n b = t//T\n else:\n b = t//T+1\n ", "t%T==0", "t%T", "t", "T", "0", "b = t//T", "b", "t//T", "t", "T", "b = t//T+1", "b", "t//T+1", "t//T", "t", "T", "1", "T0 = T*b", "T0", "T*b", "T", "b", "A0 = A*b", "A0", "A*b", "A", "b", "c = 1", "c", "1", "if a>A0:\n if a%A0==0:\n c = a//A0\n else:\n c = a//A0+1\n ", "a>A0", "a", "A0", "if a%A0==0:\n c = a//A0\n else:\n c = a//A0+1\n ", "a%A0==0", "a%A0", "a", "A0", "0", "c = a//A0", "c", "a//A0", "a", "A0", "c = a//A0+1", "c", "a//A0+1", "a//A0", "a", "A0", "1", "T0 = T0*c", "T0", "T0*c", "T0", "c", "A0 = A0*c", "A0", "A0*c", "A0", "c", "c = 1", "c", "1", "if a>A:\n if a%A==0:\n c = a//A\n else:\n c = a//A+1\n ", "a>A", "a", "A", "if a%A==0:\n c = a//A\n else:\n c = a//A+1\n ", "a%A==0", "a%A", "a", "A", "0", "c = a//A", "c", "a//A", "a", "A", "c = a//A+1", "c", "a//A+1", "a//A", "a", "A", "1", "T1 = T*c", "T1", "T*c", "T", "c", "A1 = A*c", "A1", "A*c", "A", "c", "b = 1", "b", "1", "if t>T1:\n if t%T1==0:\n b = t//T1\n else:\n b = t//T1+1\n ", "t>T1", "t", "T1", "if t%T1==0:\n b = t//T1\n else:\n b = t//T1+1\n ", "t%T1==0", "t%T1", "t", "T1", "0", "b = t//T1", "b", "t//T1", "t", "T1", "b = t//T1+1", "b", "t//T1+1", "t//T1", "t", "T1", "1", "T1 *= b", "T1", "b", "A1 *= b", "A1", "b", "if T0<=T1:\n t,a = T0,A0\n else:\n t,a = T1,A1", "T0<=T1", "T0", "T1", "t,a = T0,A0", "t", "T0", "a", "A0", "t,a = T1,A1", "t", "T1", "a", "A1", "print(t+a)", "print", "t+a", "t", "a", "t,a = map(int,input().split())", "map(int,input().split())", "t", "T0 = T0*c", "T0*c", "T0", "c = 1", "1", "c", "c = a//A+1", "a//A+1", "c", "b = 1", "1", "b", "N = int(input())", "int(input())", "N", "A0 = A*b", "A*b", "A0", "c = 1", "1", "c", "A1 *= b", "b", "A1", "a = T1,A1", "A1", "a", "b = t//T", "t//T", "b", "T1 *= b", "b", "T1", "c = a//A0+1", "a//A0+1", "c", "b = t//T1+1", "t//T1+1", "b", "A1 = A*c", "A*c", "A1", "A = map(int,input().split())", "map(int,input().split())", "A", "t,a = T0,A0", "T0", "t", "b = 1", "1", "b", "b = t//T+1", "t//T+1", "b", "T,A = map(int,input().split())", "map(int,input().split())", "T", "t,a = T1,A1", "T1", "t", "c = a//A0", "a//A0", "c", "b = t//T1", "t//T1", "b", "a = T0,A0", "A0", "a", "a = map(int,input().split())", "map(int,input().split())", "a", "c = a//A", "a//A", "c", "A0 = A0*c", "A0*c", "A0", "T0 = T*b", "T*b", "T0", "T1 = T*c", "T*c", "T1" ]

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

[ [ 76, 2 ], [ 82, 8 ], [ 67, 11 ], [ 15, 14 ], [ 77, 17 ], [ 85, 19 ], [ 85, 28 ], [ 70, 30 ], [ 80, 32 ], [ 83, 38 ], [ 71, 38 ], [ 80, 39 ], [ 68, 43 ], [ 74, 43 ], [ 86, 44 ], [ 73, 46 ], [ 86, 48 ], [ 71, 54 ], [ 83, 54 ], [ 80, 55 ], [ 68, 59 ], [ 74, 59 ], [ 86, 60 ], [ 71, 64 ], [ 83, 64 ], [ 74, 65 ], [ 68, 65 ], [ 67, 68 ], [ 70, 71 ], [ 73, 74 ], [ 76, 77 ], [ 85, 80 ], [ 82, 83 ], [ 85, 86 ] ]

[ "n = int(input())\ntpred = 1\napred = 1\n\nfor i in range(n):\n t, a = map(int, input().split())\n tpred = t*max(-(-tpred//t), -(-apred//a))\n apred = a*max(-(-tpred//t), -(-apred//a))\n\nprint(tpred+apred)", "n = int(input())", "n", "int(input())", "int", "input()", "input", "tpred = 1", "tpred", "1", "apred = 1", "apred", "1", "for i in range(n):\n t, a = map(int, input().split())\n tpred = t*max(-(-tpred//t), -(-apred//a))\n apred = a*max(-(-tpred//t), -(-apred//a))", "i", "range(n)", "range", "n", "t, a = map(int, input().split())", "t", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "a", "tpred = t*max(-(-tpred//t), -(-apred//a))", "tpred", "t*max(-(-tpred//t), -(-apred//a))", "t", "max(-(-tpred//t), -(-apred//a))", "max", "-(-tpred//t)", "-tpred//t", "-tpred", "tpred", "t", "-(-apred//a)", "-apred//a", "-apred", "apred", "a", "apred = a*max(-(-tpred//t), -(-apred//a))", "apred", "a*max(-(-tpred//t), -(-apred//a))", "a", "max(-(-tpred//t), -(-apred//a))", "max", "-(-tpred//t)", "-tpred//t", "-tpred", "tpred", "t", "-(-apred//a)", "-apred//a", "-apred", "apred", "a", "print(tpred+apred)", "print", "tpred+apred", "tpred", "apred", "apred = 1", "1", "apred", "tpred = t*max(-(-tpred//t), -(-apred//a))", "t*max(-(-tpred//t), -(-apred//a))", "tpred", "apred = a*max(-(-tpred//t), -(-apred//a))", "a*max(-(-tpred//t), -(-apred//a))", "apred", "n = int(input())", "int(input())", "n", "t, a = map(int, input().split())", "map(int, input().split())", "t", "tpred = 1", "1", "tpred", "a = map(int, input().split())", "map(int, input().split())", "a" ]

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

[ [ 95, 6 ], [ 101, 19 ], [ 37, 36 ], [ 96, 41 ], [ 47, 46 ], [ 96, 50 ], [ 58, 53 ], [ 102, 54 ], [ 46, 56 ], [ 102, 64 ], [ 46, 65 ], [ 102, 67 ], [ 46, 69 ], [ 102, 73 ], [ 46, 75 ], [ 102, 83 ], [ 96, 85 ], [ 99, 93 ], [ 95, 96 ], [ 101, 102 ] ]

[ "import sys\nimport numpy as np\n\nn = int(sys.stdin.readline().rstrip())\nres = np.array(sys.stdin.read().split(), dtype=np.int64).reshape(n, 2)\n\ndef main():\n for i in range(n - 1):\n res[i+1] *= ((res[i] + res[i+1] - 1) // res[i+1]).max()\n print(res[n-1].sum())\n \nif __name__ == '__main__':\n main()", "import sys", "sys", "import numpy as np", "numpy", "n = int(sys.stdin.readline().rstrip())", "n", "int(sys.stdin.readline().rstrip())", "int", "sys.stdin.readline().rstrip()", "sys.stdin.readline().rstrip", "sys.stdin.readline()", "sys.stdin.readline", "sys.stdin", "sys", "stdin", "readline", "rstrip", "res = np.array(sys.stdin.read().split(), dtype=np.int64).reshape(n, 2)", "res", "np.array(sys.stdin.read().split(), dtype=np.int64).reshape(n, 2)", "np.array(sys.stdin.read().split(), dtype=np.int64).reshape", "np.array(sys.stdin.read().split(), dtype=np.int64)", "np.array", "np", "array", "sys.stdin.read().split()", "sys.stdin.read().split", "sys.stdin.read()", "sys.stdin.read", "sys.stdin", "sys", "stdin", "read", "split", "dtype=np.int64", "dtype", "np.int64", "np", "int64", "reshape", "n", "2", "def main():\n for i in range(n - 1):\n res[i+1] *= ((res[i] + res[i+1] - 1) // res[i+1]).max()\n print(res[n-1].sum())\n ", "main", "for i in range(n - 1):\n res[i+1] *= ((res[i] + res[i+1] - 1) // res[i+1]).max()\n ", "i", "range(n - 1)", "range", "n - 1", "n", "1", "res[i+1] *= ((res[i] + res[i+1] - 1) // res[i+1]).max()", "res[i+1]", "res", "i+1", "i", "1", "((res[i] + res[i+1] - 1) // res[i+1]).max()", "(res[i] + res[i+1] - 1) // res[i+1]).max", "(res[i] + res[i+1] - 1) // res[i+1]", "res[i] + res[i+1] - 1", "res[i] + res[i+1]", "res[i]", "res", "i", "res[i+1]", "res", "i+1", "i", "1", "1", "res[i+1]", "res", "i+1", "i", "1", "max", "print(res[n-1].sum())", "print", "res[n-1].sum()", "[n-1].sum", "[n-1]", "res", "n-1", "n", "1", "sum", "if __name__ == '__main__':\n main()", "__name__ == '__main__'", "__name__", "'__main__'", "main()", "main", "n = int(sys.stdin.readline().rstrip())", "int(sys.stdin.readline().rstrip())", "n", "def main():\n for i in range(n - 1):\n res[i+1] *= ((res[i] + res[i+1] - 1) // res[i+1]).max()\n print(res[n-1].sum())\n ", "def main():\n for i in range(n - 1):\n res[i+1] *= ((res[i] + res[i+1] - 1) // res[i+1]).max()\n print(res[n-1].sum())\n ", "main", "res = np.array(sys.stdin.read().split(), dtype=np.int64).reshape(n, 2)", "np.array(sys.stdin.read().split(), dtype=np.int64).reshape(n, 2)", "res" ]

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

[ [ 159, 4 ], [ 213, 10 ], [ 213, 19 ], [ 180, 21 ], [ 214, 22 ], [ 171, 24 ], [ 211, 25 ], [ 28, 27 ], [ 160, 31 ], [ 192, 33 ], [ 192, 42 ], [ 181, 46 ], [ 169, 46 ], [ 184, 46 ], [ 190, 46 ], [ 205, 46 ], [ 202, 46 ], [ 193, 47 ], [ 214, 47 ], [ 172, 49 ], [ 217, 49 ], [ 166, 49 ], [ 163, 49 ], [ 199, 49 ], [ 220, 49 ], [ 175, 50 ], [ 211, 50 ], [ 201, 52 ], [ 193, 53 ], [ 214, 53 ], [ 219, 55 ], [ 175, 56 ], [ 211, 56 ], [ 181, 60 ], [ 169, 60 ], [ 184, 60 ], [ 190, 60 ], [ 205, 60 ], [ 202, 60 ], [ 193, 61 ], [ 214, 61 ], [ 172, 63 ], [ 217, 63 ], [ 166, 63 ], [ 163, 63 ], [ 199, 63 ], [ 220, 63 ], [ 175, 64 ], [ 211, 64 ], [ 177, 66 ], [ 181, 70 ], [ 169, 70 ], [ 184, 70 ], [ 190, 70 ], [ 205, 70 ], [ 202, 70 ], [ 193, 71 ], [ 214, 71 ], [ 204, 73 ], [ 178, 75 ], [ 208, 75 ], [ 193, 76 ], [ 214, 76 ], [ 198, 77 ], [ 178, 79 ], [ 208, 79 ], [ 175, 80 ], [ 211, 80 ], [ 181, 84 ], [ 169, 84 ], [ 184, 84 ], [ 190, 84 ], [ 205, 84 ], [ 202, 84 ], [ 193, 85 ], [ 214, 85 ], [ 172, 87 ], [ 217, 87 ], [ 166, 87 ], [ 163, 87 ], [ 199, 87 ], [ 220, 87 ], [ 175, 88 ], [ 211, 88 ], [ 207, 90 ], [ 172, 94 ], [ 217, 94 ], [ 166, 94 ], [ 163, 94 ], [ 199, 94 ], [ 220, 94 ], [ 175, 95 ], [ 211, 95 ], [ 189, 97 ], [ 208, 99 ], [ 178, 99 ], [ 193, 100 ], [ 214, 100 ], [ 162, 101 ], [ 208, 103 ], [ 178, 103 ], [ 175, 104 ], [ 211, 104 ], [ 195, 106 ], [ 181, 110 ], [ 169, 110 ], [ 184, 110 ], [ 190, 110 ], [ 205, 110 ], [ 202, 110 ], [ 193, 111 ], [ 214, 111 ], [ 186, 113 ], [ 172, 117 ], [ 217, 117 ], [ 166, 117 ], [ 163, 117 ], [ 199, 117 ], [ 220, 117 ], [ 175, 118 ], [ 211, 118 ], [ 196, 123 ], [ 193, 124 ], [ 214, 124 ], [ 196, 126 ], [ 175, 127 ], [ 211, 127 ], [ 187, 130 ], [ 193, 131 ], [ 214, 131 ], [ 187, 133 ], [ 175, 134 ], [ 211, 134 ], [ 183, 136 ], [ 196, 138 ], [ 193, 139 ], [ 214, 139 ], [ 165, 140 ], [ 196, 142 ], [ 175, 143 ], [ 211, 143 ], [ 168, 145 ], [ 187, 147 ], [ 193, 148 ], [ 214, 148 ], [ 216, 149 ], [ 187, 151 ], [ 175, 152 ], [ 211, 152 ], [ 217, 156 ], [ 166, 156 ], [ 163, 156 ], [ 199, 156 ], [ 220, 156 ], [ 172, 156 ], [ 169, 157 ], [ 184, 157 ], [ 190, 157 ], [ 205, 157 ], [ 202, 157 ], [ 181, 157 ], [ 159, 160 ], [ 162, 163 ], [ 165, 166 ], [ 168, 169 ], [ 211, 171 ], [ 171, 172 ], [ 192, 175 ], [ 177, 178 ], [ 214, 180 ], [ 180, 181 ], [ 183, 184 ], [ 186, 187 ], [ 189, 190 ], [ 192, 193 ], [ 195, 196 ], [ 198, 199 ], [ 193, 201 ], [ 214, 201 ], [ 201, 202 ], [ 204, 205 ], [ 207, 208 ], [ 213, 211 ], [ 213, 214 ], [ 216, 217 ], [ 175, 219 ], [ 211, 219 ], [ 219, 220 ] ]

[ "import math\n\nn=int(input())\nt,a=map(int,input().split())\nvt=t\nva=a\nfor i in range(1,n):\n t, a = map(int, input().split())\n if vt<=t and va<=a:\n vt=t\n va=a\n elif vt>t and va<=a:\n x=-(-vt//t)\n vt,va=x*t,x*a\n elif vt<=t and va>a:\n x=-(-va//a)\n vt,va=x*t,x*a\n else:\n x1 = -(-vt // t)\n x2 = -(-va // a)\n if x1*t+x1*a >=x2*t+x2*a:\n vt, va = x1 * t, x1 * a\n else:\n vt, va = x2 * t, x2 * a\n\nprint(va+vt)", "import math", "math", "n=int(input())", "n", "int(input())", "int", "input()", "input", "t,a=map(int,input().split())", "t", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "a", "vt=t", "vt", "t", "va=a", "va", "a", "for i in range(1,n):\n t, a = map(int, input().split())\n if vt<=t and va<=a:\n vt=t\n va=a\n elif vt>t and va<=a:\n x=-(-vt//t)\n vt,va=x*t,x*a\n elif vt<=t and va>a:\n x=-(-va//a)\n vt,va=x*t,x*a\n else:\n x1 = -(-vt // t)\n x2 = -(-va // a)\n if x1*t+x1*a >=x2*t+x2*a:\n vt, va = x1 * t, x1 * a\n else:\n vt, va = x2 * t, x2 * a", "i", "range(1,n)", "range", "1", "n", "t, a = map(int, input().split())", "t", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "a", "if vt<=t and va<=a:\n vt=t\n va=a\n elif vt>t and va<=a:\n x=-(-vt//t)\n vt,va=x*t,x*a\n elif vt<=t and va>a:\n x=-(-va//a)\n vt,va=x*t,x*a\n else:\n x1 = -(-vt // t)\n x2 = -(-va // a)\n if x1*t+x1*a >=x2*t+x2*a:\n vt, va = x1 * t, x1 * a\n else:\n vt, va = x2 * t, x2 * a", "vt<=t and va<=a", "vt<=t", "vt", "t", "va<=a", "va", "a", "vt=t", "vt", "t", "va=a", "va", "a", "elif vt>t and va<=a:\n x=-(-vt//t)\n vt,va=x*t,x*a\n ", "vt>t and va<=a", "vt>t", "vt", "t", "va<=a", "va", "a", "x=-(-vt//t)", "x", "-(-vt//t)", "-vt//t", "-vt", "vt", "t", "vt,va=x*t,x*a", "vt", "x*t", "x", "t", "va", "x*a", "x", "a", "elif vt<=t and va>a:\n x=-(-va//a)\n vt,va=x*t,x*a\n ", "vt<=t and va>a", "vt<=t", "vt", "t", "va>a", "va", "a", "x=-(-va//a)", "x", "-(-va//a)", "-va//a", "-va", "va", "a", "vt,va=x*t,x*a", "vt", "x*t", "x", "t", "va", "x*a", "x", "a", "x1 = -(-vt // t)", "x1", "-(-vt // t)", "-vt // t", "-vt", "vt", "t", "x2 = -(-va // a)", "x2", "-(-va // a)", "-va // a", "-va", "va", "a", "if x1*t+x1*a >=x2*t+x2*a:\n vt, va = x1 * t, x1 * a\n else:\n vt, va = x2 * t, x2 * a", "x1*t+x1*a >=x2*t+x2*a", "x1*t+x1*a", "x1*t", "x1", "t", "x1*a", "x1", "a", "x2*t+x2*a", "x2*t", "x2", "t", "x2*a", "x2", "a", "vt, va = x1 * t, x1 * a", "vt", "x1 * t", "x1", "t", "va", "x1 * a", "x1", "a", "vt, va = x2 * t, x2 * a", "vt", "x2 * t", "x2", "t", "va", "x2 * a", "x2", "a", "print(va+vt)", "print", "va+vt", "va", "vt", "n=int(input())", "int(input())", "n", "va=x*t,x*a", "x*a", "va", "va = x1 * t, x1 * a", "x1 * a", "va", "vt, va = x2 * t, x2 * a", "x2 * t", "vt", "va=a", "a", "va", "a = map(int, input().split())", "map(int, input().split())", "a", "x=-(-vt//t)", "-(-vt//t)", "x", "vt=t", "t", "vt", "vt, va = x1 * t, x1 * a", "x1 * t", "vt", "x2 = -(-va // a)", "-(-va // a)", "x2", "vt,va=x*t,x*a", "x*t", "vt", "t, a = map(int, input().split())", "map(int, input().split())", "t", "x1 = -(-vt // t)", "-(-vt // t)", "x1", "va=x*t,x*a", "x*a", "va", "vt=t", "t", "vt", "vt,va=x*t,x*a", "x*t", "vt", "x=-(-va//a)", "-(-va//a)", "x", "a=map(int,input().split())", "map(int,input().split())", "a", "t,a=map(int,input().split())", "map(int,input().split())", "t", "va = x2 * t, x2 * a", "x2 * a", "va", "va=a", "a", "va" ]

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

[ [ 79, 2 ], [ 73, 8 ], [ 94, 11 ], [ 15, 14 ], [ 80, 17 ], [ 97, 19 ], [ 97, 28 ], [ 76, 30 ], [ 74, 34 ], [ 71, 34 ], [ 98, 35 ], [ 98, 37 ], [ 88, 39 ], [ 95, 43 ], [ 83, 43 ], [ 92, 44 ], [ 92, 46 ], [ 85, 48 ], [ 70, 55 ], [ 98, 57 ], [ 86, 58 ], [ 82, 60 ], [ 92, 62 ], [ 86, 63 ], [ 71, 67 ], [ 74, 67 ], [ 83, 68 ], [ 95, 68 ], [ 70, 71 ], [ 73, 74 ], [ 76, 77 ], [ 79, 80 ], [ 82, 83 ], [ 85, 86 ], [ 88, 89 ], [ 97, 92 ], [ 94, 95 ], [ 97, 98 ] ]

[ "n=int(input())\ntans=1\naans=1\nfor i in range(n):\n t,a = map(int,input().split())\n tt=(tans+t-1)//t\n at=(aans+a-1)//a\n mt=max([tt,at])\n tans=t*mt\n aans=a*mt\nprint(tans+aans)", "n=int(input())", "n", "int(input())", "int", "input()", "input", "tans=1", "tans", "1", "aans=1", "aans", "1", "for i in range(n):\n t,a = map(int,input().split())\n tt=(tans+t-1)//t\n at=(aans+a-1)//a\n mt=max([tt,at])\n tans=t*mt\n aans=a*mt", "i", "range(n)", "range", "n", "t,a = map(int,input().split())", "t", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "a", "tt=(tans+t-1)//t", "tt", "(tans+t-1)//t", "tans+t-1", "tans+t", "tans", "t", "1", "t", "at=(aans+a-1)//a", "at", "(aans+a-1)//a", "aans+a-1", "aans+a", "aans", "a", "1", "a", "mt=max([tt,at])", "mt", "max([tt,at])", "max", "[tt,at]", "tt", "at", "tans=t*mt", "tans", "t*mt", "t", "mt", "aans=a*mt", "aans", "a*mt", "a", "mt", "print(tans+aans)", "print", "tans+aans", "tans", "aans", "tans=t*mt", "t*mt", "tans", "tans=1", "1", "tans", "tt=(tans+t-1)//t", "(tans+t-1)//t", "tt", "n=int(input())", "int(input())", "n", "aans=a*mt", "a*mt", "aans", "mt=max([tt,at])", "max([tt,at])", "mt", "at=(aans+a-1)//a", "(aans+a-1)//a", "at", "a = map(int,input().split())", "map(int,input().split())", "a", "aans=1", "1", "aans", "t,a = map(int,input().split())", "map(int,input().split())", "t" ]

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

[ [ 5, 4 ], [ 11, 10 ], [ 13, 12 ], [ 16, 15 ], [ 4, 18 ], [ 21, 20 ], [ 21, 29 ], [ 32, 31 ], [ 10, 37 ], [ 49, 37 ], [ 20, 38 ], [ 20, 40 ], [ 12, 44 ], [ 53, 44 ], [ 29, 45 ], [ 29, 47 ], [ 50, 49 ], [ 20, 51 ], [ 31, 52 ], [ 54, 53 ], [ 29, 55 ], [ 31, 56 ], [ 49, 60 ], [ 10, 60 ], [ 53, 61 ], [ 12, 61 ], [ 70, 67 ] ]

[ "#!/usr/bin/env python3\n# -*- coding: utf-8 -*-\n\n\ndef main():\n N = int(input())\n T, A = 1, 1\n\n for i in range(N):\n t, a = map(int, input().split())\n m = max((T + t - 1) // t, (A + a - 1) // a)\n T, A = t * m, a * m\n print(T + A)\n\n\nif __name__ == \"__main__\":\n main()", "def main():\n N = int(input())\n T, A = 1, 1\n\n for i in range(N):\n t, a = map(int, input().split())\n m = max((T + t - 1) // t, (A + a - 1) // a)\n T, A = t * m, a * m\n print(T + A)", "main", "N = int(input())", "N", "int(input())", "int", "input()", "input", "T, A = 1, 1", "T", "1", "A", "1", "for i in range(N):\n t, a = map(int, input().split())\n m = max((T + t - 1) // t, (A + a - 1) // a)\n T, A = t * m, a * m\n ", "i", "range(N)", "range", "N", "t, a = map(int, input().split())", "t", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "a", "m = max((T + t - 1) // t, (A + a - 1) // a)", "m", "max((T + t - 1) // t, (A + a - 1) // a)", "max", "(T + t - 1) // t", "T + t - 1", "T + t", "T", "t", "1", "t", "(A + a - 1) // a", "A + a - 1", "A + a", "A", "a", "1", "a", "T, A = t * m, a * m", "T", "t * m", "t", "m", "A", "a * m", "a", "m", "print(T + A)", "print", "T + A", "T", "A", "if __name__ == \"__main__\":\n main()", "__name__ == \"__main__\"", "__name__", "\"__main__\"", "main()", "main", "def main():\n N = int(input())\n T, A = 1, 1\n\n for i in range(N):\n t, a = map(int, input().split())\n m = max((T + t - 1) // t, (A + a - 1) // a)\n T, A = t * m, a * m\n print(T + A)", "def main():\n N = int(input())\n T, A = 1, 1\n\n for i in range(N):\n t, a = map(int, input().split())\n m = max((T + t - 1) // t, (A + a - 1) // a)\n T, A = t * m, a * m\n print(T + A)", "main" ]

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

[ [ 62, 2 ], [ 80, 8 ], [ 68, 10 ], [ 14, 13 ], [ 63, 16 ], [ 71, 18 ], [ 71, 27 ], [ 83, 29 ], [ 81, 35 ], [ 75, 35 ], [ 66, 36 ], [ 66, 38 ], [ 69, 42 ], [ 78, 42 ], [ 72, 43 ], [ 72, 45 ], [ 74, 47 ], [ 66, 49 ], [ 84, 50 ], [ 63, 50 ], [ 77, 52 ], [ 72, 54 ], [ 84, 55 ], [ 63, 55 ], [ 75, 59 ], [ 81, 59 ], [ 78, 60 ], [ 69, 60 ], [ 62, 63 ], [ 71, 66 ], [ 68, 69 ], [ 71, 72 ], [ 74, 75 ], [ 77, 78 ], [ 80, 81 ], [ 83, 84 ] ]

[ "n = int(input())\n\nra,rb = 1,1\nfor i in range(n):\n a,b = map(int,input().split())\n n = max((ra+a-1)//a,(rb+b-1)//b)\n ra = a*n\n rb = b*n\n \nprint(ra+rb)", "n = int(input())", "n", "int(input())", "int", "input()", "input", "ra,rb = 1,1", "ra", "1", "rb", "1", "for i in range(n):\n a,b = map(int,input().split())\n n = max((ra+a-1)//a,(rb+b-1)//b)\n ra = a*n\n rb = b*n\n ", "i", "range(n)", "range", "n", "a,b = map(int,input().split())", "a", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "n = max((ra+a-1)//a,(rb+b-1)//b)", "n", "max((ra+a-1)//a,(rb+b-1)//b)", "max", "(ra+a-1)//a", "ra+a-1", "ra+a", "ra", "a", "1", "a", "(rb+b-1)//b", "rb+b-1", "rb+b", "rb", "b", "1", "b", "ra = a*n", "ra", "a*n", "a", "n", "rb = b*n", "rb", "b*n", "b", "n", "print(ra+rb)", "print", "ra+rb", "ra", "rb", "n = int(input())", "int(input())", "n", "a,b = map(int,input().split())", "map(int,input().split())", "a", "rb = 1,1", "1", "rb", "b = map(int,input().split())", "map(int,input().split())", "b", "ra = a*n", "a*n", "ra", "rb = b*n", "b*n", "rb", "ra,rb = 1,1", "1", "ra", "n = max((ra+a-1)//a,(rb+b-1)//b)", "max((ra+a-1)//a,(rb+b-1)//b)", "n" ]

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

[ [ 98, 4 ], [ 15, 14 ], [ 99, 18 ], [ 22, 21 ], [ 14, 24 ], [ 99, 36 ], [ 41, 40 ], [ 44, 43 ], [ 46, 45 ], [ 53, 52 ], [ 43, 57 ], [ 74, 57 ], [ 43, 61 ], [ 74, 61 ], [ 45, 66 ], [ 79, 66 ], [ 45, 70 ], [ 79, 70 ], [ 75, 74 ], [ 52, 76 ], [ 80, 79 ], [ 52, 81 ], [ 74, 86 ], [ 43, 86 ], [ 79, 87 ], [ 45, 87 ], [ 96, 93 ], [ 98, 99 ] ]

[ "import sys\nreadline = sys.stdin.readline\nfrom math import floor, ceil\n\ndef main():\n N = int(readline())\n inp = [tuple(map(int, readline().rstrip().split())) for _ in range(N)]\n scr_t, scr_a = 1, 1\n for t, a in inp:\n # n = max(ceil(scr_t/t), ceil(scr_a/a))\n n = max((scr_t//t)+(scr_t%t!=0), (scr_a//a)+(scr_a%a!=0))\n scr_t = n * t\n scr_a = n * a\n\n print(scr_t + scr_a)\n\nif __name__ == '__main__':\n main()", "import sys", "sys", "readline = sys.stdin.readline", "readline", "sys.stdin.readline", "sys.stdin", "sys", "stdin", "readline", "from math import floor, ceil", "def main():\n N = int(readline())\n inp = [tuple(map(int, readline().rstrip().split())) for _ in range(N)]\n scr_t, scr_a = 1, 1\n for t, a in inp:\n # n = max(ceil(scr_t/t), ceil(scr_a/a))\n n = max((scr_t//t)+(scr_t%t!=0), (scr_a//a)+(scr_a%a!=0))\n scr_t = n * t\n scr_a = n * a\n\n print(scr_t + scr_a)", "main", "N = int(readline())", "N", "int(readline())", "int", "readline()", "readline", "tuple(map(int, readline().rstrip().split())) for _ in range(N)", "for _ in range(N)", "_", "range(N)", "range", "N", "for _ in range(N)", "tuple(map(int, readline().rstrip().split()))", "tuple", "map(int, readline().rstrip().split())", "map", "int", "readline().rstrip().split()", "().rstrip().split", "().rstrip()", "().rstrip", "()", "readline", "rstrip", "split", "inp = [tuple(map(int, readline().rstrip().split())) for _ in range(N)]", "inp", "[tuple(map(int, readline().rstrip().split())) for _ in range(N)]", "scr_t, scr_a = 1, 1", "scr_t", "1", "scr_a", "1", "for t, a in inp:\n # n = max(ceil(scr_t/t), ceil(scr_a/a))\n n = max((scr_t//t)+(scr_t%t!=0), (scr_a//a)+(scr_a%a!=0))\n scr_t = n * t\n scr_a = n * a\n\n ", "t", "a", "inp", "n = max((scr_t//t)+(scr_t%t!=0), (scr_a//a)+(scr_a%a!=0))", "n", "max((scr_t//t)+(scr_t%t!=0), (scr_a//a)+(scr_a%a!=0))", "max", "(scr_t//t)+(scr_t%t!=0)", "scr_t//t", "scr_t", "t", "scr_t%t!=0", "scr_t%t", "scr_t", "t", "0", "(scr_a//a)+(scr_a%a!=0)", "scr_a//a", "scr_a", "a", "scr_a%a!=0", "scr_a%a", "scr_a", "a", "0", "scr_t = n * t", "scr_t", "n * t", "n", "t", "scr_a = n * a", "scr_a", "n * a", "n", "a", "print(scr_t + scr_a)", "print", "scr_t + scr_a", "scr_t", "scr_a", "if __name__ == '__main__':\n main()", "__name__ == '__main__'", "__name__", "'__main__'", "main()", "main", "def main():\n N = int(readline())\n inp = [tuple(map(int, readline().rstrip().split())) for _ in range(N)]\n scr_t, scr_a = 1, 1\n for t, a in inp:\n # n = max(ceil(scr_t/t), ceil(scr_a/a))\n n = max((scr_t//t)+(scr_t%t!=0), (scr_a//a)+(scr_a%a!=0))\n scr_t = n * t\n scr_a = n * a\n\n print(scr_t + scr_a)", "def main():\n N = int(readline())\n inp = [tuple(map(int, readline().rstrip().split())) for _ in range(N)]\n scr_t, scr_a = 1, 1\n for t, a in inp:\n # n = max(ceil(scr_t/t), ceil(scr_a/a))\n n = max((scr_t//t)+(scr_t%t!=0), (scr_a//a)+(scr_a%a!=0))\n scr_t = n * t\n scr_a = n * a\n\n print(scr_t + scr_a)", "main", "readline = sys.stdin.readline", "sys.stdin.readline", "readline" ]

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

[ [ 80, 2 ], [ 68, 8 ], [ 62, 10 ], [ 14, 13 ], [ 81, 16 ], [ 77, 18 ], [ 77, 27 ], [ 83, 29 ], [ 69, 35 ], [ 75, 35 ], [ 78, 37 ], [ 63, 42 ], [ 66, 42 ], [ 72, 44 ], [ 74, 47 ], [ 78, 49 ], [ 84, 50 ], [ 65, 52 ], [ 72, 54 ], [ 84, 55 ], [ 66, 59 ], [ 63, 59 ], [ 75, 60 ], [ 69, 60 ], [ 62, 63 ], [ 65, 66 ], [ 68, 69 ], [ 77, 72 ], [ 74, 75 ], [ 77, 78 ], [ 80, 81 ], [ 83, 84 ] ]

[ "N = int(input())\nT, A = 1, 1\nfor _ in range(N):\n t, a = map(int,input().split())\n k = max((T - 1) // t + 1, (A - 1) // a + 1)\n T = t * k\n A = a * k\nprint(A + T)", "N = int(input())", "N", "int(input())", "int", "input()", "input", "T, A = 1, 1", "T", "1", "A", "1", "for _ in range(N):\n t, a = map(int,input().split())\n k = max((T - 1) // t + 1, (A - 1) // a + 1)\n T = t * k\n A = a * k", "_", "range(N)", "range", "N", "t, a = map(int,input().split())", "t", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "a", "k = max((T - 1) // t + 1, (A - 1) // a + 1)", "k", "max((T - 1) // t + 1, (A - 1) // a + 1)", "max", "(T - 1) // t + 1", "(T - 1) // t", "T - 1", "T", "1", "t", "1", "(A - 1) // a + 1", "(A - 1) // a", "A - 1", "A", "1", "a", "1", "T = t * k", "T", "t * k", "t", "k", "A = a * k", "A", "a * k", "a", "k", "print(A + T)", "print", "A + T", "A", "T", "A = 1, 1", "1", "A", "A = a * k", "a * k", "A", "T, A = 1, 1", "1", "T", "a = map(int,input().split())", "map(int,input().split())", "a", "T = t * k", "t * k", "T", "t, a = map(int,input().split())", "map(int,input().split())", "t", "N = int(input())", "int(input())", "N", "k = max((T - 1) // t + 1, (A - 1) // a + 1)", "max((T - 1) // t + 1, (A - 1) // a + 1)", "k" ]

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

[ [ 15, 6 ], [ 17, 7 ], [ 15, 10 ], [ 17, 11 ], [ 15, 15 ], [ 17, 17 ], [ 98, 19 ], [ 77, 25 ], [ 80, 27 ], [ 31, 30 ], [ 99, 33 ], [ 37, 36 ], [ 36, 45 ], [ 101, 47 ], [ 101, 49 ], [ 89, 51 ], [ 93, 55 ], [ 78, 56 ], [ 84, 56 ], [ 87, 57 ], [ 93, 59 ], [ 81, 60 ], [ 96, 60 ], [ 102, 61 ], [ 83, 63 ], [ 87, 65 ], [ 90, 66 ], [ 95, 67 ], [ 102, 69 ], [ 90, 70 ], [ 84, 74 ], [ 78, 74 ], [ 96, 75 ], [ 81, 75 ], [ 77, 78 ], [ 80, 81 ], [ 83, 84 ], [ 101, 87 ], [ 89, 90 ], [ 95, 96 ], [ 98, 99 ], [ 101, 102 ] ]

[ "def ceil(a, b):\n return a//b+(1 if a % b else 0)\n\n\nn = int(input())\nx, y = 1, 1\nfor _ in range(n):\n t, a = [int(i) for i in input().split()]\n k = max(ceil(x, t), ceil(y, a))\n x, y = t * k, a * k\nprint(x+y)", "def ceil(a, b):\n return a//b+(1 if a % b else 0)", "ceil", "return a//b+(1 if a % b else 0)", "a//b+(1 if a % b else 0)", "a//b", "a", "b", "1 if a % b else 0", "a % b", "a", "b", "1", "0", "a", "a", "b", "b", "n = int(input())", "n", "int(input())", "int", "input()", "input", "x, y = 1, 1", "x", "1", "y", "1", "for _ in range(n):\n t, a = [int(i) for i in input().split()]\n k = max(ceil(x, t), ceil(y, a))\n x, y = t * k, a * k", "_", "range(n)", "range", "n", "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", "t, a = [int(i) for i in input().split()]", "t", "[int(i) for i in input().split()]", "a", "k = max(ceil(x, t), ceil(y, a))", "k", "max(ceil(x, t), ceil(y, a))", "max", "ceil(x, t)", "ceil", "x", "t", "ceil(y, a)", "ceil", "y", "a", "x, y = t * k, a * k", "x", "t * k", "t", "k", "y", "a * k", "a", "k", "print(x+y)", "print", "x+y", "x", "y", "x, y = 1, 1", "1", "x", "y = 1, 1", "1", "y", "x, y = t * k, a * k", "t * k", "x", "t, a = [int(i) for i in input().split()]", "[int(i) for i in input().split()]", "t", "k = max(ceil(x, t), ceil(y, a))", "max(ceil(x, t), ceil(y, a))", "k", "def ceil(a, b):\n return a//b+(1 if a % b else 0)", "def ceil(a, b):\n return a//b+(1 if a % b else 0)", "ceil", "y = t * k, a * k", "a * k", "y", "n = int(input())", "int(input())", "n", "a = [int(i) for i in input().split()]", "[int(i) for i in input().split()]", "a" ]

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

[ [ 148, 2 ], [ 10, 9 ], [ 149, 12 ], [ 145, 25 ], [ 151, 28 ], [ 146, 32 ], [ 146, 37 ], [ 42, 41 ], [ 149, 45 ], [ 152, 51 ], [ 146, 55 ], [ 41, 56 ], [ 152, 62 ], [ 146, 66 ], [ 41, 67 ], [ 74, 71 ], [ 152, 72 ], [ 146, 76 ], [ 41, 77 ], [ 83, 80 ], [ 152, 81 ], [ 146, 85 ], [ 41, 86 ], [ 142, 89 ], [ 152, 96 ], [ 146, 100 ], [ 41, 101 ], [ 152, 107 ], [ 146, 111 ], [ 41, 112 ], [ 118, 115 ], [ 152, 116 ], [ 146, 121 ], [ 41, 122 ], [ 143, 124 ], [ 129, 126 ], [ 152, 127 ], [ 146, 132 ], [ 41, 133 ], [ 143, 135 ], [ 152, 140 ], [ 142, 143 ], [ 145, 146 ], [ 148, 149 ], [ 151, 152 ] ]

[ "n = int(input())\nta = [list(map(int,input().split())) for _ in range(n)]\nans = [ta[0][0],ta[0][1]]\nfor i in range(1,n):\n if ans[0] / ta[i][0] <= 1 and ans[1] / ta[i][1] <= 1:\n ans[0] = ta[i][0]\n ans[1] = ta[i][1]\n else:\n x = max(-(-ans[0]//ta[i][0]),-(-ans[1]//ta[i][1]))\n ans[0] = ta[i][0]*x\n ans[1] = ta[i][1]*x\nprint(sum(ans))", "n = int(input())", "n", "int(input())", "int", "input()", "input", "list(map(int,input().split())) for _ in range(n)", "for _ in range(n)", "_", "range(n)", "range", "n", "for _ in range(n)", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "ta = [list(map(int,input().split())) for _ in range(n)]", "ta", "[list(map(int,input().split())) for _ in range(n)]", "ans = [ta[0][0],ta[0][1]]", "ans", "[ta[0][0],ta[0][1]]", "ta[0][0]", "[0]", "ta", "0", "0", "ta[0][1]", "[0]", "ta", "0", "1", "for i in range(1,n):\n if ans[0] / ta[i][0] <= 1 and ans[1] / ta[i][1] <= 1:\n ans[0] = ta[i][0]\n ans[1] = ta[i][1]\n else:\n x = max(-(-ans[0]//ta[i][0]),-(-ans[1]//ta[i][1]))\n ans[0] = ta[i][0]*x\n ans[1] = ta[i][1]*x", "i", "range(1,n)", "range", "1", "n", "if ans[0] / ta[i][0] <= 1 and ans[1] / ta[i][1] <= 1:\n ans[0] = ta[i][0]\n ans[1] = ta[i][1]\n else:\n x = max(-(-ans[0]//ta[i][0]),-(-ans[1]//ta[i][1]))\n ans[0] = ta[i][0]*x\n ans[1] = ta[i][1]*x", "ans[0] / ta[i][0] <= 1 and ans[1] / ta[i][1] <= 1", "ans[0] / ta[i][0] <= 1", "ans[0] / ta[i][0]", "ans[0]", "ans", "0", "ta[i][0]", "[i]", "ta", "i", "0", "1", "ans[1] / ta[i][1] <= 1", "ans[1] / ta[i][1]", "ans[1]", "ans", "1", "ta[i][1]", "[i]", "ta", "i", "1", "1", "ans[0] = ta[i][0]", "ans[0]", "ans", "0", "ta[i][0]", "[i]", "ta", "i", "0", "ans[1] = ta[i][1]", "ans[1]", "ans", "1", "ta[i][1]", "[i]", "ta", "i", "1", "x = max(-(-ans[0]//ta[i][0]),-(-ans[1]//ta[i][1]))", "x", "max(-(-ans[0]//ta[i][0]),-(-ans[1]//ta[i][1]))", "max", "-(-ans[0]//ta[i][0])", "-ans[0]//ta[i][0]", "-ans[0]", "ans[0]", "ans", "0", "ta[i][0]", "[i]", "ta", "i", "0", "-(-ans[1]//ta[i][1])", "-ans[1]//ta[i][1]", "-ans[1]", "ans[1]", "ans", "1", "ta[i][1]", "[i]", "ta", "i", "1", "ans[0] = ta[i][0]*x", "ans[0]", "ans", "0", "ta[i][0]*x", "ta[i][0]", "[i]", "ta", "i", "0", "x", "ans[1] = ta[i][1]*x", "ans[1]", "ans", "1", "ta[i][1]*x", "ta[i][1]", "[i]", "ta", "i", "1", "x", "print(sum(ans))", "print", "sum(ans)", "sum", "ans", "x = max(-(-ans[0]//ta[i][0]),-(-ans[1]//ta[i][1]))", "max(-(-ans[0]//ta[i][0]),-(-ans[1]//ta[i][1]))", "x", "ta = [list(map(int,input().split())) for _ in range(n)]", "[list(map(int,input().split())) for _ in range(n)]", "ta", "n = int(input())", "int(input())", "n", "ans = [ta[0][0],ta[0][1]]", "[ta[0][0],ta[0][1]]", "ans" ]

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

[ [ 195, 2 ], [ 10, 9 ], [ 196, 12 ], [ 174, 16 ], [ 21, 20 ], [ 175, 22 ], [ 20, 25 ], [ 183, 27 ], [ 31, 30 ], [ 175, 32 ], [ 168, 36 ], [ 30, 37 ], [ 168, 38 ], [ 166, 42 ], [ 169, 43 ], [ 177, 46 ], [ 184, 49 ], [ 187, 49 ], [ 186, 51 ], [ 198, 57 ], [ 201, 60 ], [ 166, 61 ], [ 189, 63 ], [ 169, 64 ], [ 166, 67 ], [ 169, 68 ], [ 204, 70 ], [ 171, 73 ], [ 169, 74 ], [ 192, 76 ], [ 166, 77 ], [ 147, 80 ], [ 85, 80 ], [ 187, 81 ], [ 184, 81 ], [ 205, 82 ], [ 199, 82 ], [ 172, 83 ], [ 202, 83 ], [ 88, 85 ], [ 187, 86 ], [ 184, 86 ], [ 205, 87 ], [ 199, 87 ], [ 147, 91 ], [ 85, 91 ], [ 187, 92 ], [ 184, 92 ], [ 205, 93 ], [ 199, 93 ], [ 172, 94 ], [ 202, 94 ], [ 172, 95 ], [ 202, 95 ], [ 172, 96 ], [ 202, 96 ], [ 180, 98 ], [ 85, 101 ], [ 147, 101 ], [ 187, 102 ], [ 184, 102 ], [ 205, 103 ], [ 199, 103 ], [ 172, 104 ], [ 202, 104 ], [ 193, 105 ], [ 190, 105 ], [ 187, 109 ], [ 184, 109 ], [ 205, 111 ], [ 199, 111 ], [ 181, 113 ], [ 120, 115 ], [ 187, 116 ], [ 184, 116 ], [ 205, 118 ], [ 199, 118 ], [ 181, 120 ], [ 187, 124 ], [ 184, 124 ], [ 205, 126 ], [ 199, 126 ], [ 193, 128 ], [ 190, 128 ], [ 135, 130 ], [ 187, 131 ], [ 184, 131 ], [ 205, 133 ], [ 199, 133 ], [ 187, 139 ], [ 184, 139 ], [ 205, 141 ], [ 199, 141 ], [ 193, 143 ], [ 190, 143 ], [ 193, 144 ], [ 190, 144 ], [ 193, 145 ], [ 190, 145 ], [ 150, 147 ], [ 187, 148 ], [ 184, 148 ], [ 205, 149 ], [ 199, 149 ], [ 187, 153 ], [ 184, 153 ], [ 205, 155 ], [ 199, 155 ], [ 193, 157 ], [ 190, 157 ], [ 172, 158 ], [ 202, 158 ], [ 187, 163 ], [ 184, 163 ], [ 30, 165 ], [ 168, 166 ], [ 30, 168 ], [ 168, 169 ], [ 169, 171 ], [ 171, 172 ], [ 174, 175 ], [ 177, 178 ], [ 180, 181 ], [ 183, 184 ], [ 186, 187 ], [ 169, 189 ], [ 189, 190 ], [ 166, 192 ], [ 192, 193 ], [ 195, 196 ], [ 198, 199 ], [ 166, 201 ], [ 201, 202 ], [ 204, 205 ] ]

[ "N = int(input())\nTA = [[int(i) for i in input().split()] for _ in range(N)]\nans = [i for i in TA[0]]\nfor ta in TA[1:]:\n t, a = ta\n if t == a == 1:\n m = max(ans)\n ans = [m, m]\n continue\n si = 0\n sn = t\n ln = a\n if t > a:\n si = 1\n sn = a\n ln = t\n if ans[si] % sn:\n ans[si] = ans[si] // sn * sn + sn\n n = ans[si] // sn * ln\n if ans[si ^ 1] <= n:\n ans[si ^ 1] = n\n else:\n if ans[si ^ 1] % ln:\n ans[si ^ 1] = ans[si ^ 1] // ln * ln + ln\n ans[si] = ans[si ^ 1] // ln * sn\nprint(sum(ans))", "N = int(input())", "N", "int(input())", "int", "input()", "input", "[int(i) for i in input().split()] for _ in range(N)", "for _ in range(N)", "_", "range(N)", "range", "N", "for _ in range(N)", "[int(i) for i in input().split()]", "TA = [[int(i) for i in input().split()] for _ in range(N)]", "TA", "[[int(i) for i in input().split()] for _ in range(N)]", "i for i in TA[0]", "for i in TA[0]", "i", "TA[0]", "TA", "0", "for i in TA[0]", "i", "ans = [i for i in TA[0]]", "ans", "[i for i in TA[0]]", "for ta in TA[1:]:\n t, a = ta\n if t == a == 1:\n m = max(ans)\n ans = [m, m]\n continue\n si = 0\n sn = t\n ln = a\n if t > a:\n si = 1\n sn = a\n ln = t\n if ans[si] % sn:\n ans[si] = ans[si] // sn * sn + sn\n n = ans[si] // sn * ln\n if ans[si ^ 1] <= n:\n ans[si ^ 1] = n\n else:\n if ans[si ^ 1] % ln:\n ans[si ^ 1] = ans[si ^ 1] // ln * ln + ln\n ans[si] = ans[si ^ 1] // ln * sn", "ta", "TA[1:]", "TA", "1:", "1", "t, a = ta", "t", "ta", "a", "if t == a == 1:\n m = max(ans)\n ans = [m, m]\n continue\n ", "t == a == 1", "t == a", "t", "a", "1", "m = max(ans)", "m", "max(ans)", "max", "ans", "ans = [m, m]", "ans", "[m, m]", "m", "m", "continue", "si = 0", "si", "0", "sn = t", "sn", "t", "ln = a", "ln", "a", "if t > a:\n si = 1\n sn = a\n ln = t\n ", "t > a", "t", "a", "si = 1", "si", "1", "sn = a", "sn", "a", "ln = t", "ln", "t", "if ans[si] % sn:\n ans[si] = ans[si] // sn * sn + sn\n ", "ans[si] % sn", "ans[si]", "ans", "si", "sn", "ans[si] = ans[si] // sn * sn + sn", "ans[si]", "ans", "si", "ans[si] // sn * sn + sn", "ans[si] // sn * sn", "ans[si] // sn", "ans[si]", "ans", "si", "sn", "sn", "sn", "n = ans[si] // sn * ln", "n", "ans[si] // sn * ln", "ans[si] // sn", "ans[si]", "ans", "si", "sn", "ln", "if ans[si ^ 1] <= n:\n ans[si ^ 1] = n\n else:\n if ans[si ^ 1] % ln:\n ans[si ^ 1] = ans[si ^ 1] // ln * ln + ln\n ans[si] = ans[si ^ 1] // ln * sn", "ans[si ^ 1] <= n", "ans[si ^ 1]", "ans", "si ^ 1", "si", "1", "n", "ans[si ^ 1] = n", "ans[si ^ 1]", "ans", "si ^ 1", "si", "1", "n", "if ans[si ^ 1] % ln:\n ans[si ^ 1] = ans[si ^ 1] // ln * ln + ln\n ", "ans[si ^ 1] % ln", "ans[si ^ 1]", "ans", "si ^ 1", "si", "1", "ln", "ans[si ^ 1] = ans[si ^ 1] // ln * ln + ln", "ans[si ^ 1]", "ans", "si ^ 1", "si", "1", "ans[si ^ 1] // ln * ln + ln", "ans[si ^ 1] // ln * ln", "ans[si ^ 1] // ln", "ans[si ^ 1]", "ans", "si ^ 1", "si", "1", "ln", "ln", "ln", "ans[si] = ans[si ^ 1] // ln * sn", "ans[si]", "ans", "si", "ans[si ^ 1] // ln * sn", "ans[si ^ 1] // ln", "ans[si ^ 1]", "ans", "si ^ 1", "si", "1", "ln", "sn", "print(sum(ans))", "print", "sum(ans)", "sum", "ans", "t, a = ta", "ta", "t", "a = ta", "ta", "a", "sn = a", "a", "sn", "TA = [[int(i) for i in input().split()] for _ in range(N)]", "[[int(i) for i in input().split()] for _ in range(N)]", "TA", "m = max(ans)", "max(ans)", "m", "n = ans[si] // sn * ln", "ans[si] // sn * ln", "n", "ans = [i for i in TA[0]]", "[i for i in TA[0]]", "ans", "ans = [m, m]", "[m, m]", "ans", "ln = a", "a", "ln", "ln = t", "t", "ln", "N = int(input())", "int(input())", "N", "si = 0", "0", "si", "sn = t", "t", "sn", "si = 1", "1", "si" ]

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

[ [ 76, 3 ], [ 79, 9 ], [ 73, 11 ], [ 15, 14 ], [ 77, 17 ], [ 64, 19 ], [ 64, 28 ], [ 70, 30 ], [ 80, 36 ], [ 62, 36 ], [ 65, 37 ], [ 74, 41 ], [ 68, 41 ], [ 59, 42 ], [ 61, 44 ], [ 65, 46 ], [ 71, 47 ], [ 67, 48 ], [ 59, 50 ], [ 71, 51 ], [ 62, 55 ], [ 80, 55 ], [ 68, 56 ], [ 74, 56 ], [ 64, 59 ], [ 61, 62 ], [ 64, 65 ], [ 67, 68 ], [ 70, 71 ], [ 73, 74 ], [ 76, 77 ], [ 79, 80 ] ]

[ "from math import ceil\n\nN = int(input())\nprv_t, prv_a = 1, 1\nfor _ in range(N):\n t,a = map(int,input().split())\n x = max(-(-prv_t//t), -(-prv_a//a))\n prv_t, prv_a = t*x, a*x\nprint(prv_t+prv_a)", "from math import ceil", "N = int(input())", "N", "int(input())", "int", "input()", "input", "prv_t, prv_a = 1, 1", "prv_t", "1", "prv_a", "1", "for _ in range(N):\n t,a = map(int,input().split())\n x = max(-(-prv_t//t), -(-prv_a//a))\n prv_t, prv_a = t*x, a*x", "_", "range(N)", "range", "N", "t,a = map(int,input().split())", "t", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "a", "x = max(-(-prv_t//t), -(-prv_a//a))", "x", "max(-(-prv_t//t), -(-prv_a//a))", "max", "-(-prv_t//t)", "-prv_t//t", "-prv_t", "prv_t", "t", "-(-prv_a//a)", "-prv_a//a", "-prv_a", "prv_a", "a", "prv_t, prv_a = t*x, a*x", "prv_t", "t*x", "t", "x", "prv_a", "a*x", "a", "x", "print(prv_t+prv_a)", "print", "prv_t+prv_a", "prv_t", "prv_a", "a = map(int,input().split())", "map(int,input().split())", "a", "prv_t, prv_a = t*x, a*x", "t*x", "prv_t", "t,a = map(int,input().split())", "map(int,input().split())", "t", "prv_a = t*x, a*x", "a*x", "prv_a", "x = max(-(-prv_t//t), -(-prv_a//a))", "max(-(-prv_t//t), -(-prv_a//a))", "x", "prv_a = 1, 1", "1", "prv_a", "N = int(input())", "int(input())", "N", "prv_t, prv_a = 1, 1", "1", "prv_t" ]

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

[ [ 8, 7 ], [ 19, 19 ], [ 21, 21 ], [ 23, 23 ], [ 27, 26 ], [ 35, 35 ], [ 37, 37 ], [ 39, 39 ], [ 41, 41 ], [ 45, 44 ], [ 53, 53 ], [ 55, 55 ], [ 57, 57 ], [ 59, 59 ], [ 61, 61 ], [ 65, 65 ], [ 68, 67 ], [ 76, 75 ], [ 270, 81 ], [ 86, 85 ], [ 239, 103 ], [ 251, 108 ], [ 119, 118 ], [ 151, 119 ], [ 122, 121 ], [ 149, 122 ], [ 121, 126 ], [ 144, 126 ], [ 118, 128 ], [ 141, 128 ], [ 131, 130 ], [ 118, 133 ], [ 141, 133 ], [ 121, 134 ], [ 144, 134 ], [ 153, 138 ], [ 130, 139 ], [ 142, 141 ], [ 130, 142 ], [ 145, 144 ], [ 130, 145 ], [ 141, 147 ], [ 118, 147 ], [ 149, 149 ], [ 151, 151 ], [ 153, 153 ], [ 245, 155 ], [ 270, 157 ], [ 281, 159 ], [ 231, 161 ], [ 281, 162 ], [ 165, 164 ], [ 246, 168 ], [ 260, 171 ], [ 231, 173 ], [ 260, 174 ], [ 212, 176 ], [ 225, 178 ], [ 240, 180 ], [ 261, 185 ], [ 279, 187 ], [ 216, 187 ], [ 234, 190 ], [ 282, 192 ], [ 249, 192 ], [ 215, 195 ], [ 261, 197 ], [ 213, 198 ], [ 248, 199 ], [ 234, 201 ], [ 213, 202 ], [ 227, 204 ], [ 216, 206 ], [ 279, 206 ], [ 249, 207 ], [ 282, 207 ], [ 228, 210 ], [ 212, 213 ], [ 215, 216 ], [ 227, 228 ], [ 260, 234 ], [ 239, 240 ], [ 245, 246 ], [ 248, 249 ], [ 251, 252 ], [ 260, 261 ], [ 281, 279 ], [ 281, 282 ] ]

[ "# -*- coding: utf-8 -*-\n\nimport sys\n\ndef input(): return sys.stdin.readline().strip()\ndef list2d(a, b, c): return [[c] * b for i in range(a)]\ndef list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]\ndef list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]\ndef ceil(x, y=1): return int(-(-x // y))\ndef INT(): return int(input())\ndef MAP(): return map(int, input().split())\ndef LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]\ndef Yes(): print('Yes')\ndef No(): print('No')\ndef YES(): print('YES')\ndef NO(): print('NO')\nsys.setrecursionlimit(10 ** 9)\nINF = 10 ** 18\nMOD = 10 ** 9 + 7\n\ndef bisearch_min(mn, mx, func):\n \"\"\" 条件を満たす最小値を見つける二分探索 \"\"\"\n\n ok = mx\n ng = mn\n while ng+1 < ok:\n mid = (ok+ng) // 2\n if func(mid):\n # 下を探しに行く\n ok = mid\n else:\n # 上を探しに行く\n ng = mid\n return ok\n\nN = INT()\ncura, curb = MAP()\nfor i in range(N-1):\n a, b = MAP()\n # 比をそのままで、現在の票数より大きくする\n res = bisearch_min(0, INF, lambda m: a*m >= cura and b*m >= curb)\n cura, curb = a * res, b * res\nans = cura + curb\nprint(ans)", "import sys", "sys", "def input(): return sys.stdin.readline().strip()", "input", "[c] * b for i in range(a)", "for i in range(a)", "i", "range(a)", "range", "a", "for i in range(a)", "[c] * b", "[c]", "c", "b", "def list2d(a, b, c): return [[c] * b for i in range(a)]", "list2d", "a", "a", "b", "b", "c", "c", "[[d] * c for j in range(b)] for i in range(a)", "for i in range(a)", "i", "range(a)", "range", "a", "for i in range(a)", "[[d] * c for j in range(b)]", "def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]", "list3d", "a", "a", "b", "b", "c", "c", "d", "d", "[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)", "for i in range(a)", "i", "range(a)", "range", "a", "for i in range(a)", "[[[e] * d for j in range(c)] for j in range(b)]", "def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]", "list4d", "a", "a", "b", "b", "c", "c", "d", "d", "e", "e", "def ceil(x, y=1): return int(-(-x // y))", "ceil", "x", "x", "y=1", "y", "1", "def INT(): return int(input())", "INT", "def MAP(): return map(int, input().split())", "MAP", "INT() for i in range(N)", "for i in range(N)", "i", "range(N)", "range", "N", "for i in range(N)", "INT()", "INT", "def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]", "LIST", "N=None", "N", "None", "def Yes(): print('Yes')", "Yes", "def No(): print('No')", "No", "def YES(): print('YES')", "YES", "def NO(): print('NO')", "NO", "sys.setrecursionlimit(10 ** 9)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "10 ** 9", "10", "9", "INF = 10 ** 18", "INF", "10 ** 18", "10", "18", "MOD = 10 ** 9 + 7", "MOD", "10 ** 9 + 7", "10 ** 9", "10", "9", "7", "def bisearch_min(mn, mx, func):\n \"\"\" 条件を満たす最小値を見つける二分探索 \"\"\"\n\n ok = mx\n ng = mn\n while ng+1 < ok:\n mid = (ok+ng) // 2\n if func(mid):\n # 下を探しに行く\n ok = mid\n else:\n # 上を探しに行く\n ng = mid\n return ok", "bisearch_min", "\"\"\" 条件を満たす最小値を見つける二分探索 \"\"\"", "ok = mx", "ok", "mx", "ng = mn", "ng", "mn", "while ng+1 < ok:\n mid = (ok+ng) // 2\n if func(mid):\n # 下を探しに行く\n ok = mid\n else:\n # 上を探しに行く\n ng = mid\n ", "ng+1 < ok", "ng+1", "ng", "1", "ok", "mid = (ok+ng) // 2", "mid", "(ok+ng) // 2", "ok+ng", "ok", "ng", "2", "if func(mid):\n # 下を探しに行く\n ok = mid\n else:\n # 上を探しに行く\n ng = mid\n ", "func(mid)", "func", "mid", "ok = mid", "ok", "mid", "ng = mid", "ng", "mid", "return ok", "ok", "mn", "mn", "mx", "mx", "func", "func", "N = INT()", "N", "INT()", "INT", "cura, curb = MAP()", "cura", "MAP()", "MAP", "curb", "for i in range(N-1):\n a, b = MAP()\n # 比をそのままで、現在の票数より大きくする\n res = bisearch_min(0, INF, lambda m: a*m >= cura and b*m >= curb)\n cura, curb = a * res, b * res", "i", "range(N-1)", "range", "N-1", "N", "1", "a, b = MAP()", "a", "MAP()", "MAP", "b", "res = bisearch_min(0, INF, lambda m: a*m >= cura and b*m >= curb)", "res", "bisearch_min(0, INF, lambda m: a*m >= cura and b*m >= curb)", "bisearch_min", "0", "INF", "lambda m: a*m >= cura and b*m >= curb", "a*m >= cura and b*m >= curb", "a*m >= cura", "a*m", "a", "m", "cura", "b*m >= curb", "b*m", "b", "m", "curb", "m", "cura, curb = a * res, b * res", "cura", "a * res", "a", "res", "curb", "b * res", "b", "res", "ans = cura + curb", "ans", "cura + curb", "cura", "curb", "print(ans)", "print", "ans", "res = bisearch_min(0, INF, lambda m: a*m >= cura and b*m >= curb)", "bisearch_min(0, INF, lambda m: a*m >= cura and b*m >= curb)", "res", "cura, curb = a * res, b * res", "a * res", "cura", "def list2d(a, b, c): return [[c] * b for i in range(a)]", "def list2d(a, b, c): return [[c] * b for i in range(a)]", "list2d", "def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]", "def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]", "list4d", "def bisearch_min(mn, mx, func):\n \"\"\" 条件を満たす最小値を見つける二分探索 \"\"\"\n\n ok = mx\n ng = mn\n while ng+1 < ok:\n mid = (ok+ng) // 2\n if func(mid):\n # 下を探しに行く\n ok = mid\n else:\n # 上を探しに行く\n ng = mid\n return ok", "def bisearch_min(mn, mx, func):\n \"\"\" 条件を満たす最小値を見つける二分探索 \"\"\"\n\n ok = mx\n ng = mn\n while ng+1 < ok:\n mid = (ok+ng) // 2\n if func(mid):\n # 下を探しに行く\n ok = mid\n else:\n # 上を探しに行く\n ng = mid\n return ok", "bisearch_min", "ans = cura + curb", "cura + curb", "ans", "def MAP(): return map(int, input().split())", "def MAP(): return map(int, input().split())", "MAP", "b = MAP()", "MAP()", "b", "def NO(): print('NO')", "def NO(): print('NO')", "NO", "INF = 10 ** 18", "10 ** 18", "INF", "def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]", "def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]", "LIST", "N = INT()", "INT()", "N", "curb = a * res, b * res", "b * res", "curb", "MOD = 10 ** 9 + 7", "10 ** 9 + 7", "MOD", "def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]", "def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]", "list3d", "def No(): print('No')", "def No(): print('No')", "No", "a, b = MAP()", "MAP()", "a", "def ceil(x, y=1): return int(-(-x // y))", "def ceil(x, y=1): return int(-(-x // y))", "ceil", "def input(): return sys.stdin.readline().strip()", "def input(): return sys.stdin.readline().strip()", "input", "def INT(): return int(input())", "def INT(): return int(input())", "INT", "def Yes(): print('Yes')", "def Yes(): print('Yes')", "Yes", "def YES(): print('YES')", "def YES(): print('YES')", "YES", "cura, curb = MAP()", "MAP()", "cura", "curb = MAP()", "MAP()", "curb" ]

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

[ [ 67, 2 ], [ 76, 8 ], [ 76, 11 ], [ 15, 14 ], [ 68, 17 ], [ 73, 19 ], [ 73, 28 ], [ 70, 30 ], [ 62, 36 ], [ 80, 36 ], [ 74, 37 ], [ 77, 41 ], [ 59, 41 ], [ 65, 42 ], [ 79, 44 ], [ 71, 46 ], [ 74, 47 ], [ 58, 48 ], [ 71, 50 ], [ 65, 51 ], [ 80, 55 ], [ 62, 55 ], [ 59, 56 ], [ 77, 56 ], [ 58, 59 ], [ 76, 62 ], [ 73, 65 ], [ 67, 68 ], [ 70, 71 ], [ 73, 74 ], [ 76, 77 ], [ 79, 80 ] ]

[ "N=int(input())\nt=a=1\nfor i in range(N):\n T,A=map(int,input().split())\n num=max(-(-t//T),-(-a//A))\n t,a=num*T,num*A\n\nprint(t + a)", "N=int(input())", "N", "int(input())", "int", "input()", "input", "t=a=1", "t", "1", "=a=1", "a", "1", "for i in range(N):\n T,A=map(int,input().split())\n num=max(-(-t//T),-(-a//A))\n t,a=num*T,num*A", "i", "range(N)", "range", "N", "T,A=map(int,input().split())", "T", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "A", "num=max(-(-t//T),-(-a//A))", "num", "max(-(-t//T),-(-a//A))", "max", "-(-t//T)", "-t//T", "-t", "t", "T", "-(-a//A)", "-a//A", "-a", "a", "A", "t,a=num*T,num*A", "t", "num*T", "num", "T", "a", "num*A", "num", "A", "print(t + a)", "print", "t + a", "t", "a", "a=num*T,num*A", "num*A", "a", "t=a=1", "1", "t", "A=map(int,input().split())", "map(int,input().split())", "A", "N=int(input())", "int(input())", "N", "num=max(-(-t//T),-(-a//A))", "max(-(-t//T),-(-a//A))", "num", "T,A=map(int,input().split())", "map(int,input().split())", "T", "a=1", "1", "a", "t,a=num*T,num*A", "num*T", "t" ]

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

[ [ 8, 4 ], [ 102, 10 ], [ 18, 17 ], [ 103, 20 ], [ 96, 33 ], [ 93, 36 ], [ 105, 39 ], [ 43, 42 ], [ 103, 45 ], [ 99, 47 ], [ 97, 49 ], [ 42, 50 ], [ 99, 51 ], [ 108, 53 ], [ 94, 61 ], [ 112, 61 ], [ 91, 64 ], [ 106, 70 ], [ 115, 70 ], [ 100, 73 ], [ 111, 75 ], [ 109, 77 ], [ 91, 78 ], [ 114, 80 ], [ 109, 82 ], [ 100, 83 ], [ 112, 87 ], [ 94, 87 ], [ 115, 88 ], [ 106, 88 ], [ 99, 91 ], [ 93, 94 ], [ 96, 97 ], [ 99, 100 ], [ 102, 103 ], [ 105, 106 ], [ 108, 109 ], [ 111, 112 ], [ 114, 115 ] ]

[ "from math import ceil\nfrom decimal import Decimal, getcontext\ngetcontext().prec = 100\nN = int(input())\nTA = [tuple(map(int, input().split())) for _ in range(N)]\n\nT = 1\nA = 1\nfor i in range(N):\n x, y = TA[i]\n n = max(ceil(Decimal(T)/Decimal(x)), ceil(Decimal(A)/Decimal(y)))\n T = n*x\n A = n*y\nprint(T+A)", "from math import ceil", "from decimal import Decimal, getcontext", "getcontext().prec = 100", "getcontext().prec", "()", "getcontext", "prec", "100", "N = int(input())", "N", "int(input())", "int", "input()", "input", "tuple(map(int, input().split())) for _ in range(N)", "for _ in range(N)", "_", "range(N)", "range", "N", "for _ in range(N)", "tuple(map(int, input().split()))", "tuple", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "TA = [tuple(map(int, input().split())) for _ in range(N)]", "TA", "[tuple(map(int, input().split())) for _ in range(N)]", "T = 1", "T", "1", "A = 1", "A", "1", "for i in range(N):\n x, y = TA[i]\n n = max(ceil(Decimal(T)/Decimal(x)), ceil(Decimal(A)/Decimal(y)))\n T = n*x\n A = n*y", "i", "range(N)", "range", "N", "x, y = TA[i]", "x", "TA[i]", "TA", "i", "y", "n = max(ceil(Decimal(T)/Decimal(x)), ceil(Decimal(A)/Decimal(y)))", "n", "max(ceil(Decimal(T)/Decimal(x)), ceil(Decimal(A)/Decimal(y)))", "max", "ceil(Decimal(T)/Decimal(x))", "ceil", "Decimal(T)/Decimal(x)", "Decimal(T)", "Decimal", "T", "Decimal(x)", "Decimal", "x", "ceil(Decimal(A)/Decimal(y))", "ceil", "Decimal(A)/Decimal(y)", "Decimal(A)", "Decimal", "A", "Decimal(y)", "Decimal", "y", "T = n*x", "T", "n*x", "n", "x", "A = n*y", "A", "n*y", "n", "y", "print(T+A)", "print", "T+A", "T", "A", "x, y = TA[i]", "TA[i]", "x", "T = 1", "1", "T", "TA = [tuple(map(int, input().split())) for _ in range(N)]", "[tuple(map(int, input().split())) for _ in range(N)]", "TA", "y = TA[i]", "TA[i]", "y", "N = int(input())", "int(input())", "N", "A = 1", "1", "A", "n = max(ceil(Decimal(T)/Decimal(x)), ceil(Decimal(A)/Decimal(y)))", "max(ceil(Decimal(T)/Decimal(x)), ceil(Decimal(A)/Decimal(y)))", "n", "T = n*x", "n*x", "T", "A = n*y", "n*y", "A" ]

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

[ [ 96, 11 ], [ 108, 17 ], [ 102, 19 ], [ 23, 22 ], [ 97, 25 ], [ 99, 27 ], [ 99, 36 ], [ 109, 40 ], [ 118, 40 ], [ 94, 40 ], [ 88, 41 ], [ 100, 43 ], [ 103, 44 ], [ 115, 44 ], [ 106, 44 ], [ 111, 46 ], [ 109, 50 ], [ 118, 50 ], [ 94, 50 ], [ 100, 51 ], [ 100, 53 ], [ 93, 55 ], [ 112, 57 ], [ 91, 57 ], [ 100, 58 ], [ 105, 59 ], [ 112, 61 ], [ 91, 61 ], [ 88, 62 ], [ 90, 64 ], [ 103, 68 ], [ 115, 68 ], [ 106, 68 ], [ 88, 69 ], [ 88, 71 ], [ 117, 73 ], [ 91, 75 ], [ 112, 75 ], [ 100, 76 ], [ 114, 77 ], [ 91, 79 ], [ 112, 79 ], [ 88, 80 ], [ 118, 84 ], [ 94, 84 ], [ 109, 84 ], [ 115, 85 ], [ 106, 85 ], [ 103, 85 ], [ 99, 88 ], [ 90, 91 ], [ 93, 94 ], [ 96, 97 ], [ 99, 100 ], [ 102, 103 ], [ 105, 106 ], [ 108, 109 ], [ 111, 112 ], [ 114, 115 ], [ 117, 118 ] ]

[ "import sys\nimport heapq, math\nfrom itertools import zip_longest, permutations, combinations, combinations_with_replacement\nfrom itertools import accumulate, dropwhile, takewhile, groupby\nfrom functools import lru_cache\nfrom copy import deepcopy\n\nN = int(input())\n\nA, B = 1, 1\n\nfor i in range(N):\n XA, XB = map(int, input().split())\n\n if A * XB > XA * B:\n d = (A + XA - 1) // XA\n A, B = d * XA, d * XB\n else:\n d = (B + XB - 1) // XB\n A, B = d * XA, d * XB\n\nprint(A + B)", "import sys", "sys", "import heapq, math", "heapq", "math", "from itertools import zip_longest, permutations, combinations, combinations_with_replacement", "from itertools import accumulate, dropwhile, takewhile, groupby", "from functools import lru_cache", "from copy import deepcopy", "N = int(input())", "N", "int(input())", "int", "input()", "input", "A, B = 1, 1", "A", "1", "B", "1", "for i in range(N):\n XA, XB = map(int, input().split())\n\n if A * XB > XA * B:\n d = (A + XA - 1) // XA\n A, B = d * XA, d * XB\n else:\n d = (B + XB - 1) // XB\n A, B = d * XA, d * XB", "i", "range(N)", "range", "N", "XA, XB = map(int, input().split())", "XA", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "XB", "if A * XB > XA * B:\n d = (A + XA - 1) // XA\n A, B = d * XA, d * XB\n else:\n d = (B + XB - 1) // XB\n A, B = d * XA, d * XB", "A * XB > XA * B", "A * XB", "A", "XB", "XA * B", "XA", "B", "d = (A + XA - 1) // XA", "d", "(A + XA - 1) // XA", "A + XA - 1", "A + XA", "A", "XA", "1", "XA", "A, B = d * XA, d * XB", "A", "d * XA", "d", "XA", "B", "d * XB", "d", "XB", "d = (B + XB - 1) // XB", "d", "(B + XB - 1) // XB", "B + XB - 1", "B + XB", "B", "XB", "1", "XB", "A, B = d * XA, d * XB", "A", "d * XA", "d", "XA", "B", "d * XB", "d", "XB", "print(A + B)", "print", "A + B", "A", "B", "XB = map(int, input().split())", "map(int, input().split())", "XB", "d = (B + XB - 1) // XB", "(B + XB - 1) // XB", "d", "A, B = d * XA, d * XB", "d * XA", "A", "N = int(input())", "int(input())", "N", "XA, XB = map(int, input().split())", "map(int, input().split())", "XA", "B = 1, 1", "1", "B", "B = d * XA, d * XB", "d * XB", "B", "A, B = 1, 1", "1", "A", "d = (A + XA - 1) // XA", "(A + XA - 1) // XA", "d", "B = d * XA, d * XB", "d * XB", "B", "A, B = d * XA, d * XB", "d * XA", "A" ]

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

[ [ 76, 2 ], [ 79, 8 ], [ 67, 11 ], [ 15, 14 ], [ 77, 17 ], [ 85, 19 ], [ 85, 28 ], [ 70, 30 ], [ 80, 37 ], [ 71, 37 ], [ 83, 38 ], [ 68, 42 ], [ 74, 42 ], [ 86, 43 ], [ 83, 44 ], [ 73, 46 ], [ 71, 53 ], [ 80, 53 ], [ 83, 54 ], [ 68, 58 ], [ 74, 58 ], [ 86, 59 ], [ 86, 60 ], [ 71, 64 ], [ 80, 64 ], [ 74, 65 ], [ 68, 65 ], [ 67, 68 ], [ 70, 71 ], [ 73, 74 ], [ 76, 77 ], [ 79, 80 ], [ 85, 83 ], [ 85, 86 ] ]

[ "N = int(input())\nT=1\nA=1\nfor i in range(N):\n t,a = map(int,input().split())\n T = max(-(-T//t),-(-A//a))*t\n A = max(-(-T//t),-(-A//a))*a\nprint(T+A)", "N = int(input())", "N", "int(input())", "int", "input()", "input", "T=1", "T", "1", "A=1", "A", "1", "for i in range(N):\n t,a = map(int,input().split())\n T = max(-(-T//t),-(-A//a))*t\n A = max(-(-T//t),-(-A//a))*a", "i", "range(N)", "range", "N", "t,a = map(int,input().split())", "t", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "a", "T = max(-(-T//t),-(-A//a))*t", "T", "max(-(-T//t),-(-A//a))*t", "max(-(-T//t),-(-A//a))", "max", "-(-T//t)", "-T//t", "-T", "T", "t", "-(-A//a)", "-A//a", "-A", "A", "a", "t", "A = max(-(-T//t),-(-A//a))*a", "A", "max(-(-T//t),-(-A//a))*a", "max(-(-T//t),-(-A//a))", "max", "-(-T//t)", "-T//t", "-T", "T", "t", "-(-A//a)", "-A//a", "-A", "A", "a", "a", "print(T+A)", "print", "T+A", "T", "A", "A=1", "1", "A", "T = max(-(-T//t),-(-A//a))*t", "max(-(-T//t),-(-A//a))*t", "T", "A = max(-(-T//t),-(-A//a))*a", "max(-(-T//t),-(-A//a))*a", "A", "N = int(input())", "int(input())", "N", "T=1", "1", "T", "t,a = map(int,input().split())", "map(int,input().split())", "t", "a = map(int,input().split())", "map(int,input().split())", "a" ]

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

[ [ 93, 2 ], [ 87, 8 ], [ 90, 10 ], [ 14, 13 ], [ 94, 16 ], [ 96, 18 ], [ 96, 27 ], [ 72, 29 ], [ 88, 33 ], [ 100, 33 ], [ 76, 33 ], [ 97, 34 ], [ 84, 36 ], [ 91, 40 ], [ 103, 40 ], [ 82, 40 ], [ 79, 41 ], [ 73, 44 ], [ 85, 45 ], [ 75, 47 ], [ 97, 49 ], [ 73, 50 ], [ 81, 52 ], [ 79, 54 ], [ 73, 55 ], [ 99, 57 ], [ 97, 59 ], [ 85, 60 ], [ 102, 62 ], [ 79, 64 ], [ 85, 65 ], [ 100, 69 ], [ 76, 69 ], [ 88, 69 ], [ 103, 70 ], [ 82, 70 ], [ 91, 70 ], [ 72, 73 ], [ 75, 76 ], [ 96, 79 ], [ 81, 82 ], [ 84, 85 ], [ 87, 88 ], [ 90, 91 ], [ 93, 94 ], [ 96, 97 ], [ 99, 100 ], [ 102, 103 ] ]

[ "n = int(input())\nx, y = 1, 1\n\nfor i in range(n):\n t, a = map(int, input().split())\n\n l = -(-x // t)\n r = -(-y // a)\n if l > r:\n x = t * l\n y = a * l\n else:\n x = t * r\n y = a * r\n\n #print(x, y)\n\nprint(x + y)", "n = int(input())", "n", "int(input())", "int", "input()", "input", "x, y = 1, 1", "x", "1", "y", "1", "for i in range(n):\n t, a = map(int, input().split())\n\n l = -(-x // t)\n r = -(-y // a)\n if l > r:\n x = t * l\n y = a * l\n else:\n x = t * r\n y = a * r\n\n #print(x, y)", "i", "range(n)", "range", "n", "t, a = map(int, input().split())", "t", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "a", "l = -(-x // t)", "l", "-(-x // t)", "-x // t", "-x", "x", "t", "r = -(-y // a)", "r", "-(-y // a)", "-y // a", "-y", "y", "a", "if l > r:\n x = t * l\n y = a * l\n else:\n x = t * r\n y = a * r\n\n #print(x, y)", "l > r", "l", "r", "x = t * l", "x", "t * l", "t", "l", "y = a * l", "y", "a * l", "a", "l", "x = t * r", "x", "t * r", "t", "r", "y = a * r", "y", "a * r", "a", "r", "print(x + y)", "print", "x + y", "x", "y", "l = -(-x // t)", "-(-x // t)", "l", "x = t * l", "t * l", "x", "a = map(int, input().split())", "map(int, input().split())", "a", "y = a * l", "a * l", "y", "r = -(-y // a)", "-(-y // a)", "r", "x, y = 1, 1", "1", "x", "y = 1, 1", "1", "y", "n = int(input())", "int(input())", "n", "t, a = map(int, input().split())", "map(int, input().split())", "t", "x = t * r", "t * r", "x", "y = a * r", "a * r", "y" ]

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

[ [ 107, 20 ], [ 104, 26 ], [ 113, 28 ], [ 32, 31 ], [ 108, 34 ], [ 119, 36 ], [ 119, 45 ], [ 105, 49 ], [ 99, 49 ], [ 111, 49 ], [ 114, 52 ], [ 117, 52 ], [ 96, 52 ], [ 110, 55 ], [ 93, 56 ], [ 95, 57 ], [ 120, 58 ], [ 101, 60 ], [ 105, 71 ], [ 99, 71 ], [ 111, 71 ], [ 93, 72 ], [ 114, 75 ], [ 117, 75 ], [ 96, 75 ], [ 120, 76 ], [ 98, 78 ], [ 93, 80 ], [ 102, 81 ], [ 116, 82 ], [ 120, 84 ], [ 102, 85 ], [ 99, 89 ], [ 111, 89 ], [ 105, 89 ], [ 117, 90 ], [ 96, 90 ], [ 114, 90 ], [ 119, 93 ], [ 120, 95 ], [ 95, 96 ], [ 98, 99 ], [ 101, 102 ], [ 104, 105 ], [ 107, 108 ], [ 93, 110 ], [ 110, 111 ], [ 113, 114 ], [ 116, 117 ], [ 119, 120 ] ]

[ "import math\nimport numpy as np\nfrom fractions import gcd\nimport fractions\nimport statistics\nimport collections\nfrom functools import reduce\nimport itertools\nfrom collections import defaultdict\nimport bisect\nfrom fractions import Fraction\n \nN = int(input())\nca, cb = 0, 0\nfor _ in range(N):\n a, b = map(int, input().split())\n if ca == 0 and cb == 0:\n ca, cb = a, b\n else:\n r = int(math.ceil(max(Fraction(ca, a), Fraction(cb,b))))\n ca, cb = a*r, b*r\n\nprint (ca + cb)", "import math", "math", "import numpy as np", "numpy", "from fractions import gcd", "import fractions", "fractions", "import statistics", "statistics", "import collections", "collections", "from functools import reduce", "import itertools", "itertools", "from collections import defaultdict", "import bisect", "bisect", "from fractions import Fraction", "N = int(input())", "N", "int(input())", "int", "input()", "input", "ca, cb = 0, 0", "ca", "0", "cb", "0", "for _ in range(N):\n a, b = map(int, input().split())\n if ca == 0 and cb == 0:\n ca, cb = a, b\n else:\n r = int(math.ceil(max(Fraction(ca, a), Fraction(cb,b))))\n ca, cb = a*r, b*r", "_", "range(N)", "range", "N", "a, b = map(int, input().split())", "a", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "if ca == 0 and cb == 0:\n ca, cb = a, b\n else:\n r = int(math.ceil(max(Fraction(ca, a), Fraction(cb,b))))\n ca, cb = a*r, b*r", "ca == 0 and cb == 0", "ca == 0", "ca", "0", "cb == 0", "cb", "0", "ca, cb = a, b", "ca", "a", "cb", "b", "r = int(math.ceil(max(Fraction(ca, a), Fraction(cb,b))))", "r", "int(math.ceil(max(Fraction(ca, a), Fraction(cb,b))))", "int", "math.ceil(max(Fraction(ca, a), Fraction(cb,b)))", "math.ceil", "math", "ceil", "max(Fraction(ca, a), Fraction(cb,b))", "max", "Fraction(ca, a)", "Fraction", "ca", "a", "Fraction(cb,b)", "Fraction", "cb", "b", "ca, cb = a*r, b*r", "ca", "a*r", "a", "r", "cb", "b*r", "b", "r", "print (ca + cb)", "print", "ca + cb", "ca", "cb", "a, b = map(int, input().split())", "map(int, input().split())", "a", "cb = a, b", "b", "cb", "ca, cb = a*r, b*r", "a*r", "ca", "r = int(math.ceil(max(Fraction(ca, a), Fraction(cb,b))))", "int(math.ceil(max(Fraction(ca, a), Fraction(cb,b))))", "r", "ca, cb = 0, 0", "0", "ca", "N = int(input())", "int(input())", "N", "ca, cb = a, b", "a", "ca", "cb = 0, 0", "0", "cb", "cb = a*r, b*r", "b*r", "cb", "b = map(int, input().split())", "map(int, input().split())", "b" ]

[ 7, 0, 13, 4, 13, 4, 13, 0, 13, 2, 39, 17, 13, 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, 0, 13, 17, 0, 13, 17, 28, 13, 4, 13, 13, 0, 13, 4, 13, 40, 2, 40, 13, 18, 13, 13, 40, 2, 40, 13, 18, 13, 13, 0, 13, 2, 13, 18, 13, 13, 0, 13, 2, 13, 18, 13, 13, 4, 13, 2, 13, 13, 10, 4, 13, 10, 2, 13, 10, 17, 13, 10, 4, 13, 10, 2, 13, 10, 17, 13, 10, 2, 13, 10, 2, 13 ]

[ [ 87, 2 ], [ 99, 8 ], [ 88, 12 ], [ 105, 13 ], [ 88, 17 ], [ 20, 19 ], [ 88, 22 ], [ 27, 24 ], [ 100, 25 ], [ 19, 26 ], [ 27, 35 ], [ 106, 36 ], [ 19, 37 ], [ 102, 39 ], [ 102, 42 ], [ 46, 45 ], [ 88, 48 ], [ 96, 50 ], [ 103, 56 ], [ 109, 56 ], [ 24, 57 ], [ 100, 58 ], [ 45, 59 ], [ 94, 63 ], [ 91, 63 ], [ 35, 64 ], [ 106, 65 ], [ 45, 66 ], [ 108, 68 ], [ 97, 70 ], [ 24, 71 ], [ 100, 72 ], [ 45, 73 ], [ 90, 75 ], [ 97, 77 ], [ 35, 78 ], [ 106, 79 ], [ 45, 80 ], [ 109, 84 ], [ 103, 84 ], [ 91, 85 ], [ 94, 85 ], [ 87, 88 ], [ 90, 91 ], [ 102, 94 ], [ 96, 97 ], [ 99, 100 ], [ 102, 103 ], [ 105, 106 ], [ 108, 109 ] ]

[ "N = int(input())\nT, A = [0]*N, [0]*N\n\nfor i in range(N):\n T[i], A[i] = map(int, input().split())\nt = a = 1\nfor i in range(N):\n n = max(-(-t//T[i]), -(-a//A[i]))\n t = n*T[i]\n a = n*A[i]\nprint(t+a)", "N = int(input())", "N", "int(input())", "int", "input()", "input", "T, A = [0]*N, [0]*N", "T", "[0]*N", "[0]", "0", "N", "A", "[0]*N", "[0]", "0", "N", "for i in range(N):\n T[i], A[i] = map(int, input().split())", "i", "range(N)", "range", "N", "T[i], A[i] = map(int, input().split())", "T[i]", "T", "i", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "A[i]", "A", "i", "t = a = 1", "t", "1", "= a = 1", "a", "1", "for i in range(N):\n n = max(-(-t//T[i]), -(-a//A[i]))\n t = n*T[i]\n a = n*A[i]", "i", "range(N)", "range", "N", "n = max(-(-t//T[i]), -(-a//A[i]))", "n", "max(-(-t//T[i]), -(-a//A[i]))", "max", "-(-t//T[i])", "-t//T[i]", "-t", "t", "T[i]", "T", "i", "-(-a//A[i])", "-a//A[i]", "-a", "a", "A[i]", "A", "i", "t = n*T[i]", "t", "n*T[i]", "n", "T[i]", "T", "i", "a = n*A[i]", "a", "n*A[i]", "n", "A[i]", "A", "i", "print(t+a)", "print", "t+a", "t", "a", "N = int(input())", "int(input())", "N", "a = n*A[i]", "n*A[i]", "a", "a = 1", "1", "a", "n = max(-(-t//T[i]), -(-a//A[i]))", "max(-(-t//T[i]), -(-a//A[i]))", "n", "T, A = [0]*N, [0]*N", "[0]*N", "T", "t = a = 1", "1", "t", "A = [0]*N, [0]*N", "[0]*N", "A", "t = n*T[i]", "n*T[i]", "t" ]

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

[ [ 6, 5 ], [ 11, 10 ], [ 5, 14 ], [ 17, 16 ], [ 10, 19 ], [ 16, 22 ], [ 26, 25 ], [ 5, 32 ], [ 26, 34 ], [ 37, 36 ], [ 5, 43 ], [ 37, 45 ], [ 48, 47 ], [ 71, 51 ], [ 25, 51 ], [ 36, 52 ], [ 36, 54 ], [ 57, 56 ], [ 76, 60 ], [ 34, 60 ], [ 45, 61 ], [ 45, 63 ], [ 66, 65 ], [ 47, 68 ], [ 56, 69 ], [ 72, 71 ], [ 36, 73 ], [ 65, 74 ], [ 77, 76 ], [ 45, 78 ], [ 65, 79 ], [ 76, 83 ], [ 34, 83 ], [ 71, 84 ], [ 25, 84 ], [ 93, 90 ] ]

[ "from sys import stdin\ndef main():\n #入力\n readline=stdin.readline\n n=int(readline())\n for i in range(n):\n if i==0:\n t,a=map(int,readline().split())\n else:\n t_i,a_i=map(int,readline().split())\n tmp1=(t+t_i-1)//t_i\n tmp2=(a+a_i-1)//a_i\n x=max(tmp1,tmp2)\n t=t_i*x\n a=a_i*x\n \n print(a+t)\n\nif __name__==\"__main__\":\n main()", "from sys import stdin", "def main():\n #入力\n readline=stdin.readline\n n=int(readline())\n for i in range(n):\n if i==0:\n t,a=map(int,readline().split())\n else:\n t_i,a_i=map(int,readline().split())\n tmp1=(t+t_i-1)//t_i\n tmp2=(a+a_i-1)//a_i\n x=max(tmp1,tmp2)\n t=t_i*x\n a=a_i*x\n \n print(a+t)", "main", "readline=stdin.readline", "readline", "stdin.readline", "stdin", "readline", "n=int(readline())", "n", "int(readline())", "int", "readline()", "readline", "for i in range(n):\n if i==0:\n t,a=map(int,readline().split())\n else:\n t_i,a_i=map(int,readline().split())\n tmp1=(t+t_i-1)//t_i\n tmp2=(a+a_i-1)//a_i\n x=max(tmp1,tmp2)\n t=t_i*x\n a=a_i*x\n \n ", "i", "range(n)", "range", "n", "if i==0:\n t,a=map(int,readline().split())\n else:\n t_i,a_i=map(int,readline().split())\n tmp1=(t+t_i-1)//t_i\n tmp2=(a+a_i-1)//a_i\n x=max(tmp1,tmp2)\n t=t_i*x\n a=a_i*x\n \n ", "i==0", "i", "0", "t,a=map(int,readline().split())", "t", "map(int,readline().split())", "map", "int", "readline().split()", "().split", "()", "readline", "split", "a", "t_i,a_i=map(int,readline().split())", "t_i", "map(int,readline().split())", "map", "int", "readline().split()", "().split", "()", "readline", "split", "a_i", "tmp1=(t+t_i-1)//t_i", "tmp1", "(t+t_i-1)//t_i", "t+t_i-1", "t+t_i", "t", "t_i", "1", "t_i", "tmp2=(a+a_i-1)//a_i", "tmp2", "(a+a_i-1)//a_i", "a+a_i-1", "a+a_i", "a", "a_i", "1", "a_i", "x=max(tmp1,tmp2)", "x", "max(tmp1,tmp2)", "max", "tmp1", "tmp2", "t=t_i*x", "t", "t_i*x", "t_i", "x", "a=a_i*x", "a", "a_i*x", "a_i", "x", "print(a+t)", "print", "a+t", "a", "t", "if __name__==\"__main__\":\n main()", "__name__==\"__main__\"", "__name__", "\"__main__\"", "main()", "main", "def main():\n #入力\n readline=stdin.readline\n n=int(readline())\n for i in range(n):\n if i==0:\n t,a=map(int,readline().split())\n else:\n t_i,a_i=map(int,readline().split())\n tmp1=(t+t_i-1)//t_i\n tmp2=(a+a_i-1)//a_i\n x=max(tmp1,tmp2)\n t=t_i*x\n a=a_i*x\n \n print(a+t)", "def main():\n #入力\n readline=stdin.readline\n n=int(readline())\n for i in range(n):\n if i==0:\n t,a=map(int,readline().split())\n else:\n t_i,a_i=map(int,readline().split())\n tmp1=(t+t_i-1)//t_i\n tmp2=(a+a_i-1)//a_i\n x=max(tmp1,tmp2)\n t=t_i*x\n a=a_i*x\n \n print(a+t)", "main" ]

[ 7, 0, 13, 4, 13, 4, 13, 0, 13, 2, 39, 17, 13, 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, 13, 13, 18, 13, 13, 13, 14, 2, 13, 17, 4, 13, 2, 18, 13, 17, 18, 13, 17, 28, 13, 4, 13, 17, 13, 28, 13, 4, 13, 4, 13, 2, 18, 13, 2, 13, 17, 18, 13, 13, 2, 18, 13, 2, 13, 17, 18, 13, 13, 2, 17, 17, 14, 2, 40, 2, 18, 13, 13, 13, 18, 13, 2, 13, 17, 40, 2, 18, 13, 13, 13, 18, 13, 2, 13, 17, 0, 18, 13, 13, 2, 18, 13, 13, 13, 18, 13, 13, 2, 18, 13, 13, 13, 3, 4, 13, 2, 18, 13, 2, 13, 17, 18, 13, 2, 13, 17, 10, 2, 13, 10, 4, 13, 10, 2, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 149, 2 ], [ 152, 8 ], [ 150, 12 ], [ 146, 14 ], [ 150, 18 ], [ 21, 20 ], [ 150, 23 ], [ 158, 25 ], [ 158, 34 ], [ 39, 36 ], [ 153, 37 ], [ 20, 38 ], [ 156, 39 ], [ 43, 40 ], [ 147, 41 ], [ 20, 42 ], [ 159, 43 ], [ 150, 46 ], [ 153, 52 ], [ 147, 55 ], [ 59, 58 ], [ 150, 62 ], [ 65, 64 ], [ 153, 71 ], [ 58, 73 ], [ 36, 75 ], [ 115, 75 ], [ 153, 76 ], [ 58, 77 ], [ 147, 80 ], [ 58, 82 ], [ 40, 84 ], [ 123, 84 ], [ 147, 85 ], [ 58, 86 ], [ 36, 94 ], [ 115, 94 ], [ 153, 95 ], [ 58, 96 ], [ 64, 97 ], [ 153, 99 ], [ 58, 101 ], [ 40, 105 ], [ 123, 105 ], [ 147, 106 ], [ 58, 107 ], [ 64, 108 ], [ 147, 110 ], [ 58, 112 ], [ 118, 115 ], [ 153, 116 ], [ 58, 117 ], [ 36, 119 ], [ 115, 119 ], [ 153, 120 ], [ 58, 121 ], [ 64, 122 ], [ 126, 123 ], [ 147, 124 ], [ 58, 125 ], [ 40, 127 ], [ 123, 127 ], [ 147, 128 ], [ 58, 129 ], [ 64, 130 ], [ 153, 136 ], [ 150, 138 ], [ 147, 141 ], [ 150, 143 ], [ 146, 147 ], [ 149, 150 ], [ 152, 153 ], [ 158, 156 ], [ 158, 159 ] ]

[ "n = int(input())\nt = [0] * n\na = [0] * n\nfor i in range(n):\n tt, aa = map(int, input().split())\n t[i], a[i] = tt, aa\n\nif n == 1:\n print(t[0]+a[0])\nelse:\n for i in range(1, n):\n for j in range(max(t[i-1]//t[i], a[i-1]//a[i]), 10**18):\n if t[i]*j >= t[i-1] and a[i]*j >= a[i-1]:\n t[i], a[i] = t[i] * j, a[i] * j\n break\n print(t[n-1]+a[n-1])", "n = int(input())", "n", "int(input())", "int", "input()", "input", "t = [0] * n", "t", "[0] * n", "[0]", "0", "n", "a = [0] * n", "a", "[0] * n", "[0]", "0", "n", "for i in range(n):\n tt, aa = map(int, input().split())\n t[i], a[i] = tt, aa", "i", "range(n)", "range", "n", "tt, aa = map(int, input().split())", "tt", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "aa", "t[i], a[i] = tt, aa", "t[i]", "t", "i", "tt", "a[i]", "a", "i", "aa", "if n == 1:\n print(t[0]+a[0])\nelse:\n for i in range(1, n):\n for j in range(max(t[i-1]//t[i], a[i-1]//a[i]), 10**18):\n if t[i]*j >= t[i-1] and a[i]*j >= a[i-1]:\n t[i], a[i] = t[i] * j, a[i] * j\n break\n print(t[n-1]+a[n-1])", "n == 1", "n", "1", "print(t[0]+a[0])", "print", "t[0]+a[0]", "t[0]", "t", "0", "a[0]", "a", "0", "for i in range(1, n):\n for j in range(max(t[i-1]//t[i], a[i-1]//a[i]), 10**18):\n if t[i]*j >= t[i-1] and a[i]*j >= a[i-1]:\n t[i], a[i] = t[i] * j, a[i] * j\n break\n ", "i", "range(1, n)", "range", "1", "n", "for j in range(max(t[i-1]//t[i], a[i-1]//a[i]), 10**18):\n if t[i]*j >= t[i-1] and a[i]*j >= a[i-1]:\n t[i], a[i] = t[i] * j, a[i] * j\n break\n ", "j", "range(max(t[i-1]//t[i], a[i-1]//a[i]), 10**18)", "range", "max(t[i-1]//t[i], a[i-1]//a[i])", "max", "t[i-1]//t[i]", "t[i-1]", "t", "i-1", "i", "1", "t[i]", "t", "i", "a[i-1]//a[i]", "a[i-1]", "a", "i-1", "i", "1", "a[i]", "a", "i", "10**18", "10", "18", "if t[i]*j >= t[i-1] and a[i]*j >= a[i-1]:\n t[i], a[i] = t[i] * j, a[i] * j\n break\n ", "t[i]*j >= t[i-1] and a[i]*j >= a[i-1]", "t[i]*j >= t[i-1]", "t[i]*j", "t[i]", "t", "i", "j", "t[i-1]", "t", "i-1", "i", "1", "a[i]*j >= a[i-1]", "a[i]*j", "a[i]", "a", "i", "j", "a[i-1]", "a", "i-1", "i", "1", "t[i], a[i] = t[i] * j, a[i] * j", "t[i]", "t", "i", "t[i] * j", "t[i]", "t", "i", "j", "a[i]", "a", "i", "a[i] * j", "a[i]", "a", "i", "j", "break", "print(t[n-1]+a[n-1])", "print", "t[n-1]+a[n-1]", "t[n-1]", "t", "n-1", "n", "1", "a[n-1]", "a", "n-1", "n", "1", "a = [0] * n", "[0] * n", "a", "n = int(input())", "int(input())", "n", "t = [0] * n", "[0] * n", "t", "tt, aa = map(int, input().split())", "map(int, input().split())", "tt", "aa = map(int, input().split())", "map(int, input().split())", "aa" ]

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

[ [ 82, 2 ], [ 70, 8 ], [ 61, 10 ], [ 14, 13 ], [ 83, 16 ], [ 79, 18 ], [ 79, 27 ], [ 64, 29 ], [ 68, 35 ], [ 71, 36 ], [ 77, 36 ], [ 68, 38 ], [ 80, 42 ], [ 62, 43 ], [ 74, 43 ], [ 80, 45 ], [ 76, 47 ], [ 68, 49 ], [ 65, 50 ], [ 73, 51 ], [ 80, 53 ], [ 65, 54 ], [ 77, 58 ], [ 71, 58 ], [ 74, 59 ], [ 62, 59 ], [ 61, 62 ], [ 64, 65 ], [ 79, 68 ], [ 70, 71 ], [ 73, 74 ], [ 76, 77 ], [ 79, 80 ], [ 82, 83 ] ]

[ "N = int(input())\n\na, b = 1, 1\nfor i in range(N):\n T, A = map(int, input().split())\n mult = max((T+a-1)//T, (A+b-1)//A)\n a, b = T * mult, A * mult\n \nprint(a+b)", "N = int(input())", "N", "int(input())", "int", "input()", "input", "a, b = 1, 1", "a", "1", "b", "1", "for i in range(N):\n T, A = map(int, input().split())\n mult = max((T+a-1)//T, (A+b-1)//A)\n a, b = T * mult, A * mult\n ", "i", "range(N)", "range", "N", "T, A = map(int, input().split())", "T", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "A", "mult = max((T+a-1)//T, (A+b-1)//A)", "mult", "max((T+a-1)//T, (A+b-1)//A)", "max", "(T+a-1)//T", "T+a-1", "T+a", "T", "a", "1", "T", "(A+b-1)//A", "A+b-1", "A+b", "A", "b", "1", "A", "a, b = T * mult, A * mult", "a", "T * mult", "T", "mult", "b", "A * mult", "A", "mult", "print(a+b)", "print", "a+b", "a", "b", "b = 1, 1", "1", "b", "mult = max((T+a-1)//T, (A+b-1)//A)", "max((T+a-1)//T, (A+b-1)//A)", "mult", "T, A = map(int, input().split())", "map(int, input().split())", "T", "a, b = 1, 1", "1", "a", "b = T * mult, A * mult", "A * mult", "b", "a, b = T * mult, A * mult", "T * mult", "a", "A = map(int, input().split())", "map(int, input().split())", "A", "N = int(input())", "int(input())", "N" ]

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

[ [ 90, 2 ], [ 105, 8 ], [ 87, 11 ], [ 22, 19 ], [ 24, 20 ], [ 22, 22 ], [ 24, 24 ], [ 27, 26 ], [ 91, 29 ], [ 108, 31 ], [ 108, 40 ], [ 79, 44 ], [ 100, 44 ], [ 106, 45 ], [ 97, 45 ], [ 109, 47 ], [ 103, 47 ], [ 88, 48 ], [ 94, 48 ], [ 81, 50 ], [ 85, 54 ], [ 106, 55 ], [ 97, 55 ], [ 79, 56 ], [ 100, 56 ], [ 85, 58 ], [ 88, 59 ], [ 94, 59 ], [ 109, 60 ], [ 103, 60 ], [ 99, 62 ], [ 82, 63 ], [ 102, 65 ], [ 82, 66 ], [ 96, 68 ], [ 100, 69 ], [ 79, 69 ], [ 93, 70 ], [ 103, 71 ], [ 109, 71 ], [ 100, 75 ], [ 79, 75 ], [ 103, 76 ], [ 109, 76 ], [ 108, 79 ], [ 81, 82 ], [ 87, 88 ], [ 90, 91 ], [ 103, 93 ], [ 109, 93 ], [ 93, 94 ], [ 100, 96 ], [ 79, 96 ], [ 96, 97 ], [ 82, 99 ], [ 99, 100 ], [ 82, 102 ], [ 102, 103 ], [ 105, 106 ], [ 108, 109 ] ]

[ "# coding: utf-8\n# Your code here!\nN=int(input())\n\npre_T=0\npre_A=0\n\ndef krag(n,m):\n return -(-n//m)\n\n\nfor _ in range(N):\n T,A=map(int,input().split())\n \n if T<pre_T or A<pre_A:\n k=max(krag(pre_T,T),krag(pre_A,A))\n T*=k\n A*=k\n \n pre_T,pre_A=T,A \nprint(T+A)", "N=int(input())", "N", "int(input())", "int", "input()", "input", "pre_T=0", "pre_T", "0", "pre_A=0", "pre_A", "0", "def krag(n,m):\n return -(-n//m)", "krag", "return -(-n//m)", "-(-n//m)", "-n//m", "-n", "n", "m", "n", "n", "m", "m", "for _ in range(N):\n T,A=map(int,input().split())\n \n if T<pre_T or A<pre_A:\n k=max(krag(pre_T,T),krag(pre_A,A))\n T*=k\n A*=k\n \n pre_T,pre_A=T,A ", "_", "range(N)", "range", "N", "T,A=map(int,input().split())", "T", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "A", "if T<pre_T or A<pre_A:\n k=max(krag(pre_T,T),krag(pre_A,A))\n T*=k\n A*=k\n \n ", "T<pre_T or A<pre_A", "T<pre_T", "T", "pre_T", "A<pre_A", "A", "pre_A", "k=max(krag(pre_T,T),krag(pre_A,A))", "k", "max(krag(pre_T,T),krag(pre_A,A))", "max", "krag(pre_T,T)", "krag", "pre_T", "T", "krag(pre_A,A)", "krag", "pre_A", "A", "T*=k", "T", "k", "A*=k", "A", "k", "pre_T,pre_A=T,A", "pre_T", "T", "pre_A", "A", "print(T+A)", "print", "T+A", "T", "A", "T,A=map(int,input().split())", "map(int,input().split())", "T", "k=max(krag(pre_T,T),krag(pre_A,A))", "max(krag(pre_T,T),krag(pre_A,A))", "k", "def krag(n,m):\n return -(-n//m)", "def krag(n,m):\n return -(-n//m)", "krag", "pre_A=0", "0", "pre_A", "N=int(input())", "int(input())", "N", "pre_A=T,A", "A", "pre_A", "pre_T,pre_A=T,A", "T", "pre_T", "T*=k", "k", "T", "A*=k", "k", "A", "pre_T=0", "0", "pre_T", "A=map(int,input().split())", "map(int,input().split())", "A" ]

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

[ [ 212, 2 ], [ 10, 9 ], [ 213, 12 ], [ 221, 25 ], [ 233, 28 ], [ 222, 31 ], [ 203, 35 ], [ 222, 38 ], [ 45, 44 ], [ 213, 48 ], [ 234, 52 ], [ 192, 52 ], [ 195, 52 ], [ 222, 55 ], [ 44, 56 ], [ 204, 59 ], [ 231, 59 ], [ 201, 59 ], [ 222, 62 ], [ 44, 63 ], [ 194, 66 ], [ 222, 69 ], [ 44, 70 ], [ 200, 73 ], [ 222, 76 ], [ 44, 77 ], [ 215, 80 ], [ 218, 83 ], [ 234, 87 ], [ 192, 87 ], [ 195, 87 ], [ 222, 90 ], [ 44, 91 ], [ 234, 96 ], [ 192, 96 ], [ 195, 96 ], [ 222, 99 ], [ 44, 100 ], [ 206, 104 ], [ 234, 106 ], [ 192, 106 ], [ 195, 106 ], [ 222, 109 ], [ 44, 110 ], [ 224, 113 ], [ 234, 117 ], [ 192, 117 ], [ 195, 117 ], [ 222, 120 ], [ 44, 121 ], [ 201, 125 ], [ 204, 125 ], [ 231, 125 ], [ 222, 128 ], [ 44, 129 ], [ 201, 134 ], [ 204, 134 ], [ 231, 134 ], [ 222, 137 ], [ 44, 138 ], [ 227, 142 ], [ 201, 144 ], [ 204, 144 ], [ 231, 144 ], [ 222, 147 ], [ 44, 148 ], [ 197, 151 ], [ 201, 155 ], [ 204, 155 ], [ 231, 155 ], [ 222, 158 ], [ 44, 159 ], [ 209, 162 ], [ 225, 165 ], [ 207, 165 ], [ 216, 165 ], [ 198, 166 ], [ 228, 166 ], [ 219, 166 ], [ 191, 168 ], [ 210, 170 ], [ 222, 173 ], [ 44, 174 ], [ 230, 177 ], [ 210, 179 ], [ 222, 182 ], [ 44, 183 ], [ 192, 188 ], [ 195, 188 ], [ 234, 188 ], [ 231, 189 ], [ 201, 189 ], [ 204, 189 ], [ 191, 192 ], [ 194, 195 ], [ 197, 198 ], [ 200, 201 ], [ 203, 204 ], [ 206, 207 ], [ 209, 210 ], [ 212, 213 ], [ 215, 216 ], [ 218, 219 ], [ 221, 222 ], [ 224, 225 ], [ 227, 228 ], [ 230, 231 ], [ 233, 234 ] ]

[ "N=int(input())\nA=[list(map(int,input().split())) for i in range(N)]\na=A[0][0]\nb=A[0][1]\nimport fractions\nfor i in range(1,N):\n if a<=A[i][0] and b<=A[i][1]:\n a=A[i][0] \n b=A[i][1]\n else:\n aa=1\n bb=1\n if a>A[i][0]:\n if a%A[i][0]==0:\n aa=a//A[i][0]\n else:\n aa=1+a//A[i][0]\n if b>A[i][1]:\n if b%A[i][1]==0:\n bb=b//A[i][1]\n else:\n bb=1+b//A[i][1]\n c=max(aa,bb)\n a=c*A[i][0]\n b=c*A[i][1]\nprint(a+b)", "N=int(input())", "N", "int(input())", "int", "input()", "input", "list(map(int,input().split())) for i in range(N)", "for i in range(N)", "i", "range(N)", "range", "N", "for i in range(N)", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "A=[list(map(int,input().split())) for i in range(N)]", "A", "[list(map(int,input().split())) for i in range(N)]", "a=A[0][0]", "a", "A[0][0]", "[0]", "A", "0", "0", "b=A[0][1]", "b", "A[0][1]", "[0]", "A", "0", "1", "import fractions", "fractions", "for i in range(1,N):\n if a<=A[i][0] and b<=A[i][1]:\n a=A[i][0] \n b=A[i][1]\n else:\n aa=1\n bb=1\n if a>A[i][0]:\n if a%A[i][0]==0:\n aa=a//A[i][0]\n else:\n aa=1+a//A[i][0]\n if b>A[i][1]:\n if b%A[i][1]==0:\n bb=b//A[i][1]\n else:\n bb=1+b//A[i][1]\n c=max(aa,bb)\n a=c*A[i][0]\n b=c*A[i][1]", "i", "range(1,N)", "range", "1", "N", "if a<=A[i][0] and b<=A[i][1]:\n a=A[i][0] \n b=A[i][1]\n else:\n aa=1\n bb=1\n if a>A[i][0]:\n if a%A[i][0]==0:\n aa=a//A[i][0]\n else:\n aa=1+a//A[i][0]\n if b>A[i][1]:\n if b%A[i][1]==0:\n bb=b//A[i][1]\n else:\n bb=1+b//A[i][1]\n c=max(aa,bb)\n a=c*A[i][0]\n b=c*A[i][1]", "a<=A[i][0] and b<=A[i][1]", "a<=A[i][0]", "a", "A[i][0]", "[i]", "A", "i", "0", "b<=A[i][1]", "b", "A[i][1]", "[i]", "A", "i", "1", "a=A[i][0]", "a", "A[i][0]", "[i]", "A", "i", "0", "b=A[i][1]", "b", "A[i][1]", "[i]", "A", "i", "1", "aa=1", "aa", "1", "bb=1", "bb", "1", "if a>A[i][0]:\n if a%A[i][0]==0:\n aa=a//A[i][0]\n else:\n aa=1+a//A[i][0]\n ", "a>A[i][0]", "a", "A[i][0]", "[i]", "A", "i", "0", "if a%A[i][0]==0:\n aa=a//A[i][0]\n else:\n aa=1+a//A[i][0]\n ", "a%A[i][0]==0", "a%A[i][0]", "a", "A[i][0]", "[i]", "A", "i", "0", "0", "aa=a//A[i][0]", "aa", "a//A[i][0]", "a", "A[i][0]", "[i]", "A", "i", "0", "aa=1+a//A[i][0]", "aa", "1+a//A[i][0]", "1", "a//A[i][0]", "a", "A[i][0]", "[i]", "A", "i", "0", "if b>A[i][1]:\n if b%A[i][1]==0:\n bb=b//A[i][1]\n else:\n bb=1+b//A[i][1]\n ", "b>A[i][1]", "b", "A[i][1]", "[i]", "A", "i", "1", "if b%A[i][1]==0:\n bb=b//A[i][1]\n else:\n bb=1+b//A[i][1]\n ", "b%A[i][1]==0", "b%A[i][1]", "b", "A[i][1]", "[i]", "A", "i", "1", "0", "bb=b//A[i][1]", "bb", "b//A[i][1]", "b", "A[i][1]", "[i]", "A", "i", "1", "bb=1+b//A[i][1]", "bb", "1+b//A[i][1]", "1", "b//A[i][1]", "b", "A[i][1]", "[i]", "A", "i", "1", "c=max(aa,bb)", "c", "max(aa,bb)", "max", "aa", "bb", "a=c*A[i][0]", "a", "c*A[i][0]", "c", "A[i][0]", "[i]", "A", "i", "0", "b=c*A[i][1]", "b", "c*A[i][1]", "c", "A[i][1]", "[i]", "A", "i", "1", "print(a+b)", "print", "a+b", "a", "b", "a=c*A[i][0]", "c*A[i][0]", "a", "a=A[i][0]", "A[i][0]", "a", "bb=1+b//A[i][1]", "1+b//A[i][1]", "bb", "b=A[i][1]", "A[i][1]", "b", "b=A[0][1]", "A[0][1]", "b", "aa=a//A[i][0]", "a//A[i][0]", "aa", "c=max(aa,bb)", "max(aa,bb)", "c", "N=int(input())", "int(input())", "N", "aa=1", "1", "aa", "bb=1", "1", "bb", "A=[list(map(int,input().split())) for i in range(N)]", "[list(map(int,input().split())) for i in range(N)]", "A", "aa=1+a//A[i][0]", "1+a//A[i][0]", "aa", "bb=b//A[i][1]", "b//A[i][1]", "bb", "b=c*A[i][1]", "c*A[i][1]", "b", "a=A[0][0]", "A[0][0]", "a" ]

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

[ [ 78, 2 ], [ 69, 8 ], [ 69, 17 ], [ 20, 19 ], [ 79, 23 ], [ 87, 26 ], [ 87, 35 ], [ 84, 37 ], [ 70, 43 ], [ 82, 43 ], [ 76, 44 ], [ 67, 48 ], [ 73, 48 ], [ 88, 49 ], [ 81, 51 ], [ 85, 53 ], [ 76, 54 ], [ 72, 56 ], [ 85, 58 ], [ 88, 59 ], [ 82, 63 ], [ 70, 63 ], [ 73, 64 ], [ 67, 64 ], [ 69, 67 ], [ 69, 70 ], [ 72, 73 ], [ 87, 76 ], [ 78, 79 ], [ 81, 82 ], [ 84, 85 ], [ 87, 88 ] ]

[ "n = int(input())\nT, A = map(int, input().split())\n\nfor _ in range(n-1):\n t, a = map(int, input().split())\n x = max(-(-T//t), -(-A//a))\n T = x * t; A = x * a\nprint(T+A)", "n = int(input())", "n", "int(input())", "int", "input()", "input", "T, A = map(int, input().split())", "T", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "A", "for _ in range(n-1):\n t, a = map(int, input().split())\n x = max(-(-T//t), -(-A//a))\n T = x * t; A = x * a", "_", "range(n-1)", "range", "n-1", "n", "1", "t, a = map(int, input().split())", "t", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "a", "x = max(-(-T//t), -(-A//a))", "x", "max(-(-T//t), -(-A//a))", "max", "-(-T//t)", "-T//t", "-T", "T", "t", "-(-A//a)", "-A//a", "-A", "A", "a", "T = x * t", "T", "x * t", "x", "t", "A = x * a", "A", "x * a", "x", "a", "print(T+A)", "print", "T+A", "T", "A", "A = map(int, input().split())", "map(int, input().split())", "A", "T, A = map(int, input().split())", "map(int, input().split())", "T", "A = x * a", "x * a", "A", "t, a = map(int, input().split())", "map(int, input().split())", "t", "n = int(input())", "int(input())", "n", "T = x * t", "x * t", "T", "x = max(-(-T//t), -(-A//a))", "max(-(-T//t), -(-A//a))", "x", "a = map(int, input().split())", "map(int, input().split())", "a" ]

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

[ [ 20, 6 ], [ 22, 7 ], [ 20, 11 ], [ 22, 12 ], [ 20, 16 ], [ 22, 17 ], [ 20, 20 ], [ 22, 22 ], [ 167, 24 ], [ 137, 27 ], [ 143, 30 ], [ 37, 36 ], [ 144, 39 ], [ 176, 41 ], [ 176, 50 ], [ 177, 54 ], [ 168, 55 ], [ 171, 55 ], [ 165, 55 ], [ 180, 55 ], [ 153, 55 ], [ 174, 57 ], [ 138, 58 ], [ 156, 58 ], [ 147, 58 ], [ 159, 58 ], [ 150, 58 ], [ 152, 60 ], [ 177, 61 ], [ 149, 62 ], [ 174, 63 ], [ 177, 67 ], [ 168, 68 ], [ 171, 68 ], [ 165, 68 ], [ 180, 68 ], [ 153, 68 ], [ 174, 70 ], [ 138, 71 ], [ 156, 71 ], [ 147, 71 ], [ 159, 71 ], [ 150, 71 ], [ 179, 73 ], [ 177, 75 ], [ 141, 77 ], [ 138, 78 ], [ 156, 78 ], [ 147, 78 ], [ 159, 78 ], [ 150, 78 ], [ 174, 79 ], [ 158, 80 ], [ 174, 82 ], [ 141, 84 ], [ 138, 85 ], [ 156, 85 ], [ 147, 85 ], [ 159, 85 ], [ 150, 85 ], [ 174, 86 ], [ 177, 90 ], [ 168, 91 ], [ 171, 91 ], [ 165, 91 ], [ 180, 91 ], [ 153, 91 ], [ 174, 93 ], [ 138, 94 ], [ 156, 94 ], [ 147, 94 ], [ 159, 94 ], [ 150, 94 ], [ 164, 96 ], [ 177, 98 ], [ 141, 100 ], [ 168, 101 ], [ 171, 101 ], [ 165, 101 ], [ 180, 101 ], [ 153, 101 ], [ 177, 102 ], [ 146, 103 ], [ 174, 105 ], [ 141, 107 ], [ 165, 108 ], [ 168, 108 ], [ 171, 108 ], [ 180, 108 ], [ 153, 108 ], [ 177, 109 ], [ 161, 111 ], [ 141, 115 ], [ 168, 116 ], [ 171, 116 ], [ 165, 116 ], [ 180, 116 ], [ 153, 116 ], [ 177, 117 ], [ 141, 119 ], [ 138, 120 ], [ 156, 120 ], [ 147, 120 ], [ 159, 120 ], [ 150, 120 ], [ 174, 121 ], [ 170, 123 ], [ 177, 125 ], [ 162, 126 ], [ 155, 127 ], [ 174, 129 ], [ 162, 130 ], [ 171, 134 ], [ 165, 134 ], [ 180, 134 ], [ 153, 134 ], [ 168, 134 ], [ 156, 135 ], [ 147, 135 ], [ 159, 135 ], [ 150, 135 ], [ 138, 135 ], [ 137, 138 ], [ 143, 144 ], [ 146, 147 ], [ 174, 149 ], [ 149, 150 ], [ 177, 152 ], [ 152, 153 ], [ 155, 156 ], [ 158, 159 ], [ 161, 162 ], [ 164, 165 ], [ 167, 168 ], [ 170, 171 ], [ 176, 174 ], [ 176, 177 ], [ 179, 180 ] ]

[ "def waru(k,l):\n if k%l==0:\n return k//l\n else:\n return (k//l)+1\nA=0\nB=0\nN=int(input())\nfor i in range(N):\n a,b=map(int,input().split())\n if a>=A and b>=B:\n A,B=a,b\n elif a>=A and b<B:\n A,B=a*waru(B,b),b*waru(B,b)\n elif a<A and b>=B:\n A,B=a*waru(A,a),b*waru(A,a)\n else:\n c=max(waru(A,a),waru(B,b))\n A,B=a*c,b*c\nprint(A+B)", "def waru(k,l):\n if k%l==0:\n return k//l\n else:\n return (k//l)+1", "waru", "if k%l==0:\n return k//l\n else:\n return (k//l)+1", "k%l==0", "k%l", "k", "l", "0", "return k//l", "k//l", "k", "l", "return (k//l)+1", "(k//l)+1", "k//l", "k", "l", "1", "k", "k", "l", "l", "A=0", "A", "0", "B=0", "B", "0", "N=int(input())", "N", "int(input())", "int", "input()", "input", "for i in range(N):\n a,b=map(int,input().split())\n if a>=A and b>=B:\n A,B=a,b\n elif a>=A and b<B:\n A,B=a*waru(B,b),b*waru(B,b)\n elif a<A and b>=B:\n A,B=a*waru(A,a),b*waru(A,a)\n else:\n c=max(waru(A,a),waru(B,b))\n A,B=a*c,b*c", "i", "range(N)", "range", "N", "a,b=map(int,input().split())", "a", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "if a>=A and b>=B:\n A,B=a,b\n elif a>=A and b<B:\n A,B=a*waru(B,b),b*waru(B,b)\n elif a<A and b>=B:\n A,B=a*waru(A,a),b*waru(A,a)\n else:\n c=max(waru(A,a),waru(B,b))\n A,B=a*c,b*c", "a>=A and b>=B", "a>=A", "a", "A", "b>=B", "b", "B", "A,B=a,b", "A", "a", "B", "b", "elif a>=A and b<B:\n A,B=a*waru(B,b),b*waru(B,b)\n ", "a>=A and b<B", "a>=A", "a", "A", "b<B", "b", "B", "A,B=a*waru(B,b),b*waru(B,b)", "A", "a*waru(B,b)", "a", "waru(B,b)", "waru", "B", "b", "B", "b*waru(B,b)", "b", "waru(B,b)", "waru", "B", "b", "elif a<A and b>=B:\n A,B=a*waru(A,a),b*waru(A,a)\n ", "a<A and b>=B", "a<A", "a", "A", "b>=B", "b", "B", "A,B=a*waru(A,a),b*waru(A,a)", "A", "a*waru(A,a)", "a", "waru(A,a)", "waru", "A", "a", "B", "b*waru(A,a)", "b", "waru(A,a)", "waru", "A", "a", "c=max(waru(A,a),waru(B,b))", "c", "max(waru(A,a),waru(B,b))", "max", "waru(A,a)", "waru", "A", "a", "waru(B,b)", "waru", "B", "b", "A,B=a*c,b*c", "A", "a*c", "a", "c", "B", "b*c", "b", "c", "print(A+B)", "print", "A+B", "A", "B", "B=0", "0", "B", "def waru(k,l):\n if k%l==0:\n return k//l\n else:\n return (k//l)+1", "def waru(k,l):\n if k%l==0:\n return k//l\n else:\n return (k//l)+1", "waru", "N=int(input())", "int(input())", "N", "B=a*waru(A,a),b*waru(A,a)", "b*waru(A,a)", "B", "B=a,b", "b", "B", "A,B=a,b", "a", "A", "B=a*c,b*c", "b*c", "B", "B=a*waru(B,b),b*waru(B,b)", "b*waru(B,b)", "B", "c=max(waru(A,a),waru(B,b))", "max(waru(A,a),waru(B,b))", "c", "A,B=a*waru(A,a),b*waru(A,a)", "a*waru(A,a)", "A", "A=0", "0", "A", "A,B=a*c,b*c", "a*c", "A", "b=map(int,input().split())", "map(int,input().split())", "b", "a,b=map(int,input().split())", "map(int,input().split())", "a", "A,B=a*waru(B,b),b*waru(B,b)", "a*waru(B,b)", "A" ]

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

[ [ 111, 2 ], [ 10, 9 ], [ 112, 12 ], [ 108, 16 ], [ 21, 20 ], [ 112, 23 ], [ 102, 27 ], [ 31, 30 ], [ 112, 33 ], [ 38, 35 ], [ 109, 36 ], [ 30, 37 ], [ 38, 46 ], [ 103, 47 ], [ 30, 48 ], [ 123, 50 ], [ 109, 52 ], [ 120, 55 ], [ 103, 57 ], [ 61, 60 ], [ 112, 64 ], [ 114, 66 ], [ 124, 72 ], [ 106, 72 ], [ 35, 73 ], [ 109, 74 ], [ 60, 75 ], [ 121, 79 ], [ 118, 79 ], [ 46, 80 ], [ 103, 81 ], [ 60, 82 ], [ 105, 84 ], [ 115, 86 ], [ 35, 87 ], [ 109, 88 ], [ 60, 89 ], [ 117, 90 ], [ 115, 92 ], [ 46, 93 ], [ 103, 94 ], [ 60, 95 ], [ 106, 99 ], [ 124, 99 ], [ 118, 100 ], [ 121, 100 ], [ 102, 103 ], [ 105, 106 ], [ 108, 109 ], [ 111, 112 ], [ 114, 115 ], [ 117, 118 ], [ 120, 121 ], [ 123, 124 ] ]

[ "n = int(input())\n\nt = [0 for i in range(n)]\na = [0 for i in range(n)]\n\nfor i in range(n):\n t[i],a[i] = map(int,input().split())\n\nt_num = t[0]\na_num = a[0]\n\nfor i in range(1,n):\n k = max(-(-t_num//t[i]),-(-a_num//a[i]))\n #その比に票を合わせる\n t_num,a_num = k*t[i],k*a[i]\n\nprint(t_num + a_num)", "n = int(input())", "n", "int(input())", "int", "input()", "input", "0 for i in range(n)", "for i in range(n)", "i", "range(n)", "range", "n", "for i in range(n)", "0", "t = [0 for i in range(n)]", "t", "[0 for i in range(n)]", "0 for i in range(n)", "for i in range(n)", "i", "range(n)", "range", "n", "for i in range(n)", "0", "a = [0 for i in range(n)]", "a", "[0 for i in range(n)]", "for i in range(n):\n t[i],a[i] = map(int,input().split())", "i", "range(n)", "range", "n", "t[i],a[i] = map(int,input().split())", "t[i]", "t", "i", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "a[i]", "a", "i", "t_num = t[0]", "t_num", "t[0]", "t", "0", "a_num = a[0]", "a_num", "a[0]", "a", "0", "for i in range(1,n):\n k = max(-(-t_num//t[i]),-(-a_num//a[i]))\n #その比に票を合わせる\n t_num,a_num = k*t[i],k*a[i]", "i", "range(1,n)", "range", "1", "n", "k = max(-(-t_num//t[i]),-(-a_num//a[i]))", "k", "max(-(-t_num//t[i]),-(-a_num//a[i]))", "max", "-(-t_num//t[i])", "-t_num//t[i]", "-t_num", "t_num", "t[i]", "t", "i", "-(-a_num//a[i])", "-a_num//a[i]", "-a_num", "a_num", "a[i]", "a", "i", "t_num,a_num = k*t[i],k*a[i]", "t_num", "k*t[i]", "k", "t[i]", "t", "i", "a_num", "k*a[i]", "k", "a[i]", "a", "i", "print(t_num + a_num)", "print", "t_num + a_num", "t_num", "a_num", "a = [0 for i in range(n)]", "[0 for i in range(n)]", "a", "t_num,a_num = k*t[i],k*a[i]", "k*t[i]", "t_num", "t = [0 for i in range(n)]", "[0 for i in range(n)]", "t", "n = int(input())", "int(input())", "n", "k = max(-(-t_num//t[i]),-(-a_num//a[i]))", "max(-(-t_num//t[i]),-(-a_num//a[i]))", "k", "a_num = k*t[i],k*a[i]", "k*a[i]", "a_num", "a_num = a[0]", "a[0]", "a_num", "t_num = t[0]", "t[0]", "t_num" ]

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

[ [ 243, 11 ], [ 246, 24 ], [ 219, 29 ], [ 39, 38 ], [ 44, 44 ], [ 56, 55 ], [ 244, 59 ], [ 55, 65 ], [ 74, 73 ], [ 83, 83 ], [ 87, 86 ], [ 250, 92 ], [ 96, 96 ], [ 100, 99 ], [ 232, 105 ], [ 109, 109 ], [ 113, 112 ], [ 244, 114 ], [ 112, 123 ], [ 137, 136 ], [ 238, 138 ], [ 141, 140 ], [ 235, 142 ], [ 136, 143 ], [ 146, 145 ], [ 149, 148 ], [ 156, 155 ], [ 145, 161 ], [ 173, 161 ], [ 148, 168 ], [ 177, 168 ], [ 174, 173 ], [ 155, 175 ], [ 178, 177 ], [ 155, 179 ], [ 183, 182 ], [ 173, 184 ], [ 145, 184 ], [ 177, 185 ], [ 148, 185 ], [ 182, 190 ], [ 217, 196 ], [ 219, 220 ], [ 243, 244 ], [ 246, 247 ] ]

[ "#\n# 　　 ⋀_⋀　 \n#　　 (･ω･) \n# .／ Ｕ ∽ Ｕ＼\n# │＊　合　＊│\n# │＊　格　＊│ \n# │＊　祈　＊│ \n# │＊　願　＊│ \n# │＊　　　＊│ \n# ￣\n#\nimport sys\nsys.setrecursionlimit(10**6)\ninput=sys.stdin.readline\nfrom math import floor,ceil,sqrt,factorial,log #log2ないｙｐ\nfrom heapq import heappop, heappush, heappushpop\nfrom collections import Counter,defaultdict,deque\nfrom itertools import accumulate,permutations,combinations,product,combinations_with_replacement\nfrom bisect import bisect_left,bisect_right\nfrom copy import deepcopy\ninf=float('inf')\nmod = 10**9+7\ndef pprint(*A): \n for a in A: print(*a,sep='\\n')\ndef INT_(n): return int(n)-1\ndef MI(): return map(int,input().split())\ndef MF(): return map(float, input().split())\ndef MI_(): return map(INT_,input().split())\ndef LI(): return list(MI())\ndef LI_(): return [int(x) - 1 for x in input().split()]\ndef LF(): return list(MF())\ndef LIN(n:int): return [I() for _ in range(n)]\ndef LLIN(n: int): return [LI() for _ in range(n)]\ndef LLIN_(n: int): return [LI_() for _ in range(n)]\ndef LLI(): return [list(map(int, l.split() )) for l in input()]\ndef I(): return int(input())\ndef F(): return float(input())\ndef ST(): return input().replace('\\n', '')\ndef main():\n N=I()\n TA=LLIN(N)\n C=1\n D=1\n for t,a in TA:\n n = max((C+t-1)//t , (D+a-1)//a)\n # n = (max(int(ceil(C/t)),int(ceil(D/a))))\n C,D = n*t,n*a\n ans = C+D\n print(int(ans))\nif __name__ == '__main__':\n main()", "import sys", "sys", "sys.setrecursionlimit(10**6)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "10**6", "10", "6", "input=sys.stdin.readline", "input", "sys.stdin.readline", "sys.stdin", "sys", "stdin", "readline", "from math import floor,ceil,sqrt,factorial,log", "from heapq import heappop, heappush, heappushpop", "from collections import Counter,defaultdict,deque", "from itertools import accumulate,permutations,combinations,product,combinations_with_replacement", "from bisect import bisect_left,bisect_right", "from copy import deepcopy", "inf=float('inf')", "inf", "float('inf')", "float", "'inf'", "mod = 10**9+7", "mod", "10**9+7", "10**9", "10", "9", "7", "def pprint(*A): \n for a in A: print(*a,sep='\\n')", "pprint", "for a in A: print(*a,sep='", "a", "A", "*A", "def INT_(n): return int(n)-1", "INT_", "n", "n", "def MI(): return map(int,input().split())", "MI", "def MF(): return map(float, input().split())", "MF", "def MI_(): return map(INT_,input().split())", "MI_", "def LI(): return list(MI())", "LI", "int(x) - 1 for x in input().split()", "for x in input().split()", "x", "input().split()", "().split", "()", "input", "split", "for x in input().split()", "int(x) - 1", "int(x)", "int", "x", "1", "def LI_(): return [int(x) - 1 for x in input().split()]", "LI_", "def LF(): return list(MF())", "LF", "I() for _ in range(n)", "for _ in range(n)", "_", "range(n)", "range", "n", "for _ in range(n)", "I()", "I", "def LIN(n:int): return [I() for _ in range(n)]", "LIN", "n:int", "n", "LI() for _ in range(n)", "for _ in range(n)", "_", "range(n)", "range", "n", "for _ in range(n)", "LI()", "LI", "def LLIN(n: int): return [LI() for _ in range(n)]", "LLIN", "n: int", "n", "LI_() for _ in range(n)", "for _ in range(n)", "_", "range(n)", "range", "n", "for _ in range(n)", "LI_()", "LI_", "def LLIN_(n: int): return [LI_() for _ in range(n)]", "LLIN_", "n: int", "n", "list(map(int, l.split() )) for l in input()", "for l in input()", "l", "input()", "input", "for l in input()", "list(map(int, l.split() ))", "list", "map(int, l.split() )", "map", "int", "l.split()", "l.split", "l", "split", "def LLI(): return [list(map(int, l.split() )) for l in input()]", "LLI", "def I(): return int(input())", "I", "def F(): return float(input())", "F", "def ST(): return input().replace('\\n', '')", "ST", "def main():\n N=I()\n TA=LLIN(N)\n C=1\n D=1\n for t,a in TA:\n n = max((C+t-1)//t , (D+a-1)//a)\n # n = (max(int(ceil(C/t)),int(ceil(D/a))))\n C,D = n*t,n*a\n ans = C+D\n print(int(ans))", "main", "N=I()", "N", "I()", "I", "TA=LLIN(N)", "TA", "LLIN(N)", "LLIN", "N", "C=1", "C", "1", "D=1", "D", "1", "for t,a in TA:\n n = max((C+t-1)//t , (D+a-1)//a)\n # n = (max(int(ceil(C/t)),int(ceil(D/a))))\n C,D = n*t,n*a\n ", "t", "a", "TA", "n = max((C+t-1)//t , (D+a-1)//a)", "n", "max((C+t-1)//t , (D+a-1)//a)", "max", "(C+t-1)//t", "C+t-1", "C+t", "C", "t", "1", "t", "(D+a-1)//a", "D+a-1", "D+a", "D", "a", "1", "a", "C,D = n*t,n*a", "C", "n*t", "n", "t", "D", "n*a", "n", "a", "ans = C+D", "ans", "C+D", "C", "D", "print(int(ans))", "print", "int(ans)", "int", "ans", "if __name__ == '__main__':\n main()", "__name__ == '__main__'", "__name__", "'__main__'", "main()", "main", "def MI(): return map(int,input().split())", "def MI(): return map(int,input().split())", "MI", "def MI_(): return map(INT_,input().split())", "def MI_(): return map(INT_,input().split())", "MI_", "def MF(): return map(float, input().split())", "def MF(): return map(float, input().split())", "MF", "def pprint(*A): \n for a in A: print(*a,sep='\\n')", "def pprint(*A): \n for a in A: print(*a,sep='\\n')", "pprint", "def LIN(n:int): return [I() for _ in range(n)]", "def LIN(n:int): return [I() for _ in range(n)]", "LIN", "def LLI(): return [list(map(int, l.split() )) for l in input()]", "def LLI(): return [list(map(int, l.split() )) for l in input()]", "LLI", "def main():\n N=I()\n TA=LLIN(N)\n C=1\n D=1\n for t,a in TA:\n n = max((C+t-1)//t , (D+a-1)//a)\n # n = (max(int(ceil(C/t)),int(ceil(D/a))))\n C,D = n*t,n*a\n ans = C+D\n print(int(ans))", "def main():\n N=I()\n TA=LLIN(N)\n C=1\n D=1\n for t,a in TA:\n n = max((C+t-1)//t , (D+a-1)//a)\n # n = (max(int(ceil(C/t)),int(ceil(D/a))))\n C,D = n*t,n*a\n ans = C+D\n print(int(ans))", "main", "mod = 10**9+7", "10**9+7", "mod", "def F(): return float(input())", "def F(): return float(input())", "F", "def LF(): return list(MF())", "def LF(): return list(MF())", "LF", "def INT_(n): return int(n)-1", "def INT_(n): return int(n)-1", "INT_", "def LI_(): return [int(x) - 1 for x in input().split()]", "def LI_(): return [int(x) - 1 for x in input().split()]", "LI_", "def LLIN(n: int): return [LI() for _ in range(n)]", "def LLIN(n: int): return [LI() for _ in range(n)]", "LLIN", "def I(): return int(input())", "def I(): return int(input())", "I", "def ST(): return input().replace('\\n', '')", "def ST(): return input().replace('\\n', '')", "ST", "input=sys.stdin.readline", "sys.stdin.readline", "input", "inf=float('inf')", "float('inf')", "inf", "def LI(): return list(MI())", "def LI(): return list(MI())", "LI", "def LLIN_(n: int): return [LI_() for _ in range(n)]", "def LLIN_(n: int): return [LI_() for _ in range(n)]", "LLIN_" ]

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

[ [ 121, 2 ], [ 139, 8 ], [ 112, 10 ], [ 14, 13 ], [ 122, 16 ], [ 109, 18 ], [ 109, 27 ], [ 140, 31 ], [ 107, 31 ], [ 119, 31 ], [ 110, 32 ], [ 113, 34 ], [ 116, 34 ], [ 128, 34 ], [ 104, 35 ], [ 118, 37 ], [ 110, 38 ], [ 127, 40 ], [ 104, 41 ], [ 140, 45 ], [ 107, 45 ], [ 119, 45 ], [ 110, 46 ], [ 100, 49 ], [ 140, 51 ], [ 107, 51 ], [ 119, 51 ], [ 110, 52 ], [ 136, 54 ], [ 140, 57 ], [ 107, 57 ], [ 119, 57 ], [ 110, 58 ], [ 128, 63 ], [ 113, 63 ], [ 116, 63 ], [ 104, 64 ], [ 130, 67 ], [ 128, 69 ], [ 113, 69 ], [ 116, 69 ], [ 104, 70 ], [ 133, 72 ], [ 128, 75 ], [ 113, 75 ], [ 116, 75 ], [ 104, 76 ], [ 124, 79 ], [ 137, 82 ], [ 101, 82 ], [ 134, 83 ], [ 131, 83 ], [ 106, 85 ], [ 125, 87 ], [ 110, 88 ], [ 115, 90 ], [ 125, 92 ], [ 104, 93 ], [ 107, 97 ], [ 119, 97 ], [ 140, 97 ], [ 116, 98 ], [ 128, 98 ], [ 113, 98 ], [ 100, 101 ], [ 109, 104 ], [ 106, 107 ], [ 109, 110 ], [ 112, 113 ], [ 115, 116 ], [ 110, 118 ], [ 118, 119 ], [ 121, 122 ], [ 124, 125 ], [ 104, 127 ], [ 127, 128 ], [ 130, 131 ], [ 133, 134 ], [ 136, 137 ], [ 139, 140 ] ]

[ "n = int(input())\nx, y = 1, 1\nfor _ in range(n):\n t, a = map(int, input().split())\n if x <= t and y <= a:\n x = t\n y = a\n else:\n if x % t == 0:\n i_x = x // t\n else:\n i_x = x // t + 1\n\n if y % a == 0:\n i_y = y // a\n else:\n i_y = y // a + 1\n bigger = max(i_x, i_y)\n x = bigger*t\n y = bigger*a\nprint(x+y)", "n = int(input())", "n", "int(input())", "int", "input()", "input", "x, y = 1, 1", "x", "1", "y", "1", "for _ in range(n):\n t, a = map(int, input().split())\n if x <= t and y <= a:\n x = t\n y = a\n else:\n if x % t == 0:\n i_x = x // t\n else:\n i_x = x // t + 1\n\n if y % a == 0:\n i_y = y // a\n else:\n i_y = y // a + 1\n bigger = max(i_x, i_y)\n x = bigger*t\n y = bigger*a", "_", "range(n)", "range", "n", "t, a = map(int, input().split())", "t", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "a", "if x <= t and y <= a:\n x = t\n y = a\n else:\n if x % t == 0:\n i_x = x // t\n else:\n i_x = x // t + 1\n\n if y % a == 0:\n i_y = y // a\n else:\n i_y = y // a + 1\n bigger = max(i_x, i_y)\n x = bigger*t\n y = bigger*a", "x <= t and y <= a", "x <= t", "x", "t", "y <= a", "y", "a", "x = t", "x", "t", "y = a", "y", "a", "if x % t == 0:\n i_x = x // t\n else:\n i_x = x // t + 1\n\n ", "x % t == 0", "x % t", "x", "t", "0", "i_x = x // t", "i_x", "x // t", "x", "t", "i_x = x // t + 1", "i_x", "x // t + 1", "x // t", "x", "t", "1", "if y % a == 0:\n i_y = y // a\n else:\n i_y = y // a + 1\n ", "y % a == 0", "y % a", "y", "a", "0", "i_y = y // a", "i_y", "y // a", "y", "a", "i_y = y // a + 1", "i_y", "y // a + 1", "y // a", "y", "a", "1", "bigger = max(i_x, i_y)", "bigger", "max(i_x, i_y)", "max", "i_x", "i_y", "x = bigger*t", "x", "bigger*t", "bigger", "t", "y = bigger*a", "y", "bigger*a", "bigger", "a", "print(x+y)", "print", "x+y", "x", "y", "i_x = x // t", "x // t", "i_x", "a = map(int, input().split())", "map(int, input().split())", "a", "x = bigger*t", "bigger*t", "x", "t, a = map(int, input().split())", "map(int, input().split())", "t", "y = 1, 1", "1", "y", "y = bigger*a", "bigger*a", "y", "x = t", "t", "x", "n = int(input())", "int(input())", "n", "bigger = max(i_x, i_y)", "max(i_x, i_y)", "bigger", "y = a", "a", "y", "i_y = y // a", "y // a", "i_y", "i_y = y // a + 1", "y // a + 1", "i_y", "i_x = x // t + 1", "x // t + 1", "i_x", "x, y = 1, 1", "1", "x" ]

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

[ [ 82, 5 ], [ 13, 12 ], [ 83, 15 ], [ 88, 28 ], [ 103, 31 ], [ 100, 33 ], [ 37, 36 ], [ 83, 39 ], [ 106, 41 ], [ 89, 43 ], [ 36, 44 ], [ 106, 45 ], [ 94, 47 ], [ 104, 57 ], [ 98, 57 ], [ 107, 58 ], [ 101, 64 ], [ 92, 64 ], [ 86, 65 ], [ 97, 67 ], [ 95, 69 ], [ 107, 70 ], [ 91, 72 ], [ 95, 74 ], [ 86, 75 ], [ 98, 79 ], [ 104, 79 ], [ 92, 80 ], [ 101, 80 ], [ 82, 83 ], [ 106, 86 ], [ 88, 89 ], [ 91, 92 ], [ 94, 95 ], [ 97, 98 ], [ 100, 101 ], [ 103, 104 ], [ 106, 107 ] ]

[ "#C\nimport math\nfrom decimal import *\nN = int(input())\nTA = [list(map(int,input().split())) for i in range(N)]\n\nt,a = 1,1\nfor i in range(N):\n ti,ai = TA[i]\n n = Decimal(max(math.ceil(t/ti),math.ceil(a/ai)))\n t = n*ti\n a = n*ai\n \n #print(t,a)\n \nprint(t+a)", "import math", "math", "from decimal import *", "N = int(input())", "N", "int(input())", "int", "input()", "input", "list(map(int,input().split())) for i in range(N)", "for i in range(N)", "i", "range(N)", "range", "N", "for i in range(N)", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "TA = [list(map(int,input().split())) for i in range(N)]", "TA", "[list(map(int,input().split())) for i in range(N)]", "t,a = 1,1", "t", "1", "a", "1", "for i in range(N):\n ti,ai = TA[i]\n n = Decimal(max(math.ceil(t/ti),math.ceil(a/ai)))\n t = n*ti\n a = n*ai\n \n #print(t,a)\n ", "i", "range(N)", "range", "N", "ti,ai = TA[i]", "ti", "TA[i]", "TA", "i", "ai", "n = Decimal(max(math.ceil(t/ti),math.ceil(a/ai)))", "n", "Decimal(max(math.ceil(t/ti),math.ceil(a/ai)))", "Decimal", "max(math.ceil(t/ti),math.ceil(a/ai))", "max", "math.ceil(t/ti)", "math.ceil", "math", "ceil", "t/ti", "t", "ti", "math.ceil(a/ai)", "math.ceil", "math", "ceil", "a/ai", "a", "ai", "t = n*ti", "t", "n*ti", "n", "ti", "a = n*ai", "a", "n*ai", "n", "ai", "print(t+a)", "print", "t+a", "t", "a", "N = int(input())", "int(input())", "N", "ai = TA[i]", "TA[i]", "ai", "TA = [list(map(int,input().split())) for i in range(N)]", "[list(map(int,input().split())) for i in range(N)]", "TA", "a = n*ai", "n*ai", "a", "n = Decimal(max(math.ceil(t/ti),math.ceil(a/ai)))", "Decimal(max(math.ceil(t/ti),math.ceil(a/ai)))", "n", "t = n*ti", "n*ti", "t", "a = 1,1", "1", "a", "t,a = 1,1", "1", "t", "ti,ai = TA[i]", "TA[i]", "ti" ]

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

[ [ 10, 8 ], [ 10, 10 ], [ 12, 12 ], [ 90, 14 ], [ 102, 20 ], [ 111, 22 ], [ 26, 25 ], [ 91, 28 ], [ 105, 30 ], [ 105, 39 ], [ 108, 41 ], [ 85, 43 ], [ 106, 44 ], [ 118, 44 ], [ 94, 45 ], [ 100, 45 ], [ 117, 47 ], [ 106, 49 ], [ 118, 49 ], [ 109, 50 ], [ 99, 51 ], [ 94, 53 ], [ 100, 53 ], [ 109, 54 ], [ 87, 56 ], [ 103, 62 ], [ 97, 62 ], [ 118, 63 ], [ 106, 63 ], [ 112, 67 ], [ 115, 67 ], [ 100, 68 ], [ 94, 68 ], [ 96, 70 ], [ 118, 72 ], [ 106, 72 ], [ 88, 73 ], [ 114, 74 ], [ 100, 76 ], [ 94, 76 ], [ 88, 77 ], [ 97, 81 ], [ 103, 81 ], [ 115, 82 ], [ 112, 82 ], [ 87, 88 ], [ 90, 91 ], [ 105, 94 ], [ 96, 97 ], [ 99, 100 ], [ 102, 103 ], [ 105, 106 ], [ 108, 109 ], [ 111, 112 ], [ 114, 115 ], [ 117, 118 ] ]

[ "def gcd(a, b):\n while b: a, b = b, a % b\n return abs(a)\n\nN = int(input())\ns, t = 1, 1\nfor _ in range(N):\n a, b = map(int, input().split())\n g = gcd(a, b)\n a, b = a//g, b//g\n mi = max(-(-s//a), -(-t//b))\n s, t = a*mi, b*mi\nprint(s+t)", "def gcd(a, b):\n while b: a, b = b, a % b\n return abs(a)", "gcd", "while b: a, b = b, a % b\n ", "b", "return abs(a)", "abs(a)", "abs", "a", "a", "a", "b", "b", "N = int(input())", "N", "int(input())", "int", "input()", "input", "s, t = 1, 1", "s", "1", "t", "1", "for _ in range(N):\n a, b = map(int, input().split())\n g = gcd(a, b)\n a, b = a//g, b//g\n mi = max(-(-s//a), -(-t//b))\n s, t = a*mi, b*mi", "_", "range(N)", "range", "N", "a, b = map(int, input().split())", "a", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "g = gcd(a, b)", "g", "gcd(a, b)", "gcd", "a", "b", "a, b = a//g, b//g", "a", "a//g", "a", "g", "b", "b//g", "b", "g", "mi = max(-(-s//a), -(-t//b))", "mi", "max(-(-s//a), -(-t//b))", "max", "-(-s//a)", "-s//a", "-s", "s", "a", "-(-t//b)", "-t//b", "-t", "t", "b", "s, t = a*mi, b*mi", "s", "a*mi", "a", "mi", "t", "b*mi", "b", "mi", "print(s+t)", "print", "s+t", "s", "t", "def gcd(a, b):\n while b: a, b = b, a % b\n return abs(a)", "def gcd(a, b):\n while b: a, b = b, a % b\n return abs(a)", "gcd", "mi = max(-(-s//a), -(-t//b))", "max(-(-s//a), -(-t//b))", "mi", "N = int(input())", "int(input())", "N", "b = map(int, input().split())", "map(int, input().split())", "b", "s, t = a*mi, b*mi", "a*mi", "s", "b = a//g, b//g", "b//g", "b", "s, t = 1, 1", "1", "s", "a, b = map(int, input().split())", "map(int, input().split())", "a", "g = gcd(a, b)", "gcd(a, b)", "g", "t = 1, 1", "1", "t", "t = a*mi, b*mi", "b*mi", "t", "a, b = a//g, b//g", "a//g", "a" ]

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

[ [ 93, 4 ], [ 114, 10 ], [ 114, 13 ], [ 17, 16 ], [ 94, 19 ], [ 99, 21 ], [ 99, 30 ], [ 84, 32 ], [ 115, 36 ], [ 106, 36 ], [ 103, 36 ], [ 100, 37 ], [ 111, 39 ], [ 109, 43 ], [ 82, 43 ], [ 88, 43 ], [ 91, 44 ], [ 85, 48 ], [ 112, 51 ], [ 102, 54 ], [ 100, 55 ], [ 87, 57 ], [ 91, 58 ], [ 96, 60 ], [ 85, 63 ], [ 112, 64 ], [ 105, 66 ], [ 97, 68 ], [ 100, 69 ], [ 81, 71 ], [ 97, 73 ], [ 91, 74 ], [ 106, 78 ], [ 103, 78 ], [ 115, 78 ], [ 82, 79 ], [ 88, 79 ], [ 109, 79 ], [ 81, 82 ], [ 84, 85 ], [ 91, 87 ], [ 87, 88 ], [ 99, 91 ], [ 93, 94 ], [ 96, 97 ], [ 99, 100 ], [ 100, 102 ], [ 102, 103 ], [ 105, 106 ], [ 114, 109 ], [ 111, 112 ], [ 114, 115 ] ]

[ "import fractions\nN=int(input())\n\nvt=va=0\nfor _ in range(N):\n T,A=map(int,input().split())\n kt=-(-vt//T)\n ka=-(-va//A)\n if kt==0 and ka==0:\n vt=T\n va=A\n else:\n k=max(kt,ka)\n vt=k*T\n va=k*A\n \n #print(vt,va)\n \nprint(vt+va)", "import fractions", "fractions", "N=int(input())", "N", "int(input())", "int", "input()", "input", "vt=va=0", "vt", "0", "=va=0", "va", "0", "for _ in range(N):\n T,A=map(int,input().split())\n kt=-(-vt//T)\n ka=-(-va//A)\n if kt==0 and ka==0:\n vt=T\n va=A\n else:\n k=max(kt,ka)\n vt=k*T\n va=k*A\n \n #print(vt,va)\n ", "_", "range(N)", "range", "N", "T,A=map(int,input().split())", "T", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "A", "kt=-(-vt//T)", "kt", "-(-vt//T)", "-vt//T", "-vt", "vt", "T", "ka=-(-va//A)", "ka", "-(-va//A)", "-va//A", "-va", "va", "A", "if kt==0 and ka==0:\n vt=T\n va=A\n else:\n k=max(kt,ka)\n vt=k*T\n va=k*A\n \n #print(vt,va)\n ", "kt==0 and ka==0", "kt==0", "kt", "0", "ka==0", "ka", "0", "vt=T", "vt", "T", "va=A", "va", "A", "k=max(kt,ka)", "k", "max(kt,ka)", "max", "kt", "ka", "vt=k*T", "vt", "k*T", "k", "T", "va=k*A", "va", "k*A", "k", "A", "print(vt+va)", "print", "vt+va", "vt", "va", "va=k*A", "k*A", "va", "kt=-(-vt//T)", "-(-vt//T)", "kt", "va=A", "A", "va", "A=map(int,input().split())", "map(int,input().split())", "A", "N=int(input())", "int(input())", "N", "k=max(kt,ka)", "max(kt,ka)", "k", "T,A=map(int,input().split())", "map(int,input().split())", "T", "vt=T", "T", "vt", "vt=k*T", "k*T", "vt", "va=0", "0", "va", "ka=-(-va//A)", "-(-va//A)", "ka", "vt=va=0", "0", "vt" ]

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

[ [ 3, 2 ], [ 74, 10 ], [ 74, 19 ], [ 2, 22 ], [ 71, 25 ], [ 63, 26 ], [ 80, 27 ], [ 75, 28 ], [ 77, 30 ], [ 69, 36 ], [ 72, 36 ], [ 63, 37 ], [ 63, 39 ], [ 66, 43 ], [ 81, 43 ], [ 75, 44 ], [ 75, 46 ], [ 68, 48 ], [ 63, 50 ], [ 78, 51 ], [ 65, 53 ], [ 75, 55 ], [ 78, 56 ], [ 69, 59 ], [ 72, 59 ], [ 66, 60 ], [ 81, 60 ], [ 74, 63 ], [ 65, 66 ], [ 68, 69 ], [ 63, 71 ], [ 71, 72 ], [ 74, 75 ], [ 77, 78 ], [ 75, 80 ], [ 80, 81 ] ]

[ "for i in range(int(raw_input())):\n\tn,d = map(int, raw_input().split())\n\tif i == 0:\n\t\ta,b = n,d\n\telse:\n\t\tq = max((a+n-1)/n, (b+d-1)/d)\n\t\ta = n*q\n\t\tb = d*q\n\n\n\nprint a+b", "for i in range(int(raw_input())):\n\tn,d = map(int, raw_input().split())\n\tif i == 0:\n\t\ta,b = n,d\n\telse:\n\t\tq = max((a+n-1)/n, (b+d-1)/d)\n\t\ta = n*q\n\t\tb = d*q", "i", "range(int(raw_input()))", "range", "int(raw_input())", "int", "raw_input()", "raw_input", "n,d = map(int, raw_input().split())", "n", "map(int, raw_input().split())", "map", "int", "raw_input().split()", "().split", "()", "raw_input", "split", "d", "if i == 0:\n\t\ta,b = n,d\n\telse:\n\t\tq = max((a+n-1)/n, (b+d-1)/d)\n\t\ta = n*q\n\t\tb = d*q", "i == 0", "i", "0", "a,b = n,d", "a", "n", "b", "d", "q = max((a+n-1)/n, (b+d-1)/d)", "q", "max((a+n-1)/n, (b+d-1)/d)", "max", "(a+n-1)/n", "a+n-1", "a+n", "a", "n", "1", "n", "(b+d-1)/d", "b+d-1", "b+d", "b", "d", "1", "d", "a = n*q", "a", "n*q", "n", "q", "b = d*q", "b", "d*q", "d", "q", "print", "a+b", "a", "b", "n,d = map(int, raw_input().split())", "map(int, raw_input().split())", "n", "b = d*q", "d*q", "b", "a = n*q", "n*q", "a", "a,b = n,d", "n", "a", "d = map(int, raw_input().split())", "map(int, raw_input().split())", "d", "q = max((a+n-1)/n, (b+d-1)/d)", "max((a+n-1)/n, (b+d-1)/d)", "q", "b = n,d", "d", "b" ]

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

[ [ 82, 2 ], [ 70, 8 ], [ 79, 11 ], [ 15, 14 ], [ 83, 17 ], [ 85, 19 ], [ 85, 28 ], [ 67, 30 ], [ 71, 37 ], [ 68, 37 ], [ 74, 38 ], [ 80, 42 ], [ 77, 42 ], [ 86, 43 ], [ 74, 44 ], [ 76, 46 ], [ 68, 53 ], [ 71, 53 ], [ 74, 54 ], [ 80, 58 ], [ 77, 58 ], [ 86, 59 ], [ 86, 60 ], [ 68, 64 ], [ 71, 64 ], [ 77, 65 ], [ 80, 65 ], [ 67, 68 ], [ 70, 71 ], [ 85, 74 ], [ 76, 77 ], [ 79, 80 ], [ 82, 83 ], [ 85, 86 ] ]

[ "n=int(input())\nt_sum=1\na_sum=1\nfor i in range(n):\n T,A=map(int,input().split())\n t_sum = max(-(-t_sum//T),-(-a_sum//A))*T\n a_sum = max(-(-t_sum//T),-(-a_sum//A))*A\nprint(t_sum+a_sum)", "n=int(input())", "n", "int(input())", "int", "input()", "input", "t_sum=1", "t_sum", "1", "a_sum=1", "a_sum", "1", "for i in range(n):\n T,A=map(int,input().split())\n t_sum = max(-(-t_sum//T),-(-a_sum//A))*T\n a_sum = max(-(-t_sum//T),-(-a_sum//A))*A", "i", "range(n)", "range", "n", "T,A=map(int,input().split())", "T", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "A", "t_sum = max(-(-t_sum//T),-(-a_sum//A))*T", "t_sum", "max(-(-t_sum//T),-(-a_sum//A))*T", "max(-(-t_sum//T),-(-a_sum//A))", "max", "-(-t_sum//T)", "-t_sum//T", "-t_sum", "t_sum", "T", "-(-a_sum//A)", "-a_sum//A", "-a_sum", "a_sum", "A", "T", "a_sum = max(-(-t_sum//T),-(-a_sum//A))*A", "a_sum", "max(-(-t_sum//T),-(-a_sum//A))*A", "max(-(-t_sum//T),-(-a_sum//A))", "max", "-(-t_sum//T)", "-t_sum//T", "-t_sum", "t_sum", "T", "-(-a_sum//A)", "-a_sum//A", "-a_sum", "a_sum", "A", "A", "print(t_sum+a_sum)", "print", "t_sum+a_sum", "t_sum", "a_sum", "t_sum = max(-(-t_sum//T),-(-a_sum//A))*T", "max(-(-t_sum//T),-(-a_sum//A))*T", "t_sum", "t_sum=1", "1", "t_sum", "T,A=map(int,input().split())", "map(int,input().split())", "T", "a_sum = max(-(-t_sum//T),-(-a_sum//A))*A", "max(-(-t_sum//T),-(-a_sum//A))*A", "a_sum", "a_sum=1", "1", "a_sum", "n=int(input())", "int(input())", "n", "A=map(int,input().split())", "map(int,input().split())", "A" ]

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

[ [ 83, 2 ], [ 86, 8 ], [ 80, 11 ], [ 95, 14 ], [ 18, 17 ], [ 84, 20 ], [ 92, 22 ], [ 92, 31 ], [ 77, 33 ], [ 81, 37 ], [ 102, 37 ], [ 93, 38 ], [ 96, 40 ], [ 99, 40 ], [ 90, 41 ], [ 81, 48 ], [ 102, 48 ], [ 93, 50 ], [ 78, 51 ], [ 105, 51 ], [ 96, 53 ], [ 99, 53 ], [ 90, 55 ], [ 78, 56 ], [ 105, 56 ], [ 101, 58 ], [ 93, 60 ], [ 78, 61 ], [ 105, 61 ], [ 98, 63 ], [ 90, 65 ], [ 78, 66 ], [ 105, 66 ], [ 104, 69 ], [ 102, 74 ], [ 81, 74 ], [ 99, 75 ], [ 96, 75 ], [ 77, 78 ], [ 80, 81 ], [ 83, 84 ], [ 86, 87 ], [ 92, 90 ], [ 92, 93 ], [ 95, 96 ], [ 98, 99 ], [ 101, 102 ], [ 104, 105 ] ]

[ "n = int(input())\nans = 0\nmax_t = 0\nmax_a = 0\nfor _ in range(n):\n t, a = map(int, input().split())\n x = max(max_t//t, max_a//a, 1)\n while 1:\n if max_t <= t*x and max_a <= a*x:\n max_t = t * x\n max_a = a * x\n break\n else:\n x += 1\nprint(max_t + max_a)", "n = int(input())", "n", "int(input())", "int", "input()", "input", "ans = 0", "ans", "0", "max_t = 0", "max_t", "0", "max_a = 0", "max_a", "0", "for _ in range(n):\n t, a = map(int, input().split())\n x = max(max_t//t, max_a//a, 1)\n while 1:\n if max_t <= t*x and max_a <= a*x:\n max_t = t * x\n max_a = a * x\n break\n else:\n x += 1", "_", "range(n)", "range", "n", "t, a = map(int, input().split())", "t", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "a", "x = max(max_t//t, max_a//a, 1)", "x", "max(max_t//t, max_a//a, 1)", "max", "max_t//t", "max_t", "t", "max_a//a", "max_a", "a", "1", "while 1:\n if max_t <= t*x and max_a <= a*x:\n max_t = t * x\n max_a = a * x\n break\n else:\n x += 1", "1", "if max_t <= t*x and max_a <= a*x:\n max_t = t * x\n max_a = a * x\n break\n else:\n x += 1", "max_t <= t*x and max_a <= a*x", "max_t <= t*x", "max_t", "t*x", "t", "x", "max_a <= a*x", "max_a", "a*x", "a", "x", "max_t = t * x", "max_t", "t * x", "t", "x", "max_a = a * x", "max_a", "a * x", "a", "x", "break", "x += 1", "x", "1", "print(max_t + max_a)", "print", "max_t + max_a", "max_t", "max_a", "x = max(max_t//t, max_a//a, 1)", "max(max_t//t, max_a//a, 1)", "x", "max_t = 0", "0", "max_t", "n = int(input())", "int(input())", "n", "ans = 0", "0", "ans", "a = map(int, input().split())", "map(int, input().split())", "a", "t, a = map(int, input().split())", "map(int, input().split())", "t", "max_a = 0", "0", "max_a", "max_a = a * x", "a * x", "max_a", "max_t = t * x", "t * x", "max_t", "x += 1", "1", "x" ]

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

[ [ 95, 2 ], [ 77, 8 ], [ 83, 11 ], [ 15, 14 ], [ 96, 17 ], [ 92, 19 ], [ 92, 28 ], [ 89, 30 ], [ 78, 34 ], [ 87, 34 ], [ 93, 35 ], [ 93, 37 ], [ 80, 39 ], [ 84, 43 ], [ 75, 43 ], [ 72, 44 ], [ 72, 46 ], [ 98, 48 ], [ 90, 51 ], [ 81, 52 ], [ 86, 54 ], [ 93, 56 ], [ 99, 57 ], [ 74, 59 ], [ 72, 61 ], [ 99, 62 ], [ 75, 68 ], [ 84, 68 ], [ 87, 69 ], [ 78, 69 ], [ 92, 72 ], [ 74, 75 ], [ 77, 78 ], [ 80, 81 ], [ 83, 84 ], [ 86, 87 ], [ 89, 90 ], [ 92, 93 ], [ 95, 96 ], [ 98, 99 ] ]

[ "n = int(input())\nt = 1\na = 1\nfor i in range(n):\n next_t, next_a = map(int, input().split())\n kake_t = (t + next_t - 1) // next_t\n kake_a = (a + next_a - 1) // next_a\n kake = max(kake_t, kake_a)\n t = next_t * kake\n a = next_a * kake\nprint(int(a + t))", "n = int(input())", "n", "int(input())", "int", "input()", "input", "t = 1", "t", "1", "a = 1", "a", "1", "for i in range(n):\n next_t, next_a = map(int, input().split())\n kake_t = (t + next_t - 1) // next_t\n kake_a = (a + next_a - 1) // next_a\n kake = max(kake_t, kake_a)\n t = next_t * kake\n a = next_a * kake", "i", "range(n)", "range", "n", "next_t, next_a = map(int, input().split())", "next_t", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "next_a", "kake_t = (t + next_t - 1) // next_t", "kake_t", "(t + next_t - 1) // next_t", "t + next_t - 1", "t + next_t", "t", "next_t", "1", "next_t", "kake_a = (a + next_a - 1) // next_a", "kake_a", "(a + next_a - 1) // next_a", "a + next_a - 1", "a + next_a", "a", "next_a", "1", "next_a", "kake = max(kake_t, kake_a)", "kake", "max(kake_t, kake_a)", "max", "kake_t", "kake_a", "t = next_t * kake", "t", "next_t * kake", "next_t", "kake", "a = next_a * kake", "a", "next_a * kake", "next_a", "kake", "print(int(a + t))", "print", "int(a + t)", "int", "a + t", "a", "t", "next_a = map(int, input().split())", "map(int, input().split())", "next_a", "a = next_a * kake", "next_a * kake", "a", "t = 1", "1", "t", "kake_a = (a + next_a - 1) // next_a", "(a + next_a - 1) // next_a", "kake_a", "a = 1", "1", "a", "t = next_t * kake", "next_t * kake", "t", "kake_t = (t + next_t - 1) // next_t", "(t + next_t - 1) // next_t", "kake_t", "next_t, next_a = map(int, input().split())", "map(int, input().split())", "next_t", "n = int(input())", "int(input())", "n", "kake = max(kake_t, kake_a)", "max(kake_t, kake_a)", "kake" ]

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

[ [ 14, 6 ], [ 16, 7 ], [ 14, 10 ], [ 16, 11 ], [ 14, 14 ], [ 16, 16 ], [ 88, 18 ], [ 94, 24 ], [ 94, 27 ], [ 31, 30 ], [ 89, 33 ], [ 97, 35 ], [ 97, 44 ], [ 76, 46 ], [ 74, 50 ], [ 92, 51 ], [ 86, 51 ], [ 83, 52 ], [ 74, 54 ], [ 95, 55 ], [ 80, 55 ], [ 98, 56 ], [ 85, 58 ], [ 83, 60 ], [ 77, 61 ], [ 79, 63 ], [ 98, 65 ], [ 77, 66 ], [ 86, 70 ], [ 92, 70 ], [ 80, 71 ], [ 95, 71 ], [ 76, 77 ], [ 79, 80 ], [ 97, 83 ], [ 85, 86 ], [ 88, 89 ], [ 94, 92 ], [ 94, 95 ], [ 97, 98 ] ]

[ "def ceil(a, b):\n return a // b + (a % b > 0)\n\nN = int(input())\nT = A = 1\nfor i in range(N):\n t, a = map(int, input().split())\n m = max(ceil(T, t), ceil(A, a))\n T = t * m\n A = a * m\nprint(T + A)", "def ceil(a, b):\n return a // b + (a % b > 0)", "ceil", "return a // b + (a % b > 0)", "a // b + (a % b > 0)", "a // b", "a", "b", "a % b > 0", "a % b", "a", "b", "0", "a", "a", "b", "b", "N = int(input())", "N", "int(input())", "int", "input()", "input", "T = A = 1", "T", "1", "= A = 1", "A", "1", "for i in range(N):\n t, a = map(int, input().split())\n m = max(ceil(T, t), ceil(A, a))\n T = t * m\n A = a * m", "i", "range(N)", "range", "N", "t, a = map(int, input().split())", "t", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "a", "m = max(ceil(T, t), ceil(A, a))", "m", "max(ceil(T, t), ceil(A, a))", "max", "ceil(T, t)", "ceil", "T", "t", "ceil(A, a)", "ceil", "A", "a", "T = t * m", "T", "t * m", "t", "m", "A = a * m", "A", "a * m", "a", "m", "print(T + A)", "print", "T + A", "T", "A", "def ceil(a, b):\n return a // b + (a % b > 0)", "def ceil(a, b):\n return a // b + (a % b > 0)", "ceil", "m = max(ceil(T, t), ceil(A, a))", "max(ceil(T, t), ceil(A, a))", "m", "A = a * m", "a * m", "A", "t, a = map(int, input().split())", "map(int, input().split())", "t", "T = t * m", "t * m", "T", "N = int(input())", "int(input())", "N", "T = A = 1", "1", "T", "A = 1", "1", "A", "a = map(int, input().split())", "map(int, input().split())", "a" ]

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

[ [ 84, 2 ], [ 87, 8 ], [ 75, 11 ], [ 15, 14 ], [ 85, 17 ], [ 99, 19 ], [ 99, 28 ], [ 81, 30 ], [ 88, 36 ], [ 79, 36 ], [ 100, 37 ], [ 100, 39 ], [ 93, 41 ], [ 76, 47 ], [ 103, 47 ], [ 97, 48 ], [ 97, 50 ], [ 90, 52 ], [ 82, 55 ], [ 94, 56 ], [ 78, 58 ], [ 100, 60 ], [ 91, 61 ], [ 102, 63 ], [ 97, 65 ], [ 91, 66 ], [ 79, 72 ], [ 88, 72 ], [ 103, 73 ], [ 76, 73 ], [ 75, 76 ], [ 78, 79 ], [ 81, 82 ], [ 84, 85 ], [ 87, 88 ], [ 90, 91 ], [ 93, 94 ], [ 99, 97 ], [ 99, 100 ], [ 102, 103 ] ]

[ "N = int(input())\ntakahashi = 1\naoki = 1\nfor _ in range(N):\n t, a = map(int, input().split())\n X = -(-(takahashi + t-1))//t # 切り上げ\n Y = -(-(aoki + a-1))//a # 切り上げ\n n = max(X, Y)\n takahashi = t*n\n aoki = a*n\n \nprint(int(takahashi+aoki))", "N = int(input())", "N", "int(input())", "int", "input()", "input", "takahashi = 1", "takahashi", "1", "aoki = 1", "aoki", "1", "for _ in range(N):\n t, a = map(int, input().split())\n X = -(-(takahashi + t-1))//t # 切り上げ\n Y = -(-(aoki + a-1))//a # 切り上げ\n n = max(X, Y)\n takahashi = t*n\n aoki = a*n\n ", "_", "range(N)", "range", "N", "t, a = map(int, input().split())", "t", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "a", "X = -(-(takahashi + t-1))//t", "X", "-(-(takahashi + t-1))//t", "-(-(takahashi + t-1))", "-(takahashi + t-1)", "takahashi + t-1", "takahashi + t", "takahashi", "t", "1", "t", "Y = -(-(aoki + a-1))//a", "Y", "-(-(aoki + a-1))//a", "-(-(aoki + a-1))", "-(aoki + a-1)", "aoki + a-1", "aoki + a", "aoki", "a", "1", "a", "n = max(X, Y)", "n", "max(X, Y)", "max", "X", "Y", "takahashi = t*n", "takahashi", "t*n", "t", "n", "aoki = a*n", "aoki", "a*n", "a", "n", "print(int(takahashi+aoki))", "print", "int(takahashi+aoki)", "int", "takahashi+aoki", "takahashi", "aoki", "aoki = 1", "1", "aoki", "takahashi = t*n", "t*n", "takahashi", "X = -(-(takahashi + t-1))//t", "-(-(takahashi + t-1))//t", "X", "N = int(input())", "int(input())", "N", "takahashi = 1", "1", "takahashi", "n = max(X, Y)", "max(X, Y)", "n", "Y = -(-(aoki + a-1))//a", "-(-(aoki + a-1))//a", "Y", "a = map(int, input().split())", "map(int, input().split())", "a", "t, a = map(int, input().split())", "map(int, input().split())", "t", "aoki = a*n", "a*n", "aoki" ]

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

[ [ 20, 6 ], [ 22, 7 ], [ 20, 11 ], [ 22, 12 ], [ 20, 16 ], [ 22, 17 ], [ 20, 20 ], [ 22, 22 ], [ 81, 24 ], [ 90, 26 ], [ 93, 29 ], [ 36, 35 ], [ 94, 38 ], [ 99, 40 ], [ 99, 49 ], [ 102, 51 ], [ 97, 55 ], [ 82, 56 ], [ 79, 56 ], [ 88, 57 ], [ 97, 59 ], [ 91, 60 ], [ 85, 60 ], [ 100, 61 ], [ 78, 63 ], [ 103, 65 ], [ 88, 66 ], [ 84, 68 ], [ 103, 70 ], [ 100, 71 ], [ 79, 75 ], [ 82, 75 ], [ 85, 76 ], [ 91, 76 ], [ 78, 79 ], [ 81, 82 ], [ 84, 85 ], [ 99, 88 ], [ 90, 91 ], [ 93, 94 ], [ 99, 100 ], [ 102, 103 ] ]

[ "def ceil(a0,b0):\n if a0%b0 == 0:\n return a0//b0\n else:\n return a0//b0 +1\n\nt_num,a_num = 1,1\n\nn = int(input())\n\nfor i in range(n):\n t,a = map(int,input().split())\n k = max(ceil(t_num,t),ceil(a_num,a))\n #その比に票を合わせる\n t_num = k*t\n a_num = k*a\n #print([t_num,a_num]) \n\nprint(t_num + a_num)", "def ceil(a0,b0):\n if a0%b0 == 0:\n return a0//b0\n else:\n return a0//b0 +1", "ceil", "if a0%b0 == 0:\n return a0//b0\n else:\n return a0//b0 +1", "a0%b0 == 0", "a0%b0", "a0", "b0", "0", "return a0//b0", "a0//b0", "a0", "b0", "return a0//b0 +1", "a0//b0 +1", "a0//b0", "a0", "b0", "1", "a0", "a0", "b0", "b0", "t_num,a_num = 1,1", "t_num", "1", "a_num", "1", "n = int(input())", "n", "int(input())", "int", "input()", "input", "for i in range(n):\n t,a = map(int,input().split())\n k = max(ceil(t_num,t),ceil(a_num,a))\n #その比に票を合わせる\n t_num = k*t\n a_num = k*a\n #print([t_num,a_num]) ", "i", "range(n)", "range", "n", "t,a = map(int,input().split())", "t", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "a", "k = max(ceil(t_num,t),ceil(a_num,a))", "k", "max(ceil(t_num,t),ceil(a_num,a))", "max", "ceil(t_num,t)", "ceil", "t_num", "t", "ceil(a_num,a)", "ceil", "a_num", "a", "t_num = k*t", "t_num", "k*t", "k", "t", "a_num = k*a", "a_num", "k*a", "k", "a", "print(t_num + a_num)", "print", "t_num + a_num", "t_num", "a_num", "t_num = k*t", "k*t", "t_num", "t_num,a_num = 1,1", "1", "t_num", "a_num = k*a", "k*a", "a_num", "t,a = map(int,input().split())", "map(int,input().split())", "t", "a_num = 1,1", "1", "a_num", "n = int(input())", "int(input())", "n", "def ceil(a0,b0):\n if a0%b0 == 0:\n return a0//b0\n else:\n return a0//b0 +1", "def ceil(a0,b0):\n if a0%b0 == 0:\n return a0//b0\n else:\n return a0//b0 +1", "ceil", "a = map(int,input().split())", "map(int,input().split())", "a", "k = max(ceil(t_num,t),ceil(a_num,a))", "max(ceil(t_num,t),ceil(a_num,a))", "k" ]

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

[ [ 114, 4 ], [ 120, 10 ], [ 120, 19 ], [ 22, 21 ], [ 115, 25 ], [ 111, 27 ], [ 111, 36 ], [ 109, 40 ], [ 121, 41 ], [ 136, 41 ], [ 100, 41 ], [ 112, 43 ], [ 103, 44 ], [ 130, 44 ], [ 127, 44 ], [ 99, 46 ], [ 109, 47 ], [ 126, 48 ], [ 112, 49 ], [ 117, 52 ], [ 100, 54 ], [ 121, 54 ], [ 136, 54 ], [ 109, 55 ], [ 123, 56 ], [ 127, 58 ], [ 103, 58 ], [ 130, 58 ], [ 112, 59 ], [ 100, 63 ], [ 121, 63 ], [ 136, 63 ], [ 109, 64 ], [ 132, 67 ], [ 127, 72 ], [ 103, 72 ], [ 130, 72 ], [ 112, 73 ], [ 105, 76 ], [ 135, 79 ], [ 109, 81 ], [ 133, 84 ], [ 118, 84 ], [ 106, 85 ], [ 124, 85 ], [ 129, 86 ], [ 112, 88 ], [ 133, 91 ], [ 118, 91 ], [ 106, 92 ], [ 124, 92 ], [ 136, 96 ], [ 100, 96 ], [ 121, 96 ], [ 130, 97 ], [ 127, 97 ], [ 103, 97 ], [ 109, 99 ], [ 99, 100 ], [ 120, 103 ], [ 105, 106 ], [ 111, 109 ], [ 111, 112 ], [ 114, 115 ], [ 117, 118 ], [ 120, 121 ], [ 123, 124 ], [ 112, 126 ], [ 126, 127 ], [ 129, 130 ], [ 132, 133 ], [ 135, 136 ] ]

[ "import fractions\nN=int(input())\nT,A=map(int,input().split())\nfor i in range(1,N):\n nT,nA=map(int,input().split())\n if(nT>=T and nA>=A):\n T,A=nT,nA\n continue\n pT,pA=T//nT,A//nA\n if(T%nT!=0):\n pT+=1\n if(A%nA!=0):\n pA+=1\n T,A=nT*max(pT,pA),nA*max(pT,pA)\nprint(T+A)", "import fractions", "fractions", "N=int(input())", "N", "int(input())", "int", "input()", "input", "T,A=map(int,input().split())", "T", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "A", "for i in range(1,N):\n nT,nA=map(int,input().split())\n if(nT>=T and nA>=A):\n T,A=nT,nA\n continue\n pT,pA=T//nT,A//nA\n if(T%nT!=0):\n pT+=1\n if(A%nA!=0):\n pA+=1\n T,A=nT*max(pT,pA),nA*max(pT,pA)", "i", "range(1,N)", "range", "1", "N", "nT,nA=map(int,input().split())", "nT", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "nA", "if(nT>=T and nA>=A):\n T,A=nT,nA\n continue\n ", "nT>=T and nA>=A", "nT>=T", "nT", "T", "nA>=A", "nA", "A", "T,A=nT,nA", "T", "nT", "A", "nA", "continue", "pT,pA=T//nT,A//nA", "pT", "T//nT", "T", "nT", "pA", "A//nA", "A", "nA", "if(T%nT!=0):\n pT+=1\n ", "T%nT!=0", "T%nT", "T", "nT", "0", "pT+=1", "pT", "1", "if(A%nA!=0):\n pA+=1\n ", "A%nA!=0", "A%nA", "A", "nA", "0", "pA+=1", "pA", "1", "T,A=nT*max(pT,pA),nA*max(pT,pA)", "T", "nT*max(pT,pA)", "nT", "max(pT,pA)", "max", "pT", "pA", "A", "nA*max(pT,pA)", "nA", "max(pT,pA)", "max", "pT", "pA", "print(T+A)", "print", "T+A", "T", "A", "T,A=nT,nA", "nT", "T", "A=map(int,input().split())", "map(int,input().split())", "A", "pA+=1", "1", "pA", "nT,nA=map(int,input().split())", "map(int,input().split())", "nT", "nA=map(int,input().split())", "map(int,input().split())", "nA", "N=int(input())", "int(input())", "N", "pT,pA=T//nT,A//nA", "T//nT", "pT", "T,A=map(int,input().split())", "map(int,input().split())", "T", "pA=T//nT,A//nA", "A//nA", "pA", "A=nT,nA", "nA", "A", "A=nT*max(pT,pA),nA*max(pT,pA)", "nA*max(pT,pA)", "A", "pT+=1", "1", "pT", "T,A=nT*max(pT,pA),nA*max(pT,pA)", "nT*max(pT,pA)", "T" ]

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

[ [ 99, 2 ], [ 10, 9 ], [ 100, 12 ], [ 105, 25 ], [ 108, 28 ], [ 106, 30 ], [ 34, 33 ], [ 100, 37 ], [ 111, 39 ], [ 109, 45 ], [ 106, 50 ], [ 33, 51 ], [ 109, 56 ], [ 106, 61 ], [ 33, 62 ], [ 102, 65 ], [ 71, 68 ], [ 109, 69 ], [ 106, 74 ], [ 33, 75 ], [ 103, 77 ], [ 112, 77 ], [ 82, 79 ], [ 109, 80 ], [ 106, 85 ], [ 33, 86 ], [ 103, 88 ], [ 112, 88 ], [ 109, 93 ], [ 109, 96 ], [ 99, 100 ], [ 102, 103 ], [ 105, 106 ], [ 108, 109 ], [ 111, 112 ] ]

[ "\nn = int(input())\nda = [list(map(int,input().split())) for i in range(n)]\n\nnow = da[0]\nfor i in range(1,n):\n co = max((now[0] - 1)// da[i][0], (now[1] - 1)// da[i][1])\n co += 1\n now[0] = da[i][0] * co\n now[1] = da[i][1] * co\nprint(now[0] + now[1])", "n = int(input())", "n", "int(input())", "int", "input()", "input", "list(map(int,input().split())) for i in range(n)", "for i in range(n)", "i", "range(n)", "range", "n", "for i in range(n)", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "da = [list(map(int,input().split())) for i in range(n)]", "da", "[list(map(int,input().split())) for i in range(n)]", "now = da[0]", "now", "da[0]", "da", "0", "for i in range(1,n):\n co = max((now[0] - 1)// da[i][0], (now[1] - 1)// da[i][1])\n co += 1\n now[0] = da[i][0] * co\n now[1] = da[i][1] * co", "i", "range(1,n)", "range", "1", "n", "co = max((now[0] - 1)// da[i][0], (now[1] - 1)// da[i][1])", "co", "max((now[0] - 1)// da[i][0], (now[1] - 1)// da[i][1])", "max", "(now[0] - 1)// da[i][0]", "now[0] - 1", "now[0]", "now", "0", "1", "da[i][0]", "[i]", "da", "i", "0", "(now[1] - 1)// da[i][1]", "now[1] - 1", "now[1]", "now", "1", "1", "da[i][1]", "[i]", "da", "i", "1", "co += 1", "co", "1", "now[0] = da[i][0] * co", "now[0]", "now", "0", "da[i][0] * co", "da[i][0]", "[i]", "da", "i", "0", "co", "now[1] = da[i][1] * co", "now[1]", "now", "1", "da[i][1] * co", "da[i][1]", "[i]", "da", "i", "1", "co", "print(now[0] + now[1])", "print", "now[0] + now[1]", "now[0]", "now", "0", "now[1]", "now", "1", "n = int(input())", "int(input())", "n", "co += 1", "1", "co", "da = [list(map(int,input().split())) for i in range(n)]", "[list(map(int,input().split())) for i in range(n)]", "da", "now = da[0]", "da[0]", "now", "co = max((now[0] - 1)// da[i][0], (now[1] - 1)// da[i][1])", "max((now[0] - 1)// da[i][0], (now[1] - 1)// da[i][1])", "co" ]

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

[ [ 91, 2 ], [ 10, 9 ], [ 92, 12 ], [ 88, 25 ], [ 82, 28 ], [ 100, 30 ], [ 34, 33 ], [ 92, 36 ], [ 85, 38 ], [ 83, 44 ], [ 95, 44 ], [ 89, 47 ], [ 33, 48 ], [ 101, 52 ], [ 98, 52 ], [ 89, 55 ], [ 33, 56 ], [ 94, 59 ], [ 89, 63 ], [ 33, 64 ], [ 86, 66 ], [ 97, 68 ], [ 89, 72 ], [ 33, 73 ], [ 86, 75 ], [ 95, 79 ], [ 83, 79 ], [ 98, 80 ], [ 101, 80 ], [ 82, 83 ], [ 85, 86 ], [ 88, 89 ], [ 91, 92 ], [ 94, 95 ], [ 97, 98 ], [ 100, 101 ] ]

[ "n=int(input())\nta=[list(map(int,input().split())) for i in range(n)]\na,b=1,1\nfor i in range(n):\n l=-min(-a//ta[i][0],-b//ta[i][1])\n a=ta[i][0]*l\n b=ta[i][1]*l\nprint(a+b)", "n=int(input())", "n", "int(input())", "int", "input()", "input", "list(map(int,input().split())) for i in range(n)", "for i in range(n)", "i", "range(n)", "range", "n", "for i in range(n)", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "ta=[list(map(int,input().split())) for i in range(n)]", "ta", "[list(map(int,input().split())) for i in range(n)]", "a,b=1,1", "a", "1", "b", "1", "for i in range(n):\n l=-min(-a//ta[i][0],-b//ta[i][1])\n a=ta[i][0]*l\n b=ta[i][1]*l", "i", "range(n)", "range", "n", "l=-min(-a//ta[i][0],-b//ta[i][1])", "l", "-min(-a//ta[i][0],-b//ta[i][1])", "min(-a//ta[i][0],-b//ta[i][1])", "min", "-a//ta[i][0]", "-a", "a", "ta[i][0]", "[i]", "ta", "i", "0", "-b//ta[i][1]", "-b", "b", "ta[i][1]", "[i]", "ta", "i", "1", "a=ta[i][0]*l", "a", "ta[i][0]*l", "ta[i][0]", "[i]", "ta", "i", "0", "l", "b=ta[i][1]*l", "b", "ta[i][1]*l", "ta[i][1]", "[i]", "ta", "i", "1", "l", "print(a+b)", "print", "a+b", "a", "b", "a,b=1,1", "1", "a", "l=-min(-a//ta[i][0],-b//ta[i][1])", "-min(-a//ta[i][0],-b//ta[i][1])", "l", "ta=[list(map(int,input().split())) for i in range(n)]", "[list(map(int,input().split())) for i in range(n)]", "ta", "n=int(input())", "int(input())", "n", "a=ta[i][0]*l", "ta[i][0]*l", "a", "b=ta[i][1]*l", "ta[i][1]*l", "b", "b=1,1", "1", "b" ]

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

[ [ 74, 2 ], [ 101, 13 ], [ 83, 20 ], [ 102, 22 ], [ 98, 24 ], [ 75, 26 ], [ 98, 27 ], [ 30, 29 ], [ 84, 33 ], [ 89, 36 ], [ 75, 38 ], [ 89, 39 ], [ 92, 41 ], [ 78, 47 ], [ 81, 47 ], [ 90, 48 ], [ 90, 50 ], [ 99, 54 ], [ 96, 54 ], [ 87, 55 ], [ 87, 57 ], [ 80, 59 ], [ 90, 61 ], [ 93, 62 ], [ 95, 64 ], [ 87, 66 ], [ 93, 67 ], [ 81, 71 ], [ 78, 71 ], [ 96, 72 ], [ 99, 72 ], [ 74, 75 ], [ 98, 78 ], [ 80, 81 ], [ 83, 84 ], [ 89, 87 ], [ 89, 90 ], [ 92, 93 ], [ 95, 96 ], [ 98, 99 ], [ 101, 102 ] ]

[ "ma = lambda : map(int,input().split())\nni = lambda :int(input())\n\nn = ni()\npt,pa = ma()\nfor i in range(n-1):\n t,a = ma()\n l = max((pt+t-1)//t,(pa+a-1)//a)\n pt = t*l\n pa = a*l\nprint(pt+pa)", "ma = lambda : map(int,input().split())", "ma", "lambda : map(int,input().split())", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "ni = lambda :int(input())", "ni", "lambda :int(input())", "int(input())", "int", "input()", "input", "n = ni()", "n", "ni()", "ni", "pt,pa = ma()", "pt", "ma()", "ma", "pa", "for i in range(n-1):\n t,a = ma()\n l = max((pt+t-1)//t,(pa+a-1)//a)\n pt = t*l\n pa = a*l", "i", "range(n-1)", "range", "n-1", "n", "1", "t,a = ma()", "t", "ma()", "ma", "a", "l = max((pt+t-1)//t,(pa+a-1)//a)", "l", "max((pt+t-1)//t,(pa+a-1)//a)", "max", "(pt+t-1)//t", "pt+t-1", "pt+t", "pt", "t", "1", "t", "(pa+a-1)//a", "pa+a-1", "pa+a", "pa", "a", "1", "a", "pt = t*l", "pt", "t*l", "t", "l", "pa = a*l", "pa", "a*l", "a", "l", "print(pt+pa)", "print", "pt+pa", "pt", "pa", "ma = lambda : map(int,input().split())", "lambda : map(int,input().split())", "ma", "pt,pa = ma()", "ma()", "pt", "pt = t*l", "t*l", "pt", "n = ni()", "ni()", "n", "a = ma()", "ma()", "a", "t,a = ma()", "ma()", "t", "l = max((pt+t-1)//t,(pa+a-1)//a)", "max((pt+t-1)//t,(pa+a-1)//a)", "l", "pa = a*l", "a*l", "pa", "pa = ma()", "ma()", "pa", "ni = lambda :int(input())", "lambda :int(input())", "ni" ]

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

[ [ 154, 2 ], [ 10, 9 ], [ 155, 12 ], [ 172, 25 ], [ 178, 28 ], [ 173, 30 ], [ 173, 36 ], [ 166, 44 ], [ 179, 47 ], [ 158, 47 ], [ 152, 47 ], [ 182, 47 ], [ 170, 47 ], [ 149, 47 ], [ 148, 49 ], [ 163, 54 ], [ 149, 60 ], [ 179, 60 ], [ 158, 60 ], [ 152, 60 ], [ 182, 60 ], [ 170, 60 ], [ 160, 67 ], [ 164, 71 ], [ 142, 74 ], [ 149, 80 ], [ 179, 80 ], [ 158, 80 ], [ 152, 80 ], [ 182, 80 ], [ 170, 80 ], [ 145, 87 ], [ 143, 91 ], [ 161, 95 ], [ 149, 97 ], [ 179, 97 ], [ 158, 97 ], [ 152, 97 ], [ 182, 97 ], [ 170, 97 ], [ 169, 100 ], [ 146, 106 ], [ 149, 108 ], [ 179, 108 ], [ 158, 108 ], [ 152, 108 ], [ 182, 108 ], [ 170, 108 ], [ 181, 111 ], [ 164, 118 ], [ 161, 119 ], [ 146, 121 ], [ 143, 122 ], [ 151, 124 ], [ 157, 129 ], [ 175, 134 ], [ 158, 137 ], [ 152, 137 ], [ 182, 137 ], [ 170, 137 ], [ 149, 137 ], [ 179, 137 ], [ 176, 140 ], [ 142, 143 ], [ 145, 146 ], [ 148, 149 ], [ 151, 152 ], [ 154, 155 ], [ 157, 158 ], [ 160, 161 ], [ 163, 164 ], [ 166, 167 ], [ 169, 170 ], [ 172, 173 ], [ 175, 176 ], [ 178, 179 ], [ 181, 182 ] ]

[ "N = int(input())\nQ = [tuple(map(int, input().split())) for _ in range(N)]\nvote = Q[0] # 初期値はそのまま得票(互いに素)\n\nfor p, q in Q[1:]:\n if p == q:\n g = max(vote)\n vote = (g, g)\n # p基準: 現在の得票以上の最小のpの倍数\n p_v0 = ((vote[0] + p - 1) // p) * p\n p_v1 = q * p_v0 // p\n # q基準\n q_v1 = ((vote[1] + q - 1) // q) * q\n q_v0 = p * q_v1 // q\n # 減っていたら除外\n if p_v1 < vote[1]:\n vote = (q_v0, q_v1)\n elif q_v0 < vote[0]:\n vote = (p_v0, p_v1)\n else:\n # どっちもありえるなら小さいほう\n if p_v0 + p_v1 <= q_v0 + q_v1:\n vote = (p_v0, p_v1)\n else:\n vote = (q_v0, q_v1)\n\nans = sum(vote)\nprint(ans)", "N = int(input())", "N", "int(input())", "int", "input()", "input", "tuple(map(int, input().split())) for _ in range(N)", "for _ in range(N)", "_", "range(N)", "range", "N", "for _ in range(N)", "tuple(map(int, input().split()))", "tuple", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "Q = [tuple(map(int, input().split())) for _ in range(N)]", "Q", "[tuple(map(int, input().split())) for _ in range(N)]", "vote = Q[0]", "vote", "Q[0]", "Q", "0", "for p, q in Q[1:]:\n if p == q:\n g = max(vote)\n vote = (g, g)\n # p基準: 現在の得票以上の最小のpの倍数\n p_v0 = ((vote[0] + p - 1) // p) * p\n p_v1 = q * p_v0 // p\n # q基準\n q_v1 = ((vote[1] + q - 1) // q) * q\n q_v0 = p * q_v1 // q\n # 減っていたら除外\n if p_v1 < vote[1]:\n vote = (q_v0, q_v1)\n elif q_v0 < vote[0]:\n vote = (p_v0, p_v1)\n else:\n # どっちもありえるなら小さいほう\n if p_v0 + p_v1 <= q_v0 + q_v1:\n vote = (p_v0, p_v1)\n else:\n vote = (q_v0, q_v1)", "p", "q", "Q[1:]", "Q", "1:", "1", "if p == q:\n g = max(vote)\n vote = (g, g)\n # p基準: 現在の得票以上の最小のpの倍数\n ", "p == q", "p", "q", "g = max(vote)", "g", "max(vote)", "max", "vote", "vote = (g, g)", "vote", "(g, g)", "g", "g", "p_v0 = ((vote[0] + p - 1) // p) * p", "p_v0", "((vote[0] + p - 1) // p) * p", "(vote[0] + p - 1) // p", "vote[0] + p - 1", "vote[0] + p", "vote[0]", "vote", "0", "p", "1", "p", "p", "p_v1 = q * p_v0 // p", "p_v1", "q * p_v0 // p", "q * p_v0", "q", "p_v0", "p", "q_v1 = ((vote[1] + q - 1) // q) * q", "q_v1", "((vote[1] + q - 1) // q) * q", "(vote[1] + q - 1) // q", "vote[1] + q - 1", "vote[1] + q", "vote[1]", "vote", "1", "q", "1", "q", "q", "q_v0 = p * q_v1 // q", "q_v0", "p * q_v1 // q", "p * q_v1", "p", "q_v1", "q", "if p_v1 < vote[1]:\n vote = (q_v0, q_v1)\n elif q_v0 < vote[0]:\n vote = (p_v0, p_v1)\n else:\n # どっちもありえるなら小さいほう\n if p_v0 + p_v1 <= q_v0 + q_v1:\n vote = (p_v0, p_v1)\n else:\n vote = (q_v0, q_v1)", "p_v1 < vote[1]", "p_v1", "vote[1]", "vote", "1", "vote = (q_v0, q_v1)", "vote", "(q_v0, q_v1)", "q_v0", "q_v1", "elif q_v0 < vote[0]:\n vote = (p_v0, p_v1)\n ", "q_v0 < vote[0]", "q_v0", "vote[0]", "vote", "0", "vote = (p_v0, p_v1)", "vote", "(p_v0, p_v1)", "p_v0", "p_v1", "if p_v0 + p_v1 <= q_v0 + q_v1:\n vote = (p_v0, p_v1)\n else:\n vote = (q_v0, q_v1)", "p_v0 + p_v1 <= q_v0 + q_v1", "p_v0 + p_v1", "p_v0", "p_v1", "q_v0 + q_v1", "q_v0", "q_v1", "vote = (p_v0, p_v1)", "vote", "(p_v0, p_v1)", "p_v0", "p_v1", "vote = (q_v0, q_v1)", "vote", "(q_v0, q_v1)", "q_v0", "q_v1", "ans = sum(vote)", "ans", "sum(vote)", "sum", "vote", "print(ans)", "print", "ans", "q_v1 = ((vote[1] + q - 1) // q) * q", "((vote[1] + q - 1) // q) * q", "q_v1", "q_v0 = p * q_v1 // q", "p * q_v1 // q", "q_v0", "vote = (g, g)", "(g, g)", "vote", "vote = (p_v0, p_v1)", "(p_v0, p_v1)", "vote", "N = int(input())", "int(input())", "N", "vote = (q_v0, q_v1)", "(q_v0, q_v1)", "vote", "p_v1 = q * p_v0 // p", "q * p_v0 // p", "p_v1", "p_v0 = ((vote[0] + p - 1) // p) * p", "((vote[0] + p - 1) // p) * p", "p_v0", "g = max(vote)", "max(vote)", "g", "vote = (q_v0, q_v1)", "(q_v0, q_v1)", "vote", "Q = [tuple(map(int, input().split())) for _ in range(N)]", "[tuple(map(int, input().split())) for _ in range(N)]", "Q", "ans = sum(vote)", "sum(vote)", "ans", "vote = Q[0]", "Q[0]", "vote", "vote = (p_v0, p_v1)", "(p_v0, p_v1)", "vote" ]

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

[ [ 76, 2 ], [ 70, 8 ], [ 67, 11 ], [ 15, 14 ], [ 77, 17 ], [ 82, 19 ], [ 82, 28 ], [ 79, 30 ], [ 71, 38 ], [ 86, 38 ], [ 83, 40 ], [ 68, 47 ], [ 89, 47 ], [ 74, 49 ], [ 85, 52 ], [ 80, 54 ], [ 83, 55 ], [ 88, 57 ], [ 80, 59 ], [ 74, 60 ], [ 86, 64 ], [ 71, 64 ], [ 89, 65 ], [ 68, 65 ], [ 67, 68 ], [ 70, 71 ], [ 82, 74 ], [ 76, 77 ], [ 79, 80 ], [ 82, 83 ], [ 85, 86 ], [ 88, 89 ] ]

[ "n=int(input())\ntv=1\nav=1\nfor i in range(n):\n ti,ai=map(int,input().split())\n m=max(int((tv-1)//ti)+1,int((av-1)//ai)+1)\n tv=m*ti\n av=m*ai\nprint(tv+av)", "n=int(input())", "n", "int(input())", "int", "input()", "input", "tv=1", "tv", "1", "av=1", "av", "1", "for i in range(n):\n ti,ai=map(int,input().split())\n m=max(int((tv-1)//ti)+1,int((av-1)//ai)+1)\n tv=m*ti\n av=m*ai", "i", "range(n)", "range", "n", "ti,ai=map(int,input().split())", "ti", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "ai", "m=max(int((tv-1)//ti)+1,int((av-1)//ai)+1)", "m", "max(int((tv-1)//ti)+1,int((av-1)//ai)+1)", "max", "int((tv-1)//ti)+1", "int((tv-1)//ti)", "int", "(tv-1)//ti", "tv-1", "tv", "1", "ti", "1", "int((av-1)//ai)+1", "int((av-1)//ai)", "int", "(av-1)//ai", "av-1", "av", "1", "ai", "1", "tv=m*ti", "tv", "m*ti", "m", "ti", "av=m*ai", "av", "m*ai", "m", "ai", "print(tv+av)", "print", "tv+av", "tv", "av", "av=1", "1", "av", "tv=1", "1", "tv", "ai=map(int,input().split())", "map(int,input().split())", "ai", "n=int(input())", "int(input())", "n", "m=max(int((tv-1)//ti)+1,int((av-1)//ai)+1)", "max(int((tv-1)//ti)+1,int((av-1)//ai)+1)", "m", "ti,ai=map(int,input().split())", "map(int,input().split())", "ti", "tv=m*ti", "m*ti", "tv", "av=m*ai", "m*ai", "av" ]

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

[ [ 5, 4 ], [ 11, 10 ], [ 11, 19 ], [ 22, 21 ], [ 4, 25 ], [ 29, 28 ], [ 29, 37 ], [ 40, 39 ], [ 10, 45 ], [ 53, 45 ], [ 28, 46 ], [ 19, 50 ], [ 57, 50 ], [ 37, 51 ], [ 54, 53 ], [ 28, 55 ], [ 39, 56 ], [ 58, 57 ], [ 37, 59 ], [ 39, 60 ], [ 53, 64 ], [ 10, 64 ], [ 57, 65 ], [ 19, 65 ], [ 74, 71 ] ]

[ "def main():\n N = int(input())\n T1, A1 = map(int, input().split())\n for _ in range(N-1):\n T2, A2 = map(int, input().split())\n n = max(-(-T1//T2),-(-A1//A2))\n T1,A1 = T2*n,A2*n\n print(T1 + A1)\n\n\nif __name__ == '__main__':\n main()", "def main():\n N = int(input())\n T1, A1 = map(int, input().split())\n for _ in range(N-1):\n T2, A2 = map(int, input().split())\n n = max(-(-T1//T2),-(-A1//A2))\n T1,A1 = T2*n,A2*n\n print(T1 + A1)", "main", "N = int(input())", "N", "int(input())", "int", "input()", "input", "T1, A1 = map(int, input().split())", "T1", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "A1", "for _ in range(N-1):\n T2, A2 = map(int, input().split())\n n = max(-(-T1//T2),-(-A1//A2))\n T1,A1 = T2*n,A2*n\n ", "_", "range(N-1)", "range", "N-1", "N", "1", "T2, A2 = map(int, input().split())", "T2", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "A2", "n = max(-(-T1//T2),-(-A1//A2))", "n", "max(-(-T1//T2),-(-A1//A2))", "max", "-(-T1//T2)", "-T1//T2", "-T1", "T1", "T2", "-(-A1//A2)", "-A1//A2", "-A1", "A1", "A2", "T1,A1 = T2*n,A2*n", "T1", "T2*n", "T2", "n", "A1", "A2*n", "A2", "n", "print(T1 + A1)", "print", "T1 + A1", "T1", "A1", "if __name__ == '__main__':\n main()", "__name__ == '__main__'", "__name__", "'__main__'", "main()", "main", "def main():\n N = int(input())\n T1, A1 = map(int, input().split())\n for _ in range(N-1):\n T2, A2 = map(int, input().split())\n n = max(-(-T1//T2),-(-A1//A2))\n T1,A1 = T2*n,A2*n\n print(T1 + A1)", "def main():\n N = int(input())\n T1, A1 = map(int, input().split())\n for _ in range(N-1):\n T2, A2 = map(int, input().split())\n n = max(-(-T1//T2),-(-A1//A2))\n T1,A1 = T2*n,A2*n\n print(T1 + A1)", "main" ]

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

[ [ 117, 2 ], [ 129, 8 ], [ 129, 17 ], [ 20, 19 ], [ 118, 23 ], [ 123, 26 ], [ 123, 35 ], [ 138, 37 ], [ 99, 40 ], [ 115, 45 ], [ 136, 45 ], [ 121, 46 ], [ 108, 49 ], [ 115, 51 ], [ 136, 51 ], [ 121, 52 ], [ 102, 54 ], [ 115, 57 ], [ 136, 57 ], [ 121, 58 ], [ 130, 63 ], [ 127, 63 ], [ 124, 64 ], [ 132, 67 ], [ 130, 69 ], [ 127, 69 ], [ 124, 70 ], [ 105, 72 ], [ 130, 75 ], [ 127, 75 ], [ 124, 76 ], [ 111, 79 ], [ 103, 82 ], [ 109, 82 ], [ 139, 82 ], [ 106, 83 ], [ 133, 83 ], [ 100, 83 ], [ 135, 85 ], [ 121, 87 ], [ 112, 88 ], [ 126, 89 ], [ 124, 91 ], [ 112, 92 ], [ 136, 96 ], [ 115, 96 ], [ 127, 97 ], [ 130, 97 ], [ 99, 100 ], [ 102, 103 ], [ 105, 106 ], [ 108, 109 ], [ 111, 112 ], [ 129, 115 ], [ 117, 118 ], [ 123, 121 ], [ 123, 124 ], [ 126, 127 ], [ 129, 130 ], [ 132, 133 ], [ 135, 136 ], [ 138, 139 ] ]

[ "n = int(input())\nA,B = map(int,input().split())\nfor _ in range(n-1):\n a,b = map(int,input().split())\n aa = 0\n bb = 0\n if A % a == 0:\n aa = A // a\n else:\n aa = A // a + 1\n if B % b == 0:\n bb = B // b\n else:\n bb = B // b + 1\n m = max(aa, bb)\n A,B = a * m, b * m\nprint(A+B)", "n = int(input())", "n", "int(input())", "int", "input()", "input", "A,B = map(int,input().split())", "A", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "B", "for _ in range(n-1):\n a,b = map(int,input().split())\n aa = 0\n bb = 0\n if A % a == 0:\n aa = A // a\n else:\n aa = A // a + 1\n if B % b == 0:\n bb = B // b\n else:\n bb = B // b + 1\n m = max(aa, bb)\n A,B = a * m, b * m", "_", "range(n-1)", "range", "n-1", "n", "1", "a,b = map(int,input().split())", "a", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "aa = 0", "aa", "0", "bb = 0", "bb", "0", "if A % a == 0:\n aa = A // a\n else:\n aa = A // a + 1\n ", "A % a == 0", "A % a", "A", "a", "0", "aa = A // a", "aa", "A // a", "A", "a", "aa = A // a + 1", "aa", "A // a + 1", "A // a", "A", "a", "1", "if B % b == 0:\n bb = B // b\n else:\n bb = B // b + 1\n ", "B % b == 0", "B % b", "B", "b", "0", "bb = B // b", "bb", "B // b", "B", "b", "bb = B // b + 1", "bb", "B // b + 1", "B // b", "B", "b", "1", "m = max(aa, bb)", "m", "max(aa, bb)", "max", "aa", "bb", "A,B = a * m, b * m", "A", "a * m", "a", "m", "B", "b * m", "b", "m", "print(A+B)", "print", "A+B", "A", "B", "bb = 0", "0", "bb", "aa = A // a + 1", "A // a + 1", "aa", "bb = B // b + 1", "B // b + 1", "bb", "aa = A // a", "A // a", "aa", "m = max(aa, bb)", "max(aa, bb)", "m", "A,B = map(int,input().split())", "map(int,input().split())", "A", "n = int(input())", "int(input())", "n", "a,b = map(int,input().split())", "map(int,input().split())", "a", "b = map(int,input().split())", "map(int,input().split())", "b", "B = a * m, b * m", "b * m", "B", "B = map(int,input().split())", "map(int,input().split())", "B", "bb = B // b", "B // b", "bb", "A,B = a * m, b * m", "a * m", "A", "aa = 0", "0", "aa" ]

[ 7, 12, 13, 0, 13, 4, 13, 4, 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, 17, 13, 17, 28, 13, 4, 13, 13, 0, 13, 18, 13, 13, 13, 0, 13, 4, 13, 2, 2, 13, 13, 40, 2, 13, 13, 17, 2, 2, 13, 13, 40, 2, 13, 13, 17, 0, 13, 2, 13, 13, 13, 2, 13, 13, 4, 13, 2, 13, 13, 4, 13, 10, 12, 13 ]

[ [ 5, 4 ], [ 11, 10 ], [ 14, 13 ], [ 4, 16 ], [ 10, 19 ], [ 33, 32 ], [ 35, 34 ], [ 38, 37 ], [ 4, 40 ], [ 43, 42 ], [ 10, 44 ], [ 37, 45 ], [ 43, 46 ], [ 49, 48 ], [ 32, 53 ], [ 70, 53 ], [ 42, 54 ], [ 32, 57 ], [ 70, 57 ], [ 42, 58 ], [ 34, 62 ], [ 74, 62 ], [ 46, 63 ], [ 34, 66 ], [ 74, 66 ], [ 46, 67 ], [ 71, 70 ], [ 48, 72 ], [ 42, 73 ], [ 75, 74 ], [ 48, 76 ], [ 46, 77 ], [ 70, 81 ], [ 32, 81 ], [ 74, 82 ], [ 34, 82 ], [ 87, 84 ] ]

[ "\ndef resolve():\n\tn = int(input())\n\tv = []\n\tfor _ in range(n):\n\t\tv.append(list(map(int, input().split())))\n\tt, a = 1, 1\n\tfor i in range(n):\n\t\ttv, av = v[i]\n\t\tc = max(t//tv + (t%tv!=0), a//av + (a%av!=0))\n\t\tt, a = c*tv, c*av\n\tprint(t+a)\nresolve()", "def resolve():\n\tn = int(input())\n\tv = []\n\tfor _ in range(n):\n\t\tv.append(list(map(int, input().split())))\n\tt, a = 1, 1\n\tfor i in range(n):\n\t\ttv, av = v[i]\n\t\tc = max(t//tv + (t%tv!=0), a//av + (a%av!=0))\n\t\tt, a = c*tv, c*av\n\tprint(t+a)", "resolve", "n = int(input())", "n", "int(input())", "int", "input()", "input", "v = []", "v", "[]", "for _ in range(n):\n\t\tv.append(list(map(int, input().split())))\n\t", "_", "range(n)", "range", "n", "v.append(list(map(int, input().split())))", "v.append", "v", "append", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "t, a = 1, 1", "t", "1", "a", "1", "for i in range(n):\n\t\ttv, av = v[i]\n\t\tc = max(t//tv + (t%tv!=0), a//av + (a%av!=0))\n\t\tt, a = c*tv, c*av\n\t", "i", "range(n)", "range", "n", "tv, av = v[i]", "tv", "v[i]", "v", "i", "av", "c = max(t//tv + (t%tv!=0), a//av + (a%av!=0))", "c", "max(t//tv + (t%tv!=0), a//av + (a%av!=0))", "max", "t//tv + (t%tv!=0)", "t//tv", "t", "tv", "t%tv!=0", "t%tv", "t", "tv", "0", "a//av + (a%av!=0)", "a//av", "a", "av", "a%av!=0", "a%av", "a", "av", "0", "t, a = c*tv, c*av", "t", "c*tv", "c", "tv", "a", "c*av", "c", "av", "print(t+a)", "print", "t+a", "t", "a", "resolve()", "resolve", "def resolve():\n\tn = int(input())\n\tv = []\n\tfor _ in range(n):\n\t\tv.append(list(map(int, input().split())))\n\tt, a = 1, 1\n\tfor i in range(n):\n\t\ttv, av = v[i]\n\t\tc = max(t//tv + (t%tv!=0), a//av + (a%av!=0))\n\t\tt, a = c*tv, c*av\n\tprint(t+a)", "def resolve():\n\tn = int(input())\n\tv = []\n\tfor _ in range(n):\n\t\tv.append(list(map(int, input().split())))\n\tt, a = 1, 1\n\tfor i in range(n):\n\t\ttv, av = v[i]\n\t\tc = max(t//tv + (t%tv!=0), a//av + (a%av!=0))\n\t\tt, a = c*tv, c*av\n\tprint(t+a)", "resolve" ]

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

[ [ 60, 8 ], [ 85, 10 ], [ 69, 12 ], [ 73, 14 ], [ 69, 15 ], [ 18, 17 ], [ 61, 21 ], [ 75, 23 ], [ 73, 25 ], [ 75, 26 ], [ 87, 28 ], [ 70, 34 ], [ 82, 34 ], [ 76, 35 ], [ 76, 37 ], [ 64, 41 ], [ 79, 41 ], [ 67, 42 ], [ 67, 44 ], [ 81, 46 ], [ 76, 48 ], [ 88, 49 ], [ 78, 50 ], [ 67, 52 ], [ 88, 53 ], [ 82, 57 ], [ 70, 57 ], [ 79, 58 ], [ 64, 58 ], [ 60, 61 ], [ 69, 64 ], [ 75, 67 ], [ 69, 70 ], [ 75, 76 ], [ 78, 79 ], [ 81, 82 ], [ 87, 88 ] ]

[ "import sys\ndef I(): return int(sys.stdin.readline().rstrip())\ndef LI(): return list(map(int,sys.stdin.readline().rstrip().split())) #空白あり\n\nN = I()\nx,y = LI() # 高橋君、青木君の得票数\nfor i in range(1,N):\n T,A = LI()\n a = max((x+T-1)//T,(y+A-1)//A)\n x,y = T*a,A*a\n\nprint(x+y)", "import sys", "sys", "def I(): return int(sys.stdin.readline().rstrip())", "I", "def LI(): return list(map(int,sys.stdin.readline().rstrip().split())) #空白あり", "LI", "N = I()", "N", "I()", "I", "x,y = LI()", "x", "LI()", "LI", "y", "for i in range(1,N):\n T,A = LI()\n a = max((x+T-1)//T,(y+A-1)//A)\n x,y = T*a,A*a", "i", "range(1,N)", "range", "1", "N", "T,A = LI()", "T", "LI()", "LI", "A", "a = max((x+T-1)//T,(y+A-1)//A)", "a", "max((x+T-1)//T,(y+A-1)//A)", "max", "(x+T-1)//T", "x+T-1", "x+T", "x", "T", "1", "T", "(y+A-1)//A", "y+A-1", "y+A", "y", "A", "1", "A", "x,y = T*a,A*a", "x", "T*a", "T", "a", "y", "A*a", "A", "a", "print(x+y)", "print", "x+y", "x", "y", "N = I()", "I()", "N", "y = LI()", "LI()", "y", "A = LI()", "LI()", "A", "x,y = LI()", "LI()", "x", "def LI(): return list(map(int,sys.stdin.readline().rstrip().split())) #空白あり", "def LI(): return list(map(int,sys.stdin.readline().rstrip().split())) #空白あり", "LI", "T,A = LI()", "LI()", "T", "y = T*a,A*a", "A*a", "y", "x,y = T*a,A*a", "T*a", "x", "def I(): return int(sys.stdin.readline().rstrip())", "def I(): return int(sys.stdin.readline().rstrip())", "I", "a = max((x+T-1)//T,(y+A-1)//A)", "max((x+T-1)//T,(y+A-1)//A)", "a" ]

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

[ [ 94, 2 ], [ 10, 9 ], [ 95, 12 ], [ 88, 25 ], [ 79, 28 ], [ 34, 33 ], [ 95, 36 ], [ 91, 38 ], [ 89, 40 ], [ 33, 41 ], [ 91, 42 ], [ 76, 44 ], [ 80, 51 ], [ 86, 51 ], [ 83, 53 ], [ 80, 58 ], [ 86, 58 ], [ 92, 60 ], [ 85, 62 ], [ 83, 65 ], [ 77, 66 ], [ 92, 68 ], [ 77, 69 ], [ 86, 74 ], [ 80, 74 ], [ 76, 77 ], [ 79, 80 ], [ 91, 83 ], [ 85, 86 ], [ 88, 89 ], [ 91, 92 ], [ 94, 95 ] ]

[ "n = int(input())\nTA = [list(map(int, input().split())) for _ in range(n)]\n\n# from math import ceil\n\nres = [1, 1]\nfor i in range(n):\n t, a = TA[i]\n # mx = max(ceil(res[0] / t), ceil(res[1] / a))\n mx = max(-(-res[0] // t), -(-res[1] // a))\n res = [t * mx, a * mx]\n\nprint(sum(res))", "n = int(input())", "n", "int(input())", "int", "input()", "input", "list(map(int, input().split())) for _ in range(n)", "for _ in range(n)", "_", "range(n)", "range", "n", "for _ in range(n)", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "TA = [list(map(int, input().split())) for _ in range(n)]", "TA", "[list(map(int, input().split())) for _ in range(n)]", "res = [1, 1]", "res", "[1, 1]", "1", "1", "for i in range(n):\n t, a = TA[i]\n # mx = max(ceil(res[0] / t), ceil(res[1] / a))\n mx = max(-(-res[0] // t), -(-res[1] // a))\n res = [t * mx, a * mx]", "i", "range(n)", "range", "n", "t, a = TA[i]", "t", "TA[i]", "TA", "i", "a", "mx = max(-(-res[0] // t), -(-res[1] // a))", "mx", "max(-(-res[0] // t), -(-res[1] // a))", "max", "-(-res[0] // t)", "-res[0] // t", "-res[0]", "res[0]", "res", "0", "t", "-(-res[1] // a)", "-res[1] // a", "-res[1]", "res[1]", "res", "1", "a", "res = [t * mx, a * mx]", "res", "[t * mx, a * mx]", "t * mx", "t", "mx", "a * mx", "a", "mx", "print(sum(res))", "print", "sum(res)", "sum", "res", "mx = max(-(-res[0] // t), -(-res[1] // a))", "max(-(-res[0] // t), -(-res[1] // a))", "mx", "res = [1, 1]", "[1, 1]", "res", "t, a = TA[i]", "TA[i]", "t", "res = [t * mx, a * mx]", "[t * mx, a * mx]", "res", "TA = [list(map(int, input().split())) for _ in range(n)]", "[list(map(int, input().split())) for _ in range(n)]", "TA", "a = TA[i]", "TA[i]", "a", "n = int(input())", "int(input())", "n" ]

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

[ [ 116, 2 ], [ 10, 9 ], [ 117, 12 ], [ 122, 25 ], [ 113, 28 ], [ 123, 31 ], [ 128, 34 ], [ 123, 37 ], [ 42, 41 ], [ 117, 45 ], [ 125, 47 ], [ 114, 51 ], [ 120, 51 ], [ 123, 54 ], [ 41, 55 ], [ 123, 60 ], [ 41, 61 ], [ 134, 64 ], [ 129, 68 ], [ 132, 68 ], [ 123, 71 ], [ 41, 72 ], [ 123, 77 ], [ 41, 78 ], [ 110, 81 ], [ 126, 84 ], [ 135, 85 ], [ 119, 87 ], [ 111, 89 ], [ 123, 92 ], [ 41, 93 ], [ 131, 96 ], [ 111, 98 ], [ 123, 101 ], [ 41, 102 ], [ 120, 107 ], [ 114, 107 ], [ 132, 108 ], [ 129, 108 ], [ 110, 111 ], [ 113, 114 ], [ 116, 117 ], [ 119, 120 ], [ 122, 123 ], [ 125, 126 ], [ 128, 129 ], [ 131, 132 ], [ 134, 135 ] ]

[ "n=int(input())\na=[list(map(int,input().split())) for i in range(n)]\nx,y = a[0][0],a[0][1]\nfor i in range(1,n):\n xr=(x+a[i][0]-1)//a[i][0]\n yr=(y+a[i][1]-1)//a[i][1]\n r=max(xr,yr)\n x=r*a[i][0]\n y=r*a[i][1]\nprint(x+y)", "n=int(input())", "n", "int(input())", "int", "input()", "input", "list(map(int,input().split())) for i in range(n)", "for i in range(n)", "i", "range(n)", "range", "n", "for i in range(n)", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "a=[list(map(int,input().split())) for i in range(n)]", "a", "[list(map(int,input().split())) for i in range(n)]", "x,y = a[0][0],a[0][1]", "x", "a[0][0]", "[0]", "a", "0", "0", "y", "a[0][1]", "[0]", "a", "0", "1", "for i in range(1,n):\n xr=(x+a[i][0]-1)//a[i][0]\n yr=(y+a[i][1]-1)//a[i][1]\n r=max(xr,yr)\n x=r*a[i][0]\n y=r*a[i][1]", "i", "range(1,n)", "range", "1", "n", "xr=(x+a[i][0]-1)//a[i][0]", "xr", "(x+a[i][0]-1)//a[i][0]", "x+a[i][0]-1", "x+a[i][0]", "x", "a[i][0]", "[i]", "a", "i", "0", "1", "a[i][0]", "[i]", "a", "i", "0", "yr=(y+a[i][1]-1)//a[i][1]", "yr", "(y+a[i][1]-1)//a[i][1]", "y+a[i][1]-1", "y+a[i][1]", "y", "a[i][1]", "[i]", "a", "i", "1", "1", "a[i][1]", "[i]", "a", "i", "1", "r=max(xr,yr)", "r", "max(xr,yr)", "max", "xr", "yr", "x=r*a[i][0]", "x", "r*a[i][0]", "r", "a[i][0]", "[i]", "a", "i", "0", "y=r*a[i][1]", "y", "r*a[i][1]", "r", "a[i][1]", "[i]", "a", "i", "1", "print(x+y)", "print", "x+y", "x", "y", "r=max(xr,yr)", "max(xr,yr)", "r", "x,y = a[0][0],a[0][1]", "a[0][0]", "x", "n=int(input())", "int(input())", "n", "x=r*a[i][0]", "r*a[i][0]", "x", "a=[list(map(int,input().split())) for i in range(n)]", "[list(map(int,input().split())) for i in range(n)]", "a", "xr=(x+a[i][0]-1)//a[i][0]", "(x+a[i][0]-1)//a[i][0]", "xr", "y = a[0][0],a[0][1]", "a[0][1]", "y", "y=r*a[i][1]", "r*a[i][1]", "y", "yr=(y+a[i][1]-1)//a[i][1]", "(y+a[i][1]-1)//a[i][1]", "yr" ]

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

[ [ 97, 2 ], [ 10, 9 ], [ 9, 18 ], [ 91, 20 ], [ 91, 22 ], [ 25, 24 ], [ 98, 28 ], [ 33, 32 ], [ 32, 41 ], [ 94, 43 ], [ 94, 45 ], [ 85, 47 ], [ 92, 53 ], [ 101, 53 ], [ 95, 55 ], [ 80, 60 ], [ 89, 60 ], [ 83, 62 ], [ 100, 65 ], [ 95, 67 ], [ 86, 68 ], [ 88, 69 ], [ 83, 71 ], [ 86, 72 ], [ 101, 76 ], [ 92, 76 ], [ 89, 77 ], [ 80, 77 ], [ 91, 80 ], [ 94, 83 ], [ 85, 86 ], [ 88, 89 ], [ 91, 92 ], [ 94, 95 ], [ 97, 98 ], [ 100, 101 ] ]

[ "n = int(input())\na, b = [int(x) for x in input().split()]\nfor _ in range(n - 1):\n\tc, d = [int(x) for x in input().split()]\n\tk = max((a - 1) // c + 1, (b - 1) // d + 1)\n\ta, b = c * k, d * k\nprint(a + b)", "n = int(input())", "n", "int(input())", "int", "input()", "input", "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", "for _ in range(n - 1):\n\tc, d = [int(x) for x in input().split()]\n\tk = max((a - 1) // c + 1, (b - 1) // d + 1)\n\ta, b = c * k, d * k", "_", "range(n - 1)", "range", "n - 1", "n", "1", "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", "c, d = [int(x) for x in input().split()]", "c", "[int(x) for x in input().split()]", "d", "k = max((a - 1) // c + 1, (b - 1) // d + 1)", "k", "max((a - 1) // c + 1, (b - 1) // d + 1)", "max", "(a - 1) // c + 1", "(a - 1) // c", "a - 1", "a", "1", "c", "1", "(b - 1) // d + 1", "(b - 1) // d", "b - 1", "b", "1", "d", "1", "a, b = c * k, d * k", "a", "c * k", "c", "k", "b", "d * k", "d", "k", "print(a + b)", "print", "a + b", "a", "b", "b = [int(x) for x in input().split()]", "[int(x) for x in input().split()]", "b", "d = [int(x) for x in input().split()]", "[int(x) for x in input().split()]", "d", "k = max((a - 1) // c + 1, (b - 1) // d + 1)", "max((a - 1) // c + 1, (b - 1) // d + 1)", "k", "b = c * k, d * k", "d * k", "b", "a, b = [int(x) for x in input().split()]", "[int(x) for x in input().split()]", "a", "c, d = [int(x) for x in input().split()]", "[int(x) for x in input().split()]", "c", "n = int(input())", "int(input())", "n", "a, b = c * k, d * k", "c * k", "a" ]

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

[ [ 107, 4 ], [ 110, 17 ], [ 101, 31 ], [ 111, 34 ], [ 111, 35 ], [ 43, 39 ], [ 43, 42 ], [ 50, 49 ], [ 39, 53 ], [ 73, 53 ], [ 59, 58 ], [ 42, 62 ], [ 78, 62 ], [ 68, 67 ], [ 49, 70 ], [ 58, 71 ], [ 74, 73 ], [ 67, 76 ], [ 79, 78 ], [ 67, 81 ], [ 84, 83 ], [ 73, 85 ], [ 39, 85 ], [ 78, 86 ], [ 42, 86 ], [ 83, 88 ], [ 113, 94 ], [ 105, 96 ], [ 114, 99 ], [ 101, 102 ], [ 107, 108 ], [ 110, 111 ], [ 113, 114 ] ]

[ "import sys\n\nn = int(sys.stdin.readline().rstrip())\nab = map(int, sys.stdin.read().split())\nab = zip(ab, ab)\n\ndef main():\n c_a = c_b = 1\n for a, b in ab:\n t_a = (c_a + a - 1) // a\n t_b = (c_b + b - 1) // b\n t = max(t_a, t_b)\n c_a = a * t\n c_b = b * t\n \n ans = c_a + c_b\n return ans\n\nif __name__ == '__main__':\n ans = main()\n print(ans)", "import sys", "sys", "n = int(sys.stdin.readline().rstrip())", "n", "int(sys.stdin.readline().rstrip())", "int", "sys.stdin.readline().rstrip()", "sys.stdin.readline().rstrip", "sys.stdin.readline()", "sys.stdin.readline", "sys.stdin", "sys", "stdin", "readline", "rstrip", "ab = map(int, sys.stdin.read().split())", "ab", "map(int, sys.stdin.read().split())", "map", "int", "sys.stdin.read().split()", "sys.stdin.read().split", "sys.stdin.read()", "sys.stdin.read", "sys.stdin", "sys", "stdin", "read", "split", "ab = zip(ab, ab)", "ab", "zip(ab, ab)", "zip", "ab", "ab", "def main():\n c_a = c_b = 1\n for a, b in ab:\n t_a = (c_a + a - 1) // a\n t_b = (c_b + b - 1) // b\n t = max(t_a, t_b)\n c_a = a * t\n c_b = b * t\n \n ans = c_a + c_b\n return ans", "main", "c_a = c_b = 1", "c_a", "1", "= c_b = 1", "c_b", "1", "for a, b in ab:\n t_a = (c_a + a - 1) // a\n t_b = (c_b + b - 1) // b\n t = max(t_a, t_b)\n c_a = a * t\n c_b = b * t\n \n ", "a", "b", "ab", "t_a = (c_a + a - 1) // a", "t_a", "(c_a + a - 1) // a", "c_a + a - 1", "c_a + a", "c_a", "a", "1", "a", "t_b = (c_b + b - 1) // b", "t_b", "(c_b + b - 1) // b", "c_b + b - 1", "c_b + b", "c_b", "b", "1", "b", "t = max(t_a, t_b)", "t", "max(t_a, t_b)", "max", "t_a", "t_b", "c_a = a * t", "c_a", "a * t", "a", "t", "c_b = b * t", "c_b", "b * t", "b", "t", "ans = c_a + c_b", "ans", "c_a + c_b", "c_a", "c_b", "return ans", "ans", "if __name__ == '__main__':\n ans = main()\n print(ans)", "__name__ == '__main__'", "__name__", "'__main__'", "ans = main()", "ans", "main()", "main", "print(ans)", "print", "ans", "ab = zip(ab, ab)", "zip(ab, ab)", "ab", "def main():\n c_a = c_b = 1\n for a, b in ab:\n t_a = (c_a + a - 1) // a\n t_b = (c_b + b - 1) // b\n t = max(t_a, t_b)\n c_a = a * t\n c_b = b * t\n \n ans = c_a + c_b\n return ans", "def main():\n c_a = c_b = 1\n for a, b in ab:\n t_a = (c_a + a - 1) // a\n t_b = (c_b + b - 1) // b\n t = max(t_a, t_b)\n c_a = a * t\n c_b = b * t\n \n ans = c_a + c_b\n return ans", "main", "n = int(sys.stdin.readline().rstrip())", "int(sys.stdin.readline().rstrip())", "n", "ab = map(int, sys.stdin.read().split())", "map(int, sys.stdin.read().split())", "ab", "ans = main()", "main()", "ans" ]