Datasets:

---

codefuse-ai

/

GALLa

like 1

Follow

CodeFuse AI 145

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

[ [ 45, 2 ], [ 46, 15 ], [ 46, 24 ], [ 46, 27 ], [ 46, 32 ], [ 46, 36 ], [ 46, 41 ], [ 45, 46 ] ]

[ "a = list(map(int, input().split()))\na.sort()\n\nprint(int(a[0]*a[1]*(a[2] - a[2]//2 -a[2]//2)))\n\n", "a = list(map(int, input().split()))", "a", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "a.sort()", "a.sort", "a", "sort", "print(int(a[0]*a[1]*(a[2] - a[2]//2 -a[2]//2)))", "print", "int(a[0]*a[1]*(a[2] - a[2]//2 -a[2]//2))", "int", "a[0]*a[1]*(a[2] - a[2]//2 -a[2]//2)", "a[0]*a[1]", "a[0]", "a", "0", "a[1]", "a", "1", "a[2] - a[2]//2 -a[2]//2", "a[2] - a[2]//2", "a[2]", "a", "2", "a[2]//2", "a[2]", "a", "2", "2", "a[2]//2", "a[2]", "a", "2", "2", "a = list(map(int, input().split()))", "list(map(int, input().split()))", "a" ]

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

[ [ 70, 11 ], [ 67, 16 ], [ 26, 25 ], [ 40, 39 ], [ 25, 39 ], [ 39, 44 ], [ 25, 55 ], [ 25, 58 ], [ 74, 65 ], [ 67, 68 ], [ 70, 71 ] ]

[ "import sys\n\nsys.setrecursionlimit(10 ** 7)\nf_inf = float('inf')\nmod = 10 ** 9 + 7\n\n\ndef resolve():\n ABC = sorted(list(map(int, input().split())))\n\n for i in ABC:\n if i % 2 == 0:\n print(0)\n break\n else:\n print(ABC[0] * ABC[1])\n\n\nif __name__ == '__main__':\n resolve()", "import sys", "sys", "sys.setrecursionlimit(10 ** 7)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "10 ** 7", "10", "7", "f_inf = float('inf')", "f_inf", "float('inf')", "float", "'inf'", "mod = 10 ** 9 + 7", "mod", "10 ** 9 + 7", "10 ** 9", "10", "9", "7", "def resolve():\n ABC = sorted(list(map(int, input().split())))\n\n for i in ABC:\n if i % 2 == 0:\n print(0)\n break\n else:\n print(ABC[0] * ABC[1])", "resolve", "ABC = sorted(list(map(int, input().split())))", "ABC", "sorted(list(map(int, input().split())))", "sorted", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "for i in ABC:\n if i % 2 == 0:\n print(0)\n break\n else:\n print(ABC[0] * ABC[1])", "i", "ABC", "if i % 2 == 0:\n print(0)\n break\n ", "i % 2 == 0", "i % 2", "i", "2", "0", "print(0)", "print", "0", "break", "print(ABC[0] * ABC[1])", "print", "ABC[0] * ABC[1]", "ABC[0]", "ABC", "0", "ABC[1]", "ABC", "1", "if __name__ == '__main__':\n resolve()", "__name__ == '__main__'", "__name__", "'__main__'", "resolve()", "resolve", "mod = 10 ** 9 + 7", "10 ** 9 + 7", "mod", "f_inf = float('inf')", "float('inf')", "f_inf", "def resolve():\n ABC = sorted(list(map(int, input().split())))\n\n for i in ABC:\n if i % 2 == 0:\n print(0)\n break\n else:\n print(ABC[0] * ABC[1])", "def resolve():\n ABC = sorted(list(map(int, input().split())))\n\n for i in ABC:\n if i % 2 == 0:\n print(0)\n break\n else:\n print(ABC[0] * ABC[1])", "resolve" ]

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

[ [ 79, 2 ], [ 79, 13 ], [ 79, 14 ], [ 80, 20 ], [ 71, 25 ], [ 74, 30 ], [ 76, 34 ], [ 80, 36 ], [ 71, 37 ], [ 64, 39 ], [ 74, 41 ], [ 67, 44 ], [ 74, 46 ], [ 65, 47 ], [ 82, 49 ], [ 77, 52 ], [ 68, 53 ], [ 77, 55 ], [ 65, 56 ], [ 83, 59 ], [ 64, 65 ], [ 67, 68 ], [ 79, 71 ], [ 79, 74 ], [ 76, 77 ], [ 79, 80 ], [ 82, 83 ] ]

[ "A, B, C = sorted(map(int,input().split()))\n\nif A % 2 != 0 and B % 2 != 0 and C % 2 != 0:\n \n tmp1 = A * B\n tmp2 = C // 2\n tmp3 = C - tmp2\n ans = tmp1 * tmp3 - tmp1 * tmp2\n print(ans)\nelse:\n print(0)", "A, B, C = sorted(map(int,input().split()))", "A", "sorted(map(int,input().split()))", "sorted", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "B", "C", "if A % 2 != 0 and B % 2 != 0 and C % 2 != 0:\n \n tmp1 = A * B\n tmp2 = C // 2\n tmp3 = C - tmp2\n ans = tmp1 * tmp3 - tmp1 * tmp2\n print(ans)\nelse:\n print(0)", "A % 2 != 0 and B % 2 != 0 and C % 2 != 0", "A % 2 != 0 and B % 2 != 0", "A % 2 != 0", "A % 2", "A", "2", "0", "B % 2 != 0", "B % 2", "B", "2", "0", "C % 2 != 0", "C % 2", "C", "2", "0", "tmp1 = A * B", "tmp1", "A * B", "A", "B", "tmp2 = C // 2", "tmp2", "C // 2", "C", "2", "tmp3 = C - tmp2", "tmp3", "C - tmp2", "C", "tmp2", "ans = tmp1 * tmp3 - tmp1 * tmp2", "ans", "tmp1 * tmp3 - tmp1 * tmp2", "tmp1 * tmp3", "tmp1", "tmp3", "tmp1 * tmp2", "tmp1", "tmp2", "print(ans)", "print", "ans", "print(0)", "print", "0", "tmp2 = C // 2", "C // 2", "tmp2", "tmp3 = C - tmp2", "C - tmp2", "tmp3", "B, C = sorted(map(int,input().split()))", "sorted(map(int,input().split()))", "B", "C = sorted(map(int,input().split()))", "sorted(map(int,input().split()))", "C", "tmp1 = A * B", "A * B", "tmp1", "A, B, C = sorted(map(int,input().split()))", "sorted(map(int,input().split()))", "A", "ans = tmp1 * tmp3 - tmp1 * tmp2", "tmp1 * tmp3 - tmp1 * tmp2", "ans" ]

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

[ [ 42, 2 ], [ 45, 14 ], [ 43, 17 ], [ 20, 19 ], [ 46, 25 ], [ 46, 36 ], [ 46, 39 ], [ 42, 43 ], [ 45, 46 ] ]

[ "A = list(map(int, input().split()))\n\nnewlist = sorted(A, reverse=True)\nif newlist[0]%2 == 0:\n print('0')\nelse:\n print(newlist[1]*newlist[2])", "A = list(map(int, input().split()))", "A", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "newlist = sorted(A, reverse=True)", "newlist", "sorted(A, reverse=True)", "sorted", "A", "reverse=True", "reverse", "True", "if newlist[0]%2 == 0:\n print('0')\nelse:\n print(newlist[1]*newlist[2])", "newlist[0]%2 == 0", "newlist[0]%2", "newlist[0]", "newlist", "0", "2", "0", "print('0')", "print", "'0'", "print(newlist[1]*newlist[2])", "print", "newlist[1]*newlist[2]", "newlist[1]", "newlist", "1", "newlist[2]", "newlist", "2", "A = list(map(int, input().split()))", "list(map(int, input().split()))", "A", "newlist = sorted(A, reverse=True)", "sorted(A, reverse=True)", "newlist" ]

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

[ [ 38, 2 ], [ 39, 15 ], [ 39, 32 ], [ 39, 35 ], [ 38, 39 ] ]

[ "ABC = list(map(int, input().split()))\nABC.sort()\nif any(x % 2 == 0 for x in ABC):\n print(0)\nelse:\n print(ABC[0] * ABC[1])", "ABC = list(map(int, input().split()))", "ABC", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "ABC.sort()", "ABC.sort", "ABC", "sort", "if any(x % 2 == 0 for x in ABC):\n print(0)\nelse:\n print(ABC[0] * ABC[1])", "any(x % 2 == 0 for x in ABC)", "any", "x % 2 == 0", "x % 2", "x", "2", "0", "print(0)", "print", "0", "print(ABC[0] * ABC[1])", "print", "ABC[0] * ABC[1]", "ABC[0]", "ABC", "0", "ABC[1]", "ABC", "1", "ABC = list(map(int, input().split()))", "list(map(int, input().split()))", "ABC" ]

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

[ [ 66, 2 ], [ 66, 11 ], [ 66, 12 ], [ 54, 14 ], [ 61, 17 ], [ 64, 18 ], [ 67, 19 ], [ 69, 20 ], [ 55, 25 ], [ 61, 25 ], [ 64, 26 ], [ 67, 27 ], [ 55, 30 ], [ 61, 30 ], [ 64, 31 ], [ 67, 32 ], [ 55, 35 ], [ 61, 35 ], [ 64, 36 ], [ 67, 37 ], [ 57, 38 ], [ 55, 41 ], [ 61, 41 ], [ 70, 42 ], [ 64, 42 ], [ 67, 43 ], [ 55, 48 ], [ 61, 48 ], [ 70, 49 ], [ 64, 49 ], [ 58, 51 ], [ 67, 51 ], [ 54, 55 ], [ 57, 58 ], [ 66, 61 ], [ 66, 64 ], [ 66, 67 ], [ 69, 70 ] ]

[ "a,b,c=map(int,input().split())\na,b,c=min(a,b,c),a+b+c-max(a,b,c)-min(a,b,c),max(a,b,c)\nprint(a*b*(c%2))", "a,b,c=map(int,input().split())", "a", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "c", "a,b,c=min(a,b,c),a+b+c-max(a,b,c)-min(a,b,c),max(a,b,c)", "a", "min(a,b,c)", "min", "a", "b", "c", "b", "a+b+c-max(a,b,c)-min(a,b,c)", "a+b+c-max(a,b,c)", "a+b+c", "a+b", "a", "b", "c", "max(a,b,c)", "max", "a", "b", "c", "min(a,b,c)", "min", "a", "b", "c", "c", "max(a,b,c)", "max", "a", "b", "c", "print(a*b*(c%2))", "print", "a*b*(c%2)", "a*b", "a", "b", "c%2", "c", "2", "a,b,c=min(a,b,c),a+b+c-max(a,b,c)-min(a,b,c),max(a,b,c)", "min(a,b,c)", "a", "c=min(a,b,c),a+b+c-max(a,b,c)-min(a,b,c),max(a,b,c)", "max(a,b,c)", "c", "a,b,c=map(int,input().split())", "map(int,input().split())", "a", "b,c=map(int,input().split())", "map(int,input().split())", "b", "c=map(int,input().split())", "map(int,input().split())", "c", "b,c=min(a,b,c),a+b+c-max(a,b,c)-min(a,b,c),max(a,b,c)", "a+b+c-max(a,b,c)-min(a,b,c)", "b" ]

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

[ [ 34, 2 ], [ 34, 13 ], [ 34, 14 ], [ 29, 20 ], [ 35, 24 ], [ 32, 25 ], [ 34, 29 ], [ 34, 32 ], [ 34, 35 ] ]

[ "A, B, C = sorted(map(int, input().split()))\nprint(A * B if C % 2 == 1 else 0)", "A, B, C = sorted(map(int, input().split()))", "A", "sorted(map(int, input().split()))", "sorted", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "B", "C", "print(A * B if C % 2 == 1 else 0)", "print", "A * B if C % 2 == 1 else 0", "C % 2 == 1", "C % 2", "C", "2", "1", "A * B", "A", "B", "0", "C = sorted(map(int, input().split()))", "sorted(map(int, input().split()))", "C", "B, C = sorted(map(int, input().split()))", "sorted(map(int, input().split()))", "B", "A, B, C = sorted(map(int, input().split()))", "sorted(map(int, input().split()))", "A" ]

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

[ [ 44, 2 ], [ 44, 11 ], [ 44, 12 ], [ 42, 18 ], [ 45, 19 ], [ 39, 21 ], [ 42, 25 ], [ 39, 26 ], [ 45, 28 ], [ 45, 32 ], [ 39, 33 ], [ 42, 35 ], [ 44, 39 ], [ 44, 42 ], [ 44, 45 ] ]

[ "l,h,b = map(int,raw_input().split())\nprint min((l*h)*(b%2),(l*b)*(h%2),(h*b)*(l%2))", "l,h,b = map(int,raw_input().split())", "l", "map(int,raw_input().split())", "map", "int", "raw_input().split()", "().split", "()", "raw_input", "split", "h", "b", "print", "min((l*h)*(b%2),(l*b)*(h%2),(h*b)*(l%2))", "min", "(l*h)*(b%2)", "l*h", "l", "h", "b%2", "b", "2", "(l*b)*(h%2)", "l*b", "l", "b", "h%2", "h", "2", "(h*b)*(l%2)", "h*b", "h", "b", "l%2", "l", "2", "b = map(int,raw_input().split())", "map(int,raw_input().split())", "b", "l,h,b = map(int,raw_input().split())", "map(int,raw_input().split())", "l", "h,b = map(int,raw_input().split())", "map(int,raw_input().split())", "h" ]

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

[ [ 93, 2 ], [ 93, 11 ], [ 93, 12 ], [ 96, 14 ], [ 85, 21 ], [ 91, 23 ], [ 94, 24 ], [ 85, 28 ], [ 85, 30 ], [ 91, 32 ], [ 94, 33 ], [ 99, 35 ], [ 91, 42 ], [ 85, 44 ], [ 94, 45 ], [ 91, 49 ], [ 91, 51 ], [ 85, 53 ], [ 94, 54 ], [ 87, 56 ], [ 94, 63 ], [ 91, 65 ], [ 85, 66 ], [ 94, 70 ], [ 94, 72 ], [ 91, 74 ], [ 85, 75 ], [ 97, 80 ], [ 100, 81 ], [ 88, 82 ], [ 93, 85 ], [ 87, 88 ], [ 93, 91 ], [ 93, 94 ], [ 96, 97 ], [ 99, 100 ] ]

[ "a, b, c = map(int, input().split())\n\nt1 = abs(a//2 * b * c - ((a - a//2) * b * c))\nt2 = abs(b//2 * a * c - ((b - b//2) * a * c))\nt3 = abs(c//2 * b * a - ((c - c//2) * b * a))\nprint(min(t1, t2, t3))", "a, b, c = map(int, input().split())", "a", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "c", "t1 = abs(a//2 * b * c - ((a - a//2) * b * c))", "t1", "abs(a//2 * b * c - ((a - a//2) * b * c))", "abs", "a//2 * b * c - ((a - a//2) * b * c)", "a//2 * b * c", "a//2 * b", "a//2", "a", "2", "b", "c", "(a - a//2) * b * c", "(a - a//2) * b", "a - a//2", "a", "a//2", "a", "2", "b", "c", "t2 = abs(b//2 * a * c - ((b - b//2) * a * c))", "t2", "abs(b//2 * a * c - ((b - b//2) * a * c))", "abs", "b//2 * a * c - ((b - b//2) * a * c)", "b//2 * a * c", "b//2 * a", "b//2", "b", "2", "a", "c", "(b - b//2) * a * c", "(b - b//2) * a", "b - b//2", "b", "b//2", "b", "2", "a", "c", "t3 = abs(c//2 * b * a - ((c - c//2) * b * a))", "t3", "abs(c//2 * b * a - ((c - c//2) * b * a))", "abs", "c//2 * b * a - ((c - c//2) * b * a)", "c//2 * b * a", "c//2 * b", "c//2", "c", "2", "b", "a", "(c - c//2) * b * a", "(c - c//2) * b", "c - c//2", "c", "c//2", "c", "2", "b", "a", "print(min(t1, t2, t3))", "print", "min(t1, t2, t3)", "min", "t1", "t2", "t3", "a, b, c = map(int, input().split())", "map(int, input().split())", "a", "t3 = abs(c//2 * b * a - ((c - c//2) * b * a))", "abs(c//2 * b * a - ((c - c//2) * b * a))", "t3", "b, c = map(int, input().split())", "map(int, input().split())", "b", "c = map(int, input().split())", "map(int, input().split())", "c", "t1 = abs(a//2 * b * c - ((a - a//2) * b * c))", "abs(a//2 * b * c - ((a - a//2) * b * c))", "t1", "t2 = abs(b//2 * a * c - ((b - b//2) * a * c))", "abs(b//2 * a * c - ((b - b//2) * a * c))", "t2" ]

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

[ [ 69, 2 ], [ 69, 11 ], [ 69, 12 ], [ 48, 14 ], [ 70, 17 ], [ 58, 18 ], [ 52, 19 ], [ 49, 22 ], [ 58, 23 ], [ 63, 25 ], [ 58, 26 ], [ 54, 27 ], [ 64, 28 ], [ 70, 28 ], [ 49, 31 ], [ 52, 32 ], [ 66, 34 ], [ 52, 35 ], [ 60, 36 ], [ 67, 37 ], [ 70, 37 ], [ 55, 42 ], [ 58, 42 ], [ 61, 43 ], [ 52, 43 ], [ 67, 45 ], [ 64, 45 ], [ 70, 45 ], [ 48, 49 ], [ 69, 52 ], [ 64, 54 ], [ 70, 54 ], [ 54, 55 ], [ 69, 58 ], [ 67, 60 ], [ 70, 60 ], [ 60, 61 ], [ 58, 63 ], [ 63, 64 ], [ 52, 66 ], [ 66, 67 ], [ 69, 70 ] ]

[ "A, B, C = map(int, input().split())\nmx = max(A, B, C)\n\nif mx == B:\n A, B = B, A\nelif mx == C:\n A, C = C, A\n\nprint(B*C*(A % 2))", "A, B, C = map(int, input().split())", "A", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "B", "C", "mx = max(A, B, C)", "mx", "max(A, B, C)", "max", "A", "B", "C", "if mx == B:\n A, B = B, A\nelif mx == C:\n A, C = C, A", "mx == B", "mx", "B", "A, B = B, A", "A", "B", "B", "A", "elif mx == C:\n A, C = C, A", "mx == C", "mx", "C", "A, C = C, A", "A", "C", "C", "A", "print(B*C*(A % 2))", "print", "B*C*(A % 2)", "B*C", "B", "C", "A % 2", "A", "2", "mx = max(A, B, C)", "max(A, B, C)", "mx", "C = map(int, input().split())", "map(int, input().split())", "C", "B = B, A", "A", "B", "B, C = map(int, input().split())", "map(int, input().split())", "B", "C = C, A", "A", "C", "A, B = B, A", "B", "A", "A, C = C, A", "C", "A", "A, B, C = map(int, input().split())", "map(int, input().split())", "A" ]

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

[ [ 72, 2 ], [ 72, 11 ], [ 72, 12 ], [ 57, 14 ], [ 73, 17 ], [ 64, 18 ], [ 70, 19 ], [ 60, 21 ], [ 73, 24 ], [ 64, 25 ], [ 70, 26 ], [ 66, 28 ], [ 73, 32 ], [ 64, 33 ], [ 70, 34 ], [ 58, 36 ], [ 61, 37 ], [ 58, 43 ], [ 67, 44 ], [ 61, 45 ], [ 58, 54 ], [ 67, 55 ], [ 57, 58 ], [ 60, 61 ], [ 72, 64 ], [ 66, 67 ], [ 72, 70 ], [ 72, 73 ] ]

[ "A,B,C=map(int,input().split())\nX=min(A,B,C)\nZ=max(A,B,C)\nY=A+B+C-(X+Z)\n\nif (X*Y*Z)%2==0:\n print(0)\nelse:\n print(X*Y)", "A,B,C=map(int,input().split())", "A", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "B", "C", "X=min(A,B,C)", "X", "min(A,B,C)", "min", "A", "B", "C", "Z=max(A,B,C)", "Z", "max(A,B,C)", "max", "A", "B", "C", "Y=A+B+C-(X+Z)", "Y", "A+B+C-(X+Z)", "A+B+C", "A+B", "A", "B", "C", "X+Z", "X", "Z", "if (X*Y*Z)%2==0:\n print(0)\nelse:\n print(X*Y)", "(X*Y*Z)%2==0", "(X*Y*Z)%2", "X*Y*Z", "X*Y", "X", "Y", "Z", "2", "0", "print(0)", "print", "0", "print(X*Y)", "print", "X*Y", "X", "Y", "X=min(A,B,C)", "min(A,B,C)", "X", "Z=max(A,B,C)", "max(A,B,C)", "Z", "B,C=map(int,input().split())", "map(int,input().split())", "B", "Y=A+B+C-(X+Z)", "A+B+C-(X+Z)", "Y", "C=map(int,input().split())", "map(int,input().split())", "C", "A,B,C=map(int,input().split())", "map(int,input().split())", "A" ]

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

[ [ 49, 2 ], [ 49, 11 ], [ 49, 12 ], [ 15, 14 ], [ 14, 22 ], [ 50, 34 ], [ 44, 35 ], [ 44, 37 ], [ 47, 38 ], [ 47, 40 ], [ 50, 41 ], [ 49, 44 ], [ 49, 47 ], [ 49, 50 ] ]

[ "A, B, C = map(int, input().split())\n\nfor num in [A, B, C]:\n if num % 2 == 0:\n print(0)\n break\nelse:\n print(min(A * B, B * C, C * A))", "A, B, C = map(int, input().split())", "A", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "B", "C", "for num in [A, B, C]:\n if num % 2 == 0:\n print(0)\n break\nelse:\n print(min(A * B, B * C, C * A))", "num", "[A, B, C]", "A", "B", "C", "if num % 2 == 0:\n print(0)\n break", "num % 2 == 0", "num % 2", "num", "2", "0", "print(0)", "print", "0", "break", "print(min(A * B, B * C, C * A))", "print", "min(A * B, B * C, C * A)", "min", "A * B", "A", "B", "B * C", "B", "C", "C * A", "C", "A", "B, C = map(int, input().split())", "map(int, input().split())", "B", "C = map(int, input().split())", "map(int, input().split())", "C", "A, B, C = map(int, input().split())", "map(int, input().split())", "A" ]

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

[ [ 64, 2 ], [ 64, 11 ], [ 64, 12 ], [ 62, 18 ], [ 65, 23 ], [ 59, 28 ], [ 62, 39 ], [ 65, 40 ], [ 59, 41 ], [ 62, 49 ], [ 65, 50 ], [ 65, 52 ], [ 59, 53 ], [ 59, 55 ], [ 62, 56 ], [ 64, 59 ], [ 64, 62 ], [ 64, 65 ] ]

[ "a, b, c = map(int, input().split())\nif a % 2 == 0 or b % 2 == 0 or c % 2 == 0:\n print(0)\nelif (a and b and c) % 2 != 0 :\n print(min(a * b, b * c, c * a))", "a, b, c = map(int, input().split())", "a", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "c", "if a % 2 == 0 or b % 2 == 0 or c % 2 == 0:\n print(0)\nelif (a and b and c) % 2 != 0 :\n print(min(a * b, b * c, c * a))", "a % 2 == 0 or b % 2 == 0 or c % 2 == 0", "a % 2 == 0 or b % 2 == 0", "a % 2 == 0", "a % 2", "a", "2", "0", "b % 2 == 0", "b % 2", "b", "2", "0", "c % 2 == 0", "c % 2", "c", "2", "0", "print(0)", "print", "0", "elif (a and b and c) % 2 != 0 :\n print(min(a * b, b * c, c * a))", "(a and b and c) % 2 != 0", "(a and b and c) % 2", "a and b and c", "a and b", "a", "b", "c", "2", "0", "print(min(a * b, b * c, c * a))", "print", "min(a * b, b * c, c * a)", "min", "a * b", "a", "b", "b * c", "b", "c", "c * a", "c", "a", "c = map(int, input().split())", "map(int, input().split())", "c", "a, b, c = map(int, input().split())", "map(int, input().split())", "a", "b, c = map(int, input().split())", "map(int, input().split())", "b" ]

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

[ [ 4, 3 ], [ 3, 12 ], [ 39, 14 ], [ 40, 18 ], [ 40, 26 ], [ 40, 32 ], [ 40, 35 ], [ 39, 40 ] ]

[ "# AGC 004: A – Divide a Cuboid\nn = [int(s) for s in input().split()]\nn.sort()\n\nprint(n[0] * n[1] if n[2] % 2 == 1 else 0)", "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", "n = [int(s) for s in input().split()]", "n", "[int(s) for s in input().split()]", "n.sort()", "n.sort", "n", "sort", "print(n[0] * n[1] if n[2] % 2 == 1 else 0)", "print", "n[0] * n[1] if n[2] % 2 == 1 else 0", "n[2] % 2 == 1", "n[2] % 2", "n[2]", "n", "2", "2", "1", "n[0] * n[1]", "n[0]", "n", "0", "n[1]", "n", "1", "0", "n = [int(s) for s in input().split()]", "[int(s) for s in input().split()]", "n" ]

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

[ [ 50, 2 ], [ 50, 11 ], [ 50, 12 ], [ 56, 14 ], [ 48, 21 ], [ 51, 22 ], [ 45, 23 ], [ 53, 27 ], [ 48, 32 ], [ 51, 33 ], [ 51, 35 ], [ 45, 36 ], [ 45, 38 ], [ 48, 39 ], [ 54, 42 ], [ 57, 42 ], [ 50, 45 ], [ 50, 48 ], [ 50, 51 ], [ 53, 54 ], [ 56, 57 ] ]

[ "a,b,c = map(int,input().split())\nres = 0\nif a*b*c%2!=0:\n res = min([a*b,b*c,c*a])\nprint(res)", "a,b,c = map(int,input().split())", "a", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "c", "res = 0", "res", "0", "if a*b*c%2!=0:\n res = min([a*b,b*c,c*a])", "a*b*c%2!=0", "a*b*c%2", "a*b*c", "a*b", "a", "b", "c", "2", "0", "res = min([a*b,b*c,c*a])", "res", "min([a*b,b*c,c*a])", "min", "[a*b,b*c,c*a]", "a*b", "a", "b", "b*c", "b", "c", "c*a", "c", "a", "print(res)", "print", "res", "c = map(int,input().split())", "map(int,input().split())", "c", "a,b,c = map(int,input().split())", "map(int,input().split())", "a", "b,c = map(int,input().split())", "map(int,input().split())", "b", "res = min([a*b,b*c,c*a])", "min([a*b,b*c,c*a])", "res", "res = 0", "0", "res" ]

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

[ [ 62, 2 ], [ 62, 11 ], [ 62, 12 ], [ 65, 14 ], [ 60, 21 ], [ 57, 26 ], [ 63, 31 ], [ 71, 35 ], [ 60, 39 ], [ 57, 40 ], [ 60, 44 ], [ 63, 45 ], [ 57, 47 ], [ 63, 48 ], [ 68, 50 ], [ 69, 54 ], [ 72, 54 ], [ 66, 54 ], [ 62, 57 ], [ 62, 60 ], [ 62, 63 ], [ 65, 66 ], [ 68, 69 ], [ 71, 72 ] ]

[ "A, B, C = map(int, input().split())\n\nans = 0\nif A % 2 == 1 and B % 2 == 1 and C % 2 == 1:\n ans = min(A * B, min(A * C, B * C))\nelse:\n ans = 0\n\nprint(ans)", "A, B, C = map(int, input().split())", "A", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "B", "C", "ans = 0", "ans", "0", "if A % 2 == 1 and B % 2 == 1 and C % 2 == 1:\n ans = min(A * B, min(A * C, B * C))\nelse:\n ans = 0", "A % 2 == 1 and B % 2 == 1 and C % 2 == 1", "A % 2 == 1 and B % 2 == 1", "A % 2 == 1", "A % 2", "A", "2", "1", "B % 2 == 1", "B % 2", "B", "2", "1", "C % 2 == 1", "C % 2", "C", "2", "1", "ans = min(A * B, min(A * C, B * C))", "ans", "min(A * B, min(A * C, B * C))", "min", "A * B", "A", "B", "min(A * C, B * C)", "min", "A * C", "A", "C", "B * C", "B", "C", "ans = 0", "ans", "0", "print(ans)", "print", "ans", "B, C = map(int, input().split())", "map(int, input().split())", "B", "A, B, C = map(int, input().split())", "map(int, input().split())", "A", "C = map(int, input().split())", "map(int, input().split())", "C", "ans = 0", "0", "ans", "ans = 0", "0", "ans", "ans = min(A * B, min(A * C, B * C))", "min(A * B, min(A * C, B * C))", "ans" ]

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

[ [ 168, 18 ], [ 153, 57 ], [ 159, 80 ], [ 166, 82 ], [ 159, 83 ], [ 159, 84 ], [ 160, 95 ], [ 151, 97 ], [ 157, 98 ], [ 160, 102 ], [ 160, 104 ], [ 151, 106 ], [ 157, 107 ], [ 160, 113 ], [ 151, 115 ], [ 151, 117 ], [ 157, 119 ], [ 160, 122 ], [ 151, 124 ], [ 157, 126 ], [ 160, 132 ], [ 151, 133 ], [ 157, 135 ], [ 157, 137 ], [ 160, 141 ], [ 151, 142 ], [ 157, 144 ], [ 159, 151 ], [ 153, 154 ], [ 159, 157 ], [ 159, 160 ], [ 168, 169 ] ]

[ "#from statistics import median\n#import collections\n#aa = collections.Counter(a) # list to list || .most_common(2)で最大の2個とりだせるお a[0][0]\nfrom fractions import gcd\nfrom itertools import combinations,permutations,accumulate, product # (string,3) 3回\n#from collections import deque\nfrom collections import deque,defaultdict,Counter\nimport decimal\nimport re\nimport math\n#import bisect\n#\n# d = m - k[i] - k[j]\n# if kk[bisect.bisect_right(kk,d) - 1] == d:\n#\n#\n#\n# pythonで無理なときは、pypyでやると正解するかも！！\n#\n#\n# my_round_int = lambda x:np.round((x*2 + 1)//2)\n# 四捨五入g\nimport sys\nsys.setrecursionlimit(10000000)\n#mod = 10**9 + 7\n#mod = 9982443453\nmod = 998244353\ndef readInts():\n return list(map(int,input().split()))\ndef I():\n return int(input())\n#from statistics import median\n#import collections\n#aa = collections.Counter(a) # list to list || .most_common(2)で最大の2個とりだせるお a[0][0]\nfrom fractions import gcd\nfrom itertools import combinations,permutations,accumulate, product # (string,3) 3回\n#from collections import deque\nfrom collections import deque,defaultdict,Counter\nimport decimal\nimport re\nimport math\n#import bisect\n#\n# d = m - k[i] - k[j]\n# if kk[bisect.bisect_right(kk,d) - 1] == d:\n#\n#\n#\n# pythonで無理なときは、pypyでやると正解するかも！！\n#\n#\n# my_round_int = lambda x:np.round((x*2 + 1)//2)\n# 四捨五入g\nimport sys\nsys.setrecursionlimit(10000000)\n#mod = 10**9 + 7\n#mod = 9982443453\nmod = 998244353\ndef readInts():\n return list(map(int,input().split()))\ndef I():\n return int(input())\na,b,c = readInts()\nprint(min(abs((a//2) * b * c - (a-a//2) * b * c), abs(a * (b-b//2) * c - a* (b//2) * c), abs(a*b*(c-c//2) - a*b*(c//2))))", "from fractions import gcd", "from itertools import combinations,permutations,accumulate, product", "from collections import deque,defaultdict,Counter", "import decimal", "decimal", "import re", "re", "import math", "math", "import sys", "sys", "sys.setrecursionlimit(10000000)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "10000000", "mod = 998244353", "mod", "998244353", "def readInts():\n return list(map(int,input().split()))", "readInts", "return list(map(int,input().split()))", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "def I():\n return int(input())\n#from statistics import median\n#import collections\n#aa = collections.Counter(a) # list to list || .most_common(2)で最大の2個とりだせるお a[0][0]", "I", "return int(input())", "int(input())", "int", "input()", "input", "from fractions import gcd", "from itertools import combinations,permutations,accumulate, product", "from collections import deque,defaultdict,Counter", "import decimal", "decimal", "import re", "re", "import math", "math", "import sys", "sys", "sys.setrecursionlimit(10000000)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "10000000", "mod = 998244353", "mod", "998244353", "def readInts():\n return list(map(int,input().split()))", "readInts", "return list(map(int,input().split()))", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "def I():\n return int(input())", "I", "return int(input())", "int(input())", "int", "input()", "input", "a,b,c = readInts()", "a", "readInts()", "readInts", "b", "c", "print(min(abs((a//2) * b * c - (a-a//2) * b * c), abs(a * (b-b//2) * c - a* (b//2) * c), abs(a*b*(c-c//2) - a*b*(c//2))))", "print", "min(abs((a//2) * b * c - (a-a//2) * b * c), abs(a * (b-b//2) * c - a* (b//2) * c), abs(a*b*(c-c//2) - a*b*(c//2)))", "min", "abs((a//2) * b * c - (a-a//2) * b * c)", "abs", "(a//2) * b * c - (a-a//2) * b * c", "(a//2) * b * c", "(a//2) * b", "a//2", "a", "2", "b", "c", "(a-a//2) * b * c", "(a-a//2) * b", "a-a//2", "a", "a//2", "a", "2", "b", "c", "abs(a * (b-b//2) * c - a* (b//2) * c)", "abs", "a * (b-b//2) * c - a* (b//2) * c", "a * (b-b//2) * c", "a * (b-b//2)", "a", "b-b//2", "b", "b//2", "b", "2", "c", "a* (b//2) * c", "a* (b//2)", "a", "b//2", "b", "2", "c", "abs(a*b*(c-c//2) - a*b*(c//2))", "abs", "a*b*(c-c//2) - a*b*(c//2)", "a*b*(c-c//2)", "a*b", "a", "b", "c-c//2", "c", "c//2", "c", "2", "a*b*(c//2)", "a*b", "a", "b", "c//2", "c", "2", "def I():\n return int(input())\n#from statistics import median\n#import collections\n#aa = collections.Counter(a) # list to list || .most_common(2)で最大の2個とりだせるお a[0][0]", "def I():\n return int(input())\n#from statistics import median\n#import collections\n#aa = collections.Counter(a) # list to list || .most_common(2)で最大の2個とりだせるお a[0][0]", "I", "b,c = readInts()", "readInts()", "b", "mod = 998244353", "998244353", "mod", "c = readInts()", "readInts()", "c", "a,b,c = readInts()", "readInts()", "a", "def readInts():\n return list(map(int,input().split()))", "def readInts():\n return list(map(int,input().split()))", "readInts", "def readInts():\n return list(map(int,input().split()))", "def readInts():\n return list(map(int,input().split()))", "readInts", "mod = 998244353", "998244353", "mod", "def I():\n return int(input())", "def I():\n return int(input())", "I" ]

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

[ [ 60, 2 ], [ 60, 11 ], [ 60, 12 ], [ 52, 18 ], [ 61, 23 ], [ 55, 28 ], [ 57, 35 ], [ 52, 39 ], [ 61, 40 ], [ 61, 42 ], [ 55, 43 ], [ 55, 45 ], [ 52, 46 ], [ 58, 49 ], [ 60, 52 ], [ 60, 55 ], [ 57, 58 ], [ 60, 61 ] ]

[ "A,B,C = map(int,input().split())\nif A%2==0 or B%2==0 or C%2==0:\n print(0)\nelse:\n cmin = min(A*B,B*C,C*A)\n print(cmin)", "A,B,C = map(int,input().split())", "A", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "B", "C", "if A%2==0 or B%2==0 or C%2==0:\n print(0)\nelse:\n cmin = min(A*B,B*C,C*A)\n print(cmin)", "A%2==0 or B%2==0 or C%2==0", "A%2==0 or B%2==0", "A%2==0", "A%2", "A", "2", "0", "B%2==0", "B%2", "B", "2", "0", "C%2==0", "C%2", "C", "2", "0", "print(0)", "print", "0", "cmin = min(A*B,B*C,C*A)", "cmin", "min(A*B,B*C,C*A)", "min", "A*B", "A", "B", "B*C", "B", "C", "C*A", "C", "A", "print(cmin)", "print", "cmin", "A,B,C = map(int,input().split())", "map(int,input().split())", "A", "C = map(int,input().split())", "map(int,input().split())", "C", "cmin = min(A*B,B*C,C*A)", "min(A*B,B*C,C*A)", "cmin", "B,C = map(int,input().split())", "map(int,input().split())", "B" ]

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

[ [ 4, 3 ], [ 3, 12 ], [ 48, 14 ], [ 33, 24 ], [ 49, 25 ], [ 49, 28 ], [ 49, 32 ], [ 49, 39 ], [ 49, 42 ], [ 49, 45 ], [ 48, 49 ] ]

[ "s = [int(s) for s in input().split()]\n\nif any([n % 2 == 0 for n in s]):\n print(0)\nelse:\n s[s.index(max(s))] = 1\n print(s[0] * s[1] * s[2])", "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", "s = [int(s) for s in input().split()]", "s", "[int(s) for s in input().split()]", "if any([n % 2 == 0 for n in s]):\n print(0)\nelse:\n s[s.index(max(s))] = 1\n print(s[0] * s[1] * s[2])", "any([n % 2 == 0 for n in s])", "any", "[n % 2 == 0 for n in s]", "print(0)", "print", "0", "s[s.index(max(s))] = 1", "s[s.index(max(s))]", "s", "s.index(max(s))", "s.index", "s", "index", "max(s)", "max", "s", "1", "print(s[0] * s[1] * s[2])", "print", "s[0] * s[1] * s[2]", "s[0] * s[1]", "s[0]", "s", "0", "s[1]", "s", "1", "s[2]", "s", "2", "s = [int(s) for s in input().split()]", "[int(s) for s in input().split()]", "s" ]

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

[ [ 36, 2 ], [ 36, 13 ], [ 36, 14 ], [ 37, 21 ], [ 34, 22 ], [ 31, 23 ], [ 37, 26 ], [ 34, 27 ], [ 36, 31 ], [ 36, 34 ], [ 36, 37 ] ]

[ "A,B,C=sorted(map(int,input().split()))\nprint(A*B if A*B*C%2 else 0)", "A,B,C=sorted(map(int,input().split()))", "A", "sorted(map(int,input().split()))", "sorted", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "B", "C", "print(A*B if A*B*C%2 else 0)", "print", "A*B if A*B*C%2 else 0", "A*B*C%2", "A*B*C", "A*B", "A", "B", "C", "2", "A*B", "A", "B", "0", "C=sorted(map(int,input().split()))", "sorted(map(int,input().split()))", "C", "B,C=sorted(map(int,input().split()))", "sorted(map(int,input().split()))", "B", "A,B,C=sorted(map(int,input().split()))", "sorted(map(int,input().split()))", "A" ]

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

[ [ 79, 2 ], [ 76, 14 ], [ 80, 17 ], [ 20, 19 ], [ 82, 22 ], [ 77, 24 ], [ 64, 27 ], [ 77, 29 ], [ 67, 32 ], [ 77, 34 ], [ 70, 37 ], [ 83, 41 ], [ 65, 43 ], [ 68, 44 ], [ 73, 46 ], [ 83, 50 ], [ 83, 52 ], [ 65, 54 ], [ 68, 55 ], [ 71, 61 ], [ 74, 62 ], [ 64, 65 ], [ 67, 68 ], [ 70, 71 ], [ 73, 74 ], [ 76, 77 ], [ 79, 80 ], [ 82, 83 ] ]

[ "cubic = list(map(int, input().split()))\nsort_cubic = sorted(cubic, reverse=True)\na = sort_cubic[0]\nb = sort_cubic[1]\nc = sort_cubic[2]\nred = (a // 2 ) * b * c\nblue = (a - a//2) * b * c\nprint(abs(red - blue))", "cubic = list(map(int, input().split()))", "cubic", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "sort_cubic = sorted(cubic, reverse=True)", "sort_cubic", "sorted(cubic, reverse=True)", "sorted", "cubic", "reverse=True", "reverse", "True", "a = sort_cubic[0]", "a", "sort_cubic[0]", "sort_cubic", "0", "b = sort_cubic[1]", "b", "sort_cubic[1]", "sort_cubic", "1", "c = sort_cubic[2]", "c", "sort_cubic[2]", "sort_cubic", "2", "red = (a // 2 ) * b * c", "red", "(a // 2 ) * b * c", "(a // 2 ) * b", "a // 2", "a", "2", "b", "c", "blue = (a - a//2) * b * c", "blue", "(a - a//2) * b * c", "(a - a//2) * b", "a - a//2", "a", "a//2", "a", "2", "b", "c", "print(abs(red - blue))", "print", "abs(red - blue)", "abs", "red - blue", "red", "blue", "b = sort_cubic[1]", "sort_cubic[1]", "b", "c = sort_cubic[2]", "sort_cubic[2]", "c", "red = (a // 2 ) * b * c", "(a // 2 ) * b * c", "red", "blue = (a - a//2) * b * c", "(a - a//2) * b * c", "blue", "sort_cubic = sorted(cubic, reverse=True)", "sorted(cubic, reverse=True)", "sort_cubic", "cubic = list(map(int, input().split()))", "list(map(int, input().split()))", "cubic", "a = sort_cubic[0]", "sort_cubic[0]", "a" ]

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

[ [ 52, 2 ], [ 53, 21 ], [ 53, 28 ], [ 53, 35 ], [ 53, 46 ], [ 53, 49 ], [ 52, 53 ] ]

[ "L = list(sorted(map(int, input().split())))\nif L[0] % 2 == 0 or L[1] % 2 == 0 or L[2] % 2 == 0:\n print(0)\nelse:\n print(L[0] * L[1])", "L = list(sorted(map(int, input().split())))", "L", "list(sorted(map(int, input().split())))", "list", "sorted(map(int, input().split()))", "sorted", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "if L[0] % 2 == 0 or L[1] % 2 == 0 or L[2] % 2 == 0:\n print(0)\nelse:\n print(L[0] * L[1])", "L[0] % 2 == 0 or L[1] % 2 == 0 or L[2] % 2 == 0", "L[0] % 2 == 0 or L[1] % 2 == 0", "L[0] % 2 == 0", "L[0] % 2", "L[0]", "L", "0", "2", "0", "L[1] % 2 == 0", "L[1] % 2", "L[1]", "L", "1", "2", "0", "L[2] % 2 == 0", "L[2] % 2", "L[2]", "L", "2", "2", "0", "print(0)", "print", "0", "print(L[0] * L[1])", "print", "L[0] * L[1]", "L[0]", "L", "0", "L[1]", "L", "1", "L = list(sorted(map(int, input().split())))", "list(sorted(map(int, input().split())))", "L" ]

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

[ [ 4, 3 ], [ 3, 12 ], [ 52, 14 ], [ 49, 17 ], [ 43, 24 ], [ 53, 28 ], [ 46, 31 ], [ 53, 34 ], [ 53, 37 ], [ 47, 41 ], [ 44, 41 ], [ 50, 41 ], [ 43, 44 ], [ 46, 47 ], [ 49, 50 ], [ 52, 53 ] ]

[ "n = [int(w) for w in input().split()]\n\nans = 0\nif any([w % 2 == 0 for w in n]):\n ans = 0\nelse:\n n.sort()\n ans = (n[0]*n[1])\n\n\nprint(ans)", "int(w) for w in input().split()", "for w in input().split()", "w", "input().split()", "().split", "()", "input", "split", "for w in input().split()", "int(w)", "int", "w", "n = [int(w) for w in input().split()]", "n", "[int(w) for w in input().split()]", "ans = 0", "ans", "0", "if any([w % 2 == 0 for w in n]):\n ans = 0\nelse:\n n.sort()\n ans = (n[0]*n[1])", "any([w % 2 == 0 for w in n])", "any", "[w % 2 == 0 for w in n]", "ans = 0", "ans", "0", "n.sort()", "n.sort", "n", "sort", "ans = (n[0]*n[1])", "ans", "n[0]*n[1]", "n[0]", "n", "0", "n[1]", "n", "1", "print(ans)", "print", "ans", "ans = 0", "0", "ans", "ans = (n[0]*n[1])", "n[0]*n[1]", "ans", "ans = 0", "0", "ans", "n = [int(w) for w in input().split()]", "[int(w) for w in input().split()]", "n" ]

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

[ [ 48, 2 ], [ 49, 21 ], [ 49, 26 ], [ 49, 31 ], [ 49, 39 ], [ 49, 42 ], [ 48, 49 ] ]

[ "a = sorted(list(map(int,input().split())))\nif a[0]%2 == a[1]%2 == a[2]%2 == 1:\n print(a[0]*a[1])\nelse:\n print(0)", "a = sorted(list(map(int,input().split())))", "a", "sorted(list(map(int,input().split())))", "sorted", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "if a[0]%2 == a[1]%2 == a[2]%2 == 1:\n print(a[0]*a[1])\nelse:\n print(0)", "a[0]%2 == a[1]%2 == a[2]%2 == 1", "a[0]%2 == a[1]%2 == a[2]%2", "a[0]%2 == a[1]%2", "a[0]%2", "a[0]", "a", "0", "2", "a[1]%2", "a[1]", "a", "1", "2", "a[2]%2", "a[2]", "a", "2", "2", "1", "print(a[0]*a[1])", "print", "a[0]*a[1]", "a[0]", "a", "0", "a[1]", "a", "1", "print(0)", "print", "0", "a = sorted(list(map(int,input().split())))", "sorted(list(map(int,input().split())))", "a" ]

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

[ [ 106, 6 ], [ 112, 15 ], [ 115, 24 ], [ 109, 33 ], [ 124, 47 ], [ 116, 54 ], [ 124, 56 ], [ 124, 57 ], [ 101, 63 ], [ 125, 68 ], [ 122, 73 ], [ 103, 80 ], [ 118, 86 ], [ 104, 89 ], [ 119, 94 ], [ 104, 94 ], [ 119, 97 ], [ 104, 97 ], [ 124, 101 ], [ 103, 104 ], [ 106, 107 ], [ 109, 110 ], [ 112, 113 ], [ 115, 116 ], [ 118, 119 ], [ 124, 122 ], [ 124, 125 ] ]

[ "#! /usr/bin/env python3\n\nimport sys\nimport numpy as np\nint1 = lambda x: int(x) - 1\nread = sys.stdin.buffer.read\nreadline = sys.stdin.buffer.readline\nreadlines = sys.stdin.buffer.readlines\nsys.setrecursionlimit(500000)\n\nA, B, C = map(int, readline().split())\n\nif (A % 2 == 0) or (B % 2 == 0) or (C % 2 == 0):\n print(0)\nelse:\n tmp = [A, B, C]\n tmp = sorted(tmp)\n print(tmp[0] * tmp[1])", "import sys", "sys", "import numpy as np", "numpy", "int1 = lambda x: int(x) - 1", "int1", "lambda x: int(x) - 1", "int(x) - 1", "int(x)", "int", "x", "1", "x", "read = sys.stdin.buffer.read", "read", "sys.stdin.buffer.read", "sys.stdin.buffer", "sys.stdin", "sys", "stdin", "buffer", "read", "readline = sys.stdin.buffer.readline", "readline", "sys.stdin.buffer.readline", "sys.stdin.buffer", "sys.stdin", "sys", "stdin", "buffer", "readline", "readlines = sys.stdin.buffer.readlines", "readlines", "sys.stdin.buffer.readlines", "sys.stdin.buffer", "sys.stdin", "sys", "stdin", "buffer", "readlines", "sys.setrecursionlimit(500000)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "500000", "A, B, C = map(int, readline().split())", "A", "map(int, readline().split())", "map", "int", "readline().split()", "().split", "()", "readline", "split", "B", "C", "if (A % 2 == 0) or (B % 2 == 0) or (C % 2 == 0):\n print(0)\nelse:\n tmp = [A, B, C]\n tmp = sorted(tmp)\n print(tmp[0] * tmp[1])", "(A % 2 == 0) or (B % 2 == 0) or (C % 2 == 0)", "(A % 2 == 0) or (B % 2 == 0)", "A % 2 == 0", "A % 2", "A", "2", "0", "B % 2 == 0", "B % 2", "B", "2", "0", "C % 2 == 0", "C % 2", "C", "2", "0", "print(0)", "print", "0", "tmp = [A, B, C]", "tmp", "[A, B, C]", "A", "B", "C", "tmp = sorted(tmp)", "tmp", "sorted(tmp)", "sorted", "tmp", "print(tmp[0] * tmp[1])", "print", "tmp[0] * tmp[1]", "tmp[0]", "tmp", "0", "tmp[1]", "tmp", "1", "A, B, C = map(int, readline().split())", "map(int, readline().split())", "A", "tmp = [A, B, C]", "[A, B, C]", "tmp", "int1 = lambda x: int(x) - 1", "lambda x: int(x) - 1", "int1", "readlines = sys.stdin.buffer.readlines", "sys.stdin.buffer.readlines", "readlines", "read = sys.stdin.buffer.read", "sys.stdin.buffer.read", "read", "readline = sys.stdin.buffer.readline", "sys.stdin.buffer.readline", "readline", "tmp = sorted(tmp)", "sorted(tmp)", "tmp", "C = map(int, readline().split())", "map(int, readline().split())", "C", "B, C = map(int, readline().split())", "map(int, readline().split())", "B" ]

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

[ [ 9, 8 ], [ 9, 17 ], [ 9, 18 ], [ 21, 20 ], [ 45, 44 ], [ 20, 51 ], [ 44, 58 ], [ 63, 58 ], [ 61, 60 ], [ 64, 63 ], [ 20, 72 ], [ 60, 73 ], [ 20, 84 ], [ 60, 85 ], [ 95, 92 ] ]

[ "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n#\n# FileName: \tA\n# CreatedDate: 2020-09-27 00:18:14 +0900\n# LastModified: 2020-09-27 00:27:44 +0900\n#\n\n\nimport os\nimport sys\n# import numpy as np\n# import pandas as pd\n\n\ndef main():\n A, B, C = map(int, input().split())\n abc = {\n \"AB\": [A*B, C],\n \"AC\": [A*C, B],\n \"BC\": [B*C, A]\n }\n max_value = 1e18\n for key, value in abc.items():\n if value[0] < max_value:\n important_key = key\n max_value = value[0]\n if abc[important_key][1] % 2 == 0:\n print(0)\n else:\n print(abc[important_key][0])\n\n\nif __name__ == \"__main__\":\n main()", "import os", "os", "import sys", "sys", "def main():\n A, B, C = map(int, input().split())\n abc = {\n \"AB\": [A*B, C],\n \"AC\": [A*C, B],\n \"BC\": [B*C, A]\n }\n max_value = 1e18\n for key, value in abc.items():\n if value[0] < max_value:\n important_key = key\n max_value = value[0]\n if abc[important_key][1] % 2 == 0:\n print(0)\n else:\n print(abc[important_key][0])", "main", "A, B, C = map(int, input().split())", "A", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "B", "C", "abc = {\n \"AB\": [A*B, C],\n \"AC\": [A*C, B],\n \"BC\": [B*C, A]\n }", "abc", "{\n \"AB\": [A*B, C],\n \"AC\": [A*C, B],\n \"BC\": [B*C, A]\n }", "\"AB\"", "\"AB\"", "[A*B, C]", "A*B", "A", "B", "C", "\"AC\"", "\"AC\"", "[A*C, B]", "A*C", "A", "C", "B", "\"BC\"", "\"BC\"", "[B*C, A]", "B*C", "B", "C", "A", "max_value = 1e18", "max_value", "1e18", "for key, value in abc.items():\n if value[0] < max_value:\n important_key = key\n max_value = value[0]\n ", "key", "value", "abc.items()", "abc.items", "abc", "items", "if value[0] < max_value:\n important_key = key\n max_value = value[0]\n ", "value[0] < max_value", "value[0]", "value", "0", "max_value", "important_key = key", "important_key", "key", "max_value = value[0]", "max_value", "value[0]", "value", "0", "if abc[important_key][1] % 2 == 0:\n print(0)\n else:\n print(abc[important_key][0])", "abc[important_key][1] % 2 == 0", "abc[important_key][1] % 2", "abc[important_key][1]", "[important_key]", "abc", "important_key", "1", "2", "0", "print(0)", "print", "0", "print(abc[important_key][0])", "print", "abc[important_key][0]", "[important_key]", "abc", "important_key", "0", "if __name__ == \"__main__\":\n main()", "__name__ == \"__main__\"", "__name__", "\"__main__\"", "main()", "main", "def main():\n A, B, C = map(int, input().split())\n abc = {\n \"AB\": [A*B, C],\n \"AC\": [A*C, B],\n \"BC\": [B*C, A]\n }\n max_value = 1e18\n for key, value in abc.items():\n if value[0] < max_value:\n important_key = key\n max_value = value[0]\n if abc[important_key][1] % 2 == 0:\n print(0)\n else:\n print(abc[important_key][0])", "def main():\n A, B, C = map(int, input().split())\n abc = {\n \"AB\": [A*B, C],\n \"AC\": [A*C, B],\n \"BC\": [B*C, A]\n }\n max_value = 1e18\n for key, value in abc.items():\n if value[0] < max_value:\n important_key = key\n max_value = value[0]\n if abc[important_key][1] % 2 == 0:\n print(0)\n else:\n print(abc[important_key][0])", "main" ]

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

[ [ 26, 25 ], [ 109, 31 ], [ 35, 35 ], [ 96, 44 ], [ 87, 49 ], [ 102, 57 ], [ 91, 59 ], [ 103, 62 ], [ 103, 70 ], [ 103, 81 ], [ 103, 84 ], [ 87, 88 ], [ 96, 97 ], [ 102, 103 ] ]

[ "import sys, re\nfrom collections import deque, defaultdict, Counter\nfrom math import ceil, sqrt, hypot, factorial, pi, sin, cos, tan, asin, acos, atan, radians, degrees#, log2, log\nfrom itertools import accumulate, permutations, combinations, combinations_with_replacement, product, groupby\nfrom operator import itemgetter, mul\nfrom copy import deepcopy\nfrom string import ascii_lowercase, ascii_uppercase, digits\nfrom bisect import bisect, bisect_left, insort, insort_left\nfrom fractions import gcd\nfrom heapq import heappush, heappop\nfrom functools import reduce\nfrom decimal import Decimal\ndef input(): return sys.stdin.readline().strip()\ndef INT(): return int(input())\ndef MAP(): return map(int, input().split())\ndef LIST(): return list(map(int, input().split()))\ndef ZIP(n): return zip(*(MAP() for _ in range(n)))\nsys.setrecursionlimit(10 ** 9)\nINF = float('inf')\nmod = 10**9 + 7\nfrom decimal import *\n\nA = LIST()\nA.sort()\n\nif any(A[i]%2 == 0 for i in range(3)):\n\tprint(0)\nelse:\n\tprint(A[0]*A[1])", "import sys, re", "sys", "re", "from collections import deque, defaultdict, Counter", "from math import ceil, sqrt, hypot, factorial, pi, sin, cos, tan, asin, acos, atan, radians, degrees", "from itertools import accumulate, permutations, combinations, combinations_with_replacement, product, groupby", "from operator import itemgetter, mul", "from copy import deepcopy", "from string import ascii_lowercase, ascii_uppercase, digits", "from bisect import bisect, bisect_left, insort, insort_left", "from fractions import gcd", "from heapq import heappush, heappop", "from functools import reduce", "from decimal import Decimal", "def input(): return sys.stdin.readline().strip()", "input", "def INT(): return int(input())", "INT", "def MAP(): return map(int, input().split())", "MAP", "def LIST(): return list(map(int, input().split()))", "LIST", "MAP() for _ in range(n)", "for _ in range(n)", "_", "range(n)", "range", "n", "for _ in range(n)", "MAP()", "MAP", "def ZIP(n): return zip(*(MAP() for _ in range(n)))", "ZIP", "n", "n", "sys.setrecursionlimit(10 ** 9)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "10 ** 9", "10", "9", "INF = float('inf')", "INF", "float('inf')", "float", "'inf'", "mod = 10**9 + 7", "mod", "10**9 + 7", "10**9", "10", "9", "7", "from decimal import *", "A = LIST()", "A", "LIST()", "LIST", "A.sort()", "A.sort", "A", "sort", "if any(A[i]%2 == 0 for i in range(3)):\n\tprint(0)\nelse:\n\tprint(A[0]*A[1])", "any(A[i]%2 == 0 for i in range(3))", "any", "A[i]%2 == 0", "A[i]%2", "A[i]", "A", "i", "2", "0", "print(0)", "print", "0", "print(A[0]*A[1])", "print", "A[0]*A[1]", "A[0]", "A", "0", "A[1]", "A", "1", "mod = 10**9 + 7", "10**9 + 7", "mod", "def LIST(): return list(map(int, input().split()))", "def LIST(): return list(map(int, input().split()))", "LIST", "def input(): return sys.stdin.readline().strip()", "def input(): return sys.stdin.readline().strip()", "input", "INF = float('inf')", "float('inf')", "INF", "def INT(): return int(input())", "def INT(): return int(input())", "INT", "A = LIST()", "LIST()", "A", "def ZIP(n): return zip(*(MAP() for _ in range(n)))", "def ZIP(n): return zip(*(MAP() for _ in range(n)))", "ZIP", "def MAP(): return map(int, input().split())", "def MAP(): return map(int, input().split())", "MAP" ]

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

[ [ 79, 4 ], [ 82, 11 ], [ 73, 18 ], [ 33, 32 ], [ 80, 41 ], [ 32, 45 ], [ 56, 55 ], [ 32, 58 ], [ 32, 61 ], [ 55, 65 ], [ 77, 71 ], [ 73, 74 ], [ 79, 80 ], [ 82, 83 ] ]

[ "import sys\n\nreadline = sys.stdin.readline\nMOD = 10 ** 9 + 7\nINF = float('INF')\nsys.setrecursionlimit(10 ** 5)\n\n\ndef main():\n l = list(map(int, readline().split()))\n l.sort()\n\n if any([x % 2 == 0 for x in l]):\n print(0)\n else:\n s = l[0] * l[1]\n print(s)\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 l = list(map(int, readline().split()))\n l.sort()\n\n if any([x % 2 == 0 for x in l]):\n print(0)\n else:\n s = l[0] * l[1]\n print(s)", "main", "l = list(map(int, readline().split()))", "l", "list(map(int, readline().split()))", "list", "map(int, readline().split())", "map", "int", "readline().split()", "().split", "()", "readline", "split", "l.sort()", "l.sort", "l", "sort", "if any([x % 2 == 0 for x in l]):\n print(0)\n else:\n s = l[0] * l[1]\n print(s)", "any([x % 2 == 0 for x in l])", "any", "[x % 2 == 0 for x in l]", "print(0)", "print", "0", "s = l[0] * l[1]", "s", "l[0] * l[1]", "l[0]", "l", "0", "l[1]", "l", "1", "print(s)", "print", "s", "if __name__ == '__main__':\n main()", "__name__ == '__main__'", "__name__", "'__main__'", "main()", "main", "INF = float('INF')", "float('INF')", "INF", "def main():\n l = list(map(int, readline().split()))\n l.sort()\n\n if any([x % 2 == 0 for x in l]):\n print(0)\n else:\n s = l[0] * l[1]\n print(s)", "def main():\n l = list(map(int, readline().split()))\n l.sort()\n\n if any([x % 2 == 0 for x in l]):\n print(0)\n else:\n s = l[0] * l[1]\n print(s)", "main", "readline = sys.stdin.readline", "sys.stdin.readline", "readline", "MOD = 10 ** 9 + 7", "10 ** 9 + 7", "MOD" ]

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

[ [ 33, 2 ], [ 34, 27 ], [ 34, 30 ], [ 33, 34 ] ]

[ "ABC = sorted(map(int, input().split()))\nif not all(x % 2 for x in ABC):\n print(0)\nelse:\n print(ABC[0] * ABC[1])", "ABC = sorted(map(int, input().split()))", "ABC", "sorted(map(int, input().split()))", "sorted", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "if not all(x % 2 for x in ABC):\n print(0)\nelse:\n print(ABC[0] * ABC[1])", "not all(x % 2 for x in ABC)", "all(x % 2 for x in ABC)", "all", "x % 2", "x", "2", "print(0)", "print", "0", "print(ABC[0] * ABC[1])", "print", "ABC[0] * ABC[1]", "ABC[0]", "ABC", "0", "ABC[1]", "ABC", "1", "ABC = sorted(map(int, input().split()))", "sorted(map(int, input().split()))", "ABC" ]

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

[ [ 4, 3 ], [ 3, 12 ], [ 67, 14 ], [ 70, 17 ], [ 23, 22 ], [ 68, 30 ], [ 22, 31 ], [ 68, 40 ], [ 44, 43 ], [ 68, 50 ], [ 68, 53 ], [ 68, 57 ], [ 68, 62 ], [ 67, 68 ], [ 70, 71 ] ]

[ "ABC = [int(e) for e in input().split()]\n\nmin_ABC = 10**9\n\nfor i in range(3):\n if ABC[i]%2==0:\n print(0)\n break\nelse:\n ABC.sort(reverse=False)\n print(ABC[0]*ABC[1]*(ABC[2]-ABC[2]//2*2))", "int(e) for e in input().split()", "for e in input().split()", "e", "input().split()", "().split", "()", "input", "split", "for e in input().split()", "int(e)", "int", "e", "ABC = [int(e) for e in input().split()]", "ABC", "[int(e) for e in input().split()]", "min_ABC = 10**9", "min_ABC", "10**9", "10", "9", "for i in range(3):\n if ABC[i]%2==0:\n print(0)\n break\nelse:\n ABC.sort(reverse=False)\n print(ABC[0]*ABC[1]*(ABC[2]-ABC[2]//2*2))", "i", "range(3)", "range", "3", "if ABC[i]%2==0:\n print(0)\n break", "ABC[i]%2==0", "ABC[i]%2", "ABC[i]", "ABC", "i", "2", "0", "print(0)", "print", "0", "break", "ABC.sort(reverse=False)", "ABC.sort", "ABC", "sort", "reverse=False", "reverse", "False", "print(ABC[0]*ABC[1]*(ABC[2]-ABC[2]//2*2))", "print", "ABC[0]*ABC[1]*(ABC[2]-ABC[2]//2*2)", "ABC[0]*ABC[1]", "ABC[0]", "ABC", "0", "ABC[1]", "ABC", "1", "ABC[2]-ABC[2]//2*2", "ABC[2]", "ABC", "2", "ABC[2]//2*2", "ABC[2]//2", "ABC[2]", "ABC", "2", "2", "2", "ABC = [int(e) for e in input().split()]", "[int(e) for e in input().split()]", "ABC", "min_ABC = 10**9", "10**9", "min_ABC" ]

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

[ [ 62, 2 ], [ 63, 15 ], [ 56, 18 ], [ 68, 21 ], [ 25, 24 ], [ 63, 24 ], [ 24, 29 ], [ 65, 36 ], [ 66, 41 ], [ 69, 41 ], [ 59, 44 ], [ 63, 47 ], [ 63, 50 ], [ 60, 54 ], [ 57, 54 ], [ 56, 57 ], [ 59, 60 ], [ 62, 63 ], [ 65, 66 ], [ 68, 69 ] ]

[ "a = list(map(int, input().split()))\na.sort()\n\nans = 0\nx = 0\n\nfor num in a:\n if num%2 == 0:\n print(0)\n x += 1\n break\n \nif x == 0:\n ans = a[0] * a[1]\n print(ans)", "a = list(map(int, input().split()))", "a", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "a.sort()", "a.sort", "a", "sort", "ans = 0", "ans", "0", "x = 0", "x", "0", "for num in a:\n if num%2 == 0:\n print(0)\n x += 1\n break\n ", "num", "a", "if num%2 == 0:\n print(0)\n x += 1\n break\n ", "num%2 == 0", "num%2", "num", "2", "0", "print(0)", "print", "0", "x += 1", "x", "1", "break", "if x == 0:\n ans = a[0] * a[1]\n print(ans)", "x == 0", "x", "0", "ans = a[0] * a[1]", "ans", "a[0] * a[1]", "a[0]", "a", "0", "a[1]", "a", "1", "print(ans)", "print", "ans", "ans = 0", "0", "ans", "ans = a[0] * a[1]", "a[0] * a[1]", "ans", "a = list(map(int, input().split()))", "list(map(int, input().split()))", "a", "x += 1", "1", "x", "x = 0", "0", "x" ]

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

[ [ 57, 2 ], [ 57, 11 ], [ 57, 12 ], [ 52, 19 ], [ 55, 20 ], [ 58, 22 ], [ 58, 25 ], [ 52, 30 ], [ 58, 31 ], [ 55, 33 ], [ 55, 36 ], [ 58, 41 ], [ 55, 42 ], [ 52, 44 ], [ 52, 47 ], [ 57, 52 ], [ 57, 55 ], [ 57, 58 ] ]

[ "a,b,c=map(int,input().split())\nprint(min(a*b*(c-(c//2)*2),a*c*(b-(b//2)*2),c*b*(a-(a//2)*2)))\n", "a,b,c=map(int,input().split())", "a", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "c", "print(min(a*b*(c-(c//2)*2),a*c*(b-(b//2)*2),c*b*(a-(a//2)*2)))", "print", "min(a*b*(c-(c//2)*2),a*c*(b-(b//2)*2),c*b*(a-(a//2)*2))", "min", "a*b*(c-(c//2)*2)", "a*b", "a", "b", "c-(c//2)*2", "c", "(c//2)*2", "c//2", "c", "2", "2", "a*c*(b-(b//2)*2)", "a*c", "a", "c", "b-(b//2)*2", "b", "(b//2)*2", "b//2", "b", "2", "2", "c*b*(a-(a//2)*2)", "c*b", "c", "b", "a-(a//2)*2", "a", "(a//2)*2", "a//2", "a", "2", "2", "a,b,c=map(int,input().split())", "map(int,input().split())", "a", "b,c=map(int,input().split())", "map(int,input().split())", "b", "c=map(int,input().split())", "map(int,input().split())", "c" ]

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

[ [ 75, 4 ], [ 76, 28 ], [ 72, 31 ], [ 76, 34 ], [ 76, 38 ], [ 76, 42 ], [ 76, 48 ], [ 76, 51 ], [ 73, 59 ], [ 73, 66 ], [ 72, 73 ], [ 75, 76 ] ]

[ "import math\na = list(map(int, input().split()))\nif sum(list(map(lambda x:x%2, a))) == 3:\n b = a.pop(a.index(max(a)))\n print(a[0]*a[1]*(math.ceil(b/2) - math.floor(b/2)))\nelse:\n print(0)", "import math", "math", "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 sum(list(map(lambda x:x%2, a))) == 3:\n b = a.pop(a.index(max(a)))\n print(a[0]*a[1]*(math.ceil(b/2) - math.floor(b/2)))\nelse:\n print(0)", "sum(list(map(lambda x:x%2, a))) == 3", "sum(list(map(lambda x:x%2, a)))", "sum", "list(map(lambda x:x%2, a))", "list", "map(lambda x:x%2, a)", "map", "lambda x:x%2", "x%2", "x", "2", "x", "a", "3", "b = a.pop(a.index(max(a)))", "b", "a.pop(a.index(max(a)))", "a.pop", "a", "pop", "a.index(max(a))", "a.index", "a", "index", "max(a)", "max", "a", "print(a[0]*a[1]*(math.ceil(b/2) - math.floor(b/2)))", "print", "a[0]*a[1]*(math.ceil(b/2) - math.floor(b/2))", "a[0]*a[1]", "a[0]", "a", "0", "a[1]", "a", "1", "math.ceil(b/2) - math.floor(b/2)", "math.ceil(b/2)", "math.ceil", "math", "ceil", "b/2", "b", "2", "math.floor(b/2)", "math.floor", "math", "floor", "b/2", "b", "2", "print(0)", "print", "0", "b = a.pop(a.index(max(a)))", "a.pop(a.index(max(a)))", "b", "a = list(map(int, input().split()))", "list(map(int, input().split()))", "a" ]

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

[ [ 54, 2 ], [ 54, 11 ], [ 54, 12 ], [ 55, 18 ], [ 49, 23 ], [ 52, 28 ], [ 55, 39 ], [ 49, 40 ], [ 52, 41 ], [ 55, 44 ], [ 49, 45 ], [ 52, 46 ], [ 54, 49 ], [ 54, 52 ], [ 54, 55 ] ]

[ "a,b,c=map(int,input().split())\nif a%2==0 or b%2==0 or c%2==0:\n print(0)\nelse:\n print(a*b*c//max(a,b,c))", "a,b,c=map(int,input().split())", "a", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "c", "if a%2==0 or b%2==0 or c%2==0:\n print(0)\nelse:\n print(a*b*c//max(a,b,c))", "a%2==0 or b%2==0 or c%2==0", "a%2==0 or b%2==0", "a%2==0", "a%2", "a", "2", "0", "b%2==0", "b%2", "b", "2", "0", "c%2==0", "c%2", "c", "2", "0", "print(0)", "print", "0", "print(a*b*c//max(a,b,c))", "print", "a*b*c//max(a,b,c)", "a*b*c", "a*b", "a", "b", "c", "max(a,b,c)", "max", "a", "b", "c", "b,c=map(int,input().split())", "map(int,input().split())", "b", "c=map(int,input().split())", "map(int,input().split())", "c", "a,b,c=map(int,input().split())", "map(int,input().split())", "a" ]

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

[ [ 106, 2 ], [ 106, 11 ], [ 106, 12 ], [ 100, 14 ], [ 95, 18 ], [ 107, 19 ], [ 98, 21 ], [ 95, 25 ], [ 107, 26 ], [ 98, 28 ], [ 98, 30 ], [ 91, 33 ], [ 95, 37 ], [ 107, 39 ], [ 98, 41 ], [ 95, 44 ], [ 107, 46 ], [ 107, 48 ], [ 98, 50 ], [ 103, 52 ], [ 95, 57 ], [ 107, 59 ], [ 98, 60 ], [ 95, 64 ], [ 95, 66 ], [ 107, 68 ], [ 98, 69 ], [ 88, 71 ], [ 101, 75 ], [ 92, 78 ], [ 104, 81 ], [ 89, 86 ], [ 88, 89 ], [ 91, 92 ], [ 106, 95 ], [ 106, 98 ], [ 100, 101 ], [ 103, 104 ], [ 106, 107 ] ]

[ "a, b, c = map(int, input().split())\n\nL1 = a*b*(c//2)-a*b*(c-c//2)\nL2 = a*(b//2)*c-a*(b-b//2)*c\nL3 = (a//2)*b*c-(a-a//2)*b*c\nL = [abs(L1), abs(L2), abs(L3)]\nprint(min(L))", "a, b, c = map(int, input().split())", "a", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "c", "L1 = a*b*(c//2)-a*b*(c-c//2)", "L1", "a*b*(c//2)-a*b*(c-c//2)", "a*b*(c//2)", "a*b", "a", "b", "c//2", "c", "2", "a*b*(c-c//2)", "a*b", "a", "b", "c-c//2", "c", "c//2", "c", "2", "L2 = a*(b//2)*c-a*(b-b//2)*c", "L2", "a*(b//2)*c-a*(b-b//2)*c", "a*(b//2)*c", "a*(b//2)", "a", "b//2", "b", "2", "c", "a*(b-b//2)*c", "a*(b-b//2)", "a", "b-b//2", "b", "b//2", "b", "2", "c", "L3 = (a//2)*b*c-(a-a//2)*b*c", "L3", "(a//2)*b*c-(a-a//2)*b*c", "(a//2)*b*c", "(a//2)*b", "a//2", "a", "2", "b", "c", "(a-a//2)*b*c", "(a-a//2)*b", "a-a//2", "a", "a//2", "a", "2", "b", "c", "L = [abs(L1), abs(L2), abs(L3)]", "L", "[abs(L1), abs(L2), abs(L3)]", "abs(L1)", "abs", "L1", "abs(L2)", "abs", "L2", "abs(L3)", "abs", "L3", "print(min(L))", "print", "min(L)", "min", "L", "L = [abs(L1), abs(L2), abs(L3)]", "[abs(L1), abs(L2), abs(L3)]", "L", "L2 = a*(b//2)*c-a*(b-b//2)*c", "a*(b//2)*c-a*(b-b//2)*c", "L2", "a, b, c = map(int, input().split())", "map(int, input().split())", "a", "c = map(int, input().split())", "map(int, input().split())", "c", "L1 = a*b*(c//2)-a*b*(c-c//2)", "a*b*(c//2)-a*b*(c-c//2)", "L1", "L3 = (a//2)*b*c-(a-a//2)*b*c", "(a//2)*b*c-(a-a//2)*b*c", "L3", "b, c = map(int, input().split())", "map(int, input().split())", "b" ]

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

[ [ 5, 4 ], [ 5, 13 ], [ 5, 14 ], [ 4, 20 ], [ 13, 25 ], [ 14, 30 ], [ 4, 41 ], [ 13, 42 ], [ 13, 44 ], [ 14, 45 ], [ 14, 47 ], [ 4, 48 ], [ 57, 54 ] ]

[ "def main():\n a, b, c = map( int, input().split())\n if a%2 == 0 or b%2 == 0 or c%2 == 0:\n print(0)\n else:\n print( min(a*b, b*c, c*a))\n\nif __name__ == '__main__':\n main()", "def main():\n a, b, c = map( int, input().split())\n if a%2 == 0 or b%2 == 0 or c%2 == 0:\n print(0)\n else:\n print( min(a*b, b*c, c*a))", "main", "a, b, c = map( int, input().split())", "a", "map( int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "c", "if a%2 == 0 or b%2 == 0 or c%2 == 0:\n print(0)\n else:\n print( min(a*b, b*c, c*a))", "a%2 == 0 or b%2 == 0 or c%2 == 0", "a%2 == 0 or b%2 == 0", "a%2 == 0", "a%2", "a", "2", "0", "b%2 == 0", "b%2", "b", "2", "0", "c%2 == 0", "c%2", "c", "2", "0", "print(0)", "print", "0", "print( min(a*b, b*c, c*a))", "print", "min(a*b, b*c, c*a)", "min", "a*b", "a", "b", "b*c", "b", "c", "c*a", "c", "a", "if __name__ == '__main__':\n main()", "__name__ == '__main__'", "__name__", "'__main__'", "main()", "main", "def main():\n a, b, c = map( int, input().split())\n if a%2 == 0 or b%2 == 0 or c%2 == 0:\n print(0)\n else:\n print( min(a*b, b*c, c*a))", "def main():\n a, b, c = map( int, input().split())\n if a%2 == 0 or b%2 == 0 or c%2 == 0:\n print(0)\n else:\n print( min(a*b, b*c, c*a))", "main" ]

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

[ [ 64, 2 ], [ 64, 11 ], [ 64, 12 ], [ 65, 18 ], [ 62, 23 ], [ 56, 28 ], [ 58, 35 ], [ 44, 43 ], [ 59, 49 ], [ 59, 52 ], [ 64, 56 ], [ 58, 59 ], [ 64, 62 ], [ 64, 65 ] ]

[ "a, b, c = map(int, input().split())\n\nif a % 2 == 0 or b % 2 == 0 or c % 2 == 0:\n print(0)\nelse:\n li_wk = sorted([a, b, c], reverse=True)\n print(li_wk[1] * li_wk[2])", "a, b, c = map(int, input().split())", "a", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "c", "if a % 2 == 0 or b % 2 == 0 or c % 2 == 0:\n print(0)\nelse:\n li_wk = sorted([a, b, c], reverse=True)\n print(li_wk[1] * li_wk[2])", "a % 2 == 0 or b % 2 == 0 or c % 2 == 0", "a % 2 == 0 or b % 2 == 0", "a % 2 == 0", "a % 2", "a", "2", "0", "b % 2 == 0", "b % 2", "b", "2", "0", "c % 2 == 0", "c % 2", "c", "2", "0", "print(0)", "print", "0", "li_wk = sorted([a, b, c], reverse=True)", "li_wk", "sorted([a, b, c], reverse=True)", "sorted", "[a, b, c]", "a", "b", "c", "reverse=True", "reverse", "True", "print(li_wk[1] * li_wk[2])", "print", "li_wk[1] * li_wk[2]", "li_wk[1]", "li_wk", "1", "li_wk[2]", "li_wk", "2", "c = map(int, input().split())", "map(int, input().split())", "c", "li_wk = sorted([a, b, c], reverse=True)", "sorted([a, b, c], reverse=True)", "li_wk", "b, c = map(int, input().split())", "map(int, input().split())", "b", "a, b, c = map(int, input().split())", "map(int, input().split())", "a" ]

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

[ [ 55, 2 ], [ 55, 11 ], [ 55, 12 ], [ 56, 17 ], [ 47, 20 ], [ 53, 23 ], [ 49, 26 ], [ 56, 31 ], [ 47, 32 ], [ 56, 34 ], [ 53, 35 ], [ 47, 37 ], [ 53, 38 ], [ 58, 40 ], [ 59, 44 ], [ 50, 44 ], [ 55, 47 ], [ 49, 50 ], [ 55, 53 ], [ 55, 56 ], [ 58, 59 ] ]

[ "a,b,c=map(int,input().split())\nif a%2 and b%2 and c%2:\n ans=min([a*b,a*c,b*c])\nelse:\n ans=0\nprint(ans)", "a,b,c=map(int,input().split())", "a", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "c", "if a%2 and b%2 and c%2:\n ans=min([a*b,a*c,b*c])\nelse:\n ans=0", "a%2 and b%2 and c%2", "a%2 and b%2", "a%2", "a", "2", "b%2", "b", "2", "c%2", "c", "2", "ans=min([a*b,a*c,b*c])", "ans", "min([a*b,a*c,b*c])", "min", "[a*b,a*c,b*c]", "a*b", "a", "b", "a*c", "a", "c", "b*c", "b", "c", "ans=0", "ans", "0", "print(ans)", "print", "ans", "b,c=map(int,input().split())", "map(int,input().split())", "b", "ans=min([a*b,a*c,b*c])", "min([a*b,a*c,b*c])", "ans", "c=map(int,input().split())", "map(int,input().split())", "c", "a,b,c=map(int,input().split())", "map(int,input().split())", "a", "ans=0", "0", "ans" ]

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

[ [ 37, 2 ], [ 38, 20 ], [ 38, 23 ], [ 38, 27 ], [ 38, 32 ], [ 37, 38 ] ]

[ "A = sorted(list(map(int,input().split())))\nprint(A[0]*A[1]*(A[2]-(A[2]//2)*2))", "A = sorted(list(map(int,input().split())))", "A", "sorted(list(map(int,input().split())))", "sorted", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "print(A[0]*A[1]*(A[2]-(A[2]//2)*2))", "print", "A[0]*A[1]*(A[2]-(A[2]//2)*2)", "A[0]*A[1]", "A[0]", "A", "0", "A[1]", "A", "1", "A[2]-(A[2]//2)*2", "A[2]", "A", "2", "(A[2]//2)*2", "A[2]//2", "A[2]", "A", "2", "2", "2", "A = sorted(list(map(int,input().split())))", "sorted(list(map(int,input().split())))", "A" ]

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

[ [ 78, 4 ], [ 18, 17 ], [ 26, 25 ], [ 79, 34 ], [ 38, 37 ], [ 25, 40 ], [ 43, 42 ], [ 37, 45 ], [ 25, 45 ], [ 50, 49 ], [ 37, 52 ], [ 25, 52 ], [ 42, 54 ], [ 49, 60 ], [ 42, 61 ], [ 37, 63 ], [ 25, 63 ], [ 37, 66 ], [ 25, 66 ], [ 82, 73 ], [ 78, 79 ] ]

[ "import sys\ninput = sys.stdin.readline\n\n\ndef log(*args):\n print(*args, file=sys.stderr)\n\n\ndef main():\n l = list(map(int, input().split()))\n l = sorted(l)\n small = l[2] // 2\n large = l[2] - small\n print((large - small) * l[0] * l[1])\n\n\nif __name__ == '__main__':\n main()", "import sys", "sys", "input = sys.stdin.readline", "input", "sys.stdin.readline", "sys.stdin", "sys", "stdin", "readline", "def log(*args):\n print(*args, file=sys.stderr)", "log", "print(*args, file=sys.stderr)", "print", "*args", "args", "file=sys.stderr", "file", "sys.stderr", "sys", "stderr", "*args", "def main():\n l = list(map(int, input().split()))\n l = sorted(l)\n small = l[2] // 2\n large = l[2] - small\n print((large - small) * l[0] * l[1])", "main", "l = list(map(int, input().split()))", "l", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "l = sorted(l)", "l", "sorted(l)", "sorted", "l", "small = l[2] // 2", "small", "l[2] // 2", "l[2]", "l", "2", "2", "large = l[2] - small", "large", "l[2] - small", "l[2]", "l", "2", "small", "print((large - small) * l[0] * l[1])", "print", "(large - small) * l[0] * l[1]", "(large - small) * l[0]", "large - small", "large", "small", "l[0]", "l", "0", "l[1]", "l", "1", "if __name__ == '__main__':\n main()", "__name__ == '__main__'", "__name__", "'__main__'", "main()", "main", "def log(*args):\n print(*args, file=sys.stderr)", "def log(*args):\n print(*args, file=sys.stderr)", "log", "input = sys.stdin.readline", "sys.stdin.readline", "input", "def main():\n l = list(map(int, input().split()))\n l = sorted(l)\n small = l[2] // 2\n large = l[2] - small\n print((large - small) * l[0] * l[1])", "def main():\n l = list(map(int, input().split()))\n l = sorted(l)\n small = l[2] // 2\n large = l[2] - small\n print((large - small) * l[0] * l[1])", "main" ]

[ 7, 15, 13, 4, 18, 13, 13, 2, 17, 17, 0, 13, 12, 4, 13, 4, 18, 18, 13, 13, 13, 0, 13, 12, 4, 13, 13, 4, 18, 4, 18, 18, 13, 13, 13, 13, 0, 13, 12, 4, 13, 4, 13, 0, 13, 12, 4, 18, 4, 18, 18, 13, 13, 13, 13, 0, 13, 12, 4, 13, 17, 31, 13, 17, 32, 4, 13, 0, 13, 18, 13, 13, 32, 13, 23, 16, 0, 13, 4, 13, 13, 13, 12, 13, 0, 13, 4, 13, 39, 2, 2, 4, 13, 2, 2, 13, 17, 2, 13, 2, 13, 17, 13, 13, 2, 2, 4, 13, 2, 2, 13, 17, 2, 13, 2, 13, 17, 13, 13, 2, 2, 4, 13, 2, 2, 13, 17, 2, 13, 2, 13, 17, 13, 13, 29, 13, 4, 13, 4, 13, 10, 4, 13, 10, 12, 13, 10, 4, 13, 10, 12, 13, 10, 12, 13, 10, 12, 13, 10, 12, 13, 10, 4, 13, 10, 12, 13 ]

[ [ 153, 11 ], [ 144, 22 ], [ 156, 37 ], [ 145, 42 ], [ 165, 44 ], [ 150, 56 ], [ 69, 68 ], [ 162, 77 ], [ 157, 79 ], [ 162, 80 ], [ 162, 81 ], [ 86, 85 ], [ 142, 95 ], [ 142, 98 ], [ 142, 100 ], [ 148, 102 ], [ 163, 103 ], [ 148, 110 ], [ 148, 113 ], [ 148, 115 ], [ 142, 117 ], [ 163, 118 ], [ 163, 125 ], [ 163, 128 ], [ 163, 130 ], [ 148, 132 ], [ 142, 133 ], [ 85, 135 ], [ 160, 139 ], [ 162, 142 ], [ 144, 145 ], [ 162, 148 ], [ 150, 151 ], [ 153, 154 ], [ 156, 157 ], [ 162, 163 ], [ 165, 166 ] ]

[ "import sys\n\nsys.setrecursionlimit(10 ** 8)\nini = lambda: int(sys.stdin.readline())\ninm = lambda: map(int, sys.stdin.readline().split())\ninl = lambda: list(inm())\nins = lambda: sys.stdin.readline().rstrip()\ndebug = lambda *a, **kw: print(\"\\033[33m\", *a, \"\\033[0m\", **dict(file=sys.stderr, **kw))\n\n\na, b, c = inl()\n\n\ndef solve():\n ans = min(\n [\n abs((a // 2) - (a - a // 2)) * b * c,\n abs((b // 2) - (b - b // 2)) * a * c,\n abs((c // 2) - (c - c // 2)) * b * a,\n ]\n )\n return ans\n\n\nprint(solve())", "import sys", "sys", "sys.setrecursionlimit(10 ** 8)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "10 ** 8", "10", "8", "ini = lambda: int(sys.stdin.readline())", "ini", "lambda: int(sys.stdin.readline())", "int(sys.stdin.readline())", "int", "sys.stdin.readline()", "sys.stdin.readline", "sys.stdin", "sys", "stdin", "readline", "inm = lambda: map(int, sys.stdin.readline().split())", "inm", "lambda: map(int, sys.stdin.readline().split())", "map(int, sys.stdin.readline().split())", "map", "int", "sys.stdin.readline().split()", "sys.stdin.readline().split", "sys.stdin.readline()", "sys.stdin.readline", "sys.stdin", "sys", "stdin", "readline", "split", "inl = lambda: list(inm())", "inl", "lambda: list(inm())", "list(inm())", "list", "inm()", "inm", "ins = lambda: sys.stdin.readline().rstrip()", "ins", "lambda: sys.stdin.readline().rstrip()", "sys.stdin.readline().rstrip()", "sys.stdin.readline().rstrip", "sys.stdin.readline()", "sys.stdin.readline", "sys.stdin", "sys", "stdin", "readline", "rstrip", "debug = lambda *a, **kw: print(\"\\033[33m\", *a, \"\\033[0m\", **dict(file=sys.stderr, **kw))", "debug", "lambda *a, **kw: print(\"\\033[33m\", *a, \"\\033[0m\", **dict(file=sys.stderr, **kw))", "print(\"\\033[33m\", *a, \"\\033[0m\", **dict(file=sys.stderr, **kw))", "print", "\"\\033[33m\"", "*a", "a", "\"\\033[0m\"", "**dict(file=sys.stderr, **kw)", "dict(file=sys.stderr, **kw)", "dict", "file=sys.stderr", "file", "sys.stderr", "sys", "stderr", "**kw", "kw", "*a", "**kw", "a, b, c = inl()", "a", "inl()", "inl", "b", "c", "def solve():\n ans = min(\n [\n abs((a // 2) - (a - a // 2)) * b * c,\n abs((b // 2) - (b - b // 2)) * a * c,\n abs((c // 2) - (c - c // 2)) * b * a,\n ]\n )\n return ans", "solve", "ans = min(\n [\n abs((a // 2) - (a - a // 2)) * b * c,\n abs((b // 2) - (b - b // 2)) * a * c,\n abs((c // 2) - (c - c // 2)) * b * a,\n ]\n )", "ans", "min(\n [\n abs((a // 2) - (a - a // 2)) * b * c,\n abs((b // 2) - (b - b // 2)) * a * c,\n abs((c // 2) - (c - c // 2)) * b * a,\n ]\n )", "min", "[\n abs((a // 2) - (a - a // 2)) * b * c,\n abs((b // 2) - (b - b // 2)) * a * c,\n abs((c // 2) - (c - c // 2)) * b * a,\n ]", "abs((a // 2) - (a - a // 2)) * b * c", "abs((a // 2) - (a - a // 2)) * b", "abs((a // 2) - (a - a // 2))", "abs", "(a // 2) - (a - a // 2)", "a // 2", "a", "2", "a - a // 2", "a", "a // 2", "a", "2", "b", "c", "abs((b // 2) - (b - b // 2)) * a * c", "abs((b // 2) - (b - b // 2)) * a", "abs((b // 2) - (b - b // 2))", "abs", "(b // 2) - (b - b // 2)", "b // 2", "b", "2", "b - b // 2", "b", "b // 2", "b", "2", "a", "c", "abs((c // 2) - (c - c // 2)) * b * a", "abs((c // 2) - (c - c // 2)) * b", "abs((c // 2) - (c - c // 2))", "abs", "(c // 2) - (c - c // 2)", "c // 2", "c", "2", "c - c // 2", "c", "c // 2", "c", "2", "b", "a", "return ans", "ans", "print(solve())", "print", "solve()", "solve", "a, b, c = inl()", "inl()", "a", "inm = lambda: map(int, sys.stdin.readline().split())", "lambda: map(int, sys.stdin.readline().split())", "inm", "b, c = inl()", "inl()", "b", "debug = lambda *a, **kw: print(\"\\033[33m\", *a, \"\\033[0m\", **dict(file=sys.stderr, **kw))", "lambda *a, **kw: print(\"\\033[33m\", *a, \"\\033[0m\", **dict(file=sys.stderr, **kw))", "debug", "ini = lambda: int(sys.stdin.readline())", "lambda: int(sys.stdin.readline())", "ini", "inl = lambda: list(inm())", "lambda: list(inm())", "inl", "def solve():\n ans = min(\n [\n abs((a // 2) - (a - a // 2)) * b * c,\n abs((b // 2) - (b - b // 2)) * a * c,\n abs((c // 2) - (c - c // 2)) * b * a,\n ]\n )\n return ans", "def solve():\n ans = min(\n [\n abs((a // 2) - (a - a // 2)) * b * c,\n abs((b // 2) - (b - b // 2)) * a * c,\n abs((c // 2) - (c - c // 2)) * b * a,\n ]\n )\n return ans", "solve", "c = inl()", "inl()", "c", "ins = lambda: sys.stdin.readline().rstrip()", "lambda: sys.stdin.readline().rstrip()", "ins" ]

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

[ [ 54, 2 ], [ 55, 15 ], [ 55, 23 ], [ 55, 30 ], [ 55, 37 ], [ 55, 48 ], [ 55, 51 ], [ 54, 55 ] ]

[ "A = list(map(int, input().split()))\nA.sort()\nif A[0] % 2 == 0 or A[1] % 2 == 0 or A[2] % 2 == 0:\n print(0)\nelse:\n print(A[0] * A[1])", "A = list(map(int, input().split()))", "A", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "A.sort()", "A.sort", "A", "sort", "if A[0] % 2 == 0 or A[1] % 2 == 0 or A[2] % 2 == 0:\n print(0)\nelse:\n print(A[0] * A[1])", "A[0] % 2 == 0 or A[1] % 2 == 0 or A[2] % 2 == 0", "A[0] % 2 == 0 or A[1] % 2 == 0", "A[0] % 2 == 0", "A[0] % 2", "A[0]", "A", "0", "2", "0", "A[1] % 2 == 0", "A[1] % 2", "A[1]", "A", "1", "2", "0", "A[2] % 2 == 0", "A[2] % 2", "A[2]", "A", "2", "2", "0", "print(0)", "print", "0", "print(A[0] * A[1])", "print", "A[0] * A[1]", "A[0]", "A", "0", "A[1]", "A", "1", "A = list(map(int, input().split()))", "list(map(int, input().split()))", "A" ]

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

[ [ 45, 2 ], [ 42, 16 ], [ 46, 20 ], [ 43, 30 ], [ 46, 32 ], [ 43, 34 ], [ 46, 36 ], [ 46, 39 ], [ 42, 43 ], [ 45, 46 ] ]

[ "abc=sorted(list(map(int,input().split())))\nl=(abc[2]+1)//2\nprint((l-abc[2]+l)*abc[0]*abc[1])", "abc=sorted(list(map(int,input().split())))", "abc", "sorted(list(map(int,input().split())))", "sorted", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "l=(abc[2]+1)//2", "l", "(abc[2]+1)//2", "abc[2]+1", "abc[2]", "abc", "2", "1", "2", "print((l-abc[2]+l)*abc[0]*abc[1])", "print", "(l-abc[2]+l)*abc[0]*abc[1]", "(l-abc[2]+l)*abc[0]", "l-abc[2]+l", "l-abc[2]", "l", "abc[2]", "abc", "2", "l", "abc[0]", "abc", "0", "abc[1]", "abc", "1", "l=(abc[2]+1)//2", "(abc[2]+1)//2", "l", "abc=sorted(list(map(int,input().split())))", "sorted(list(map(int,input().split())))", "abc" ]

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

[ [ 63, 16 ], [ 61, 23 ], [ 63, 25 ], [ 63, 26 ], [ 55, 32 ], [ 64, 37 ], [ 58, 42 ], [ 63, 55 ], [ 63, 58 ], [ 63, 64 ] ]

[ "import sys\ndef input():\n return sys.stdin.readline().rstrip()\n\nA,B,C=map(int,input().split())\nif A%2==0 or B%2==0 or C%2==0:\n print(0)\nelse:\n print(min({A*B,B*C,C*A}))", "import sys", "sys", "def input():\n return sys.stdin.readline().rstrip()", "input", "return sys.stdin.readline().rstrip()", "sys.stdin.readline().rstrip()", "sys.stdin.readline().rstrip", "sys.stdin.readline()", "sys.stdin.readline", "sys.stdin", "sys", "stdin", "readline", "rstrip", "A,B,C=map(int,input().split())", "A", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "B", "C", "if A%2==0 or B%2==0 or C%2==0:\n print(0)\nelse:\n print(min({A*B,B*C,C*A}))", "A%2==0 or B%2==0 or C%2==0", "A%2==0 or B%2==0", "A%2==0", "A%2", "A", "2", "0", "B%2==0", "B%2", "B", "2", "0", "C%2==0", "C%2", "C", "2", "0", "print(0)", "print", "0", "print(min({A*B,B*C,C*A}))", "print", "min({A*B,B*C,C*A})", "min", "{A*B,B*C,C*A}", "A,B,C=map(int,input().split())", "map(int,input().split())", "A", "C=map(int,input().split())", "map(int,input().split())", "C", "def input():\n return sys.stdin.readline().rstrip()", "def input():\n return sys.stdin.readline().rstrip()", "input", "B,C=map(int,input().split())", "map(int,input().split())", "B" ]

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

[ [ 36, 2 ], [ 37, 19 ], [ 37, 30 ], [ 37, 33 ], [ 36, 37 ] ]

[ "A = sorted(list(map(int, input().split())))\nif A[2] % 2 == 0:\n print(0)\nelse:\n print(A[0] * A[1])", "A = sorted(list(map(int, input().split())))", "A", "sorted(list(map(int, input().split())))", "sorted", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "if A[2] % 2 == 0:\n print(0)\nelse:\n print(A[0] * A[1])", "A[2] % 2 == 0", "A[2] % 2", "A[2]", "A", "2", "2", "0", "print(0)", "print", "0", "print(A[0] * A[1])", "print", "A[0] * A[1]", "A[0]", "A", "0", "A[1]", "A", "1", "A = sorted(list(map(int, input().split())))", "sorted(list(map(int, input().split())))", "A" ]

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

[ [ 5, 4 ], [ 4, 17 ], [ 21, 20 ], [ 4, 20 ], [ 20, 25 ], [ 4, 37 ], [ 4, 40 ], [ 50, 47 ] ]

[ "def main():\n lst = list(map(int, input().split()))\n lst.sort()\n\n for l in lst:\n if l % 2 == 0:\n print(0)\n exit()\n print(lst[0] * lst[1])\n\n\nif __name__ == \"__main__\":\n main()", "def main():\n lst = list(map(int, input().split()))\n lst.sort()\n\n for l in lst:\n if l % 2 == 0:\n print(0)\n exit()\n print(lst[0] * lst[1])", "main", "lst = list(map(int, input().split()))", "lst", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "lst.sort()", "lst.sort", "lst", "sort", "for l in lst:\n if l % 2 == 0:\n print(0)\n exit()\n ", "l", "lst", "if l % 2 == 0:\n print(0)\n exit()\n ", "l % 2 == 0", "l % 2", "l", "2", "0", "print(0)", "print", "0", "exit()", "exit", "print(lst[0] * lst[1])", "print", "lst[0] * lst[1]", "lst[0]", "lst", "0", "lst[1]", "lst", "1", "if __name__ == \"__main__\":\n main()", "__name__ == \"__main__\"", "__name__", "\"__main__\"", "main()", "main", "def main():\n lst = list(map(int, input().split()))\n lst.sort()\n\n for l in lst:\n if l % 2 == 0:\n print(0)\n exit()\n print(lst[0] * lst[1])", "def main():\n lst = list(map(int, input().split()))\n lst.sort()\n\n for l in lst:\n if l % 2 == 0:\n print(0)\n exit()\n print(lst[0] * lst[1])", "main" ]

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

[ [ 80, 2 ], [ 80, 11 ], [ 80, 12 ], [ 74, 14 ], [ 78, 17 ], [ 81, 18 ], [ 72, 19 ], [ 86, 21 ], [ 78, 25 ], [ 81, 27 ], [ 72, 28 ], [ 89, 29 ], [ 81, 33 ], [ 78, 35 ], [ 72, 36 ], [ 83, 37 ], [ 72, 41 ], [ 78, 43 ], [ 81, 44 ], [ 87, 54 ], [ 75, 55 ], [ 90, 61 ], [ 75, 62 ], [ 84, 68 ], [ 75, 69 ], [ 80, 72 ], [ 74, 75 ], [ 80, 78 ], [ 80, 81 ], [ 83, 84 ], [ 86, 87 ], [ 89, 90 ] ]

[ "a, b, c = map(int, input().split())\nx = a*b*c\nA, B, C = a//2*b*c, b//2*a*c, c//2*a*b\nprint(min(abs(2*A-x), abs(2*B-x), abs(2*C-x)))", "a, b, c = map(int, input().split())", "a", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "c", "x = a*b*c", "x", "a*b*c", "a*b", "a", "b", "c", "A, B, C = a//2*b*c, b//2*a*c, c//2*a*b", "A", "a//2*b*c", "a//2*b", "a//2", "a", "2", "b", "c", "B", "b//2*a*c", "b//2*a", "b//2", "b", "2", "a", "c", "C", "c//2*a*b", "c//2*a", "c//2", "c", "2", "a", "b", "print(min(abs(2*A-x), abs(2*B-x), abs(2*C-x)))", "print", "min(abs(2*A-x), abs(2*B-x), abs(2*C-x))", "min", "abs(2*A-x)", "abs", "2*A-x", "2*A", "2", "A", "x", "abs(2*B-x)", "abs", "2*B-x", "2*B", "2", "B", "x", "abs(2*C-x)", "abs", "2*C-x", "2*C", "2", "C", "x", "c = map(int, input().split())", "map(int, input().split())", "c", "x = a*b*c", "a*b*c", "x", "a, b, c = map(int, input().split())", "map(int, input().split())", "a", "b, c = map(int, input().split())", "map(int, input().split())", "b", "C = a//2*b*c, b//2*a*c, c//2*a*b", "c//2*a*b", "C", "A, B, C = a//2*b*c, b//2*a*c, c//2*a*b", "a//2*b*c", "A", "B, C = a//2*b*c, b//2*a*c, c//2*a*b", "b//2*a*c", "B" ]

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

[ [ 45, 2 ], [ 45, 11 ], [ 45, 12 ], [ 48, 23 ], [ 43, 27 ], [ 40, 28 ], [ 46, 30 ], [ 40, 31 ], [ 43, 33 ], [ 46, 34 ], [ 49, 37 ], [ 45, 40 ], [ 45, 43 ], [ 45, 46 ], [ 48, 49 ] ]

[ "a,b,c = map(int,input().split())\nif any([i%2==0 for i in (a,b,c)]):\n print(0)\n exit()\nelse:\n ans = min(a*b , c*b , a*c)\nprint(ans)", "a,b,c = map(int,input().split())", "a", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "c", "if any([i%2==0 for i in (a,b,c)]):\n print(0)\n exit()\nelse:\n ans = min(a*b , c*b , a*c)", "any([i%2==0 for i in (a,b,c)])", "any", "[i%2==0 for i in (a,b,c)]", "print(0)", "print", "0", "exit()", "exit", "ans = min(a*b , c*b , a*c)", "ans", "min(a*b , c*b , a*c)", "min", "a*b", "a", "b", "c*b", "c", "b", "a*c", "a", "c", "print(ans)", "print", "ans", "b,c = map(int,input().split())", "map(int,input().split())", "b", "a,b,c = map(int,input().split())", "map(int,input().split())", "a", "c = map(int,input().split())", "map(int,input().split())", "c", "ans = min(a*b , c*b , a*c)", "min(a*b , c*b , a*c)", "ans" ]

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

[ [ 18, 17 ], [ 74, 26 ], [ 30, 29 ], [ 17, 33 ], [ 17, 36 ], [ 17, 39 ], [ 43, 42 ], [ 48, 47 ], [ 17, 47 ], [ 47, 52 ], [ 57, 56 ], [ 61, 60 ], [ 42, 63 ], [ 60, 63 ], [ 56, 63 ], [ 29, 65 ], [ 47, 66 ], [ 60, 69 ], [ 56, 69 ], [ 42, 69 ], [ 77, 71 ] ]

[ "import sys\nsys.setrecursionlimit(10 ** 5 + 10)\ndef input(): return sys.stdin.readline().strip()\n\ndef resolve():\n\n L=list(map(int,input().split()))\n prod=L[0]*L[1]*L[2]\n ans=10**20\n for i in L:\n if i%2==0:\n ans= 0\n break\n else:\n ans=min(ans,prod//i)\n print(ans)\n\n\nresolve()", "import sys", "sys", "sys.setrecursionlimit(10 ** 5 + 10)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "10 ** 5 + 10", "10 ** 5", "10", "5", "10", "def input(): return sys.stdin.readline().strip()", "input", "def resolve():\n\n L=list(map(int,input().split()))\n prod=L[0]*L[1]*L[2]\n ans=10**20\n for i in L:\n if i%2==0:\n ans= 0\n break\n else:\n ans=min(ans,prod//i)\n print(ans)", "resolve", "L=list(map(int,input().split()))", "L", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "prod=L[0]*L[1]*L[2]", "prod", "L[0]*L[1]*L[2]", "L[0]*L[1]", "L[0]", "L", "0", "L[1]", "L", "1", "L[2]", "L", "2", "ans=10**20", "ans", "10**20", "10", "20", "for i in L:\n if i%2==0:\n ans= 0\n break\n else:\n ans=min(ans,prod//i)\n ", "i", "L", "if i%2==0:\n ans= 0\n break\n else:\n ans=min(ans,prod//i)\n ", "i%2==0", "i%2", "i", "2", "0", "ans= 0", "ans", "0", "break", "ans=min(ans,prod//i)", "ans", "min(ans,prod//i)", "min", "ans", "prod//i", "prod", "i", "print(ans)", "print", "ans", "resolve()", "resolve", "def input(): return sys.stdin.readline().strip()", "def input(): return sys.stdin.readline().strip()", "input", "def resolve():\n\n L=list(map(int,input().split()))\n prod=L[0]*L[1]*L[2]\n ans=10**20\n for i in L:\n if i%2==0:\n ans= 0\n break\n else:\n ans=min(ans,prod//i)\n print(ans)", "def resolve():\n\n L=list(map(int,input().split()))\n prod=L[0]*L[1]*L[2]\n ans=10**20\n for i in L:\n if i%2==0:\n ans= 0\n break\n else:\n ans=min(ans,prod//i)\n print(ans)", "resolve" ]

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

[ [ 54, 2 ], [ 54, 11 ], [ 54, 12 ], [ 52, 18 ], [ 55, 23 ], [ 49, 28 ], [ 52, 36 ], [ 55, 37 ], [ 55, 39 ], [ 49, 40 ], [ 49, 42 ], [ 52, 43 ], [ 54, 49 ], [ 54, 52 ], [ 54, 55 ] ]

[ "a, b, c = map(int, input().split())\nif a%2!=0 and b%2!=0 and c%2!=0:\n print(min(a*b, b*c, c*a))\nelse:\n print(0)", "a, b, c = map(int, input().split())", "a", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "c", "if a%2!=0 and b%2!=0 and c%2!=0:\n print(min(a*b, b*c, c*a))\nelse:\n print(0)", "a%2!=0 and b%2!=0 and c%2!=0", "a%2!=0 and b%2!=0", "a%2!=0", "a%2", "a", "2", "0", "b%2!=0", "b%2", "b", "2", "0", "c%2!=0", "c%2", "c", "2", "0", "print(min(a*b, b*c, c*a))", "print", "min(a*b, b*c, c*a)", "min", "a*b", "a", "b", "b*c", "b", "c", "c*a", "c", "a", "print(0)", "print", "0", "c = map(int, input().split())", "map(int, input().split())", "c", "a, b, c = map(int, input().split())", "map(int, input().split())", "a", "b, c = map(int, input().split())", "map(int, input().split())", "b" ]

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

[ [ 70, 2 ], [ 71, 19 ], [ 71, 26 ], [ 71, 33 ], [ 79, 41 ], [ 76, 44 ], [ 71, 47 ], [ 71, 51 ], [ 54, 53 ], [ 53, 59 ], [ 77, 60 ], [ 73, 62 ], [ 71, 64 ], [ 53, 65 ], [ 74, 68 ], [ 80, 68 ], [ 70, 71 ], [ 73, 74 ], [ 76, 77 ], [ 79, 80 ] ]

[ "l = list(map(int, input().split()))\n\nif l[0] % 2 == 0 or l[1] % 2 == 0 or l[2] % 2 == 0:\n print(0)\nelse:\n ans = 1\n max_idx = l.index(max(l))\n for i in range(3):\n if i != max_idx:\n ans *= l[i]\n print(ans)", "l = list(map(int, input().split()))", "l", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "if l[0] % 2 == 0 or l[1] % 2 == 0 or l[2] % 2 == 0:\n print(0)\nelse:\n ans = 1\n max_idx = l.index(max(l))\n for i in range(3):\n if i != max_idx:\n ans *= l[i]\n print(ans)", "l[0] % 2 == 0 or l[1] % 2 == 0 or l[2] % 2 == 0", "l[0] % 2 == 0 or l[1] % 2 == 0", "l[0] % 2 == 0", "l[0] % 2", "l[0]", "l", "0", "2", "0", "l[1] % 2 == 0", "l[1] % 2", "l[1]", "l", "1", "2", "0", "l[2] % 2 == 0", "l[2] % 2", "l[2]", "l", "2", "2", "0", "print(0)", "print", "0", "ans = 1", "ans", "1", "max_idx = l.index(max(l))", "max_idx", "l.index(max(l))", "l.index", "l", "index", "max(l)", "max", "l", "for i in range(3):\n if i != max_idx:\n ans *= l[i]\n ", "i", "range(3)", "range", "3", "if i != max_idx:\n ans *= l[i]\n ", "i != max_idx", "i", "max_idx", "ans *= l[i]", "ans", "l[i]", "l", "i", "print(ans)", "print", "ans", "l = list(map(int, input().split()))", "list(map(int, input().split()))", "l", "ans *= l[i]", "l[i]", "ans", "max_idx = l.index(max(l))", "l.index(max(l))", "max_idx", "ans = 1", "1", "ans" ]

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

[ [ 70, 2 ], [ 70, 11 ], [ 70, 12 ], [ 59, 18 ], [ 71, 23 ], [ 62, 28 ], [ 64, 35 ], [ 67, 41 ], [ 65, 44 ], [ 47, 46 ], [ 68, 52 ], [ 68, 55 ], [ 70, 59 ], [ 70, 62 ], [ 64, 65 ], [ 67, 68 ], [ 70, 71 ] ]

[ "A, B, C = map(int, input().split())\nif A % 2 == 0 or B % 2 == 0 or C % 2 == 0:\n print(0)\nelse:\n array = [A, B, C]\n sort_array = sorted(array, reverse=True)\n print(sort_array[1] * sort_array[2])", "A, B, C = map(int, input().split())", "A", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "B", "C", "if A % 2 == 0 or B % 2 == 0 or C % 2 == 0:\n print(0)\nelse:\n array = [A, B, C]\n sort_array = sorted(array, reverse=True)\n print(sort_array[1] * sort_array[2])", "A % 2 == 0 or B % 2 == 0 or C % 2 == 0", "A % 2 == 0 or B % 2 == 0", "A % 2 == 0", "A % 2", "A", "2", "0", "B % 2 == 0", "B % 2", "B", "2", "0", "C % 2 == 0", "C % 2", "C", "2", "0", "print(0)", "print", "0", "array = [A, B, C]", "array", "[A, B, C]", "A", "B", "C", "sort_array = sorted(array, reverse=True)", "sort_array", "sorted(array, reverse=True)", "sorted", "array", "reverse=True", "reverse", "True", "print(sort_array[1] * sort_array[2])", "print", "sort_array[1] * sort_array[2]", "sort_array[1]", "sort_array", "1", "sort_array[2]", "sort_array", "2", "A, B, C = map(int, input().split())", "map(int, input().split())", "A", "C = map(int, input().split())", "map(int, input().split())", "C", "array = [A, B, C]", "[A, B, C]", "array", "sort_array = sorted(array, reverse=True)", "sorted(array, reverse=True)", "sort_array", "B, C = map(int, input().split())", "map(int, input().split())", "B" ]

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

[ [ 56, 2 ], [ 56, 11 ], [ 56, 12 ], [ 51, 18 ], [ 54, 23 ], [ 57, 28 ], [ 51, 41 ], [ 54, 42 ], [ 57, 43 ], [ 51, 46 ], [ 54, 47 ], [ 57, 48 ], [ 56, 51 ], [ 56, 54 ], [ 56, 57 ] ]

[ "A, B, C = map(int,input().split())\nif A%2 == 0 or B%2 == 0 or C%2 == 0:\n print(0)\n exit()\nprint(A*B*C//max(A,B,C))", "A, B, C = map(int,input().split())", "A", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "B", "C", "if A%2 == 0 or B%2 == 0 or C%2 == 0:\n print(0)\n exit()", "A%2 == 0 or B%2 == 0 or C%2 == 0", "A%2 == 0 or B%2 == 0", "A%2 == 0", "A%2", "A", "2", "0", "B%2 == 0", "B%2", "B", "2", "0", "C%2 == 0", "C%2", "C", "2", "0", "print(0)", "print", "0", "exit()", "exit", "print(A*B*C//max(A,B,C))", "print", "A*B*C//max(A,B,C)", "A*B*C", "A*B", "A", "B", "C", "max(A,B,C)", "max", "A", "B", "C", "A, B, C = map(int,input().split())", "map(int,input().split())", "A", "B, C = map(int,input().split())", "map(int,input().split())", "B", "C = map(int,input().split())", "map(int,input().split())", "C" ]

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

[ [ 5, 4 ], [ 13, 12 ], [ 4, 15 ], [ 20, 19 ], [ 4, 22 ], [ 4, 29 ], [ 35, 34 ], [ 4, 43 ], [ 4, 46 ], [ 34, 48 ], [ 12, 48 ], [ 4, 52 ], [ 4, 55 ], [ 19, 57 ], [ 59, 59 ], [ 61, 61 ], [ 63, 63 ], [ 68, 67 ], [ 73, 72 ], [ 73, 81 ], [ 73, 82 ], [ 104, 86 ], [ 72, 87 ], [ 81, 88 ], [ 82, 89 ], [ 101, 95 ] ]

[ "def myAnswer(A:int,B:int,C:int) -> int:\n l = sorted([A,B,C])\n red = l[2] // 2\n blue = l[2] // 2\n if(l[2] % 2 == 1):\n red += 1\n return abs(l[0]*l[1]*red - l[0]*l[1]*blue)\n \n\ndef modelAnswer():\n tmp=1\ndef main():\n A,B,C = map(int,input().split())\n print(myAnswer(A,B,C))\nif __name__ == '__main__':\n main()", "def myAnswer(A:int,B:int,C:int) -> int:\n l = sorted([A,B,C])\n red = l[2] // 2\n blue = l[2] // 2\n if(l[2] % 2 == 1):\n red += 1\n return abs(l[0]*l[1]*red - l[0]*l[1]*blue)\n ", "myAnswer", "l = sorted([A,B,C])", "l", "sorted([A,B,C])", "sorted", "[A,B,C]", "A", "B", "C", "red = l[2] // 2", "red", "l[2] // 2", "l[2]", "l", "2", "2", "blue = l[2] // 2", "blue", "l[2] // 2", "l[2]", "l", "2", "2", "if(l[2] % 2 == 1):\n red += 1\n ", "l[2] % 2 == 1", "l[2] % 2", "l[2]", "l", "2", "2", "1", "red += 1", "red", "1", "return abs(l[0]*l[1]*red - l[0]*l[1]*blue)", "abs(l[0]*l[1]*red - l[0]*l[1]*blue)", "abs", "l[0]*l[1]*red - l[0]*l[1]*blue", "l[0]*l[1]*red", "l[0]*l[1]", "l[0]", "l", "0", "l[1]", "l", "1", "red", "l[0]*l[1]*blue", "l[0]*l[1]", "l[0]", "l", "0", "l[1]", "l", "1", "blue", "A:int", "A", "B:int", "B", "C:int", "C", "def modelAnswer():\n tmp=1", "modelAnswer", "tmp=1", "tmp", "1", "def main():\n A,B,C = map(int,input().split())\n print(myAnswer(A,B,C))", "main", "A,B,C = map(int,input().split())", "A", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "B", "C", "print(myAnswer(A,B,C))", "print", "myAnswer(A,B,C)", "myAnswer", "A", "B", "C", "if __name__ == '__main__':\n main()", "__name__ == '__main__'", "__name__", "'__main__'", "main()", "main", "def modelAnswer():\n tmp=1", "def modelAnswer():\n tmp=1", "modelAnswer", "def main():\n A,B,C = map(int,input().split())\n print(myAnswer(A,B,C))", "def main():\n A,B,C = map(int,input().split())\n print(myAnswer(A,B,C))", "main", "def myAnswer(A:int,B:int,C:int) -> int:\n l = sorted([A,B,C])\n red = l[2] // 2\n blue = l[2] // 2\n if(l[2] % 2 == 1):\n red += 1\n return abs(l[0]*l[1]*red - l[0]*l[1]*blue)\n ", "def myAnswer(A:int,B:int,C:int) -> int:\n l = sorted([A,B,C])\n red = l[2] // 2\n blue = l[2] // 2\n if(l[2] % 2 == 1):\n red += 1\n return abs(l[0]*l[1]*red - l[0]*l[1]*blue)\n ", "myAnswer" ]

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

[ [ 79, 4 ], [ 80, 17 ], [ 82, 20 ], [ 80, 22 ], [ 85, 25 ], [ 80, 27 ], [ 88, 30 ], [ 80, 32 ], [ 83, 39 ], [ 86, 44 ], [ 89, 49 ], [ 83, 62 ], [ 86, 63 ], [ 89, 65 ], [ 83, 69 ], [ 86, 70 ], [ 89, 76 ], [ 79, 80 ], [ 82, 83 ], [ 85, 86 ], [ 88, 89 ] ]

[ "import math\ntmp = list(map(int, input().split()))\ntmp.sort()\na = tmp[0]\nb = tmp[1]\nc = tmp[2]\n\nif a % 2 == 0 or b % 2 == 0 or c % 2 == 0:\n print(0)\nelse:\n\n print(abs(a * b * (c // 2) - (a * b * (math.ceil(c / 2)))))", "import math", "math", "tmp = list(map(int, input().split()))", "tmp", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "tmp.sort()", "tmp.sort", "tmp", "sort", "a = tmp[0]", "a", "tmp[0]", "tmp", "0", "b = tmp[1]", "b", "tmp[1]", "tmp", "1", "c = tmp[2]", "c", "tmp[2]", "tmp", "2", "if a % 2 == 0 or b % 2 == 0 or c % 2 == 0:\n print(0)\nelse:\n\n print(abs(a * b * (c // 2) - (a * b * (math.ceil(c / 2)))))", "a % 2 == 0 or b % 2 == 0 or c % 2 == 0", "a % 2 == 0 or b % 2 == 0", "a % 2 == 0", "a % 2", "a", "2", "0", "b % 2 == 0", "b % 2", "b", "2", "0", "c % 2 == 0", "c % 2", "c", "2", "0", "print(0)", "print", "0", "print(abs(a * b * (c // 2) - (a * b * (math.ceil(c / 2)))))", "print", "abs(a * b * (c // 2) - (a * b * (math.ceil(c / 2))))", "abs", "a * b * (c // 2) - (a * b * (math.ceil(c / 2)))", "a * b * (c // 2)", "a * b", "a", "b", "c // 2", "c", "2", "a * b * (math.ceil(c / 2))", "a * b", "a", "b", "math.ceil(c / 2)", "math.ceil", "math", "ceil", "c / 2", "c", "2", "tmp = list(map(int, input().split()))", "list(map(int, input().split()))", "tmp", "a = tmp[0]", "tmp[0]", "a", "b = tmp[1]", "tmp[1]", "b", "c = tmp[2]", "tmp[2]", "c" ]

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

[ [ 101, 2 ], [ 102, 15 ], [ 19, 18 ], [ 102, 26 ], [ 102, 33 ], [ 102, 40 ], [ 98, 51 ], [ 102, 55 ], [ 102, 58 ], [ 102, 61 ], [ 67, 64 ], [ 102, 65 ], [ 102, 69 ], [ 104, 73 ], [ 102, 77 ], [ 102, 80 ], [ 102, 83 ], [ 107, 86 ], [ 99, 88 ], [ 105, 89 ], [ 105, 95 ], [ 108, 96 ], [ 98, 99 ], [ 101, 102 ], [ 104, 105 ], [ 107, 108 ] ]

[ "a = list(map(int,input().split()))\na.sort(reverse = True)\nif a[0] % 2 == 0 or a[1] % 2 == 0 or a[2] % 2 == 0:\n print(0)\n exit(0)\nblock = a[0] * a[1] * a[2]\na[0] = a[0] // 2\nx = a[0] * a[1] * a[2]\ny = block - x\nprint(abs(x - y))", "a = list(map(int,input().split()))", "a", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "a.sort(reverse = True)", "a.sort", "a", "sort", "reverse = True", "reverse", "True", "if a[0] % 2 == 0 or a[1] % 2 == 0 or a[2] % 2 == 0:\n print(0)\n exit(0)", "a[0] % 2 == 0 or a[1] % 2 == 0 or a[2] % 2 == 0", "a[0] % 2 == 0 or a[1] % 2 == 0", "a[0] % 2 == 0", "a[0] % 2", "a[0]", "a", "0", "2", "0", "a[1] % 2 == 0", "a[1] % 2", "a[1]", "a", "1", "2", "0", "a[2] % 2 == 0", "a[2] % 2", "a[2]", "a", "2", "2", "0", "print(0)", "print", "0", "exit(0)", "exit", "0", "block = a[0] * a[1] * a[2]", "block", "a[0] * a[1] * a[2]", "a[0] * a[1]", "a[0]", "a", "0", "a[1]", "a", "1", "a[2]", "a", "2", "a[0] = a[0] // 2", "a[0]", "a", "0", "a[0] // 2", "a[0]", "a", "0", "2", "x = a[0] * a[1] * a[2]", "x", "a[0] * a[1] * a[2]", "a[0] * a[1]", "a[0]", "a", "0", "a[1]", "a", "1", "a[2]", "a", "2", "y = block - x", "y", "block - x", "block", "x", "print(abs(x - y))", "print", "abs(x - y)", "abs", "x - y", "x", "y", "block = a[0] * a[1] * a[2]", "a[0] * a[1] * a[2]", "block", "a = list(map(int,input().split()))", "list(map(int,input().split()))", "a", "x = a[0] * a[1] * a[2]", "a[0] * a[1] * a[2]", "x", "y = block - x", "block - x", "y" ]

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

[ [ 155, 4 ], [ 155, 13 ], [ 155, 14 ], [ 113, 16 ], [ 123, 18 ], [ 129, 19 ], [ 149, 21 ], [ 156, 27 ], [ 152, 30 ], [ 156, 32 ], [ 150, 33 ], [ 140, 35 ], [ 114, 40 ], [ 150, 41 ], [ 114, 43 ], [ 153, 44 ], [ 125, 46 ], [ 123, 48 ], [ 156, 49 ], [ 137, 51 ], [ 129, 57 ], [ 134, 60 ], [ 129, 62 ], [ 138, 63 ], [ 116, 65 ], [ 126, 70 ], [ 138, 71 ], [ 126, 73 ], [ 135, 74 ], [ 143, 76 ], [ 129, 78 ], [ 156, 79 ], [ 119, 81 ], [ 123, 87 ], [ 146, 90 ], [ 123, 92 ], [ 120, 93 ], [ 131, 95 ], [ 144, 100 ], [ 120, 101 ], [ 144, 103 ], [ 147, 104 ], [ 141, 109 ], [ 117, 110 ], [ 132, 111 ], [ 113, 114 ], [ 116, 117 ], [ 119, 120 ], [ 155, 123 ], [ 125, 126 ], [ 155, 129 ], [ 131, 132 ], [ 134, 135 ], [ 137, 138 ], [ 140, 141 ], [ 143, 144 ], [ 146, 147 ], [ 149, 150 ], [ 152, 153 ], [ 155, 156 ] ]

[ "import math\nA,B,C = map(int, input().split())\n\n#A-B Partern\nbase1 = A*B\npart1_a = math.ceil(C/2)\npart1_b = C-part1_a \nans1 = abs((base1*part1_a)-(base1*part1_b))\n\n#A-C Partern\nbase2 = A*C\npart2_a = math.ceil(B/2)\npart2_b = B - part2_a \nans2 = abs((base2*part2_a)-(base2*part2_b))\n\n#B-C Partern\nbase3 = B*C\npart3_a = math.ceil(A/2)\npart3_b = A - part3_a \nans3 = abs((base3*part3_a)-(base3*part3_b))\n\nprint(min(ans1,ans2,ans3))", "import math", "math", "A,B,C = map(int, input().split())", "A", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "B", "C", "base1 = A*B", "base1", "A*B", "A", "B", "part1_a = math.ceil(C/2)", "part1_a", "math.ceil(C/2)", "math.ceil", "math", "ceil", "C/2", "C", "2", "part1_b = C-part1_a", "part1_b", "C-part1_a", "C", "part1_a", "ans1 = abs((base1*part1_a)-(base1*part1_b))", "ans1", "abs((base1*part1_a)-(base1*part1_b))", "abs", "(base1*part1_a)-(base1*part1_b)", "base1*part1_a", "base1", "part1_a", "base1*part1_b", "base1", "part1_b", "base2 = A*C", "base2", "A*C", "A", "C", "part2_a = math.ceil(B/2)", "part2_a", "math.ceil(B/2)", "math.ceil", "math", "ceil", "B/2", "B", "2", "part2_b = B - part2_a", "part2_b", "B - part2_a", "B", "part2_a", "ans2 = abs((base2*part2_a)-(base2*part2_b))", "ans2", "abs((base2*part2_a)-(base2*part2_b))", "abs", "(base2*part2_a)-(base2*part2_b)", "base2*part2_a", "base2", "part2_a", "base2*part2_b", "base2", "part2_b", "base3 = B*C", "base3", "B*C", "B", "C", "part3_a = math.ceil(A/2)", "part3_a", "math.ceil(A/2)", "math.ceil", "math", "ceil", "A/2", "A", "2", "part3_b = A - part3_a", "part3_b", "A - part3_a", "A", "part3_a", "ans3 = abs((base3*part3_a)-(base3*part3_b))", "ans3", "abs((base3*part3_a)-(base3*part3_b))", "abs", "(base3*part3_a)-(base3*part3_b)", "base3*part3_a", "base3", "part3_a", "base3*part3_b", "base3", "part3_b", "print(min(ans1,ans2,ans3))", "print", "min(ans1,ans2,ans3)", "min", "ans1", "ans2", "ans3", "base1 = A*B", "A*B", "base1", "ans2 = abs((base2*part2_a)-(base2*part2_b))", "abs((base2*part2_a)-(base2*part2_b))", "ans2", "part3_a = math.ceil(A/2)", "math.ceil(A/2)", "part3_a", "A,B,C = map(int, input().split())", "map(int, input().split())", "A", "base2 = A*C", "A*C", "base2", "B,C = map(int, input().split())", "map(int, input().split())", "B", "ans3 = abs((base3*part3_a)-(base3*part3_b))", "abs((base3*part3_a)-(base3*part3_b))", "ans3", "part2_b = B - part2_a", "B - part2_a", "part2_b", "part2_a = math.ceil(B/2)", "math.ceil(B/2)", "part2_a", "ans1 = abs((base1*part1_a)-(base1*part1_b))", "abs((base1*part1_a)-(base1*part1_b))", "ans1", "base3 = B*C", "B*C", "base3", "part3_b = A - part3_a", "A - part3_a", "part3_b", "part1_a = math.ceil(C/2)", "math.ceil(C/2)", "part1_a", "part1_b = C-part1_a", "C-part1_a", "part1_b", "C = map(int, input().split())", "map(int, input().split())", "C" ]

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

[ [ 102, 2 ], [ 102, 11 ], [ 102, 12 ], [ 88, 18 ], [ 103, 23 ], [ 100, 28 ], [ 96, 35 ], [ 88, 41 ], [ 88, 45 ], [ 103, 47 ], [ 100, 48 ], [ 90, 50 ], [ 103, 56 ], [ 103, 60 ], [ 88, 62 ], [ 100, 63 ], [ 93, 65 ], [ 100, 71 ], [ 100, 75 ], [ 88, 77 ], [ 103, 78 ], [ 97, 83 ], [ 91, 84 ], [ 94, 85 ], [ 102, 88 ], [ 90, 91 ], [ 93, 94 ], [ 96, 97 ], [ 102, 100 ], [ 102, 103 ] ]

[ "# -*- coding: utf-8 -*-\na, b, c = map(int,input().split())\n\nif a % 2 == 0 or b % 2 == 0 or c % 2 == 0:\n print(0)\nelse:\n tmp1 = ((a//2+1) - a//2) * b * c\n tmp2 = ((b//2+1) - b//2) * a * c\n tmp3 = ((c//2+1) - c//2) * a * b\n print(min(tmp1, tmp2, tmp3))", "a, b, c = map(int,input().split())", "a", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "c", "if a % 2 == 0 or b % 2 == 0 or c % 2 == 0:\n print(0)\nelse:\n tmp1 = ((a//2+1) - a//2) * b * c\n tmp2 = ((b//2+1) - b//2) * a * c\n tmp3 = ((c//2+1) - c//2) * a * b\n print(min(tmp1, tmp2, tmp3))", "a % 2 == 0 or b % 2 == 0 or c % 2 == 0", "a % 2 == 0 or b % 2 == 0", "a % 2 == 0", "a % 2", "a", "2", "0", "b % 2 == 0", "b % 2", "b", "2", "0", "c % 2 == 0", "c % 2", "c", "2", "0", "print(0)", "print", "0", "tmp1 = ((a//2+1) - a//2) * b * c", "tmp1", "((a//2+1) - a//2) * b * c", "((a//2+1) - a//2) * b", "(a//2+1) - a//2", "a//2+1", "a//2", "a", "2", "1", "a//2", "a", "2", "b", "c", "tmp2 = ((b//2+1) - b//2) * a * c", "tmp2", "((b//2+1) - b//2) * a * c", "((b//2+1) - b//2) * a", "(b//2+1) - b//2", "b//2+1", "b//2", "b", "2", "1", "b//2", "b", "2", "a", "c", "tmp3 = ((c//2+1) - c//2) * a * b", "tmp3", "((c//2+1) - c//2) * a * b", "((c//2+1) - c//2) * a", "(c//2+1) - c//2", "c//2+1", "c//2", "c", "2", "1", "c//2", "c", "2", "a", "b", "print(min(tmp1, tmp2, tmp3))", "print", "min(tmp1, tmp2, tmp3)", "min", "tmp1", "tmp2", "tmp3", "a, b, c = map(int,input().split())", "map(int,input().split())", "a", "tmp2 = ((b//2+1) - b//2) * a * c", "((b//2+1) - b//2) * a * c", "tmp2", "tmp3 = ((c//2+1) - c//2) * a * b", "((c//2+1) - c//2) * a * b", "tmp3", "tmp1 = ((a//2+1) - a//2) * b * c", "((a//2+1) - a//2) * b * c", "tmp1", "c = map(int,input().split())", "map(int,input().split())", "c", "b, c = map(int,input().split())", "map(int,input().split())", "b" ]

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

[ [ 66, 4 ], [ 66, 13 ], [ 66, 14 ], [ 67, 20 ], [ 58, 25 ], [ 64, 30 ], [ 60, 41 ], [ 67, 45 ], [ 58, 46 ], [ 58, 48 ], [ 64, 49 ], [ 64, 51 ], [ 67, 52 ], [ 61, 55 ], [ 66, 58 ], [ 60, 61 ], [ 66, 64 ], [ 66, 67 ] ]

[ "import sys\na,b,c=map(int,input().split())\nif a%2==0 or b%2==0 or c%2==0:\n print(0)\n sys.exit()\nans=min(a*b,b*c,c*a)\nprint(ans)", "import sys", "sys", "a,b,c=map(int,input().split())", "a", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "c", "if a%2==0 or b%2==0 or c%2==0:\n print(0)\n sys.exit()", "a%2==0 or b%2==0 or c%2==0", "a%2==0 or b%2==0", "a%2==0", "a%2", "a", "2", "0", "b%2==0", "b%2", "b", "2", "0", "c%2==0", "c%2", "c", "2", "0", "print(0)", "print", "0", "sys.exit()", "sys.exit", "sys", "exit", "ans=min(a*b,b*c,c*a)", "ans", "min(a*b,b*c,c*a)", "min", "a*b", "a", "b", "b*c", "b", "c", "c*a", "c", "a", "print(ans)", "print", "ans", "b,c=map(int,input().split())", "map(int,input().split())", "b", "ans=min(a*b,b*c,c*a)", "min(a*b,b*c,c*a)", "ans", "c=map(int,input().split())", "map(int,input().split())", "c", "a,b,c=map(int,input().split())", "map(int,input().split())", "a" ]

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

[ [ 42, 2 ], [ 42, 13 ], [ 42, 14 ], [ 37, 22 ], [ 40, 25 ], [ 43, 28 ], [ 37, 32 ], [ 40, 33 ], [ 42, 37 ], [ 42, 40 ], [ 42, 43 ] ]

[ "A,B,C=sorted(map(int,input().split()))\nprint(A*B if A%2==B%2==C%2==1 else 0)", "A,B,C=sorted(map(int,input().split()))", "A", "sorted(map(int,input().split()))", "sorted", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "B", "C", "print(A*B if A%2==B%2==C%2==1 else 0)", "print", "A*B if A%2==B%2==C%2==1 else 0", "A%2==B%2==C%2==1", "A%2==B%2==C%2", "A%2==B%2", "A%2", "A", "2", "B%2", "B", "2", "C%2", "C", "2", "1", "A*B", "A", "B", "0", "A,B,C=sorted(map(int,input().split()))", "sorted(map(int,input().split()))", "A", "B,C=sorted(map(int,input().split()))", "sorted(map(int,input().split()))", "B", "C=sorted(map(int,input().split()))", "sorted(map(int,input().split()))", "C" ]

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

[ [ 80, 3 ], [ 83, 16 ], [ 77, 31 ], [ 81, 33 ], [ 77, 34 ], [ 77, 35 ], [ 75, 41 ], [ 72, 46 ], [ 78, 51 ], [ 75, 59 ], [ 72, 60 ], [ 72, 62 ], [ 78, 63 ], [ 78, 65 ], [ 75, 66 ], [ 77, 72 ], [ 77, 75 ], [ 77, 78 ], [ 80, 81 ], [ 83, 84 ] ]

[ "from sys import stdin\nnii=lambda:map(int,stdin.readline().split())\nlnii=lambda:list(map(int,stdin.readline().split()))\n\na,b,c=nii()\n\nif a%2==1 and b%2==1 and c%2==1:\n print(min(a*b,b*c,c*a))\nelse:\n print(0)", "from sys import stdin", "nii=lambda:map(int,stdin.readline().split())", "nii", "lambda:map(int,stdin.readline().split())", "map(int,stdin.readline().split())", "map", "int", "stdin.readline().split()", "stdin.readline().split", "stdin.readline()", "stdin.readline", "stdin", "readline", "split", "lnii=lambda:list(map(int,stdin.readline().split()))", "lnii", "lambda:list(map(int,stdin.readline().split()))", "list(map(int,stdin.readline().split()))", "list", "map(int,stdin.readline().split())", "map", "int", "stdin.readline().split()", "stdin.readline().split", "stdin.readline()", "stdin.readline", "stdin", "readline", "split", "a,b,c=nii()", "a", "nii()", "nii", "b", "c", "if a%2==1 and b%2==1 and c%2==1:\n print(min(a*b,b*c,c*a))\nelse:\n print(0)", "a%2==1 and b%2==1 and c%2==1", "a%2==1 and b%2==1", "a%2==1", "a%2", "a", "2", "1", "b%2==1", "b%2", "b", "2", "1", "c%2==1", "c%2", "c", "2", "1", "print(min(a*b,b*c,c*a))", "print", "min(a*b,b*c,c*a)", "min", "a*b", "a", "b", "b*c", "b", "c", "c*a", "c", "a", "print(0)", "print", "0", "b,c=nii()", "nii()", "b", "a,b,c=nii()", "nii()", "a", "c=nii()", "nii()", "c", "nii=lambda:map(int,stdin.readline().split())", "lambda:map(int,stdin.readline().split())", "nii", "lnii=lambda:list(map(int,stdin.readline().split()))", "lambda:list(map(int,stdin.readline().split()))", "lnii" ]

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

[ [ 85, 4 ], [ 88, 26 ], [ 91, 39 ], [ 86, 46 ], [ 91, 48 ], [ 91, 49 ], [ 94, 51 ], [ 92, 56 ], [ 80, 57 ], [ 83, 59 ], [ 92, 63 ], [ 80, 65 ], [ 83, 67 ], [ 92, 71 ], [ 80, 73 ], [ 83, 74 ], [ 95, 77 ], [ 91, 80 ], [ 91, 83 ], [ 85, 86 ], [ 88, 89 ], [ 91, 92 ], [ 94, 95 ] ]

[ "import sys\ninput = lambda : sys.stdin.readline().rstrip()\nsys.setrecursionlimit(max(1000, 10**9))\nwrite = lambda x: sys.stdout.write(x+\"\\n\")\n\n\na,b,c = map(int, input().split())\nans = min(a*b*(c%2), a*(b%2)*c, (a%2*b*c))\nprint(ans)", "import sys", "sys", "input = lambda : sys.stdin.readline().rstrip()", "input", "lambda : sys.stdin.readline().rstrip()", "sys.stdin.readline().rstrip()", "sys.stdin.readline().rstrip", "sys.stdin.readline()", "sys.stdin.readline", "sys.stdin", "sys", "stdin", "readline", "rstrip", "sys.setrecursionlimit(max(1000, 10**9))", "sys.setrecursionlimit", "sys", "setrecursionlimit", "max(1000, 10**9)", "max", "1000", "10**9", "10", "9", "write = lambda x: sys.stdout.write(x+\"\\n\")", "write", "lambda x: sys.stdout.write(x+\"\\n\")", "sys.stdout.write(x+\"\\n\")", "sys.stdout.write", "sys.stdout", "sys", "stdout", "write", "x+\"\\n\"", "x", "\"\\n\"", "x", "a,b,c = map(int, input().split())", "a", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "c", "ans = min(a*b*(c%2), a*(b%2)*c, (a%2*b*c))", "ans", "min(a*b*(c%2), a*(b%2)*c, (a%2*b*c))", "min", "a*b*(c%2)", "a*b", "a", "b", "c%2", "c", "2", "a*(b%2)*c", "a*(b%2)", "a", "b%2", "b", "2", "c", "a%2*b*c", "a%2*b", "a%2", "a", "2", "b", "c", "print(ans)", "print", "ans", "b,c = map(int, input().split())", "map(int, input().split())", "b", "c = map(int, input().split())", "map(int, input().split())", "c", "input = lambda : sys.stdin.readline().rstrip()", "lambda : sys.stdin.readline().rstrip()", "input", "write = lambda x: sys.stdout.write(x+\"\\n\")", "lambda x: sys.stdout.write(x+\"\\n\")", "write", "a,b,c = map(int, input().split())", "map(int, input().split())", "a", "ans = min(a*b*(c%2), a*(b%2)*c, (a%2*b*c))", "min(a*b*(c%2), a*(b%2)*c, (a%2*b*c))", "ans" ]

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

[ [ 52, 2 ], [ 52, 11 ], [ 52, 12 ], [ 53, 20 ], [ 50, 25 ], [ 47, 30 ], [ 53, 36 ], [ 50, 37 ], [ 50, 39 ], [ 47, 40 ], [ 47, 42 ], [ 53, 43 ], [ 52, 47 ], [ 52, 50 ], [ 52, 53 ] ]

[ "a, b, c = map(int, input().split())\nprint(min(a * b, b * c, c * a) if a % 2 != 0 and b % 2 != 0 and c % 2 != 0 else 0)", "a, b, c = map(int, input().split())", "a", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "c", "print(min(a * b, b * c, c * a) if a % 2 != 0 and b % 2 != 0 and c % 2 != 0 else 0)", "print", "min(a * b, b * c, c * a) if a % 2 != 0 and b % 2 != 0 and c % 2 != 0 else 0", "a % 2 != 0 and b % 2 != 0 and c % 2 != 0", "a % 2 != 0 and b % 2 != 0", "a % 2 != 0", "a % 2", "a", "2", "0", "b % 2 != 0", "b % 2", "b", "2", "0", "c % 2 != 0", "c % 2", "c", "2", "0", "min(a * b, b * c, c * a)", "min", "a * b", "a", "b", "b * c", "b", "c", "c * a", "c", "a", "0", "c = map(int, input().split())", "map(int, input().split())", "c", "b, c = map(int, input().split())", "map(int, input().split())", "b", "a, b, c = map(int, input().split())", "map(int, input().split())", "a" ]

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

[ [ 54, 2 ], [ 54, 11 ], [ 54, 12 ], [ 52, 18 ], [ 55, 23 ], [ 49, 28 ], [ 52, 36 ], [ 55, 37 ], [ 55, 39 ], [ 49, 40 ], [ 49, 42 ], [ 52, 43 ], [ 54, 49 ], [ 54, 52 ], [ 54, 55 ] ]

[ "A,B,C = map(int,input().split())\nif A % 2 == 1 and B % 2 == 1 and C % 2 == 1:\n print(min(A*B,B*C,C*A))\nelse:\n print(0)", "A,B,C = map(int,input().split())", "A", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "B", "C", "if A % 2 == 1 and B % 2 == 1 and C % 2 == 1:\n print(min(A*B,B*C,C*A))\nelse:\n print(0)", "A % 2 == 1 and B % 2 == 1 and C % 2 == 1", "A % 2 == 1 and B % 2 == 1", "A % 2 == 1", "A % 2", "A", "2", "1", "B % 2 == 1", "B % 2", "B", "2", "1", "C % 2 == 1", "C % 2", "C", "2", "1", "print(min(A*B,B*C,C*A))", "print", "min(A*B,B*C,C*A)", "min", "A*B", "A", "B", "B*C", "B", "C", "C*A", "C", "A", "print(0)", "print", "0", "C = map(int,input().split())", "map(int,input().split())", "C", "A,B,C = map(int,input().split())", "map(int,input().split())", "A", "B,C = map(int,input().split())", "map(int,input().split())", "B" ]

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

[ [ 75, 2 ], [ 75, 11 ], [ 75, 12 ], [ 78, 14 ], [ 76, 19 ], [ 67, 20 ], [ 70, 21 ], [ 60, 23 ], [ 76, 28 ], [ 67, 29 ], [ 70, 30 ], [ 63, 32 ], [ 76, 37 ], [ 67, 38 ], [ 70, 39 ], [ 79, 40 ], [ 61, 41 ], [ 72, 43 ], [ 61, 47 ], [ 79, 52 ], [ 64, 53 ], [ 73, 58 ], [ 60, 61 ], [ 63, 64 ], [ 75, 67 ], [ 75, 70 ], [ 72, 73 ], [ 75, 76 ], [ 78, 79 ] ]

[ "a, b, c = map(int, input().split())\n\nmi = min(min(a, b), c)\nma = max(max(a, b), c)\nr = (a + b + c) - mi - ma\n\nans = (mi * r) * 1 if ma % 2 == 1 else 0\nprint(ans)", "a, b, c = map(int, input().split())", "a", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "c", "mi = min(min(a, b), c)", "mi", "min(min(a, b), c)", "min", "min(a, b)", "min", "a", "b", "c", "ma = max(max(a, b), c)", "ma", "max(max(a, b), c)", "max", "max(a, b)", "max", "a", "b", "c", "r = (a + b + c) - mi - ma", "r", "(a + b + c) - mi - ma", "(a + b + c) - mi", "a + b + c", "a + b", "a", "b", "c", "mi", "ma", "ans = (mi * r) * 1 if ma % 2 == 1 else 0", "ans", "(mi * r) * 1 if ma % 2 == 1 else 0", "ma % 2 == 1", "ma % 2", "ma", "2", "1", "(mi * r) * 1", "mi * r", "mi", "r", "1", "0", "print(ans)", "print", "ans", "ma = max(max(a, b), c)", "max(max(a, b), c)", "ma", "r = (a + b + c) - mi - ma", "(a + b + c) - mi - ma", "r", "b, c = map(int, input().split())", "map(int, input().split())", "b", "c = map(int, input().split())", "map(int, input().split())", "c", "ans = (mi * r) * 1 if ma % 2 == 1 else 0", "(mi * r) * 1 if ma % 2 == 1 else 0", "ans", "a, b, c = map(int, input().split())", "map(int, input().split())", "a", "mi = min(min(a, b), c)", "min(min(a, b), c)", "mi" ]

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

[ [ 5, 4 ], [ 5, 13 ], [ 5, 14 ], [ 17, 16 ], [ 4, 19 ], [ 13, 20 ], [ 14, 21 ], [ 24, 23 ], [ 16, 26 ], [ 13, 31 ], [ 14, 32 ], [ 4, 35 ], [ 4, 38 ], [ 4, 40 ], [ 44, 43 ], [ 23, 46 ], [ 16, 46 ], [ 4, 51 ], [ 14, 52 ], [ 13, 55 ], [ 13, 58 ], [ 13, 60 ], [ 64, 63 ], [ 43, 66 ], [ 23, 66 ], [ 16, 66 ], [ 13, 71 ], [ 4, 72 ], [ 14, 75 ], [ 14, 78 ], [ 14, 80 ], [ 63, 84 ], [ 43, 84 ], [ 23, 84 ], [ 16, 84 ], [ 93, 90 ] ]

[ "def main():\n\ta,b , c = map(int , input().split())\n\tans = a*b*c\n\tans = min(ans, abs(b*c*((a//2)-(a-(a//2)))))\n\tans = min(ans, abs(a*c*((b//2)-(b-(b//2)))))\n\tans = min(ans, abs(b*a*((c//2)-(c-(c//2)))))\n\tprint(ans)\nif __name__==\"__main__\":\n\tmain()", "def main():\n\ta,b , c = map(int , input().split())\n\tans = a*b*c\n\tans = min(ans, abs(b*c*((a//2)-(a-(a//2)))))\n\tans = min(ans, abs(a*c*((b//2)-(b-(b//2)))))\n\tans = min(ans, abs(b*a*((c//2)-(c-(c//2)))))\n\tprint(ans)", "main", "a,b , c = map(int , input().split())", "a", "map(int , input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "c", "ans = a*b*c", "ans", "a*b*c", "a*b", "a", "b", "c", "ans = min(ans, abs(b*c*((a//2)-(a-(a//2)))))", "ans", "min(ans, abs(b*c*((a//2)-(a-(a//2)))))", "min", "ans", "abs(b*c*((a//2)-(a-(a//2))))", "abs", "b*c*((a//2)-(a-(a//2)))", "b*c", "b", "c", "(a//2)-(a-(a//2))", "a//2", "a", "2", "a-(a//2)", "a", "a//2", "a", "2", "ans = min(ans, abs(a*c*((b//2)-(b-(b//2)))))", "ans", "min(ans, abs(a*c*((b//2)-(b-(b//2)))))", "min", "ans", "abs(a*c*((b//2)-(b-(b//2))))", "abs", "a*c*((b//2)-(b-(b//2)))", "a*c", "a", "c", "(b//2)-(b-(b//2))", "b//2", "b", "2", "b-(b//2)", "b", "b//2", "b", "2", "ans = min(ans, abs(b*a*((c//2)-(c-(c//2)))))", "ans", "min(ans, abs(b*a*((c//2)-(c-(c//2)))))", "min", "ans", "abs(b*a*((c//2)-(c-(c//2))))", "abs", "b*a*((c//2)-(c-(c//2)))", "b*a", "b", "a", "(c//2)-(c-(c//2))", "c//2", "c", "2", "c-(c//2)", "c", "c//2", "c", "2", "print(ans)", "print", "ans", "if __name__==\"__main__\":\n\tmain()", "__name__==\"__main__\"", "__name__", "\"__main__\"", "main()", "main", "def main():\n\ta,b , c = map(int , input().split())\n\tans = a*b*c\n\tans = min(ans, abs(b*c*((a//2)-(a-(a//2)))))\n\tans = min(ans, abs(a*c*((b//2)-(b-(b//2)))))\n\tans = min(ans, abs(b*a*((c//2)-(c-(c//2)))))\n\tprint(ans)", "def main():\n\ta,b , c = map(int , input().split())\n\tans = a*b*c\n\tans = min(ans, abs(b*c*((a//2)-(a-(a//2)))))\n\tans = min(ans, abs(a*c*((b//2)-(b-(b//2)))))\n\tans = min(ans, abs(b*a*((c//2)-(c-(c//2)))))\n\tprint(ans)", "main" ]

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

[ [ 39, 2 ], [ 40, 15 ], [ 36, 18 ], [ 40, 21 ], [ 40, 24 ], [ 37, 29 ], [ 40, 32 ], [ 36, 37 ], [ 39, 40 ] ]

[ "d = list(map(int, input().split()))\nd.sort()\ns = d[0]*d[1]\nprint(s*(d[2]%2))", "d = list(map(int, input().split()))", "d", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "d.sort()", "d.sort", "d", "sort", "s = d[0]*d[1]", "s", "d[0]*d[1]", "d[0]", "d", "0", "d[1]", "d", "1", "print(s*(d[2]%2))", "print", "s*(d[2]%2)", "s", "d[2]%2", "d[2]", "d", "2", "2", "s = d[0]*d[1]", "d[0]*d[1]", "s", "d = list(map(int, input().split()))", "list(map(int, input().split()))", "d" ]

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

[ [ 54, 2 ], [ 54, 11 ], [ 54, 12 ], [ 49, 18 ], [ 52, 23 ], [ 55, 28 ], [ 49, 36 ], [ 52, 37 ], [ 52, 39 ], [ 55, 40 ], [ 55, 42 ], [ 49, 43 ], [ 54, 49 ], [ 54, 52 ], [ 54, 55 ] ]

[ "#AtCoder Grand Contest 004 a\na,b,c=map(int,input().split())\nif a%2==1 and b%2==1 and c%2==1:\n print(min(a*b,b*c,c*a))\nelse:\n print(0)", "a,b,c=map(int,input().split())", "a", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "c", "if a%2==1 and b%2==1 and c%2==1:\n print(min(a*b,b*c,c*a))\nelse:\n print(0)", "a%2==1 and b%2==1 and c%2==1", "a%2==1 and b%2==1", "a%2==1", "a%2", "a", "2", "1", "b%2==1", "b%2", "b", "2", "1", "c%2==1", "c%2", "c", "2", "1", "print(min(a*b,b*c,c*a))", "print", "min(a*b,b*c,c*a)", "min", "a*b", "a", "b", "b*c", "b", "c", "c*a", "c", "a", "print(0)", "print", "0", "a,b,c=map(int,input().split())", "map(int,input().split())", "a", "b,c=map(int,input().split())", "map(int,input().split())", "b", "c=map(int,input().split())", "map(int,input().split())", "c" ]

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

[ [ 114, 2 ], [ 114, 11 ], [ 114, 12 ], [ 105, 14 ], [ 103, 17 ], [ 109, 18 ], [ 115, 19 ], [ 96, 21 ], [ 106, 24 ], [ 103, 30 ], [ 109, 31 ], [ 115, 33 ], [ 103, 37 ], [ 109, 38 ], [ 115, 40 ], [ 115, 42 ], [ 111, 45 ], [ 97, 48 ], [ 106, 48 ], [ 103, 54 ], [ 109, 56 ], [ 115, 58 ], [ 103, 61 ], [ 109, 63 ], [ 109, 65 ], [ 115, 67 ], [ 99, 69 ], [ 112, 72 ], [ 97, 72 ], [ 106, 72 ], [ 103, 79 ], [ 109, 81 ], [ 115, 82 ], [ 103, 86 ], [ 103, 88 ], [ 109, 90 ], [ 115, 91 ], [ 100, 94 ], [ 112, 94 ], [ 97, 94 ], [ 106, 94 ], [ 96, 97 ], [ 99, 100 ], [ 114, 103 ], [ 105, 106 ], [ 114, 109 ], [ 111, 112 ], [ 114, 115 ] ]

[ "a,b,c = map(int, input().split())\n\nres = a*b*c\nres = min(res, abs(a*b*(c//2) - a*b*(c-c//2)))\nres = min(res, abs(a*(b//2)*c - a*(b-b//2)*c))\nres = min(res, abs((a//2)*b*c - (a-a//2)*b*c))\nprint(res)", "a,b,c = map(int, input().split())", "a", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "c", "res = a*b*c", "res", "a*b*c", "a*b", "a", "b", "c", "res = min(res, abs(a*b*(c//2) - a*b*(c-c//2)))", "res", "min(res, abs(a*b*(c//2) - a*b*(c-c//2)))", "min", "res", "abs(a*b*(c//2) - a*b*(c-c//2))", "abs", "a*b*(c//2) - a*b*(c-c//2)", "a*b*(c//2)", "a*b", "a", "b", "c//2", "c", "2", "a*b*(c-c//2)", "a*b", "a", "b", "c-c//2", "c", "c//2", "c", "2", "res = min(res, abs(a*(b//2)*c - a*(b-b//2)*c))", "res", "min(res, abs(a*(b//2)*c - a*(b-b//2)*c))", "min", "res", "abs(a*(b//2)*c - a*(b-b//2)*c)", "abs", "a*(b//2)*c - a*(b-b//2)*c", "a*(b//2)*c", "a*(b//2)", "a", "b//2", "b", "2", "c", "a*(b-b//2)*c", "a*(b-b//2)", "a", "b-b//2", "b", "b//2", "b", "2", "c", "res = min(res, abs((a//2)*b*c - (a-a//2)*b*c))", "res", "min(res, abs((a//2)*b*c - (a-a//2)*b*c))", "min", "res", "abs((a//2)*b*c - (a-a//2)*b*c)", "abs", "(a//2)*b*c - (a-a//2)*b*c", "(a//2)*b*c", "(a//2)*b", "a//2", "a", "2", "b", "c", "(a-a//2)*b*c", "(a-a//2)*b", "a-a//2", "a", "a//2", "a", "2", "b", "c", "print(res)", "print", "res", "res = min(res, abs(a*b*(c//2) - a*b*(c-c//2)))", "min(res, abs(a*b*(c//2) - a*b*(c-c//2)))", "res", "res = min(res, abs((a//2)*b*c - (a-a//2)*b*c))", "min(res, abs((a//2)*b*c - (a-a//2)*b*c))", "res", "a,b,c = map(int, input().split())", "map(int, input().split())", "a", "res = a*b*c", "a*b*c", "res", "b,c = map(int, input().split())", "map(int, input().split())", "b", "res = min(res, abs(a*(b//2)*c - a*(b-b//2)*c))", "min(res, abs(a*(b//2)*c - a*(b-b//2)*c))", "res", "c = map(int, input().split())", "map(int, input().split())", "c" ]

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

[ [ 58, 4 ], [ 67, 18 ], [ 59, 27 ], [ 67, 29 ], [ 67, 30 ], [ 65, 36 ], [ 68, 41 ], [ 62, 46 ], [ 65, 55 ], [ 68, 56 ], [ 58, 59 ], [ 67, 62 ], [ 67, 65 ], [ 67, 68 ] ]

[ "import sys\ninput = sys.stdin.readline\nsys.setrecursionlimit(10 ** 7)\n\na, b, c = sorted(map(int, input().split()))\n\nif a % 2 == 0 or b % 2 == 0 or c % 2 == 0:\n print(0)\nelse:\n print(a * b)", "import sys", "sys", "input = sys.stdin.readline", "input", "sys.stdin.readline", "sys.stdin", "sys", "stdin", "readline", "sys.setrecursionlimit(10 ** 7)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "10 ** 7", "10", "7", "a, b, c = sorted(map(int, input().split()))", "a", "sorted(map(int, input().split()))", "sorted", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "c", "if a % 2 == 0 or b % 2 == 0 or c % 2 == 0:\n print(0)\nelse:\n print(a * b)", "a % 2 == 0 or b % 2 == 0 or c % 2 == 0", "a % 2 == 0 or b % 2 == 0", "a % 2 == 0", "a % 2", "a", "2", "0", "b % 2 == 0", "b % 2", "b", "2", "0", "c % 2 == 0", "c % 2", "c", "2", "0", "print(0)", "print", "0", "print(a * b)", "print", "a * b", "a", "b", "input = sys.stdin.readline", "sys.stdin.readline", "input", "c = sorted(map(int, input().split()))", "sorted(map(int, input().split()))", "c", "a, b, c = sorted(map(int, input().split()))", "sorted(map(int, input().split()))", "a", "b, c = sorted(map(int, input().split()))", "sorted(map(int, input().split()))", "b" ]

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

[ [ 83, 2 ], [ 77, 14 ], [ 20, 19 ], [ 80, 24 ], [ 84, 26 ], [ 19, 28 ], [ 89, 30 ], [ 84, 32 ], [ 19, 35 ], [ 92, 38 ], [ 84, 40 ], [ 19, 43 ], [ 86, 47 ], [ 93, 49 ], [ 74, 52 ], [ 93, 54 ], [ 87, 55 ], [ 95, 57 ], [ 78, 60 ], [ 96, 60 ], [ 87, 66 ], [ 75, 67 ], [ 81, 68 ], [ 90, 69 ], [ 96, 72 ], [ 78, 72 ], [ 74, 75 ], [ 77, 78 ], [ 80, 81 ], [ 83, 84 ], [ 86, 87 ], [ 89, 90 ], [ 92, 93 ], [ 95, 96 ] ]

[ "Z = list(map(int, input().split()))\nans = 10 ** 18\nfor i in range(3):\n a, b, c = Z[i % 3], Z[(i + 1) % 3], Z[(i + 2) % 3]\n # print(a, b, c)\n left = c // 2\n right = c - left\n ans = min(ans, abs(left - right) * a * b)\n\nprint(ans)", "Z = list(map(int, input().split()))", "Z", "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(3):\n a, b, c = Z[i % 3], Z[(i + 1) % 3], Z[(i + 2) % 3]\n # print(a, b, c)\n left = c // 2\n right = c - left\n ans = min(ans, abs(left - right) * a * b)", "i", "range(3)", "range", "3", "a, b, c = Z[i % 3], Z[(i + 1) % 3], Z[(i + 2) % 3]", "a", "Z[i % 3]", "Z", "i % 3", "i", "3", "b", "Z[(i + 1) % 3]", "Z", "(i + 1) % 3", "i + 1", "i", "1", "3", "c", "Z[(i + 2) % 3]", "Z", "(i + 2) % 3", "i + 2", "i", "2", "3", "left = c // 2", "left", "c // 2", "c", "2", "right = c - left", "right", "c - left", "c", "left", "ans = min(ans, abs(left - right) * a * b)", "ans", "min(ans, abs(left - right) * a * b)", "min", "ans", "abs(left - right) * a * b", "abs(left - right) * a", "abs(left - right)", "abs", "left - right", "left", "right", "a", "b", "print(ans)", "print", "ans", "right = c - left", "c - left", "right", "ans = 10 ** 18", "10 ** 18", "ans", "a, b, c = Z[i % 3], Z[(i + 1) % 3], Z[(i + 2) % 3]", "Z[i % 3]", "a", "Z = list(map(int, input().split()))", "list(map(int, input().split()))", "Z", "left = c // 2", "c // 2", "left", "b, c = Z[i % 3], Z[(i + 1) % 3], Z[(i + 2) % 3]", "Z[(i + 1) % 3]", "b", "c = Z[i % 3], Z[(i + 1) % 3], Z[(i + 2) % 3]", "Z[(i + 2) % 3]", "c", "ans = min(ans, abs(left - right) * a * b)", "min(ans, abs(left - right) * a * b)", "ans" ]

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

[ [ 101, 2 ], [ 101, 11 ], [ 101, 12 ], [ 95, 14 ], [ 93, 20 ], [ 99, 21 ], [ 102, 23 ], [ 93, 27 ], [ 99, 28 ], [ 102, 31 ], [ 86, 35 ], [ 96, 38 ], [ 93, 44 ], [ 102, 45 ], [ 99, 47 ], [ 93, 51 ], [ 102, 52 ], [ 99, 55 ], [ 89, 59 ], [ 87, 62 ], [ 96, 62 ], [ 99, 68 ], [ 102, 69 ], [ 93, 71 ], [ 99, 75 ], [ 102, 76 ], [ 93, 79 ], [ 90, 84 ], [ 87, 84 ], [ 96, 84 ], [ 86, 87 ], [ 89, 90 ], [ 101, 93 ], [ 95, 96 ], [ 101, 99 ], [ 101, 102 ] ]

[ "A, B, C = map(int, input().split())\nans = abs(A*B*(C//2) - A*B*((C+1)//2))\nans = min(ans, abs(A*C*(B//2) - A*C*((B+1)//2)))\nans = min(ans, abs(B*C*(A//2) - B*C*((A+1)//2)))\nprint(ans)", "A, B, C = map(int, input().split())", "A", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "B", "C", "ans = abs(A*B*(C//2) - A*B*((C+1)//2))", "ans", "abs(A*B*(C//2) - A*B*((C+1)//2))", "abs", "A*B*(C//2) - A*B*((C+1)//2)", "A*B*(C//2)", "A*B", "A", "B", "C//2", "C", "2", "A*B*((C+1)//2)", "A*B", "A", "B", "(C+1)//2", "C+1", "C", "1", "2", "ans = min(ans, abs(A*C*(B//2) - A*C*((B+1)//2)))", "ans", "min(ans, abs(A*C*(B//2) - A*C*((B+1)//2)))", "min", "ans", "abs(A*C*(B//2) - A*C*((B+1)//2))", "abs", "A*C*(B//2) - A*C*((B+1)//2)", "A*C*(B//2)", "A*C", "A", "C", "B//2", "B", "2", "A*C*((B+1)//2)", "A*C", "A", "C", "(B+1)//2", "B+1", "B", "1", "2", "ans = min(ans, abs(B*C*(A//2) - B*C*((A+1)//2)))", "ans", "min(ans, abs(B*C*(A//2) - B*C*((A+1)//2)))", "min", "ans", "abs(B*C*(A//2) - B*C*((A+1)//2))", "abs", "B*C*(A//2) - B*C*((A+1)//2)", "B*C*(A//2)", "B*C", "B", "C", "A//2", "A", "2", "B*C*((A+1)//2)", "B*C", "B", "C", "(A+1)//2", "A+1", "A", "1", "2", "print(ans)", "print", "ans", "ans = min(ans, abs(A*C*(B//2) - A*C*((B+1)//2)))", "min(ans, abs(A*C*(B//2) - A*C*((B+1)//2)))", "ans", "ans = min(ans, abs(B*C*(A//2) - B*C*((A+1)//2)))", "min(ans, abs(B*C*(A//2) - B*C*((A+1)//2)))", "ans", "A, B, C = map(int, input().split())", "map(int, input().split())", "A", "ans = abs(A*B*(C//2) - A*B*((C+1)//2))", "abs(A*B*(C//2) - A*B*((C+1)//2))", "ans", "B, C = map(int, input().split())", "map(int, input().split())", "B", "C = map(int, input().split())", "map(int, input().split())", "C" ]

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

[ [ 80, 11 ], [ 22, 21 ], [ 81, 25 ], [ 21, 30 ], [ 33, 32 ], [ 33, 34 ], [ 33, 35 ], [ 32, 41 ], [ 34, 46 ], [ 35, 51 ], [ 32, 62 ], [ 34, 63 ], [ 34, 65 ], [ 35, 66 ], [ 35, 68 ], [ 32, 69 ], [ 78, 75 ], [ 80, 81 ] ]

[ "import sys\n\nsys.setrecursionlimit(10 ** 8)\n\ninput = sys.stdin.readline\n\n\ndef main():\n A, B, C = [int(x) for x in input().split()]\n\n\n if A % 2 == 0 or B % 2 == 0 or C % 2 ==0:\n print(0)\n else:\n print(min(A * B, B * C, C * A))\n\n\nif __name__ == '__main__':\n main()", "import sys", "sys", "sys.setrecursionlimit(10 ** 8)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "10 ** 8", "10", "8", "input = sys.stdin.readline", "input", "sys.stdin.readline", "sys.stdin", "sys", "stdin", "readline", "def main():\n A, B, C = [int(x) for x in input().split()]\n\n\n if A % 2 == 0 or B % 2 == 0 or C % 2 ==0:\n print(0)\n else:\n print(min(A * B, B * C, C * A))", "main", "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, C = [int(x) for x in input().split()]", "A", "[int(x) for x in input().split()]", "B", "C", "if A % 2 == 0 or B % 2 == 0 or C % 2 ==0:\n print(0)\n else:\n print(min(A * B, B * C, C * A))", "A % 2 == 0 or B % 2 == 0 or C % 2 ==0", "A % 2 == 0 or B % 2 == 0", "A % 2 == 0", "A % 2", "A", "2", "0", "B % 2 == 0", "B % 2", "B", "2", "0", "C % 2 ==0", "C % 2", "C", "2", "0", "print(0)", "print", "0", "print(min(A * B, B * C, C * A))", "print", "min(A * B, B * C, C * A)", "min", "A * B", "A", "B", "B * C", "B", "C", "C * A", "C", "A", "if __name__ == '__main__':\n main()", "__name__ == '__main__'", "__name__", "'__main__'", "main()", "main", "def main():\n A, B, C = [int(x) for x in input().split()]\n\n\n if A % 2 == 0 or B % 2 == 0 or C % 2 ==0:\n print(0)\n else:\n print(min(A * B, B * C, C * A))", "def main():\n A, B, C = [int(x) for x in input().split()]\n\n\n if A % 2 == 0 or B % 2 == 0 or C % 2 ==0:\n print(0)\n else:\n print(min(A * B, B * C, C * A))", "main", "input = sys.stdin.readline", "sys.stdin.readline", "input" ]

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

[ [ 40, 2 ], [ 40, 11 ], [ 40, 12 ], [ 35, 24 ], [ 38, 25 ], [ 35, 27 ], [ 41, 28 ], [ 38, 30 ], [ 41, 31 ], [ 40, 35 ], [ 40, 38 ], [ 40, 41 ] ]

[ "a, b, c = map(int, input().split())\nprint(min(a*b, a*c, b*c) if all(i%2 for i in [a, b, c]) else 0)", "a, b, c = map(int, input().split())", "a", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "c", "print(min(a*b, a*c, b*c) if all(i%2 for i in [a, b, c]) else 0)", "print", "min(a*b, a*c, b*c) if all(i%2 for i in [a, b, c]) else 0", "all(i%2 for i in [a, b, c])", "all", "i%2", "i", "2", "min(a*b, a*c, b*c)", "min", "a*b", "a", "b", "a*c", "a", "c", "b*c", "b", "c", "0", "a, b, c = map(int, input().split())", "map(int, input().split())", "a", "b, c = map(int, input().split())", "map(int, input().split())", "b", "c = map(int, input().split())", "map(int, input().split())", "c" ]

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

[ [ 46, 2 ], [ 43, 14 ], [ 47, 17 ], [ 47, 24 ], [ 47, 37 ], [ 47, 40 ], [ 43, 44 ], [ 46, 47 ] ]

[ "A = sorted(map(int,input().split()))\na = A[-1]//2\nif A[-1] % 2 == 0:\n print(0)\nelse:\n print(1*A[0]*A[1])", "A = sorted(map(int,input().split()))", "A", "sorted(map(int,input().split()))", "sorted", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "a = A[-1]//2", "a", "A[-1]//2", "A[-1]", "A", "-1", "2", "if A[-1] % 2 == 0:\n print(0)\nelse:\n print(1*A[0]*A[1])", "A[-1] % 2 == 0", "A[-1] % 2", "A[-1]", "A", "-1", "2", "0", "print(0)", "print", "0", "print(1*A[0]*A[1])", "print", "1*A[0]*A[1]", "1*A[0]", "1", "A[0]", "A", "0", "A[1]", "A", "1", "a = A[-1]//2", "A[-1]//2", "a", "A = sorted(map(int,input().split()))", "sorted(map(int,input().split()))", "A" ]

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

[ [ 4, 3 ], [ 3, 13 ], [ 57, 15 ], [ 57, 19 ], [ 57, 20 ], [ 58, 26 ], [ 52, 31 ], [ 55, 36 ], [ 63, 40 ], [ 60, 43 ], [ 58, 45 ], [ 52, 46 ], [ 61, 49 ], [ 64, 49 ], [ 57, 52 ], [ 57, 55 ], [ 57, 58 ], [ 60, 61 ], [ 63, 64 ] ]

[ "#!/usr/bin/env python3\n\nA, B, C = sorted([int(x) for x in input().split(\" \")])\n\nif A % 2 == 0 or B % 2 == 0 or C % 2 == 0:\n ans = 0\nelse:\n ans = A * B\n\nprint(ans)\n \n \n", "int(x) for x in input().split(\" \")", "for x in input().split(\" \")", "x", "input().split(\" \")", "().split", "()", "input", "split", "\" \"", "for x in input().split(\" \")", "int(x)", "int", "x", "A, B, C = sorted([int(x) for x in input().split(\" \")])", "A", "sorted([int(x) for x in input().split(\" \")])", "sorted", "[int(x) for x in input().split(\" \")]", "B", "C", "if A % 2 == 0 or B % 2 == 0 or C % 2 == 0:\n ans = 0\nelse:\n ans = A * B", "A % 2 == 0 or B % 2 == 0 or C % 2 == 0", "A % 2 == 0 or B % 2 == 0", "A % 2 == 0", "A % 2", "A", "2", "0", "B % 2 == 0", "B % 2", "B", "2", "0", "C % 2 == 0", "C % 2", "C", "2", "0", "ans = 0", "ans", "0", "ans = A * B", "ans", "A * B", "A", "B", "print(ans)", "print", "ans", "B, C = sorted([int(x) for x in input().split(\" \")])", "sorted([int(x) for x in input().split(\" \")])", "B", "C = sorted([int(x) for x in input().split(\" \")])", "sorted([int(x) for x in input().split(\" \")])", "C", "A, B, C = sorted([int(x) for x in input().split(\" \")])", "sorted([int(x) for x in input().split(\" \")])", "A", "ans = A * B", "A * B", "ans", "ans = 0", "0", "ans" ]

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

[ [ 93, 2 ], [ 93, 11 ], [ 93, 12 ], [ 96, 14 ], [ 102, 17 ], [ 87, 20 ], [ 79, 25 ], [ 105, 29 ], [ 94, 31 ], [ 73, 32 ], [ 81, 34 ], [ 94, 39 ], [ 84, 43 ], [ 73, 45 ], [ 79, 46 ], [ 90, 48 ], [ 73, 53 ], [ 75, 57 ], [ 79, 59 ], [ 94, 60 ], [ 99, 62 ], [ 82, 68 ], [ 106, 68 ], [ 97, 68 ], [ 91, 69 ], [ 85, 69 ], [ 103, 69 ], [ 100, 70 ], [ 76, 70 ], [ 88, 70 ], [ 93, 73 ], [ 75, 76 ], [ 93, 79 ], [ 81, 82 ], [ 84, 85 ], [ 87, 88 ], [ 90, 91 ], [ 93, 94 ], [ 96, 97 ], [ 99, 100 ], [ 102, 103 ], [ 105, 106 ] ]

[ "a,b,c=map(int,input().split())\nmina=0\nminb=0\nminc=0\n\nif a%2==1:\n mina=b*c\nelse:\n mina=0\nif b%2==1:\n minb=c*a\nelse:\n minb=0\nif c%2==1:\n minc=a*b\nelse:\n minc=0\n\nprint(min(mina,minb,minc))", "a,b,c=map(int,input().split())", "a", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "c", "mina=0", "mina", "0", "minb=0", "minb", "0", "minc=0", "minc", "0", "if a%2==1:\n mina=b*c\nelse:\n mina=0", "a%2==1", "a%2", "a", "2", "1", "mina=b*c", "mina", "b*c", "b", "c", "mina=0", "mina", "0", "if b%2==1:\n minb=c*a\nelse:\n minb=0", "b%2==1", "b%2", "b", "2", "1", "minb=c*a", "minb", "c*a", "c", "a", "minb=0", "minb", "0", "if c%2==1:\n minc=a*b\nelse:\n minc=0", "c%2==1", "c%2", "c", "2", "1", "minc=a*b", "minc", "a*b", "a", "b", "minc=0", "minc", "0", "print(min(mina,minb,minc))", "print", "min(mina,minb,minc)", "min", "mina", "minb", "minc", "c=map(int,input().split())", "map(int,input().split())", "c", "minc=a*b", "a*b", "minc", "a,b,c=map(int,input().split())", "map(int,input().split())", "a", "mina=0", "0", "mina", "minb=c*a", "c*a", "minb", "minc=0", "0", "minc", "minb=0", "0", "minb", "b,c=map(int,input().split())", "map(int,input().split())", "b", "mina=0", "0", "mina", "minc=0", "0", "minc", "minb=0", "0", "minb", "mina=b*c", "b*c", "mina" ]

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

[ [ 68, 4 ], [ 14, 13 ], [ 69, 20 ], [ 14, 22 ], [ 14, 23 ], [ 26, 25 ], [ 13, 28 ], [ 22, 29 ], [ 23, 31 ], [ 35, 34 ], [ 13, 37 ], [ 22, 39 ], [ 23, 41 ], [ 44, 43 ], [ 13, 47 ], [ 22, 49 ], [ 23, 50 ], [ 53, 52 ], [ 25, 55 ], [ 34, 56 ], [ 43, 57 ], [ 52, 60 ], [ 72, 66 ], [ 68, 69 ] ]

[ "import sys\n\ninput = sys.stdin.readline\n\n\ndef main():\n A, B, C = map(int, input().split())\n\n diff_1 = A * B * (C % 2)\n diff_2 = A * (B % 2) * C\n diff_3 = (A % 2) * B * C\n \n ans = min(diff_1, diff_2, diff_3)\n print(ans)\n\n\nif __name__ == \"__main__\":\n main()", "import sys", "sys", "input = sys.stdin.readline", "input", "sys.stdin.readline", "sys.stdin", "sys", "stdin", "readline", "def main():\n A, B, C = map(int, input().split())\n\n diff_1 = A * B * (C % 2)\n diff_2 = A * (B % 2) * C\n diff_3 = (A % 2) * B * C\n \n ans = min(diff_1, diff_2, diff_3)\n print(ans)", "main", "A, B, C = map(int, input().split())", "A", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "B", "C", "diff_1 = A * B * (C % 2)", "diff_1", "A * B * (C % 2)", "A * B", "A", "B", "C % 2", "C", "2", "diff_2 = A * (B % 2) * C", "diff_2", "A * (B % 2) * C", "A * (B % 2)", "A", "B % 2", "B", "2", "C", "diff_3 = (A % 2) * B * C", "diff_3", "(A % 2) * B * C", "(A % 2) * B", "A % 2", "A", "2", "B", "C", "ans = min(diff_1, diff_2, diff_3)", "ans", "min(diff_1, diff_2, diff_3)", "min", "diff_1", "diff_2", "diff_3", "print(ans)", "print", "ans", "if __name__ == \"__main__\":\n main()", "__name__ == \"__main__\"", "__name__", "\"__main__\"", "main()", "main", "input = sys.stdin.readline", "sys.stdin.readline", "input", "def main():\n A, B, C = map(int, input().split())\n\n diff_1 = A * B * (C % 2)\n diff_2 = A * (B % 2) * C\n diff_3 = (A % 2) * B * C\n \n ans = min(diff_1, diff_2, diff_3)\n print(ans)", "def main():\n A, B, C = map(int, input().split())\n\n diff_1 = A * B * (C % 2)\n diff_2 = A * (B % 2) * C\n diff_3 = (A % 2) * B * C\n \n ans = min(diff_1, diff_2, diff_3)\n print(ans)", "main" ]

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

[ [ 65, 2 ], [ 65, 11 ], [ 65, 12 ], [ 66, 18 ], [ 57, 23 ], [ 60, 28 ], [ 62, 37 ], [ 63, 44 ], [ 63, 50 ], [ 63, 53 ], [ 65, 57 ], [ 65, 60 ], [ 62, 63 ], [ 65, 66 ] ]

[ "a,b,c = map(int, input().split())\n\nif a%2 == 0 or b%2 == 0 or c%2 == 0:\n print(0)\n exit()\n\nal = [a,b,c]\nal.sort()\nprint(al[0]*al[1])", "a,b,c = map(int, input().split())", "a", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "c", "if a%2 == 0 or b%2 == 0 or c%2 == 0:\n print(0)\n exit()", "a%2 == 0 or b%2 == 0 or c%2 == 0", "a%2 == 0 or b%2 == 0", "a%2 == 0", "a%2", "a", "2", "0", "b%2 == 0", "b%2", "b", "2", "0", "c%2 == 0", "c%2", "c", "2", "0", "print(0)", "print", "0", "exit()", "exit", "al = [a,b,c]", "al", "[a,b,c]", "a", "b", "c", "al.sort()", "al.sort", "al", "sort", "print(al[0]*al[1])", "print", "al[0]*al[1]", "al[0]", "al", "0", "al[1]", "al", "1", "b,c = map(int, input().split())", "map(int, input().split())", "b", "c = map(int, input().split())", "map(int, input().split())", "c", "al = [a,b,c]", "[a,b,c]", "al", "a,b,c = map(int, input().split())", "map(int, input().split())", "a" ]

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

[ [ 63, 2 ], [ 63, 11 ], [ 63, 12 ], [ 64, 18 ], [ 55, 23 ], [ 58, 28 ], [ 60, 35 ], [ 61, 42 ], [ 61, 48 ], [ 61, 51 ], [ 63, 55 ], [ 63, 58 ], [ 60, 61 ], [ 63, 64 ] ]

[ "a,b,c=map(int,input().split())\nif a%2==0 or b%2==0 or c%2==0:\n print(0)\nelse:\n x=[a,b,c]\n x.sort()\n print(x[0]*x[1])", "a,b,c=map(int,input().split())", "a", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "c", "if a%2==0 or b%2==0 or c%2==0:\n print(0)\nelse:\n x=[a,b,c]\n x.sort()\n print(x[0]*x[1])", "a%2==0 or b%2==0 or c%2==0", "a%2==0 or b%2==0", "a%2==0", "a%2", "a", "2", "0", "b%2==0", "b%2", "b", "2", "0", "c%2==0", "c%2", "c", "2", "0", "print(0)", "print", "0", "x=[a,b,c]", "x", "[a,b,c]", "a", "b", "c", "x.sort()", "x.sort", "x", "sort", "print(x[0]*x[1])", "print", "x[0]*x[1]", "x[0]", "x", "0", "x[1]", "x", "1", "b,c=map(int,input().split())", "map(int,input().split())", "b", "c=map(int,input().split())", "map(int,input().split())", "c", "x=[a,b,c]", "[a,b,c]", "x", "a,b,c=map(int,input().split())", "map(int,input().split())", "a" ]

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

[ [ 55, 2 ], [ 55, 11 ], [ 55, 12 ], [ 53, 18 ], [ 56, 19 ], [ 50, 20 ], [ 46, 24 ], [ 43, 27 ], [ 53, 31 ], [ 56, 32 ], [ 56, 34 ], [ 50, 35 ], [ 50, 37 ], [ 53, 38 ], [ 44, 41 ], [ 47, 41 ], [ 43, 44 ], [ 46, 47 ], [ 55, 50 ], [ 55, 53 ], [ 55, 56 ] ]

[ "A, B, C = map(int,input().split())\n\nif (A * B * C) % 2 == 0:\n ans = 0\nelse:\n ans = min(A*B,B*C,C*A)\nprint(ans)", "A, B, C = map(int,input().split())", "A", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "B", "C", "if (A * B * C) % 2 == 0:\n ans = 0\nelse:\n ans = min(A*B,B*C,C*A)", "(A * B * C) % 2 == 0", "(A * B * C) % 2", "A * B * C", "A * B", "A", "B", "C", "2", "0", "ans = 0", "ans", "0", "ans = min(A*B,B*C,C*A)", "ans", "min(A*B,B*C,C*A)", "min", "A*B", "A", "B", "B*C", "B", "C", "C*A", "C", "A", "print(ans)", "print", "ans", "ans = min(A*B,B*C,C*A)", "min(A*B,B*C,C*A)", "ans", "ans = 0", "0", "ans", "C = map(int,input().split())", "map(int,input().split())", "C", "A, B, C = map(int,input().split())", "map(int,input().split())", "A", "B, C = map(int,input().split())", "map(int,input().split())", "B" ]

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

[ [ 50, 2 ], [ 50, 11 ], [ 50, 12 ], [ 48, 18 ], [ 51, 21 ], [ 45, 24 ], [ 48, 32 ], [ 51, 33 ], [ 51, 35 ], [ 45, 36 ], [ 48, 38 ], [ 45, 39 ], [ 50, 45 ], [ 50, 48 ], [ 50, 51 ] ]

[ "A, B, C = map(int, input().split())\nif A%2 == B%2 == C%2 == 1:\n print(min(A*B, B*C, A*C))\nelse:\n print(0)", "A, B, C = map(int, input().split())", "A", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "B", "C", "if A%2 == B%2 == C%2 == 1:\n print(min(A*B, B*C, A*C))\nelse:\n print(0)", "A%2 == B%2 == C%2 == 1", "A%2 == B%2 == C%2", "A%2 == B%2", "A%2", "A", "2", "B%2", "B", "2", "C%2", "C", "2", "1", "print(min(A*B, B*C, A*C))", "print", "min(A*B, B*C, A*C)", "min", "A*B", "A", "B", "B*C", "B", "C", "A*C", "A", "C", "print(0)", "print", "0", "C = map(int, input().split())", "map(int, input().split())", "C", "A, B, C = map(int, input().split())", "map(int, input().split())", "A", "B, C = map(int, input().split())", "map(int, input().split())", "B" ]

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

[ [ 65, 2 ], [ 59, 8 ], [ 68, 14 ], [ 71, 20 ], [ 66, 27 ], [ 60, 28 ], [ 62, 30 ], [ 66, 32 ], [ 69, 33 ], [ 63, 36 ], [ 66, 39 ], [ 60, 40 ], [ 56, 42 ], [ 69, 45 ], [ 60, 46 ], [ 66, 49 ], [ 60, 50 ], [ 72, 51 ], [ 57, 54 ], [ 56, 57 ], [ 59, 60 ], [ 62, 63 ], [ 65, 66 ], [ 68, 69 ], [ 71, 72 ] ]

[ "# 宿泊代の合計金額を求める。\n\ndays_of_stay = int(input())\ndays_of_original_price = int(input())\noriginal_price = int(input())\ndiscount_price = int(input())\n\n\n# if文の上が、割引適用なし。下が割引適用。\nif days_of_stay <= days_of_original_price:\n total_fee = days_of_stay * original_price\n print(total_fee)\nelif days_of_stay > days_of_original_price:\n total_fee = original_price * days_of_original_price + (days_of_stay - days_of_original_price) * discount_price\n print(total_fee)", "days_of_stay = int(input())", "days_of_stay", "int(input())", "int", "input()", "input", "days_of_original_price = int(input())", "days_of_original_price", "int(input())", "int", "input()", "input", "original_price = int(input())", "original_price", "int(input())", "int", "input()", "input", "discount_price = int(input())", "discount_price", "int(input())", "int", "input()", "input", "if days_of_stay <= days_of_original_price:\n total_fee = days_of_stay * original_price\n print(total_fee)\nelif days_of_stay > days_of_original_price:\n total_fee = original_price * days_of_original_price + (days_of_stay - days_of_original_price) * discount_price\n print(total_fee)", "days_of_stay <= days_of_original_price", "days_of_stay", "days_of_original_price", "total_fee = days_of_stay * original_price", "total_fee", "days_of_stay * original_price", "days_of_stay", "original_price", "print(total_fee)", "print", "total_fee", "elif days_of_stay > days_of_original_price:\n total_fee = original_price * days_of_original_price + (days_of_stay - days_of_original_price) * discount_price\n print(total_fee)", "days_of_stay > days_of_original_price", "days_of_stay", "days_of_original_price", "total_fee = original_price * days_of_original_price + (days_of_stay - days_of_original_price) * discount_price", "total_fee", "original_price * days_of_original_price + (days_of_stay - days_of_original_price) * discount_price", "original_price * days_of_original_price", "original_price", "days_of_original_price", "(days_of_stay - days_of_original_price) * discount_price", "days_of_stay - days_of_original_price", "days_of_stay", "days_of_original_price", "discount_price", "print(total_fee)", "print", "total_fee", "total_fee = original_price * days_of_original_price + (days_of_stay - days_of_original_price) * discount_price", "original_price * days_of_original_price + (days_of_stay - days_of_original_price) * discount_price", "total_fee", "days_of_original_price = int(input())", "int(input())", "days_of_original_price", "total_fee = days_of_stay * original_price", "days_of_stay * original_price", "total_fee", "days_of_stay = int(input())", "int(input())", "days_of_stay", "original_price = int(input())", "int(input())", "original_price", "discount_price = int(input())", "int(input())", "discount_price" ]

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

[ [ 42, 2 ], [ 51, 8 ], [ 45, 14 ], [ 48, 20 ], [ 46, 28 ], [ 52, 31 ], [ 43, 32 ], [ 43, 37 ], [ 52, 38 ], [ 49, 40 ], [ 42, 43 ], [ 45, 46 ], [ 48, 49 ], [ 51, 52 ] ]

[ "\nn = int(raw_input())\nk = int(raw_input())\np = int(raw_input())\nq = int(raw_input())\nprint p * min(k,n) + max(n - k,0) *q", "n = int(raw_input())", "n", "int(raw_input())", "int", "raw_input()", "raw_input", "k = int(raw_input())", "k", "int(raw_input())", "int", "raw_input()", "raw_input", "p = int(raw_input())", "p", "int(raw_input())", "int", "raw_input()", "raw_input", "q = int(raw_input())", "q", "int(raw_input())", "int", "raw_input()", "raw_input", "print", "p * min(k,n) + max(n - k,0) *q", "p * min(k,n)", "p", "min(k,n)", "min", "k", "n", "max(n - k,0) *q", "max(n - k,0)", "max", "n - k", "n", "k", "0", "q", "n = int(raw_input())", "int(raw_input())", "n", "p = int(raw_input())", "int(raw_input())", "p", "q = int(raw_input())", "int(raw_input())", "q", "k = int(raw_input())", "int(raw_input())", "k" ]

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

[ [ 63, 4 ], [ 9, 8 ], [ 64, 14 ], [ 8, 18 ], [ 64, 23 ], [ 64, 26 ], [ 64, 33 ], [ 64, 36 ], [ 66, 39 ], [ 64, 43 ], [ 64, 46 ], [ 64, 51 ], [ 64, 54 ], [ 64, 57 ], [ 67, 61 ], [ 63, 64 ], [ 66, 67 ] ]

[ "import sys\n\nlis = list()\n\nfor line in sys.stdin : \n lis.append(int(line))\n \n\nif (lis[0] - lis[1]) < 0 : \n print(lis[0] * lis[2])\n \nelse : \n sum = lis[1] * lis[2] + (lis[0] - lis[1]) * lis[3]\n print(sum)", "import sys", "sys", "lis = list()", "lis", "list()", "list", "for line in sys.stdin : \n lis.append(int(line))\n ", "line", "sys.stdin", "sys", "stdin", "lis.append(int(line))", "lis.append", "lis", "append", "int(line)", "int", "line", "if (lis[0] - lis[1]) < 0 : \n print(lis[0] * lis[2])\n \nelse : \n sum = lis[1] * lis[2] + (lis[0] - lis[1]) * lis[3]\n print(sum)", "(lis[0] - lis[1]) < 0", "lis[0] - lis[1]", "lis[0]", "lis", "0", "lis[1]", "lis", "1", "0", "print(lis[0] * lis[2])", "print", "lis[0] * lis[2]", "lis[0]", "lis", "0", "lis[2]", "lis", "2", "sum = lis[1] * lis[2] + (lis[0] - lis[1]) * lis[3]", "sum", "lis[1] * lis[2] + (lis[0] - lis[1]) * lis[3]", "lis[1] * lis[2]", "lis[1]", "lis", "1", "lis[2]", "lis", "2", "(lis[0] - lis[1]) * lis[3]", "lis[0] - lis[1]", "lis[0]", "lis", "0", "lis[1]", "lis", "1", "lis[3]", "lis", "3", "print(sum)", "print", "sum", "lis = list()", "list()", "lis", "sum = lis[1] * lis[2] + (lis[0] - lis[1]) * lis[3]", "lis[1] * lis[2] + (lis[0] - lis[1]) * lis[3]", "sum" ]

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

[ [ 4, 3 ], [ 75, 13 ], [ 75, 15 ], [ 75, 16 ], [ 75, 17 ], [ 72, 19 ], [ 72, 22 ], [ 69, 25 ], [ 76, 28 ], [ 55, 29 ], [ 55, 31 ], [ 58, 32 ], [ 76, 34 ], [ 58, 35 ], [ 60, 37 ], [ 76, 40 ], [ 55, 41 ], [ 76, 44 ], [ 55, 45 ], [ 64, 46 ], [ 70, 51 ], [ 73, 51 ], [ 61, 52 ], [ 67, 52 ], [ 75, 55 ], [ 75, 58 ], [ 60, 61 ], [ 75, 64 ], [ 72, 67 ], [ 69, 70 ], [ 72, 73 ], [ 75, 76 ] ]

[ "n,k,x,y=[int(input())for i in range(4)]\na=b=0\na=k*x if n>k else n*x;b=(n-k)*y if n>k else 0\nprint(a+b)", "int(input())for i in range(4)", "for i in range(4)", "i", "range(4)", "range", "4", "for i in range(4)", "int(input())", "int", "input()", "input", "n,k,x,y=[int(input())for i in range(4)]", "n", "[int(input())for i in range(4)]", "k", "x", "y", "a=b=0", "a", "0", "=b=0", "b", "0", "a=k*x if n>k else n*x", "a", "k*x if n>k else n*x", "n>k", "n", "k", "k*x", "k", "x", "n*x", "n", "x", "b=(n-k)*y if n>k else 0", "b", "(n-k)*y if n>k else 0", "n>k", "n", "k", "(n-k)*y", "n-k", "n", "k", "y", "0", "print(a+b)", "print", "a+b", "a", "b", "k,x,y=[int(input())for i in range(4)]", "[int(input())for i in range(4)]", "k", "x,y=[int(input())for i in range(4)]", "[int(input())for i in range(4)]", "x", "b=(n-k)*y if n>k else 0", "(n-k)*y if n>k else 0", "b", "y=[int(input())for i in range(4)]", "[int(input())for i in range(4)]", "y", "b=0", "0", "b", "a=k*x if n>k else n*x", "k*x if n>k else n*x", "a", "a=b=0", "0", "a", "n,k,x,y=[int(input())for i in range(4)]", "[int(input())for i in range(4)]", "n" ]

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

[ [ 50, 2 ], [ 59, 8 ], [ 53, 14 ], [ 56, 20 ], [ 51, 27 ], [ 60, 28 ], [ 60, 33 ], [ 54, 34 ], [ 51, 37 ], [ 60, 38 ], [ 57, 39 ], [ 51, 42 ], [ 60, 43 ], [ 51, 47 ], [ 54, 48 ], [ 50, 51 ], [ 53, 54 ], [ 56, 57 ], [ 59, 60 ] ]

[ "n = int(input())\nk = int(input())\nx = int(input())\ny = int(input())\n\nif n > k :\n print(k*x + (n-k)*y)\nelif n <= k:\n print(n*x)", "n = int(input())", "n", "int(input())", "int", "input()", "input", "k = int(input())", "k", "int(input())", "int", "input()", "input", "x = int(input())", "x", "int(input())", "int", "input()", "input", "y = int(input())", "y", "int(input())", "int", "input()", "input", "if n > k :\n print(k*x + (n-k)*y)\nelif n <= k:\n print(n*x)", "n > k", "n", "k", "print(k*x + (n-k)*y)", "print", "k*x + (n-k)*y", "k*x", "k", "x", "(n-k)*y", "n-k", "n", "k", "y", "elif n <= k:\n print(n*x)", "n <= k", "n", "k", "print(n*x)", "print", "n*x", "n", "x", "n = int(input())", "int(input())", "n", "x = int(input())", "int(input())", "x", "y = int(input())", "int(input())", "y", "k = int(input())", "int(input())", "k" ]

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

[ [ 67, 2 ], [ 58, 8 ], [ 49, 14 ], [ 64, 20 ], [ 61, 26 ], [ 30, 29 ], [ 68, 32 ], [ 29, 35 ], [ 59, 37 ], [ 52, 40 ], [ 50, 41 ], [ 55, 43 ], [ 65, 44 ], [ 56, 47 ], [ 53, 47 ], [ 62, 47 ], [ 49, 50 ], [ 50, 52 ], [ 52, 53 ], [ 65, 55 ], [ 55, 56 ], [ 58, 59 ], [ 61, 62 ], [ 64, 65 ], [ 67, 68 ] ]

[ "a=int(input())\nb=int(input())\nc=int(input())\nd=int(input())\nsum=0\nfor i in range(a):\n if i<=b-1:\n sum+=c\n else:\n sum+=d\nprint(sum)", "a=int(input())", "a", "int(input())", "int", "input()", "input", "b=int(input())", "b", "int(input())", "int", "input()", "input", "c=int(input())", "c", "int(input())", "int", "input()", "input", "d=int(input())", "d", "int(input())", "int", "input()", "input", "sum=0", "sum", "0", "for i in range(a):\n if i<=b-1:\n sum+=c\n else:\n sum+=d", "i", "range(a)", "range", "a", "if i<=b-1:\n sum+=c\n else:\n sum+=d", "i<=b-1", "i", "b-1", "b", "1", "sum+=c", "sum", "c", "sum+=d", "sum", "d", "print(sum)", "print", "sum", "c=int(input())", "int(input())", "c", "sum+=c", "c", "sum", "sum+=d", "d", "sum", "b=int(input())", "int(input())", "b", "sum=0", "0", "sum", "d=int(input())", "int(input())", "d", "a=int(input())", "int(input())", "a" ]

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

[ [ 70, 2 ], [ 73, 8 ], [ 76, 14 ], [ 82, 20 ], [ 79, 26 ], [ 71, 30 ], [ 74, 31 ], [ 34, 33 ], [ 74, 36 ], [ 80, 39 ], [ 77, 41 ], [ 44, 43 ], [ 71, 47 ], [ 74, 48 ], [ 80, 51 ], [ 83, 53 ], [ 56, 55 ], [ 71, 58 ], [ 80, 61 ], [ 77, 63 ], [ 80, 68 ], [ 70, 71 ], [ 73, 74 ], [ 76, 77 ], [ 79, 80 ], [ 82, 83 ] ]

[ "n = int(input())\nk = int(input())\nx = int(input())\ny = int(input())\n\nans = []\nif n>k:\n for i in range(k):\n ans.append(x)\n\n for i in range(n-k):\n ans.append(y)\nelse:\n for i in range(n):\n ans.append(x)\nprint(sum(ans))", "n = int(input())", "n", "int(input())", "int", "input()", "input", "k = int(input())", "k", "int(input())", "int", "input()", "input", "x = int(input())", "x", "int(input())", "int", "input()", "input", "y = int(input())", "y", "int(input())", "int", "input()", "input", "ans = []", "ans", "[]", "if n>k:\n for i in range(k):\n ans.append(x)\n\n for i in range(n-k):\n ans.append(y)\nelse:\n for i in range(n):\n ans.append(x)", "n>k", "n", "k", "for i in range(k):\n ans.append(x)\n\n ", "i", "range(k)", "range", "k", "ans.append(x)", "ans.append", "ans", "append", "x", "for i in range(n-k):\n ans.append(y)", "i", "range(n-k)", "range", "n-k", "n", "k", "ans.append(y)", "ans.append", "ans", "append", "y", "for i in range(n):\n ans.append(x)", "i", "range(n)", "range", "n", "ans.append(x)", "ans.append", "ans", "append", "x", "print(sum(ans))", "print", "sum(ans)", "sum", "ans", "n = int(input())", "int(input())", "n", "k = int(input())", "int(input())", "k", "x = int(input())", "int(input())", "x", "ans = []", "[]", "ans", "y = int(input())", "int(input())", "y" ]

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

[ [ 60, 2 ], [ 63, 8 ], [ 72, 14 ], [ 66, 20 ], [ 54, 26 ], [ 30, 29 ], [ 61, 34 ], [ 29, 38 ], [ 64, 39 ], [ 69, 41 ], [ 55, 43 ], [ 58, 43 ], [ 70, 43 ], [ 73, 44 ], [ 57, 46 ], [ 55, 48 ], [ 58, 48 ], [ 70, 48 ], [ 67, 49 ], [ 58, 52 ], [ 70, 52 ], [ 55, 52 ], [ 54, 55 ], [ 57, 58 ], [ 60, 61 ], [ 63, 64 ], [ 66, 67 ], [ 69, 70 ], [ 72, 73 ] ]

[ "n=int(input())\nk=int(input())\nx=int(input())\ny=int(input())\npay=0\nfor i in range(1,n+1):\n if i<=k:\n pay=pay+x\n else:\n pay=pay+y\n\n\n\nprint(pay)\n", "n=int(input())", "n", "int(input())", "int", "input()", "input", "k=int(input())", "k", "int(input())", "int", "input()", "input", "x=int(input())", "x", "int(input())", "int", "input()", "input", "y=int(input())", "y", "int(input())", "int", "input()", "input", "pay=0", "pay", "0", "for i in range(1,n+1):\n if i<=k:\n pay=pay+x\n else:\n pay=pay+y", "i", "range(1,n+1)", "range", "1", "n+1", "n", "1", "if i<=k:\n pay=pay+x\n else:\n pay=pay+y", "i<=k", "i", "k", "pay=pay+x", "pay", "pay+x", "pay", "x", "pay=pay+y", "pay", "pay+y", "pay", "y", "print(pay)", "print", "pay", "pay=0", "0", "pay", "pay=pay+y", "pay+y", "pay", "n=int(input())", "int(input())", "n", "k=int(input())", "int(input())", "k", "y=int(input())", "int(input())", "y", "pay=pay+x", "pay+x", "pay", "x=int(input())", "int(input())", "x" ]

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

[ [ 52, 2 ], [ 67, 8 ], [ 55, 14 ], [ 64, 20 ], [ 68, 27 ], [ 53, 28 ], [ 58, 30 ], [ 56, 33 ], [ 68, 34 ], [ 65, 36 ], [ 53, 38 ], [ 68, 39 ], [ 59, 42 ], [ 61, 44 ], [ 53, 46 ], [ 56, 47 ], [ 62, 50 ], [ 52, 53 ], [ 55, 56 ], [ 58, 59 ], [ 61, 62 ], [ 64, 65 ], [ 67, 68 ] ]

[ "N = int(input())\nK = int(input())\nX = int(input())\nY = int(input())\nif K < N:\n x = X*K + Y*(N-K)\n print(x)\nelse:\n x = N*X\n print(x)", "N = int(input())", "N", "int(input())", "int", "input()", "input", "K = int(input())", "K", "int(input())", "int", "input()", "input", "X = int(input())", "X", "int(input())", "int", "input()", "input", "Y = int(input())", "Y", "int(input())", "int", "input()", "input", "if K < N:\n x = X*K + Y*(N-K)\n print(x)\nelse:\n x = N*X\n print(x)", "K < N", "K", "N", "x = X*K + Y*(N-K)", "x", "X*K + Y*(N-K)", "X*K", "X", "K", "Y*(N-K)", "Y", "N-K", "N", "K", "print(x)", "print", "x", "x = N*X", "x", "N*X", "N", "X", "print(x)", "print", "x", "N = int(input())", "int(input())", "N", "X = int(input())", "int(input())", "X", "x = X*K + Y*(N-K)", "X*K + Y*(N-K)", "x", "x = N*X", "N*X", "x", "Y = int(input())", "int(input())", "Y", "K = int(input())", "int(input())", "K" ]

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

[ [ 91, 16 ], [ 88, 23 ], [ 70, 29 ], [ 73, 35 ], [ 76, 41 ], [ 82, 47 ], [ 89, 51 ], [ 71, 52 ], [ 74, 53 ], [ 79, 55 ], [ 71, 56 ], [ 80, 59 ], [ 89, 59 ], [ 85, 62 ], [ 80, 64 ], [ 89, 64 ], [ 77, 65 ], [ 86, 68 ], [ 83, 68 ], [ 70, 71 ], [ 73, 74 ], [ 76, 77 ], [ 71, 79 ], [ 79, 80 ], [ 82, 83 ], [ 85, 86 ], [ 88, 89 ], [ 91, 92 ] ]

[ "import sys\nimport itertools\nsys.setrecursionlimit(1000000000)\nfrom heapq import heapify,heappop,heappush,heappushpop\nimport math\nimport collections\nMOD = 10**9+7\n\nn = int(input())\nk = int(input())\nx = int(input())\ny = int(input())\nans = min(n,k)*(x)\nn -= k\nif n>0:\n ans += n*y\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", "n = int(input())", "n", "int(input())", "int", "input()", "input", "k = int(input())", "k", "int(input())", "int", "input()", "input", "x = int(input())", "x", "int(input())", "int", "input()", "input", "y = int(input())", "y", "int(input())", "int", "input()", "input", "ans = min(n,k)*(x)", "ans", "min(n,k)*(x)", "min(n,k)", "min", "n", "k", "x", "n -= k", "n", "k", "if n>0:\n ans += n*y", "n>0", "n", "0", "ans += n*y", "ans", "n*y", "n", "y", "print(ans)", "print", "ans", "k = int(input())", "int(input())", "k", "x = int(input())", "int(input())", "x", "y = int(input())", "int(input())", "y", "n -= k", "k", "n", "ans = min(n,k)*(x)", "min(n,k)*(x)", "ans", "ans += n*y", "n*y", "ans", "n = int(input())", "int(input())", "n", "MOD = 10**9+7", "10**9+7", "MOD" ]

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

[ [ 104, 2 ], [ 95, 6 ], [ 92, 10 ], [ 101, 14 ], [ 119, 18 ], [ 116, 21 ], [ 105, 27 ], [ 96, 30 ], [ 120, 33 ], [ 111, 33 ], [ 96, 36 ], [ 122, 38 ], [ 117, 40 ], [ 123, 40 ], [ 93, 43 ], [ 110, 45 ], [ 120, 47 ], [ 111, 47 ], [ 111, 51 ], [ 120, 51 ], [ 99, 51 ], [ 105, 54 ], [ 107, 56 ], [ 123, 58 ], [ 117, 58 ], [ 108, 58 ], [ 102, 61 ], [ 98, 63 ], [ 111, 65 ], [ 120, 65 ], [ 99, 65 ], [ 120, 69 ], [ 114, 69 ], [ 105, 72 ], [ 89, 74 ], [ 117, 76 ], [ 90, 76 ], [ 93, 79 ], [ 113, 81 ], [ 120, 83 ], [ 114, 83 ], [ 90, 87 ], [ 108, 87 ], [ 123, 87 ], [ 117, 87 ], [ 89, 90 ], [ 92, 93 ], [ 95, 96 ], [ 98, 99 ], [ 101, 102 ], [ 104, 105 ], [ 107, 108 ], [ 110, 111 ], [ 113, 114 ], [ 116, 117 ], [ 119, 120 ], [ 122, 123 ] ]

[ "#合計宿泊数\nN = input()\n#通常宿泊数\nK = input()\n#通常宿泊費\nX = input()\n#割引宿泊費\nY = input()\n#宿泊日数カウント\nS = 1\n#合計金額カウント\nP = 0\n\n#合計日数が割引日数以上\nif int(N) >= int(K):\n #通常宿泊出力\n while S <= int(K):\n P = P + int(X)\n S = S + 1\n\n #割引宿泊出力\n while S <= int(N):\n P = P + int(Y)\n S = S + 1\n#合計日数が割引日数未満\nelse :\n #通常宿泊出力\n while S <= int(N):\n P = P + int(X)\n S = S + 1\n\n#合計金額出力\nprint(P)", "N = input()", "N", "input()", "input", "K = input()", "K", "input()", "input", "X = input()", "X", "input()", "input", "Y = input()", "Y", "input()", "input", "S = 1", "S", "1", "P = 0", "P", "0", "if int(N) >= int(K):\n #通常宿泊出力\n while S <= int(K):\n P = P + int(X)\n S = S + 1\n\n #割引宿泊出力\n while S <= int(N):\n P = P + int(Y)\n S = S + 1\n#合計日数が割引日数未満\nelse :\n #通常宿泊出力\n while S <= int(N):\n P = P + int(X)\n S = S + 1\n\n#合計金額出力", "int(N) >= int(K)", "int(N)", "int", "N", "int(K)", "int", "K", "while S <= int(K):\n P = P + int(X)\n S = S + 1\n\n #割引宿泊出力\n ", "S <= int(K)", "S", "int(K)", "int", "K", "P = P + int(X)", "P", "P + int(X)", "P", "int(X)", "int", "X", "S = S + 1", "S", "S + 1", "S", "1", "while S <= int(N):\n P = P + int(Y)\n S = S + 1\n#合計日数が割引日数未満", "S <= int(N)", "S", "int(N)", "int", "N", "P = P + int(Y)", "P", "P + int(Y)", "P", "int(Y)", "int", "Y", "S = S + 1", "S", "S + 1", "S", "1", "while S <= int(N):\n P = P + int(X)\n S = S + 1\n\n#合計金額出力", "S <= int(N)", "S", "int(N)", "int", "N", "P = P + int(X)", "P", "P + int(X)", "P", "int(X)", "int", "X", "S = S + 1", "S", "S + 1", "S", "1", "print(P)", "print", "P", "P = P + int(X)", "P + int(X)", "P", "X = input()", "input()", "X", "K = input()", "input()", "K", "S = S + 1", "S + 1", "S", "Y = input()", "input()", "Y", "N = input()", "input()", "N", "P = P + int(Y)", "P + int(Y)", "P", "S = S + 1", "S + 1", "S", "S = S + 1", "S + 1", "S", "P = 0", "0", "P", "S = 1", "1", "S", "P = P + int(X)", "P + int(X)", "P" ]

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

[ [ 96, 2 ], [ 87, 5 ], [ 105, 10 ], [ 78, 15 ], [ 22, 21 ], [ 102, 31 ], [ 102, 33 ], [ 102, 34 ], [ 102, 35 ], [ 93, 37 ], [ 82, 40 ], [ 70, 41 ], [ 91, 42 ], [ 82, 45 ], [ 70, 46 ], [ 84, 48 ], [ 70, 50 ], [ 103, 51 ], [ 72, 53 ], [ 85, 55 ], [ 106, 55 ], [ 94, 56 ], [ 79, 56 ], [ 75, 58 ], [ 82, 60 ], [ 103, 61 ], [ 99, 63 ], [ 76, 64 ], [ 106, 64 ], [ 100, 67 ], [ 73, 67 ], [ 88, 67 ], [ 102, 70 ], [ 72, 73 ], [ 75, 76 ], [ 78, 79 ], [ 102, 82 ], [ 84, 85 ], [ 87, 88 ], [ 102, 91 ], [ 93, 94 ], [ 96, 97 ], [ 76, 99 ], [ 106, 99 ], [ 99, 100 ], [ 102, 103 ], [ 105, 106 ] ]

[ "n = 4\ntotal = int(0)\nzenhan = int(0)\nkouhan = int(0)\n\nN, K, X, Y = [int(input()) for i in range(4) ]\n\nkouhan = (N - K ) * Y\n\nif (N > K):\n zenhan = K * X\n total = zenhan + kouhan\nelse:\n zenhan = N * X\n total = zenhan\n\nprint(total)", "n = 4", "n", "4", "total = int(0)", "total", "int(0)", "int", "0", "zenhan = int(0)", "zenhan", "int(0)", "int", "0", "kouhan = int(0)", "kouhan", "int(0)", "int", "0", "int(input()) for i in range(4)", "for i in range(4)", "i", "range(4)", "range", "4", "for i in range(4)", "int(input())", "int", "input()", "input", "N, K, X, Y = [int(input()) for i in range(4) ]", "N", "[int(input()) for i in range(4) ]", "K", "X", "Y", "kouhan = (N - K ) * Y", "kouhan", "(N - K ) * Y", "N - K", "N", "K", "Y", "if (N > K):\n zenhan = K * X\n total = zenhan + kouhan\nelse:\n zenhan = N * X\n total = zenhan", "N > K", "N", "K", "zenhan = K * X", "zenhan", "K * X", "K", "X", "total = zenhan + kouhan", "total", "zenhan + kouhan", "zenhan", "kouhan", "zenhan = N * X", "zenhan", "N * X", "N", "X", "total = zenhan", "total", "zenhan", "print(total)", "print", "total", "K, X, Y = [int(input()) for i in range(4) ]", "[int(input()) for i in range(4) ]", "K", "total = zenhan + kouhan", "zenhan + kouhan", "total", "zenhan = N * X", "N * X", "zenhan", "kouhan = int(0)", "int(0)", "kouhan", "N, K, X, Y = [int(input()) for i in range(4) ]", "[int(input()) for i in range(4) ]", "N", "zenhan = K * X", "K * X", "zenhan", "total = int(0)", "int(0)", "total", "Y = [int(input()) for i in range(4) ]", "[int(input()) for i in range(4) ]", "Y", "kouhan = (N - K ) * Y", "(N - K ) * Y", "kouhan", "n = 4", "4", "n", "total = zenhan", "zenhan", "total", "X, Y = [int(input()) for i in range(4) ]", "[int(input()) for i in range(4) ]", "X", "zenhan = int(0)", "int(0)", "zenhan" ]

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

[ [ 55, 2 ], [ 49, 8 ], [ 52, 14 ], [ 46, 20 ], [ 50, 27 ], [ 56, 28 ], [ 50, 33 ], [ 53, 34 ], [ 56, 37 ], [ 50, 38 ], [ 47, 39 ], [ 56, 43 ], [ 53, 44 ], [ 46, 47 ], [ 49, 50 ], [ 52, 53 ], [ 55, 56 ] ]

[ "n = int(input())\nk = int(input())\nx = int(input())\ny = int(input())\nif k <= n:\n print(k*x+(n-k)*y)\nelse:\n print(n*x)", "n = int(input())", "n", "int(input())", "int", "input()", "input", "k = int(input())", "k", "int(input())", "int", "input()", "input", "x = int(input())", "x", "int(input())", "int", "input()", "input", "y = int(input())", "y", "int(input())", "int", "input()", "input", "if k <= n:\n print(k*x+(n-k)*y)\nelse:\n print(n*x)", "k <= n", "k", "n", "print(k*x+(n-k)*y)", "print", "k*x+(n-k)*y", "k*x", "k", "x", "(n-k)*y", "n-k", "n", "k", "y", "print(n*x)", "print", "n*x", "n", "x", "y = int(input())", "int(input())", "y", "k = int(input())", "int(input())", "k", "x = int(input())", "int(input())", "x", "n = int(input())", "int(input())", "n" ]

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

[ [ 55, 2 ], [ 49, 8 ], [ 52, 14 ], [ 46, 20 ], [ 56, 27 ], [ 50, 28 ], [ 56, 32 ], [ 53, 33 ], [ 53, 38 ], [ 50, 39 ], [ 56, 42 ], [ 50, 43 ], [ 47, 44 ], [ 46, 47 ], [ 49, 50 ], [ 52, 53 ], [ 55, 56 ] ]

[ "a = int(input())\nb = int(input())\nc = int(input())\nd = int(input())\nif a<= b:\n print(a*c)\nelse:\n print(c*b +(a-b)*d)", "a = int(input())", "a", "int(input())", "int", "input()", "input", "b = int(input())", "b", "int(input())", "int", "input()", "input", "c = int(input())", "c", "int(input())", "int", "input()", "input", "d = int(input())", "d", "int(input())", "int", "input()", "input", "if a<= b:\n print(a*c)\nelse:\n print(c*b +(a-b)*d)", "a<= b", "a", "b", "print(a*c)", "print", "a*c", "a", "c", "print(c*b +(a-b)*d)", "print", "c*b +(a-b)*d", "c*b", "c", "b", "(a-b)*d", "a-b", "a", "b", "d", "d = int(input())", "int(input())", "d", "b = int(input())", "int(input())", "b", "c = int(input())", "int(input())", "c", "a = int(input())", "int(input())", "a" ]

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

[ [ 60, 2 ], [ 6, 5 ], [ 61, 11 ], [ 61, 20 ], [ 61, 23 ], [ 29, 26 ], [ 61, 27 ], [ 61, 30 ], [ 57, 33 ], [ 61, 37 ], [ 61, 40 ], [ 61, 45 ], [ 61, 48 ], [ 61, 51 ], [ 58, 55 ], [ 57, 58 ], [ 60, 61 ] ]

[ "arr = []\nfor _ in range(4):\n arr.append(int(input()))\n\nif arr[1] > arr[0]:\n arr[1] = arr[0]\ncharge = arr[1]*arr[2] + (arr[0]-arr[1])*arr[3]\nprint(charge)", "arr = []", "arr", "[]", "for _ in range(4):\n arr.append(int(input()))", "_", "range(4)", "range", "4", "arr.append(int(input()))", "arr.append", "arr", "append", "int(input())", "int", "input()", "input", "if arr[1] > arr[0]:\n arr[1] = arr[0]", "arr[1] > arr[0]", "arr[1]", "arr", "1", "arr[0]", "arr", "0", "arr[1] = arr[0]", "arr[1]", "arr", "1", "arr[0]", "arr", "0", "charge = arr[1]*arr[2] + (arr[0]-arr[1])*arr[3]", "charge", "arr[1]*arr[2] + (arr[0]-arr[1])*arr[3]", "arr[1]*arr[2]", "arr[1]", "arr", "1", "arr[2]", "arr", "2", "(arr[0]-arr[1])*arr[3]", "arr[0]-arr[1]", "arr[0]", "arr", "0", "arr[1]", "arr", "1", "arr[3]", "arr", "3", "print(charge)", "print", "charge", "charge = arr[1]*arr[2] + (arr[0]-arr[1])*arr[3]", "arr[1]*arr[2] + (arr[0]-arr[1])*arr[3]", "charge", "arr = []", "[]", "arr" ]

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

[ [ 43, 2 ], [ 46, 8 ], [ 52, 14 ], [ 49, 20 ], [ 53, 29 ], [ 44, 32 ], [ 47, 33 ], [ 50, 35 ], [ 44, 39 ], [ 47, 40 ], [ 43, 44 ], [ 46, 47 ], [ 49, 50 ], [ 52, 53 ] ]

[ "n = int(input())\nk = int(input())\nx = int(input())\ny = int(input())\n\nprint(x * min(n, k) + y * max(n-k, 0))", "n = int(input())", "n", "int(input())", "int", "input()", "input", "k = int(input())", "k", "int(input())", "int", "input()", "input", "x = int(input())", "x", "int(input())", "int", "input()", "input", "y = int(input())", "y", "int(input())", "int", "input()", "input", "print(x * min(n, k) + y * max(n-k, 0))", "print", "x * min(n, k) + y * max(n-k, 0)", "x * min(n, k)", "x", "min(n, k)", "min", "n", "k", "y * max(n-k, 0)", "y", "max(n-k, 0)", "max", "n-k", "n", "k", "0", "n = int(input())", "int(input())", "n", "k = int(input())", "int(input())", "k", "y = int(input())", "int(input())", "y", "x = int(input())", "int(input())", "x" ]

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

[ [ 49, 2 ], [ 46, 8 ], [ 55, 14 ], [ 52, 20 ], [ 50, 27 ], [ 47, 28 ], [ 47, 33 ], [ 56, 34 ], [ 50, 37 ], [ 47, 38 ], [ 53, 39 ], [ 50, 43 ], [ 56, 44 ], [ 46, 47 ], [ 49, 50 ], [ 52, 53 ], [ 55, 56 ] ]

[ "num1 = int(input())\nnum2 = int(input())\nnum3 = int(input())\nnum4 = int(input())\n\nif num1>num2:\n print(num2*num3+(num1-num2)*num4)\nelse:\n print(num1*num3)", "num1 = int(input())", "num1", "int(input())", "int", "input()", "input", "num2 = int(input())", "num2", "int(input())", "int", "input()", "input", "num3 = int(input())", "num3", "int(input())", "int", "input()", "input", "num4 = int(input())", "num4", "int(input())", "int", "input()", "input", "if num1>num2:\n print(num2*num3+(num1-num2)*num4)\nelse:\n print(num1*num3)", "num1>num2", "num1", "num2", "print(num2*num3+(num1-num2)*num4)", "print", "num2*num3+(num1-num2)*num4", "num2*num3", "num2", "num3", "(num1-num2)*num4", "num1-num2", "num1", "num2", "num4", "print(num1*num3)", "print", "num1*num3", "num1", "num3", "num2 = int(input())", "int(input())", "num2", "num1 = int(input())", "int(input())", "num1", "num4 = int(input())", "int(input())", "num4", "num3 = int(input())", "int(input())", "num3" ]

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

[ [ 67, 2 ], [ 61, 8 ], [ 55, 14 ], [ 58, 20 ], [ 52, 26 ], [ 56, 28 ], [ 68, 29 ], [ 64, 31 ], [ 56, 34 ], [ 62, 35 ], [ 59, 37 ], [ 68, 39 ], [ 62, 40 ], [ 68, 43 ], [ 62, 44 ], [ 53, 47 ], [ 65, 50 ], [ 52, 53 ], [ 55, 56 ], [ 58, 59 ], [ 61, 62 ], [ 64, 65 ], [ 67, 68 ] ]

[ "n = int(input())\nk = int(input())\nx = int(input())\ny = int(input())\n\nf_normal = x * n\nf_addition = x * k + y * (n - k)\n\nif n <= k:\n print(f_normal)\nelse:\n print(f_addition)", "n = int(input())", "n", "int(input())", "int", "input()", "input", "k = int(input())", "k", "int(input())", "int", "input()", "input", "x = int(input())", "x", "int(input())", "int", "input()", "input", "y = int(input())", "y", "int(input())", "int", "input()", "input", "f_normal = x * n", "f_normal", "x * n", "x", "n", "f_addition = x * k + y * (n - k)", "f_addition", "x * k + y * (n - k)", "x * k", "x", "k", "y * (n - k)", "y", "n - k", "n", "k", "if n <= k:\n print(f_normal)\nelse:\n print(f_addition)", "n <= k", "n", "k", "print(f_normal)", "print", "f_normal", "print(f_addition)", "print", "f_addition", "f_normal = x * n", "x * n", "f_normal", "x = int(input())", "int(input())", "x", "y = int(input())", "int(input())", "y", "k = int(input())", "int(input())", "k", "f_addition = x * k + y * (n - k)", "x * k + y * (n - k)", "f_addition", "n = int(input())", "int(input())", "n" ]