Datasets:

---

codefuse-ai

/

GALLa

like 1

Follow

CodeFuse AI 145

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

[ [ 87, 3 ], [ 96, 9 ], [ 93, 21 ], [ 25, 24 ], [ 88, 27 ], [ 105, 29 ], [ 97, 32 ], [ 24, 33 ], [ 97, 35 ], [ 24, 36 ], [ 90, 38 ], [ 97, 41 ], [ 102, 43 ], [ 91, 47 ], [ 88, 48 ], [ 99, 50 ], [ 91, 54 ], [ 88, 55 ], [ 106, 62 ], [ 94, 62 ], [ 88, 65 ], [ 103, 66 ], [ 103, 67 ], [ 91, 71 ], [ 103, 72 ], [ 106, 75 ], [ 94, 75 ], [ 88, 78 ], [ 100, 79 ], [ 100, 80 ], [ 91, 84 ], [ 100, 85 ], [ 87, 88 ], [ 90, 91 ], [ 93, 94 ], [ 96, 97 ], [ 99, 100 ], [ 102, 103 ], [ 105, 106 ] ]

[ "from math import ceil, floor\n\nn = int(input())\nls = list(map(int, input().split()))\nsqsm = 0\nfor i in range(n):\n sqsm += ls[i] * ls[i]\nsm = sum(ls)\nx1 = floor(sm / n)\nx2 = ceil(sm / n)\nprint(min(sqsm + n * x1 * x1 - 2 * sm * x1, sqsm + n * x2 * x2 - 2 * sm * x2))", "from math import ceil, floor", "n = int(input())", "n", "int(input())", "int", "input()", "input", "ls = list(map(int, input().split()))", "ls", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "sqsm = 0", "sqsm", "0", "for i in range(n):\n sqsm += ls[i] * ls[i]", "i", "range(n)", "range", "n", "sqsm += ls[i] * ls[i]", "sqsm", "ls[i] * ls[i]", "ls[i]", "ls", "i", "ls[i]", "ls", "i", "sm = sum(ls)", "sm", "sum(ls)", "sum", "ls", "x1 = floor(sm / n)", "x1", "floor(sm / n)", "floor", "sm / n", "sm", "n", "x2 = ceil(sm / n)", "x2", "ceil(sm / n)", "ceil", "sm / n", "sm", "n", "print(min(sqsm + n * x1 * x1 - 2 * sm * x1, sqsm + n * x2 * x2 - 2 * sm * x2))", "print", "min(sqsm + n * x1 * x1 - 2 * sm * x1, sqsm + n * x2 * x2 - 2 * sm * x2)", "min", "sqsm + n * x1 * x1 - 2 * sm * x1", "sqsm + n * x1 * x1", "sqsm", "n * x1 * x1", "n * x1", "n", "x1", "x1", "2 * sm * x1", "2 * sm", "2", "sm", "x1", "sqsm + n * x2 * x2 - 2 * sm * x2", "sqsm + n * x2 * x2", "sqsm", "n * x2 * x2", "n * x2", "n", "x2", "x2", "2 * sm * x2", "2 * sm", "2", "sm", "x2", "n = int(input())", "int(input())", "n", "sm = sum(ls)", "sum(ls)", "sm", "sqsm = 0", "0", "sqsm", "ls = list(map(int, input().split()))", "list(map(int, input().split()))", "ls", "x2 = ceil(sm / n)", "ceil(sm / n)", "x2", "x1 = floor(sm / n)", "floor(sm / n)", "x1", "sqsm += ls[i] * ls[i]", "ls[i] * ls[i]", "sqsm" ]

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

[ [ 77, 2 ], [ 86, 8 ], [ 89, 20 ], [ 87, 23 ], [ 74, 25 ], [ 87, 28 ], [ 92, 30 ], [ 36, 35 ], [ 75, 38 ], [ 90, 40 ], [ 83, 43 ], [ 47, 46 ], [ 87, 46 ], [ 68, 49 ], [ 46, 51 ], [ 35, 52 ], [ 80, 54 ], [ 69, 56 ], [ 71, 59 ], [ 93, 62 ], [ 72, 62 ], [ 81, 63 ], [ 84, 63 ], [ 72, 66 ], [ 93, 66 ], [ 68, 69 ], [ 71, 72 ], [ 74, 75 ], [ 77, 78 ], [ 80, 81 ], [ 83, 84 ], [ 86, 87 ], [ 89, 90 ], [ 92, 93 ] ]

[ "N = int(input())\nA = list(map(int, input().split()))\n\nmax_A = max(A)\nmin_A = min(A)\n\nans = 10**9\nfor y in range(min_A, max_A+1):\n tmp = 0\n for a in A:\n xsuby = a - y\n tmp += xsuby ** 2\n ans = min(ans, tmp)\n\nprint(ans)", "N = int(input())", "N", "int(input())", "int", "input()", "input", "A = list(map(int, input().split()))", "A", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "max_A = max(A)", "max_A", "max(A)", "max", "A", "min_A = min(A)", "min_A", "min(A)", "min", "A", "ans = 10**9", "ans", "10**9", "10", "9", "for y in range(min_A, max_A+1):\n tmp = 0\n for a in A:\n xsuby = a - y\n tmp += xsuby ** 2\n ans = min(ans, tmp)", "y", "range(min_A, max_A+1)", "range", "min_A", "max_A+1", "max_A", "1", "tmp = 0", "tmp", "0", "for a in A:\n xsuby = a - y\n tmp += xsuby ** 2\n ", "a", "A", "xsuby = a - y", "xsuby", "a - y", "a", "y", "tmp += xsuby ** 2", "tmp", "xsuby ** 2", "xsuby", "2", "ans = min(ans, tmp)", "ans", "min(ans, tmp)", "min", "ans", "tmp", "print(ans)", "print", "ans", "xsuby = a - y", "a - y", "xsuby", "ans = min(ans, tmp)", "min(ans, tmp)", "ans", "min_A = min(A)", "min(A)", "min_A", "N = int(input())", "int(input())", "N", "tmp += xsuby ** 2", "xsuby ** 2", "tmp", "tmp = 0", "0", "tmp", "A = list(map(int, input().split()))", "list(map(int, input().split()))", "A", "max_A = max(A)", "max(A)", "max_A", "ans = 10**9", "10**9", "ans" ]

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

[ [ 62, 2 ], [ 65, 8 ], [ 53, 20 ], [ 26, 25 ], [ 68, 31 ], [ 35, 34 ], [ 66, 34 ], [ 59, 37 ], [ 34, 40 ], [ 25, 41 ], [ 56, 44 ], [ 54, 47 ], [ 57, 47 ], [ 60, 48 ], [ 69, 48 ], [ 57, 51 ], [ 54, 51 ], [ 53, 54 ], [ 56, 57 ], [ 59, 60 ], [ 62, 63 ], [ 65, 66 ], [ 68, 69 ] ]

[ "n = int(input())\na = list(map(int, input().split()))\n\nans = 10**9\nfor i in range(-100, 101):\n cost = 0\n for j in a:\n cost += (j-i)**2\n ans = min(ans, cost)\nprint(ans)", "n = int(input())", "n", "int(input())", "int", "input()", "input", "a = list(map(int, input().split()))", "a", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "ans = 10**9", "ans", "10**9", "10", "9", "for i in range(-100, 101):\n cost = 0\n for j in a:\n cost += (j-i)**2\n ans = min(ans, cost)", "i", "range(-100, 101)", "range", "-100", "101", "cost = 0", "cost", "0", "for j in a:\n cost += (j-i)**2\n ", "j", "a", "cost += (j-i)**2", "cost", "(j-i)**2", "j-i", "j", "i", "2", "ans = min(ans, cost)", "ans", "min(ans, cost)", "min", "ans", "cost", "print(ans)", "print", "ans", "ans = 10**9", "10**9", "ans", "ans = min(ans, cost)", "min(ans, cost)", "ans", "cost += (j-i)**2", "(j-i)**2", "cost", "n = int(input())", "int(input())", "n", "a = list(map(int, input().split()))", "list(map(int, input().split()))", "a", "cost = 0", "0", "cost" ]

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

[ [ 5, 4 ], [ 12, 11 ], [ 11, 20 ], [ 23, 22 ], [ 26, 25 ], [ 22, 29 ], [ 4, 30 ], [ 34, 33 ], [ 22, 33 ], [ 33, 38 ], [ 53, 50 ] ]

[ "def c_be_together():\n N = int(input())\n A = [int(i) for i in input().split()]\n a_ave = sum(A) // N\n return min(sum([(a - option)**2 for a in A]) for option in (a_ave, a_ave + 1))\n\nprint(c_be_together())", "def c_be_together():\n N = int(input())\n A = [int(i) for i in input().split()]\n a_ave = sum(A) // N\n return min(sum([(a - option)**2 for a in A]) for option in (a_ave, a_ave + 1))", "c_be_together", "N = int(input())", "N", "int(input())", "int", "input()", "input", "int(i) for i in input().split()", "for i in input().split()", "i", "input().split()", "().split", "()", "input", "split", "for i in input().split()", "int(i)", "int", "i", "A = [int(i) for i in input().split()]", "A", "[int(i) for i in input().split()]", "a_ave = sum(A) // N", "a_ave", "sum(A) // N", "sum(A)", "sum", "A", "N", "(a - option)**2 for a in A", "for a in A", "a", "A", "for a in A", "(a - option)**2", "a - option", "a", "option", "2", "return min(sum([(a - option)**2 for a in A]) for option in (a_ave, a_ave + 1))", "min(sum([(a - option)**2 for a in A]) for option in (a_ave, a_ave + 1))", "min", "sum([(a - option)**2 for a in A])", "sum", "[(a - option)**2 for a in A]", "print(c_be_together())", "print", "c_be_together()", "c_be_together", "def c_be_together():\n N = int(input())\n A = [int(i) for i in input().split()]\n a_ave = sum(A) // N\n return min(sum([(a - option)**2 for a in A]) for option in (a_ave, a_ave + 1))", "def c_be_together():\n N = int(input())\n A = [int(i) for i in input().split()]\n a_ave = sum(A) // N\n return min(sum([(a - option)**2 for a in A]) for option in (a_ave, a_ave + 1))", "c_be_together" ]

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

[ [ 69, 2 ], [ 60, 8 ], [ 72, 20 ], [ 26, 25 ], [ 57, 31 ], [ 35, 34 ], [ 70, 37 ], [ 66, 39 ], [ 61, 43 ], [ 34, 44 ], [ 25, 45 ], [ 63, 48 ], [ 67, 51 ], [ 58, 51 ], [ 73, 52 ], [ 64, 52 ], [ 64, 55 ], [ 73, 55 ], [ 57, 58 ], [ 60, 61 ], [ 63, 64 ], [ 66, 67 ], [ 69, 70 ], [ 72, 73 ] ]

[ "n=int(input())\na=list(map(int,input().split()))\n\nmn=10**18\nfor i in range(-100,101):\n sm=0\n for k in range(n):\n sm+=(a[k]-i)**2\n mn=min(sm,mn)\n\nprint(mn)", "n=int(input())", "n", "int(input())", "int", "input()", "input", "a=list(map(int,input().split()))", "a", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "mn=10**18", "mn", "10**18", "10", "18", "for i in range(-100,101):\n sm=0\n for k in range(n):\n sm+=(a[k]-i)**2\n mn=min(sm,mn)", "i", "range(-100,101)", "range", "-100", "101", "sm=0", "sm", "0", "for k in range(n):\n sm+=(a[k]-i)**2\n ", "k", "range(n)", "range", "n", "sm+=(a[k]-i)**2", "sm", "(a[k]-i)**2", "a[k]-i", "a[k]", "a", "k", "i", "2", "mn=min(sm,mn)", "mn", "min(sm,mn)", "min", "sm", "mn", "print(mn)", "print", "mn", "sm=0", "0", "sm", "a=list(map(int,input().split()))", "list(map(int,input().split()))", "a", "mn=min(sm,mn)", "min(sm,mn)", "mn", "sm+=(a[k]-i)**2", "(a[k]-i)**2", "sm", "n=int(input())", "int(input())", "n", "mn=10**18", "10**18", "mn" ]

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

[ [ 54, 2 ], [ 45, 8 ], [ 48, 20 ], [ 46, 26 ], [ 55, 27 ], [ 51, 29 ], [ 33, 32 ], [ 46, 32 ], [ 57, 35 ], [ 49, 38 ], [ 32, 39 ], [ 58, 43 ], [ 52, 43 ], [ 45, 46 ], [ 48, 49 ], [ 51, 52 ], [ 54, 55 ], [ 57, 58 ] ]

[ "n = int(input())\nls = list(map(int,input().split()))\nmd = round(sum(ls)/n)\np = 0\nfor i in ls:\n p += (md-i)**2\nprint(p)", "n = int(input())", "n", "int(input())", "int", "input()", "input", "ls = list(map(int,input().split()))", "ls", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "md = round(sum(ls)/n)", "md", "round(sum(ls)/n)", "round", "sum(ls)/n", "sum(ls)", "sum", "ls", "n", "p = 0", "p", "0", "for i in ls:\n p += (md-i)**2", "i", "ls", "p += (md-i)**2", "p", "(md-i)**2", "md-i", "md", "i", "2", "print(p)", "print", "p", "ls = list(map(int,input().split()))", "list(map(int,input().split()))", "ls", "md = round(sum(ls)/n)", "round(sum(ls)/n)", "md", "p = 0", "0", "p", "n = int(input())", "int(input())", "n", "p += (md-i)**2", "(md-i)**2", "p" ]

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

[ [ 66, 2 ], [ 63, 8 ], [ 75, 20 ], [ 26, 25 ], [ 64, 30 ], [ 64, 34 ], [ 72, 37 ], [ 41, 40 ], [ 64, 40 ], [ 60, 43 ], [ 40, 46 ], [ 25, 47 ], [ 61, 51 ], [ 73, 51 ], [ 76, 52 ], [ 70, 52 ], [ 69, 54 ], [ 61, 55 ], [ 73, 55 ], [ 70, 58 ], [ 76, 58 ], [ 60, 61 ], [ 63, 64 ], [ 66, 67 ], [ 61, 69 ], [ 73, 69 ], [ 69, 70 ], [ 72, 73 ], [ 75, 76 ] ]

[ "n = int(input())\na = list(map(int, input().split()))\n\nt = 10**9\nfor i in range(min(a),max(a)+1):\n num = 0\n for h in a:\n num += (h-i)**2\n if num <= t:\n t = num\nprint(t)", "n = int(input())", "n", "int(input())", "int", "input()", "input", "a = list(map(int, input().split()))", "a", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "t = 10**9", "t", "10**9", "10", "9", "for i in range(min(a),max(a)+1):\n num = 0\n for h in a:\n num += (h-i)**2\n if num <= t:\n t = num", "i", "range(min(a),max(a)+1)", "range", "min(a)", "min", "a", "max(a)+1", "max(a)", "max", "a", "1", "num = 0", "num", "0", "for h in a:\n num += (h-i)**2\n ", "h", "a", "num += (h-i)**2", "num", "(h-i)**2", "h-i", "h", "i", "2", "if num <= t:\n t = num", "num <= t", "num", "t", "t = num", "t", "num", "print(t)", "print", "t", "num += (h-i)**2", "(h-i)**2", "num", "a = list(map(int, input().split()))", "list(map(int, input().split()))", "a", "n = int(input())", "int(input())", "n", "t = num", "num", "t", "num = 0", "0", "num", "t = 10**9", "10**9", "t" ]

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

[ [ 67, 2 ], [ 73, 8 ], [ 70, 20 ], [ 74, 24 ], [ 68, 25 ], [ 82, 27 ], [ 82, 30 ], [ 34, 33 ], [ 68, 36 ], [ 64, 38 ], [ 74, 42 ], [ 33, 43 ], [ 71, 44 ], [ 79, 47 ], [ 74, 52 ], [ 33, 53 ], [ 71, 54 ], [ 65, 61 ], [ 83, 61 ], [ 80, 62 ], [ 77, 62 ], [ 64, 65 ], [ 67, 68 ], [ 70, 71 ], [ 73, 74 ], [ 82, 77 ], [ 79, 80 ], [ 82, 83 ] ]

[ "n = int(input())\na = list(map(int,input().split()))\nave = sum(a)//n\nb = c = 0\nfor i in range(n):\n b += (a[i]-ave)**2\n c += (a[i] - ave - 1)**2\nprint(min(b,c))", "n = int(input())", "n", "int(input())", "int", "input()", "input", "a = list(map(int,input().split()))", "a", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "ave = sum(a)//n", "ave", "sum(a)//n", "sum(a)", "sum", "a", "n", "b = c = 0", "b", "0", "= c = 0", "c", "0", "for i in range(n):\n b += (a[i]-ave)**2\n c += (a[i] - ave - 1)**2", "i", "range(n)", "range", "n", "b += (a[i]-ave)**2", "b", "(a[i]-ave)**2", "a[i]-ave", "a[i]", "a", "i", "ave", "2", "c += (a[i] - ave - 1)**2", "c", "(a[i] - ave - 1)**2", "a[i] - ave - 1", "a[i] - ave", "a[i]", "a", "i", "ave", "1", "2", "print(min(b,c))", "print", "min(b,c)", "min", "b", "c", "b += (a[i]-ave)**2", "(a[i]-ave)**2", "b", "n = int(input())", "int(input())", "n", "ave = sum(a)//n", "sum(a)//n", "ave", "a = list(map(int,input().split()))", "list(map(int,input().split()))", "a", "c = 0", "0", "c", "c += (a[i] - ave - 1)**2", "(a[i] - ave - 1)**2", "c", "b = c = 0", "0", "b" ]

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

[ [ 70, 2 ], [ 73, 8 ], [ 76, 20 ], [ 74, 23 ], [ 79, 25 ], [ 74, 28 ], [ 67, 30 ], [ 34, 33 ], [ 77, 36 ], [ 80, 38 ], [ 64, 41 ], [ 45, 44 ], [ 74, 44 ], [ 82, 47 ], [ 44, 50 ], [ 33, 51 ], [ 68, 55 ], [ 83, 57 ], [ 65, 57 ], [ 68, 62 ], [ 64, 65 ], [ 67, 68 ], [ 70, 71 ], [ 73, 74 ], [ 76, 77 ], [ 79, 80 ], [ 82, 83 ] ]

[ "n = int(input())\na = list(map(int, input().split()))\n\nb = min(a)\nc = max(a)\nans = []\nfor i in range(b, c+1):\n res = 0\n for j in a:\n res += (j - i)**2\n ans.append(res)\n\nprint(min(ans))", "n = int(input())", "n", "int(input())", "int", "input()", "input", "a = list(map(int, input().split()))", "a", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b = min(a)", "b", "min(a)", "min", "a", "c = max(a)", "c", "max(a)", "max", "a", "ans = []", "ans", "[]", "for i in range(b, c+1):\n res = 0\n for j in a:\n res += (j - i)**2\n ans.append(res)", "i", "range(b, c+1)", "range", "b", "c+1", "c", "1", "res = 0", "res", "0", "for j in a:\n res += (j - i)**2\n ", "j", "a", "res += (j - i)**2", "res", "(j - i)**2", "j - i", "j", "i", "2", "ans.append(res)", "ans.append", "ans", "append", "res", "print(min(ans))", "print", "min(ans)", "min", "ans", "res = 0", "0", "res", "ans = []", "[]", "ans", "n = int(input())", "int(input())", "n", "a = list(map(int, input().split()))", "list(map(int, input().split()))", "a", "b = min(a)", "min(a)", "b", "c = max(a)", "max(a)", "c", "res += (j - i)**2", "(j - i)**2", "res" ]

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

[ [ 66, 2 ], [ 10, 9 ], [ 9, 18 ], [ 63, 20 ], [ 57, 23 ], [ 27, 26 ], [ 60, 32 ], [ 36, 35 ], [ 64, 35 ], [ 69, 38 ], [ 35, 41 ], [ 26, 42 ], [ 54, 45 ], [ 58, 48 ], [ 55, 48 ], [ 70, 49 ], [ 61, 49 ], [ 55, 52 ], [ 58, 52 ], [ 54, 55 ], [ 57, 58 ], [ 60, 61 ], [ 63, 64 ], [ 66, 67 ], [ 69, 70 ] ]

[ "n=int(input())\na=[int(i) for i in input().split()]\n\nans=10000000000000000\nfor criterion in range(-100,101):\n result=0\n for i in a:\n result+=(i-criterion)**2\n ans=min(ans,result)\nprint(ans)", "n=int(input())", "n", "int(input())", "int", "input()", "input", "int(i) for i in input().split()", "for i in input().split()", "i", "input().split()", "().split", "()", "input", "split", "for i in input().split()", "int(i)", "int", "i", "a=[int(i) for i in input().split()]", "a", "[int(i) for i in input().split()]", "ans=10000000000000000", "ans", "10000000000000000", "for criterion in range(-100,101):\n result=0\n for i in a:\n result+=(i-criterion)**2\n ans=min(ans,result)", "criterion", "range(-100,101)", "range", "-100", "101", "result=0", "result", "0", "for i in a:\n result+=(i-criterion)**2\n ", "i", "a", "result+=(i-criterion)**2", "result", "(i-criterion)**2", "i-criterion", "i", "criterion", "2", "ans=min(ans,result)", "ans", "min(ans,result)", "min", "ans", "result", "print(ans)", "print", "ans", "ans=min(ans,result)", "min(ans,result)", "ans", "ans=10000000000000000", "10000000000000000", "ans", "result=0", "0", "result", "a=[int(i) for i in input().split()]", "[int(i) for i in input().split()]", "a", "n=int(input())", "int(input())", "n", "result+=(i-criterion)**2", "(i-criterion)**2", "result" ]

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

[ [ 93, 16 ], [ 99, 23 ], [ 87, 28 ], [ 102, 34 ], [ 90, 46 ], [ 100, 47 ], [ 50, 49 ], [ 96, 55 ], [ 59, 58 ], [ 88, 61 ], [ 84, 63 ], [ 49, 66 ], [ 103, 68 ], [ 58, 69 ], [ 81, 72 ], [ 91, 75 ], [ 82, 75 ], [ 85, 76 ], [ 97, 76 ], [ 82, 79 ], [ 91, 79 ], [ 81, 82 ], [ 84, 85 ], [ 87, 88 ], [ 100, 90 ], [ 90, 91 ], [ 93, 94 ], [ 96, 97 ], [ 99, 100 ], [ 102, 103 ] ]

[ "import sys\nimport itertools\nsys.setrecursionlimit(1000000000)\nfrom heapq import heapify,heappop,heappush,heappushpop\nimport math\nimport collections\nMOD = 10**9+7\nMAX = 10**18\nn = int(input())\na = list(map(int,input().split()))\nans = MAX\nfor i in range(-100,101):\n cost = 0\n for j in range(n):\n cost += (i-a[j])**2\n ans = min(ans,cost)\nprint(ans)", "import sys", "sys", "import itertools", "itertools", "sys.setrecursionlimit(1000000000)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "1000000000", "from heapq import heapify,heappop,heappush,heappushpop", "import math", "math", "import collections", "collections", "MOD = 10**9+7", "MOD", "10**9+7", "10**9", "10", "9", "7", "MAX = 10**18", "MAX", "10**18", "10", "18", "n = int(input())", "n", "int(input())", "int", "input()", "input", "a = list(map(int,input().split()))", "a", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "ans = MAX", "ans", "MAX", "for i in range(-100,101):\n cost = 0\n for j in range(n):\n cost += (i-a[j])**2\n ans = min(ans,cost)", "i", "range(-100,101)", "range", "-100", "101", "cost = 0", "cost", "0", "for j in range(n):\n cost += (i-a[j])**2\n ", "j", "range(n)", "range", "n", "cost += (i-a[j])**2", "cost", "(i-a[j])**2", "i-a[j]", "i", "a[j]", "a", "j", "2", "ans = min(ans,cost)", "ans", "min(ans,cost)", "min", "ans", "cost", "print(ans)", "print", "ans", "ans = min(ans,cost)", "min(ans,cost)", "ans", "cost += (i-a[j])**2", "(i-a[j])**2", "cost", "n = int(input())", "int(input())", "n", "ans = MAX", "MAX", "ans", "MOD = 10**9+7", "10**9+7", "MOD", "cost = 0", "0", "cost", "MAX = 10**18", "10**18", "MAX", "a = list(map(int,input().split()))", "list(map(int,input().split()))", "a" ]

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

[ [ 5, 4 ], [ 11, 10 ], [ 23, 22 ], [ 10, 28 ], [ 10, 31 ], [ 34, 33 ], [ 37, 36 ], [ 10, 42 ], [ 45, 44 ], [ 22, 47 ], [ 10, 49 ], [ 36, 50 ], [ 22, 52 ], [ 10, 54 ], [ 36, 55 ], [ 44, 58 ], [ 33, 58 ], [ 63, 60 ] ]

[ "def main():\n n=int(input())\n num = list(map(int,input().split()))\n ave=round(sum(num)/len(num))\n ans=0\n for i in range(0,len(num)):\n ans+=(ave-num[i])*(ave-num[i])\n print(ans)\n\nmain()", "def main():\n n=int(input())\n num = list(map(int,input().split()))\n ave=round(sum(num)/len(num))\n ans=0\n for i in range(0,len(num)):\n ans+=(ave-num[i])*(ave-num[i])\n print(ans)", "main", "n=int(input())", "n", "int(input())", "int", "input()", "input", "num = list(map(int,input().split()))", "num", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "ave=round(sum(num)/len(num))", "ave", "round(sum(num)/len(num))", "round", "sum(num)/len(num)", "sum(num)", "sum", "num", "len(num)", "len", "num", "ans=0", "ans", "0", "for i in range(0,len(num)):\n ans+=(ave-num[i])*(ave-num[i])\n ", "i", "range(0,len(num))", "range", "0", "len(num)", "len", "num", "ans+=(ave-num[i])*(ave-num[i])", "ans", "(ave-num[i])*(ave-num[i])", "ave-num[i]", "ave", "num[i]", "num", "i", "ave-num[i]", "ave", "num[i]", "num", "i", "print(ans)", "print", "ans", "main()", "main", "def main():\n n=int(input())\n num = list(map(int,input().split()))\n ave=round(sum(num)/len(num))\n ans=0\n for i in range(0,len(num)):\n ans+=(ave-num[i])*(ave-num[i])\n print(ans)", "def main():\n n=int(input())\n num = list(map(int,input().split()))\n ave=round(sum(num)/len(num))\n ans=0\n for i in range(0,len(num)):\n ans+=(ave-num[i])*(ave-num[i])\n print(ans)", "main" ]

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

[ [ 90, 4 ], [ 96, 11 ], [ 87, 18 ], [ 33, 32 ], [ 91, 36 ], [ 39, 38 ], [ 91, 47 ], [ 51, 50 ], [ 88, 51 ], [ 54, 53 ], [ 60, 59 ], [ 63, 62 ], [ 38, 62 ], [ 66, 65 ], [ 62, 68 ], [ 53, 69 ], [ 73, 72 ], [ 50, 75 ], [ 72, 75 ], [ 65, 76 ], [ 59, 76 ], [ 72, 79 ], [ 50, 79 ], [ 94, 85 ], [ 87, 88 ], [ 90, 91 ], [ 96, 97 ] ]

[ "import sys\n\nreadline = sys.stdin.readline\nMOD = 10 ** 9 + 7\nINF = float('INF')\nsys.setrecursionlimit(10 ** 5)\n\n\ndef main():\n n = int(readline())\n a = list(map(int, readline().split()))\n\n ans = INF\n for i in range(-100, 101):\n score = 0\n for x in a:\n score += (x - i) ** 2\n ans = min(ans, score)\n\n print(ans)\n\n\nif __name__ == '__main__':\n main()", "import sys", "sys", "readline = sys.stdin.readline", "readline", "sys.stdin.readline", "sys.stdin", "sys", "stdin", "readline", "MOD = 10 ** 9 + 7", "MOD", "10 ** 9 + 7", "10 ** 9", "10", "9", "7", "INF = float('INF')", "INF", "float('INF')", "float", "'INF'", "sys.setrecursionlimit(10 ** 5)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "10 ** 5", "10", "5", "def main():\n n = int(readline())\n a = list(map(int, readline().split()))\n\n ans = INF\n for i in range(-100, 101):\n score = 0\n for x in a:\n score += (x - i) ** 2\n ans = min(ans, score)\n\n print(ans)", "main", "n = int(readline())", "n", "int(readline())", "int", "readline()", "readline", "a = list(map(int, readline().split()))", "a", "list(map(int, readline().split()))", "list", "map(int, readline().split())", "map", "int", "readline().split()", "().split", "()", "readline", "split", "ans = INF", "ans", "INF", "for i in range(-100, 101):\n score = 0\n for x in a:\n score += (x - i) ** 2\n ans = min(ans, score)\n\n ", "i", "range(-100, 101)", "range", "-100", "101", "score = 0", "score", "0", "for x in a:\n score += (x - i) ** 2\n ", "x", "a", "score += (x - i) ** 2", "score", "(x - i) ** 2", "x - i", "x", "i", "2", "ans = min(ans, score)", "ans", "min(ans, score)", "min", "ans", "score", "print(ans)", "print", "ans", "if __name__ == '__main__':\n main()", "__name__ == '__main__'", "__name__", "'__main__'", "main()", "main", "INF = float('INF')", "float('INF')", "INF", "readline = sys.stdin.readline", "sys.stdin.readline", "readline", "def main():\n n = int(readline())\n a = list(map(int, readline().split()))\n\n ans = INF\n for i in range(-100, 101):\n score = 0\n for x in a:\n score += (x - i) ** 2\n ans = min(ans, score)\n\n print(ans)", "def main():\n n = int(readline())\n a = list(map(int, readline().split()))\n\n ans = INF\n for i in range(-100, 101):\n score = 0\n for x in a:\n score += (x - i) ** 2\n ans = min(ans, score)\n\n print(ans)", "main", "MOD = 10 ** 9 + 7", "10 ** 9 + 7", "MOD" ]

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

[ [ 74, 7 ], [ 15, 14 ], [ 14, 24 ], [ 68, 26 ], [ 77, 29 ], [ 35, 34 ], [ 71, 40 ], [ 44, 43 ], [ 69, 43 ], [ 62, 46 ], [ 43, 49 ], [ 34, 50 ], [ 65, 53 ], [ 78, 56 ], [ 66, 56 ], [ 63, 57 ], [ 72, 57 ], [ 66, 60 ], [ 78, 60 ], [ 62, 63 ], [ 65, 66 ], [ 68, 69 ], [ 71, 72 ], [ 74, 75 ], [ 77, 78 ] ]

[ "import os, sys, re, math\n\nN = int(input())\na = [int(s) for s in input().split(' ')]\n\nret = float('inf')\nfor i in range(-100,101):\n s = 0\n for aj in a:\n s += (aj - i) ** 2\n ret = min(ret,s)\n\nprint(ret)", "import os, sys, re, math", "os", "sys", "re", "math", "N = int(input())", "N", "int(input())", "int", "input()", "input", "int(s) for s in input().split(' ')", "for s in input().split(' ')", "s", "input().split(' ')", "().split", "()", "input", "split", "' '", "for s in input().split(' ')", "int(s)", "int", "s", "a = [int(s) for s in input().split(' ')]", "a", "[int(s) for s in input().split(' ')]", "ret = float('inf')", "ret", "float('inf')", "float", "'inf'", "for i in range(-100,101):\n s = 0\n for aj in a:\n s += (aj - i) ** 2\n ret = min(ret,s)", "i", "range(-100,101)", "range", "-100", "101", "s = 0", "s", "0", "for aj in a:\n s += (aj - i) ** 2\n ", "aj", "a", "s += (aj - i) ** 2", "s", "(aj - i) ** 2", "aj - i", "aj", "i", "2", "ret = min(ret,s)", "ret", "min(ret,s)", "min", "ret", "s", "print(ret)", "print", "ret", "s += (aj - i) ** 2", "(aj - i) ** 2", "s", "ret = min(ret,s)", "min(ret,s)", "ret", "a = [int(s) for s in input().split(' ')]", "[int(s) for s in input().split(' ')]", "a", "s = 0", "0", "s", "N = int(input())", "int(input())", "N", "ret = float('inf')", "float('inf')", "ret" ]

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

[ [ 93, 2 ], [ 96, 8 ], [ 84, 20 ], [ 97, 25 ], [ 90, 27 ], [ 33, 32 ], [ 97, 37 ], [ 97, 41 ], [ 81, 44 ], [ 48, 47 ], [ 94, 50 ], [ 87, 52 ], [ 97, 57 ], [ 47, 58 ], [ 97, 64 ], [ 47, 65 ], [ 32, 66 ], [ 32, 68 ], [ 88, 72 ], [ 82, 72 ], [ 91, 73 ], [ 100, 73 ], [ 99, 75 ], [ 88, 76 ], [ 82, 76 ], [ 100, 79 ], [ 91, 79 ], [ 81, 82 ], [ 84, 85 ], [ 87, 88 ], [ 90, 91 ], [ 93, 94 ], [ 96, 97 ], [ 88, 99 ], [ 82, 99 ], [ 99, 100 ] ]

[ "# N =int(input())\n# a = list(map(int,input().split()))\n# ans = (10**9)\n# for av in range(min(a),max(a)+1):\n# Sum = 0\n# for i in range(N):\n# Sum += (a[i]-av)**2\n# if Sum < ans:\n# ans = Sum\n# print(ans)\n\nN =int(input())\na = list(map(int,input().split()))\nb = list(set(a))\nans = (10**9)\nfor av in range(min(a),max(a)+1):\n Sum = 0\n for i in range(N):\n Sum += a[i]**2-2*a[i]*av+av**2\n if Sum < ans:\n ans = Sum\nprint(ans)", "N =int(input())", "N", "int(input())", "int", "input()", "input", "a = list(map(int,input().split()))", "a", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b = list(set(a))", "b", "list(set(a))", "list", "set(a)", "set", "a", "ans = (10**9)", "ans", "10**9", "10", "9", "for av in range(min(a),max(a)+1):\n Sum = 0\n for i in range(N):\n Sum += a[i]**2-2*a[i]*av+av**2\n if Sum < ans:\n ans = Sum", "av", "range(min(a),max(a)+1)", "range", "min(a)", "min", "a", "max(a)+1", "max(a)", "max", "a", "1", "Sum = 0", "Sum", "0", "for i in range(N):\n Sum += a[i]**2-2*a[i]*av+av**2\n ", "i", "range(N)", "range", "N", "Sum += a[i]**2-2*a[i]*av+av**2", "Sum", "a[i]**2-2*a[i]*av+av**2", "a[i]**2-2*a[i]*av", "a[i]**2", "a[i]", "a", "i", "2", "2*a[i]*av", "2*a[i]", "2", "a[i]", "a", "i", "av", "av**2", "av", "2", "if Sum < ans:\n ans = Sum", "Sum < ans", "Sum", "ans", "ans = Sum", "ans", "Sum", "print(ans)", "print", "ans", "Sum = 0", "0", "Sum", "b = list(set(a))", "list(set(a))", "b", "Sum += a[i]**2-2*a[i]*av+av**2", "a[i]**2-2*a[i]*av+av**2", "Sum", "ans = (10**9)", "10**9", "ans", "N =int(input())", "int(input())", "N", "a = list(map(int,input().split()))", "list(map(int,input().split()))", "a", "ans = Sum", "Sum", "ans" ]

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

[ [ 85, 5 ], [ 73, 11 ], [ 76, 23 ], [ 74, 26 ], [ 77, 30 ], [ 77, 35 ], [ 70, 38 ], [ 77, 43 ], [ 79, 45 ], [ 77, 51 ], [ 88, 54 ], [ 58, 57 ], [ 74, 57 ], [ 82, 60 ], [ 80, 63 ], [ 71, 63 ], [ 77, 63 ], [ 57, 64 ], [ 83, 68 ], [ 89, 68 ], [ 70, 71 ], [ 73, 74 ], [ 76, 77 ], [ 79, 80 ], [ 82, 83 ], [ 85, 86 ], [ 88, 89 ] ]

[ "import math\nfrom statistics import mean\n\nn = int(input())\na = list(map(int, input().split()))\n\nm = mean(a)\nif m - math.floor(m) < 0.5:\n m = math.floor(m)\nelse:\n m = math.floor(m) + 1\n\ndiff = 0\nfor v in a:\n diff += (m - v) ** 2\n\nprint(diff)", "import math", "math", "from statistics import mean", "n = int(input())", "n", "int(input())", "int", "input()", "input", "a = list(map(int, input().split()))", "a", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "m = mean(a)", "m", "mean(a)", "mean", "a", "if m - math.floor(m) < 0.5:\n m = math.floor(m)\nelse:\n m = math.floor(m) + 1", "m - math.floor(m) < 0.5", "m - math.floor(m)", "m", "math.floor(m)", "math.floor", "math", "floor", "m", "0.5", "m = math.floor(m)", "m", "math.floor(m)", "math.floor", "math", "floor", "m", "m = math.floor(m) + 1", "m", "math.floor(m) + 1", "math.floor(m)", "math.floor", "math", "floor", "m", "1", "diff = 0", "diff", "0", "for v in a:\n diff += (m - v) ** 2", "v", "a", "diff += (m - v) ** 2", "diff", "(m - v) ** 2", "m - v", "m", "v", "2", "print(diff)", "print", "diff", "m = math.floor(m)", "math.floor(m)", "m", "a = list(map(int, input().split()))", "list(map(int, input().split()))", "a", "m = mean(a)", "mean(a)", "m", "m = math.floor(m) + 1", "math.floor(m) + 1", "m", "diff += (m - v) ** 2", "(m - v) ** 2", "diff", "n = int(input())", "int(input())", "n", "diff = 0", "0", "diff" ]

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

[ [ 95, 2 ], [ 89, 8 ], [ 98, 20 ], [ 24, 23 ], [ 96, 26 ], [ 86, 28 ], [ 90, 30 ], [ 23, 31 ], [ 83, 33 ], [ 87, 37 ], [ 99, 37 ], [ 96, 38 ], [ 80, 40 ], [ 84, 42 ], [ 92, 45 ], [ 107, 48 ], [ 52, 51 ], [ 96, 54 ], [ 101, 56 ], [ 90, 60 ], [ 51, 61 ], [ 84, 62 ], [ 104, 65 ], [ 90, 69 ], [ 51, 70 ], [ 81, 71 ], [ 102, 77 ], [ 93, 77 ], [ 105, 78 ], [ 108, 78 ], [ 80, 81 ], [ 83, 84 ], [ 86, 87 ], [ 89, 90 ], [ 92, 93 ], [ 95, 96 ], [ 98, 99 ], [ 101, 102 ], [ 104, 105 ], [ 107, 108 ] ]

[ "n = int(input())\na = list(map(int,input().split()))\nb = 0\n\nfor i in range(n):\n b += a[i]\n\nc = int(b/n)\nd = c + 1\ne = 0\nf = 0\n\nfor i in range(n):\n e += (a[i]-c)**2\n f += (a[i]-d)**2\n\nprint(min(e,f))\n", "n = int(input())", "n", "int(input())", "int", "input()", "input", "a = list(map(int,input().split()))", "a", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b = 0", "b", "0", "for i in range(n):\n b += a[i]", "i", "range(n)", "range", "n", "b += a[i]", "b", "a[i]", "a", "i", "c = int(b/n)", "c", "int(b/n)", "int", "b/n", "b", "n", "d = c + 1", "d", "c + 1", "c", "1", "e = 0", "e", "0", "f = 0", "f", "0", "for i in range(n):\n e += (a[i]-c)**2\n f += (a[i]-d)**2", "i", "range(n)", "range", "n", "e += (a[i]-c)**2", "e", "(a[i]-c)**2", "a[i]-c", "a[i]", "a", "i", "c", "2", "f += (a[i]-d)**2", "f", "(a[i]-d)**2", "a[i]-d", "a[i]", "a", "i", "d", "2", "print(min(e,f))", "print", "min(e,f)", "min", "e", "f", "d = c + 1", "c + 1", "d", "c = int(b/n)", "int(b/n)", "c", "b += a[i]", "a[i]", "b", "a = list(map(int,input().split()))", "list(map(int,input().split()))", "a", "e = 0", "0", "e", "n = int(input())", "int(input())", "n", "b = 0", "0", "b", "e += (a[i]-c)**2", "(a[i]-c)**2", "e", "f += (a[i]-d)**2", "(a[i]-d)**2", "f", "f = 0", "0", "f" ]

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

[ [ 76, 2 ], [ 82, 8 ], [ 73, 11 ], [ 88, 23 ], [ 74, 27 ], [ 83, 27 ], [ 77, 28 ], [ 89, 31 ], [ 89, 35 ], [ 79, 38 ], [ 89, 41 ], [ 85, 43 ], [ 89, 47 ], [ 91, 50 ], [ 54, 53 ], [ 77, 56 ], [ 70, 58 ], [ 74, 62 ], [ 83, 62 ], [ 53, 63 ], [ 86, 64 ], [ 80, 64 ], [ 89, 64 ], [ 71, 68 ], [ 92, 68 ], [ 70, 71 ], [ 73, 74 ], [ 76, 77 ], [ 79, 80 ], [ 82, 83 ], [ 85, 86 ], [ 88, 89 ], [ 91, 92 ] ]

[ "n=int(input())\na=[]\na=list(map(int,input().split()))\nave=sum(a)/n\nif ave<int(ave)+0.5:\n ave=int(ave)\nelse:\n ave=int(ave)+1\nans=0\nfor i in range(n):\n ans+=(a[i]-ave)**2\nprint(ans)", "n=int(input())", "n", "int(input())", "int", "input()", "input", "a=[]", "a", "[]", "a=list(map(int,input().split()))", "a", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "ave=sum(a)/n", "ave", "sum(a)/n", "sum(a)", "sum", "a", "n", "if ave<int(ave)+0.5:\n ave=int(ave)\nelse:\n ave=int(ave)+1", "ave<int(ave)+0.5", "ave", "int(ave)+0.5", "int(ave)", "int", "ave", "0.5", "ave=int(ave)", "ave", "int(ave)", "int", "ave", "ave=int(ave)+1", "ave", "int(ave)+1", "int(ave)", "int", "ave", "1", "ans=0", "ans", "0", "for i in range(n):\n ans+=(a[i]-ave)**2", "i", "range(n)", "range", "n", "ans+=(a[i]-ave)**2", "ans", "(a[i]-ave)**2", "a[i]-ave", "a[i]", "a", "i", "ave", "2", "print(ans)", "print", "ans", "ans+=(a[i]-ave)**2", "(a[i]-ave)**2", "ans", "a=list(map(int,input().split()))", "list(map(int,input().split()))", "a", "n=int(input())", "int(input())", "n", "ave=int(ave)", "int(ave)", "ave", "a=[]", "[]", "a", "ave=int(ave)+1", "int(ave)+1", "ave", "ave=sum(a)/n", "sum(a)/n", "ave", "ans=0", "0", "ans" ]

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

[ [ 116, 4 ], [ 110, 10 ], [ 128, 22 ], [ 128, 25 ], [ 29, 28 ], [ 111, 28 ], [ 131, 31 ], [ 28, 32 ], [ 107, 34 ], [ 28, 36 ], [ 132, 41 ], [ 123, 41 ], [ 117, 42 ], [ 108, 49 ], [ 129, 49 ], [ 132, 52 ], [ 123, 52 ], [ 117, 54 ], [ 125, 56 ], [ 132, 62 ], [ 123, 62 ], [ 117, 63 ], [ 119, 65 ], [ 132, 71 ], [ 123, 71 ], [ 117, 72 ], [ 113, 74 ], [ 117, 80 ], [ 126, 82 ], [ 132, 87 ], [ 123, 87 ], [ 126, 88 ], [ 108, 89 ], [ 129, 89 ], [ 117, 93 ], [ 120, 95 ], [ 132, 100 ], [ 123, 100 ], [ 120, 101 ], [ 108, 102 ], [ 129, 102 ], [ 114, 105 ], [ 107, 108 ], [ 110, 111 ], [ 113, 114 ], [ 116, 117 ], [ 119, 120 ], [ 128, 123 ], [ 125, 126 ], [ 128, 129 ], [ 28, 131 ], [ 131, 132 ] ]

[ "import math\n\nn = int(input())\ns = list(map(int,input().split()))\n\nb = c = 0\nfor i in s:\n b += i\n c += i**2\n\nif b%n == 0:\n print(int(c-b**2/n))\nelse:\n koho1 = math.floor(b/n)\n koho2 = math.ceil(b/n)\n ans = min(n*(koho1**2)-2*b*koho1+c,n*(koho2**2)-2*b*koho2+c)\n print(ans)", "import math", "math", "n = int(input())", "n", "int(input())", "int", "input()", "input", "s = list(map(int,input().split()))", "s", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b = c = 0", "b", "0", "= c = 0", "c", "0", "for i in s:\n b += i\n c += i**2", "i", "s", "b += i", "b", "i", "c += i**2", "c", "i**2", "i", "2", "if b%n == 0:\n print(int(c-b**2/n))\nelse:\n koho1 = math.floor(b/n)\n koho2 = math.ceil(b/n)\n ans = min(n*(koho1**2)-2*b*koho1+c,n*(koho2**2)-2*b*koho2+c)\n print(ans)", "b%n == 0", "b%n", "b", "n", "0", "print(int(c-b**2/n))", "print", "int(c-b**2/n)", "int", "c-b**2/n", "c", "b**2/n", "b**2", "b", "2", "n", "koho1 = math.floor(b/n)", "koho1", "math.floor(b/n)", "math.floor", "math", "floor", "b/n", "b", "n", "koho2 = math.ceil(b/n)", "koho2", "math.ceil(b/n)", "math.ceil", "math", "ceil", "b/n", "b", "n", "ans = min(n*(koho1**2)-2*b*koho1+c,n*(koho2**2)-2*b*koho2+c)", "ans", "min(n*(koho1**2)-2*b*koho1+c,n*(koho2**2)-2*b*koho2+c)", "min", "n*(koho1**2)-2*b*koho1+c", "n*(koho1**2)-2*b*koho1", "n*(koho1**2)", "n", "koho1**2", "koho1", "2", "2*b*koho1", "2*b", "2", "b", "koho1", "c", "n*(koho2**2)-2*b*koho2+c", "n*(koho2**2)-2*b*koho2", "n*(koho2**2)", "n", "koho2**2", "koho2", "2", "2*b*koho2", "2*b", "2", "b", "koho2", "c", "print(ans)", "print", "ans", "c += i**2", "i**2", "c", "s = list(map(int,input().split()))", "list(map(int,input().split()))", "s", "ans = min(n*(koho1**2)-2*b*koho1+c,n*(koho2**2)-2*b*koho2+c)", "min(n*(koho1**2)-2*b*koho1+c,n*(koho2**2)-2*b*koho2+c)", "ans", "n = int(input())", "int(input())", "n", "koho2 = math.ceil(b/n)", "math.ceil(b/n)", "koho2", "b = c = 0", "0", "b", "koho1 = math.floor(b/n)", "math.floor(b/n)", "koho1", "c = 0", "0", "c", "b += i", "i", "b" ]

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

[ [ 63, 2 ], [ 10, 9 ], [ 9, 18 ], [ 66, 20 ], [ 69, 23 ], [ 27, 26 ], [ 72, 33 ], [ 37, 36 ], [ 64, 39 ], [ 60, 41 ], [ 67, 45 ], [ 36, 46 ], [ 26, 47 ], [ 70, 51 ], [ 61, 53 ], [ 73, 53 ], [ 70, 58 ], [ 60, 61 ], [ 63, 64 ], [ 66, 67 ], [ 69, 70 ], [ 72, 73 ] ]

[ "N = int(input())\na = [int(x) for x in input().split()]\nans = []\nfor i in range(-100, 101, 1):\n v = 0\n for j in range(N):\n v += (a[j] - i) ** 2\n ans.append(v)\nprint(min(ans))", "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 = [int(x) for x in input().split()]", "a", "[int(x) for x in input().split()]", "ans = []", "ans", "[]", "for i in range(-100, 101, 1):\n v = 0\n for j in range(N):\n v += (a[j] - i) ** 2\n ans.append(v)", "i", "range(-100, 101, 1)", "range", "-100", "101", "1", "v = 0", "v", "0", "for j in range(N):\n v += (a[j] - i) ** 2\n ", "j", "range(N)", "range", "N", "v += (a[j] - i) ** 2", "v", "(a[j] - i) ** 2", "a[j] - i", "a[j]", "a", "j", "i", "2", "ans.append(v)", "ans.append", "ans", "append", "v", "print(min(ans))", "print", "min(ans)", "min", "ans", "v += (a[j] - i) ** 2", "(a[j] - i) ** 2", "v", "N = int(input())", "int(input())", "N", "a = [int(x) for x in input().split()]", "[int(x) for x in input().split()]", "a", "ans = []", "[]", "ans", "v = 0", "0", "v" ]

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

[ [ 59, 2 ], [ 53, 8 ], [ 68, 20 ], [ 26, 25 ], [ 62, 31 ], [ 35, 34 ], [ 54, 34 ], [ 56, 37 ], [ 34, 40 ], [ 25, 41 ], [ 65, 44 ], [ 69, 47 ], [ 66, 47 ], [ 57, 48 ], [ 63, 48 ], [ 66, 51 ], [ 69, 51 ], [ 53, 54 ], [ 56, 57 ], [ 59, 60 ], [ 62, 63 ], [ 65, 66 ], [ 68, 69 ] ]

[ "n = int(input())\nA = list(map(int,input().split()))\nans = 10**9\nfor i in range(-100,101):\n tmp = 0\n for a in A:\n tmp += (a-i)**2\n ans = min(ans, tmp)\nprint(ans)", "n = int(input())", "n", "int(input())", "int", "input()", "input", "A = list(map(int,input().split()))", "A", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "ans = 10**9", "ans", "10**9", "10", "9", "for i in range(-100,101):\n tmp = 0\n for a in A:\n tmp += (a-i)**2\n ans = min(ans, tmp)", "i", "range(-100,101)", "range", "-100", "101", "tmp = 0", "tmp", "0", "for a in A:\n tmp += (a-i)**2\n ", "a", "A", "tmp += (a-i)**2", "tmp", "(a-i)**2", "a-i", "a", "i", "2", "ans = min(ans, tmp)", "ans", "min(ans, tmp)", "min", "ans", "tmp", "print(ans)", "print", "ans", "A = list(map(int,input().split()))", "list(map(int,input().split()))", "A", "tmp += (a-i)**2", "(a-i)**2", "tmp", "n = int(input())", "int(input())", "n", "tmp = 0", "0", "tmp", "ans = min(ans, tmp)", "min(ans, tmp)", "ans", "ans = 10**9", "10**9", "ans" ]

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

[ [ 51, 2 ], [ 45, 8 ], [ 48, 20 ], [ 46, 26 ], [ 52, 27 ], [ 57, 29 ], [ 33, 32 ], [ 46, 32 ], [ 54, 35 ], [ 32, 38 ], [ 49, 39 ], [ 55, 43 ], [ 58, 43 ], [ 45, 46 ], [ 48, 49 ], [ 51, 52 ], [ 54, 55 ], [ 57, 58 ] ]

[ "n = int(input())\na_list = list(map(int,input().split()))\nmid = round(sum(a_list)/n)\nans = 0\nfor a in a_list:\n ans += (a-mid) ** 2\nprint(ans)", "n = int(input())", "n", "int(input())", "int", "input()", "input", "a_list = list(map(int,input().split()))", "a_list", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "mid = round(sum(a_list)/n)", "mid", "round(sum(a_list)/n)", "round", "sum(a_list)/n", "sum(a_list)", "sum", "a_list", "n", "ans = 0", "ans", "0", "for a in a_list:\n ans += (a-mid) ** 2", "a", "a_list", "ans += (a-mid) ** 2", "ans", "(a-mid) ** 2", "a-mid", "a", "mid", "2", "print(ans)", "print", "ans", "a_list = list(map(int,input().split()))", "list(map(int,input().split()))", "a_list", "mid = round(sum(a_list)/n)", "round(sum(a_list)/n)", "mid", "n = int(input())", "int(input())", "n", "ans += (a-mid) ** 2", "(a-mid) ** 2", "ans", "ans = 0", "0", "ans" ]

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

[ [ 55, 2 ], [ 61, 8 ], [ 64, 20 ], [ 24, 23 ], [ 67, 29 ], [ 33, 32 ], [ 62, 32 ], [ 70, 35 ], [ 23, 38 ], [ 32, 39 ], [ 65, 43 ], [ 71, 45 ], [ 68, 45 ], [ 58, 47 ], [ 65, 50 ], [ 59, 53 ], [ 55, 56 ], [ 58, 59 ], [ 61, 62 ], [ 64, 65 ], [ 67, 68 ], [ 70, 71 ] ]

[ "N = int(input())\nl = list(map(int, input().split()))\ncal = []\nfor i in range(-100,101):\n a = 0\n for j in l:\n a += (i - j)**2\n cal.append(a)\n\nans = min(cal)\nprint(ans)", "N = int(input())", "N", "int(input())", "int", "input()", "input", "l = list(map(int, input().split()))", "l", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "cal = []", "cal", "[]", "for i in range(-100,101):\n a = 0\n for j in l:\n a += (i - j)**2\n cal.append(a)", "i", "range(-100,101)", "range", "-100", "101", "a = 0", "a", "0", "for j in l:\n a += (i - j)**2\n ", "j", "l", "a += (i - j)**2", "a", "(i - j)**2", "i - j", "i", "j", "2", "cal.append(a)", "cal.append", "cal", "append", "a", "ans = min(cal)", "ans", "min(cal)", "min", "cal", "print(ans)", "print", "ans", "N = int(input())", "int(input())", "N", "ans = min(cal)", "min(cal)", "ans", "l = list(map(int, input().split()))", "list(map(int, input().split()))", "l", "cal = []", "[]", "cal", "a = 0", "0", "a", "a += (i - j)**2", "(i - j)**2", "a" ]

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

[ [ 65, 2 ], [ 74, 8 ], [ 62, 20 ], [ 26, 25 ], [ 68, 31 ], [ 35, 34 ], [ 66, 37 ], [ 71, 39 ], [ 75, 45 ], [ 34, 46 ], [ 25, 47 ], [ 59, 50 ], [ 63, 53 ], [ 60, 53 ], [ 72, 54 ], [ 69, 54 ], [ 60, 57 ], [ 63, 57 ], [ 59, 60 ], [ 62, 63 ], [ 65, 66 ], [ 68, 69 ], [ 71, 72 ], [ 74, 75 ] ]

[ "N=int(input())\na=list(map(int,input().split()))\nans=10**9\nfor i in range(-100,101):\n bns=0\n for j in range(N):\n bns+=(abs(a[j]-i)**2)\n ans=min(ans,bns)\nprint(ans)", "N=int(input())", "N", "int(input())", "int", "input()", "input", "a=list(map(int,input().split()))", "a", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "ans=10**9", "ans", "10**9", "10", "9", "for i in range(-100,101):\n bns=0\n for j in range(N):\n bns+=(abs(a[j]-i)**2)\n ans=min(ans,bns)", "i", "range(-100,101)", "range", "-100", "101", "bns=0", "bns", "0", "for j in range(N):\n bns+=(abs(a[j]-i)**2)\n ", "j", "range(N)", "range", "N", "bns+=(abs(a[j]-i)**2)", "bns", "abs(a[j]-i)**2", "abs(a[j]-i)", "abs", "a[j]-i", "a[j]", "a", "j", "i", "2", "ans=min(ans,bns)", "ans", "min(ans,bns)", "min", "ans", "bns", "print(ans)", "print", "ans", "ans=min(ans,bns)", "min(ans,bns)", "ans", "ans=10**9", "10**9", "ans", "N=int(input())", "int(input())", "N", "bns=0", "0", "bns", "bns+=(abs(a[j]-i)**2)", "abs(a[j]-i)**2", "bns", "a=list(map(int,input().split()))", "list(map(int,input().split()))", "a" ]

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

[ [ 57, 2 ], [ 54, 8 ], [ 60, 23 ], [ 55, 29 ], [ 58, 30 ], [ 51, 32 ], [ 61, 37 ], [ 52, 48 ], [ 55, 49 ], [ 51, 52 ], [ 54, 55 ], [ 57, 58 ], [ 60, 61 ] ]

[ "N = int(input())\nL = list(map(int, input().split()))[:N]\n\nstart = round(sum(L) / N)\nf = lambda x: (x - start)**2\n\nprint(sum(list(map(f, L))))", "N = int(input())", "N", "int(input())", "int", "input()", "input", "L = list(map(int, input().split()))[:N]", "L", "list(map(int, input().split()))[:N]", "(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", ":N", "N", "start = round(sum(L) / N)", "start", "round(sum(L) / N)", "round", "sum(L) / N", "sum(L)", "sum", "L", "N", "f = lambda x: (x - start)**2", "f", "lambda x: (x - start)**2", "(x - start)**2", "x - start", "x", "start", "2", "x", "print(sum(list(map(f, L))))", "print", "sum(list(map(f, L)))", "sum", "list(map(f, L))", "list", "map(f, L)", "map", "f", "L", "f = lambda x: (x - start)**2", "lambda x: (x - start)**2", "f", "L = list(map(int, input().split()))[:N]", "list(map(int, input().split()))[:N]", "L", "N = int(input())", "int(input())", "N", "start = round(sum(L) / N)", "round(sum(L) / N)", "start" ]

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

[ [ 69, 2 ], [ 72, 8 ], [ 75, 20 ], [ 73, 26 ], [ 70, 27 ], [ 84, 29 ], [ 33, 32 ], [ 73, 37 ], [ 76, 39 ], [ 78, 42 ], [ 46, 45 ], [ 70, 48 ], [ 81, 50 ], [ 32, 53 ], [ 73, 55 ], [ 45, 56 ], [ 85, 60 ], [ 82, 62 ], [ 79, 62 ], [ 85, 67 ], [ 69, 70 ], [ 72, 73 ], [ 75, 76 ], [ 78, 79 ], [ 81, 82 ], [ 84, 85 ] ]

[ "N = int(input())\na = list(map(int, input().split()))\navg = round(sum(a)/N)\nsums = []\nfor i in range(min(a), avg+1):\n s = 0\n for j in range(N):\n s += (i-a[j])**2\n sums.append(s)\nprint(min(sums))", "N = int(input())", "N", "int(input())", "int", "input()", "input", "a = list(map(int, input().split()))", "a", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "avg = round(sum(a)/N)", "avg", "round(sum(a)/N)", "round", "sum(a)/N", "sum(a)", "sum", "a", "N", "sums = []", "sums", "[]", "for i in range(min(a), avg+1):\n s = 0\n for j in range(N):\n s += (i-a[j])**2\n sums.append(s)", "i", "range(min(a), avg+1)", "range", "min(a)", "min", "a", "avg+1", "avg", "1", "s = 0", "s", "0", "for j in range(N):\n s += (i-a[j])**2\n ", "j", "range(N)", "range", "N", "s += (i-a[j])**2", "s", "(i-a[j])**2", "i-a[j]", "i", "a[j]", "a", "j", "2", "sums.append(s)", "sums.append", "sums", "append", "s", "print(min(sums))", "print", "min(sums)", "min", "sums", "N = int(input())", "int(input())", "N", "a = list(map(int, input().split()))", "list(map(int, input().split()))", "a", "avg = round(sum(a)/N)", "round(sum(a)/N)", "avg", "s = 0", "0", "s", "s += (i-a[j])**2", "(i-a[j])**2", "s", "sums = []", "[]", "sums" ]

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

[ [ 67, 2 ], [ 55, 8 ], [ 64, 20 ], [ 24, 23 ], [ 58, 29 ], [ 33, 32 ], [ 68, 35 ], [ 61, 37 ], [ 56, 41 ], [ 32, 42 ], [ 23, 43 ], [ 70, 46 ], [ 65, 49 ], [ 71, 49 ], [ 62, 50 ], [ 59, 50 ], [ 71, 53 ], [ 65, 53 ], [ 55, 56 ], [ 58, 59 ], [ 61, 62 ], [ 64, 65 ], [ 67, 68 ], [ 70, 71 ] ]

[ "a = int(input())\nb = list(map(int,input().split()))\nans = 4000000\n\nfor i in range(-100,101):\n ans_sub = 0\n for j in range(a):\n ans_sub += (b[j]-i)**2\n ans = min(ans,ans_sub)\nprint(ans)", "a = int(input())", "a", "int(input())", "int", "input()", "input", "b = list(map(int,input().split()))", "b", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "ans = 4000000", "ans", "4000000", "for i in range(-100,101):\n ans_sub = 0\n for j in range(a):\n ans_sub += (b[j]-i)**2\n ans = min(ans,ans_sub)", "i", "range(-100,101)", "range", "-100", "101", "ans_sub = 0", "ans_sub", "0", "for j in range(a):\n ans_sub += (b[j]-i)**2\n ", "j", "range(a)", "range", "a", "ans_sub += (b[j]-i)**2", "ans_sub", "(b[j]-i)**2", "b[j]-i", "b[j]", "b", "j", "i", "2", "ans = min(ans,ans_sub)", "ans", "min(ans,ans_sub)", "min", "ans", "ans_sub", "print(ans)", "print", "ans", "b = list(map(int,input().split()))", "list(map(int,input().split()))", "b", "ans_sub = 0", "0", "ans_sub", "ans_sub += (b[j]-i)**2", "(b[j]-i)**2", "ans_sub", "ans = 4000000", "4000000", "ans", "a = int(input())", "int(input())", "a", "ans = min(ans,ans_sub)", "min(ans,ans_sub)", "ans" ]

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

[ [ 66, 2 ], [ 57, 8 ], [ 54, 20 ], [ 24, 23 ], [ 63, 29 ], [ 33, 32 ], [ 58, 32 ], [ 60, 35 ], [ 32, 38 ], [ 23, 39 ], [ 51, 42 ], [ 55, 45 ], [ 52, 45 ], [ 61, 46 ], [ 64, 46 ], [ 52, 49 ], [ 55, 49 ], [ 51, 52 ], [ 54, 55 ], [ 57, 58 ], [ 60, 61 ], [ 63, 64 ], [ 66, 67 ] ]

[ "n = int(input())\n\na = list(map(int,input().split()))\n\nans = 100010001000\n\nfor i in range(-100,101):\n total = 0\n for j in a:\n total += (j-i)**2\n \n ans = min(ans,total)\n \nprint(ans)", "n = int(input())", "n", "int(input())", "int", "input()", "input", "a = list(map(int,input().split()))", "a", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "ans = 100010001000", "ans", "100010001000", "for i in range(-100,101):\n total = 0\n for j in a:\n total += (j-i)**2\n \n ans = min(ans,total)\n ", "i", "range(-100,101)", "range", "-100", "101", "total = 0", "total", "0", "for j in a:\n total += (j-i)**2\n \n ", "j", "a", "total += (j-i)**2", "total", "(j-i)**2", "j-i", "j", "i", "2", "ans = min(ans,total)", "ans", "min(ans,total)", "min", "ans", "total", "print(ans)", "print", "ans", "ans = min(ans,total)", "min(ans,total)", "ans", "ans = 100010001000", "100010001000", "ans", "a = list(map(int,input().split()))", "list(map(int,input().split()))", "a", "total += (j-i)**2", "(j-i)**2", "total", "total = 0", "0", "total", "n = int(input())", "int(input())", "n" ]

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

[ [ 92, 2 ], [ 10, 9 ], [ 9, 18 ], [ 98, 20 ], [ 104, 23 ], [ 99, 29 ], [ 99, 32 ], [ 86, 34 ], [ 105, 37 ], [ 105, 40 ], [ 105, 43 ], [ 105, 47 ], [ 105, 50 ], [ 105, 53 ], [ 89, 56 ], [ 62, 61 ], [ 87, 61 ], [ 107, 64 ], [ 68, 67 ], [ 99, 67 ], [ 95, 70 ], [ 61, 73 ], [ 67, 74 ], [ 101, 77 ], [ 90, 80 ], [ 102, 80 ], [ 96, 81 ], [ 108, 81 ], [ 102, 84 ], [ 90, 84 ], [ 86, 87 ], [ 89, 90 ], [ 92, 93 ], [ 95, 96 ], [ 98, 99 ], [ 101, 102 ], [ 104, 105 ], [ 107, 108 ] ]

[ "n = int(input())\na = [int(i) for i in input().split()]\nnum = int(sum(a) / len(a))\ncheck = [num -3, num - 2, num -1, num, num + 1, num + 2, num +3]\nans = float('inf')\nfor i in check:\n cnt = 0\n for j in a:\n cnt += (i - j) ** 2\n\n ans = min(ans, cnt)\nprint(ans)", "n = int(input())", "n", "int(input())", "int", "input()", "input", "int(i) for i in input().split()", "for i in input().split()", "i", "input().split()", "().split", "()", "input", "split", "for i in input().split()", "int(i)", "int", "i", "a = [int(i) for i in input().split()]", "a", "[int(i) for i in input().split()]", "num = int(sum(a) / len(a))", "num", "int(sum(a) / len(a))", "int", "sum(a) / len(a)", "sum(a)", "sum", "a", "len(a)", "len", "a", "check = [num -3, num - 2, num -1, num, num + 1, num + 2, num +3]", "check", "[num -3, num - 2, num -1, num, num + 1, num + 2, num +3]", "num -3", "num", "3", "num - 2", "num", "2", "num -1", "num", "1", "num", "num + 1", "num", "1", "num + 2", "num", "2", "num +3", "num", "3", "ans = float('inf')", "ans", "float('inf')", "float", "'inf'", "for i in check:\n cnt = 0\n for j in a:\n cnt += (i - j) ** 2\n\n ans = min(ans, cnt)", "i", "check", "cnt = 0", "cnt", "0", "for j in a:\n cnt += (i - j) ** 2\n\n ", "j", "a", "cnt += (i - j) ** 2", "cnt", "(i - j) ** 2", "i - j", "i", "j", "2", "ans = min(ans, cnt)", "ans", "min(ans, cnt)", "min", "ans", "cnt", "print(ans)", "print", "ans", "check = [num -3, num - 2, num -1, num, num + 1, num + 2, num +3]", "[num -3, num - 2, num -1, num, num + 1, num + 2, num +3]", "check", "ans = float('inf')", "float('inf')", "ans", "n = int(input())", "int(input())", "n", "cnt += (i - j) ** 2", "(i - j) ** 2", "cnt", "a = [int(i) for i in input().split()]", "[int(i) for i in input().split()]", "a", "ans = min(ans, cnt)", "min(ans, cnt)", "ans", "num = int(sum(a) / len(a))", "int(sum(a) / len(a))", "num", "cnt = 0", "0", "cnt" ]

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

[ [ 48, 2 ], [ 57, 8 ], [ 51, 20 ], [ 58, 26 ], [ 49, 27 ], [ 54, 29 ], [ 33, 32 ], [ 58, 32 ], [ 45, 35 ], [ 32, 38 ], [ 52, 39 ], [ 46, 43 ], [ 55, 43 ], [ 45, 46 ], [ 48, 49 ], [ 51, 52 ], [ 54, 55 ], [ 57, 58 ] ]

[ "n = int(input())\na = list(map(int, input().split()))\navg_a = round(sum(a)/n)\n\nresult = 0\nfor num in a:\n result += (num-avg_a)**2\n\nprint(result)", "n = int(input())", "n", "int(input())", "int", "input()", "input", "a = list(map(int, input().split()))", "a", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "avg_a = round(sum(a)/n)", "avg_a", "round(sum(a)/n)", "round", "sum(a)/n", "sum(a)", "sum", "a", "n", "result = 0", "result", "0", "for num in a:\n result += (num-avg_a)**2", "num", "a", "result += (num-avg_a)**2", "result", "(num-avg_a)**2", "num-avg_a", "num", "avg_a", "2", "print(result)", "print", "result", "result += (num-avg_a)**2", "(num-avg_a)**2", "result", "n = int(input())", "int(input())", "n", "avg_a = round(sum(a)/n)", "round(sum(a)/n)", "avg_a", "result = 0", "0", "result", "a = list(map(int, input().split()))", "list(map(int, input().split()))", "a" ]

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

[ [ 5, 4 ], [ 11, 10 ], [ 23, 22 ], [ 28, 27 ], [ 36, 35 ], [ 39, 38 ], [ 10, 38 ], [ 42, 41 ], [ 27, 44 ], [ 38, 45 ], [ 49, 48 ], [ 22, 51 ], [ 48, 51 ], [ 41, 52 ], [ 35, 52 ], [ 48, 55 ], [ 22, 55 ], [ 64, 61 ] ]

[ "def solve():\n N = int(input())\n A = list(map(int,input().split()))\n\n ans = float('inf')\n for i in range(-100, 100+1):\n cnt = 0\n for a in A:\n cnt += (i-a) ** 2 \n ans = min(ans, cnt)\n \n print(ans)\n\nif __name__ == '__main__':\n solve()", "def solve():\n N = int(input())\n A = list(map(int,input().split()))\n\n ans = float('inf')\n for i in range(-100, 100+1):\n cnt = 0\n for a in A:\n cnt += (i-a) ** 2 \n ans = min(ans, cnt)\n \n print(ans)", "solve", "N = int(input())", "N", "int(input())", "int", "input()", "input", "A = list(map(int,input().split()))", "A", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "ans = float('inf')", "ans", "float('inf')", "float", "'inf'", "for i in range(-100, 100+1):\n cnt = 0\n for a in A:\n cnt += (i-a) ** 2 \n ans = min(ans, cnt)\n \n ", "i", "range(-100, 100+1)", "range", "-100", "100+1", "100", "1", "cnt = 0", "cnt", "0", "for a in A:\n cnt += (i-a) ** 2 \n ", "a", "A", "cnt += (i-a) ** 2", "cnt", "(i-a) ** 2", "i-a", "i", "a", "2", "ans = min(ans, cnt)", "ans", "min(ans, cnt)", "min", "ans", "cnt", "print(ans)", "print", "ans", "if __name__ == '__main__':\n solve()", "__name__ == '__main__'", "__name__", "'__main__'", "solve()", "solve", "def solve():\n N = int(input())\n A = list(map(int,input().split()))\n\n ans = float('inf')\n for i in range(-100, 100+1):\n cnt = 0\n for a in A:\n cnt += (i-a) ** 2 \n ans = min(ans, cnt)\n \n print(ans)", "def solve():\n N = int(input())\n A = list(map(int,input().split()))\n\n ans = float('inf')\n for i in range(-100, 100+1):\n cnt = 0\n for a in A:\n cnt += (i-a) ** 2 \n ans = min(ans, cnt)\n \n print(ans)", "solve" ]

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

[ [ 64, 2 ], [ 52, 8 ], [ 61, 20 ], [ 53, 26 ], [ 53, 29 ], [ 55, 31 ], [ 35, 34 ], [ 53, 34 ], [ 34, 38 ], [ 62, 39 ], [ 58, 42 ], [ 34, 45 ], [ 62, 46 ], [ 59, 50 ], [ 56, 50 ], [ 52, 53 ], [ 55, 56 ], [ 58, 59 ], [ 61, 62 ], [ 64, 65 ] ]

[ "N = int(input())\nS = list(map(int,input().split()))\nave = round(sum(S) / len(S))\nans = 0\nfor i in S:\n if i == ave:\n continue\n else:\n ans += (i - ave) ** 2\n\nprint(ans)", "N = int(input())", "N", "int(input())", "int", "input()", "input", "S = list(map(int,input().split()))", "S", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "ave = round(sum(S) / len(S))", "ave", "round(sum(S) / len(S))", "round", "sum(S) / len(S)", "sum(S)", "sum", "S", "len(S)", "len", "S", "ans = 0", "ans", "0", "for i in S:\n if i == ave:\n continue\n else:\n ans += (i - ave) ** 2", "i", "S", "if i == ave:\n continue\n else:\n ans += (i - ave) ** 2", "i == ave", "i", "ave", "continue", "ans += (i - ave) ** 2", "ans", "(i - ave) ** 2", "i - ave", "i", "ave", "2", "print(ans)", "print", "ans", "S = list(map(int,input().split()))", "list(map(int,input().split()))", "S", "ans = 0", "0", "ans", "ans += (i - ave) ** 2", "(i - ave) ** 2", "ans", "ave = round(sum(S) / len(S))", "round(sum(S) / len(S))", "ave", "N = int(input())", "int(input())", "N" ]

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

[ [ 61, 2 ], [ 10, 9 ], [ 9, 18 ], [ 55, 20 ], [ 58, 23 ], [ 29, 28 ], [ 56, 33 ], [ 56, 37 ], [ 64, 40 ], [ 59, 43 ], [ 65, 43 ], [ 28, 48 ], [ 65, 53 ], [ 59, 53 ], [ 55, 56 ], [ 58, 59 ], [ 61, 62 ], [ 64, 65 ] ]

[ "N = int(input())\nA = [int(T) for T in input().split()]\nMin = 10**9\nfor TN in range(min(A),max(A)+1):\n Min = min(Min,sum((TN-TA)**2 for TA in A))\nprint(Min)", "N = int(input())", "N", "int(input())", "int", "input()", "input", "int(T) for T in input().split()", "for T in input().split()", "T", "input().split()", "().split", "()", "input", "split", "for T in input().split()", "int(T)", "int", "T", "A = [int(T) for T in input().split()]", "A", "[int(T) for T in input().split()]", "Min = 10**9", "Min", "10**9", "10", "9", "for TN in range(min(A),max(A)+1):\n Min = min(Min,sum((TN-TA)**2 for TA in A))", "TN", "range(min(A),max(A)+1)", "range", "min(A)", "min", "A", "max(A)+1", "max(A)", "max", "A", "1", "Min = min(Min,sum((TN-TA)**2 for TA in A))", "Min", "min(Min,sum((TN-TA)**2 for TA in A))", "min", "Min", "sum((TN-TA)**2 for TA in A)", "sum", "(TN-TA)**2", "TN-TA", "TN", "TA", "2", "print(Min)", "print", "Min", "A = [int(T) for T in input().split()]", "[int(T) for T in input().split()]", "A", "Min = 10**9", "10**9", "Min", "N = int(input())", "int(input())", "N", "Min = min(Min,sum((TN-TA)**2 for TA in A))", "min(Min,sum((TN-TA)**2 for TA in A))", "Min" ]

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

[ [ 38, 2 ], [ 44, 8 ], [ 41, 20 ], [ 45, 26 ], [ 39, 27 ], [ 42, 35 ], [ 38, 39 ], [ 41, 42 ], [ 44, 45 ] ]

[ "N = int(input())\nA = list(map(int,input().split()))\nm = round(sum(A)/N)\nprint(sum((a-m)**2 for a in A))", "N = int(input())", "N", "int(input())", "int", "input()", "input", "A = list(map(int,input().split()))", "A", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "m = round(sum(A)/N)", "m", "round(sum(A)/N)", "round", "sum(A)/N", "sum(A)", "sum", "A", "N", "print(sum((a-m)**2 for a in A))", "print", "sum((a-m)**2 for a in A)", "sum", "(a-m)**2", "a-m", "a", "m", "2", "N = int(input())", "int(input())", "N", "m = round(sum(A)/N)", "round(sum(A)/N)", "m", "A = list(map(int,input().split()))", "list(map(int,input().split()))", "A" ]

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

[ [ 5, 4 ], [ 11, 10 ], [ 23, 22 ], [ 26, 25 ], [ 29, 28 ], [ 10, 33 ], [ 10, 37 ], [ 41, 40 ], [ 10, 40 ], [ 28, 44 ], [ 40, 45 ], [ 48, 47 ], [ 28, 50 ], [ 40, 51 ], [ 25, 55 ], [ 47, 57 ], [ 22, 57 ], [ 59, 57 ], [ 60, 59 ], [ 63, 62 ], [ 25, 65 ], [ 62, 68 ], [ 77, 74 ] ]

[ "# -*- coding: utf-8 -*-\n\ndef main():\n\n \n N = int(input())\n a = list(map(int, input().split()))\n\n cost = 0\n listCost = []\n\n for i in range(min(a), max(a)+1):\n for j in a:\n if i != j:\n cost += (i - j) ** 2\n\n listCost.append(cost)\n cost = 0\n\n ans = min(listCost)\n\n print(ans)\n \n\nif __name__ == \"__main__\":\n main()", "def main():\n\n \n N = int(input())\n a = list(map(int, input().split()))\n\n cost = 0\n listCost = []\n\n for i in range(min(a), max(a)+1):\n for j in a:\n if i != j:\n cost += (i - j) ** 2\n\n listCost.append(cost)\n cost = 0\n\n ans = min(listCost)\n\n print(ans)\n ", "main", "N = int(input())", "N", "int(input())", "int", "input()", "input", "a = list(map(int, input().split()))", "a", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "cost = 0", "cost", "0", "listCost = []", "listCost", "[]", "for i in range(min(a), max(a)+1):\n for j in a:\n if i != j:\n cost += (i - j) ** 2\n\n listCost.append(cost)\n cost = 0\n\n ", "i", "range(min(a), max(a)+1)", "range", "min(a)", "min", "a", "max(a)+1", "max(a)", "max", "a", "1", "for j in a:\n if i != j:\n cost += (i - j) ** 2\n\n ", "j", "a", "if i != j:\n cost += (i - j) ** 2\n\n ", "i != j", "i", "j", "cost += (i - j) ** 2", "cost", "(i - j) ** 2", "i - j", "i", "j", "2", "listCost.append(cost)", "listCost.append", "listCost", "append", "cost", "cost = 0", "cost", "0", "ans = min(listCost)", "ans", "min(listCost)", "min", "listCost", "print(ans)", "print", "ans", "if __name__ == \"__main__\":\n main()", "__name__ == \"__main__\"", "__name__", "\"__main__\"", "main()", "main", "def main():\n\n \n N = int(input())\n a = list(map(int, input().split()))\n\n cost = 0\n listCost = []\n\n for i in range(min(a), max(a)+1):\n for j in a:\n if i != j:\n cost += (i - j) ** 2\n\n listCost.append(cost)\n cost = 0\n\n ans = min(listCost)\n\n print(ans)\n ", "def main():\n\n \n N = int(input())\n a = list(map(int, input().split()))\n\n cost = 0\n listCost = []\n\n for i in range(min(a), max(a)+1):\n for j in a:\n if i != j:\n cost += (i - j) ** 2\n\n listCost.append(cost)\n cost = 0\n\n ans = min(listCost)\n\n print(ans)\n ", "main" ]

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

[ [ 9, 8 ], [ 71, 12 ], [ 15, 14 ], [ 71, 23 ], [ 27, 26 ], [ 14, 30 ], [ 8, 31 ], [ 34, 33 ], [ 39, 38 ], [ 26, 41 ], [ 26, 43 ], [ 47, 46 ], [ 50, 49 ], [ 14, 49 ], [ 53, 52 ], [ 33, 55 ], [ 52, 55 ], [ 46, 56 ], [ 52, 59 ], [ 33, 59 ], [ 68, 65 ] ]

[ "import sys\ndef input(): return sys.stdin.readline().strip()\n\ndef main():\n N = int(input())\n A = list(map(int, input().split()))\n c = sum(A) // N\n ans = 10**10\n for x in range(c, c + 2):\n val = 0\n for a in A: val += (x - a) ** 2\n ans = min(ans, val)\n print(ans)\n\nif __name__ == \"__main__\":\n main()", "import sys", "sys", "def input(): return sys.stdin.readline().strip()", "input", "def main():\n N = int(input())\n A = list(map(int, input().split()))\n c = sum(A) // N\n ans = 10**10\n for x in range(c, c + 2):\n val = 0\n for a in A: val += (x - a) ** 2\n ans = min(ans, val)\n print(ans)", "main", "N = int(input())", "N", "int(input())", "int", "input()", "input", "A = list(map(int, input().split()))", "A", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "c = sum(A) // N", "c", "sum(A) // N", "sum(A)", "sum", "A", "N", "ans = 10**10", "ans", "10**10", "10", "10", "for x in range(c, c + 2):\n val = 0\n for a in A: val += (x - a) ** 2\n ans = min(ans, val)\n ", "x", "range(c, c + 2)", "range", "c", "c + 2", "c", "2", "val = 0", "val", "0", "for a in A: val += (x - a) ** 2\n ", "a", "A", "ans = min(ans, val)", "ans", "min(ans, val)", "min", "ans", "val", "print(ans)", "print", "ans", "if __name__ == \"__main__\":\n main()", "__name__ == \"__main__\"", "__name__", "\"__main__\"", "main()", "main", "def main():\n N = int(input())\n A = list(map(int, input().split()))\n c = sum(A) // N\n ans = 10**10\n for x in range(c, c + 2):\n val = 0\n for a in A: val += (x - a) ** 2\n ans = min(ans, val)\n print(ans)", "def main():\n N = int(input())\n A = list(map(int, input().split()))\n c = sum(A) // N\n ans = 10**10\n for x in range(c, c + 2):\n val = 0\n for a in A: val += (x - a) ** 2\n ans = min(ans, val)\n print(ans)", "main", "def input(): return sys.stdin.readline().strip()", "def input(): return sys.stdin.readline().strip()", "input" ]

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

[ [ 56, 2 ], [ 10, 9 ], [ 9, 19 ], [ 65, 21 ], [ 59, 24 ], [ 66, 30 ], [ 57, 31 ], [ 62, 33 ], [ 37, 36 ], [ 57, 39 ], [ 53, 41 ], [ 66, 45 ], [ 36, 46 ], [ 60, 47 ], [ 54, 51 ], [ 63, 51 ], [ 53, 54 ], [ 56, 57 ], [ 59, 60 ], [ 62, 63 ], [ 65, 66 ] ]

[ "q = int(input())\n\nl = [int(x) for x in input().split(' ')]\n\navarage = round(sum(l)/q)\n\ncost = 0\nfor i in range(q):\n cost += (l[i]-avarage)**2\n\nprint(cost)", "q = int(input())", "q", "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", "l = [int(x) for x in input().split(' ')]", "l", "[int(x) for x in input().split(' ')]", "avarage = round(sum(l)/q)", "avarage", "round(sum(l)/q)", "round", "sum(l)/q", "sum(l)", "sum", "l", "q", "cost = 0", "cost", "0", "for i in range(q):\n cost += (l[i]-avarage)**2", "i", "range(q)", "range", "q", "cost += (l[i]-avarage)**2", "cost", "(l[i]-avarage)**2", "l[i]-avarage", "l[i]", "l", "i", "avarage", "2", "print(cost)", "print", "cost", "cost += (l[i]-avarage)**2", "(l[i]-avarage)**2", "cost", "q = int(input())", "int(input())", "q", "avarage = round(sum(l)/q)", "round(sum(l)/q)", "avarage", "cost = 0", "0", "cost", "l = [int(x) for x in input().split(' ')]", "[int(x) for x in input().split(' ')]", "l" ]

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

[ [ 82, 2 ], [ 73, 8 ], [ 76, 20 ], [ 70, 23 ], [ 74, 26 ], [ 79, 28 ], [ 74, 31 ], [ 34, 33 ], [ 71, 36 ], [ 80, 38 ], [ 85, 41 ], [ 45, 44 ], [ 83, 47 ], [ 88, 49 ], [ 86, 51 ], [ 89, 51 ], [ 74, 55 ], [ 44, 56 ], [ 33, 57 ], [ 77, 61 ], [ 89, 63 ], [ 86, 63 ], [ 77, 68 ], [ 70, 71 ], [ 73, 74 ], [ 76, 77 ], [ 79, 80 ], [ 82, 83 ], [ 85, 86 ], [ 88, 89 ] ]

[ "n=int(input())\nl=list(map(int,input().split()))\nk=[]\na=min(l)\nb=max(l)\nfor i in range(a,b+1):\n c=0\n for j in range(n):\n c=c+(l[j]-i)**2\n k.append(c)\nprint(min(k))", "n=int(input())", "n", "int(input())", "int", "input()", "input", "l=list(map(int,input().split()))", "l", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "k=[]", "k", "[]", "a=min(l)", "a", "min(l)", "min", "l", "b=max(l)", "b", "max(l)", "max", "l", "for i in range(a,b+1):\n c=0\n for j in range(n):\n c=c+(l[j]-i)**2\n k.append(c)", "i", "range(a,b+1)", "range", "a", "b+1", "b", "1", "c=0", "c", "0", "for j in range(n):\n c=c+(l[j]-i)**2\n ", "j", "range(n)", "range", "n", "c=c+(l[j]-i)**2", "c", "c+(l[j]-i)**2", "c", "(l[j]-i)**2", "l[j]-i", "l[j]", "l", "j", "i", "2", "k.append(c)", "k.append", "k", "append", "c", "print(min(k))", "print", "min(k)", "min", "k", "a=min(l)", "min(l)", "a", "l=list(map(int,input().split()))", "list(map(int,input().split()))", "l", "k=[]", "[]", "k", "b=max(l)", "max(l)", "b", "n=int(input())", "int(input())", "n", "c=0", "0", "c", "c=c+(l[j]-i)**2", "c+(l[j]-i)**2", "c" ]

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

[ [ 60, 2 ], [ 57, 8 ], [ 48, 20 ], [ 58, 26 ], [ 61, 27 ], [ 51, 30 ], [ 34, 33 ], [ 58, 33 ], [ 54, 36 ], [ 33, 39 ], [ 49, 40 ], [ 55, 46 ], [ 52, 46 ], [ 48, 49 ], [ 51, 52 ], [ 54, 55 ], [ 57, 58 ], [ 60, 61 ] ]

[ "N = int(input())\nan = list(map(int,input().split()))\nave = round((sum(an)/N),0)\nans = 0\n\nfor i in an:\n ans += (i-ave)**2\n\nprint(int(ans))", "N = int(input())", "N", "int(input())", "int", "input()", "input", "an = list(map(int,input().split()))", "an", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "ave = round((sum(an)/N),0)", "ave", "round((sum(an)/N),0)", "round", "sum(an)/N", "sum(an)", "sum", "an", "N", "0", "ans = 0", "ans", "0", "for i in an:\n ans += (i-ave)**2", "i", "an", "ans += (i-ave)**2", "ans", "(i-ave)**2", "i-ave", "i", "ave", "2", "print(int(ans))", "print", "int(ans)", "int", "ans", "ave = round((sum(an)/N),0)", "round((sum(an)/N),0)", "ave", "ans = 0", "0", "ans", "ans += (i-ave)**2", "(i-ave)**2", "ans", "an = list(map(int,input().split()))", "list(map(int,input().split()))", "an", "N = int(input())", "int(input())", "N" ]

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

[ [ 60, 2 ], [ 57, 8 ], [ 66, 21 ], [ 25, 24 ], [ 63, 30 ], [ 34, 33 ], [ 58, 33 ], [ 69, 36 ], [ 33, 39 ], [ 24, 40 ], [ 67, 44 ], [ 70, 46 ], [ 64, 46 ], [ 67, 49 ], [ 67, 54 ], [ 57, 58 ], [ 60, 61 ], [ 63, 64 ], [ 66, 67 ], [ 69, 70 ] ]

[ "n = int(input())\nl = list(map(int,input().split(\" \")))\n\ncost_list = []\n\nfor i in range (-100,101):\n cost = 0\n for j in l:\n cost += (j - i)**2\n cost_list.append(cost)\ncost_list.sort()\nprint(cost_list[0])", "n = int(input())", "n", "int(input())", "int", "input()", "input", "l = list(map(int,input().split(\" \")))", "l", "list(map(int,input().split(\" \")))", "list", "map(int,input().split(\" \"))", "map", "int", "input().split(\" \")", "().split", "()", "input", "split", "\" \"", "cost_list = []", "cost_list", "[]", "for i in range (-100,101):\n cost = 0\n for j in l:\n cost += (j - i)**2\n cost_list.append(cost)", "i", "range (-100,101)", "range", "-100", "101", "cost = 0", "cost", "0", "for j in l:\n cost += (j - i)**2\n ", "j", "l", "cost += (j - i)**2", "cost", "(j - i)**2", "j - i", "j", "i", "2", "cost_list.append(cost)", "cost_list.append", "cost_list", "append", "cost", "cost_list.sort()", "cost_list.sort", "cost_list", "sort", "print(cost_list[0])", "print", "cost_list[0]", "cost_list", "0", "l = list(map(int,input().split(\" \")))", "list(map(int,input().split(\" \")))", "l", "n = int(input())", "int(input())", "n", "cost = 0", "0", "cost", "cost_list = []", "[]", "cost_list", "cost += (j - i)**2", "(j - i)**2", "cost" ]

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

[ [ 5, 4 ], [ 8, 7 ], [ 19, 7 ], [ 11, 10 ], [ 7, 13 ], [ 21, 14 ], [ 10, 17 ], [ 4, 17 ], [ 19, 19 ], [ 21, 21 ], [ 67, 23 ], [ 64, 29 ], [ 43, 42 ], [ 62, 49 ], [ 65, 50 ], [ 42, 51 ], [ 70, 53 ], [ 71, 59 ], [ 64, 65 ], [ 67, 68 ], [ 70, 71 ] ]

[ "def sigma(a,r):\n t=0\n for i in a:\n t+=(i-r)**2\n return t\n\n_=int(input())\na=list(map(int,input().split()))\ns=min([sigma(a,r) for r in range(-100,101)])\nprint(s)", "def sigma(a,r):\n t=0\n for i in a:\n t+=(i-r)**2\n return t", "sigma", "t=0", "t", "0", "for i in a:\n t+=(i-r)**2\n ", "i", "a", "t+=(i-r)**2", "t", "(i-r)**2", "i-r", "i", "r", "2", "return t", "t", "a", "a", "r", "r", "_=int(input())", "_", "int(input())", "int", "input()", "input", "a=list(map(int,input().split()))", "a", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "sigma(a,r) for r in range(-100,101)", "for r in range(-100,101)", "r", "range(-100,101)", "range", "-100", "101", "for r in range(-100,101)", "sigma(a,r)", "sigma", "a", "r", "s=min([sigma(a,r) for r in range(-100,101)])", "s", "min([sigma(a,r) for r in range(-100,101)])", "min", "[sigma(a,r) for r in range(-100,101)]", "print(s)", "print", "s", "def sigma(a,r):\n t=0\n for i in a:\n t+=(i-r)**2\n return t", "def sigma(a,r):\n t=0\n for i in a:\n t+=(i-r)**2\n return t", "sigma", "a=list(map(int,input().split()))", "list(map(int,input().split()))", "a", "_=int(input())", "int(input())", "_", "s=min([sigma(a,r) for r in range(-100,101)])", "min([sigma(a,r) for r in range(-100,101)])", "s" ]

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

[ [ 92, 3 ], [ 80, 8 ], [ 93, 12 ], [ 77, 14 ], [ 93, 23 ], [ 78, 31 ], [ 86, 34 ], [ 40, 39 ], [ 89, 45 ], [ 49, 48 ], [ 78, 48 ], [ 74, 51 ], [ 48, 54 ], [ 39, 55 ], [ 87, 59 ], [ 84, 59 ], [ 75, 60 ], [ 90, 60 ], [ 83, 62 ], [ 75, 63 ], [ 90, 63 ], [ 71, 65 ], [ 72, 69 ], [ 84, 69 ], [ 87, 69 ], [ 71, 72 ], [ 74, 75 ], [ 77, 78 ], [ 80, 81 ], [ 75, 83 ], [ 90, 83 ], [ 83, 84 ], [ 86, 87 ], [ 89, 90 ], [ 92, 93 ] ]

[ "from sys import stdin\ninput = stdin.readline\n\nN = int(input())\nA = list(map(int, input().split()))\n\nif len(set(A)) != 1:\n cost = 2**20\n for i in range(-100, 101):\n tc = 0\n for a in A:\n tc += (a-i)**2\n if cost > tc:\n cost = tc\nelse:\n cost = 0\n\nprint(cost)", "from sys import stdin", "input = stdin.readline", "input", "stdin.readline", "stdin", "readline", "N = int(input())", "N", "int(input())", "int", "input()", "input", "A = list(map(int, input().split()))", "A", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "if len(set(A)) != 1:\n cost = 2**20\n for i in range(-100, 101):\n tc = 0\n for a in A:\n tc += (a-i)**2\n if cost > tc:\n cost = tc\nelse:\n cost = 0", "len(set(A)) != 1", "len(set(A))", "len", "set(A)", "set", "A", "1", "cost = 2**20", "cost", "2**20", "2", "20", "for i in range(-100, 101):\n tc = 0\n for a in A:\n tc += (a-i)**2\n if cost > tc:\n cost = tc", "i", "range(-100, 101)", "range", "-100", "101", "tc = 0", "tc", "0", "for a in A:\n tc += (a-i)**2\n ", "a", "A", "tc += (a-i)**2", "tc", "(a-i)**2", "a-i", "a", "i", "2", "if cost > tc:\n cost = tc", "cost > tc", "cost", "tc", "cost = tc", "cost", "tc", "cost = 0", "cost", "0", "print(cost)", "print", "cost", "cost = 0", "0", "cost", "tc += (a-i)**2", "(a-i)**2", "tc", "A = list(map(int, input().split()))", "list(map(int, input().split()))", "A", "N = int(input())", "int(input())", "N", "cost = tc", "tc", "cost", "cost = 2**20", "2**20", "cost", "tc = 0", "0", "tc", "input = stdin.readline", "stdin.readline", "input" ]

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

[ [ 26, 16 ], [ 27, 26 ], [ 95, 42 ], [ 99, 44 ], [ 113, 46 ], [ 93, 48 ], [ 107, 50 ], [ 56, 55 ], [ 101, 61 ], [ 65, 64 ], [ 114, 69 ], [ 110, 71 ], [ 55, 74 ], [ 114, 76 ], [ 64, 77 ], [ 104, 80 ], [ 108, 83 ], [ 105, 83 ], [ 111, 84 ], [ 102, 84 ], [ 105, 87 ], [ 108, 87 ], [ 95, 96 ], [ 101, 102 ], [ 104, 105 ], [ 107, 108 ], [ 110, 111 ], [ 113, 114 ] ]

[ "def cin():\n\treturn map(int,input().split())\n\ndef cino(test=False):\n if not test:\n return int(input())\n else:\n return input()\ndef cina():\n return list(map(int,input().split()))\n\na = cino()\nl = cina()\nans = 10**18\nfor i in range(-100,101):\n cost = 0\n for j in range(len(l)):\n cost += (i-l[j])**2\n ans = min(ans,cost)\nprint(ans)\n\n", "def cin():\n\treturn map(int,input().split())", "cin", "return map(int,input().split())", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "def cino(test=False):\n if not test:\n return int(input())\n else:\n return input()", "cino", "if not test:\n return int(input())\n else:\n return input()", "not test", "test", "return int(input())", "int(input())", "int", "input()", "input", "return input()", "input()", "input", "test=False", "test", "False", "def cina():\n return list(map(int,input().split()))", "cina", "return list(map(int,input().split()))", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "a = cino()", "a", "cino()", "cino", "l = cina()", "l", "cina()", "cina", "ans = 10**18", "ans", "10**18", "10", "18", "for i in range(-100,101):\n cost = 0\n for j in range(len(l)):\n cost += (i-l[j])**2\n ans = min(ans,cost)", "i", "range(-100,101)", "range", "-100", "101", "cost = 0", "cost", "0", "for j in range(len(l)):\n cost += (i-l[j])**2\n ", "j", "range(len(l))", "range", "len(l)", "len", "l", "cost += (i-l[j])**2", "cost", "(i-l[j])**2", "i-l[j]", "i", "l[j]", "l", "j", "2", "ans = min(ans,cost)", "ans", "min(ans,cost)", "min", "ans", "cost", "print(ans)", "print", "ans", "def cin():\n\treturn map(int,input().split())", "def cin():\n\treturn map(int,input().split())", "cin", "def cina():\n return list(map(int,input().split()))", "def cina():\n return list(map(int,input().split()))", "cina", "a = cino()", "cino()", "a", "def cino(test=False):\n if not test:\n return int(input())\n else:\n return input()", "def cino(test=False):\n if not test:\n return int(input())\n else:\n return input()", "cino", "cost = 0", "0", "cost", "ans = min(ans,cost)", "min(ans,cost)", "ans", "ans = 10**18", "10**18", "ans", "cost += (i-l[j])**2", "(i-l[j])**2", "cost", "l = cina()", "cina()", "l" ]

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

[ [ 66, 2 ], [ 87, 8 ], [ 78, 20 ], [ 26, 25 ], [ 81, 30 ], [ 75, 33 ], [ 88, 40 ], [ 84, 42 ], [ 25, 46 ], [ 72, 49 ], [ 25, 53 ], [ 69, 56 ], [ 79, 59 ], [ 70, 59 ], [ 85, 60 ], [ 82, 60 ], [ 73, 61 ], [ 76, 61 ], [ 70, 64 ], [ 79, 64 ], [ 66, 67 ], [ 69, 70 ], [ 72, 73 ], [ 75, 76 ], [ 78, 79 ], [ 81, 82 ], [ 84, 85 ], [ 87, 88 ] ]

[ "n=int(input())\na = list(map(int,input().split()))\n\nans = 10**7\nfor i in range(102):\n p = 0\n m = 0\n for j, aa in enumerate(a):\n p += (aa-i)**2\n m += (aa+i)**2\n ans = min(ans,p,m)\n\nprint(ans)", "n=int(input())", "n", "int(input())", "int", "input()", "input", "a = list(map(int,input().split()))", "a", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "ans = 10**7", "ans", "10**7", "10", "7", "for i in range(102):\n p = 0\n m = 0\n for j, aa in enumerate(a):\n p += (aa-i)**2\n m += (aa+i)**2\n ans = min(ans,p,m)", "i", "range(102)", "range", "102", "p = 0", "p", "0", "m = 0", "m", "0", "for j, aa in enumerate(a):\n p += (aa-i)**2\n m += (aa+i)**2\n ", "j", "aa", "enumerate(a)", "enumerate", "a", "p += (aa-i)**2", "p", "(aa-i)**2", "aa-i", "aa", "i", "2", "m += (aa+i)**2", "m", "(aa+i)**2", "aa+i", "aa", "i", "2", "ans = min(ans,p,m)", "ans", "min(ans,p,m)", "min", "ans", "p", "m", "print(ans)", "print", "ans", "n=int(input())", "int(input())", "n", "ans = min(ans,p,m)", "min(ans,p,m)", "ans", "m += (aa+i)**2", "(aa+i)**2", "m", "m = 0", "0", "m", "ans = 10**7", "10**7", "ans", "p = 0", "0", "p", "p += (aa-i)**2", "(aa-i)**2", "p", "a = list(map(int,input().split()))", "list(map(int,input().split()))", "a" ]

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

[ [ 57, 2 ], [ 66, 8 ], [ 63, 20 ], [ 67, 26 ], [ 67, 29 ], [ 60, 31 ], [ 35, 34 ], [ 67, 39 ], [ 69, 41 ], [ 61, 43 ], [ 70, 43 ], [ 67, 47 ], [ 34, 48 ], [ 64, 49 ], [ 70, 55 ], [ 61, 55 ], [ 57, 58 ], [ 60, 61 ], [ 63, 64 ], [ 66, 67 ], [ 69, 70 ] ]

[ "#ABC043C\nn=int(input())\na = list(map(int, input().split()))\nh=round(sum(a)/len(a))\nsum_a=0\nfor i in range(len(a)):\n sum_a=sum_a+(a[i]-h)**2\nprint(int(sum_a))", "n=int(input())", "n", "int(input())", "int", "input()", "input", "a = list(map(int, input().split()))", "a", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "h=round(sum(a)/len(a))", "h", "round(sum(a)/len(a))", "round", "sum(a)/len(a)", "sum(a)", "sum", "a", "len(a)", "len", "a", "sum_a=0", "sum_a", "0", "for i in range(len(a)):\n sum_a=sum_a+(a[i]-h)**2", "i", "range(len(a))", "range", "len(a)", "len", "a", "sum_a=sum_a+(a[i]-h)**2", "sum_a", "sum_a+(a[i]-h)**2", "sum_a", "(a[i]-h)**2", "a[i]-h", "a[i]", "a", "i", "h", "2", "print(int(sum_a))", "print", "int(sum_a)", "int", "sum_a", "n=int(input())", "int(input())", "n", "sum_a=0", "0", "sum_a", "h=round(sum(a)/len(a))", "round(sum(a)/len(a))", "h", "a = list(map(int, input().split()))", "list(map(int, input().split()))", "a", "sum_a=sum_a+(a[i]-h)**2", "sum_a+(a[i]-h)**2", "sum_a" ]

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

[ [ 73, 2 ], [ 10, 9 ], [ 9, 18 ], [ 79, 20 ], [ 26, 25 ], [ 29, 28 ], [ 40, 28 ], [ 32, 31 ], [ 28, 34 ], [ 42, 35 ], [ 31, 38 ], [ 25, 38 ], [ 40, 40 ], [ 42, 42 ], [ 46, 45 ], [ 80, 50 ], [ 80, 54 ], [ 71, 58 ], [ 80, 59 ], [ 45, 60 ], [ 76, 62 ], [ 77, 68 ], [ 73, 74 ], [ 76, 77 ], [ 79, 80 ] ]

[ "N = int(input())\nint_list = [int(x) for x in input().split()]\n\n# int_listの各整数をyに書き換えるときのコストの総和を計算\ndef calc_cost(int_list, y):\n cost = 0\n for x in int_list:\n cost += (x - y)**2\n return cost\n\ncost_list = [calc_cost(int_list, y) for y in range(min(int_list), max(int_list)+1)]\nprint(min(cost_list))", "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", "int_list = [int(x) for x in input().split()]", "int_list", "[int(x) for x in input().split()]", "def calc_cost(int_list, y):\n cost = 0\n for x in int_list:\n cost += (x - y)**2\n return cost", "calc_cost", "cost = 0", "cost", "0", "for x in int_list:\n cost += (x - y)**2\n ", "x", "int_list", "cost += (x - y)**2", "cost", "(x - y)**2", "x - y", "x", "y", "2", "return cost", "cost", "int_list", "int_list", "y", "y", "calc_cost(int_list, y) for y in range(min(int_list), max(int_list)+1)", "for y in range(min(int_list), max(int_list)+1)", "y", "range(min(int_list), max(int_list)+1)", "range", "min(int_list)", "min", "int_list", "max(int_list)+1", "max(int_list)", "max", "int_list", "1", "for y in range(min(int_list), max(int_list)+1)", "calc_cost(int_list, y)", "calc_cost", "int_list", "y", "cost_list = [calc_cost(int_list, y) for y in range(min(int_list), max(int_list)+1)]", "cost_list", "[calc_cost(int_list, y) for y in range(min(int_list), max(int_list)+1)]", "print(min(cost_list))", "print", "min(cost_list)", "min", "cost_list", "def calc_cost(int_list, y):\n cost = 0\n for x in int_list:\n cost += (x - y)**2\n return cost", "def calc_cost(int_list, y):\n cost = 0\n for x in int_list:\n cost += (x - y)**2\n return cost", "calc_cost", "N = int(input())", "int(input())", "N", "cost_list = [calc_cost(int_list, y) for y in range(min(int_list), max(int_list)+1)]", "[calc_cost(int_list, y) for y in range(min(int_list), max(int_list)+1)]", "cost_list", "int_list = [int(x) for x in input().split()]", "[int(x) for x in input().split()]", "int_list" ]

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

[ [ 94, 2 ], [ 91, 8 ], [ 28, 24 ], [ 30, 25 ], [ 28, 28 ], [ 30, 30 ], [ 103, 32 ], [ 92, 36 ], [ 95, 37 ], [ 88, 39 ], [ 100, 47 ], [ 53, 52 ], [ 89, 57 ], [ 97, 59 ], [ 107, 66 ], [ 104, 69 ], [ 89, 71 ], [ 52, 72 ], [ 92, 74 ], [ 85, 76 ], [ 101, 79 ], [ 86, 79 ], [ 98, 80 ], [ 86, 83 ], [ 101, 83 ], [ 85, 86 ], [ 88, 89 ], [ 91, 92 ], [ 94, 95 ], [ 97, 98 ], [ 100, 101 ], [ 103, 104 ] ]

[ "N=int(input())\na=list(map(int,input().split()))\n\ndef calc_cost(x,avg):\n return (x-avg)**2\n\navg = sum(a)//N\n\ndelta = [-2,-1,0,1,2]\n\nans=10**20\nfor i in range(len(delta)):\n val = sum(map(lambda x:calc_cost(x,avg+delta[i]),a))\n ans = min(ans,val)\n \nprint(ans)", "N=int(input())", "N", "int(input())", "int", "input()", "input", "a=list(map(int,input().split()))", "a", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "def calc_cost(x,avg):\n return (x-avg)**2", "calc_cost", "return (x-avg)**2", "(x-avg)**2", "x-avg", "x", "avg", "2", "x", "x", "avg", "avg", "avg = sum(a)//N", "avg", "sum(a)//N", "sum(a)", "sum", "a", "N", "delta = [-2,-1,0,1,2]", "delta", "[-2,-1,0,1,2]", "-2", "-1", "0", "1", "2", "ans=10**20", "ans", "10**20", "10", "20", "for i in range(len(delta)):\n val = sum(map(lambda x:calc_cost(x,avg+delta[i]),a))\n ans = min(ans,val)\n ", "i", "range(len(delta))", "range", "len(delta)", "len", "delta", "val = sum(map(lambda x:calc_cost(x,avg+delta[i]),a))", "val", "sum(map(lambda x:calc_cost(x,avg+delta[i]),a))", "sum", "map(lambda x:calc_cost(x,avg+delta[i]),a)", "map", "lambda x:calc_cost(x,avg+delta[i])", "calc_cost(x,avg+delta[i])", "calc_cost", "x", "avg+delta[i]", "avg", "delta[i]", "delta", "i", "x", "a", "ans = min(ans,val)", "ans", "min(ans,val)", "min", "ans", "val", "print(ans)", "print", "ans", "ans = min(ans,val)", "min(ans,val)", "ans", "delta = [-2,-1,0,1,2]", "[-2,-1,0,1,2]", "delta", "a=list(map(int,input().split()))", "list(map(int,input().split()))", "a", "N=int(input())", "int(input())", "N", "val = sum(map(lambda x:calc_cost(x,avg+delta[i]),a))", "sum(map(lambda x:calc_cost(x,avg+delta[i]),a))", "val", "ans=10**20", "10**20", "ans", "avg = sum(a)//N", "sum(a)//N", "avg", "def calc_cost(x,avg):\n return (x-avg)**2", "def calc_cost(x,avg):\n return (x-avg)**2", "calc_cost" ]

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

[ [ 9, 6 ], [ 104, 7 ], [ 106, 8 ], [ 106, 9 ], [ 14, 11 ], [ 104, 12 ], [ 108, 13 ], [ 108, 14 ], [ 18, 17 ], [ 6, 21 ], [ 104, 22 ], [ 106, 23 ], [ 31, 28 ], [ 104, 29 ], [ 35, 34 ], [ 6, 38 ], [ 104, 39 ], [ 106, 40 ], [ 48, 45 ], [ 104, 46 ], [ 51, 50 ], [ 6, 55 ], [ 104, 56 ], [ 106, 57 ], [ 65, 60 ], [ 28, 61 ], [ 104, 62 ], [ 50, 64 ], [ 28, 68 ], [ 104, 69 ], [ 50, 72 ], [ 50, 74 ], [ 11, 75 ], [ 104, 76 ], [ 108, 77 ], [ 84, 79 ], [ 45, 80 ], [ 104, 81 ], [ 50, 83 ], [ 45, 87 ], [ 104, 88 ], [ 50, 91 ], [ 50, 95 ], [ 11, 97 ], [ 104, 98 ], [ 108, 99 ], [ 11, 100 ], [ 104, 101 ], [ 108, 102 ], [ 104, 104 ], [ 106, 106 ], [ 108, 108 ], [ 140, 116 ], [ 142, 118 ], [ 140, 123 ], [ 142, 126 ], [ 144, 127 ], [ 140, 130 ], [ 144, 132 ], [ 140, 134 ], [ 140, 137 ], [ 140, 140 ], [ 142, 142 ], [ 144, 144 ], [ 222, 163 ], [ 207, 169 ], [ 226, 171 ], [ 210, 173 ], [ 177, 176 ], [ 216, 182 ], [ 186, 185 ], [ 208, 185 ], [ 219, 188 ], [ 185, 191 ], [ 176, 192 ], [ 213, 195 ], [ 220, 198 ], [ 217, 198 ], [ 211, 199 ], [ 214, 199 ], [ 214, 202 ], [ 211, 202 ], [ 207, 208 ], [ 210, 211 ], [ 213, 214 ], [ 216, 217 ], [ 219, 220 ], [ 222, 223 ] ]

[ "\nclass Combination:\n def __init__(self, n, mod):\n self.n = n\n self.mod = mod\n self.fac = [1 for i in range(self.n + 1)]\n self.finv = [1 for i in range(self.n + 1)]\n for i in range(2, self.n+1):\n self.fac[i] = (self.fac[i - 1] * i) % self.mod\n self.finv[i] = (self.finv[i-1] * pow(i, -1, self.mod)) % self.mod\n\n def comb(self, n, m):\n return self.fac[n] * (self.finv[n-m] * self.finv[m] % self.mod) % self.mod\ndef iparse():\n return list(map(int, input().split()))\n\nif __name__ == \"__main__\":\n n = int(input())\n a = iparse()\n ans = 10000000000\n for i in range(-100, 101):\n tmp = 0\n for e in a:\n tmp += (e - i)** 2\n ans = min(tmp, ans)\n print(ans)\n ", "class Combination:\n def __init__(self, n, mod):\n self.n = n\n self.mod = mod\n self.fac = [1 for i in range(self.n + 1)]\n self.finv = [1 for i in range(self.n + 1)]\n for i in range(2, self.n+1):\n self.fac[i] = (self.fac[i - 1] * i) % self.mod\n self.finv[i] = (self.finv[i-1] * pow(i, -1, self.mod)) % self.mod\n\n def comb(self, n, m):\n return self.fac[n] * (self.finv[n-m] * self.finv[m] % self.mod) % self.mod", "Combination", "def __init__(self, n, mod):\n self.n = n\n self.mod = mod\n self.fac = [1 for i in range(self.n + 1)]\n self.finv = [1 for i in range(self.n + 1)]\n for i in range(2, self.n+1):\n self.fac[i] = (self.fac[i - 1] * i) % self.mod\n self.finv[i] = (self.finv[i-1] * pow(i, -1, self.mod)) % self.mod\n\n ", "__init__", "self.n = n", "self.n", "self", "n", "n", "self.mod = mod", "self.mod", "self", "mod", "mod", "1 for i in range(self.n + 1)", "for i in range(self.n + 1)", "i", "range(self.n + 1)", "range", "self.n + 1", "self.n", "self", "n", "1", "for i in range(self.n + 1)", "1", "self.fac = [1 for i in range(self.n + 1)]", "self.fac", "self", "fac", "[1 for i in range(self.n + 1)]", "1 for i in range(self.n + 1)", "for i in range(self.n + 1)", "i", "range(self.n + 1)", "range", "self.n + 1", "self.n", "self", "n", "1", "for i in range(self.n + 1)", "1", "self.finv = [1 for i in range(self.n + 1)]", "self.finv", "self", "finv", "[1 for i in range(self.n + 1)]", "for i in range(2, self.n+1):\n self.fac[i] = (self.fac[i - 1] * i) % self.mod\n self.finv[i] = (self.finv[i-1] * pow(i, -1, self.mod)) % self.mod\n\n ", "i", "range(2, self.n+1)", "range", "2", "self.n+1", "self.n", "self", "n", "1", "self.fac[i] = (self.fac[i - 1] * i) % self.mod", "self.fac[i]", "self.fac", "self", "fac", "i", "(self.fac[i - 1] * i) % self.mod", "self.fac[i - 1] * i", "self.fac[i - 1]", "self.fac", "self", "fac", "i - 1", "i", "1", "i", "self.mod", "self", "mod", "self.finv[i] = (self.finv[i-1] * pow(i, -1, self.mod)) % self.mod", "self.finv[i]", "self.finv", "self", "finv", "i", "(self.finv[i-1] * pow(i, -1, self.mod)) % self.mod", "self.finv[i-1] * pow(i, -1, self.mod)", "self.finv[i-1]", "self.finv", "self", "finv", "i-1", "i", "1", "pow(i, -1, self.mod)", "pow", "i", "-1", "self.mod", "self", "mod", "self.mod", "self", "mod", "self", "self", "n", "n", "mod", "mod", "def comb(self, n, m):\n return self.fac[n] * (self.finv[n-m] * self.finv[m] % self.mod) % self.mod", "comb", "return self.fac[n] * (self.finv[n-m] * self.finv[m] % self.mod) % self.mod", "self.fac[n] * (self.finv[n-m] * self.finv[m] % self.mod) % self.mod", "self.fac[n] * (self.finv[n-m] * self.finv[m] % self.mod)", "self.fac[n]", "self.fac", "self", "fac", "n", "self.finv[n-m] * self.finv[m] % self.mod", "self.finv[n-m] * self.finv[m]", "self.finv[n-m]", "self.finv", "self", "finv", "n-m", "n", "m", "self.finv[m]", "self.finv", "self", "finv", "m", "self.mod", "self", "mod", "self.mod", "self", "mod", "self", "self", "n", "n", "m", "m", "def iparse():\n return list(map(int, input().split()))", "iparse", "return list(map(int, input().split()))", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "if __name__ == \"__main__\":\n n = int(input())\n a = iparse()\n ans = 10000000000\n for i in range(-100, 101):\n tmp = 0\n for e in a:\n tmp += (e - i)** 2\n ans = min(tmp, ans)\n print(ans)\n ", "__name__ == \"__main__\"", "__name__", "\"__main__\"", "n = int(input())", "n", "int(input())", "int", "input()", "input", "a = iparse()", "a", "iparse()", "iparse", "ans = 10000000000", "ans", "10000000000", "for i in range(-100, 101):\n tmp = 0\n for e in a:\n tmp += (e - i)** 2\n ans = min(tmp, ans)\n ", "i", "range(-100, 101)", "range", "-100", "101", "tmp = 0", "tmp", "0", "for e in a:\n tmp += (e - i)** 2\n ", "e", "a", "tmp += (e - i)** 2", "tmp", "(e - i)** 2", "e - i", "e", "i", "2", "ans = min(tmp, ans)", "ans", "min(tmp, ans)", "min", "tmp", "ans", "print(ans)", "print", "ans", "class Combination:\n def __init__(self, n, mod):\n self.n = n\n self.mod = mod\n self.fac = [1 for i in range(self.n + 1)]\n self.finv = [1 for i in range(self.n + 1)]\n for i in range(2, self.n+1):\n self.fac[i] = (self.fac[i - 1] * i) % self.mod\n self.finv[i] = (self.finv[i-1] * pow(i, -1, self.mod)) % self.mod\n\n def comb(self, n, m):\n return self.fac[n] * (self.finv[n-m] * self.finv[m] % self.mod) % self.mod", "class Combination:\n def __init__(self, n, mod):\n self.n = n\n self.mod = mod\n self.fac = [1 for i in range(self.n + 1)]\n self.finv = [1 for i in range(self.n + 1)]\n for i in range(2, self.n+1):\n self.fac[i] = (self.fac[i - 1] * i) % self.mod\n self.finv[i] = (self.finv[i-1] * pow(i, -1, self.mod)) % self.mod\n\n def comb(self, n, m):\n return self.fac[n] * (self.finv[n-m] * self.finv[m] % self.mod) % self.mod", "Combination", "a = iparse()", "iparse()", "a", "ans = 10000000000", "10000000000", "ans", "ans = min(tmp, ans)", "min(tmp, ans)", "ans", "tmp = 0", "0", "tmp", "tmp += (e - i)** 2", "(e - i)** 2", "tmp", "n = int(input())", "int(input())", "n", "def iparse():\n return list(map(int, input().split()))", "def iparse():\n return list(map(int, input().split()))", "iparse" ]

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

[ [ 4, 3 ], [ 3, 12 ], [ 39, 14 ], [ 42, 20 ], [ 25, 24 ], [ 39, 40 ], [ 42, 43 ] ]

[ "N=int(input());a=[int(i) for i in input().split()]\nprint(min([sum([(n-i)**2 for n in a])for i in range(-100,101)]))", "int(i) for i in input().split()", "for i in input().split()", "i", "input().split()", "().split", "()", "input", "split", "for i in input().split()", "int(i)", "int", "i", "N=int(input())", "N", "int(input())", "int", "input()", "input", "a=[int(i) for i in input().split()]", "a", "[int(i) for i in input().split()]", "sum([(n-i)**2 for n in a])for i in range(-100,101)", "for i in range(-100,101)", "i", "range(-100,101)", "range", "-100", "101", "for i in range(-100,101)", "sum([(n-i)**2 for n in a])", "sum", "[(n-i)**2 for n in a]", "print(min([sum([(n-i)**2 for n in a])for i in range(-100,101)]))", "print", "min([sum([(n-i)**2 for n in a])for i in range(-100,101)])", "min", "[sum([(n-i)**2 for n in a])for i in range(-100,101)]", "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, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 0, 13, 39, 28, 13, 4, 13, 17, 17, 0, 13, 17, 28, 13, 4, 13, 13, 0, 13, 2, 13, 2, 2, 13, 18, 13, 13, 17, 4, 18, 13, 13, 13, 4, 13, 4, 13, 13, 10, 4, 13, 10, 17, 13, 10, 39, 13, 10, 2, 13, 10, 4, 13 ]

[ [ 70, 2 ], [ 58, 8 ], [ 64, 20 ], [ 24, 23 ], [ 61, 29 ], [ 33, 32 ], [ 71, 35 ], [ 67, 37 ], [ 62, 39 ], [ 68, 39 ], [ 23, 42 ], [ 59, 44 ], [ 32, 45 ], [ 65, 49 ], [ 68, 51 ], [ 62, 51 ], [ 65, 56 ], [ 58, 59 ], [ 61, 62 ], [ 64, 65 ], [ 67, 68 ], [ 70, 71 ] ]

[ "n = int(input())\na = list(map(int,input().split()))\n\nstock =[]\n\nfor x in range(-100,101):\n total = 0\n for i in range(n):\n total = total + (x-a[i])**2\n stock.append(total)\n\n\nprint(min(stock))", "n = int(input())", "n", "int(input())", "int", "input()", "input", "a = list(map(int,input().split()))", "a", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "stock =[]", "stock", "[]", "for x in range(-100,101):\n total = 0\n for i in range(n):\n total = total + (x-a[i])**2\n stock.append(total)", "x", "range(-100,101)", "range", "-100", "101", "total = 0", "total", "0", "for i in range(n):\n total = total + (x-a[i])**2\n ", "i", "range(n)", "range", "n", "total = total + (x-a[i])**2", "total", "total + (x-a[i])**2", "total", "(x-a[i])**2", "x-a[i]", "x", "a[i]", "a", "i", "2", "stock.append(total)", "stock.append", "stock", "append", "total", "print(min(stock))", "print", "min(stock)", "min", "stock", "a = list(map(int,input().split()))", "list(map(int,input().split()))", "a", "total = 0", "0", "total", "stock =[]", "[]", "stock", "total = total + (x-a[i])**2", "total + (x-a[i])**2", "total", "n = int(input())", "int(input())", "n" ]

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

[ [ 69, 2 ], [ 54, 8 ], [ 60, 20 ], [ 26, 25 ], [ 57, 32 ], [ 36, 35 ], [ 55, 35 ], [ 66, 38 ], [ 25, 41 ], [ 35, 42 ], [ 63, 45 ], [ 67, 48 ], [ 58, 48 ], [ 61, 49 ], [ 64, 49 ], [ 64, 52 ], [ 61, 52 ], [ 54, 55 ], [ 57, 58 ], [ 60, 61 ], [ 63, 64 ], [ 66, 67 ], [ 69, 70 ] ]

[ "n = int(input())\na = tuple(map(int,input().split()))\n\nans = float('inf')\nfor x in range(-100,101,1):\n c = 0\n for ai in a:\n c += (x-ai)**2\n ans = min(c,ans)\nprint(ans)", "n = int(input())", "n", "int(input())", "int", "input()", "input", "a = tuple(map(int,input().split()))", "a", "tuple(map(int,input().split()))", "tuple", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "ans = float('inf')", "ans", "float('inf')", "float", "'inf'", "for x in range(-100,101,1):\n c = 0\n for ai in a:\n c += (x-ai)**2\n ans = min(c,ans)", "x", "range(-100,101,1)", "range", "-100", "101", "1", "c = 0", "c", "0", "for ai in a:\n c += (x-ai)**2\n ", "ai", "a", "c += (x-ai)**2", "c", "(x-ai)**2", "x-ai", "x", "ai", "2", "ans = min(c,ans)", "ans", "min(c,ans)", "min", "c", "ans", "print(ans)", "print", "ans", "a = tuple(map(int,input().split()))", "tuple(map(int,input().split()))", "a", "c = 0", "0", "c", "ans = float('inf')", "float('inf')", "ans", "ans = min(c,ans)", "min(c,ans)", "ans", "c += (x-ai)**2", "(x-ai)**2", "c", "n = int(input())", "int(input())", "n" ]

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

[ [ 6, 5 ], [ 6, 18 ], [ 22, 21 ], [ 27, 26 ], [ 21, 31 ], [ 35, 34 ], [ 26, 37 ], [ 39, 38 ], [ 26, 41 ], [ 44, 43 ], [ 49, 48 ], [ 34, 51 ], [ 38, 53 ], [ 57, 56 ], [ 21, 63 ], [ 67, 66 ], [ 48, 71 ], [ 76, 75 ], [ 43, 78 ], [ 75, 78 ], [ 66, 79 ], [ 56, 79 ], [ 75, 82 ], [ 43, 82 ], [ 91, 88 ] ]

[ "def main():\n from collections import Counter\n n, *a = map(int, open(0).read().split())\n c = Counter(a)\n d = list(c.keys())\n x, y = min(d), max(d)\n ans = float(\"Inf\")\n for i in range(x, y + 1):\n tmp = 0\n for k, v in c.items():\n tmp += (k - i) ** 2 * v\n ans = min(ans, tmp)\n print(ans)\n\n\nif __name__ == '__main__':\n main()", "def main():\n from collections import Counter\n n, *a = map(int, open(0).read().split())\n c = Counter(a)\n d = list(c.keys())\n x, y = min(d), max(d)\n ans = float(\"Inf\")\n for i in range(x, y + 1):\n tmp = 0\n for k, v in c.items():\n tmp += (k - i) ** 2 * v\n ans = min(ans, tmp)\n print(ans)", "main", "from collections import Counter", "n, *a = map(int, open(0).read().split())", "n", "map(int, open(0).read().split())", "map", "int", "open(0).read().split()", "(0).read().split", "(0).read()", "(0).read", "(0)", "open", "0", "read", "split", "*a", "a", "c = Counter(a)", "c", "Counter(a)", "Counter", "a", "d = list(c.keys())", "d", "list(c.keys())", "list", "c.keys()", "c.keys", "c", "keys", "x, y = min(d), max(d)", "x", "min(d)", "min", "d", "y", "max(d)", "max", "d", "ans = float(\"Inf\")", "ans", "float(\"Inf\")", "float", "\"Inf\"", "for i in range(x, y + 1):\n tmp = 0\n for k, v in c.items():\n tmp += (k - i) ** 2 * v\n ans = min(ans, tmp)\n ", "i", "range(x, y + 1)", "range", "x", "y + 1", "y", "1", "tmp = 0", "tmp", "0", "for k, v in c.items():\n tmp += (k - i) ** 2 * v\n ", "k", "v", "c.items()", "c.items", "c", "items", "tmp += (k - i) ** 2 * v", "tmp", "(k - i) ** 2 * v", "(k - i) ** 2", "k - i", "k", "i", "2", "v", "ans = min(ans, tmp)", "ans", "min(ans, tmp)", "min", "ans", "tmp", "print(ans)", "print", "ans", "if __name__ == '__main__':\n main()", "__name__ == '__main__'", "__name__", "'__main__'", "main()", "main", "def main():\n from collections import Counter\n n, *a = map(int, open(0).read().split())\n c = Counter(a)\n d = list(c.keys())\n x, y = min(d), max(d)\n ans = float(\"Inf\")\n for i in range(x, y + 1):\n tmp = 0\n for k, v in c.items():\n tmp += (k - i) ** 2 * v\n ans = min(ans, tmp)\n print(ans)", "def main():\n from collections import Counter\n n, *a = map(int, open(0).read().split())\n c = Counter(a)\n d = list(c.keys())\n x, y = min(d), max(d)\n ans = float(\"Inf\")\n for i in range(x, y + 1):\n tmp = 0\n for k, v in c.items():\n tmp += (k - i) ** 2 * v\n ans = min(ans, tmp)\n print(ans)", "main" ]

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

[ [ 11, 10 ], [ 127, 22 ], [ 124, 28 ], [ 125, 51 ], [ 130, 53 ], [ 125, 58 ], [ 118, 60 ], [ 131, 64 ], [ 122, 64 ], [ 125, 69 ], [ 131, 78 ], [ 122, 78 ], [ 133, 80 ], [ 128, 88 ], [ 119, 91 ], [ 125, 97 ], [ 134, 98 ], [ 119, 108 ], [ 121, 110 ], [ 119, 116 ], [ 118, 119 ], [ 121, 122 ], [ 124, 125 ], [ 127, 128 ], [ 130, 131 ], [ 133, 134 ] ]

[ "import numpy as np\nimport logging\nlogging.basicConfig(level=logging.DEBUG)\nlogging.disable(logging.CRITICAL)\n\nN=int(input())\n\nx=np.array(list(map(int,input().split())))\nlogging.debug('x={}'.format(x))\n\ni=np.amin(x)\nans=[]\nwhile i<=np.amax(x):\n\n logging.debug('i={}'.format(i))\n y=np.array([i]*N)\n ans.append(sum((x-y)**2))\n\n logging.debug('ans={}'.format(ans))\n i+=1\nprint(min(ans))", "import numpy as np", "numpy", "import logging", "logging", "logging.basicConfig(level=logging.DEBUG)", "logging.basicConfig", "logging", "basicConfig", "level=logging.DEBUG", "level", "logging.DEBUG", "logging", "DEBUG", "logging.disable(logging.CRITICAL)", "logging.disable", "logging", "disable", "logging.CRITICAL", "logging", "CRITICAL", "N=int(input())", "N", "int(input())", "int", "input()", "input", "x=np.array(list(map(int,input().split())))", "x", "np.array(list(map(int,input().split())))", "np.array", "np", "array", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "logging.debug('x={}'.format(x))", "logging.debug", "logging", "debug", "'x={}'.format(x)", "'x={}'.format", "'x={}'", "format", "x", "i=np.amin(x)", "i", "np.amin(x)", "np.amin", "np", "amin", "x", "ans=[]", "ans", "[]", "while i<=np.amax(x):\n\n logging.debug('i={}'.format(i))\n y=np.array([i]*N)\n ans.append(sum((x-y)**2))\n\n logging.debug('ans={}'.format(ans))\n i+=1", "i<=np.amax(x)", "i", "np.amax(x)", "np.amax", "np", "amax", "x", "logging.debug('i={}'.format(i))", "logging.debug", "logging", "debug", "'i={}'.format(i)", "'i={}'.format", "'i={}'", "format", "i", "y=np.array([i]*N)", "y", "np.array([i]*N)", "np.array", "np", "array", "[i]*N", "[i]", "i", "N", "ans.append(sum((x-y)**2))", "ans.append", "ans", "append", "sum((x-y)**2)", "sum", "(x-y)**2", "x-y", "x", "y", "2", "logging.debug('ans={}'.format(ans))", "logging.debug", "logging", "debug", "'ans={}'.format(ans)", "'ans={}'.format", "'ans={}'", "format", "ans", "i+=1", "i", "1", "print(min(ans))", "print", "min(ans)", "min", "ans", "ans=[]", "[]", "ans", "i+=1", "1", "i", "x=np.array(list(map(int,input().split())))", "np.array(list(map(int,input().split())))", "x", "N=int(input())", "int(input())", "N", "i=np.amin(x)", "np.amin(x)", "i", "y=np.array([i]*N)", "np.array([i]*N)", "y" ]

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

[ [ 69, 2 ], [ 10, 8 ], [ 72, 19 ], [ 66, 24 ], [ 75, 29 ], [ 35, 34 ], [ 67, 37 ], [ 73, 39 ], [ 44, 43 ], [ 43, 48 ], [ 34, 49 ], [ 63, 52 ], [ 76, 55 ], [ 64, 55 ], [ 64, 61 ], [ 76, 61 ], [ 63, 64 ], [ 66, 67 ], [ 69, 70 ], [ 72, 73 ], [ 75, 76 ] ]

[ "N=int(input())\n*A,=map(int,input().split())\n\nmx=max(A)\nmn=min(A)\n\nans=float('inf')\nfor i in range(mn,mx+1):\n ans=min(ans, sum([(k-i)**2 for k in A]))\nprint(ans)", "N=int(input())", "N", "int(input())", "int", "input()", "input", "*A,=map(int,input().split())", "*A", "A", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "mx=max(A)", "mx", "max(A)", "max", "A", "mn=min(A)", "mn", "min(A)", "min", "A", "ans=float('inf')", "ans", "float('inf')", "float", "'inf'", "for i in range(mn,mx+1):\n ans=min(ans, sum([(k-i)**2 for k in A]))", "i", "range(mn,mx+1)", "range", "mn", "mx+1", "mx", "1", "(k-i)**2 for k in A", "for k in A", "k", "A", "for k in A", "(k-i)**2", "k-i", "k", "i", "2", "ans=min(ans, sum([(k-i)**2 for k in A]))", "ans", "min(ans, sum([(k-i)**2 for k in A]))", "min", "ans", "sum([(k-i)**2 for k in A])", "sum", "[(k-i)**2 for k in A]", "print(ans)", "print", "ans", "ans=min(ans, sum([(k-i)**2 for k in A]))", "min(ans, sum([(k-i)**2 for k in A]))", "ans", "mn=min(A)", "min(A)", "mn", "N=int(input())", "int(input())", "N", "mx=max(A)", "max(A)", "mx", "ans=float('inf')", "float('inf')", "ans" ]

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

[ [ 58, 2 ], [ 61, 8 ], [ 62, 19 ], [ 67, 22 ], [ 62, 26 ], [ 62, 29 ], [ 34, 33 ], [ 37, 36 ], [ 41, 36 ], [ 33, 39 ], [ 41, 41 ], [ 43, 43 ], [ 48, 47 ], [ 65, 51 ], [ 62, 52 ], [ 47, 53 ], [ 58, 59 ], [ 61, 62 ], [ 67, 68 ] ]

[ "\nn = int(raw_input())\nais = map(int, raw_input().split())\nais.sort()\nvv= sum(ais)/len(ais)\ndef g(ais,m):\n\ts= 0\n\tfor ai in ais: s+=abs(ai - m) **2\n\treturn s\nprint min([g(ais,m) for m in [vv+dela for dela in [-1,0,+1]]])", "n = int(raw_input())", "n", "int(raw_input())", "int", "raw_input()", "raw_input", "ais = map(int, raw_input().split())", "ais", "map(int, raw_input().split())", "map", "int", "raw_input().split()", "().split", "()", "raw_input", "split", "ais.sort()", "ais.sort", "ais", "sort", "vv= sum(ais)/len(ais)", "vv", "sum(ais)/len(ais)", "sum(ais)", "sum", "ais", "len(ais)", "len", "ais", "def g(ais,m):\n\ts= 0\n\tfor ai in ais: s+=abs(ai - m) **2\n\treturn s", "g", "s= 0", "s", "0", "for ai in ais: s+=abs(ai - m) **2\n\t", "ai", "ais", "return s", "s", "ais", "ais", "m", "m", "print", "g(ais,m) for m in [vv+dela for dela in [-1,0,+1]]", "for m in [vv+dela for dela in [-1,0,+1]]", "m", "[vv+dela for dela in [-1,0,+1]]", "for m in [vv+dela for dela in [-1,0,+1]]", "g(ais,m)", "g", "ais", "m", "min([g(ais,m) for m in [vv+dela for dela in [-1,0,+1]]])", "min", "[g(ais,m) for m in [vv+dela for dela in [-1,0,+1]]]", "n = int(raw_input())", "int(raw_input())", "n", "ais = map(int, raw_input().split())", "map(int, raw_input().split())", "ais", "def g(ais,m):\n\ts= 0\n\tfor ai in ais: s+=abs(ai - m) **2\n\treturn s", "def g(ais,m):\n\ts= 0\n\tfor ai in ais: s+=abs(ai - m) **2\n\treturn s", "g", "vv= sum(ais)/len(ais)", "sum(ais)/len(ais)", "vv" ]

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

[ [ 60, 2 ], [ 63, 8 ], [ 69, 20 ], [ 26, 25 ], [ 66, 31 ], [ 35, 34 ], [ 64, 34 ], [ 54, 37 ], [ 34, 41 ], [ 25, 42 ], [ 57, 45 ], [ 70, 48 ], [ 58, 48 ], [ 55, 49 ], [ 67, 49 ], [ 58, 52 ], [ 70, 52 ], [ 54, 55 ], [ 57, 58 ], [ 60, 61 ], [ 63, 64 ], [ 66, 67 ], [ 69, 70 ] ]

[ "N = int(input())\nA = list(map(int, input().split()))\n\nans = float('inf')\nfor k in range(-100, 101):\n cnt = 0\n for a in A:\n cnt += pow(a - k, 2)\n ans = min(ans, cnt)\n\nprint(ans)", "N = int(input())", "N", "int(input())", "int", "input()", "input", "A = list(map(int, input().split()))", "A", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "ans = float('inf')", "ans", "float('inf')", "float", "'inf'", "for k in range(-100, 101):\n cnt = 0\n for a in A:\n cnt += pow(a - k, 2)\n ans = min(ans, cnt)", "k", "range(-100, 101)", "range", "-100", "101", "cnt = 0", "cnt", "0", "for a in A:\n cnt += pow(a - k, 2)\n ", "a", "A", "cnt += pow(a - k, 2)", "cnt", "pow(a - k, 2)", "pow", "a - k", "a", "k", "2", "ans = min(ans, cnt)", "ans", "min(ans, cnt)", "min", "ans", "cnt", "print(ans)", "print", "ans", "cnt += pow(a - k, 2)", "pow(a - k, 2)", "cnt", "ans = min(ans, cnt)", "min(ans, cnt)", "ans", "N = int(input())", "int(input())", "N", "A = list(map(int, input().split()))", "list(map(int, input().split()))", "A", "cnt = 0", "0", "cnt", "ans = float('inf')", "float('inf')", "ans" ]

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

[ [ 73, 4 ], [ 88, 10 ], [ 76, 22 ], [ 89, 26 ], [ 74, 27 ], [ 91, 29 ], [ 77, 34 ], [ 94, 36 ], [ 77, 41 ], [ 82, 43 ], [ 79, 46 ], [ 50, 49 ], [ 89, 49 ], [ 97, 52 ], [ 49, 55 ], [ 92, 56 ], [ 85, 59 ], [ 49, 62 ], [ 95, 63 ], [ 73, 74 ], [ 76, 77 ], [ 79, 80 ], [ 82, 83 ], [ 85, 86 ], [ 88, 89 ], [ 91, 92 ], [ 94, 95 ], [ 97, 98 ] ]

[ "import math\nn = int(input())\na = list(map(int,input().split()))\navg = sum(a)/n\nx = math.floor(avg)\ny = math.ceil(avg)\nsumx = 0\nsumy = 0\nfor i in a:\n sumx += (i - x) ** 2\n sumy += (i - y) ** 2\n\nprint(min([sumx,sumy]))", "import math", "math", "n = int(input())", "n", "int(input())", "int", "input()", "input", "a = list(map(int,input().split()))", "a", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "avg = sum(a)/n", "avg", "sum(a)/n", "sum(a)", "sum", "a", "n", "x = math.floor(avg)", "x", "math.floor(avg)", "math.floor", "math", "floor", "avg", "y = math.ceil(avg)", "y", "math.ceil(avg)", "math.ceil", "math", "ceil", "avg", "sumx = 0", "sumx", "0", "sumy = 0", "sumy", "0", "for i in a:\n sumx += (i - x) ** 2\n sumy += (i - y) ** 2", "i", "a", "sumx += (i - x) ** 2", "sumx", "(i - x) ** 2", "i - x", "i", "x", "2", "sumy += (i - y) ** 2", "sumy", "(i - y) ** 2", "i - y", "i", "y", "2", "print(min([sumx,sumy]))", "print", "min([sumx,sumy])", "min", "[sumx,sumy]", "sumx", "sumy", "n = int(input())", "int(input())", "n", "avg = sum(a)/n", "sum(a)/n", "avg", "sumy = 0", "0", "sumy", "sumx = 0", "0", "sumx", "sumy += (i - y) ** 2", "(i - y) ** 2", "sumy", "a = list(map(int,input().split()))", "list(map(int,input().split()))", "a", "x = math.floor(avg)", "math.floor(avg)", "x", "y = math.ceil(avg)", "math.ceil(avg)", "y", "sumx += (i - x) ** 2", "(i - x) ** 2", "sumx" ]

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

[ [ 111, 20 ], [ 114, 25 ], [ 117, 32 ], [ 126, 41 ], [ 120, 50 ], [ 135, 59 ], [ 123, 65 ], [ 129, 77 ], [ 112, 78 ], [ 81, 80 ], [ 108, 86 ], [ 90, 89 ], [ 124, 89 ], [ 132, 92 ], [ 89, 95 ], [ 80, 96 ], [ 138, 99 ], [ 130, 102 ], [ 139, 102 ], [ 133, 103 ], [ 109, 103 ], [ 139, 106 ], [ 130, 106 ], [ 108, 109 ], [ 111, 112 ], [ 114, 115 ], [ 117, 118 ], [ 120, 121 ], [ 123, 124 ], [ 126, 127 ], [ 112, 129 ], [ 129, 130 ], [ 132, 133 ], [ 135, 136 ], [ 138, 139 ] ]

[ "import sys\nimport itertools\n# import numpy as np\nimport time\nimport math\nimport heapq\nfrom collections import defaultdict\nsys.setrecursionlimit(10 ** 7)\n \nINF = 10 ** 18\nMOD = 10 ** 9 + 7\nread = sys.stdin.buffer.read\nreadline = sys.stdin.buffer.readline\nreadlines = sys.stdin.buffer.readlines\n\n# map(int, input().split())\n\nN = int(input())\nA = list(map(int, input().split()))\n\nans = INF\nfor i in range(-100, 101):\n val = 0\n for a in A:\n val += (a - i) ** 2\n ans = min(ans, val)\nprint(ans)", "import sys", "sys", "import itertools", "itertools", "import time", "time", "import math", "math", "import heapq", "heapq", "from collections import defaultdict", "sys.setrecursionlimit(10 ** 7)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "10 ** 7", "10", "7", "INF = 10 ** 18", "INF", "10 ** 18", "10", "18", "MOD = 10 ** 9 + 7", "MOD", "10 ** 9 + 7", "10 ** 9", "10", "9", "7", "read = sys.stdin.buffer.read", "read", "sys.stdin.buffer.read", "sys.stdin.buffer", "sys.stdin", "sys", "stdin", "buffer", "read", "readline = sys.stdin.buffer.readline", "readline", "sys.stdin.buffer.readline", "sys.stdin.buffer", "sys.stdin", "sys", "stdin", "buffer", "readline", "readlines = sys.stdin.buffer.readlines", "readlines", "sys.stdin.buffer.readlines", "sys.stdin.buffer", "sys.stdin", "sys", "stdin", "buffer", "readlines", "N = int(input())", "N", "int(input())", "int", "input()", "input", "A = list(map(int, input().split()))", "A", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "ans = INF", "ans", "INF", "for i in range(-100, 101):\n val = 0\n for a in A:\n val += (a - i) ** 2\n ans = min(ans, val)", "i", "range(-100, 101)", "range", "-100", "101", "val = 0", "val", "0", "for a in A:\n val += (a - i) ** 2\n ", "a", "A", "val += (a - i) ** 2", "val", "(a - i) ** 2", "a - i", "a", "i", "2", "ans = min(ans, val)", "ans", "min(ans, val)", "min", "ans", "val", "print(ans)", "print", "ans", "val = 0", "0", "val", "INF = 10 ** 18", "10 ** 18", "INF", "MOD = 10 ** 9 + 7", "10 ** 9 + 7", "MOD", "read = sys.stdin.buffer.read", "sys.stdin.buffer.read", "read", "readlines = sys.stdin.buffer.readlines", "sys.stdin.buffer.readlines", "readlines", "A = list(map(int, input().split()))", "list(map(int, input().split()))", "A", "readline = sys.stdin.buffer.readline", "sys.stdin.buffer.readline", "readline", "ans = INF", "INF", "ans", "val += (a - i) ** 2", "(a - i) ** 2", "val", "N = int(input())", "int(input())", "N", "ans = min(ans, val)", "min(ans, val)", "ans" ]

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

[ [ 75, 2 ], [ 10, 9 ], [ 9, 18 ], [ 78, 20 ], [ 79, 24 ], [ 81, 27 ], [ 31, 30 ], [ 79, 34 ], [ 79, 38 ], [ 72, 42 ], [ 46, 45 ], [ 76, 48 ], [ 69, 50 ], [ 79, 54 ], [ 45, 55 ], [ 30, 56 ], [ 82, 60 ], [ 70, 62 ], [ 73, 62 ], [ 82, 67 ], [ 69, 70 ], [ 72, 73 ], [ 75, 76 ], [ 78, 79 ], [ 81, 82 ] ]

[ "n = int(input())\na = [int(x) for x in input().split()]\na.sort()\nans = []\nfor i in range(a[0], a[-1]+1):\n cnt = 0\n for j in range(n):\n cnt += (a[j] - i)**2\n ans.append(cnt)\n\nprint(min(ans))", "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 = [int(x) for x in input().split()]", "a", "[int(x) for x in input().split()]", "a.sort()", "a.sort", "a", "sort", "ans = []", "ans", "[]", "for i in range(a[0], a[-1]+1):\n cnt = 0\n for j in range(n):\n cnt += (a[j] - i)**2\n ans.append(cnt)", "i", "range(a[0], a[-1]+1)", "range", "a[0]", "a", "0", "a[-1]+1", "a[-1]", "a", "-1", "1", "cnt = 0", "cnt", "0", "for j in range(n):\n cnt += (a[j] - i)**2\n ", "j", "range(n)", "range", "n", "cnt += (a[j] - i)**2", "cnt", "(a[j] - i)**2", "a[j] - i", "a[j]", "a", "j", "i", "2", "ans.append(cnt)", "ans.append", "ans", "append", "cnt", "print(min(ans))", "print", "min(ans)", "min", "ans", "cnt += (a[j] - i)**2", "(a[j] - i)**2", "cnt", "cnt = 0", "0", "cnt", "n = int(input())", "int(input())", "n", "a = [int(x) for x in input().split()]", "[int(x) for x in input().split()]", "a", "ans = []", "[]", "ans" ]

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

[ [ 68, 2 ], [ 71, 8 ], [ 74, 20 ], [ 72, 23 ], [ 83, 25 ], [ 72, 28 ], [ 77, 30 ], [ 36, 35 ], [ 84, 38 ], [ 75, 40 ], [ 65, 43 ], [ 47, 46 ], [ 72, 46 ], [ 86, 49 ], [ 46, 52 ], [ 35, 53 ], [ 80, 56 ], [ 78, 59 ], [ 81, 59 ], [ 87, 60 ], [ 66, 60 ], [ 81, 63 ], [ 78, 63 ], [ 65, 66 ], [ 68, 69 ], [ 71, 72 ], [ 74, 75 ], [ 77, 78 ], [ 80, 81 ], [ 83, 84 ], [ 86, 87 ] ]

[ "n=int(input())\na=list(map(int,input().split()))\nma=max(a)\nmi=min(a)\nans=10**9\n\nfor i in range(mi,ma+1):\n tm=0\n for j in a:\n tm+=(j-i)**2\n else:\n ans=min(ans,tm)\n\nprint(ans)\n", "n=int(input())", "n", "int(input())", "int", "input()", "input", "a=list(map(int,input().split()))", "a", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "ma=max(a)", "ma", "max(a)", "max", "a", "mi=min(a)", "mi", "min(a)", "min", "a", "ans=10**9", "ans", "10**9", "10", "9", "for i in range(mi,ma+1):\n tm=0\n for j in a:\n tm+=(j-i)**2\n else:\n ans=min(ans,tm)", "i", "range(mi,ma+1)", "range", "mi", "ma+1", "ma", "1", "tm=0", "tm", "0", "for j in a:\n tm+=(j-i)**2\n else:\n ans=min(ans,tm)", "j", "a", "tm+=(j-i)**2", "tm", "(j-i)**2", "j-i", "j", "i", "2", "ans=min(ans,tm)", "ans", "min(ans,tm)", "min", "ans", "tm", "print(ans)", "print", "ans", "tm=0", "0", "tm", "n=int(input())", "int(input())", "n", "a=list(map(int,input().split()))", "list(map(int,input().split()))", "a", "ma=max(a)", "max(a)", "ma", "ans=10**9", "10**9", "ans", "ans=min(ans,tm)", "min(ans,tm)", "ans", "mi=min(a)", "min(a)", "mi", "tm+=(j-i)**2", "(j-i)**2", "tm" ]

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

[ [ 277, 18 ], [ 262, 34 ], [ 274, 53 ], [ 74, 73 ], [ 271, 92 ], [ 265, 97 ], [ 289, 114 ], [ 138, 137 ], [ 292, 157 ], [ 280, 162 ], [ 268, 177 ], [ 286, 184 ], [ 200, 197 ], [ 206, 205 ], [ 278, 207 ], [ 210, 209 ], [ 263, 211 ], [ 214, 213 ], [ 287, 214 ], [ 217, 216 ], [ 209, 222 ], [ 209, 227 ], [ 231, 230 ], [ 234, 233 ], [ 205, 236 ], [ 239, 238 ], [ 209, 242 ], [ 233, 243 ], [ 216, 244 ], [ 248, 247 ], [ 213, 250 ], [ 247, 250 ], [ 238, 251 ], [ 230, 251 ], [ 247, 254 ], [ 213, 254 ], [ 284, 260 ], [ 262, 263 ], [ 265, 266 ], [ 268, 269 ], [ 271, 272 ], [ 274, 275 ], [ 277, 278 ], [ 280, 281 ], [ 286, 287 ], [ 289, 290 ], [ 292, 293 ] ]

[ "import sys, os, math, bisect, itertools, collections, heapq, queue, copy, array\n\n# from scipy.sparse.csgraph import csgraph_from_dense, floyd_warshall\n# from decimal import Decimal\n# from collections import defaultdict, deque\n\nsys.setrecursionlimit(10000000)\n\nii = lambda: int(sys.stdin.buffer.readline().rstrip())\nil = lambda: list(map(int, sys.stdin.buffer.readline().split()))\nfl = lambda: list(map(float, sys.stdin.buffer.readline().split()))\niln = lambda n: [int(sys.stdin.buffer.readline().rstrip()) for _ in range(n)]\n\niss = lambda: sys.stdin.buffer.readline().decode().rstrip()\nsl = lambda: list(map(str, sys.stdin.buffer.readline().decode().split()))\nisn = lambda n: [sys.stdin.buffer.readline().decode().rstrip() for _ in range(n)]\n\nlcm = lambda x, y: (x * y) // math.gcd(x, y)\n\nMOD = 10 ** 9 + 7\nINF = float('inf')\n\n\ndef main():\n if os.getenv(\"LOCAL\"):\n sys.stdin = open(\"input.txt\", \"r\")\n\n N = ii()\n A = il()\n\n ret = INF\n for cost in range(min(A) - 1, max(A) + 1):\n tmp = 0\n for n in range(N):\n tmp += (A[n] - cost) ** 2\n ret = min(ret, tmp)\n print(ret)\n\n\nif __name__ == '__main__':\n main()", "import sys, os, math, bisect, itertools, collections, heapq, queue, copy, array", "sys", "os", "math", "bisect", "itertools", "collections", "heapq", "queue", "copy", "array", "sys.setrecursionlimit(10000000)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "10000000", "ii = lambda: int(sys.stdin.buffer.readline().rstrip())", "ii", "lambda: int(sys.stdin.buffer.readline().rstrip())", "int(sys.stdin.buffer.readline().rstrip())", "int", "sys.stdin.buffer.readline().rstrip()", "sys.stdin.buffer.readline().rstrip", "sys.stdin.buffer.readline()", "sys.stdin.buffer.readline", "sys.stdin.buffer", "sys.stdin", "sys", "stdin", "buffer", "readline", "rstrip", "il = lambda: list(map(int, sys.stdin.buffer.readline().split()))", "il", "lambda: list(map(int, sys.stdin.buffer.readline().split()))", "list(map(int, sys.stdin.buffer.readline().split()))", "list", "map(int, sys.stdin.buffer.readline().split())", "map", "int", "sys.stdin.buffer.readline().split()", "sys.stdin.buffer.readline().split", "sys.stdin.buffer.readline()", "sys.stdin.buffer.readline", "sys.stdin.buffer", "sys.stdin", "sys", "stdin", "buffer", "readline", "split", "fl = lambda: list(map(float, sys.stdin.buffer.readline().split()))", "fl", "lambda: list(map(float, sys.stdin.buffer.readline().split()))", "list(map(float, sys.stdin.buffer.readline().split()))", "list", "map(float, sys.stdin.buffer.readline().split())", "map", "float", "sys.stdin.buffer.readline().split()", "sys.stdin.buffer.readline().split", "sys.stdin.buffer.readline()", "sys.stdin.buffer.readline", "sys.stdin.buffer", "sys.stdin", "sys", "stdin", "buffer", "readline", "split", "int(sys.stdin.buffer.readline().rstrip()) for _ in range(n)", "for _ in range(n)", "_", "range(n)", "range", "n", "for _ in range(n)", "int(sys.stdin.buffer.readline().rstrip())", "int", "sys.stdin.buffer.readline().rstrip()", "sys.stdin.buffer.readline().rstrip", "sys.stdin.buffer.readline()", "sys.stdin.buffer.readline", "sys.stdin.buffer", "sys.stdin", "sys", "stdin", "buffer", "readline", "rstrip", "iln = lambda n: [int(sys.stdin.buffer.readline().rstrip()) for _ in range(n)]", "iln", "lambda n: [int(sys.stdin.buffer.readline().rstrip()) for _ in range(n)]", "[int(sys.stdin.buffer.readline().rstrip()) for _ in range(n)]", "n", "iss = lambda: sys.stdin.buffer.readline().decode().rstrip()", "iss", "lambda: sys.stdin.buffer.readline().decode().rstrip()", "sys.stdin.buffer.readline().decode().rstrip()", "sys.stdin.buffer.readline().decode().rstrip", "sys.stdin.buffer.readline().decode()", "sys.stdin.buffer.readline().decode", "sys.stdin.buffer.readline()", "sys.stdin.buffer.readline", "sys.stdin.buffer", "sys.stdin", "sys", "stdin", "buffer", "readline", "decode", "rstrip", "sl = lambda: list(map(str, sys.stdin.buffer.readline().decode().split()))", "sl", "lambda: list(map(str, sys.stdin.buffer.readline().decode().split()))", "list(map(str, sys.stdin.buffer.readline().decode().split()))", "list", "map(str, sys.stdin.buffer.readline().decode().split())", "map", "str", "sys.stdin.buffer.readline().decode().split()", "sys.stdin.buffer.readline().decode().split", "sys.stdin.buffer.readline().decode()", "sys.stdin.buffer.readline().decode", "sys.stdin.buffer.readline()", "sys.stdin.buffer.readline", "sys.stdin.buffer", "sys.stdin", "sys", "stdin", "buffer", "readline", "decode", "split", "sys.stdin.buffer.readline().decode().rstrip() for _ in range(n)", "for _ in range(n)", "_", "range(n)", "range", "n", "for _ in range(n)", "sys.stdin.buffer.readline().decode().rstrip()", "sys.stdin.buffer.readline().decode().rstrip", "sys.stdin.buffer.readline().decode()", "sys.stdin.buffer.readline().decode", "sys.stdin.buffer.readline()", "sys.stdin.buffer.readline", "sys.stdin.buffer", "sys.stdin", "sys", "stdin", "buffer", "readline", "decode", "rstrip", "isn = lambda n: [sys.stdin.buffer.readline().decode().rstrip() for _ in range(n)]", "isn", "lambda n: [sys.stdin.buffer.readline().decode().rstrip() for _ in range(n)]", "[sys.stdin.buffer.readline().decode().rstrip() for _ in range(n)]", "n", "lcm = lambda x, y: (x * y) // math.gcd(x, y)", "lcm", "lambda x, y: (x * y) // math.gcd(x, y)", "(x * y) // math.gcd(x, y)", "x * y", "x", "y", "math.gcd(x, y)", "math.gcd", "math", "gcd", "x", "y", "x", "y", "MOD = 10 ** 9 + 7", "MOD", "10 ** 9 + 7", "10 ** 9", "10", "9", "7", "INF = float('inf')", "INF", "float('inf')", "float", "'inf'", "def main():\n if os.getenv(\"LOCAL\"):\n sys.stdin = open(\"input.txt\", \"r\")\n\n N = ii()\n A = il()\n\n ret = INF\n for cost in range(min(A) - 1, max(A) + 1):\n tmp = 0\n for n in range(N):\n tmp += (A[n] - cost) ** 2\n ret = min(ret, tmp)\n print(ret)", "main", "if os.getenv(\"LOCAL\"):\n sys.stdin = open(\"input.txt\", \"r\")\n\n ", "os.getenv(\"LOCAL\")", "os.getenv", "os", "getenv", "\"LOCAL\"", "sys.stdin = open(\"input.txt\", \"r\")", "sys.stdin", "sys", "stdin", "open(\"input.txt\", \"r\")", "open", "\"input.txt\"", "\"r\"", "N = ii()", "N", "ii()", "ii", "A = il()", "A", "il()", "il", "ret = INF", "ret", "INF", "for cost in range(min(A) - 1, max(A) + 1):\n tmp = 0\n for n in range(N):\n tmp += (A[n] - cost) ** 2\n ret = min(ret, tmp)\n ", "cost", "range(min(A) - 1, max(A) + 1)", "range", "min(A) - 1", "min(A)", "min", "A", "1", "max(A) + 1", "max(A)", "max", "A", "1", "tmp = 0", "tmp", "0", "for n in range(N):\n tmp += (A[n] - cost) ** 2\n ", "n", "range(N)", "range", "N", "tmp += (A[n] - cost) ** 2", "tmp", "(A[n] - cost) ** 2", "A[n] - cost", "A[n]", "A", "n", "cost", "2", "ret = min(ret, tmp)", "ret", "min(ret, tmp)", "min", "ret", "tmp", "print(ret)", "print", "ret", "if __name__ == '__main__':\n main()", "__name__ == '__main__'", "__name__", "'__main__'", "main()", "main", "il = lambda: list(map(int, sys.stdin.buffer.readline().split()))", "lambda: list(map(int, sys.stdin.buffer.readline().split()))", "il", "iss = lambda: sys.stdin.buffer.readline().decode().rstrip()", "lambda: sys.stdin.buffer.readline().decode().rstrip()", "iss", "MOD = 10 ** 9 + 7", "10 ** 9 + 7", "MOD", "iln = lambda n: [int(sys.stdin.buffer.readline().rstrip()) for _ in range(n)]", "lambda n: [int(sys.stdin.buffer.readline().rstrip()) for _ in range(n)]", "iln", "fl = lambda: list(map(float, sys.stdin.buffer.readline().split()))", "lambda: list(map(float, sys.stdin.buffer.readline().split()))", "fl", "ii = lambda: int(sys.stdin.buffer.readline().rstrip())", "lambda: int(sys.stdin.buffer.readline().rstrip())", "ii", "lcm = lambda x, y: (x * y) // math.gcd(x, y)", "lambda x, y: (x * y) // math.gcd(x, y)", "lcm", "def main():\n if os.getenv(\"LOCAL\"):\n sys.stdin = open(\"input.txt\", \"r\")\n\n N = ii()\n A = il()\n\n ret = INF\n for cost in range(min(A) - 1, max(A) + 1):\n tmp = 0\n for n in range(N):\n tmp += (A[n] - cost) ** 2\n ret = min(ret, tmp)\n print(ret)", "def main():\n if os.getenv(\"LOCAL\"):\n sys.stdin = open(\"input.txt\", \"r\")\n\n N = ii()\n A = il()\n\n ret = INF\n for cost in range(min(A) - 1, max(A) + 1):\n tmp = 0\n for n in range(N):\n tmp += (A[n] - cost) ** 2\n ret = min(ret, tmp)\n print(ret)", "main", "INF = float('inf')", "float('inf')", "INF", "sl = lambda: list(map(str, sys.stdin.buffer.readline().decode().split()))", "lambda: list(map(str, sys.stdin.buffer.readline().decode().split()))", "sl", "isn = lambda n: [sys.stdin.buffer.readline().decode().rstrip() for _ in range(n)]", "lambda n: [sys.stdin.buffer.readline().decode().rstrip() for _ in range(n)]", "isn" ]

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

[ [ 33, 6 ], [ 34, 29 ], [ 33, 34 ] ]

[ "import numpy as np\n\ninput()\na = np.array(sorted(map(int, input().split())))\nprint(min(sum((a - i) ** 2) for i in range(min(a), max(a) + 1)))", "import numpy as np", "numpy", "input()", "input", "a = np.array(sorted(map(int, input().split())))", "a", "np.array(sorted(map(int, input().split())))", "np.array", "np", "array", "sorted(map(int, input().split()))", "sorted", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "print(min(sum((a - i) ** 2) for i in range(min(a), max(a) + 1)))", "print", "min(sum((a - i) ** 2) for i in range(min(a), max(a) + 1))", "min", "sum((a - i) ** 2)", "sum", "(a - i) ** 2", "a - i", "a", "i", "2", "a = np.array(sorted(map(int, input().split())))", "np.array(sorted(map(int, input().split())))", "a" ]

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

[ [ 5, 4 ], [ 11, 10 ], [ 23, 22 ], [ 36, 35 ], [ 22, 37 ], [ 10, 41 ], [ 10, 44 ], [ 48, 47 ], [ 10, 47 ], [ 47, 52 ], [ 35, 53 ], [ 57, 56 ], [ 56, 62 ], [ 71, 68 ] ]

[ "def main():\n n = int(input())\n A = list(map(int, input().split()))\n round = lambda x: int((x * 2 + 1) // 2)\n m = round(sum(A) / len(A))\n ans = [(a - m) ** 2 for a in A]\n print(sum(ans))\n\nif __name__ == '__main__':\n main()", "def main():\n n = int(input())\n A = list(map(int, input().split()))\n round = lambda x: int((x * 2 + 1) // 2)\n m = round(sum(A) / len(A))\n ans = [(a - m) ** 2 for a in A]\n print(sum(ans))", "main", "n = int(input())", "n", "int(input())", "int", "input()", "input", "A = list(map(int, input().split()))", "A", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "round = lambda x: int((x * 2 + 1) // 2)", "round", "lambda x: int((x * 2 + 1) // 2)", "int((x * 2 + 1) // 2)", "int", "(x * 2 + 1) // 2", "x * 2 + 1", "x * 2", "x", "2", "1", "2", "x", "m = round(sum(A) / len(A))", "m", "round(sum(A) / len(A))", "round", "sum(A) / len(A)", "sum(A)", "sum", "A", "len(A)", "len", "A", "(a - m) ** 2 for a in A", "for a in A", "a", "A", "for a in A", "(a - m) ** 2", "a - m", "a", "m", "2", "ans = [(a - m) ** 2 for a in A]", "ans", "[(a - m) ** 2 for a in A]", "print(sum(ans))", "print", "sum(ans)", "sum", "ans", "if __name__ == '__main__':\n main()", "__name__ == '__main__'", "__name__", "'__main__'", "main()", "main", "def main():\n n = int(input())\n A = list(map(int, input().split()))\n round = lambda x: int((x * 2 + 1) // 2)\n m = round(sum(A) / len(A))\n ans = [(a - m) ** 2 for a in A]\n print(sum(ans))", "def main():\n n = int(input())\n A = list(map(int, input().split()))\n round = lambda x: int((x * 2 + 1) // 2)\n m = round(sum(A) / len(A))\n ans = [(a - m) ** 2 for a in A]\n print(sum(ans))", "main" ]

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

[ [ 73, 2 ], [ 70, 8 ], [ 76, 20 ], [ 71, 23 ], [ 67, 25 ], [ 71, 28 ], [ 82, 30 ], [ 34, 33 ], [ 68, 36 ], [ 77, 38 ], [ 64, 41 ], [ 45, 44 ], [ 71, 44 ], [ 79, 47 ], [ 44, 50 ], [ 33, 51 ], [ 83, 55 ], [ 80, 57 ], [ 65, 57 ], [ 83, 62 ], [ 64, 65 ], [ 67, 68 ], [ 70, 71 ], [ 73, 74 ], [ 76, 77 ], [ 79, 80 ], [ 82, 83 ] ]

[ "N=int(input())\ns=list(map(int,input().split()))\ns_max=max(s)\ns_min=min(s)\nA=[]\nfor i in range(s_min,s_max+1):\n b=0\n for j in s:\n b+=(j-i)**2\n A.append(b)\nprint(min(A))", "N=int(input())", "N", "int(input())", "int", "input()", "input", "s=list(map(int,input().split()))", "s", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "s_max=max(s)", "s_max", "max(s)", "max", "s", "s_min=min(s)", "s_min", "min(s)", "min", "s", "A=[]", "A", "[]", "for i in range(s_min,s_max+1):\n b=0\n for j in s:\n b+=(j-i)**2\n A.append(b)", "i", "range(s_min,s_max+1)", "range", "s_min", "s_max+1", "s_max", "1", "b=0", "b", "0", "for j in s:\n b+=(j-i)**2\n ", "j", "s", "b+=(j-i)**2", "b", "(j-i)**2", "j-i", "j", "i", "2", "A.append(b)", "A.append", "A", "append", "b", "print(min(A))", "print", "min(A)", "min", "A", "b=0", "0", "b", "s_min=min(s)", "min(s)", "s_min", "s=list(map(int,input().split()))", "list(map(int,input().split()))", "s", "N=int(input())", "int(input())", "N", "s_max=max(s)", "max(s)", "s_max", "b+=(j-i)**2", "(j-i)**2", "b", "A=[]", "[]", "A" ]

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

[ [ 81, 2 ], [ 10, 8 ], [ 78, 19 ], [ 75, 24 ], [ 84, 40 ], [ 46, 45 ], [ 76, 48 ], [ 79, 49 ], [ 53, 52 ], [ 52, 57 ], [ 45, 58 ], [ 72, 61 ], [ 85, 64 ], [ 73, 64 ], [ 73, 70 ], [ 85, 70 ], [ 72, 73 ], [ 75, 76 ], [ 78, 79 ], [ 81, 82 ], [ 84, 85 ] ]

[ "N=int(input())\n*A,=map(int,input().split())\n\nmx=max(A)\nmn=min(A)\n\n\nif len(set(A))==1:\n print(0)\nelse:\n ans=float('inf')\n for i in range(mn,mx):\n ans=min(ans, sum([(k-i)**2 for k in A]))\n print(ans)", "N=int(input())", "N", "int(input())", "int", "input()", "input", "*A,=map(int,input().split())", "*A", "A", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "mx=max(A)", "mx", "max(A)", "max", "A", "mn=min(A)", "mn", "min(A)", "min", "A", "if len(set(A))==1:\n print(0)\nelse:\n ans=float('inf')\n for i in range(mn,mx):\n ans=min(ans, sum([(k-i)**2 for k in A]))\n print(ans)", "len(set(A))==1", "len(set(A))", "len", "set(A)", "set", "A", "1", "print(0)", "print", "0", "ans=float('inf')", "ans", "float('inf')", "float", "'inf'", "for i in range(mn,mx):\n ans=min(ans, sum([(k-i)**2 for k in A]))\n ", "i", "range(mn,mx)", "range", "mn", "mx", "(k-i)**2 for k in A", "for k in A", "k", "A", "for k in A", "(k-i)**2", "k-i", "k", "i", "2", "ans=min(ans, sum([(k-i)**2 for k in A]))", "ans", "min(ans, sum([(k-i)**2 for k in A]))", "min", "ans", "sum([(k-i)**2 for k in A])", "sum", "[(k-i)**2 for k in A]", "print(ans)", "print", "ans", "ans=min(ans, sum([(k-i)**2 for k in A]))", "min(ans, sum([(k-i)**2 for k in A]))", "ans", "mn=min(A)", "min(A)", "mn", "mx=max(A)", "max(A)", "mx", "N=int(input())", "int(input())", "N", "ans=float('inf')", "float('inf')", "ans" ]

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

[ [ 59, 2 ], [ 62, 8 ], [ 53, 20 ], [ 63, 26 ], [ 63, 29 ], [ 65, 31 ], [ 35, 34 ], [ 63, 39 ], [ 56, 41 ], [ 54, 44 ], [ 63, 46 ], [ 34, 47 ], [ 57, 51 ], [ 66, 51 ], [ 53, 54 ], [ 56, 57 ], [ 59, 60 ], [ 62, 63 ], [ 65, 66 ] ]

[ "n = int(input())\nl = list(map(int,input().split()))\nm = round(sum(l)/len(l))\nans = 0\nfor i in range(len(l)):\n ans += (m - l[i])**2\n\nprint(ans)", "n = int(input())", "n", "int(input())", "int", "input()", "input", "l = list(map(int,input().split()))", "l", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "m = round(sum(l)/len(l))", "m", "round(sum(l)/len(l))", "round", "sum(l)/len(l)", "sum(l)", "sum", "l", "len(l)", "len", "l", "ans = 0", "ans", "0", "for i in range(len(l)):\n ans += (m - l[i])**2", "i", "range(len(l))", "range", "len(l)", "len", "l", "ans += (m - l[i])**2", "ans", "(m - l[i])**2", "m - l[i]", "m", "l[i]", "l", "i", "2", "print(ans)", "print", "ans", "m = round(sum(l)/len(l))", "round(sum(l)/len(l))", "m", "ans += (m - l[i])**2", "(m - l[i])**2", "ans", "n = int(input())", "int(input())", "n", "l = list(map(int,input().split()))", "list(map(int,input().split()))", "l", "ans = 0", "0", "ans" ]

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

[ [ 76, 2 ], [ 79, 8 ], [ 64, 20 ], [ 26, 25 ], [ 80, 30 ], [ 80, 34 ], [ 70, 37 ], [ 41, 40 ], [ 77, 43 ], [ 67, 45 ], [ 80, 49 ], [ 40, 50 ], [ 25, 51 ], [ 65, 55 ], [ 74, 55 ], [ 68, 56 ], [ 71, 56 ], [ 73, 58 ], [ 68, 59 ], [ 71, 59 ], [ 74, 62 ], [ 65, 62 ], [ 64, 65 ], [ 67, 68 ], [ 70, 71 ], [ 68, 73 ], [ 71, 73 ], [ 73, 74 ], [ 76, 77 ], [ 79, 80 ] ]

[ "n=int(input())\na=list(map(int,input().split()))\nans=10**18\nfor i in range(min(a),max(a)+1):\n x=0\n for j in range(n):\n x+=(a[j]-i)**2\n if ans>x:\n ans=x\nprint(ans)", "n=int(input())", "n", "int(input())", "int", "input()", "input", "a=list(map(int,input().split()))", "a", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "ans=10**18", "ans", "10**18", "10", "18", "for i in range(min(a),max(a)+1):\n x=0\n for j in range(n):\n x+=(a[j]-i)**2\n if ans>x:\n ans=x", "i", "range(min(a),max(a)+1)", "range", "min(a)", "min", "a", "max(a)+1", "max(a)", "max", "a", "1", "x=0", "x", "0", "for j in range(n):\n x+=(a[j]-i)**2\n ", "j", "range(n)", "range", "n", "x+=(a[j]-i)**2", "x", "(a[j]-i)**2", "a[j]-i", "a[j]", "a", "j", "i", "2", "if ans>x:\n ans=x", "ans>x", "ans", "x", "ans=x", "ans", "x", "print(ans)", "print", "ans", "ans=10**18", "10**18", "ans", "x+=(a[j]-i)**2", "(a[j]-i)**2", "x", "x=0", "0", "x", "ans=x", "x", "ans", "n=int(input())", "int(input())", "n", "a=list(map(int,input().split()))", "list(map(int,input().split()))", "a" ]

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

[ [ 68, 2 ], [ 59, 8 ], [ 53, 20 ], [ 26, 25 ], [ 62, 31 ], [ 35, 34 ], [ 60, 34 ], [ 56, 37 ], [ 25, 40 ], [ 34, 41 ], [ 65, 44 ], [ 54, 47 ], [ 66, 47 ], [ 57, 48 ], [ 63, 48 ], [ 66, 51 ], [ 54, 51 ], [ 53, 54 ], [ 56, 57 ], [ 59, 60 ], [ 62, 63 ], [ 65, 66 ], [ 68, 69 ] ]

[ "N = int(input())\nA = list(map(int, input().split()))\nC = 10 ** 9\nfor i in range(-100, 101):\n c = 0\n for a in A:\n c += (i - a) ** 2\n C = min(C, c)\nprint(C)", "N = int(input())", "N", "int(input())", "int", "input()", "input", "A = list(map(int, input().split()))", "A", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "C = 10 ** 9", "C", "10 ** 9", "10", "9", "for i in range(-100, 101):\n c = 0\n for a in A:\n c += (i - a) ** 2\n C = min(C, c)", "i", "range(-100, 101)", "range", "-100", "101", "c = 0", "c", "0", "for a in A:\n c += (i - a) ** 2\n ", "a", "A", "c += (i - a) ** 2", "c", "(i - a) ** 2", "i - a", "i", "a", "2", "C = min(C, c)", "C", "min(C, c)", "min", "C", "c", "print(C)", "print", "C", "C = 10 ** 9", "10 ** 9", "C", "c += (i - a) ** 2", "(i - a) ** 2", "c", "A = list(map(int, input().split()))", "list(map(int, input().split()))", "A", "c = 0", "0", "c", "C = min(C, c)", "min(C, c)", "C", "N = int(input())", "int(input())", "N" ]

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

[ [ 72, 2 ], [ 63, 8 ], [ 57, 20 ], [ 26, 25 ], [ 60, 31 ], [ 35, 34 ], [ 73, 37 ], [ 69, 39 ], [ 25, 42 ], [ 64, 44 ], [ 34, 45 ], [ 66, 48 ], [ 70, 51 ], [ 61, 51 ], [ 58, 52 ], [ 67, 52 ], [ 67, 55 ], [ 58, 55 ], [ 57, 58 ], [ 60, 61 ], [ 63, 64 ], [ 66, 67 ], [ 69, 70 ], [ 72, 73 ] ]

[ "n=int(input())\na=list(map(int,input().split()))\nans=float('inf')\nfor i in range(-100, 101):\n tmp=0\n for j in range(n):\n tmp+=(i-a[j])**2\n ans=min(tmp,ans)\nprint(ans)", "n=int(input())", "n", "int(input())", "int", "input()", "input", "a=list(map(int,input().split()))", "a", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "ans=float('inf')", "ans", "float('inf')", "float", "'inf'", "for i in range(-100, 101):\n tmp=0\n for j in range(n):\n tmp+=(i-a[j])**2\n ans=min(tmp,ans)", "i", "range(-100, 101)", "range", "-100", "101", "tmp=0", "tmp", "0", "for j in range(n):\n tmp+=(i-a[j])**2\n ", "j", "range(n)", "range", "n", "tmp+=(i-a[j])**2", "tmp", "(i-a[j])**2", "i-a[j]", "i", "a[j]", "a", "j", "2", "ans=min(tmp,ans)", "ans", "min(tmp,ans)", "min", "tmp", "ans", "print(ans)", "print", "ans", "ans=float('inf')", "float('inf')", "ans", "tmp=0", "0", "tmp", "a=list(map(int,input().split()))", "list(map(int,input().split()))", "a", "ans=min(tmp,ans)", "min(tmp,ans)", "ans", "tmp+=(i-a[j])**2", "(i-a[j])**2", "tmp", "n=int(input())", "int(input())", "n" ]

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

[ [ 5, 4 ], [ 11, 10 ], [ 10, 27 ], [ 34, 33 ], [ 41, 40 ], [ 48, 47 ], [ 10, 47 ], [ 47, 52 ], [ 40, 53 ], [ 57, 56 ], [ 56, 62 ], [ 33, 63 ], [ 65, 63 ], [ 66, 65 ], [ 56, 66 ], [ 65, 69 ], [ 33, 69 ], [ 74, 71 ] ]

[ "def resolve():\n N = int(input())\n a_list = list(map(int, input().split()))\n if len(set(a_list)) == 1:\n print(0)\n else:\n # コストは最大でも10**6\n min_cost = 10 ** 6 + 1\n for x in range(-100, 101):\n cost = sum([(a -x)**2 for a in a_list])\n if cost < min_cost:\n min_cost = cost\n print(min_cost)\n\nresolve()", "def resolve():\n N = int(input())\n a_list = list(map(int, input().split()))\n if len(set(a_list)) == 1:\n print(0)\n else:\n # コストは最大でも10**6\n min_cost = 10 ** 6 + 1\n for x in range(-100, 101):\n cost = sum([(a -x)**2 for a in a_list])\n if cost < min_cost:\n min_cost = cost\n print(min_cost)", "resolve", "N = int(input())", "N", "int(input())", "int", "input()", "input", "a_list = list(map(int, input().split()))", "a_list", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "if len(set(a_list)) == 1:\n print(0)\n else:\n # コストは最大でも10**6\n min_cost = 10 ** 6 + 1\n for x in range(-100, 101):\n cost = sum([(a -x)**2 for a in a_list])\n if cost < min_cost:\n min_cost = cost\n print(min_cost)", "len(set(a_list)) == 1", "len(set(a_list))", "len", "set(a_list)", "set", "a_list", "1", "print(0)", "print", "0", "min_cost = 10 ** 6 + 1", "min_cost", "10 ** 6 + 1", "10 ** 6", "10", "6", "1", "for x in range(-100, 101):\n cost = sum([(a -x)**2 for a in a_list])\n if cost < min_cost:\n min_cost = cost\n ", "x", "range(-100, 101)", "range", "-100", "101", "(a -x)**2 for a in a_list", "for a in a_list", "a", "a_list", "for a in a_list", "(a -x)**2", "a -x", "a", "x", "2", "cost = sum([(a -x)**2 for a in a_list])", "cost", "sum([(a -x)**2 for a in a_list])", "sum", "[(a -x)**2 for a in a_list]", "if cost < min_cost:\n min_cost = cost\n ", "cost < min_cost", "cost", "min_cost", "min_cost = cost", "min_cost", "cost", "print(min_cost)", "print", "min_cost", "resolve()", "resolve", "def resolve():\n N = int(input())\n a_list = list(map(int, input().split()))\n if len(set(a_list)) == 1:\n print(0)\n else:\n # コストは最大でも10**6\n min_cost = 10 ** 6 + 1\n for x in range(-100, 101):\n cost = sum([(a -x)**2 for a in a_list])\n if cost < min_cost:\n min_cost = cost\n print(min_cost)", "def resolve():\n N = int(input())\n a_list = list(map(int, input().split()))\n if len(set(a_list)) == 1:\n print(0)\n else:\n # コストは最大でも10**6\n min_cost = 10 ** 6 + 1\n for x in range(-100, 101):\n cost = sum([(a -x)**2 for a in a_list])\n if cost < min_cost:\n min_cost = cost\n print(min_cost)", "resolve" ]

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

[ [ 68, 2 ], [ 10, 9 ], [ 9, 18 ], [ 62, 20 ], [ 59, 23 ], [ 29, 28 ], [ 56, 34 ], [ 38, 37 ], [ 63, 37 ], [ 71, 40 ], [ 28, 43 ], [ 37, 44 ], [ 65, 47 ], [ 60, 50 ], [ 66, 50 ], [ 72, 51 ], [ 57, 51 ], [ 66, 54 ], [ 60, 54 ], [ 56, 57 ], [ 59, 60 ], [ 62, 63 ], [ 65, 66 ], [ 68, 69 ], [ 71, 72 ] ]

[ "n = int(input())\nl = [int(i) for i in input().split()]\n\nval = float(\"inf\")\nfor i in range(-100,101):\n\tnew = 0\n\tfor j in l:\n\t\tnew += (i-j)**2\t\n\tval = min(val,new)\t\t\nprint(val)\t", "n = int(input())", "n", "int(input())", "int", "input()", "input", "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", "l = [int(i) for i in input().split()]", "l", "[int(i) for i in input().split()]", "val = float(\"inf\")", "val", "float(\"inf\")", "float", "\"inf\"", "for i in range(-100,101):\n\tnew = 0\n\tfor j in l:\n\t\tnew += (i-j)**2\t\n\tval = min(val,new)\t\t", "i", "range(-100,101)", "range", "-100", "101", "new = 0", "new", "0", "for j in l:\n\t\tnew += (i-j)**2\t\n\t", "j", "l", "new += (i-j)**2", "new", "(i-j)**2", "i-j", "i", "j", "2", "val = min(val,new)", "val", "min(val,new)", "min", "val", "new", "print(val)", "print", "val", "new = 0", "0", "new", "val = float(\"inf\")", "float(\"inf\")", "val", "l = [int(i) for i in input().split()]", "[int(i) for i in input().split()]", "l", "val = min(val,new)", "min(val,new)", "val", "n = int(input())", "int(input())", "n", "new += (i-j)**2", "(i-j)**2", "new" ]

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

[ [ 58, 2 ], [ 55, 8 ], [ 61, 20 ], [ 26, 25 ], [ 64, 33 ], [ 37, 36 ], [ 56, 36 ], [ 70, 39 ], [ 36, 42 ], [ 25, 43 ], [ 67, 46 ], [ 62, 49 ], [ 68, 49 ], [ 71, 50 ], [ 65, 50 ], [ 68, 53 ], [ 62, 53 ], [ 55, 56 ], [ 58, 59 ], [ 61, 62 ], [ 64, 65 ], [ 67, 68 ], [ 70, 71 ] ]

[ "n = int(input())\na = list(map(int,input().split()))\nans=10**9\nfor i in range(-100,100+1):\n const=0\n for j in a:\n const += (j-i)**2\n ans=min(ans,const)\nprint(ans)", "n = int(input())", "n", "int(input())", "int", "input()", "input", "a = list(map(int,input().split()))", "a", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "ans=10**9", "ans", "10**9", "10", "9", "for i in range(-100,100+1):\n const=0\n for j in a:\n const += (j-i)**2\n ans=min(ans,const)", "i", "range(-100,100+1)", "range", "-100", "100+1", "100", "1", "const=0", "const", "0", "for j in a:\n const += (j-i)**2\n ", "j", "a", "const += (j-i)**2", "const", "(j-i)**2", "j-i", "j", "i", "2", "ans=min(ans,const)", "ans", "min(ans,const)", "min", "ans", "const", "print(ans)", "print", "ans", "a = list(map(int,input().split()))", "list(map(int,input().split()))", "a", "n = int(input())", "int(input())", "n", "ans=10**9", "10**9", "ans", "const=0", "0", "const", "ans=min(ans,const)", "min(ans,const)", "ans", "const += (j-i)**2", "(j-i)**2", "const" ]

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

[ [ 65, 2 ], [ 74, 8 ], [ 83, 20 ], [ 75, 26 ], [ 75, 29 ], [ 80, 31 ], [ 75, 35 ], [ 75, 38 ], [ 81, 42 ], [ 84, 43 ], [ 68, 46 ], [ 77, 49 ], [ 53, 52 ], [ 75, 52 ], [ 71, 55 ], [ 52, 58 ], [ 69, 59 ], [ 84, 59 ], [ 72, 63 ], [ 78, 63 ], [ 65, 66 ], [ 68, 69 ], [ 71, 72 ], [ 74, 75 ], [ 77, 78 ], [ 80, 81 ], [ 83, 84 ] ]

[ "n = int(input())\nli = list(map(int,input().split()))\n\nx = int(sum(li)/len(li))\ny = sum(li)/len(li)\nif y-x > 0.5:\n x += 1\n\nans = 0\n\nfor i in li:\n ans += (i-x)**2\n\nprint(ans)", "n = int(input())", "n", "int(input())", "int", "input()", "input", "li = list(map(int,input().split()))", "li", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "x = int(sum(li)/len(li))", "x", "int(sum(li)/len(li))", "int", "sum(li)/len(li)", "sum(li)", "sum", "li", "len(li)", "len", "li", "y = sum(li)/len(li)", "y", "sum(li)/len(li)", "sum(li)", "sum", "li", "len(li)", "len", "li", "if y-x > 0.5:\n x += 1", "y-x > 0.5", "y-x", "y", "x", "0.5", "x += 1", "x", "1", "ans = 0", "ans", "0", "for i in li:\n ans += (i-x)**2", "i", "li", "ans += (i-x)**2", "ans", "(i-x)**2", "i-x", "i", "x", "2", "print(ans)", "print", "ans", "n = int(input())", "int(input())", "n", "x += 1", "1", "x", "ans += (i-x)**2", "(i-x)**2", "ans", "li = list(map(int,input().split()))", "list(map(int,input().split()))", "li", "ans = 0", "0", "ans", "y = sum(li)/len(li)", "sum(li)/len(li)", "y", "x = int(sum(li)/len(li))", "int(sum(li)/len(li))", "x" ]

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

[ [ 64, 2 ], [ 52, 8 ], [ 58, 20 ], [ 24, 23 ], [ 67, 29 ], [ 33, 32 ], [ 53, 32 ], [ 55, 35 ], [ 23, 38 ], [ 32, 39 ], [ 59, 43 ], [ 62, 43 ], [ 56, 44 ], [ 68, 44 ], [ 61, 46 ], [ 56, 47 ], [ 68, 47 ], [ 62, 50 ], [ 59, 50 ], [ 52, 53 ], [ 55, 56 ], [ 58, 59 ], [ 56, 61 ], [ 68, 61 ], [ 61, 62 ], [ 64, 65 ], [ 67, 68 ] ]

[ "n = int(input())\na = list(map(int, input().split()))\n\n\ny = 1000000\n\n\nfor i in range(-100, 101):\n x = 0\n for m in a:\n x += (i-m)**2\n if y > x:\n y = x\n\nprint(y)", "n = int(input())", "n", "int(input())", "int", "input()", "input", "a = list(map(int, input().split()))", "a", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "y = 1000000", "y", "1000000", "for i in range(-100, 101):\n x = 0\n for m in a:\n x += (i-m)**2\n if y > x:\n y = x", "i", "range(-100, 101)", "range", "-100", "101", "x = 0", "x", "0", "for m in a:\n x += (i-m)**2\n ", "m", "a", "x += (i-m)**2", "x", "(i-m)**2", "i-m", "i", "m", "2", "if y > x:\n y = x", "y > x", "y", "x", "y = x", "y", "x", "print(y)", "print", "y", "a = list(map(int, input().split()))", "list(map(int, input().split()))", "a", "x += (i-m)**2", "(i-m)**2", "x", "y = 1000000", "1000000", "y", "y = x", "x", "y", "n = int(input())", "int(input())", "n", "x = 0", "0", "x" ]

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

[ [ 52, 2 ], [ 52, 11 ], [ 50, 16 ], [ 53, 19 ], [ 50, 26 ], [ 53, 28 ], [ 53, 37 ], [ 50, 38 ], [ 52, 50 ], [ 52, 53 ] ]

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

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

[ [ 55, 4 ], [ 55, 13 ], [ 53, 17 ], [ 56, 19 ], [ 56, 30 ], [ 56, 36 ], [ 53, 37 ], [ 55, 53 ], [ 55, 56 ] ]

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

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

[ [ 5, 4 ], [ 4, 13 ], [ 58, 15 ], [ 58, 17 ], [ 59, 21 ], [ 56, 25 ], [ 59, 33 ], [ 56, 36 ], [ 56, 47 ], [ 59, 48 ], [ 58, 56 ], [ 58, 59 ] ]

[ "from bisect import bisect_right\na, b = (int(x) for x in input().split())\nif a <= 0 and 0 <= b: #0を含む\n print('Zero')\nelif 0 < a and 0 < b: #すべて正\n print('Positive')\nelse: #すべて負\n print('Positive' if (b - a + 1)%2 == 0 else 'Negative')", "from bisect import bisect_right", "int(x) for x in input().split()", "for x in input().split()", "x", "input().split()", "().split", "()", "input", "split", "for x in input().split()", "int(x)", "int", "x", "a, b = (int(x) for x in input().split())", "a", "(int(x) for x in input().split())", "b", "if a <= 0 and 0 <= b: #0を含む\n print('Zero')\nelif 0 < a and 0 < b: #すべて正\n print('Positive')\nelse: #すべて負\n print('Positive' if (b - a + 1)%2 == 0 else 'Negative')", "a <= 0 and 0 <= b", "a <= 0", "a", "0", "0 <= b", "0", "b", "print('Zero')", "print", "'Zero'", "elif 0 < a and 0 < b: #すべて正\n print('Positive')", "0 < a and 0 < b", "0 < a", "0", "a", "0 < b", "0", "b", "print('Positive')", "print", "'Positive'", "print('Positive' if (b - a + 1)%2 == 0 else 'Negative')", "print", "'Positive' if (b - a + 1)%2 == 0 else 'Negative'", "(b - a + 1)%2 == 0", "(b - a + 1)%2", "b - a + 1", "b - a", "b", "a", "1", "2", "0", "'Positive'", "'Negative'", "b = (int(x) for x in input().split())", "(int(x) for x in input().split())", "b", "a, b = (int(x) for x in input().split())", "(int(x) for x in input().split())", "a" ]

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

[ [ 73, 2 ], [ 73, 11 ], [ 74, 15 ], [ 71, 18 ], [ 74, 26 ], [ 71, 29 ], [ 74, 37 ], [ 71, 40 ], [ 67, 46 ], [ 74, 50 ], [ 71, 53 ], [ 68, 57 ], [ 67, 68 ], [ 73, 71 ], [ 73, 74 ] ]

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

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

[ [ 67, 2 ], [ 67, 11 ], [ 68, 15 ], [ 62, 18 ], [ 68, 26 ], [ 62, 29 ], [ 68, 36 ], [ 64, 42 ], [ 62, 45 ], [ 68, 46 ], [ 65, 51 ], [ 67, 62 ], [ 64, 65 ], [ 67, 68 ] ]

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

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

[ [ 67, 2 ], [ 67, 13 ], [ 70, 15 ], [ 68, 21 ], [ 65, 24 ], [ 68, 32 ], [ 65, 36 ], [ 68, 40 ], [ 65, 42 ], [ 65, 52 ], [ 68, 53 ], [ 67, 65 ], [ 67, 68 ], [ 70, 71 ] ]

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

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

[ [ 4, 3 ], [ 3, 12 ], [ 56, 14 ], [ 56, 16 ], [ 57, 19 ], [ 57, 26 ], [ 54, 33 ], [ 54, 42 ], [ 57, 43 ], [ 56, 54 ], [ 56, 57 ] ]

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

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

[ [ 9, 8 ], [ 58, 15 ], [ 9, 17 ], [ 8, 20 ], [ 8, 28 ], [ 17, 31 ], [ 17, 39 ], [ 17, 44 ], [ 8, 45 ], [ 61, 55 ] ]

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

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

[ [ 44, 2 ], [ 44, 11 ], [ 45, 14 ], [ 45, 20 ], [ 42, 21 ], [ 42, 33 ], [ 44, 42 ], [ 44, 45 ] ]

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

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

[ [ 83, 2 ], [ 83, 11 ], [ 84, 17 ], [ 81, 20 ], [ 84, 24 ], [ 81, 27 ], [ 84, 31 ], [ 81, 34 ], [ 84, 42 ], [ 81, 45 ], [ 84, 53 ], [ 81, 56 ], [ 86, 59 ], [ 81, 64 ], [ 84, 65 ], [ 87, 70 ], [ 83, 81 ], [ 83, 84 ], [ 86, 87 ] ]

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

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

[ [ 73, 2 ], [ 73, 11 ], [ 71, 15 ], [ 74, 18 ], [ 71, 26 ], [ 74, 29 ], [ 71, 38 ], [ 74, 41 ], [ 71, 45 ], [ 74, 48 ], [ 71, 58 ], [ 74, 59 ], [ 73, 71 ], [ 73, 74 ] ]

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

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

[ [ 67, 13 ], [ 23, 22 ], [ 68, 29 ], [ 23, 31 ], [ 22, 34 ], [ 31, 41 ], [ 31, 47 ], [ 22, 48 ], [ 71, 65 ], [ 67, 68 ] ]

[ "import sys\nimport bisect\nsys.setrecursionlimit(1 << 25)\nread = sys.stdin.readline\n\ndef main():\n a,b = map(int,read().split())\n if a > 0:\n print(\"Positive\")\n elif b < 0:\n if (b - a)%2 == 1:\n print(\"Positive\")\n else:\n print(\"Negative\")\n else:\n print(\"Zero\")\n \nif __name__ == '__main__':\n main()", "import sys", "sys", "import bisect", "bisect", "sys.setrecursionlimit(1 << 25)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "1 << 25", "1", "25", "read = sys.stdin.readline", "read", "sys.stdin.readline", "sys.stdin", "sys", "stdin", "readline", "def main():\n a,b = map(int,read().split())\n if a > 0:\n print(\"Positive\")\n elif b < 0:\n if (b - a)%2 == 1:\n print(\"Positive\")\n else:\n print(\"Negative\")\n else:\n print(\"Zero\")\n ", "main", "a,b = map(int,read().split())", "a", "map(int,read().split())", "map", "int", "read().split()", "().split", "()", "read", "split", "b", "if a > 0:\n print(\"Positive\")\n elif b < 0:\n if (b - a)%2 == 1:\n print(\"Positive\")\n else:\n print(\"Negative\")\n else:\n print(\"Zero\")\n ", "a > 0", "a", "0", "print(\"Positive\")", "print", "\"Positive\"", "elif b < 0:\n if (b - a)%2 == 1:\n print(\"Positive\")\n else:\n print(\"Negative\")\n ", "b < 0", "b", "0", "if (b - a)%2 == 1:\n print(\"Positive\")\n else:\n print(\"Negative\")\n ", "(b - a)%2 == 1", "(b - a)%2", "b - a", "b", "a", "2", "1", "print(\"Positive\")", "print", "\"Positive\"", "print(\"Negative\")", "print", "\"Negative\"", "print(\"Zero\")", "print", "\"Zero\"", "if __name__ == '__main__':\n main()", "__name__ == '__main__'", "__name__", "'__main__'", "main()", "main", "read = sys.stdin.readline", "sys.stdin.readline", "read", "def main():\n a,b = map(int,read().split())\n if a > 0:\n print(\"Positive\")\n elif b < 0:\n if (b - a)%2 == 1:\n print(\"Positive\")\n else:\n print(\"Negative\")\n else:\n print(\"Zero\")\n ", "def main():\n a,b = map(int,read().split())\n if a > 0:\n print(\"Positive\")\n elif b < 0:\n if (b - a)%2 == 1:\n print(\"Positive\")\n else:\n print(\"Negative\")\n else:\n print(\"Zero\")\n ", "main" ]

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

[ [ 56, 2 ], [ 56, 11 ], [ 57, 15 ], [ 51, 19 ], [ 57, 26 ], [ 53, 31 ], [ 57, 35 ], [ 51, 36 ], [ 54, 40 ], [ 56, 51 ], [ 53, 54 ], [ 56, 57 ] ]

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

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

[ [ 66, 2 ], [ 66, 13 ], [ 67, 16 ], [ 58, 17 ], [ 63, 19 ], [ 58, 20 ], [ 60, 21 ], [ 64, 22 ], [ 67, 22 ], [ 64, 27 ], [ 67, 27 ], [ 61, 30 ], [ 58, 30 ], [ 61, 35 ], [ 58, 35 ], [ 64, 36 ], [ 67, 36 ], [ 64, 45 ], [ 67, 45 ], [ 61, 49 ], [ 58, 49 ], [ 66, 58 ], [ 64, 60 ], [ 67, 60 ], [ 60, 61 ], [ 58, 63 ], [ 63, 64 ], [ 66, 67 ] ]

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

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

[ [ 81, 2 ], [ 81, 11 ], [ 72, 13 ], [ 82, 18 ], [ 70, 21 ], [ 66, 24 ], [ 82, 29 ], [ 70, 32 ], [ 78, 35 ], [ 82, 40 ], [ 70, 43 ], [ 70, 49 ], [ 82, 50 ], [ 63, 54 ], [ 75, 57 ], [ 76, 61 ], [ 64, 61 ], [ 79, 61 ], [ 67, 61 ], [ 73, 61 ], [ 63, 64 ], [ 66, 67 ], [ 81, 70 ], [ 72, 73 ], [ 75, 76 ], [ 78, 79 ], [ 81, 82 ] ]

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

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

[ [ 69, 4 ], [ 66, 11 ], [ 70, 18 ], [ 66, 20 ], [ 67, 23 ], [ 64, 30 ], [ 64, 37 ], [ 64, 40 ], [ 67, 49 ], [ 64, 52 ], [ 66, 64 ], [ 66, 67 ], [ 69, 70 ] ]

[ "import sys\ninput = sys.stdin.readline\n\n# A - Range Product\na, b = map(int, input().split())\n\nif a > 0:\n\tprint('Positive')\nelif b >= 0:\n\tprint('Zero')\nelse:\n\tif b > 0:\n\t\tb == 0\n\t\n\tif (abs(a)-abs(b)+1) % 2 == 1:\n\t\tprint('Negative')\n\telse:\n\t\tprint('Positive')", "import sys", "sys", "input = sys.stdin.readline", "input", "sys.stdin.readline", "sys.stdin", "sys", "stdin", "readline", "a, b = map(int, input().split())", "a", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "if a > 0:\n\tprint('Positive')\nelif b >= 0:\n\tprint('Zero')\nelse:\n\tif b > 0:\n\t\tb == 0\n\t\n\tif (abs(a)-abs(b)+1) % 2 == 1:\n\t\tprint('Negative')\n\telse:\n\t\tprint('Positive')", "a > 0", "a", "0", "print('Positive')", "print", "'Positive'", "elif b >= 0:\n\tprint('Zero')", "b >= 0", "b", "0", "print('Zero')", "print", "'Zero'", "if b > 0:\n\t\tb == 0\n\t\n\t", "b > 0", "b", "0", "b == 0", "b", "0", "if (abs(a)-abs(b)+1) % 2 == 1:\n\t\tprint('Negative')\n\telse:\n\t\tprint('Positive')", "(abs(a)-abs(b)+1) % 2 == 1", "(abs(a)-abs(b)+1) % 2", "abs(a)-abs(b)+1", "abs(a)-abs(b)", "abs(a)", "abs", "a", "abs(b)", "abs", "b", "1", "2", "1", "print('Negative')", "print", "'Negative'", "print('Positive')", "print", "'Positive'", "b = map(int, input().split())", "map(int, input().split())", "b", "a, b = map(int, input().split())", "map(int, input().split())", "a", "input = sys.stdin.readline", "sys.stdin.readline", "input" ]

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

[ [ 5, 4 ], [ 5, 13 ], [ 16, 15 ], [ 4, 20 ], [ 13, 23 ], [ 4, 31 ], [ 39, 38 ], [ 13, 40 ], [ 4, 41 ], [ 38, 45 ], [ 15, 45 ], [ 64, 61 ] ]

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

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

[ [ 50, 2 ], [ 50, 11 ], [ 48, 15 ], [ 51, 18 ], [ 48, 26 ], [ 51, 29 ], [ 48, 37 ], [ 51, 38 ], [ 50, 48 ], [ 50, 51 ] ]

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

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

[ [ 97, 42 ], [ 86, 44 ], [ 97, 45 ], [ 92, 48 ], [ 92, 56 ], [ 98, 60 ], [ 98, 68 ], [ 92, 69 ], [ 97, 92 ], [ 97, 98 ] ]

[ "def i():\n\treturn int(input())\ndef i2():\n\treturn map(int,input().split())\ndef s():\n\treturn str(input())\ndef l():\n\treturn list(input())\ndef intl():\n\treturn list(int(k) for k in input().split())\n\na,b = i2()\nif a > 0:\n\tprint(\"Positive\")\nelif a <= 0 and 0 <= b:\n\tprint(\"Zero\")\nelse:\n\tif (b - a)%2 == 0:\n\t\tprint(\"Negative\")\n\telse:\n\t\tprint(\"Positive\")", "def i():\n\treturn int(input())", "i", "return int(input())", "int(input())", "int", "input()", "input", "def i2():\n\treturn map(int,input().split())", "i2", "return map(int,input().split())", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "def s():\n\treturn str(input())", "s", "return str(input())", "str(input())", "str", "input()", "input", "def l():\n\treturn list(input())", "l", "return list(input())", "list(input())", "list", "input()", "input", "def intl():\n\treturn list(int(k) for k in input().split())", "intl", "return list(int(k) for k in input().split())", "list(int(k) for k in input().split())", "list", "int(k)", "int", "k", "a,b = i2()", "a", "i2()", "i2", "b", "if a > 0:\n\tprint(\"Positive\")\nelif a <= 0 and 0 <= b:\n\tprint(\"Zero\")\nelse:\n\tif (b - a)%2 == 0:\n\t\tprint(\"Negative\")\n\telse:\n\t\tprint(\"Positive\")", "a > 0", "a", "0", "print(\"Positive\")", "print", "\"Positive\"", "elif a <= 0 and 0 <= b:\n\tprint(\"Zero\")", "a <= 0 and 0 <= b", "a <= 0", "a", "0", "0 <= b", "0", "b", "print(\"Zero\")", "print", "\"Zero\"", "if (b - a)%2 == 0:\n\t\tprint(\"Negative\")\n\telse:\n\t\tprint(\"Positive\")", "(b - a)%2 == 0", "(b - a)%2", "b - a", "b", "a", "2", "0", "print(\"Negative\")", "print", "\"Negative\"", "print(\"Positive\")", "print", "\"Positive\"", "def intl():\n\treturn list(int(k) for k in input().split())", "def intl():\n\treturn list(int(k) for k in input().split())", "intl", "def l():\n\treturn list(input())", "def l():\n\treturn list(input())", "l", "def i2():\n\treturn map(int,input().split())", "def i2():\n\treturn map(int,input().split())", "i2", "def s():\n\treturn str(input())", "def s():\n\treturn str(input())", "s", "a,b = i2()", "i2()", "a", "def i():\n\treturn int(input())", "def i():\n\treturn int(input())", "i", "b = i2()", "i2()", "b" ]

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

[ [ 87, 2 ], [ 87, 11 ], [ 73, 15 ], [ 88, 18 ], [ 75, 21 ], [ 73, 25 ], [ 73, 29 ], [ 69, 32 ], [ 78, 35 ], [ 88, 38 ], [ 73, 39 ], [ 73, 43 ], [ 81, 46 ], [ 84, 49 ], [ 85, 53 ], [ 82, 53 ], [ 79, 53 ], [ 70, 53 ], [ 76, 53 ], [ 85, 60 ], [ 82, 60 ], [ 79, 60 ], [ 70, 60 ], [ 76, 60 ], [ 69, 70 ], [ 87, 73 ], [ 75, 76 ], [ 78, 79 ], [ 81, 82 ], [ 84, 85 ], [ 87, 88 ] ]

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

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

[ [ 82, 4 ], [ 91, 11 ], [ 88, 18 ], [ 33, 32 ], [ 83, 39 ], [ 33, 41 ], [ 32, 45 ], [ 41, 47 ], [ 32, 54 ], [ 32, 64 ], [ 41, 65 ], [ 86, 80 ], [ 82, 83 ], [ 88, 89 ], [ 91, 92 ] ]

[ "import sys\n\nreadline = sys.stdin.readline\nMOD = 10 ** 9 + 7\nINF = float('INF')\nsys.setrecursionlimit(10 ** 5)\n\n\ndef main():\n a, b = map(int, readline().split())\n\n if a <= 0 <= b:\n print(\"Zero\")\n else:\n if 0 < a:\n print(\"Positive\")\n elif (-a + b + 1) % 2 == 0:\n print(\"Positive\")\n else:\n print(\"Negative\")\n\n\nif __name__ == '__main__':\n main()", "import sys", "sys", "readline = sys.stdin.readline", "readline", "sys.stdin.readline", "sys.stdin", "sys", "stdin", "readline", "MOD = 10 ** 9 + 7", "MOD", "10 ** 9 + 7", "10 ** 9", "10", "9", "7", "INF = float('INF')", "INF", "float('INF')", "float", "'INF'", "sys.setrecursionlimit(10 ** 5)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "10 ** 5", "10", "5", "def main():\n a, b = map(int, readline().split())\n\n if a <= 0 <= b:\n print(\"Zero\")\n else:\n if 0 < a:\n print(\"Positive\")\n elif (-a + b + 1) % 2 == 0:\n print(\"Positive\")\n else:\n print(\"Negative\")", "main", "a, b = map(int, readline().split())", "a", "map(int, readline().split())", "map", "int", "readline().split()", "().split", "()", "readline", "split", "b", "if a <= 0 <= b:\n print(\"Zero\")\n else:\n if 0 < a:\n print(\"Positive\")\n elif (-a + b + 1) % 2 == 0:\n print(\"Positive\")\n else:\n print(\"Negative\")", "a <= 0 <= b", "a <= 0", "a", "0", "b", "print(\"Zero\")", "print", "\"Zero\"", "if 0 < a:\n print(\"Positive\")\n elif (-a + b + 1) % 2 == 0:\n print(\"Positive\")\n else:\n print(\"Negative\")", "0 < a", "0", "a", "print(\"Positive\")", "print", "\"Positive\"", "elif (-a + b + 1) % 2 == 0:\n print(\"Positive\")\n ", "(-a + b + 1) % 2 == 0", "(-a + b + 1) % 2", "-a + b + 1", "-a + b", "-a", "a", "b", "1", "2", "0", "print(\"Positive\")", "print", "\"Positive\"", "print(\"Negative\")", "print", "\"Negative\"", "if __name__ == '__main__':\n main()", "__name__ == '__main__'", "__name__", "'__main__'", "main()", "main", "readline = sys.stdin.readline", "sys.stdin.readline", "readline", "def main():\n a, b = map(int, readline().split())\n\n if a <= 0 <= b:\n print(\"Zero\")\n else:\n if 0 < a:\n print(\"Positive\")\n elif (-a + b + 1) % 2 == 0:\n print(\"Positive\")\n else:\n print(\"Negative\")", "def main():\n a, b = map(int, readline().split())\n\n if a <= 0 <= b:\n print(\"Zero\")\n else:\n if 0 < a:\n print(\"Positive\")\n elif (-a + b + 1) % 2 == 0:\n print(\"Positive\")\n else:\n print(\"Negative\")", "main", "INF = float('INF')", "float('INF')", "INF", "MOD = 10 ** 9 + 7", "10 ** 9 + 7", "MOD" ]

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

[ [ 5, 4 ], [ 5, 13 ], [ 4, 17 ], [ 13, 20 ], [ 4, 30 ], [ 13, 33 ], [ 4, 36 ], [ 13, 39 ], [ 4, 48 ], [ 13, 49 ], [ 66, 63 ] ]

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

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

[ [ 72, 2 ], [ 72, 11 ], [ 73, 15 ], [ 70, 19 ], [ 63, 21 ], [ 73, 26 ], [ 70, 29 ], [ 75, 32 ], [ 73, 37 ], [ 70, 40 ], [ 70, 46 ], [ 73, 47 ], [ 60, 51 ], [ 66, 54 ], [ 67, 58 ], [ 61, 58 ], [ 76, 58 ], [ 64, 58 ], [ 60, 61 ], [ 63, 64 ], [ 66, 67 ], [ 72, 70 ], [ 72, 73 ], [ 75, 76 ] ]

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

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

[ [ 52, 2 ], [ 52, 11 ], [ 53, 15 ], [ 50, 18 ], [ 53, 26 ], [ 50, 29 ], [ 50, 38 ], [ 53, 39 ], [ 52, 50 ], [ 52, 53 ] ]

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

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

[ [ 5, 4 ], [ 5, 15 ], [ 4, 19 ], [ 15, 22 ], [ 15, 30 ], [ 15, 36 ], [ 4, 37 ], [ 52, 49 ] ]

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

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

[ [ 51, 2 ], [ 51, 11 ], [ 52, 14 ], [ 52, 21 ], [ 49, 28 ], [ 49, 37 ], [ 52, 38 ], [ 51, 49 ], [ 51, 52 ] ]

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