Datasets:

---

codefuse-ai

/

GALLa

like 1

Follow

CodeFuse AI 145

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

[ [ 96, 2 ], [ 96, 11 ], [ 96, 12 ], [ 84, 14 ], [ 91, 20 ], [ 88, 21 ], [ 97, 23 ], [ 91, 27 ], [ 88, 28 ], [ 97, 30 ], [ 97, 32 ], [ 99, 35 ], [ 97, 41 ], [ 88, 42 ], [ 91, 44 ], [ 97, 48 ], [ 88, 49 ], [ 91, 51 ], [ 91, 53 ], [ 93, 56 ], [ 97, 62 ], [ 91, 63 ], [ 88, 65 ], [ 97, 69 ], [ 91, 70 ], [ 88, 72 ], [ 88, 74 ], [ 85, 80 ], [ 100, 81 ], [ 94, 82 ], [ 84, 85 ], [ 96, 88 ], [ 96, 91 ], [ 93, 94 ], [ 96, 97 ], [ 99, 100 ] ]

[ "a,b,c=map(int,input().split())\nd=abs((b*c)*(a//2)-(b*c)*(a-a//2))\ne=abs((a*c)*(b//2)-(a*c)*(b-b//2))\nf=abs((a*b)*(c//2)-(a*b)*(c-c//2))\nprint(min(d,e,f))", "a,b,c=map(int,input().split())", "a", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "c", "d=abs((b*c)*(a//2)-(b*c)*(a-a//2))", "d", "abs((b*c)*(a//2)-(b*c)*(a-a//2))", "abs", "(b*c)*(a//2)-(b*c)*(a-a//2)", "(b*c)*(a//2)", "b*c", "b", "c", "a//2", "a", "2", "(b*c)*(a-a//2)", "b*c", "b", "c", "a-a//2", "a", "a//2", "a", "2", "e=abs((a*c)*(b//2)-(a*c)*(b-b//2))", "e", "abs((a*c)*(b//2)-(a*c)*(b-b//2))", "abs", "(a*c)*(b//2)-(a*c)*(b-b//2)", "(a*c)*(b//2)", "a*c", "a", "c", "b//2", "b", "2", "(a*c)*(b-b//2)", "a*c", "a", "c", "b-b//2", "b", "b//2", "b", "2", "f=abs((a*b)*(c//2)-(a*b)*(c-c//2))", "f", "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", "print(min(d,e,f))", "print", "min(d,e,f)", "min", "d", "e", "f", "d=abs((b*c)*(a//2)-(b*c)*(a-a//2))", "abs((b*c)*(a//2)-(b*c)*(a-a//2))", "d", "c=map(int,input().split())", "map(int,input().split())", "c", "b,c=map(int,input().split())", "map(int,input().split())", "b", "f=abs((a*b)*(c//2)-(a*b)*(c-c//2))", "abs((a*b)*(c//2)-(a*b)*(c-c//2))", "f", "a,b,c=map(int,input().split())", "map(int,input().split())", "a", "e=abs((a*c)*(b//2)-(a*c)*(b-b//2))", "abs((a*c)*(b//2)-(a*c)*(b-b//2))", "e" ]

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

[ [ 40, 2 ], [ 43, 16 ], [ 20, 19 ], [ 41, 19 ], [ 19, 24 ], [ 44, 30 ], [ 41, 34 ], [ 41, 37 ], [ 40, 41 ], [ 43, 44 ] ]

[ "a = sorted(list(map(int, input().split())))\nok = False\nfor i in a:\n if i%2==0: ok = True\nprint(0 if ok else 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", "ok = False", "ok", "False", "for i in a:\n if i%2==0: ok = True", "i", "a", "if i%2==0: ok = ", "i%2==0", "i%2", "i", "2", "0", "print(0 if ok else a[0]*a[1])", "print", "0 if ok else a[0]*a[1]", "ok", "0", "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", "ok = False", "False", "ok" ]

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

[ [ 61, 2 ], [ 58, 16 ], [ 62, 24 ], [ 62, 31 ], [ 62, 38 ], [ 55, 43 ], [ 62, 46 ], [ 62, 49 ], [ 56, 53 ], [ 59, 53 ], [ 55, 56 ], [ 58, 59 ], [ 61, 62 ] ]

[ "l = sorted(list(map(int, input().split())))\nans = 0\nif l[0]%2!=0 and l[1]%2!=0 and l[2]%2!=0:\n ans += l[0]*l[1]\nprint(ans)", "l = sorted(list(map(int, input().split())))", "l", "sorted(list(map(int, input().split())))", "sorted", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "ans = 0", "ans", "0", "if l[0]%2!=0 and l[1]%2!=0 and l[2]%2!=0:\n ans += l[0]*l[1]", "l[0]%2!=0 and l[1]%2!=0 and l[2]%2!=0", "l[0]%2!=0 and 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", "ans += l[0]*l[1]", "ans", "l[0]*l[1]", "l[0]", "l", "0", "l[1]", "l", "1", "print(ans)", "print", "ans", "ans += l[0]*l[1]", "l[0]*l[1]", "ans", "ans = 0", "0", "ans", "l = sorted(list(map(int, input().split())))", "sorted(list(map(int, input().split())))", "l" ]

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

[ [ 50, 2 ], [ 50, 11 ], [ 50, 12 ], [ 51, 35 ], [ 45, 36 ], [ 45, 38 ], [ 48, 39 ], [ 48, 41 ], [ 51, 42 ], [ 50, 45 ], [ 50, 48 ], [ 50, 51 ] ]

[ "a, b, c = map(int, input().split())\n\nprint(0 if any(map(lambda x: x % 2 == 0, [a, b, c])) else min(\n 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", "print(0 if any(map(lambda x: x % 2 == 0, [a, b, c])) else min(\n a * b, b * c, c * a))", "print", "0 if any(map(lambda x: x % 2 == 0, [a, b, c])) else min(\n a * b, b * c, c * a)", "any(map(lambda x: x % 2 == 0, [a, b, c]))", "any", "map(lambda x: x % 2 == 0, [a, b, c])", "map", "lambda x: x % 2 == 0", "x % 2 == 0", "x % 2", "x", "2", "0", "x", "[a, b, c]", "a", "b", "c", "0", "min(\n 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, 12, 13, 41, 28, 13, 4, 18, 4, 13, 13, 4, 4, 13, 13, 0, 13, 13, 13, 13, 0, 13, 39, 0, 13, 2, 2, 2, 2, 17, 2, 40, 13, 17, 2, 13, 17, 13, 13, 4, 18, 13, 13, 13, 0, 13, 2, 2, 2, 2, 17, 2, 40, 13, 17, 2, 13, 17, 13, 13, 4, 18, 13, 13, 13, 0, 13, 2, 2, 2, 2, 17, 2, 40, 13, 17, 2, 13, 17, 13, 13, 4, 18, 13, 13, 13, 4, 13, 4, 13, 13, 14, 2, 13, 17, 4, 13, 10, 12, 13 ]

[ [ 6, 5 ], [ 5, 14 ], [ 17, 16 ], [ 17, 18 ], [ 17, 19 ], [ 22, 21 ], [ 25, 24 ], [ 16, 32 ], [ 16, 35 ], [ 18, 37 ], [ 19, 38 ], [ 21, 41 ], [ 24, 43 ], [ 46, 45 ], [ 18, 53 ], [ 18, 56 ], [ 19, 58 ], [ 16, 59 ], [ 21, 62 ], [ 45, 64 ], [ 24, 64 ], [ 67, 66 ], [ 19, 74 ], [ 19, 77 ], [ 16, 79 ], [ 18, 80 ], [ 21, 83 ], [ 66, 85 ], [ 45, 85 ], [ 24, 85 ], [ 21, 90 ], [ 99, 96 ] ]

[ "def main():\n a, b, c = (int(i) for i in input().split())\n ans = []\n v = (0--a//2 - a//2) * b * c\n ans.append(v)\n v = (0--b//2 - b//2) * c * a\n ans.append(v)\n v = (0--c//2 - c//2) * a * b\n ans.append(v)\n print(min(ans))\n\n\nif __name__ == '__main__':\n main()", "def main():\n a, b, c = (int(i) for i in input().split())\n ans = []\n v = (0--a//2 - a//2) * b * c\n ans.append(v)\n v = (0--b//2 - b//2) * c * a\n ans.append(v)\n v = (0--c//2 - c//2) * a * b\n ans.append(v)\n print(min(ans))", "main", "int(i) for i in input().split()", "for i in input().split()", "i", "input().split()", "().split", "()", "input", "split", "for i in input().split()", "int(i)", "int", "i", "a, b, c = (int(i) for i in input().split())", "a", "(int(i) for i in input().split())", "b", "c", "ans = []", "ans", "[]", "v = (0--a//2 - a//2) * b * c", "v", "(0--a//2 - a//2) * b * c", "(0--a//2 - a//2) * b", "0--a//2 - a//2", "0--a//2", "0", "-a//2", "-a", "a", "2", "a//2", "a", "2", "b", "c", "ans.append(v)", "ans.append", "ans", "append", "v", "v = (0--b//2 - b//2) * c * a", "v", "(0--b//2 - b//2) * c * a", "(0--b//2 - b//2) * c", "0--b//2 - b//2", "0--b//2", "0", "-b//2", "-b", "b", "2", "b//2", "b", "2", "c", "a", "ans.append(v)", "ans.append", "ans", "append", "v", "v = (0--c//2 - c//2) * a * b", "v", "(0--c//2 - c//2) * a * b", "(0--c//2 - c//2) * a", "0--c//2 - c//2", "0--c//2", "0", "-c//2", "-c", "c", "2", "c//2", "c", "2", "a", "b", "ans.append(v)", "ans.append", "ans", "append", "v", "print(min(ans))", "print", "min(ans)", "min", "ans", "if __name__ == '__main__':\n main()", "__name__ == '__main__'", "__name__", "'__main__'", "main()", "main", "def main():\n a, b, c = (int(i) for i in input().split())\n ans = []\n v = (0--a//2 - a//2) * b * c\n ans.append(v)\n v = (0--b//2 - b//2) * c * a\n ans.append(v)\n v = (0--c//2 - c//2) * a * b\n ans.append(v)\n print(min(ans))", "def main():\n a, b, c = (int(i) for i in input().split())\n ans = []\n v = (0--a//2 - a//2) * b * c\n ans.append(v)\n v = (0--b//2 - b//2) * c * a\n ans.append(v)\n v = (0--c//2 - c//2) * a * b\n ans.append(v)\n print(min(ans))", "main" ]

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

[ [ 122, 4 ], [ 107, 13 ], [ 110, 22 ], [ 119, 38 ], [ 113, 43 ], [ 53, 52 ], [ 108, 59 ], [ 53, 61 ], [ 53, 62 ], [ 52, 68 ], [ 61, 73 ], [ 62, 78 ], [ 83, 82 ], [ 86, 85 ], [ 52, 89 ], [ 61, 90 ], [ 61, 92 ], [ 62, 93 ], [ 62, 95 ], [ 52, 96 ], [ 85, 99 ], [ 82, 99 ], [ 117, 105 ], [ 107, 108 ], [ 110, 111 ], [ 113, 114 ], [ 119, 120 ], [ 122, 123 ] ]

[ "import sys\nread = sys.stdin.buffer.read\nreadline = sys.stdin.buffer.readline\nreadlines = sys.stdin.buffer.readlines\nsys.setrecursionlimit(10 ** 8)\nINF = float('inf')\nMOD = 10 ** 9 + 7\n\ndef main():\n A, B, C = map(int, readline().split())\n if A%2==0 or B%2==0 or C%2==0:\n ans = 0\n else:\n ans = min(A*B, B*C, C*A)\n print(ans)\n\n\n\nif __name__ == '__main__':\n main()", "import sys", "sys", "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(10 ** 8)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "10 ** 8", "10", "8", "INF = float('inf')", "INF", "float('inf')", "float", "'inf'", "MOD = 10 ** 9 + 7", "MOD", "10 ** 9 + 7", "10 ** 9", "10", "9", "7", "def main():\n A, B, C = map(int, readline().split())\n if A%2==0 or B%2==0 or C%2==0:\n ans = 0\n else:\n ans = min(A*B, B*C, C*A)\n print(ans)", "main", "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 ans = 0\n else:\n ans = min(A*B, B*C, C*A)\n ", "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 = 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", "if __name__ == '__main__':\n main()", "__name__ == '__main__'", "__name__", "'__main__'", "main()", "main", "readline = sys.stdin.buffer.readline", "sys.stdin.buffer.readline", "readline", "readlines = sys.stdin.buffer.readlines", "sys.stdin.buffer.readlines", "readlines", "MOD = 10 ** 9 + 7", "10 ** 9 + 7", "MOD", "def main():\n A, B, C = map(int, readline().split())\n if A%2==0 or B%2==0 or C%2==0:\n ans = 0\n else:\n ans = min(A*B, B*C, C*A)\n print(ans)", "def main():\n A, B, C = map(int, readline().split())\n if A%2==0 or B%2==0 or C%2==0:\n ans = 0\n else:\n ans = min(A*B, B*C, C*A)\n print(ans)", "main", "INF = float('inf')", "float('inf')", "INF", "read = sys.stdin.buffer.read", "sys.stdin.buffer.read", "read" ]

[ 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, 13, 13, 2, 13, 13, 2, 13, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13 ]

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

[ "a, b, c = map(int, input().split())\n\nif (a % 2 == 0)|(b % 2 == 0)|(c % 2 == 0):\n print(0)\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", "if (a % 2 == 0)|(b % 2 == 0)|(c % 2 == 0):\n print(0)\nelse:\n print(min(a*b, b*c, c*a))", "(a % 2 == 0)|(b % 2 == 0)|(c % 2 == 0)", "(a % 2 == 0)|(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", "a, b, c = map(int, input().split())", "map(int, input().split())", "a", "c = map(int, input().split())", "map(int, input().split())", "c", "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, 4, 13, 2, 2, 13, 17, 17, 4, 13, 17, 4, 13, 2, 18, 13, 17, 18, 13, 17, 10, 4, 13 ]

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

[ "A = sorted(list(map(int, input().split())))\nif any(a % 2 == 0 for a in A):\n\tprint(0)\nelse:\n\tprint(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 any(a % 2 == 0 for a in A):\n\tprint(0)\nelse:\n\tprint(A[0] * A[1])", "any(a % 2 == 0 for a in A)", "any", "a % 2 == 0", "a % 2", "a", "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, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 13, 14, 2, 2, 2, 13, 13, 13, 17, 4, 13, 2, 13, 13, 4, 13, 17, 10, 4, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 38, 2 ], [ 38, 13 ], [ 38, 14 ], [ 33, 19 ], [ 36, 20 ], [ 39, 21 ], [ 33, 26 ], [ 36, 27 ], [ 38, 33 ], [ 38, 36 ], [ 38, 39 ] ]

[ "A,B,C=sorted(map(int,input().split()))\nif A*B*C%2:\n print(A*B)\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*B*C%2:\n print(A*B)\nelse:\n print(0)", "A*B*C%2", "A*B*C", "A*B", "A", "B", "C", "2", "print(A*B)", "print", "A*B", "A", "B", "print(0)", "print", "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, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 0, 13, 17, 28, 13, 4, 13, 17, 14, 2, 2, 18, 13, 13, 17, 17, 0, 13, 17, 3, 14, 13, 0, 13, 17, 4, 18, 13, 13, 0, 13, 2, 18, 13, 17, 18, 13, 17, 4, 13, 13, 10, 17, 13, 10, 17, 13, 10, 4, 13, 10, 17, 13, 10, 2, 13 ]

[ [ 61, 2 ], [ 58, 14 ], [ 18, 17 ], [ 62, 25 ], [ 17, 26 ], [ 64, 30 ], [ 55, 36 ], [ 62, 40 ], [ 67, 43 ], [ 62, 46 ], [ 62, 49 ], [ 68, 53 ], [ 56, 53 ], [ 55, 56 ], [ 58, 59 ], [ 61, 62 ], [ 64, 65 ], [ 67, 68 ] ]

[ "# 2020/04/30\n# AtCoder Grand Contest 004 - A\n\n# Input\nabc = list(map(int,input().split()))\n\n# Even Check\nevenflg = False\nfor i in range(3):\n if abc[i] % 2 == 0:\n evenflg = True\n break\n\nif evenflg:\n ans = 0\nelse:\n abc.sort()\n ans = abc[0] * abc[1]\n\n# Output\nprint(ans)", "abc = list(map(int,input().split()))", "abc", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "evenflg = False", "evenflg", "False", "for i in range(3):\n if abc[i] % 2 == 0:\n evenflg = True\n break", "i", "range(3)", "range", "3", "if abc[i] % 2 == 0:\n evenflg = True\n break", "abc[i] % 2 == 0", "abc[i] % 2", "abc[i]", "abc", "i", "2", "0", "evenflg = True", "evenflg", "True", "break", "if evenflg:\n ans = 0\nelse:\n abc.sort()\n ans = abc[0] * abc[1]\n\n# Output", "evenflg", "ans = 0", "ans", "0", "abc.sort()", "abc.sort", "abc", "sort", "ans = abc[0] * abc[1]", "ans", "abc[0] * abc[1]", "abc[0]", "abc", "0", "abc[1]", "abc", "1", "print(ans)", "print", "ans", "ans = 0", "0", "ans", "evenflg = False", "False", "evenflg", "abc = list(map(int,input().split()))", "list(map(int,input().split()))", "abc", "evenflg = True", "True", "evenflg", "ans = abc[0] * abc[1]", "abc[0] * abc[1]", "ans" ]

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

[ [ 9, 8 ], [ 63, 15 ], [ 9, 17 ], [ 9, 18 ], [ 8, 24 ], [ 17, 29 ], [ 18, 34 ], [ 42, 41 ], [ 41, 48 ], [ 41, 54 ], [ 41, 57 ], [ 66, 60 ] ]

[ "import sys\ndef input(): return sys.stdin.readline().strip()\n\ndef resolve():\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 l=[a,b,c]\n l.sort()\n print(l[0]*l[1])\nresolve()", "import sys", "sys", "def input(): return sys.stdin.readline().strip()", "input", "def resolve():\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 l=[a,b,c]\n l.sort()\n print(l[0]*l[1])", "resolve", "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 l=[a,b,c]\n l.sort()\n print(l[0]*l[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", "l=[a,b,c]", "l", "[a,b,c]", "a", "b", "c", "l.sort()", "l.sort", "l", "sort", "print(l[0]*l[1])", "print", "l[0]*l[1]", "l[0]", "l", "0", "l[1]", "l", "1", "resolve()", "resolve", "def input(): return sys.stdin.readline().strip()", "def input(): return sys.stdin.readline().strip()", "input", "def resolve():\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 l=[a,b,c]\n l.sort()\n print(l[0]*l[1])", "def resolve():\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 l=[a,b,c]\n l.sort()\n print(l[0]*l[1])", "resolve" ]

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

[ [ 49, 2 ], [ 50, 15 ], [ 46, 18 ], [ 50, 21 ], [ 50, 24 ], [ 28, 27 ], [ 50, 27 ], [ 27, 32 ], [ 43, 36 ], [ 44, 41 ], [ 47, 41 ], [ 43, 44 ], [ 46, 47 ], [ 49, 50 ] ]

[ "a = list(map(int, input().split()))\na.sort()\nans = a[0] * a[1]\n\nfor i in a:\n if i % 2 == 0:\n ans = 0\n break\n\nprint(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 = a[0] * a[1]", "ans", "a[0] * a[1]", "a[0]", "a", "0", "a[1]", "a", "1", "for i in a:\n if i % 2 == 0:\n ans = 0\n break", "i", "a", "if i % 2 == 0:\n ans = 0\n break", "i % 2 == 0", "i % 2", "i", "2", "0", "ans = 0", "ans", "0", "break", "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" ]

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 13, 14, 2, 17, 39, 2, 13, 17, 2, 13, 17, 2, 13, 17, 4, 13, 17, 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 ], [ 47, 18 ], [ 44, 21 ], [ 50, 24 ], [ 47, 34 ], [ 44, 35 ], [ 44, 37 ], [ 50, 38 ], [ 50, 40 ], [ 47, 41 ], [ 49, 44 ], [ 49, 47 ], [ 49, 50 ] ]

[ "A, B, C = map(int, input().split())\nif 0 in (A % 2, B % 2, C % 2):\n print(0)\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", "if 0 in (A % 2, B % 2, C % 2):\n print(0)\nelse:\n print(min(A * B, B * C, C * A))", "0 in (A % 2, B % 2, C % 2)", "0", "(A % 2, B % 2, C % 2)", "A % 2", "A", "2", "B % 2", "B", "2", "C % 2", "C", "2", "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", "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" ]

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

[ [ 56, 2 ], [ 57, 15 ], [ 57, 23 ], [ 57, 28 ], [ 57, 33 ], [ 59, 38 ], [ 57, 41 ], [ 57, 44 ], [ 53, 47 ], [ 54, 51 ], [ 60, 51 ], [ 53, 54 ], [ 56, 57 ], [ 59, 60 ] ]

[ "a = list(map(int, input().split()))\na.sort()\n\nif a[0]%2 == a[1]%2 == a[2]%2 == 1:\n ans = a[0]*a[1]\nelse:\n ans = 0\nprint(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", "if a[0]%2 == a[1]%2 == a[2]%2 == 1:\n ans = a[0]*a[1]\nelse:\n ans = 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", "ans = a[0]*a[1]", "ans", "a[0]*a[1]", "a[0]", "a", "0", "a[1]", "a", "1", "ans = 0", "ans", "0", "print(ans)", "print", "ans", "ans = 0", "0", "ans", "a = list(map(int, input().split()))", "list(map(int, input().split()))", "a", "ans = a[0]*a[1]", "a[0]*a[1]", "ans" ]

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

[ [ 148, 15 ], [ 134, 42 ], [ 134, 50 ], [ 56, 55 ], [ 81, 58 ], [ 140, 63 ], [ 66, 65 ], [ 70, 69 ], [ 65, 73 ], [ 69, 77 ], [ 81, 81 ], [ 86, 85 ], [ 140, 89 ], [ 85, 104 ], [ 85, 107 ], [ 85, 111 ], [ 85, 114 ], [ 85, 118 ], [ 85, 121 ], [ 143, 131 ], [ 148, 149 ] ]

[ "import sys, math\nfrom functools import lru_cache\nfrom collections import defaultdict\nfrom decimal import Decimal\nsys.setrecursionlimit(10**9)\nMOD = 10**9+7\n\ndef input():\n return sys.stdin.readline()[:-1]\n\ndef mi():\n return map(int, input().split())\n\ndef ii():\n return int(input())\n\ndef i2(n):\n tmp = [list(mi()) for i in range(n)]\n return [list(i) for i in zip(*tmp)]\n\ndef main():\n X = list(mi())\n\n if all(x%2==1 for x in X):\n print(min(X[0]*X[1], X[1]*X[2], X[2]*X[0]))\n else:\n print(0)\n\nif __name__ == '__main__':\n main()", "import sys, math", "sys", "math", "from functools import lru_cache", "from collections import defaultdict", "from decimal import Decimal", "sys.setrecursionlimit(10**9)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "10**9", "10", "9", "MOD = 10**9+7", "MOD", "10**9+7", "10**9", "10", "9", "7", "def input():\n return sys.stdin.readline()[:-1]", "input", "return sys.stdin.readline()[:-1]", "sys.stdin.readline()[:-1]", "sys.stdin.readline()", "sys.stdin.readline", "sys.stdin", "sys", "stdin", "readline", ":-1", "-1", "def mi():\n return map(int, input().split())", "mi", "return map(int, input().split())", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "def ii():\n return int(input())", "ii", "return int(input())", "int(input())", "int", "input()", "input", "def i2(n):\n tmp = [list(mi()) for i in range(n)]\n return [list(i) for i in zip(*tmp)]", "i2", "list(mi()) for i in range(n)", "for i in range(n)", "i", "range(n)", "range", "n", "for i in range(n)", "list(mi())", "list", "mi()", "mi", "tmp = [list(mi()) for i in range(n)]", "tmp", "[list(mi()) for i in range(n)]", "list(i) for i in zip(*tmp)", "for i in zip(*tmp)", "i", "zip(*tmp)", "zip", "*tmp", "tmp", "for i in zip(*tmp)", "list(i)", "list", "i", "return [list(i) for i in zip(*tmp)]", "[list(i) for i in zip(*tmp)]", "n", "n", "def main():\n X = list(mi())\n\n if all(x%2==1 for x in X):\n print(min(X[0]*X[1], X[1]*X[2], X[2]*X[0]))\n else:\n print(0)", "main", "X = list(mi())", "X", "list(mi())", "list", "mi()", "mi", "if all(x%2==1 for x in X):\n print(min(X[0]*X[1], X[1]*X[2], X[2]*X[0]))\n else:\n print(0)", "all(x%2==1 for x in X)", "all", "x%2==1", "x%2", "x", "2", "1", "print(min(X[0]*X[1], X[1]*X[2], X[2]*X[0]))", "print", "min(X[0]*X[1], X[1]*X[2], X[2]*X[0])", "min", "X[0]*X[1]", "X[0]", "X", "0", "X[1]", "X", "1", "X[1]*X[2]", "X[1]", "X", "1", "X[2]", "X", "2", "X[2]*X[0]", "X[2]", "X", "2", "X[0]", "X", "0", "print(0)", "print", "0", "if __name__ == '__main__':\n main()", "__name__ == '__main__'", "__name__", "'__main__'", "main()", "main", "def input():\n return sys.stdin.readline()[:-1]", "def input():\n return sys.stdin.readline()[:-1]", "input", "def ii():\n return int(input())", "def ii():\n return int(input())", "ii", "def mi():\n return map(int, input().split())", "def mi():\n return map(int, input().split())", "mi", "def main():\n X = list(mi())\n\n if all(x%2==1 for x in X):\n print(min(X[0]*X[1], X[1]*X[2], X[2]*X[0]))\n else:\n print(0)", "def main():\n X = list(mi())\n\n if all(x%2==1 for x in X):\n print(min(X[0]*X[1], X[1]*X[2], X[2]*X[0]))\n else:\n print(0)", "main", "def i2(n):\n tmp = [list(mi()) for i in range(n)]\n return [list(i) for i in zip(*tmp)]", "def i2(n):\n tmp = [list(mi()) for i in range(n)]\n return [list(i) for i in zip(*tmp)]", "i2", "MOD = 10**9+7", "10**9+7", "MOD" ]

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

[ [ 34, 2 ], [ 34, 15 ], [ 34, 16 ], [ 29, 22 ], [ 32, 23 ], [ 35, 24 ], [ 34, 29 ], [ 34, 32 ], [ 34, 35 ] ]

[ "a,b,c=sorted(list(map(int,input().split())))\nif a*b*c%2==0:print(0)\nelse:print(a*b)", "a,b,c=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", "b", "c", "if a*b*c%2==0:print(0)\nelse:print(a*b)", "a*b*c%2==0", "a*b*c%2", "a*b*c", "a*b", "a", "b", "c", "2", "0", "a,b,c=sorted(list(map(int,input().split())))", "sorted(list(map(int,input().split())))", "a", "b,c=sorted(list(map(int,input().split())))", "sorted(list(map(int,input().split())))", "b", "c=sorted(list(map(int,input().split())))", "sorted(list(map(int,input().split())))", "c" ]

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

[ [ 46, 2 ], [ 47, 15 ], [ 47, 23 ], [ 47, 26 ], [ 47, 29 ], [ 47, 40 ], [ 47, 43 ], [ 46, 47 ] ]

[ "# AtCoder Grand Contest 004\n# A - Divide a Cuboid\n\n\nl=list(map(int,input().split()))\nl.sort()\n\nif l[0]*l[1]*l[2]%2==0:\n print(0)\nelse:\n print(l[0]*l[1])", "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.sort()", "l.sort", "l", "sort", "if l[0]*l[1]*l[2]%2==0:\n print(0)\nelse:\n print(l[0]*l[1])", "l[0]*l[1]*l[2]%2==0", "l[0]*l[1]*l[2]%2", "l[0]*l[1]*l[2]", "l[0]*l[1]", "l[0]", "l", "0", "l[1]", "l", "1", "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(map(int,input().split()))", "list(map(int,input().split()))", "l" ]

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

[ [ 7, 6 ], [ 27, 26 ], [ 6, 33 ], [ 27, 35 ], [ 27, 36 ], [ 26, 42 ], [ 35, 47 ], [ 36, 52 ], [ 26, 60 ], [ 35, 61 ], [ 35, 63 ], [ 36, 64 ], [ 36, 66 ], [ 26, 67 ], [ 79, 76 ] ]

[ "def main():\n import sys\n input = sys.stdin.readline\n sys.setrecursionlimit(10**7)\n from collections import Counter, deque\n from itertools import combinations, permutations, accumulate, groupby, product\n from bisect import bisect_left,bisect_right\n from heapq import heapify, heappop, heappush\n import math\n #from math import gcd\n\n #inf = 10**17\n #mod = 10**9 + 7\n\n a,b,c = map(int, input().split())\n if a%2 == 1 and b%2 == 1 and c%2 == 1:\n print(min(a*b, b*c, c*a))\n else:\n print(0)\n\nif __name__ == '__main__':\n main()", "def main():\n import sys\n input = sys.stdin.readline\n sys.setrecursionlimit(10**7)\n from collections import Counter, deque\n from itertools import combinations, permutations, accumulate, groupby, product\n from bisect import bisect_left,bisect_right\n from heapq import heapify, heappop, heappush\n import math\n #from math import gcd\n\n #inf = 10**17\n #mod = 10**9 + 7\n\n a,b,c = map(int, input().split())\n if a%2 == 1 and b%2 == 1 and c%2 == 1:\n print(min(a*b, b*c, c*a))\n else:\n print(0)", "main", "import sys", "sys", "input = sys.stdin.readline", "input", "sys.stdin.readline", "sys.stdin", "sys", "stdin", "readline", "sys.setrecursionlimit(10**7)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "10**7", "10", "7", "from collections import Counter, deque", "from itertools import combinations, permutations, accumulate, groupby, product", "from bisect import bisect_left,bisect_right", "from heapq import heapify, heappop, heappush", "import math", "math", "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))\n else:\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", "if __name__ == '__main__':\n main()", "__name__ == '__main__'", "__name__", "'__main__'", "main()", "main", "def main():\n import sys\n input = sys.stdin.readline\n sys.setrecursionlimit(10**7)\n from collections import Counter, deque\n from itertools import combinations, permutations, accumulate, groupby, product\n from bisect import bisect_left,bisect_right\n from heapq import heapify, heappop, heappush\n import math\n #from math import gcd\n\n #inf = 10**17\n #mod = 10**9 + 7\n\n a,b,c = map(int, input().split())\n if a%2 == 1 and b%2 == 1 and c%2 == 1:\n print(min(a*b, b*c, c*a))\n else:\n print(0)", "def main():\n import sys\n input = sys.stdin.readline\n sys.setrecursionlimit(10**7)\n from collections import Counter, deque\n from itertools import combinations, permutations, accumulate, groupby, product\n from bisect import bisect_left,bisect_right\n from heapq import heapify, heappop, heappush\n import math\n #from math import gcd\n\n #inf = 10**17\n #mod = 10**9 + 7\n\n a,b,c = map(int, input().split())\n if a%2 == 1 and b%2 == 1 and c%2 == 1:\n print(min(a*b, b*c, c*a))\n else:\n print(0)", "main" ]

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

[ [ 133, 2 ], [ 133, 11 ], [ 133, 12 ], [ 124, 14 ], [ 134, 17 ], [ 107, 18 ], [ 113, 19 ], [ 115, 21 ], [ 134, 24 ], [ 107, 25 ], [ 113, 26 ], [ 134, 30 ], [ 125, 31 ], [ 107, 33 ], [ 116, 34 ], [ 127, 36 ], [ 113, 37 ], [ 134, 41 ], [ 125, 42 ], [ 113, 44 ], [ 116, 45 ], [ 136, 47 ], [ 107, 48 ], [ 107, 52 ], [ 125, 53 ], [ 134, 55 ], [ 116, 56 ], [ 130, 58 ], [ 113, 59 ], [ 107, 63 ], [ 125, 64 ], [ 113, 66 ], [ 116, 67 ], [ 109, 69 ], [ 134, 70 ], [ 113, 74 ], [ 125, 75 ], [ 134, 77 ], [ 116, 78 ], [ 118, 80 ], [ 107, 81 ], [ 113, 85 ], [ 125, 86 ], [ 107, 88 ], [ 116, 89 ], [ 121, 91 ], [ 134, 92 ], [ 116, 98 ], [ 125, 103 ], [ 122, 104 ], [ 119, 104 ], [ 110, 104 ], [ 131, 104 ], [ 137, 104 ], [ 128, 104 ], [ 133, 107 ], [ 134, 109 ], [ 109, 110 ], [ 133, 113 ], [ 115, 116 ], [ 107, 118 ], [ 118, 119 ], [ 134, 121 ], [ 121, 122 ], [ 124, 125 ], [ 113, 127 ], [ 127, 128 ], [ 113, 130 ], [ 130, 131 ], [ 133, 134 ], [ 107, 136 ], [ 136, 137 ] ]

[ "#from statistics import mean, median,variance,stdev\na,b,c=map(int, input().split())\n\nx=min(a,b,c)\nz=max(a,b,c)\nif a==x and b==z:\n y=c\nif a==x and c==z:\n y=b\nif b==x and a==z:\n y=c\nif b==x and c==z:\n y=a\nif c==x and a==z:\n y=b\nif c==x and b==z:\n y=a\n\nprint(0 if z%2==0 else 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", "if a==x and b==z:\n y=c", "a==x and b==z", "a==x", "a", "x", "b==z", "b", "z", "y=c", "y", "c", "if a==x and c==z:\n y=b", "a==x and c==z", "a==x", "a", "x", "c==z", "c", "z", "y=b", "y", "b", "if b==x and a==z:\n y=c", "b==x and a==z", "b==x", "b", "x", "a==z", "a", "z", "y=c", "y", "c", "if b==x and c==z:\n y=a", "b==x and c==z", "b==x", "b", "x", "c==z", "c", "z", "y=a", "y", "a", "if c==x and a==z:\n y=b", "c==x and a==z", "c==x", "c", "x", "a==z", "a", "z", "y=b", "y", "b", "if c==x and b==z:\n y=a", "c==x and b==z", "c==x", "c", "x", "b==z", "b", "z", "y=a", "y", "a", "print(0 if z%2==0 else x*y)", "print", "0 if z%2==0 else x*y", "z%2==0", "z%2", "z", "2", "0", "0", "x*y", "x", "y", "b,c=map(int, input().split())", "map(int, input().split())", "b", "y=a", "a", "y", "c=map(int, input().split())", "map(int, input().split())", "c", "z=max(a,b,c)", "max(a,b,c)", "z", "y=b", "b", "y", "y=a", "a", "y", "x=min(a,b,c)", "min(a,b,c)", "x", "y=c", "c", "y", "y=c", "c", "y", "a,b,c=map(int, input().split())", "map(int, input().split())", "a", "y=b", "b", "y" ]

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

[ [ 55, 2 ], [ 55, 11 ], [ 55, 12 ], [ 49, 14 ], [ 47, 21 ], [ 44, 22 ], [ 56, 23 ], [ 52, 27 ], [ 47, 31 ], [ 44, 32 ], [ 47, 34 ], [ 56, 35 ], [ 44, 37 ], [ 56, 38 ], [ 53, 41 ], [ 50, 41 ], [ 55, 44 ], [ 55, 47 ], [ 49, 50 ], [ 52, 53 ], [ 55, 56 ] ]

[ "A, B, C = map(int, input().split())\nans = 0\nif A * B * C % 2 != 0:\n ans = min((A * B), (A * C), (B * C))\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 * B * C % 2 != 0:\n ans = min((A * B), (A * C), (B * C))", "A * B * C % 2 != 0", "A * B * C % 2", "A * B * C", "A * B", "A", "B", "C", "2", "0", "ans = min((A * B), (A * C), (B * C))", "ans", "min((A * B), (A * C), (B * C))", "min", "A * B", "A", "B", "A * C", "A", "C", "B * C", "B", "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", "ans = 0", "0", "ans", "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" ]

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

[ [ 27, 27 ], [ 29, 29 ], [ 127, 38 ], [ 172, 45 ], [ 167, 47 ], [ 172, 48 ], [ 172, 49 ], [ 130, 51 ], [ 173, 53 ], [ 146, 54 ], [ 154, 56 ], [ 146, 58 ], [ 164, 59 ], [ 157, 61 ], [ 173, 63 ], [ 164, 64 ], [ 124, 66 ], [ 131, 71 ], [ 164, 73 ], [ 131, 76 ], [ 164, 78 ], [ 164, 80 ], [ 136, 83 ], [ 155, 88 ], [ 173, 90 ], [ 155, 93 ], [ 173, 95 ], [ 173, 97 ], [ 148, 100 ], [ 158, 105 ], [ 146, 107 ], [ 158, 110 ], [ 146, 112 ], [ 146, 114 ], [ 125, 120 ], [ 137, 121 ], [ 149, 122 ], [ 124, 125 ], [ 127, 128 ], [ 130, 131 ], [ 136, 137 ], [ 172, 146 ], [ 148, 149 ], [ 154, 155 ], [ 157, 158 ], [ 172, 164 ], [ 172, 173 ] ]

[ "import sys\nimport math\nimport itertools\nimport bisect\nfrom copy import copy\nfrom collections import deque,Counter\nfrom decimal import Decimal\ndef s(): return input()\ndef i(): return int(input())\ndef S(): return input().split()\ndef I(): return map(int,input().split())\ndef L(): return list(input().split())\ndef l(): return list(map(int,input().split()))\ndef lcm(a,b): return a*b//math.gcd(a,b)\nsys.setrecursionlimit(10 ** 9)\nmod = 10**9+7\n\nA,B,C = I()\nm1 = A*B\nm2 = B*C\nm3 = A*C\nt1 = abs(m1*(C//2)-m1*(C-C//2))\nt2 = abs(m2*(A//2)-m2*(A-A//2))\nt3 = abs(m3*(B//2)-m3*(B-B//2))\nprint(min(t1,t2,t3))", "import sys", "sys", "import math", "math", "import itertools", "itertools", "import bisect", "bisect", "from copy import copy", "from collections import deque,Counter", "from decimal import Decimal", "def s(): return input()", "s", "def i(): return int(input())", "i", "def S(): return input().split()", "S", "def I(): return map(int,input().split())", "I", "def L(): return list(input().split())", "L", "def l(): return list(map(int,input().split()))", "l", "def lcm(a,b): return a*b//math.gcd(a,b)", "lcm", "a", "a", "b", "b", "sys.setrecursionlimit(10 ** 9)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "10 ** 9", "10", "9", "mod = 10**9+7", "mod", "10**9+7", "10**9", "10", "9", "7", "A,B,C = I()", "A", "I()", "I", "B", "C", "m1 = A*B", "m1", "A*B", "A", "B", "m2 = B*C", "m2", "B*C", "B", "C", "m3 = A*C", "m3", "A*C", "A", "C", "t1 = abs(m1*(C//2)-m1*(C-C//2))", "t1", "abs(m1*(C//2)-m1*(C-C//2))", "abs", "m1*(C//2)-m1*(C-C//2)", "m1*(C//2)", "m1", "C//2", "C", "2", "m1*(C-C//2)", "m1", "C-C//2", "C", "C//2", "C", "2", "t2 = abs(m2*(A//2)-m2*(A-A//2))", "t2", "abs(m2*(A//2)-m2*(A-A//2))", "abs", "m2*(A//2)-m2*(A-A//2)", "m2*(A//2)", "m2", "A//2", "A", "2", "m2*(A-A//2)", "m2", "A-A//2", "A", "A//2", "A", "2", "t3 = abs(m3*(B//2)-m3*(B-B//2))", "t3", "abs(m3*(B//2)-m3*(B-B//2))", "abs", "m3*(B//2)-m3*(B-B//2)", "m3*(B//2)", "m3", "B//2", "B", "2", "m3*(B-B//2)", "m3", "B-B//2", "B", "B//2", "B", "2", "print(min(t1,t2,t3))", "print", "min(t1,t2,t3)", "min", "t1", "t2", "t3", "t1 = abs(m1*(C//2)-m1*(C-C//2))", "abs(m1*(C//2)-m1*(C-C//2))", "t1", "mod = 10**9+7", "10**9+7", "mod", "m1 = A*B", "A*B", "m1", "def s(): return input()", "def s(): return input()", "s", "t2 = abs(m2*(A//2)-m2*(A-A//2))", "abs(m2*(A//2)-m2*(A-A//2))", "t2", "def i(): return int(input())", "def i(): return int(input())", "i", "def lcm(a,b): return a*b//math.gcd(a,b)", "def lcm(a,b): return a*b//math.gcd(a,b)", "lcm", "B,C = I()", "I()", "B", "t3 = abs(m3*(B//2)-m3*(B-B//2))", "abs(m3*(B//2)-m3*(B-B//2))", "t3", "def L(): return list(input().split())", "def L(): return list(input().split())", "L", "m2 = B*C", "B*C", "m2", "m3 = A*C", "A*C", "m3", "def S(): return input().split()", "def S(): return input().split()", "S", "C = I()", "I()", "C", "def I(): return map(int,input().split())", "def I(): return map(int,input().split())", "I", "def l(): return list(map(int,input().split()))", "def l(): return list(map(int,input().split()))", "l", "A,B,C = I()", "I()", "A" ]

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

[ [ 62, 2 ], [ 62, 11 ], [ 62, 12 ], [ 53, 14 ], [ 54, 27 ], [ 54, 30 ], [ 54, 36 ], [ 54, 42 ], [ 54, 45 ], [ 54, 49 ], [ 53, 54 ], [ 62, 57 ], [ 62, 60 ], [ 62, 63 ] ]

[ "a, b, c = map(int, input().split())\n\nx = sorted([a, b, c])\nprint(x[0] * x[1] * -(-x[2] // 2) - x[0] * x[1] * (x[2] // 2))", "a, b, c = map(int, input().split())", "a", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "c", "x = sorted([a, b, c])", "x", "sorted([a, b, c])", "sorted", "[a, b, c]", "a", "b", "c", "print(x[0] * x[1] * -(-x[2] // 2) - x[0] * x[1] * (x[2] // 2))", "print", "x[0] * x[1] * -(-x[2] // 2) - x[0] * x[1] * (x[2] // 2)", "x[0] * x[1] * -(-x[2] // 2)", "x[0] * x[1]", "x[0]", "x", "0", "x[1]", "x", "1", "-(-x[2] // 2)", "-x[2] // 2", "-x[2]", "x[2]", "x", "2", "2", "x[0] * x[1] * (x[2] // 2)", "x[0] * x[1]", "x[0]", "x", "0", "x[1]", "x", "1", "x[2] // 2", "x[2]", "x", "2", "2", "x = sorted([a, b, c])", "sorted([a, b, c])", "x", "a, b, c = map(int, input().split())", "map(int, input().split())", "a", "c = map(int, input().split())", "map(int, input().split())", "c", "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, 17, 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, 10, 17, 13 ]

[ [ 55, 2 ], [ 55, 11 ], [ 55, 12 ], [ 49, 14 ], [ 47, 21 ], [ 56, 22 ], [ 53, 23 ], [ 61, 27 ], [ 58, 30 ], [ 47, 34 ], [ 56, 35 ], [ 56, 37 ], [ 53, 38 ], [ 47, 40 ], [ 53, 41 ], [ 59, 44 ], [ 62, 44 ], [ 50, 44 ], [ 55, 47 ], [ 49, 50 ], [ 55, 53 ], [ 55, 56 ], [ 58, 59 ], [ 61, 62 ] ]

[ "a,b,c = map(int,input().split())\n\nans=0\nif a*b*c%2==0:\n ans=0\nelse:\n ans = min(a*b,b*c,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", "ans=0", "ans", "0", "if a*b*c%2==0:\n ans=0\nelse:\n ans = min(a*b,b*c,a*c)", "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,a*c)", "ans", "min(a*b,b*c,a*c)", "min", "a*b", "a", "b", "b*c", "b", "c", "a*c", "a", "c", "print(ans)", "print", "ans", "a,b,c = map(int,input().split())", "map(int,input().split())", "a", "ans=0", "0", "ans", "c = map(int,input().split())", "map(int,input().split())", "c", "b,c = map(int,input().split())", "map(int,input().split())", "b", "ans = min(a*b,b*c,a*c)", "min(a*b,b*c,a*c)", "ans", "ans=0", "0", "ans" ]

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

[ [ 5, 4 ], [ 5, 17 ], [ 5, 18 ], [ 21, 20 ], [ 4, 23 ], [ 17, 24 ], [ 18, 25 ], [ 28, 27 ], [ 4, 37 ], [ 18, 38 ], [ 17, 40 ], [ 20, 42 ], [ 18, 50 ], [ 17, 51 ], [ 4, 53 ], [ 20, 55 ], [ 17, 63 ], [ 4, 64 ], [ 18, 66 ], [ 20, 68 ], [ 27, 71 ], [ 76, 73 ] ]

[ "#!/usr/bin/env python3\n\ndef main():\n A, B, C = map(int, open(0).read().split())\n\n m = A*B*C\n ans = min(abs(2*A*C*(B//2) - m), abs(2*C*B*(A//2) - m), abs(2*B*A*(C//2) - m))\n\n print(ans)\n\n\nmain()", "def main():\n A, B, C = map(int, open(0).read().split())\n\n m = A*B*C\n ans = min(abs(2*A*C*(B//2) - m), abs(2*C*B*(A//2) - m), abs(2*B*A*(C//2) - m))\n\n print(ans)", "main", "A, B, C = map(int, open(0).read().split())", "A", "map(int, open(0).read().split())", "map", "int", "open(0).read().split()", "(0).read().split", "(0).read()", "(0).read", "(0)", "open", "0", "read", "split", "B", "C", "m = A*B*C", "m", "A*B*C", "A*B", "A", "B", "C", "ans = min(abs(2*A*C*(B//2) - m), abs(2*C*B*(A//2) - m), abs(2*B*A*(C//2) - m))", "ans", "min(abs(2*A*C*(B//2) - m), abs(2*C*B*(A//2) - m), abs(2*B*A*(C//2) - m))", "min", "abs(2*A*C*(B//2) - m)", "abs", "2*A*C*(B//2) - m", "2*A*C*(B//2)", "2*A*C", "2*A", "2", "A", "C", "B//2", "B", "2", "m", "abs(2*C*B*(A//2) - m)", "abs", "2*C*B*(A//2) - m", "2*C*B*(A//2)", "2*C*B", "2*C", "2", "C", "B", "A//2", "A", "2", "m", "abs(2*B*A*(C//2) - m)", "abs", "2*B*A*(C//2) - m", "2*B*A*(C//2)", "2*B*A", "2*B", "2", "B", "A", "C//2", "C", "2", "m", "print(ans)", "print", "ans", "main()", "main", "def main():\n A, B, C = map(int, open(0).read().split())\n\n m = A*B*C\n ans = min(abs(2*A*C*(B//2) - m), abs(2*C*B*(A//2) - m), abs(2*B*A*(C//2) - m))\n\n print(ans)", "def main():\n A, B, C = map(int, open(0).read().split())\n\n m = A*B*C\n ans = min(abs(2*A*C*(B//2) - m), abs(2*C*B*(A//2) - m), abs(2*B*A*(C//2) - m))\n\n print(ans)", "main" ]

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

[ [ 40, 2 ], [ 41, 15 ], [ 19, 18 ], [ 41, 18 ], [ 18, 23 ], [ 41, 34 ], [ 41, 37 ], [ 40, 41 ] ]

[ "ABC = list(map(int, input().split()))\n\nABC.sort()\nfor i in ABC:\n if i % 2 == 0:\n print(0)\n break\nelse:\n print(ABC[0] * ABC[1])\n", "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", "for i in ABC:\n if i % 2 == 0:\n print(0)\n break\nelse:\n print(ABC[0] * ABC[1])", "i", "ABC", "if i % 2 == 0:\n print(0)\n break", "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", "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, 28, 13, 39, 13, 13, 13, 14, 2, 2, 13, 17, 17, 4, 13, 17, 3, 0, 13, 4, 13, 2, 13, 13, 2, 13, 13, 2, 13, 13, 4, 13, 4, 13, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 54, 2 ], [ 54, 11 ], [ 54, 12 ], [ 15, 14 ], [ 14, 22 ], [ 57, 30 ], [ 49, 34 ], [ 52, 35 ], [ 52, 37 ], [ 55, 38 ], [ 55, 40 ], [ 49, 41 ], [ 58, 46 ], [ 54, 49 ], [ 54, 52 ], [ 54, 55 ], [ 57, 58 ] ]

[ "a,b,c=map(int,input().split())\nfor i in [a,b,c]:\n if i%2==0:\n print(0)\n break\nelse:\n s=min(a*b,b*c,c*a)\n print(int(s))", "a,b,c=map(int,input().split())", "a", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "c", "for i in [a,b,c]:\n if i%2==0:\n print(0)\n break\nelse:\n s=min(a*b,b*c,c*a)\n print(int(s))", "i", "[a,b,c]", "a", "b", "c", "if i%2==0:\n print(0)\n break", "i%2==0", "i%2", "i", "2", "0", "print(0)", "print", "0", "break", "s=min(a*b,b*c,c*a)", "s", "min(a*b,b*c,c*a)", "min", "a*b", "a", "b", "b*c", "b", "c", "c*a", "c", "a", "print(int(s))", "print", "int(s)", "int", "s", "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", "s=min(a*b,b*c,c*a)", "min(a*b,b*c,c*a)", "s" ]

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

[ [ 138, 2 ], [ 138, 11 ], [ 138, 12 ], [ 133, 18 ], [ 136, 23 ], [ 139, 28 ], [ 159, 35 ], [ 133, 39 ], [ 136, 41 ], [ 139, 42 ], [ 129, 44 ], [ 133, 48 ], [ 133, 50 ], [ 136, 52 ], [ 139, 53 ], [ 156, 55 ], [ 160, 59 ], [ 130, 60 ], [ 162, 62 ], [ 133, 65 ], [ 136, 67 ], [ 139, 69 ], [ 144, 71 ], [ 133, 74 ], [ 136, 76 ], [ 136, 78 ], [ 139, 80 ], [ 126, 82 ], [ 163, 86 ], [ 145, 87 ], [ 153, 89 ], [ 133, 92 ], [ 136, 93 ], [ 139, 95 ], [ 147, 98 ], [ 133, 101 ], [ 136, 102 ], [ 139, 104 ], [ 139, 106 ], [ 141, 109 ], [ 154, 113 ], [ 148, 114 ], [ 150, 116 ], [ 157, 119 ], [ 127, 120 ], [ 142, 121 ], [ 151, 124 ], [ 126, 127 ], [ 129, 130 ], [ 138, 133 ], [ 138, 136 ], [ 138, 139 ], [ 141, 142 ], [ 144, 145 ], [ 147, 148 ], [ 150, 151 ], [ 153, 154 ], [ 156, 157 ], [ 159, 160 ], [ 162, 163 ] ]

[ "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 r1=(A//2)*B*C\n b1=(A-A//2)*B*C\n val1=abs(r1-b1)\n r2=A*(B//2)*C\n b2=A*(B-B//2)*C\n val2=abs(r2-b2)\n r3=A*B*(C//2)\n b3=A*B*(C-C//2)\n val3=abs(r3-b3)\n ans=min(val1,val2,val3)\n print(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==0 or B%2==0 or C%2==0:\n print(0)\nelse:\n r1=(A//2)*B*C\n b1=(A-A//2)*B*C\n val1=abs(r1-b1)\n r2=A*(B//2)*C\n b2=A*(B-B//2)*C\n val2=abs(r2-b2)\n r3=A*B*(C//2)\n b3=A*B*(C-C//2)\n val3=abs(r3-b3)\n ans=min(val1,val2,val3)\n print(ans)", "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", "r1=(A//2)*B*C", "r1", "(A//2)*B*C", "(A//2)*B", "A//2", "A", "2", "B", "C", "b1=(A-A//2)*B*C", "b1", "(A-A//2)*B*C", "(A-A//2)*B", "A-A//2", "A", "A//2", "A", "2", "B", "C", "val1=abs(r1-b1)", "val1", "abs(r1-b1)", "abs", "r1-b1", "r1", "b1", "r2=A*(B//2)*C", "r2", "A*(B//2)*C", "A*(B//2)", "A", "B//2", "B", "2", "C", "b2=A*(B-B//2)*C", "b2", "A*(B-B//2)*C", "A*(B-B//2)", "A", "B-B//2", "B", "B//2", "B", "2", "C", "val2=abs(r2-b2)", "val2", "abs(r2-b2)", "abs", "r2-b2", "r2", "b2", "r3=A*B*(C//2)", "r3", "A*B*(C//2)", "A*B", "A", "B", "C//2", "C", "2", "b3=A*B*(C-C//2)", "b3", "A*B*(C-C//2)", "A*B", "A", "B", "C-C//2", "C", "C//2", "C", "2", "val3=abs(r3-b3)", "val3", "abs(r3-b3)", "abs", "r3-b3", "r3", "b3", "ans=min(val1,val2,val3)", "ans", "min(val1,val2,val3)", "min", "val1", "val2", "val3", "print(ans)", "print", "ans", "val2=abs(r2-b2)", "abs(r2-b2)", "val2", "b1=(A-A//2)*B*C", "(A-A//2)*B*C", "b1", "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", "val3=abs(r3-b3)", "abs(r3-b3)", "val3", "b2=A*(B-B//2)*C", "A*(B-B//2)*C", "b2", "b3=A*B*(C-C//2)", "A*B*(C-C//2)", "b3", "ans=min(val1,val2,val3)", "min(val1,val2,val3)", "ans", "r3=A*B*(C//2)", "A*B*(C//2)", "r3", "val1=abs(r1-b1)", "abs(r1-b1)", "val1", "r1=(A//2)*B*C", "(A//2)*B*C", "r1", "r2=A*(B//2)*C", "A*(B//2)*C", "r2" ]

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

[ [ 144, 2 ], [ 144, 11 ], [ 144, 12 ], [ 121, 18 ], [ 145, 19 ], [ 124, 20 ], [ 147, 24 ], [ 148, 28 ], [ 150, 30 ], [ 126, 35 ], [ 121, 38 ], [ 145, 39 ], [ 124, 40 ], [ 141, 42 ], [ 121, 44 ], [ 145, 45 ], [ 132, 47 ], [ 145, 49 ], [ 124, 50 ], [ 129, 52 ], [ 124, 54 ], [ 121, 55 ], [ 135, 57 ], [ 151, 60 ], [ 121, 66 ], [ 133, 68 ], [ 121, 72 ], [ 133, 75 ], [ 153, 77 ], [ 136, 80 ], [ 151, 80 ], [ 145, 86 ], [ 130, 88 ], [ 145, 92 ], [ 130, 95 ], [ 138, 97 ], [ 154, 100 ], [ 136, 100 ], [ 151, 100 ], [ 124, 106 ], [ 142, 108 ], [ 124, 112 ], [ 142, 115 ], [ 139, 118 ], [ 154, 118 ], [ 136, 118 ], [ 151, 118 ], [ 144, 121 ], [ 144, 124 ], [ 126, 127 ], [ 129, 130 ], [ 132, 133 ], [ 135, 136 ], [ 138, 139 ], [ 141, 142 ], [ 144, 145 ], [ 147, 148 ], [ 150, 151 ], [ 153, 154 ] ]

[ "A, B, C = map(int, input().split())\nif (A * B * C) % 2 == 0:\n ans = 0\n print(ans)\nelse:\n ans = float('inf')\n V = A*B*C\n AB = A*B\n BC = B*C\n CA = C*A\n ans = min(ans, abs((A//2)*BC - ((A//2) + 1)*BC))\n ans = min(ans, abs((B//2)*CA - ((B//2) + 1)*CA))\n ans = min(ans, abs((C//2)*AB - ((C//2) + 1)*AB))\n print(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\n print(ans)\nelse:\n ans = float('inf')\n V = A*B*C\n AB = A*B\n BC = B*C\n CA = C*A\n ans = min(ans, abs((A//2)*BC - ((A//2) + 1)*BC))\n ans = min(ans, abs((B//2)*CA - ((B//2) + 1)*CA))\n ans = min(ans, abs((C//2)*AB - ((C//2) + 1)*AB))\n print(ans)", "(A * B * C) % 2 == 0", "(A * B * C) % 2", "A * B * C", "A * B", "A", "B", "C", "2", "0", "ans = 0", "ans", "0", "print(ans)", "print", "ans", "ans = float('inf')", "ans", "float('inf')", "float", "'inf'", "V = A*B*C", "V", "A*B*C", "A*B", "A", "B", "C", "AB = A*B", "AB", "A*B", "A", "B", "BC = B*C", "BC", "B*C", "B", "C", "CA = C*A", "CA", "C*A", "C", "A", "ans = min(ans, abs((A//2)*BC - ((A//2) + 1)*BC))", "ans", "min(ans, abs((A//2)*BC - ((A//2) + 1)*BC))", "min", "ans", "abs((A//2)*BC - ((A//2) + 1)*BC)", "abs", "(A//2)*BC - ((A//2) + 1)*BC", "(A//2)*BC", "A//2", "A", "2", "BC", "((A//2) + 1)*BC", "(A//2) + 1", "A//2", "A", "2", "1", "BC", "ans = min(ans, abs((B//2)*CA - ((B//2) + 1)*CA))", "ans", "min(ans, abs((B//2)*CA - ((B//2) + 1)*CA))", "min", "ans", "abs((B//2)*CA - ((B//2) + 1)*CA)", "abs", "(B//2)*CA - ((B//2) + 1)*CA", "(B//2)*CA", "B//2", "B", "2", "CA", "((B//2) + 1)*CA", "(B//2) + 1", "B//2", "B", "2", "1", "CA", "ans = min(ans, abs((C//2)*AB - ((C//2) + 1)*AB))", "ans", "min(ans, abs((C//2)*AB - ((C//2) + 1)*AB))", "min", "ans", "abs((C//2)*AB - ((C//2) + 1)*AB)", "abs", "(C//2)*AB - ((C//2) + 1)*AB", "(C//2)*AB", "C//2", "C", "2", "AB", "((C//2) + 1)*AB", "(C//2) + 1", "C//2", "C", "2", "1", "AB", "print(ans)", "print", "ans", "A, B, C = map(int, input().split())", "map(int, input().split())", "A", "C = map(int, input().split())", "map(int, input().split())", "C", "V = A*B*C", "A*B*C", "V", "CA = C*A", "C*A", "CA", "BC = B*C", "B*C", "BC", "ans = min(ans, abs((A//2)*BC - ((A//2) + 1)*BC))", "min(ans, abs((A//2)*BC - ((A//2) + 1)*BC))", "ans", "ans = min(ans, abs((C//2)*AB - ((C//2) + 1)*AB))", "min(ans, abs((C//2)*AB - ((C//2) + 1)*AB))", "ans", "AB = A*B", "A*B", "AB", "B, C = map(int, input().split())", "map(int, input().split())", "B", "ans = 0", "0", "ans", "ans = float('inf')", "float('inf')", "ans", "ans = min(ans, abs((B//2)*CA - ((B//2) + 1)*CA))", "min(ans, abs((B//2)*CA - ((B//2) + 1)*CA))", "ans" ]

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

[ [ 38, 8 ], [ 40, 13 ], [ 42, 18 ], [ 25, 24 ], [ 25, 31 ], [ 25, 32 ], [ 24, 35 ], [ 38, 35 ], [ 31, 36 ], [ 40, 36 ], [ 38, 38 ], [ 40, 40 ], [ 42, 42 ], [ 58, 46 ] ]

[ "def solve(a, b, c):\n if a % 2 == 0 or b % 2 == 0 or c % 2 == 0:\n return 0\n a, b, c = sorted([a, b, c])\n return a * b\n\n\nprint(solve(*map(int, input().split())))", "def solve(a, b, c):\n if a % 2 == 0 or b % 2 == 0 or c % 2 == 0:\n return 0\n a, b, c = sorted([a, b, c])\n return a * b", "solve", "if a % 2 == 0 or b % 2 == 0 or c % 2 == 0:\n return 0\n ", "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", "return 0", "0", "a, b, c = sorted([a, b, c])", "a", "sorted([a, b, c])", "sorted", "[a, b, c]", "a", "b", "c", "b", "c", "return a * b", "a * b", "a", "b", "a", "a", "b", "b", "c", "c", "print(solve(*map(int, input().split())))", "print", "solve(*map(int, input().split()))", "solve", "*map(int, input().split())", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "def solve(a, b, c):\n if a % 2 == 0 or b % 2 == 0 or c % 2 == 0:\n return 0\n a, b, c = sorted([a, b, c])\n return a * b", "def solve(a, b, c):\n if a % 2 == 0 or b % 2 == 0 or c % 2 == 0:\n return 0\n a, b, c = sorted([a, b, c])\n return a * b", "solve" ]

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

[ [ 107, 4 ], [ 107, 13 ], [ 107, 14 ], [ 98, 16 ], [ 108, 23 ], [ 93, 25 ], [ 96, 26 ], [ 108, 34 ], [ 93, 36 ], [ 96, 37 ], [ 101, 39 ], [ 108, 45 ], [ 93, 47 ], [ 96, 49 ], [ 108, 52 ], [ 93, 58 ], [ 96, 60 ], [ 104, 62 ], [ 108, 68 ], [ 93, 69 ], [ 96, 71 ], [ 108, 75 ], [ 93, 76 ], [ 96, 82 ], [ 99, 88 ], [ 102, 89 ], [ 105, 90 ], [ 107, 93 ], [ 107, 96 ], [ 98, 99 ], [ 101, 102 ], [ 104, 105 ], [ 107, 108 ] ]

[ "import math\n\na, b, c = map(int, input().split())\n\na_half = abs(((a//2)*b*c)-(math.ceil(a/2)*b*c))\nb_half = abs((a*(b//2)*c)-(a*math.ceil(b/2)*c))\nc_half = abs((a*b*(c//2))-(a*b*math.ceil(c/2)))\n\nprint(min(a_half, b_half, c_half))", "import math", "math", "a, b, c = map(int, input().split())", "a", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "c", "a_half = abs(((a//2)*b*c)-(math.ceil(a/2)*b*c))", "a_half", "abs(((a//2)*b*c)-(math.ceil(a/2)*b*c))", "abs", "((a//2)*b*c)-(math.ceil(a/2)*b*c)", "(a//2)*b*c", "(a//2)*b", "a//2", "a", "2", "b", "c", "math.ceil(a/2)*b*c", "math.ceil(a/2)*b", "math.ceil(a/2)", "math.ceil", "math", "ceil", "a/2", "a", "2", "b", "c", "b_half = abs((a*(b//2)*c)-(a*math.ceil(b/2)*c))", "b_half", "abs((a*(b//2)*c)-(a*math.ceil(b/2)*c))", "abs", "(a*(b//2)*c)-(a*math.ceil(b/2)*c)", "a*(b//2)*c", "a*(b//2)", "a", "b//2", "b", "2", "c", "a*math.ceil(b/2)*c", "a*math.ceil(b/2)", "a", "math.ceil(b/2)", "math.ceil", "math", "ceil", "b/2", "b", "2", "c", "c_half = abs((a*b*(c//2))-(a*b*math.ceil(c/2)))", "c_half", "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", "print(min(a_half, b_half, c_half))", "print", "min(a_half, b_half, c_half)", "min", "a_half", "b_half", "c_half", "b, c = map(int, input().split())", "map(int, input().split())", "b", "c = map(int, input().split())", "map(int, input().split())", "c", "a_half = abs(((a//2)*b*c)-(math.ceil(a/2)*b*c))", "abs(((a//2)*b*c)-(math.ceil(a/2)*b*c))", "a_half", "b_half = abs((a*(b//2)*c)-(a*math.ceil(b/2)*c))", "abs((a*(b//2)*c)-(a*math.ceil(b/2)*c))", "b_half", "c_half = abs((a*b*(c//2))-(a*b*math.ceil(c/2)))", "abs((a*b*(c//2))-(a*b*math.ceil(c/2)))", "c_half", "a, b, c = map(int, input().split())", "map(int, input().split())", "a" ]

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

[ [ 40, 2 ], [ 18, 17 ], [ 41, 17 ], [ 17, 22 ], [ 41, 34 ], [ 41, 37 ], [ 40, 41 ] ]

[ "A = sorted(list(map(int, input().split())))\nprint(0 if any([a % 2 == 0 for a in A]) else 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", "a % 2 == 0 for a in A", "for a in A", "a", "A", "for a in A", "a % 2 == 0", "a % 2", "a", "2", "0", "print(0 if any([a % 2 == 0 for a in A]) else A[0] * A[1])", "print", "0 if any([a % 2 == 0 for a in A]) else A[0] * A[1]", "any([a % 2 == 0 for a in A])", "any", "[a % 2 == 0 for a in A]", "0", "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, 14, 2, 13, 17, 41, 28, 13, 4, 18, 4, 13, 13, 4, 4, 13, 13, 0, 13, 13, 0, 13, 17, 4, 18, 13, 13, 28, 13, 13, 14, 2, 2, 13, 17, 17, 0, 13, 17, 14, 13, 4, 13, 17, 4, 13, 2, 18, 13, 17, 18, 13, 17, 10, 13, 13, 10, 17, 13, 10, 17, 13 ]

[ [ 8, 7 ], [ 7, 16 ], [ 54, 18 ], [ 57, 21 ], [ 55, 25 ], [ 29, 28 ], [ 55, 28 ], [ 28, 33 ], [ 60, 37 ], [ 55, 48 ], [ 55, 51 ], [ 54, 55 ], [ 57, 58 ], [ 60, 61 ] ]

[ "if __name__ == '__main__':\n a = [int(i) for i in input().split()]\n flag = False\n a.sort()\n for i in a:\n if i %2 == 0:\n flag=True\n if flag:\n print(0)\n else:\n print(a[0]*a[1])", "if __name__ == '__main__':\n a = [int(i) for i in input().split()]\n flag = False\n a.sort()\n for i in a:\n if i %2 == 0:\n flag=True\n if flag:\n print(0)\n else:\n print(a[0]*a[1])", "__name__ == '__main__'", "__name__", "'__main__'", "int(i) for i in input().split()", "for i in input().split()", "i", "input().split()", "().split", "()", "input", "split", "for i in input().split()", "int(i)", "int", "i", "a = [int(i) for i in input().split()]", "a", "[int(i) for i in input().split()]", "flag = False", "flag", "False", "a.sort()", "a.sort", "a", "sort", "for i in a:\n if i %2 == 0:\n flag=True\n ", "i", "a", "if i %2 == 0:\n flag=True\n ", "i %2 == 0", "i %2", "i", "2", "0", "flag=True", "flag", "True", "if flag:\n print(0)\n else:\n print(a[0]*a[1])", "flag", "print(0)", "print", "0", "print(a[0]*a[1])", "print", "a[0]*a[1]", "a[0]", "a", "0", "a[1]", "a", "1", "a = [int(i) for i in input().split()]", "[int(i) for i in input().split()]", "a", "flag = False", "False", "flag", "flag=True", "True", "flag" ]

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

[ [ 93, 2 ], [ 93, 11 ], [ 93, 12 ], [ 84, 14 ], [ 82, 18 ], [ 79, 19 ], [ 94, 21 ], [ 94, 23 ], [ 82, 27 ], [ 79, 28 ], [ 94, 30 ], [ 87, 33 ], [ 94, 37 ], [ 79, 38 ], [ 82, 40 ], [ 82, 42 ], [ 94, 46 ], [ 79, 47 ], [ 82, 49 ], [ 90, 52 ], [ 82, 56 ], [ 94, 57 ], [ 79, 59 ], [ 79, 61 ], [ 82, 65 ], [ 94, 66 ], [ 79, 68 ], [ 85, 74 ], [ 88, 75 ], [ 91, 76 ], [ 93, 79 ], [ 93, 82 ], [ 84, 85 ], [ 87, 88 ], [ 90, 91 ], [ 93, 94 ] ]

[ "a, b, c = map(int, input().split())\n\nn1 = a*b*(c-c//2)- a*b*(c//2)\nn2 = c*b*(a-a//2)- c*b*(a//2)\nn3 = a*c*(b-b//2)- a*c*(b//2)\n\nprint(min(n1, n2, n3))", "a, b, c = map(int, input().split())", "a", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "c", "n1 = a*b*(c-c//2)- a*b*(c//2)", "n1", "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", "n2 = c*b*(a-a//2)- c*b*(a//2)", "n2", "c*b*(a-a//2)- c*b*(a//2)", "c*b*(a-a//2)", "c*b", "c", "b", "a-a//2", "a", "a//2", "a", "2", "c*b*(a//2)", "c*b", "c", "b", "a//2", "a", "2", "n3 = a*c*(b-b//2)- a*c*(b//2)", "n3", "a*c*(b-b//2)- a*c*(b//2)", "a*c*(b-b//2)", "a*c", "a", "c", "b-b//2", "b", "b//2", "b", "2", "a*c*(b//2)", "a*c", "a", "c", "b//2", "b", "2", "print(min(n1, n2, n3))", "print", "min(n1, n2, n3)", "min", "n1", "n2", "n3", "b, c = map(int, input().split())", "map(int, input().split())", "b", "a, b, c = map(int, input().split())", "map(int, input().split())", "a", "n1 = a*b*(c-c//2)- a*b*(c//2)", "a*b*(c-c//2)- a*b*(c//2)", "n1", "n2 = c*b*(a-a//2)- c*b*(a//2)", "c*b*(a-a//2)- c*b*(a//2)", "n2", "n3 = a*c*(b-b//2)- a*c*(b//2)", "a*c*(b-b//2)- a*c*(b//2)", "n3", "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, 4, 13, 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, 10, 4, 13 ]

[ [ 44, 2 ], [ 47, 14 ], [ 45, 17 ], [ 48, 23 ], [ 45, 23 ], [ 48, 26 ], [ 45, 26 ], [ 48, 31 ], [ 45, 31 ], [ 48, 35 ], [ 45, 35 ], [ 48, 40 ], [ 45, 40 ], [ 44, 45 ], [ 47, 48 ] ]

[ "L=list(map(int,input().split()))\nL=sorted(L)\nprint(L[0]*L[1]*((L[2]-L[2]//2)-L[2]//2))", "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", "print(L[0]*L[1]*((L[2]-L[2]//2)-L[2]//2))", "print", "L[0]*L[1]*((L[2]-L[2]//2)-L[2]//2)", "L[0]*L[1]", "L[0]", "L", "0", "L[1]", "L", "1", "(L[2]-L[2]//2)-L[2]//2", "L[2]-L[2]//2", "L[2]", "L", "2", "L[2]//2", "L[2]", "L", "2", "2", "L[2]//2", "L[2]", "L", "2", "2", "L=list(map(int,input().split()))", "list(map(int,input().split()))", "L", "L=sorted(L)", "sorted(L)", "L" ]

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

[ [ 108, 36 ], [ 106, 38 ], [ 108, 39 ], [ 108, 40 ], [ 97, 46 ], [ 109, 47 ], [ 91, 48 ], [ 87, 57 ], [ 97, 60 ], [ 109, 61 ], [ 91, 62 ], [ 84, 64 ], [ 97, 69 ], [ 109, 70 ], [ 91, 71 ], [ 88, 72 ], [ 97, 75 ], [ 109, 76 ], [ 91, 77 ], [ 88, 81 ], [ 85, 82 ], [ 84, 85 ], [ 87, 88 ], [ 108, 91 ], [ 108, 97 ], [ 108, 109 ] ]

[ "from collections import defaultdict\n\ndef readInt():\n return int(input())\ndef readInts():\n return list(map(int, input().split()))\ndef readChar():\n return input()\ndef readChars():\n return input().split()\n\na,b,c = readInts()\n\nif a*b*c%2==0:\n print(0)\n exit()\n\nx = min(a,b,c)\ny = (a+b+c)-x-max(a,b,c)\nprint(x*y)", "from collections import defaultdict", "def readInt():\n return int(input())", "readInt", "return int(input())", "int(input())", "int", "input()", "input", "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 readChar():\n return input()", "readChar", "return input()", "input()", "input", "def readChars():\n return input().split()", "readChars", "return input().split()", "input().split()", "().split", "()", "input", "split", "a,b,c = readInts()", "a", "readInts()", "readInts", "b", "c", "if a*b*c%2==0:\n print(0)\n exit()", "a*b*c%2==0", "a*b*c%2", "a*b*c", "a*b", "a", "b", "c", "2", "0", "print(0)", "print", "0", "exit()", "exit", "x = min(a,b,c)", "x", "min(a,b,c)", "min", "a", "b", "c", "y = (a+b+c)-x-max(a,b,c)", "y", "(a+b+c)-x-max(a,b,c)", "(a+b+c)-x", "a+b+c", "a+b", "a", "b", "c", "x", "max(a,b,c)", "max", "a", "b", "c", "print(x*y)", "print", "x*y", "x", "y", "y = (a+b+c)-x-max(a,b,c)", "(a+b+c)-x-max(a,b,c)", "y", "x = min(a,b,c)", "min(a,b,c)", "x", "c = readInts()", "readInts()", "c", "def readInt():\n return int(input())", "def readInt():\n return int(input())", "readInt", "a,b,c = readInts()", "readInts()", "a", "def readChar():\n return input()", "def readChar():\n return input()", "readChar", "def readChars():\n return input().split()", "def readChars():\n return input().split()", "readChars", "def readInts():\n return list(map(int, input().split()))", "def readInts():\n return list(map(int, input().split()))", "readInts", "b,c = readInts()", "readInts()", "b" ]

[ 7, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 4, 18, 13, 13, 0, 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 ]

[ [ 71, 2 ], [ 72, 15 ], [ 19, 18 ], [ 68, 21 ], [ 72, 25 ], [ 72, 28 ], [ 72, 31 ], [ 37, 34 ], [ 72, 35 ], [ 72, 39 ], [ 74, 43 ], [ 72, 47 ], [ 72, 50 ], [ 72, 53 ], [ 77, 56 ], [ 69, 58 ], [ 75, 59 ], [ 75, 65 ], [ 78, 66 ], [ 68, 69 ], [ 71, 72 ], [ 74, 75 ], [ 77, 78 ] ]

[ "a = list(map(int,input().split()))\na.sort(reverse = True)\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", "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, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 13, 0, 13, 39, 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, 13, 4, 13, 2, 18, 13, 17, 18, 13, 17, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 39, 13, 10, 4, 13 ]

[ [ 67, 2 ], [ 67, 11 ], [ 67, 12 ], [ 64, 14 ], [ 68, 24 ], [ 59, 29 ], [ 62, 34 ], [ 55, 41 ], [ 65, 44 ], [ 56, 49 ], [ 65, 49 ], [ 56, 52 ], [ 65, 52 ], [ 55, 56 ], [ 67, 59 ], [ 67, 62 ], [ 64, 65 ], [ 67, 68 ] ]

[ "A, B, C = map(int,input().split())\nnum = [A, B, C]\n\nif A % 2 == 0 or B % 2 == 0 or C % 2 == 0:\n print(0)\n\nelse:\n num = sorted(num)\n print(num[0] * num[1])\n\n ", "A, B, C = map(int,input().split())", "A", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "B", "C", "num = [A, B, C]", "num", "[A, B, C]", "A", "B", "C", "if A % 2 == 0 or B % 2 == 0 or C % 2 == 0:\n print(0)\n\nelse:\n num = sorted(num)\n print(num[0] * num[1])\n\n ", "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", "num = sorted(num)", "num", "sorted(num)", "sorted", "num", "print(num[0] * num[1])", "print", "num[0] * num[1]", "num[0]", "num", "0", "num[1]", "num", "1", "num = sorted(num)", "sorted(num)", "num", "B, C = map(int,input().split())", "map(int,input().split())", "B", "C = map(int,input().split())", "map(int,input().split())", "C", "num = [A, B, C]", "[A, B, C]", "num", "A, B, C = map(int,input().split())", "map(int,input().split())", "A" ]

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

[ [ 45, 10 ], [ 47, 15 ], [ 49, 20 ], [ 28, 27 ], [ 27, 38 ], [ 27, 41 ], [ 45, 45 ], [ 47, 47 ], [ 49, 49 ], [ 56, 55 ], [ 61, 60 ], [ 55, 63 ], [ 60, 66 ], [ 69, 68 ], [ 53, 70 ], [ 73, 72 ], [ 68, 77 ], [ 80, 79 ], [ 68, 84 ], [ 87, 86 ], [ 68, 91 ], [ 105, 93 ], [ 72, 94 ], [ 79, 95 ], [ 86, 96 ], [ 108, 102 ] ]

[ "#!/usr/bin/env python3\nimport sys\n\n\ndef solve(A: int, B: int, C: int):\n if A % 2 == 0 or B % 2 == 0 or C % 2 == 0:\n print(0)\n else:\n l = sorted([A, B, C])\n print(l[0] * l[1])\n return\n\n\n# Generated by 1.1.6 https://github.com/kyuridenamida/atcoder-tools (tips: You use the default template now. You can remove this line by using your custom template)\ndef main():\n def iterate_tokens():\n for line in sys.stdin:\n for word in line.split():\n yield word\n tokens = iterate_tokens()\n A = int(next(tokens)) # type: int\n B = int(next(tokens)) # type: int\n C = int(next(tokens)) # type: int\n solve(A, B, C)\n\nif __name__ == '__main__':\n main()", "import sys", "sys", "def solve(A: int, B: int, C: int):\n if A % 2 == 0 or B % 2 == 0 or C % 2 == 0:\n print(0)\n else:\n l = sorted([A, B, C])\n print(l[0] * l[1])\n return\n\n\n# Generated by 1.1.6 https://github.com/kyuridenamida/atcoder-tools (tips: You use the default template now. You can remove this line by using your custom template)", "solve", "if A % 2 == 0 or B % 2 == 0 or C % 2 == 0:\n print(0)\n else:\n l = sorted([A, B, C])\n print(l[0] * l[1])\n ", "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", "l = sorted([A, B, C])", "l", "sorted([A, B, C])", "sorted", "[A, B, C]", "A", "B", "C", "print(l[0] * l[1])", "print", "l[0] * l[1]", "l[0]", "l", "0", "l[1]", "l", "1", "return", "A: int", "A", "B: int", "B", "C: int", "C", "def main():\n def iterate_tokens():\n for line in sys.stdin:\n for word in line.split():\n yield word\n tokens = iterate_tokens()\n A = int(next(tokens)) # type: int\n B = int(next(tokens)) # type: int\n C = int(next(tokens)) # type: int\n solve(A, B, C)", "main", "def iterate_tokens():\n for line in sys.stdin:\n for word in line.split():\n yield word\n ", "iterate_tokens", "for line in sys.stdin:\n for word in line.split():\n yield word\n ", "line", "sys.stdin", "sys", "stdin", "for word in line.split():\n yield word\n ", "word", "line.split()", "line.split", "line", "split", "yield word", "word", "tokens = iterate_tokens()", "tokens", "iterate_tokens()", "iterate_tokens", "A = int(next(tokens))", "A", "int(next(tokens))", "int", "next(tokens)", "next", "tokens", "B = int(next(tokens))", "B", "int(next(tokens))", "int", "next(tokens)", "next", "tokens", "C = int(next(tokens))", "C", "int(next(tokens))", "int", "next(tokens)", "next", "tokens", "solve(A, B, C)", "solve", "A", "B", "C", "if __name__ == '__main__':\n main()", "__name__ == '__main__'", "__name__", "'__main__'", "main()", "main", "def solve(A: int, B: int, C: int):\n if A % 2 == 0 or B % 2 == 0 or C % 2 == 0:\n print(0)\n else:\n l = sorted([A, B, C])\n print(l[0] * l[1])\n return\n\n\n# Generated by 1.1.6 https://github.com/kyuridenamida/atcoder-tools (tips: You use the default template now. You can remove this line by using your custom template)", "def solve(A: int, B: int, C: int):\n if A % 2 == 0 or B % 2 == 0 or C % 2 == 0:\n print(0)\n else:\n l = sorted([A, B, C])\n print(l[0] * l[1])\n return\n\n\n# Generated by 1.1.6 https://github.com/kyuridenamida/atcoder-tools (tips: You use the default template now. You can remove this line by using your custom template)", "solve", "def main():\n def iterate_tokens():\n for line in sys.stdin:\n for word in line.split():\n yield word\n tokens = iterate_tokens()\n A = int(next(tokens)) # type: int\n B = int(next(tokens)) # type: int\n C = int(next(tokens)) # type: int\n solve(A, B, C)", "def main():\n def iterate_tokens():\n for line in sys.stdin:\n for word in line.split():\n yield word\n tokens = iterate_tokens()\n A = int(next(tokens)) # type: int\n B = int(next(tokens)) # type: int\n C = int(next(tokens)) # type: int\n solve(A, B, C)", "main" ]

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

[ [ 4, 3 ], [ 3, 12 ], [ 61, 14 ], [ 62, 18 ], [ 22, 21 ], [ 64, 33 ], [ 62, 38 ], [ 62, 41 ], [ 62, 45 ], [ 62, 48 ], [ 62, 52 ], [ 62, 55 ], [ 65, 59 ], [ 61, 62 ], [ 64, 65 ] ]

[ "l = [int(x) for x in input().split()]\n\nl.sort(reverse=True)\n\n\nif len([x for x in l if x % 2 == 0]) > 0:\n print(0)\nelse:\n ans = min(l[1]*l[2], l[0]*l[1], l[0]*l[2])\n print(ans)", "int(x) for x in input().split()", "for x in input().split()", "x", "input().split()", "().split", "()", "input", "split", "for x in input().split()", "int(x)", "int", "x", "l = [int(x) for x in input().split()]", "l", "[int(x) for x in input().split()]", "l.sort(reverse=True)", "l.sort", "l", "sort", "reverse=True", "reverse", "True", "if len([x for x in l if x % 2 == 0]) > 0:\n print(0)\nelse:\n ans = min(l[1]*l[2], l[0]*l[1], l[0]*l[2])\n print(ans)", "len([x for x in l if x % 2 == 0]) > 0", "len([x for x in l if x % 2 == 0])", "len", "[x for x in l if x % 2 == 0]", "0", "print(0)", "print", "0", "ans = min(l[1]*l[2], l[0]*l[1], l[0]*l[2])", "ans", "min(l[1]*l[2], l[0]*l[1], l[0]*l[2])", "min", "l[1]*l[2]", "l[1]", "l", "1", "l[2]", "l", "2", "l[0]*l[1]", "l[0]", "l", "0", "l[1]", "l", "1", "l[0]*l[2]", "l[0]", "l", "0", "l[2]", "l", "2", "print(ans)", "print", "ans", "l = [int(x) for x in input().split()]", "[int(x) for x in input().split()]", "l", "ans = min(l[1]*l[2], l[0]*l[1], l[0]*l[2])", "min(l[1]*l[2], l[0]*l[1], l[0]*l[2])", "ans" ]

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

[ [ 81, 4 ], [ 87, 13 ], [ 84, 22 ], [ 34, 33 ], [ 88, 40 ], [ 34, 42 ], [ 34, 43 ], [ 33, 49 ], [ 42, 50 ], [ 43, 51 ], [ 33, 63 ], [ 42, 64 ], [ 42, 66 ], [ 43, 67 ], [ 43, 69 ], [ 33, 70 ], [ 79, 76 ], [ 81, 82 ], [ 84, 85 ], [ 87, 88 ] ]

[ "import sys\nread = sys.stdin.buffer.read\nreadline = sys.stdin.buffer.readline\nreadlines = sys.stdin.buffer.readlines\n \ndef main():\n a, b, c = map(int, readline().split())\n if (a*b*c)%2 == 0:\n print(0)\n else:\n #すべて奇数\n print(min((a*b, b*c, c*a)))\nif __name__ == '__main__':\n main()", "import sys", "sys", "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", "def main():\n a, b, c = map(int, readline().split())\n if (a*b*c)%2 == 0:\n print(0)\n else:\n #すべて奇数\n print(min((a*b, b*c, c*a)))", "main", "a, b, c = map(int, readline().split())", "a", "map(int, readline().split())", "map", "int", "readline().split()", "().split", "()", "readline", "split", "b", "c", "if (a*b*c)%2 == 0:\n print(0)\n else:\n #すべて奇数\n print(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", "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", "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, readline().split())\n if (a*b*c)%2 == 0:\n print(0)\n else:\n #すべて奇数\n print(min((a*b, b*c, c*a)))", "def main():\n a, b, c = map(int, readline().split())\n if (a*b*c)%2 == 0:\n print(0)\n else:\n #すべて奇数\n print(min((a*b, b*c, c*a)))", "main", "read = sys.stdin.buffer.read", "sys.stdin.buffer.read", "read", "readlines = sys.stdin.buffer.readlines", "sys.stdin.buffer.readlines", "readlines", "readline = sys.stdin.buffer.readline", "sys.stdin.buffer.readline", "readline" ]

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

[ [ 96, 2 ], [ 96, 11 ], [ 96, 12 ], [ 17, 16 ], [ 79, 19 ], [ 81, 20 ], [ 83, 21 ], [ 79, 27 ], [ 81, 32 ], [ 83, 37 ], [ 46, 45 ], [ 45, 49 ], [ 79, 52 ], [ 81, 53 ], [ 45, 56 ], [ 81, 59 ], [ 83, 60 ], [ 45, 63 ], [ 79, 66 ], [ 83, 67 ], [ 70, 69 ], [ 45, 72 ], [ 69, 76 ], [ 45, 76 ], [ 79, 79 ], [ 81, 81 ], [ 83, 83 ], [ 100, 85 ], [ 94, 86 ], [ 91, 87 ], [ 97, 88 ], [ 96, 91 ], [ 96, 94 ], [ 96, 97 ] ]

[ "a,b,c=map(int,input().split())\n\ndef block(a,b,c):\n blocksum=a*b*c\n if a%2==0 or b%2==0 or c%2==0:\n print(0)\n return\n else:\n al=[]\n al.append(a*b)\n al.append(b*c)\n al.append(a*c)\n al=sorted(al)\n print(al[0])\nblock(a,b,c)", "a,b,c=map(int,input().split())", "a", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "c", "def block(a,b,c):\n blocksum=a*b*c\n if a%2==0 or b%2==0 or c%2==0:\n print(0)\n return\n else:\n al=[]\n al.append(a*b)\n al.append(b*c)\n al.append(a*c)\n al=sorted(al)\n print(al[0])", "block", "blocksum=a*b*c", "blocksum", "a*b*c", "a*b", "a", "b", "c", "if a%2==0 or b%2==0 or c%2==0:\n print(0)\n return\n else:\n al=[]\n al.append(a*b)\n al.append(b*c)\n al.append(a*c)\n al=sorted(al)\n print(al[0])", "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", "return", "al=[]", "al", "[]", "al.append(a*b)", "al.append", "al", "append", "a*b", "a", "b", "al.append(b*c)", "al.append", "al", "append", "b*c", "b", "c", "al.append(a*c)", "al.append", "al", "append", "a*c", "a", "c", "al=sorted(al)", "al", "sorted(al)", "sorted", "al", "print(al[0])", "print", "al[0]", "al", "0", "a", "a", "b", "b", "c", "c", "block(a,b,c)", "block", "a", "b", "c", "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", "def block(a,b,c):\n blocksum=a*b*c\n if a%2==0 or b%2==0 or c%2==0:\n print(0)\n return\n else:\n al=[]\n al.append(a*b)\n al.append(b*c)\n al.append(a*c)\n al=sorted(al)\n print(al[0])", "def block(a,b,c):\n blocksum=a*b*c\n if a%2==0 or b%2==0 or c%2==0:\n print(0)\n return\n else:\n al=[]\n al.append(a*b)\n al.append(b*c)\n al.append(a*c)\n al=sorted(al)\n print(al[0])", "block" ]

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

[ [ 107, 6 ], [ 122, 13 ], [ 108, 20 ], [ 122, 22 ], [ 122, 23 ], [ 131, 25 ], [ 111, 29 ], [ 123, 31 ], [ 120, 32 ], [ 125, 34 ], [ 132, 41 ], [ 111, 44 ], [ 123, 45 ], [ 120, 46 ], [ 132, 47 ], [ 116, 49 ], [ 123, 53 ], [ 111, 55 ], [ 120, 56 ], [ 104, 58 ], [ 117, 65 ], [ 111, 68 ], [ 123, 69 ], [ 120, 70 ], [ 117, 71 ], [ 113, 73 ], [ 120, 77 ], [ 111, 79 ], [ 123, 80 ], [ 128, 82 ], [ 114, 89 ], [ 111, 92 ], [ 123, 93 ], [ 120, 94 ], [ 114, 95 ], [ 126, 100 ], [ 132, 100 ], [ 105, 101 ], [ 117, 101 ], [ 129, 102 ], [ 114, 102 ], [ 104, 105 ], [ 107, 108 ], [ 122, 111 ], [ 113, 114 ], [ 116, 117 ], [ 122, 120 ], [ 122, 123 ], [ 125, 126 ], [ 128, 129 ], [ 131, 132 ] ]

[ "import math\nimport sys\n\ninput = sys.stdin.readline\na, b, c = map(int, input().split())\nx = (a//2)*b*c\nx = abs(abs(x-a*b*c)-x)\ny = (b//2)*a*c\ny = abs(abs(y-a*b*c)-y)\nz = (c//2)*a*b\nz = abs(abs(z-a*b*c)-z)\n\nprint(min(x, y, z))", "import math", "math", "import sys", "sys", "input = sys.stdin.readline", "input", "sys.stdin.readline", "sys.stdin", "sys", "stdin", "readline", "a, b, c = map(int, input().split())", "a", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "c", "x = (a//2)*b*c", "x", "(a//2)*b*c", "(a//2)*b", "a//2", "a", "2", "b", "c", "x = abs(abs(x-a*b*c)-x)", "x", "abs(abs(x-a*b*c)-x)", "abs", "abs(x-a*b*c)-x", "abs(x-a*b*c)", "abs", "x-a*b*c", "x", "a*b*c", "a*b", "a", "b", "c", "x", "y = (b//2)*a*c", "y", "(b//2)*a*c", "(b//2)*a", "b//2", "b", "2", "a", "c", "y = abs(abs(y-a*b*c)-y)", "y", "abs(abs(y-a*b*c)-y)", "abs", "abs(y-a*b*c)-y", "abs(y-a*b*c)", "abs", "y-a*b*c", "y", "a*b*c", "a*b", "a", "b", "c", "y", "z = (c//2)*a*b", "z", "(c//2)*a*b", "(c//2)*a", "c//2", "c", "2", "a", "b", "z = abs(abs(z-a*b*c)-z)", "z", "abs(abs(z-a*b*c)-z)", "abs", "abs(z-a*b*c)-z", "abs(z-a*b*c)", "abs", "z-a*b*c", "z", "a*b*c", "a*b", "a", "b", "c", "z", "print(min(x, y, z))", "print", "min(x, y, z)", "min", "x", "y", "z", "y = abs(abs(y-a*b*c)-y)", "abs(abs(y-a*b*c)-y)", "y", "input = sys.stdin.readline", "sys.stdin.readline", "input", "a, b, c = map(int, input().split())", "map(int, input().split())", "a", "z = (c//2)*a*b", "(c//2)*a*b", "z", "y = (b//2)*a*c", "(b//2)*a*c", "y", "c = map(int, input().split())", "map(int, input().split())", "c", "b, c = map(int, input().split())", "map(int, input().split())", "b", "x = abs(abs(x-a*b*c)-x)", "abs(abs(x-a*b*c)-x)", "x", "z = abs(abs(z-a*b*c)-z)", "abs(abs(z-a*b*c)-z)", "z", "x = (a//2)*b*c", "(a//2)*b*c", "x" ]

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

[ [ 5, 4 ], [ 5, 13 ], [ 5, 14 ], [ 4, 22 ], [ 13, 24 ], [ 14, 25 ], [ 13, 29 ], [ 4, 31 ], [ 14, 32 ], [ 14, 36 ], [ 4, 38 ], [ 13, 39 ], [ 44, 41 ] ]

[ "def main():\n A,B,C=map(int,input().split())\n print(min(A%2*B*C,B%2*A*C,C%2*A*B))\n\nmain()", "def main():\n A,B,C=map(int,input().split())\n print(min(A%2*B*C,B%2*A*C,C%2*A*B))", "main", "A,B,C=map(int,input().split())", "A", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "B", "C", "print(min(A%2*B*C,B%2*A*C,C%2*A*B))", "print", "min(A%2*B*C,B%2*A*C,C%2*A*B)", "min", "A%2*B*C", "A%2*B", "A%2", "A", "2", "B", "C", "B%2*A*C", "B%2*A", "B%2", "B", "2", "A", "C", "C%2*A*B", "C%2*A", "C%2", "C", "2", "A", "B", "main()", "main", "def main():\n A,B,C=map(int,input().split())\n print(min(A%2*B*C,B%2*A*C,C%2*A*B))", "def main():\n A,B,C=map(int,input().split())\n print(min(A%2*B*C,B%2*A*C,C%2*A*B))", "main" ]

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

[ [ 64, 2 ], [ 15, 14 ], [ 65, 22 ], [ 14, 23 ], [ 65, 33 ], [ 67, 36 ], [ 65, 39 ], [ 65, 42 ], [ 68, 48 ], [ 65, 52 ], [ 68, 57 ], [ 65, 60 ], [ 64, 65 ], [ 67, 68 ] ]

[ "a=list(map(int,input().split()))\n\nfor i in range(3):\n if a[i]%2==0:\n print(0)\n exit()\n\na.sort()\nma=a[0]*a[1]\nprint(ma*(a[2]//2+1)-ma*(a[2]//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", "for i in range(3):\n if a[i]%2==0:\n print(0)\n exit()", "i", "range(3)", "range", "3", "if a[i]%2==0:\n print(0)\n exit()", "a[i]%2==0", "a[i]%2", "a[i]", "a", "i", "2", "0", "print(0)", "print", "0", "exit()", "exit", "a.sort()", "a.sort", "a", "sort", "ma=a[0]*a[1]", "ma", "a[0]*a[1]", "a[0]", "a", "0", "a[1]", "a", "1", "print(ma*(a[2]//2+1)-ma*(a[2]//2))", "print", "ma*(a[2]//2+1)-ma*(a[2]//2)", "ma*(a[2]//2+1)", "ma", "a[2]//2+1", "a[2]//2", "a[2]", "a", "2", "2", "1", "ma*(a[2]//2)", "ma", "a[2]//2", "a[2]", "a", "2", "2", "a=list(map(int,input().split()))", "list(map(int,input().split()))", "a", "ma=a[0]*a[1]", "a[0]*a[1]", "ma" ]

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

[ [ 4, 3 ], [ 3, 12 ], [ 57, 14 ], [ 58, 22 ], [ 58, 29 ], [ 58, 36 ], [ 58, 45 ], [ 58, 51 ], [ 58, 54 ], [ 57, 58 ] ]

[ "a=[int(_) for _ in input().split()]\nif a[0]%2==0 or a[1]%2==0 or a[2]%2==0:\n print(0)\nelse:\n a.sort()\n print(a[0]*a[1])", "int(_) for _ in input().split()", "for _ in input().split()", "_", "input().split()", "().split", "()", "input", "split", "for _ in input().split()", "int(_)", "int", "_", "a=[int(_) for _ in input().split()]", "a", "[int(_) for _ in input().split()]", "if a[0]%2==0 or a[1]%2==0 or a[2]%2==0:\n print(0)\nelse:\n a.sort()\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", "a.sort()", "a.sort", "a", "sort", "print(a[0]*a[1])", "print", "a[0]*a[1]", "a[0]", "a", "0", "a[1]", "a", "1", "a=[int(_) for _ in input().split()]", "[int(_) for _ in 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, 2, 4, 13, 13, 13, 13, 17, 4, 13, 2, 2, 4, 13, 13, 13, 13, 2, 2, 2, 2, 13, 13, 13, 4, 13, 13, 13, 13, 4, 13, 13, 13, 13, 4, 13, 2, 2, 13, 4, 13, 13, 13, 13, 13, 10, 4, 13, 10, 2, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 90, 2 ], [ 90, 11 ], [ 90, 12 ], [ 91, 18 ], [ 88, 23 ], [ 82, 28 ], [ 84, 35 ], [ 91, 39 ], [ 88, 40 ], [ 82, 41 ], [ 91, 49 ], [ 88, 50 ], [ 82, 51 ], [ 91, 56 ], [ 88, 57 ], [ 82, 58 ], [ 91, 61 ], [ 88, 62 ], [ 82, 63 ], [ 91, 66 ], [ 88, 67 ], [ 82, 68 ], [ 85, 73 ], [ 91, 76 ], [ 88, 77 ], [ 82, 78 ], [ 85, 79 ], [ 90, 82 ], [ 84, 85 ], [ 90, 88 ], [ 90, 91 ] ]

[ "a,b,c=map(int,input().split())\nif a%2==0 or b%2==0 or c%2==0:\n print(0)\nelse:\n temp=max(a,b,c)//2 \n print(min(a,b,c)*(a+b+c-min(a,b,c)-max(a,b,c))*abs(temp-max(a,b,c)+temp))", "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 temp=max(a,b,c)//2 \n print(min(a,b,c)*(a+b+c-min(a,b,c)-max(a,b,c))*abs(temp-max(a,b,c)+temp))", "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", "temp=max(a,b,c)//2", "temp", "max(a,b,c)//2", "max(a,b,c)", "max", "a", "b", "c", "2", "print(min(a,b,c)*(a+b+c-min(a,b,c)-max(a,b,c))*abs(temp-max(a,b,c)+temp))", "print", "min(a,b,c)*(a+b+c-min(a,b,c)-max(a,b,c))*abs(temp-max(a,b,c)+temp)", "min(a,b,c)*(a+b+c-min(a,b,c)-max(a,b,c))", "min(a,b,c)", "min", "a", "b", "c", "a+b+c-min(a,b,c)-max(a,b,c)", "a+b+c-min(a,b,c)", "a+b+c", "a+b", "a", "b", "c", "min(a,b,c)", "min", "a", "b", "c", "max(a,b,c)", "max", "a", "b", "c", "abs(temp-max(a,b,c)+temp)", "abs", "temp-max(a,b,c)+temp", "temp-max(a,b,c)", "temp", "max(a,b,c)", "max", "a", "b", "c", "temp", "c=map(int,input().split())", "map(int,input().split())", "c", "temp=max(a,b,c)//2", "max(a,b,c)//2", "temp", "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, 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, 4, 13, 2, 18, 13, 17, 18, 13, 17, 2, 18, 13, 17, 18, 13, 17, 2, 18, 13, 17, 18, 13, 17, 10, 4, 13 ]

[ [ 66, 2 ], [ 67, 19 ], [ 67, 26 ], [ 67, 33 ], [ 67, 46 ], [ 67, 49 ], [ 67, 53 ], [ 67, 56 ], [ 67, 60 ], [ 67, 63 ], [ 66, 67 ] ]

[ "a = list(map(int,input().split()))\nif a[0] % 2 == 0 or a[1] % 2 == 0 or a[2] % 2 == 0:\n print(0)\nelse:\n print(min(a[0]*a[1],a[1]*a[2],a[0]*a[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", "if a[0] % 2 == 0 or a[1] % 2 == 0 or a[2] % 2 == 0:\n print(0)\nelse:\n print(min(a[0]*a[1],a[1]*a[2],a[0]*a[2]))", "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(min(a[0]*a[1],a[1]*a[2],a[0]*a[2]))", "print", "min(a[0]*a[1],a[1]*a[2],a[0]*a[2])", "min", "a[0]*a[1]", "a[0]", "a", "0", "a[1]", "a", "1", "a[1]*a[2]", "a[1]", "a", "1", "a[2]", "a", "2", "a[0]*a[2]", "a[0]", "a", "0", "a[2]", "a", "2", "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, 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, 4, 13, 2, 13, 13, 10, 4, 13, 10, 2, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 80, 2 ], [ 80, 11 ], [ 80, 12 ], [ 81, 18 ], [ 75, 23 ], [ 66, 28 ], [ 71, 35 ], [ 81, 38 ], [ 75, 39 ], [ 66, 40 ], [ 77, 42 ], [ 81, 45 ], [ 75, 46 ], [ 66, 47 ], [ 68, 49 ], [ 81, 53 ], [ 75, 54 ], [ 66, 55 ], [ 72, 57 ], [ 78, 58 ], [ 78, 62 ], [ 69, 63 ], [ 80, 66 ], [ 68, 69 ], [ 71, 72 ], [ 80, 75 ], [ 77, 78 ], [ 80, 81 ] ]

[ "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 = max(a,b,c)\n y = min(a,b,c)\n z = a+b+c -(x+y)\n print(y*z)", "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 = max(a,b,c)\n y = min(a,b,c)\n z = a+b+c -(x+y)\n print(y*z)", "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 = max(a,b,c)", "x", "max(a,b,c)", "max", "a", "b", "c", "y = min(a,b,c)", "y", "min(a,b,c)", "min", "a", "b", "c", "z = a+b+c -(x+y)", "z", "a+b+c -(x+y)", "a+b+c", "a+b", "a", "b", "c", "x+y", "x", "y", "print(y*z)", "print", "y*z", "y", "z", "c=map(int,input().split())", "map(int,input().split())", "c", "z = a+b+c -(x+y)", "a+b+c -(x+y)", "z", "x = max(a,b,c)", "max(a,b,c)", "x", "b,c=map(int,input().split())", "map(int,input().split())", "b", "y = min(a,b,c)", "min(a,b,c)", "y", "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, 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, 4, 13, 2, 13, 13, 2, 13, 13, 2, 13, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 58, 2 ], [ 58, 13 ], [ 58, 14 ], [ 59, 20 ], [ 56, 25 ], [ 53, 30 ], [ 59, 43 ], [ 56, 44 ], [ 56, 46 ], [ 53, 47 ], [ 53, 49 ], [ 59, 50 ], [ 58, 53 ], [ 58, 56 ], [ 58, 59 ] ]

[ "a,b,c = list(map(int, input().split()))\n\nif a%2==0 or b%2==0 or c%2==0:\n print(0)\n exit()\n\nprint(min(a*b, b*c, c*a))\n", "a,b,c = list(map(int, input().split()))", "a", "list(map(int, input().split()))", "list", "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(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 = list(map(int, input().split()))", "list(map(int, input().split()))", "c", "b,c = list(map(int, input().split()))", "list(map(int, input().split()))", "b", "a,b,c = list(map(int, input().split()))", "list(map(int, input().split()))", "a" ]

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

[ [ 53, 2 ], [ 53, 11 ], [ 53, 12 ], [ 47, 14 ], [ 51, 17 ], [ 54, 18 ], [ 45, 19 ], [ 51, 25 ], [ 54, 26 ], [ 45, 27 ], [ 48, 36 ], [ 53, 45 ], [ 47, 48 ], [ 53, 51 ], [ 53, 54 ] ]

[ "A, B, C = map(int, input().split())\nans = A*B*C\nif (A*B*C)%2==0:\n print(0)\nelse:\n print(ans//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", "ans = A*B*C", "ans", "A*B*C", "A*B", "A", "B", "C", "if (A*B*C)%2==0:\n print(0)\nelse:\n print(ans//max([A,B,C]))", "(A*B*C)%2==0", "(A*B*C)%2", "A*B*C", "A*B", "A", "B", "C", "2", "0", "print(0)", "print", "0", "print(ans//max([A,B,C]))", "print", "ans//max([A,B,C])", "ans", "max([A,B,C])", "max", "[A,B,C]", "A", "B", "C", "C = map(int, input().split())", "map(int, input().split())", "C", "ans = A*B*C", "A*B*C", "ans", "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, 2, 2, 13, 13, 13, 14, 2, 40, 13, 13, 40, 13, 13, 0, 13, 13, 0, 13, 13, 0, 13, 13, 14, 2, 40, 13, 13, 40, 13, 13, 0, 13, 13, 0, 13, 13, 0, 13, 13, 0, 13, 13, 0, 13, 13, 0, 13, 13, 14, 2, 2, 13, 17, 17, 0, 13, 17, 0, 13, 2, 2, 2, 13, 17, 13, 13, 4, 13, 13, 10, 13, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 2, 13, 10, 13, 13, 10, 13, 13, 10, 13, 13, 10, 13, 13, 10, 13, 13, 10, 13, 13, 10, 2, 13, 10, 13, 13, 10, 17, 13, 10, 13, 13 ]

[ [ 94, 2 ], [ 94, 11 ], [ 94, 12 ], [ 97, 14 ], [ 92, 17 ], [ 95, 18 ], [ 89, 19 ], [ 92, 23 ], [ 95, 24 ], [ 92, 26 ], [ 89, 27 ], [ 127, 29 ], [ 92, 30 ], [ 109, 32 ], [ 95, 33 ], [ 85, 35 ], [ 89, 36 ], [ 95, 40 ], [ 92, 41 ], [ 95, 43 ], [ 89, 44 ], [ 115, 46 ], [ 95, 47 ], [ 103, 49 ], [ 92, 50 ], [ 106, 52 ], [ 89, 53 ], [ 112, 55 ], [ 89, 56 ], [ 100, 58 ], [ 92, 59 ], [ 121, 61 ], [ 95, 62 ], [ 113, 66 ], [ 116, 66 ], [ 128, 66 ], [ 124, 70 ], [ 118, 73 ], [ 113, 77 ], [ 116, 77 ], [ 128, 77 ], [ 101, 79 ], [ 104, 79 ], [ 110, 79 ], [ 122, 80 ], [ 107, 80 ], [ 86, 80 ], [ 119, 83 ], [ 125, 83 ], [ 89, 85 ], [ 85, 86 ], [ 94, 89 ], [ 94, 92 ], [ 94, 95 ], [ 97, 98 ], [ 92, 100 ], [ 100, 101 ], [ 92, 103 ], [ 103, 104 ], [ 89, 106 ], [ 106, 107 ], [ 95, 109 ], [ 109, 110 ], [ 89, 112 ], [ 112, 113 ], [ 95, 115 ], [ 115, 116 ], [ 118, 119 ], [ 95, 121 ], [ 121, 122 ], [ 124, 125 ], [ 92, 127 ], [ 127, 128 ] ]

[ "\nA, B, C = map(int, input().split())\ntotal = A*B*C\nif A >= B and A >= C:\n x = A\n y = B\n z = C\nelif B >= A and B >= C:\n x = B\n y = A\n z = C\nelse:\n x = C\n y = A\n z = B\nif x % 2 == 0:\n ans = 0\nelse:\n ans = x % 2*y*z\nprint(ans)", "A, B, C = map(int, input().split())", "A", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "B", "C", "total = A*B*C", "total", "A*B*C", "A*B", "A", "B", "C", "if A >= B and A >= C:\n x = A\n y = B\n z = C\nelif B >= A and B >= C:\n x = B\n y = A\n z = C\nelse:\n x = C\n y = A\n z = B", "A >= B and A >= C", "A >= B", "A", "B", "A >= C", "A", "C", "x = A", "x", "A", "y = B", "y", "B", "z = C", "z", "C", "elif B >= A and B >= C:\n x = B\n y = A\n z = C", "B >= A and B >= C", "B >= A", "B", "A", "B >= C", "B", "C", "x = B", "x", "B", "y = A", "y", "A", "z = C", "z", "C", "x = C", "x", "C", "y = A", "y", "A", "z = B", "z", "B", "if x % 2 == 0:\n ans = 0\nelse:\n ans = x % 2*y*z", "x % 2 == 0", "x % 2", "x", "2", "0", "ans = 0", "ans", "0", "ans = x % 2*y*z", "ans", "x % 2*y*z", "x % 2*y", "x % 2", "x", "2", "y", "z", "print(ans)", "print", "ans", "z = C", "C", "z", "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", "total = A*B*C", "A*B*C", "total", "y = A", "A", "y", "y = A", "A", "y", "z = C", "C", "z", "y = B", "B", "y", "x = C", "C", "x", "x = B", "B", "x", "ans = x % 2*y*z", "x % 2*y*z", "ans", "z = B", "B", "z", "ans = 0", "0", "ans", "x = A", "A", "x" ]

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

[ [ 47, 6 ], [ 42, 8 ], [ 47, 9 ], [ 47, 10 ], [ 45, 16 ], [ 39, 17 ], [ 48, 18 ], [ 45, 29 ], [ 39, 30 ], [ 48, 31 ], [ 45, 34 ], [ 39, 35 ], [ 48, 36 ], [ 47, 39 ], [ 47, 45 ], [ 47, 48 ] ]

[ "import sys\ndef LI(): return list(map(int,sys.stdin.readline().rstrip().split()))\nA,B,C = LI()\nif A*B*C%2==0:\n print(0)\nelse:\n print(A*B*C//max(A,B,C))", "import sys", "sys", "def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))", "LI", "A,B,C = LI()", "A", "LI()", "LI", "B", "C", "if A*B*C%2==0:\n print(0)\nelse:\n print(A*B*C//max(A,B,C))", "A*B*C%2==0", "A*B*C%2", "A*B*C", "A*B", "A", "B", "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 = LI()", "LI()", "B", "def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))", "def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))", "LI", "A,B,C = LI()", "LI()", "A", "C = LI()", "LI()", "C" ]

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

[ [ 52, 3 ], [ 49, 26 ], [ 53, 35 ], [ 55, 38 ], [ 50, 41 ], [ 56, 41 ], [ 56, 47 ], [ 50, 47 ], [ 49, 50 ], [ 52, 53 ], [ 55, 56 ] ]

[ "from itertools import combinations\n\nABC = list(map(int, input().split()))\nif any(x % 2 == 0 for x in ABC):\n print(0)\nelse:\n ans = float(\"inf\")\n for a, b in combinations(ABC, 2):\n ans = min(ans, a * b)\n print(ans)", "from itertools import combinations", "ABC = list(map(int, input().split()))", "ABC", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "if any(x % 2 == 0 for x in ABC):\n print(0)\nelse:\n ans = float(\"inf\")\n for a, b in combinations(ABC, 2):\n ans = min(ans, a * b)\n print(ans)", "any(x % 2 == 0 for x in ABC)", "any", "x % 2 == 0", "x % 2", "x", "2", "0", "print(0)", "print", "0", "ans = float(\"inf\")", "ans", "float(\"inf\")", "float", "\"inf\"", "for a, b in combinations(ABC, 2):\n ans = min(ans, a * b)\n ", "a", "b", "combinations(ABC, 2)", "combinations", "ABC", "2", "ans = min(ans, a * b)", "ans", "min(ans, a * b)", "min", "ans", "a * b", "a", "b", "print(ans)", "print", "ans", "ans = float(\"inf\")", "float(\"inf\")", "ans", "ABC = list(map(int, input().split()))", "list(map(int, input().split()))", "ABC", "ans = min(ans, a * b)", "min(ans, a * b)", "ans" ]

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

[ [ 44, 2 ], [ 44, 11 ], [ 44, 12 ], [ 39, 29 ], [ 42, 30 ], [ 42, 32 ], [ 45, 33 ], [ 45, 35 ], [ 39, 36 ], [ 44, 39 ], [ 44, 42 ], [ 44, 45 ] ]

[ "a, b, c = map(int, input().split())\nif any(x % 2 == 0 for x in (a, b, c)):\n print(0)\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", "if any(x % 2 == 0 for x in (a, b, c)):\n print(0)\nelse:\n print(min(a*b, b*c, c*a))", "any(x % 2 == 0 for x in (a, b, c))", "any", "x % 2 == 0", "x % 2", "x", "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", "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, 41, 28, 13, 4, 18, 4, 13, 13, 4, 4, 13, 13, 0, 13, 13, 13, 13, 14, 2, 2, 2, 2, 13, 13, 13, 17, 17, 4, 13, 17, 0, 13, 4, 13, 39, 13, 13, 13, 4, 13, 2, 18, 13, 17, 18, 13, 17, 14, 2, 13, 17, 4, 13, 10, 12, 13 ]

[ [ 6, 5 ], [ 5, 14 ], [ 17, 16 ], [ 17, 18 ], [ 17, 19 ], [ 16, 25 ], [ 18, 26 ], [ 19, 27 ], [ 35, 34 ], [ 34, 45 ], [ 34, 48 ], [ 58, 55 ] ]

[ "def solve():\n A, B, C = [int(i) for i in input().split()]\n if (A + B + C) % 2 == 0:\n print(0)\n else:\n l = sorted([A, B, C])\n print(l[0] * l[1])\n\nif __name__ == \"__main__\":\n solve()", "def solve():\n A, B, C = [int(i) for i in input().split()]\n if (A + B + C) % 2 == 0:\n print(0)\n else:\n l = sorted([A, B, C])\n print(l[0] * l[1])", "solve", "int(i) for i in input().split()", "for i in input().split()", "i", "input().split()", "().split", "()", "input", "split", "for i in input().split()", "int(i)", "int", "i", "A, B, C = [int(i) for i in input().split()]", "A", "[int(i) for i in input().split()]", "B", "C", "if (A + B + C) % 2 == 0:\n print(0)\n else:\n l = sorted([A, B, C])\n print(l[0] * l[1])", "(A + B + C) % 2 == 0", "(A + B + C) % 2", "A + B + C", "A + B", "A", "B", "C", "2", "0", "print(0)", "print", "0", "l = sorted([A, B, C])", "l", "sorted([A, B, C])", "sorted", "[A, B, C]", "A", "B", "C", "print(l[0] * l[1])", "print", "l[0] * l[1]", "l[0]", "l", "0", "l[1]", "l", "1", "if __name__ == \"__main__\":\n solve()", "__name__ == \"__main__\"", "__name__", "\"__main__\"", "solve()", "solve", "def solve():\n A, B, C = [int(i) for i in input().split()]\n if (A + B + C) % 2 == 0:\n print(0)\n else:\n l = sorted([A, B, C])\n print(l[0] * l[1])", "def solve():\n A, B, C = [int(i) for i in input().split()]\n if (A + B + C) % 2 == 0:\n print(0)\n else:\n l = sorted([A, B, C])\n print(l[0] * l[1])", "solve" ]

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

[ [ 58, 2 ], [ 58, 11 ], [ 58, 12 ], [ 49, 14 ], [ 53, 18 ], [ 59, 19 ], [ 59, 21 ], [ 56, 22 ], [ 56, 24 ], [ 53, 25 ], [ 46, 27 ], [ 53, 30 ], [ 59, 31 ], [ 56, 32 ], [ 47, 36 ], [ 50, 44 ], [ 46, 47 ], [ 49, 50 ], [ 58, 53 ], [ 58, 56 ], [ 58, 59 ] ]

[ "a,b,c = map(int,input().split())\nans = min(a*b,b*c,c*a)\nx = max(a,b,c)\nprint (0) if x%2 == 0 else print (ans)", "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,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", "x = max(a,b,c)", "x", "max(a,b,c)", "max", "a", "b", "c", "print (0) if x%2 == 0 else print (ans)", "x%2 == 0", "x%2", "x", "2", "0", "print (0)", "print", "0", "print (ans)", "print", "ans", "x = max(a,b,c)", "max(a,b,c)", "x", "ans = min(a*b,b*c,c*a)", "min(a*b,b*c,c*a)", "ans", "a,b,c = map(int,input().split())", "map(int,input().split())", "a", "c = map(int,input().split())", "map(int,input().split())", "c", "b,c = map(int,input().split())", "map(int,input().split())", "b" ]

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

[ [ 34, 2 ], [ 35, 15 ], [ 35, 28 ], [ 35, 31 ], [ 34, 35 ] ]

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

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

[ [ 75, 4 ], [ 14, 13 ], [ 17, 16 ], [ 76, 23 ], [ 17, 25 ], [ 17, 26 ], [ 16, 32 ], [ 25, 33 ], [ 26, 34 ], [ 39, 38 ], [ 16, 42 ], [ 25, 43 ], [ 26, 44 ], [ 16, 48 ], [ 25, 49 ], [ 26, 50 ], [ 16, 54 ], [ 25, 55 ], [ 26, 56 ], [ 16, 59 ], [ 25, 60 ], [ 26, 61 ], [ 38, 64 ], [ 13, 64 ], [ 73, 70 ], [ 75, 76 ] ]

[ "import sys\n\ninput = sys.stdin.readline\n\ndef main():\n ans = 0\n A,B,C = map(int, input().split())\n if A*B*C%2 == 1:\n ans = min(A,B,C)*(A+B+C-(min(A,B,C)+max(A,B,C)))\n print(ans)\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 ans = 0\n A,B,C = map(int, input().split())\n if A*B*C%2 == 1:\n ans = min(A,B,C)*(A+B+C-(min(A,B,C)+max(A,B,C)))\n print(ans)", "main", "ans = 0", "ans", "0", "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 == 1:\n ans = min(A,B,C)*(A+B+C-(min(A,B,C)+max(A,B,C)))\n ", "A*B*C%2 == 1", "A*B*C%2", "A*B*C", "A*B", "A", "B", "C", "2", "1", "ans = min(A,B,C)*(A+B+C-(min(A,B,C)+max(A,B,C)))", "ans", "min(A,B,C)*(A+B+C-(min(A,B,C)+max(A,B,C)))", "min(A,B,C)", "min", "A", "B", "C", "A+B+C-(min(A,B,C)+max(A,B,C))", "A+B+C", "A+B", "A", "B", "C", "min(A,B,C)+max(A,B,C)", "min(A,B,C)", "min", "A", "B", "C", "max(A,B,C)", "max", "A", "B", "C", "print(ans)", "print", "ans", "if __name__ == '__main__':\n main()", "__name__ == '__main__'", "__name__", "'__main__'", "main()", "main", "def main():\n ans = 0\n A,B,C = map(int, input().split())\n if A*B*C%2 == 1:\n ans = min(A,B,C)*(A+B+C-(min(A,B,C)+max(A,B,C)))\n print(ans)", "def main():\n ans = 0\n A,B,C = map(int, input().split())\n if A*B*C%2 == 1:\n ans = min(A,B,C)*(A+B+C-(min(A,B,C)+max(A,B,C)))\n print(ans)", "main", "input = sys.stdin.readline", "sys.stdin.readline", "input" ]

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

[ [ 25, 24 ], [ 116, 30 ], [ 34, 34 ], [ 106, 43 ], [ 130, 48 ], [ 139, 55 ], [ 116, 57 ], [ 139, 58 ], [ 139, 59 ], [ 127, 61 ], [ 142, 69 ], [ 128, 73 ], [ 128, 76 ], [ 128, 80 ], [ 133, 84 ], [ 128, 88 ], [ 128, 91 ], [ 128, 97 ], [ 134, 103 ], [ 143, 104 ], [ 106, 107 ], [ 139, 122 ], [ 139, 125 ], [ 127, 128 ], [ 130, 131 ], [ 133, 134 ], [ 139, 140 ], [ 142, 143 ] ]

[ "import sys, re\nfrom collections import deque, defaultdict, Counter\nfrom math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians\nfrom itertools import accumulate, permutations, combinations, product\nfrom operator import itemgetter, mul\nfrom copy import deepcopy\nfrom string import ascii_lowercase, ascii_uppercase, digits\nfrom bisect import bisect, bisect_left\nfrom fractions import gcd\nfrom heapq import heappush, heappop\nfrom functools import reduce\ndef input(): return sys.stdin.readline().strip()\ndef INT(): return int(input())\ndef MAP(): return map(int, input().split())\ndef LIST(): return list(map(int, input().split()))\ndef ZIP(n): return zip(*(MAP() for _ in range(n)))\nsys.setrecursionlimit(10 ** 9)\nINF = float('inf')\nmod = 10 ** 9 + 7\n\nA, B, C = MAP()\nl = sorted([A, B, C])\nrV = l[0]*l[1]*(l[2]//2)\nbV = l[0]*l[1]*(-(-l[2]//2))\nprint(bV-rV)", "import sys, re", "sys", "re", "from collections import deque, defaultdict, Counter", "from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians", "from itertools import accumulate, permutations, combinations, product", "from operator import itemgetter, mul", "from copy import deepcopy", "from string import ascii_lowercase, ascii_uppercase, digits", "from bisect import bisect, bisect_left", "from fractions import gcd", "from heapq import heappush, heappop", "from functools import reduce", "def input(): return sys.stdin.readline().strip()", "input", "def INT(): return int(input())", "INT", "def MAP(): return map(int, input().split())", "MAP", "def LIST(): return list(map(int, input().split()))", "LIST", "MAP() for _ in range(n)", "for _ in range(n)", "_", "range(n)", "range", "n", "for _ in range(n)", "MAP()", "MAP", "def ZIP(n): return zip(*(MAP() for _ in range(n)))", "ZIP", "n", "n", "sys.setrecursionlimit(10 ** 9)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "10 ** 9", "10", "9", "INF = float('inf')", "INF", "float('inf')", "float", "'inf'", "mod = 10 ** 9 + 7", "mod", "10 ** 9 + 7", "10 ** 9", "10", "9", "7", "A, B, C = MAP()", "A", "MAP()", "MAP", "B", "C", "l = sorted([A, B, C])", "l", "sorted([A, B, C])", "sorted", "[A, B, C]", "A", "B", "C", "rV = l[0]*l[1]*(l[2]//2)", "rV", "l[0]*l[1]*(l[2]//2)", "l[0]*l[1]", "l[0]", "l", "0", "l[1]", "l", "1", "l[2]//2", "l[2]", "l", "2", "2", "bV = l[0]*l[1]*(-(-l[2]//2))", "bV", "l[0]*l[1]*(-(-l[2]//2))", "l[0]*l[1]", "l[0]", "l", "0", "l[1]", "l", "1", "-(-l[2]//2)", "-l[2]//2", "-l[2]", "l[2]", "l", "2", "2", "print(bV-rV)", "print", "bV-rV", "bV", "rV", "INF = float('inf')", "float('inf')", "INF", "def INT(): return int(input())", "def INT(): return int(input())", "INT", "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", "def LIST(): return list(map(int, input().split()))", "def LIST(): return list(map(int, input().split()))", "LIST", "A, B, C = MAP()", "MAP()", "A", "C = MAP()", "MAP()", "C", "l = sorted([A, B, C])", "sorted([A, B, C])", "l", "mod = 10 ** 9 + 7", "10 ** 9 + 7", "mod", "bV = l[0]*l[1]*(-(-l[2]//2))", "l[0]*l[1]*(-(-l[2]//2))", "bV", "def input(): return sys.stdin.readline().strip()", "def input(): return sys.stdin.readline().strip()", "input", "B, C = MAP()", "MAP()", "B", "rV = l[0]*l[1]*(l[2]//2)", "l[0]*l[1]*(l[2]//2)", "rV" ]

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

[ [ 66, 4 ], [ 81, 11 ], [ 67, 18 ], [ 81, 20 ], [ 81, 21 ], [ 76, 27 ], [ 73, 32 ], [ 82, 37 ], [ 69, 44 ], [ 76, 46 ], [ 73, 47 ], [ 78, 49 ], [ 73, 51 ], [ 82, 52 ], [ 84, 54 ], [ 82, 56 ], [ 76, 57 ], [ 70, 62 ], [ 79, 63 ], [ 85, 64 ], [ 66, 67 ], [ 69, 70 ], [ 81, 73 ], [ 81, 76 ], [ 78, 79 ], [ 81, 82 ], [ 84, 85 ] ]

[ "import sys\ninput = sys.stdin.readline\n\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 AB=A*B\n BC=B*C\n CA=C*A\n print(min(AB,BC,CA))\n\n", "import sys", "sys", "input = sys.stdin.readline", "input", "sys.stdin.readline", "sys.stdin", "sys", "stdin", "readline", "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 AB=A*B\n BC=B*C\n CA=C*A\n print(min(AB,BC,CA))", "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", "AB=A*B", "AB", "A*B", "A", "B", "BC=B*C", "BC", "B*C", "B", "C", "CA=C*A", "CA", "C*A", "C", "A", "print(min(AB,BC,CA))", "print", "min(AB,BC,CA)", "min", "AB", "BC", "CA", "input = sys.stdin.readline", "sys.stdin.readline", "input", "AB=A*B", "A*B", "AB", "B,C=map(int,input().split())", "map(int,input().split())", "B", "A,B,C=map(int,input().split())", "map(int,input().split())", "A", "BC=B*C", "B*C", "BC", "C=map(int,input().split())", "map(int,input().split())", "C", "CA=C*A", "C*A", "CA" ]

[ 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 main2():\n A, B, C = map(int, input().split())\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\nif __name__ == \"__main__\":\n main2()", "def main2():\n A, B, C = map(int, input().split())\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))", "main2", "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 main2()", "__name__ == \"__main__\"", "__name__", "\"__main__\"", "main2()", "main2", "def main2():\n A, B, C = map(int, input().split())\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 main2():\n A, B, C = map(int, input().split())\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))", "main2" ]

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

[ [ 54, 2 ], [ 54, 11 ], [ 54, 12 ], [ 42, 14 ], [ 43, 21 ], [ 48, 24 ], [ 43, 28 ], [ 43, 31 ], [ 43, 35 ], [ 49, 40 ], [ 42, 43 ], [ 54, 46 ], [ 48, 49 ], [ 54, 52 ], [ 54, 55 ] ]

[ "# https://atcoder.jp/contests/agc004/tasks/agc004_a\n\na, b, c = map(int, input().split())\n\nedges = [a, b, c]\nedges.sort()\n\nans = edges[0] * edges[1] * (edges[2] % 2)\nprint(ans)", "a, b, c = map(int, input().split())", "a", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "c", "edges = [a, b, c]", "edges", "[a, b, c]", "a", "b", "c", "edges.sort()", "edges.sort", "edges", "sort", "ans = edges[0] * edges[1] * (edges[2] % 2)", "ans", "edges[0] * edges[1] * (edges[2] % 2)", "edges[0] * edges[1]", "edges[0]", "edges", "0", "edges[1]", "edges", "1", "edges[2] % 2", "edges[2]", "edges", "2", "2", "print(ans)", "print", "ans", "edges = [a, b, c]", "[a, b, c]", "edges", "c = map(int, input().split())", "map(int, input().split())", "c", "ans = edges[0] * edges[1] * (edges[2] % 2)", "edges[0] * edges[1] * (edges[2] % 2)", "ans", "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, 13, 13, 13, 0, 13, 2, 2, 2, 13, 13, 13, 13, 0, 13, 2, 13, 17, 0, 13, 2, 13, 13, 0, 13, 4, 13, 2, 13, 2, 13, 13, 4, 13, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 2, 13, 10, 2, 13, 10, 4, 13, 10, 2, 13 ]

[ [ 61, 2 ], [ 61, 11 ], [ 61, 12 ], [ 58, 14 ], [ 56, 17 ], [ 53, 18 ], [ 62, 19 ], [ 73, 21 ], [ 56, 25 ], [ 53, 26 ], [ 62, 27 ], [ 59, 28 ], [ 67, 30 ], [ 59, 32 ], [ 64, 35 ], [ 59, 37 ], [ 68, 38 ], [ 70, 40 ], [ 74, 44 ], [ 68, 46 ], [ 65, 47 ], [ 71, 50 ], [ 61, 53 ], [ 61, 56 ], [ 58, 59 ], [ 61, 62 ], [ 64, 65 ], [ 67, 68 ], [ 70, 71 ], [ 73, 74 ] ]

[ "a, b, c = map(int,input().split())\nmaxim = max(a, b, c)\nbottom = a * b * c // maxim\nmedium = maxim // 2\nmedium1 = maxim - medium\n\nans = abs(bottom * (medium - medium1))\nprint(ans)", "a, b, c = map(int,input().split())", "a", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "c", "maxim = max(a, b, c)", "maxim", "max(a, b, c)", "max", "a", "b", "c", "bottom = a * b * c // maxim", "bottom", "a * b * c // maxim", "a * b * c", "a * b", "a", "b", "c", "maxim", "medium = maxim // 2", "medium", "maxim // 2", "maxim", "2", "medium1 = maxim - medium", "medium1", "maxim - medium", "maxim", "medium", "ans = abs(bottom * (medium - medium1))", "ans", "abs(bottom * (medium - medium1))", "abs", "bottom * (medium - medium1)", "bottom", "medium - medium1", "medium", "medium1", "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", "maxim = max(a, b, c)", "max(a, b, c)", "maxim", "c = map(int,input().split())", "map(int,input().split())", "c", "medium1 = maxim - medium", "maxim - medium", "medium1", "medium = maxim // 2", "maxim // 2", "medium", "ans = abs(bottom * (medium - medium1))", "abs(bottom * (medium - medium1))", "ans", "bottom = a * b * c // maxim", "a * b * c // maxim", "bottom" ]

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

[ [ 42, 2 ], [ 43, 15 ], [ 45, 18 ], [ 43, 21 ], [ 43, 29 ], [ 43, 32 ], [ 43, 37 ], [ 46, 39 ], [ 46, 40 ], [ 42, 43 ], [ 45, 46 ] ]

[ "V = list(map(int, input().split()))\nV.sort()\nL = V[2] // 2\nprint(V[0] * V[1] * (V[2] - L - L))", "V = list(map(int, input().split()))", "V", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "V.sort()", "V.sort", "V", "sort", "L = V[2] // 2", "L", "V[2] // 2", "V[2]", "V", "2", "2", "print(V[0] * V[1] * (V[2] - L - L))", "print", "V[0] * V[1] * (V[2] - L - L)", "V[0] * V[1]", "V[0]", "V", "0", "V[1]", "V", "1", "V[2] - L - L", "V[2] - L", "V[2]", "V", "2", "L", "L", "V = list(map(int, input().split()))", "list(map(int, input().split()))", "V", "L = V[2] // 2", "V[2] // 2", "L" ]

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

[ [ 5, 4 ], [ 4, 17 ], [ 4, 32 ], [ 4, 38 ], [ 4, 41 ], [ 54, 51 ] ]

[ "def main():\n num = list(map(int, input().split()))\n num.sort()\n\n if sum(list(map(lambda x: x % 2, num))) == 3:\n print(num[0]*num[1])\n else:\n print(0)\n\n\nif __name__ == \"__main__\":\n main()", "def main():\n num = list(map(int, input().split()))\n num.sort()\n\n if sum(list(map(lambda x: x % 2, num))) == 3:\n print(num[0]*num[1])\n else:\n print(0)", "main", "num = list(map(int, input().split()))", "num", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "num.sort()", "num.sort", "num", "sort", "if sum(list(map(lambda x: x % 2, num))) == 3:\n print(num[0]*num[1])\n else:\n print(0)", "sum(list(map(lambda x: x % 2, num))) == 3", "sum(list(map(lambda x: x % 2, num)))", "sum", "list(map(lambda x: x % 2, num))", "list", "map(lambda x: x % 2, num)", "map", "lambda x: x % 2", "x % 2", "x", "2", "x", "num", "3", "print(num[0]*num[1])", "print", "num[0]*num[1]", "num[0]", "num", "0", "num[1]", "num", "1", "print(0)", "print", "0", "if __name__ == \"__main__\":\n main()", "__name__ == \"__main__\"", "__name__", "\"__main__\"", "main()", "main", "def main():\n num = list(map(int, input().split()))\n num.sort()\n\n if sum(list(map(lambda x: x % 2, num))) == 3:\n print(num[0]*num[1])\n else:\n print(0)", "def main():\n num = list(map(int, input().split()))\n num.sort()\n\n if sum(list(map(lambda x: x % 2, num))) == 3:\n print(num[0]*num[1])\n else:\n print(0)", "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, 0, 13, 17, 0, 13, 4, 13, 13, 13, 13, 14, 2, 13, 13, 0, 13, 2, 2, 17, 13, 13, 14, 2, 13, 13, 0, 13, 2, 2, 17, 13, 13, 0, 13, 2, 2, 17, 13, 13, 4, 13, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 2, 13, 10, 17, 13, 10, 2, 13, 10, 2, 13 ]

[ [ 83, 2 ], [ 83, 11 ], [ 83, 12 ], [ 81, 18 ], [ 84, 23 ], [ 75, 28 ], [ 89, 32 ], [ 77, 35 ], [ 81, 38 ], [ 84, 39 ], [ 75, 40 ], [ 78, 43 ], [ 81, 44 ], [ 86, 46 ], [ 84, 50 ], [ 75, 51 ], [ 78, 54 ], [ 84, 55 ], [ 95, 57 ], [ 81, 61 ], [ 75, 62 ], [ 92, 64 ], [ 81, 68 ], [ 84, 69 ], [ 93, 72 ], [ 96, 72 ], [ 87, 72 ], [ 90, 72 ], [ 83, 75 ], [ 77, 78 ], [ 83, 81 ], [ 83, 84 ], [ 86, 87 ], [ 89, 90 ], [ 92, 93 ], [ 95, 96 ] ]

[ "A,B,C = map(int,input().split())\n\nif((A%2 == 0)or(B%2 == 0)or(C%2 == 0)):\n ans = 0\nelse:\n max_num = max(A,B,C) \n if(max_num == A): \n ans = 1*B*C\n elif(max_num == B):\n ans = 1*A*C\n else:\n ans = 1*A*B\n\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 == 0)or(B%2 == 0)or(C%2 == 0)):\n ans = 0\nelse:\n max_num = max(A,B,C) \n if(max_num == A): \n ans = 1*B*C\n elif(max_num == B):\n ans = 1*A*C\n else:\n ans = 1*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", "max_num = max(A,B,C)", "max_num", "max(A,B,C)", "max", "A", "B", "C", "if(max_num == A): \n ans = 1*B*C\n elif(max_num == B):\n ans = 1*A*C\n else:\n ans = 1*A*B", "max_num == A", "max_num", "A", "ans = 1*B*C", "ans", "1*B*C", "1*B", "1", "B", "C", "elif(max_num == B):\n ans = 1*A*C\n ", "max_num == B", "max_num", "B", "ans = 1*A*C", "ans", "1*A*C", "1*A", "1", "A", "C", "ans = 1*A*B", "ans", "1*A*B", "1*A", "1", "A", "B", "print(ans)", "print", "ans", "C = map(int,input().split())", "map(int,input().split())", "C", "max_num = max(A,B,C)", "max(A,B,C)", "max_num", "A,B,C = map(int,input().split())", "map(int,input().split())", "A", "B,C = map(int,input().split())", "map(int,input().split())", "B", "ans = 1*B*C", "1*B*C", "ans", "ans = 0", "0", "ans", "ans = 1*A*B", "1*A*B", "ans", "ans = 1*A*C", "1*A*C", "ans" ]

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

[ [ 59, 5 ], [ 17, 16 ], [ 56, 21 ], [ 60, 25 ], [ 60, 29 ], [ 57, 34 ], [ 53, 41 ], [ 60, 44 ], [ 60, 47 ], [ 54, 51 ], [ 53, 54 ], [ 56, 57 ], [ 59, 60 ] ]

[ "# from math import factorial,sqrt,ceil,gcd\n# from itertools import permutations as permus\nfrom collections import deque,Counter\n# import re\n# from functools import lru_cache # 簡単メモ化 @lru_cache(maxsize=1000)\n# from decimal import Decimal, getcontext\n# # getcontext().prec = 1000\n# # eps = Decimal(10) ** (-100)\n\nimport numpy as np\n# import networkx as nx\n# from scipy.sparse.csgraph import shortest_path, dijkstra, floyd_warshall, bellman_ford, johnson\n# from scipy.sparse import csr_matrix\n# from scipy.special import comb\n\n# slist = \"abcdefghijklmnopqrstuvwxyz\"\narrABC = np.array(input().split(),dtype=np.int64)\ncnt = Counter(arrABC % 2)\narrABC.sort()\nif cnt[0] > 0:\n print(0)\nelse:\n ans = arrABC[0]*arrABC[1]\n print(ans)\n\n# print(*ans) # unpackして出力。間にスペースが入る\n# for row in board:\n# print(*row,sep=\"\") #unpackして間にスペース入れずに出力する\n# print(\"{:.10f}\".format(ans))\n# print(\"{:0=10d}\".format(ans))", "from collections import deque,Counter", "import numpy as np", "numpy", "arrABC = np.array(input().split(),dtype=np.int64)", "arrABC", "np.array(input().split(),dtype=np.int64)", "np.array", "np", "array", "input().split()", "().split", "()", "input", "split", "dtype=np.int64", "dtype", "np.int64", "np", "int64", "cnt = Counter(arrABC % 2)", "cnt", "Counter(arrABC % 2)", "Counter", "arrABC % 2", "arrABC", "2", "arrABC.sort()", "arrABC.sort", "arrABC", "sort", "if cnt[0] > 0:\n print(0)\nelse:\n ans = arrABC[0]*arrABC[1]\n print(ans)\n\n# print(*ans) # unpackして出力。間にスペースが入る\n# for row in board:\n# print(*row,sep=\"\") #unpackして間にスペース入れずに出力する\n# print(\"{:.10f}\".format(ans))\n# print(\"{:0=10d}\".format(ans))", "cnt[0] > 0", "cnt[0]", "cnt", "0", "0", "print(0)", "print", "0", "ans = arrABC[0]*arrABC[1]", "ans", "arrABC[0]*arrABC[1]", "arrABC[0]", "arrABC", "0", "arrABC[1]", "arrABC", "1", "print(ans)", "print", "ans", "ans = arrABC[0]*arrABC[1]", "arrABC[0]*arrABC[1]", "ans", "cnt = Counter(arrABC % 2)", "Counter(arrABC % 2)", "cnt", "arrABC = np.array(input().split(),dtype=np.int64)", "np.array(input().split(),dtype=np.int64)", "arrABC" ]

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

[ [ 75, 2 ], [ 76, 19 ], [ 76, 26 ], [ 76, 33 ], [ 72, 41 ], [ 76, 44 ], [ 76, 48 ], [ 76, 52 ], [ 78, 54 ], [ 76, 57 ], [ 76, 61 ], [ 76, 65 ], [ 73, 69 ], [ 79, 70 ], [ 72, 73 ], [ 75, 76 ], [ 78, 79 ] ]

[ "l = list(map(int, input().split()))\nif(l[0] %2 == 0 or l[1] %2==0 or l[2]%2==0):\n print(0)\nelse:\n a = l.pop(l.index(min(l)))\n b = l.pop(l.index(min(l)))\n print(a*b)", "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 a = l.pop(l.index(min(l)))\n b = l.pop(l.index(min(l)))\n print(a*b)", "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", "a = l.pop(l.index(min(l)))", "a", "l.pop(l.index(min(l)))", "l.pop", "l", "pop", "l.index(min(l))", "l.index", "l", "index", "min(l)", "min", "l", "b = l.pop(l.index(min(l)))", "b", "l.pop(l.index(min(l)))", "l.pop", "l", "pop", "l.index(min(l))", "l.index", "l", "index", "min(l)", "min", "l", "print(a*b)", "print", "a*b", "a", "b", "a = l.pop(l.index(min(l)))", "l.pop(l.index(min(l)))", "a", "l = list(map(int, input().split()))", "list(map(int, input().split()))", "l", "b = l.pop(l.index(min(l)))", "l.pop(l.index(min(l)))", "b" ]

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

[ [ 100, 2 ], [ 100, 11 ], [ 100, 12 ], [ 73, 14 ], [ 89, 21 ], [ 85, 25 ], [ 97, 28 ], [ 74, 31 ], [ 83, 33 ], [ 101, 34 ], [ 83, 38 ], [ 94, 42 ], [ 91, 45 ], [ 98, 48 ], [ 86, 48 ], [ 74, 48 ], [ 101, 50 ], [ 89, 51 ], [ 101, 55 ], [ 76, 59 ], [ 79, 62 ], [ 92, 65 ], [ 95, 65 ], [ 98, 65 ], [ 86, 65 ], [ 74, 65 ], [ 89, 67 ], [ 83, 68 ], [ 80, 71 ], [ 77, 71 ], [ 92, 71 ], [ 95, 71 ], [ 98, 71 ], [ 86, 71 ], [ 74, 71 ], [ 73, 74 ], [ 76, 77 ], [ 79, 80 ], [ 100, 83 ], [ 85, 86 ], [ 100, 89 ], [ 91, 92 ], [ 94, 95 ], [ 97, 98 ], [ 100, 101 ] ]

[ "A, B, C = map(int, input().split())\nans = 10**18\n\nif A%2==0:\n ans = 0\nelse:\n ans = min(ans, B*C)\n\nif B%2==0:\n ans = 0\nelse:\n ans = min(ans, C*A)\n\nif C%2==0:\n ans = 0\nelse:\n ans = min(ans, A*B)\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 = 10**18", "ans", "10**18", "10", "18", "if A%2==0:\n ans = 0\nelse:\n ans = min(ans, B*C)", "A%2==0", "A%2", "A", "2", "0", "ans = 0", "ans", "0", "ans = min(ans, B*C)", "ans", "min(ans, B*C)", "min", "ans", "B*C", "B", "C", "if B%2==0:\n ans = 0\nelse:\n ans = min(ans, C*A)", "B%2==0", "B%2", "B", "2", "0", "ans = 0", "ans", "0", "ans = min(ans, C*A)", "ans", "min(ans, C*A)", "min", "ans", "C*A", "C", "A", "if C%2==0:\n ans = 0\nelse:\n ans = min(ans, A*B)", "C%2==0", "C%2", "C", "2", "0", "ans = 0", "ans", "0", "ans = min(ans, A*B)", "ans", "min(ans, A*B)", "min", "ans", "A*B", "A", "B", "print(ans)", "print", "ans", "ans = 10**18", "10**18", "ans", "ans = 0", "0", "ans", "ans = min(ans, A*B)", "min(ans, A*B)", "ans", "B, C = map(int, input().split())", "map(int, input().split())", "B", "ans = 0", "0", "ans", "A, B, C = map(int, input().split())", "map(int, input().split())", "A", "ans = min(ans, C*A)", "min(ans, C*A)", "ans", "ans = 0", "0", "ans", "ans = min(ans, B*C)", "min(ans, B*C)", "ans", "C = map(int, input().split())", "map(int, input().split())", "C" ]

[ 7, 0, 31, 13, 4, 13, 13, 4, 18, 4, 13, 13, 4, 18, 13, 13, 4, 13, 2, 2, 2, 2, 17, 2, 40, 18, 13, 17, 17, 2, 18, 13, 17, 17, 18, 13, 17, 18, 13, 17 ]

[ [ 4, 2 ] ]

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

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

[ [ 56, 3 ], [ 56, 12 ], [ 56, 13 ], [ 48, 19 ], [ 54, 20 ], [ 57, 21 ], [ 50, 28 ], [ 48, 40 ], [ 54, 41 ], [ 57, 42 ], [ 51, 45 ], [ 56, 48 ], [ 50, 51 ], [ 56, 54 ], [ 56, 57 ] ]

[ "from decimal import Decimal\nA, B, C = map(int, input().split())\n\nif A*B*C%2==0:\n print(0)\nelse:\n big = max([A, B, C])\n print((A*B*C/Decimal(big)))", "from decimal import Decimal", "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 print(0)\nelse:\n big = max([A, B, C])\n print((A*B*C/Decimal(big)))", "A*B*C%2==0", "A*B*C%2", "A*B*C", "A*B", "A", "B", "C", "2", "0", "print(0)", "print", "0", "big = max([A, B, C])", "big", "max([A, B, C])", "max", "[A, B, C]", "A", "B", "C", "print((A*B*C/Decimal(big)))", "print", "A*B*C/Decimal(big)", "A*B*C", "A*B", "A", "B", "C", "Decimal(big)", "Decimal", "big", "A, B, C = map(int, input().split())", "map(int, input().split())", "A", "big = max([A, B, C])", "max([A, B, C])", "big", "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, 2, 13, 17, 0, 13, 2, 2, 13, 13, 2, 13, 2, 13, 17, 0, 13, 4, 13, 2, 13, 13, 0, 13, 2, 2, 13, 13, 2, 13, 17, 0, 13, 2, 2, 13, 13, 2, 13, 2, 13, 17, 0, 13, 4, 13, 2, 13, 13, 0, 13, 2, 2, 13, 13, 2, 13, 17, 0, 13, 2, 2, 13, 13, 2, 13, 2, 13, 17, 0, 13, 4, 13, 2, 13, 13, 4, 13, 4, 13, 13, 13, 13, 10, 2, 13, 10, 4, 13, 10, 2, 13, 10, 2, 13, 10, 4, 13, 10, 2, 13, 10, 2, 13, 10, 4, 13, 10, 4, 13, 10, 2, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 135, 2 ], [ 135, 11 ], [ 135, 12 ], [ 120, 14 ], [ 133, 17 ], [ 136, 18 ], [ 115, 20 ], [ 108, 23 ], [ 133, 26 ], [ 136, 27 ], [ 115, 29 ], [ 115, 31 ], [ 126, 34 ], [ 121, 38 ], [ 109, 39 ], [ 102, 41 ], [ 136, 44 ], [ 115, 45 ], [ 133, 47 ], [ 129, 50 ], [ 136, 53 ], [ 115, 54 ], [ 133, 56 ], [ 133, 58 ], [ 105, 61 ], [ 103, 65 ], [ 130, 66 ], [ 117, 68 ], [ 115, 71 ], [ 133, 72 ], [ 136, 74 ], [ 111, 77 ], [ 115, 80 ], [ 133, 81 ], [ 136, 83 ], [ 136, 85 ], [ 123, 88 ], [ 118, 92 ], [ 112, 93 ], [ 106, 98 ], [ 127, 99 ], [ 124, 100 ], [ 102, 103 ], [ 105, 106 ], [ 108, 109 ], [ 111, 112 ], [ 135, 115 ], [ 117, 118 ], [ 120, 121 ], [ 123, 124 ], [ 126, 127 ], [ 129, 130 ], [ 135, 133 ], [ 135, 136 ] ]

[ "x,y,z=map(int,input().split())\ns=x*y*(z//2)\nss=x*y*(z-z//2)\nl=abs(s-ss)\nc=y*z*(x//2)\ncc=y*z*(x-x//2)\nr=abs(c-cc)\nd=z*x*(y//2)\ndd=z*x*(y-y//2)\np=abs(d-dd)\nprint(min(r,l,p))", "x,y,z=map(int,input().split())", "x", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "y", "z", "s=x*y*(z//2)", "s", "x*y*(z//2)", "x*y", "x", "y", "z//2", "z", "2", "ss=x*y*(z-z//2)", "ss", "x*y*(z-z//2)", "x*y", "x", "y", "z-z//2", "z", "z//2", "z", "2", "l=abs(s-ss)", "l", "abs(s-ss)", "abs", "s-ss", "s", "ss", "c=y*z*(x//2)", "c", "y*z*(x//2)", "y*z", "y", "z", "x//2", "x", "2", "cc=y*z*(x-x//2)", "cc", "y*z*(x-x//2)", "y*z", "y", "z", "x-x//2", "x", "x//2", "x", "2", "r=abs(c-cc)", "r", "abs(c-cc)", "abs", "c-cc", "c", "cc", "d=z*x*(y//2)", "d", "z*x*(y//2)", "z*x", "z", "x", "y//2", "y", "2", "dd=z*x*(y-y//2)", "dd", "z*x*(y-y//2)", "z*x", "z", "x", "y-y//2", "y", "y//2", "y", "2", "p=abs(d-dd)", "p", "abs(d-dd)", "abs", "d-dd", "d", "dd", "print(min(r,l,p))", "print", "min(r,l,p)", "min", "r", "l", "p", "c=y*z*(x//2)", "y*z*(x//2)", "c", "r=abs(c-cc)", "abs(c-cc)", "r", "ss=x*y*(z-z//2)", "x*y*(z-z//2)", "ss", "dd=z*x*(y-y//2)", "z*x*(y-y//2)", "dd", "z=map(int,input().split())", "map(int,input().split())", "z", "d=z*x*(y//2)", "z*x*(y//2)", "d", "s=x*y*(z//2)", "x*y*(z//2)", "s", "p=abs(d-dd)", "abs(d-dd)", "p", "l=abs(s-ss)", "abs(s-ss)", "l", "cc=y*z*(x-x//2)", "y*z*(x-x//2)", "cc", "x,y,z=map(int,input().split())", "map(int,input().split())", "x", "y,z=map(int,input().split())", "map(int,input().split())", "y" ]

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

[ [ 69, 2 ], [ 70, 18 ], [ 70, 21 ], [ 70, 24 ], [ 75, 28 ], [ 34, 33 ], [ 72, 38 ], [ 76, 41 ], [ 73, 41 ], [ 70, 46 ], [ 33, 47 ], [ 70, 49 ], [ 33, 52 ], [ 70, 56 ], [ 33, 59 ], [ 73, 64 ], [ 76, 64 ], [ 69, 70 ], [ 72, 73 ], [ 75, 76 ] ]

[ "a = list(map(int, input().split()))\nif a[0] * a[1] * a[2] % 2:\n ans = 10 ** 19\n for i in range(3):\n ans = min(ans, min(a[i], a[(i + 1) % 3]) * a[(i + 2) % 3])\n print(ans)\nelse:\n print(0)", "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 a[0] * a[1] * a[2] % 2:\n ans = 10 ** 19\n for i in range(3):\n ans = min(ans, min(a[i], a[(i + 1) % 3]) * a[(i + 2) % 3])\n print(ans)\nelse:\n print(0)", "a[0] * a[1] * a[2] % 2", "a[0] * a[1] * a[2]", "a[0] * a[1]", "a[0]", "a", "0", "a[1]", "a", "1", "a[2]", "a", "2", "2", "ans = 10 ** 19", "ans", "10 ** 19", "10", "19", "for i in range(3):\n ans = min(ans, min(a[i], a[(i + 1) % 3]) * a[(i + 2) % 3])\n ", "i", "range(3)", "range", "3", "ans = min(ans, min(a[i], a[(i + 1) % 3]) * a[(i + 2) % 3])", "ans", "min(ans, min(a[i], a[(i + 1) % 3]) * a[(i + 2) % 3])", "min", "ans", "min(a[i], a[(i + 1) % 3]) * a[(i + 2) % 3]", "min(a[i], a[(i + 1) % 3])", "min", "a[i]", "a", "i", "a[(i + 1) % 3]", "a", "(i + 1) % 3", "i + 1", "i", "1", "3", "a[(i + 2) % 3]", "a", "(i + 2) % 3", "i + 2", "i", "2", "3", "print(ans)", "print", "ans", "print(0)", "print", "0", "a = list(map(int, input().split()))", "list(map(int, input().split()))", "a", "ans = min(ans, min(a[i], a[(i + 1) % 3]) * a[(i + 2) % 3])", "min(ans, min(a[i], a[(i + 1) % 3]) * a[(i + 2) % 3])", "ans", "ans = 10 ** 19", "10 ** 19", "ans" ]

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

[ [ 64, 11 ], [ 67, 23 ], [ 65, 26 ], [ 68, 33 ], [ 68, 40 ], [ 68, 47 ], [ 68, 58 ], [ 68, 61 ], [ 64, 65 ], [ 67, 68 ] ]

[ "import sys\nsys.setrecursionlimit(10**6)\n\na=list(map(int,input().split()))\n\nnewa=sorted(a)\n\n#print(a)\n#print(newa)\n#print(newa[2])\n\nif newa[2]%2==0 or newa[1]%2==0 or newa[0]%2==0:\n print(\"0\")\nelse:\n print(newa[0]*newa[1])", "import sys", "sys", "sys.setrecursionlimit(10**6)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "10**6", "10", "6", "a=list(map(int,input().split()))", "a", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "newa=sorted(a)", "newa", "sorted(a)", "sorted", "a", "if newa[2]%2==0 or newa[1]%2==0 or newa[0]%2==0:\n print(\"0\")\nelse:\n print(newa[0]*newa[1])", "newa[2]%2==0 or newa[1]%2==0 or newa[0]%2==0", "newa[2]%2==0 or newa[1]%2==0", "newa[2]%2==0", "newa[2]%2", "newa[2]", "newa", "2", "2", "0", "newa[1]%2==0", "newa[1]%2", "newa[1]", "newa", "1", "2", "0", "newa[0]%2==0", "newa[0]%2", "newa[0]", "newa", "0", "2", "0", "print(\"0\")", "print", "\"0\"", "print(newa[0]*newa[1])", "print", "newa[0]*newa[1]", "newa[0]", "newa", "0", "newa[1]", "newa", "1", "a=list(map(int,input().split()))", "list(map(int,input().split()))", "a", "newa=sorted(a)", "sorted(a)", "newa" ]

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

[ [ 29, 28 ], [ 28, 35 ], [ 28, 39 ], [ 111, 52 ], [ 130, 54 ], [ 120, 56 ], [ 112, 59 ], [ 62, 61 ], [ 135, 64 ], [ 121, 66 ], [ 112, 66 ], [ 136, 71 ], [ 123, 78 ], [ 121, 82 ], [ 112, 82 ], [ 121, 85 ], [ 112, 85 ], [ 136, 88 ], [ 114, 91 ], [ 121, 95 ], [ 112, 95 ], [ 121, 98 ], [ 112, 98 ], [ 136, 102 ], [ 115, 108 ], [ 124, 109 ], [ 111, 112 ], [ 114, 115 ], [ 120, 121 ], [ 123, 124 ], [ 135, 136 ] ]

[ "# For taking integer inputs.\nimport math\nfrom decimal import Decimal\nfrom itertools import permutations\n\n\ndef inp():\n return(int(input()))\n\n\n# For taking List inputs.\ndef inlist():\n return(list(map(int, input().split())))\n\n\n# For taking string inputs. Actually it returns a List of Characters, instead of a string, which is easier to use in Python, because in Python, Strings are Immutable.\ndef instr():\n s = input()\n return(list(s[:len(s)]))\n\n\n# For taking space seperated integer variable inputs.\ndef invr():\n return(map(int, input().split()))\n\n\na = inlist()\na = sorted(a, reverse=True)\n\nbig = a[0]\n\nif big % 2 == 0:\n print(0)\nelse:\n d1 = a[1] * a[2] * (big // 2)\n d2 = a[1] * a[2] * ((big // 2) + 1)\n print(d2 - d1)", "import math", "math", "from decimal import Decimal", "from itertools import permutations", "def inp():\n return(int(input()))\n\n\n# For taking List inputs.", "inp", "return(int(input()))", "int(input())", "int", "input()", "input", "def inlist():\n return(list(map(int, input().split())))\n\n\n# For taking string inputs. Actually it returns a List of Characters, instead of a string, which is easier to use in Python, because in Python, Strings are Immutable.", "inlist", "return(list(map(int, input().split())))", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "def instr():\n s = input()\n return(list(s[:len(s)]))\n\n\n# For taking space seperated integer variable inputs.", "instr", "s = input()", "s", "input()", "input", "return(list(s[:len(s)]))", "list(s[:len(s)])", "list", "s[:len(s)]", "s", ":len(s)", "len(s)", "len", "s", "def invr():\n return(map(int, input().split()))", "invr", "return(map(int, input().split()))", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "a = inlist()", "a", "inlist()", "inlist", "a = sorted(a, reverse=True)", "a", "sorted(a, reverse=True)", "sorted", "a", "reverse=True", "reverse", "True", "big = a[0]", "big", "a[0]", "a", "0", "if big % 2 == 0:\n print(0)\nelse:\n d1 = a[1] * a[2] * (big // 2)\n d2 = a[1] * a[2] * ((big // 2) + 1)\n print(d2 - d1)", "big % 2 == 0", "big % 2", "big", "2", "0", "print(0)", "print", "0", "d1 = a[1] * a[2] * (big // 2)", "d1", "a[1] * a[2] * (big // 2)", "a[1] * a[2]", "a[1]", "a", "1", "a[2]", "a", "2", "big // 2", "big", "2", "d2 = a[1] * a[2] * ((big // 2) + 1)", "d2", "a[1] * a[2] * ((big // 2) + 1)", "a[1] * a[2]", "a[1]", "a", "1", "a[2]", "a", "2", "(big // 2) + 1", "big // 2", "big", "2", "1", "print(d2 - d1)", "print", "d2 - d1", "d2", "d1", "a = inlist()", "inlist()", "a", "d2 = a[1] * a[2] * ((big // 2) + 1)", "a[1] * a[2] * ((big // 2) + 1)", "d2", "def instr():\n s = input()\n return(list(s[:len(s)]))\n\n\n# For taking space seperated integer variable inputs.", "def instr():\n s = input()\n return(list(s[:len(s)]))\n\n\n# For taking space seperated integer variable inputs.", "instr", "a = sorted(a, reverse=True)", "sorted(a, reverse=True)", "a", "d1 = a[1] * a[2] * (big // 2)", "a[1] * a[2] * (big // 2)", "d1", "def inp():\n return(int(input()))\n\n\n# For taking List inputs.", "def inp():\n return(int(input()))\n\n\n# For taking List inputs.", "inp", "def inlist():\n return(list(map(int, input().split())))\n\n\n# For taking string inputs. Actually it returns a List of Characters, instead of a string, which is easier to use in Python, because in Python, Strings are Immutable.", "def inlist():\n return(list(map(int, input().split())))\n\n\n# For taking string inputs. Actually it returns a List of Characters, instead of a string, which is easier to use in Python, because in Python, Strings are Immutable.", "inlist", "def invr():\n return(map(int, input().split()))", "def invr():\n return(map(int, input().split()))", "invr", "big = a[0]", "a[0]", "big" ]

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

[ [ 42, 2 ], [ 43, 19 ], [ 43, 22 ], [ 43, 25 ], [ 43, 36 ], [ 43, 39 ], [ 42, 43 ] ]

[ "L = sorted(map(int, input().split()))\nif (L[0] * L[1] * L[2]) % 2 == 0:\n print(0)\nelse:\n print(L[0] * L[1])", "L = sorted(map(int, input().split()))", "L", "sorted(map(int, input().split()))", "sorted", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "if (L[0] * L[1] * L[2]) % 2 == 0:\n print(0)\nelse:\n print(L[0] * L[1])", "(L[0] * L[1] * L[2]) % 2 == 0", "(L[0] * L[1] * L[2]) % 2", "L[0] * L[1] * L[2]", "L[0] * L[1]", "L[0]", "L", "0", "L[1]", "L", "1", "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 = sorted(map(int, input().split()))", "sorted(map(int, input().split()))", "L" ]

[ 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, 4, 13, 13, 13, 13, 2, 2, 2, 2, 13, 13, 13, 4, 13, 13, 13, 13, 4, 13, 13, 13, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 66, 2 ], [ 66, 11 ], [ 66, 12 ], [ 64, 18 ], [ 61, 23 ], [ 67, 28 ], [ 64, 39 ], [ 61, 40 ], [ 67, 41 ], [ 64, 46 ], [ 61, 47 ], [ 67, 48 ], [ 64, 51 ], [ 61, 52 ], [ 67, 53 ], [ 64, 56 ], [ 61, 57 ], [ 67, 58 ], [ 66, 61 ], [ 66, 64 ], [ 66, 67 ] ]

[ "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(min(a,b,c)*(a+b+c-max(a,b,c)-min(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(min(a,b,c)*(a+b+c-max(a,b,c)-min(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(min(a,b,c)*(a+b+c-max(a,b,c)-min(a,b,c)))", "print", "min(a,b,c)*(a+b+c-max(a,b,c)-min(a,b,c))", "min(a,b,c)", "min", "a", "b", "c", "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", "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" ]

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

[ [ 100, 2 ], [ 100, 11 ], [ 100, 12 ], [ 103, 14 ], [ 95, 17 ], [ 101, 18 ], [ 98, 19 ], [ 109, 21 ], [ 95, 27 ], [ 101, 29 ], [ 98, 30 ], [ 91, 32 ], [ 95, 35 ], [ 101, 39 ], [ 98, 41 ], [ 106, 43 ], [ 95, 46 ], [ 101, 47 ], [ 98, 51 ], [ 110, 55 ], [ 110, 58 ], [ 92, 59 ], [ 107, 60 ], [ 104, 64 ], [ 110, 66 ], [ 92, 70 ], [ 110, 73 ], [ 92, 74 ], [ 107, 75 ], [ 104, 79 ], [ 92, 81 ], [ 104, 86 ], [ 107, 88 ], [ 91, 92 ], [ 100, 95 ], [ 100, 98 ], [ 100, 101 ], [ 103, 104 ], [ 106, 107 ], [ 109, 110 ] ]

[ "x, y, z = map(int, input().split())\n\nall = x * y * z\n\nans1 = int(x/2) * y * z\nans2 = x * int(y/2) * z\nans3 = x * y * int(z/2)\n\nif ans1 == max(ans1, ans2, ans3):\n print(all - ans1 * 2)\nelif ans2 == max(ans1, ans2, ans3):\n print(all - ans2 * 2)\nelse:\n print(all - ans3 * 2)", "x, y, z = map(int, input().split())", "x", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "y", "z", "all = x * y * z", "all", "x * y * z", "x * y", "x", "y", "z", "ans1 = int(x/2) * y * z", "ans1", "int(x/2) * y * z", "int(x/2) * y", "int(x/2)", "int", "x/2", "x", "2", "y", "z", "ans2 = x * int(y/2) * z", "ans2", "x * int(y/2) * z", "x * int(y/2)", "x", "int(y/2)", "int", "y/2", "y", "2", "z", "ans3 = x * y * int(z/2)", "ans3", "x * y * int(z/2)", "x * y", "x", "y", "int(z/2)", "int", "z/2", "z", "2", "if ans1 == max(ans1, ans2, ans3):\n print(all - ans1 * 2)\nelif ans2 == max(ans1, ans2, ans3):\n print(all - ans2 * 2)\nelse:\n print(all - ans3 * 2)", "ans1 == max(ans1, ans2, ans3)", "ans1", "max(ans1, ans2, ans3)", "max", "ans1", "ans2", "ans3", "print(all - ans1 * 2)", "print", "all - ans1 * 2", "all", "ans1 * 2", "ans1", "2", "elif ans2 == max(ans1, ans2, ans3):\n print(all - ans2 * 2)", "ans2 == max(ans1, ans2, ans3)", "ans2", "max(ans1, ans2, ans3)", "max", "ans1", "ans2", "ans3", "print(all - ans2 * 2)", "print", "all - ans2 * 2", "all", "ans2 * 2", "ans2", "2", "print(all - ans3 * 2)", "print", "all - ans3 * 2", "all", "ans3 * 2", "ans3", "2", "ans2 = x * int(y/2) * z", "x * int(y/2) * z", "ans2", "x, y, z = map(int, input().split())", "map(int, input().split())", "x", "z = map(int, input().split())", "map(int, input().split())", "z", "y, z = map(int, input().split())", "map(int, input().split())", "y", "all = x * y * z", "x * y * z", "all", "ans3 = x * y * int(z/2)", "x * y * int(z/2)", "ans3", "ans1 = int(x/2) * y * z", "int(x/2) * y * z", "ans1" ]

[ 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, 10, 4, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 38, 2 ], [ 38, 11 ], [ 38, 12 ], [ 36, 18 ], [ 39, 23 ], [ 33, 28 ], [ 38, 33 ], [ 38, 36 ], [ 38, 39 ] ]

[ "a, b, c = map(int, input().split())\nif a%2 == 0 or b%2 == 0 or c%2 == 0: print(0)\nelse: 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: print(0)\nelse: 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", "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, 12, 13, 0, 13, 4, 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, 17, 0, 13, 4, 13, 2, 13, 13, 2, 13, 13, 2, 13, 13, 4, 13, 13, 29, 4, 13, 10, 12, 13 ]

[ [ 5, 4 ], [ 5, 15 ], [ 5, 16 ], [ 19, 18 ], [ 4, 25 ], [ 15, 30 ], [ 16, 35 ], [ 40, 39 ], [ 43, 42 ], [ 15, 46 ], [ 16, 47 ], [ 16, 49 ], [ 4, 50 ], [ 4, 52 ], [ 15, 53 ], [ 42, 56 ], [ 39, 56 ], [ 18, 56 ], [ 62, 59 ] ]

[ "def resolve():\n A, B, C = list(map(int, input().split()))\n ans = ''\n if A % 2 == 0 or B % 2 == 0 or C % 2 == 0:\n ans = 0\n else:\n ans = min(B * C, C * A, A * B)\n\n print(ans)\n return\n\n\nresolve()", "def resolve():\n A, B, C = list(map(int, input().split()))\n ans = ''\n if A % 2 == 0 or B % 2 == 0 or C % 2 == 0:\n ans = 0\n else:\n ans = min(B * C, C * A, A * B)\n\n print(ans)\n return", "resolve", "A, B, C = list(map(int, input().split()))", "A", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "B", "C", "ans = ''", "ans", "''", "if A % 2 == 0 or B % 2 == 0 or C % 2 == 0:\n ans = 0\n else:\n ans = min(B * C, C * A, A * B)\n\n ", "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 = min(B * C, C * A, A * B)", "ans", "min(B * C, C * A, A * B)", "min", "B * C", "B", "C", "C * A", "C", "A", "A * B", "A", "B", "print(ans)", "print", "ans", "return", "resolve()", "resolve", "def resolve():\n A, B, C = list(map(int, input().split()))\n ans = ''\n if A % 2 == 0 or B % 2 == 0 or C % 2 == 0:\n ans = 0\n else:\n ans = min(B * C, C * A, A * B)\n\n print(ans)\n return", "def resolve():\n A, B, C = list(map(int, input().split()))\n ans = ''\n if A % 2 == 0 or B % 2 == 0 or C % 2 == 0:\n ans = 0\n else:\n ans = min(B * C, C * A, A * B)\n\n print(ans)\n return", "resolve" ]

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

[ [ 46, 2 ], [ 47, 15 ], [ 47, 23 ], [ 47, 26 ], [ 47, 29 ], [ 47, 37 ], [ 47, 40 ], [ 46, 47 ] ]

[ "A = list(map(int, input(). split()))\nA.sort()\nif (A[0]*A[1]*A[2])%2 == 1:\n print(A[0]*A[1])\nelse:\n print(0)", "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]*A[1]*A[2])%2 == 1:\n print(A[0]*A[1])\nelse:\n print(0)", "(A[0]*A[1]*A[2])%2 == 1", "(A[0]*A[1]*A[2])%2", "A[0]*A[1]*A[2]", "A[0]*A[1]", "A[0]", "A", "0", "A[1]", "A", "1", "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 = 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, 0, 13, 4, 13, 2, 2, 2, 2, 13, 17, 13, 13, 2, 2, 2, 2, 13, 17, 17, 13, 13, 0, 13, 4, 13, 2, 2, 2, 13, 2, 13, 17, 13, 2, 2, 13, 2, 2, 13, 17, 17, 13, 0, 13, 4, 13, 2, 2, 2, 13, 13, 2, 13, 17, 2, 2, 13, 13, 2, 2, 13, 17, 17, 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 ]

[ [ 111, 2 ], [ 111, 11 ], [ 111, 12 ], [ 106, 18 ], [ 112, 23 ], [ 109, 28 ], [ 120, 35 ], [ 106, 42 ], [ 112, 44 ], [ 109, 45 ], [ 106, 50 ], [ 112, 53 ], [ 109, 54 ], [ 114, 56 ], [ 106, 62 ], [ 112, 64 ], [ 109, 66 ], [ 106, 69 ], [ 112, 72 ], [ 109, 75 ], [ 117, 77 ], [ 106, 83 ], [ 112, 84 ], [ 109, 86 ], [ 106, 90 ], [ 112, 91 ], [ 109, 94 ], [ 121, 101 ], [ 115, 102 ], [ 118, 103 ], [ 111, 106 ], [ 111, 109 ], [ 111, 112 ], [ 114, 115 ], [ 117, 118 ], [ 120, 121 ] ]

[ "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 a = abs((A // 2) * B * C - ((A + 1) // 2) * B * C)\n b = abs(A * (B // 2) * C - A * ((B + 1) // 2) * C)\n c = abs(A * B * (C // 2) - A * B * ((C + 1) // 2))\n print(min(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 a = abs((A // 2) * B * C - ((A + 1) // 2) * B * C)\n b = abs(A * (B // 2) * C - A * ((B + 1) // 2) * C)\n c = abs(A * B * (C // 2) - A * B * ((C + 1) // 2))\n print(min(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", "a = abs((A // 2) * B * C - ((A + 1) // 2) * B * C)", "a", "abs((A // 2) * B * C - ((A + 1) // 2) * B * C)", "abs", "(A // 2) * B * C - ((A + 1) // 2) * B * C", "(A // 2) * B * C", "(A // 2) * B", "A // 2", "A", "2", "B", "C", "((A + 1) // 2) * B * C", "((A + 1) // 2) * B", "(A + 1) // 2", "A + 1", "A", "1", "2", "B", "C", "b = abs(A * (B // 2) * C - A * ((B + 1) // 2) * C)", "b", "abs(A * (B // 2) * C - A * ((B + 1) // 2) * C)", "abs", "A * (B // 2) * C - A * ((B + 1) // 2) * C", "A * (B // 2) * C", "A * (B // 2)", "A", "B // 2", "B", "2", "C", "A * ((B + 1) // 2) * C", "A * ((B + 1) // 2)", "A", "(B + 1) // 2", "B + 1", "B", "1", "2", "C", "c = abs(A * B * (C // 2) - A * B * ((C + 1) // 2))", "c", "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", "print(min(a, b, c))", "print", "min(a, b, c)", "min", "a", "b", "c", "A, B, C = map(int, input().split())", "map(int, input().split())", "A", "C = map(int, input().split())", "map(int, input().split())", "C", "B, C = map(int, input().split())", "map(int, input().split())", "B", "b = abs(A * (B // 2) * C - A * ((B + 1) // 2) * C)", "abs(A * (B // 2) * C - A * ((B + 1) // 2) * C)", "b", "c = abs(A * B * (C // 2) - A * B * ((C + 1) // 2))", "abs(A * B * (C // 2) - A * B * ((C + 1) // 2))", "c", "a = abs((A // 2) * B * C - ((A + 1) // 2) * B * C)", "abs((A // 2) * B * C - ((A + 1) // 2) * B * C)", "a" ]

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

[ [ 40, 2 ], [ 40, 11 ], [ 40, 12 ], [ 35, 25 ], [ 38, 26 ], [ 38, 28 ], [ 41, 29 ], [ 41, 31 ], [ 35, 32 ], [ 40, 35 ], [ 40, 38 ], [ 40, 41 ] ]

[ "a,b,c = map(int,input().split())\nif any([i%2 == 0 for i in (a,b,c)]):\n print(0)\nelse:\n print(min(b*c,c*a,a*b))", "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)\nelse:\n print(min(b*c,c*a,a*b))", "any([i%2 == 0 for i in (a,b,c)])", "any", "[i%2 == 0 for i in (a,b,c)]", "print(0)", "print", "0", "print(min(b*c,c*a,a*b))", "print", "min(b*c,c*a,a*b)", "min", "b*c", "b", "c", "c*a", "c", "a", "a*b", "a", "b", "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, 18, 4, 13, 17, 13, 13, 13, 13, 14, 2, 2, 2, 2, 13, 13, 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, 4, 13, 10, 39, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 63, 2 ], [ 63, 15 ], [ 63, 16 ], [ 52, 22 ], [ 64, 23 ], [ 61, 24 ], [ 57, 31 ], [ 54, 37 ], [ 58, 40 ], [ 55, 45 ], [ 55, 48 ], [ 63, 52 ], [ 54, 55 ], [ 57, 58 ], [ 63, 61 ], [ 63, 64 ] ]

[ "A, B, C = map(int,open(0).read().split())\nif (A * B * C) % 2 == 0:\n print(\"0\")\nelse:\n ABClist = [A, B, C]\n newlist = sorted(ABClist)\n print(newlist[0] * newlist[1])", "A, B, C = map(int,open(0).read().split())", "A", "map(int,open(0).read().split())", "map", "int", "open(0).read().split()", "(0).read().split", "(0).read()", "(0).read", "(0)", "open", "0", "read", "split", "B", "C", "if (A * B * C) % 2 == 0:\n print(\"0\")\nelse:\n ABClist = [A, B, C]\n newlist = sorted(ABClist)\n print(newlist[0] * newlist[1])", "(A * B * C) % 2 == 0", "(A * B * C) % 2", "A * B * C", "A * B", "A", "B", "C", "2", "0", "print(\"0\")", "print", "\"0\"", "ABClist = [A, B, C]", "ABClist", "[A, B, C]", "A", "B", "C", "newlist = sorted(ABClist)", "newlist", "sorted(ABClist)", "sorted", "ABClist", "print(newlist[0] * newlist[1])", "print", "newlist[0] * newlist[1]", "newlist[0]", "newlist", "0", "newlist[1]", "newlist", "1", "A, B, C = map(int,open(0).read().split())", "map(int,open(0).read().split())", "A", "newlist = sorted(ABClist)", "sorted(ABClist)", "newlist", "ABClist = [A, B, C]", "[A, B, C]", "ABClist", "C = map(int,open(0).read().split())", "map(int,open(0).read().split())", "C", "B, C = map(int,open(0).read().split())", "map(int,open(0).read().split())", "B" ]

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

[ [ 17, 16 ], [ 17, 25 ], [ 17, 26 ], [ 16, 39 ], [ 25, 40 ], [ 25, 42 ], [ 26, 43 ], [ 26, 45 ], [ 16, 46 ], [ 57, 54 ] ]

[ "import math\nimport collections\nimport fractions\nimport itertools\nimport functools\nimport operator\n\ndef solve():\n a, b, c = map(int, input().split())\n if any([i%2==0 for i in (a, b, c)]):\n print(0)\n else:\n print(min(a*b, b*c, c*a))\n return 0\n\nif __name__ == \"__main__\":\n solve()", "import math", "math", "import collections", "collections", "import fractions", "fractions", "import itertools", "itertools", "import functools", "functools", "import operator", "operator", "def solve():\n a, b, c = map(int, input().split())\n if any([i%2==0 for i in (a, b, c)]):\n print(0)\n else:\n print(min(a*b, b*c, c*a))\n return 0", "solve", "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 else:\n print(min(a*b, b*c, c*a))\n ", "any([i%2==0 for i in (a, b, c)])", "any", "[i%2==0 for i in (a, b, c)]", "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", "return 0", "0", "if __name__ == \"__main__\":\n solve()", "__name__ == \"__main__\"", "__name__", "\"__main__\"", "solve()", "solve", "def solve():\n a, b, c = map(int, input().split())\n if any([i%2==0 for i in (a, b, c)]):\n print(0)\n else:\n print(min(a*b, b*c, c*a))\n return 0", "def solve():\n a, b, c = map(int, input().split())\n if any([i%2==0 for i in (a, b, c)]):\n print(0)\n else:\n print(min(a*b, b*c, c*a))\n return 0", "solve" ]

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

[ [ 44, 2 ], [ 44, 11 ], [ 44, 12 ], [ 42, 20 ], [ 45, 21 ], [ 39, 22 ], [ 42, 29 ], [ 45, 30 ], [ 45, 32 ], [ 39, 33 ], [ 39, 35 ], [ 42, 36 ], [ 44, 39 ], [ 44, 42 ], [ 44, 45 ] ]

[ "a,b,c=map(int,input().split())\nprint(0 if (a*b*c)%2==0 else 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", "print(0 if (a*b*c)%2==0 else min(a*b,b*c,c*a))", "print", "0 if (a*b*c)%2==0 else 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", "0", "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, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 13, 14, 2, 2, 2, 2, 13, 13, 13, 17, 17, 4, 13, 17, 0, 13, 4, 13, 39, 13, 13, 13, 13, 13, 4, 13, 2, 13, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 57, 2 ], [ 57, 11 ], [ 57, 12 ], [ 52, 18 ], [ 58, 19 ], [ 49, 20 ], [ 54, 27 ], [ 54, 34 ], [ 54, 35 ], [ 46, 39 ], [ 52, 39 ], [ 43, 40 ], [ 58, 40 ], [ 54, 43 ], [ 54, 46 ], [ 57, 49 ], [ 57, 52 ], [ 54, 55 ], [ 57, 58 ] ]

[ "a, b, c = map(int, input().split())\nif a*b*c % 2 == 0:\n print(0)\nelse:\n a, b, c = sorted([a, b, c])\n print(a*b)", "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 print(0)\nelse:\n a, b, c = sorted([a, b, c])\n print(a*b)", "a*b*c % 2 == 0", "a*b*c % 2", "a*b*c", "a*b", "a", "b", "c", "2", "0", "print(0)", "print", "0", "a, b, c = sorted([a, b, c])", "a", "sorted([a, b, c])", "sorted", "[a, b, c]", "a", "b", "c", "b", "c", "print(a*b)", "print", "a*b", "a", "b", "b, c = sorted([a, b, c])", "sorted([a, b, c])", "b", "a, b, c = sorted([a, b, c])", "sorted([a, b, c])", "a", "c = map(int, input().split())", "map(int, input().split())", "c", "a, b, c = map(int, input().split())", "map(int, input().split())", "a", "c = sorted([a, b, c])", "sorted([a, b, c])", "c", "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, 13, 13, 13, 0, 13, 4, 13, 13, 13, 13, 0, 13, 2, 2, 2, 13, 13, 13, 2, 13, 13, 14, 2, 2, 13, 17, 17, 0, 13, 17, 0, 13, 2, 13, 13, 4, 13, 13, 10, 4, 13, 10, 2, 13, 10, 4, 13, 10, 17, 13, 10, 4, 13, 10, 2, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 68, 2 ], [ 68, 11 ], [ 68, 12 ], [ 74, 14 ], [ 63, 17 ], [ 69, 18 ], [ 57, 19 ], [ 77, 21 ], [ 63, 24 ], [ 69, 25 ], [ 57, 26 ], [ 59, 28 ], [ 63, 32 ], [ 69, 33 ], [ 57, 34 ], [ 75, 36 ], [ 78, 37 ], [ 75, 41 ], [ 65, 45 ], [ 71, 48 ], [ 78, 50 ], [ 60, 51 ], [ 72, 54 ], [ 66, 54 ], [ 68, 57 ], [ 59, 60 ], [ 68, 63 ], [ 65, 66 ], [ 68, 69 ], [ 71, 72 ], [ 74, 75 ], [ 77, 78 ] ]

[ "A, B, C = map(int, input().split())\nx = max(A, B, C)\ny = min(A, B, C)\nz = A+B+C-(x+y)\nif x % 2 == 0:\n ans = 0\nelse:\n ans = y*z\nprint(ans)", "A, B, C = map(int, input().split())", "A", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "B", "C", "x = max(A, B, C)", "x", "max(A, B, C)", "max", "A", "B", "C", "y = min(A, B, C)", "y", "min(A, B, C)", "min", "A", "B", "C", "z = A+B+C-(x+y)", "z", "A+B+C-(x+y)", "A+B+C", "A+B", "A", "B", "C", "x+y", "x", "y", "if x % 2 == 0:\n ans = 0\nelse:\n ans = y*z", "x % 2 == 0", "x % 2", "x", "2", "0", "ans = 0", "ans", "0", "ans = y*z", "ans", "y*z", "y", "z", "print(ans)", "print", "ans", "C = map(int, input().split())", "map(int, input().split())", "C", "z = A+B+C-(x+y)", "A+B+C-(x+y)", "z", "A, B, C = map(int, input().split())", "map(int, input().split())", "A", "ans = 0", "0", "ans", "B, C = map(int, input().split())", "map(int, input().split())", "B", "ans = y*z", "y*z", "ans", "x = max(A, B, C)", "max(A, B, C)", "x", "y = min(A, B, C)", "min(A, B, C)", "y" ]

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

[ [ 60, 2 ], [ 60, 11 ], [ 60, 12 ], [ 51, 14 ], [ 61, 17 ], [ 55, 18 ], [ 58, 19 ], [ 61, 25 ], [ 55, 30 ], [ 58, 35 ], [ 61, 46 ], [ 55, 47 ], [ 58, 48 ], [ 52, 49 ], [ 51, 52 ], [ 60, 55 ], [ 60, 58 ], [ 60, 61 ] ]

[ "A, B, C = map(int, input().split())\n\nnum = max(A, B, C)\n\nif A % 2 == 0 or B % 2 == 0 or C % 2 == 0:\n print(0)\nelse:\n print(A*B*C//num)", "A, B, C = map(int, input().split())", "A", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "B", "C", "num = max(A, B, C)", "num", "max(A, B, C)", "max", "A", "B", "C", "if A % 2 == 0 or B % 2 == 0 or C % 2 == 0:\n print(0)\nelse:\n print(A*B*C//num)", "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//num)", "print", "A*B*C//num", "A*B*C", "A*B", "A", "B", "C", "num", "num = max(A, B, C)", "max(A, B, C)", "num", "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, 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, 0, 13, 4, 13, 13, 13, 13, 4, 13, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13 ]

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

[ "a, b, c = map(int, input().split())\nv1 = abs((a // 2) * b * c - (a - (a // 2)) * b * c)\nv2 = abs((b // 2) * a * c - (b - (b // 2)) * a * c)\nv3 = abs((c // 2) * b * a - (c - (c // 2)) * b * a)\nans = min(v1, v2, v3)\nprint(ans)", "a, b, c = map(int, input().split())", "a", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "c", "v1 = abs((a // 2) * b * c - (a - (a // 2)) * b * c)", "v1", "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", "v2 = abs((b // 2) * a * c - (b - (b // 2)) * a * c)", "v2", "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", "v3 = abs((c // 2) * b * a - (c - (c // 2)) * b * a)", "v3", "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", "ans = min(v1, v2, v3)", "ans", "min(v1, v2, v3)", "min", "v1", "v2", "v3", "print(ans)", "print", "ans", "a, b, c = map(int, input().split())", "map(int, input().split())", "a", "c = map(int, input().split())", "map(int, input().split())", "c", "v1 = abs((a // 2) * b * c - (a - (a // 2)) * b * c)", "abs((a // 2) * b * c - (a - (a // 2)) * b * c)", "v1", "b, c = map(int, input().split())", "map(int, input().split())", "b", "ans = min(v1, v2, v3)", "min(v1, v2, v3)", "ans", "v2 = abs((b // 2) * a * c - (b - (b // 2)) * a * c)", "abs((b // 2) * a * c - (b - (b // 2)) * a * c)", "v2", "v3 = abs((c // 2) * b * a - (c - (c // 2)) * b * a)", "abs((c // 2) * b * a - (c - (c // 2)) * b * a)", "v3" ]

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

[ [ 44, 2 ], [ 41, 14 ], [ 45, 17 ], [ 20, 19 ], [ 42, 19 ], [ 45, 19 ], [ 19, 24 ], [ 42, 35 ], [ 45, 35 ], [ 42, 38 ], [ 45, 38 ], [ 41, 42 ], [ 44, 45 ] ]

[ "l = list(map(int, input().split()))\nl = sorted(l)\nfor i in l:\n if i % 2 == 0:\n print(0)\n break\nelse:\n print(l[0] * l[1])", "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", "for i in l:\n if i % 2 == 0:\n print(0)\n break\nelse:\n print(l[0] * l[1])", "i", "l", "if i % 2 == 0:\n print(0)\n break", "i % 2 == 0", "i % 2", "i", "2", "0", "print(0)", "print", "0", "break", "print(l[0] * l[1])", "print", "l[0] * l[1]", "l[0]", "l", "0", "l[1]", "l", "1", "l = sorted(l)", "sorted(l)", "l", "l = list(map(int, input().split()))", "list(map(int, input().split()))", "l" ]

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

[ [ 4, 3 ], [ 3, 15 ], [ 39, 17 ], [ 39, 21 ], [ 39, 22 ], [ 37, 27 ], [ 40, 28 ], [ 34, 30 ], [ 39, 34 ], [ 39, 37 ], [ 39, 40 ] ]

[ "A, B, C = sorted([int(x) for x in input().strip().split()])\nprint(A * B * (C % 2))", "int(x) for x in input().strip().split()", "for x in input().strip().split()", "x", "input().strip().split()", "().strip().split", "().strip()", "().strip", "()", "input", "strip", "split", "for x in input().strip().split()", "int(x)", "int", "x", "A, B, C = sorted([int(x) for x in input().strip().split()])", "A", "sorted([int(x) for x in input().strip().split()])", "sorted", "[int(x) for x in input().strip().split()]", "B", "C", "print(A * B * (C % 2))", "print", "A * B * (C % 2)", "A * B", "A", "B", "C % 2", "C", "2", "C = sorted([int(x) for x in input().strip().split()])", "sorted([int(x) for x in input().strip().split()])", "C", "A, B, C = sorted([int(x) for x in input().strip().split()])", "sorted([int(x) for x in input().strip().split()])", "A", "B, C = sorted([int(x) for x in input().strip().split()])", "sorted([int(x) for x in input().strip().split()])", "B" ]

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

[ [ 63, 4 ], [ 64, 17 ], [ 64, 25 ], [ 64, 32 ], [ 64, 39 ], [ 66, 51 ], [ 64, 54 ], [ 64, 57 ], [ 67, 61 ], [ 63, 64 ], [ 66, 67 ] ]

[ "import sys\na=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)\n sys.exit()\nans=a[0]*a[1]\nprint(ans)", "import sys", "sys", "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)\n sys.exit()", "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", "sys.exit()", "sys.exit", "sys", "exit", "ans=a[0]*a[1]", "ans", "a[0]*a[1]", "a[0]", "a", "0", "a[1]", "a", "1", "print(ans)", "print", "ans", "a=list(map(int,input().split()))", "list(map(int,input().split()))", "a", "ans=a[0]*a[1]", "a[0]*a[1]", "ans" ]

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

[ [ 87, 2 ], [ 87, 11 ], [ 87, 12 ], [ 93, 14 ], [ 76, 19 ], [ 76, 21 ], [ 76, 24 ], [ 90, 27 ], [ 82, 32 ], [ 82, 34 ], [ 82, 37 ], [ 84, 40 ], [ 88, 45 ], [ 88, 47 ], [ 88, 50 ], [ 78, 53 ], [ 94, 58 ], [ 82, 59 ], [ 88, 60 ], [ 76, 63 ], [ 91, 64 ], [ 88, 65 ], [ 76, 68 ], [ 82, 69 ], [ 85, 70 ], [ 79, 73 ], [ 87, 76 ], [ 78, 79 ], [ 87, 82 ], [ 84, 85 ], [ 87, 88 ], [ 90, 91 ], [ 93, 94 ] ]

[ "A, B, C = map(int, input().split())\na = abs((A-A//2) - A//2)\nb = abs((B-B//2) - B//2)\nc = abs((C-C//2) - C//2)\nans = min(a*B*C, A*b*C, A*B*c)\nprint(ans)", "A, B, C = map(int, input().split())", "A", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "B", "C", "a = abs((A-A//2) - A//2)", "a", "abs((A-A//2) - A//2)", "abs", "(A-A//2) - A//2", "A-A//2", "A", "A//2", "A", "2", "A//2", "A", "2", "b = abs((B-B//2) - B//2)", "b", "abs((B-B//2) - B//2)", "abs", "(B-B//2) - B//2", "B-B//2", "B", "B//2", "B", "2", "B//2", "B", "2", "c = abs((C-C//2) - C//2)", "c", "abs((C-C//2) - C//2)", "abs", "(C-C//2) - C//2", "C-C//2", "C", "C//2", "C", "2", "C//2", "C", "2", "ans = min(a*B*C, A*b*C, A*B*c)", "ans", "min(a*B*C, A*b*C, A*B*c)", "min", "a*B*C", "a*B", "a", "B", "C", "A*b*C", "A*b", "A", "b", "C", "A*B*c", "A*B", "A", "B", "c", "print(ans)", "print", "ans", "A, B, C = map(int, input().split())", "map(int, input().split())", "A", "ans = min(a*B*C, A*b*C, A*B*c)", "min(a*B*C, A*b*C, A*B*c)", "ans", "B, C = map(int, input().split())", "map(int, input().split())", "B", "c = abs((C-C//2) - C//2)", "abs((C-C//2) - C//2)", "c", "C = map(int, input().split())", "map(int, input().split())", "C", "b = abs((B-B//2) - B//2)", "abs((B-B//2) - B//2)", "b", "a = abs((A-A//2) - A//2)", "abs((A-A//2) - A//2)", "a" ]

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

[ [ 4, 3 ], [ 3, 12 ], [ 51, 14 ], [ 51, 16 ], [ 51, 17 ], [ 46, 23 ], [ 52, 24 ], [ 49, 25 ], [ 46, 36 ], [ 52, 37 ], [ 46, 39 ], [ 49, 40 ], [ 52, 42 ], [ 49, 43 ], [ 51, 46 ], [ 51, 49 ], [ 51, 52 ] ]

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

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

[ [ 91, 2 ], [ 91, 11 ], [ 91, 12 ], [ 70, 14 ], [ 73, 17 ], [ 76, 19 ], [ 71, 23 ], [ 83, 25 ], [ 71, 28 ], [ 89, 30 ], [ 71, 33 ], [ 92, 35 ], [ 71, 38 ], [ 85, 41 ], [ 71, 45 ], [ 71, 48 ], [ 71, 52 ], [ 79, 56 ], [ 83, 60 ], [ 89, 61 ], [ 92, 62 ], [ 86, 63 ], [ 74, 63 ], [ 80, 67 ], [ 77, 67 ], [ 86, 68 ], [ 74, 68 ], [ 70, 71 ], [ 73, 74 ], [ 76, 77 ], [ 79, 80 ], [ 91, 83 ], [ 85, 86 ], [ 91, 89 ], [ 91, 92 ] ]

[ "a, b, c = map(int, input().split())\nabc = []\nR, B = 0, 0\nabc.append(a)\nabc.append(b)\nabc.append(c)\nabc.sort()\nR = abc[0] * abc[1] * (abc[2]//2)\nB = a*b*c-R\nprint(B - R)", "a, b, c = map(int, input().split())", "a", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "c", "abc = []", "abc", "[]", "R, B = 0, 0", "R", "0", "B", "0", "abc.append(a)", "abc.append", "abc", "append", "a", "abc.append(b)", "abc.append", "abc", "append", "b", "abc.append(c)", "abc.append", "abc", "append", "c", "abc.sort()", "abc.sort", "abc", "sort", "R = abc[0] * abc[1] * (abc[2]//2)", "R", "abc[0] * abc[1] * (abc[2]//2)", "abc[0] * abc[1]", "abc[0]", "abc", "0", "abc[1]", "abc", "1", "abc[2]//2", "abc[2]", "abc", "2", "2", "B = a*b*c-R", "B", "a*b*c-R", "a*b*c", "a*b", "a", "b", "c", "R", "print(B - R)", "print", "B - R", "B", "R", "abc = []", "[]", "abc", "R, B = 0, 0", "0", "R", "B = 0, 0", "0", "B", "B = a*b*c-R", "a*b*c-R", "B", "a, b, c = map(int, input().split())", "map(int, input().split())", "a", "R = abc[0] * abc[1] * (abc[2]//2)", "abc[0] * abc[1] * (abc[2]//2)", "R", "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, 4, 13, 8, 2, 2, 2, 2, 13, 13, 13, 17, 17, 17, 2, 2, 2, 13, 13, 13, 4, 13, 13, 13, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 44, 2 ], [ 44, 11 ], [ 44, 12 ], [ 39, 20 ], [ 42, 21 ], [ 45, 22 ], [ 39, 29 ], [ 42, 30 ], [ 45, 31 ], [ 39, 34 ], [ 42, 35 ], [ 45, 36 ], [ 44, 39 ], [ 44, 42 ], [ 44, 45 ] ]

[ "a, b, c = map(int, input().split())\nprint(0 if a * b * c % 2 == 0 else 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", "print(0 if a * b * c % 2 == 0 else a * b * c // max(a, b, c) )", "print", "0 if a * b * c % 2 == 0 else a * b * c // max(a, b, c)", "a * b * c % 2 == 0", "a * b * c % 2", "a * b * c", "a * b", "a", "b", "c", "2", "0", "0", "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, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 13, 14, 2, 2, 4, 13, 13, 13, 13, 17, 17, 0, 13, 17, 0, 13, 2, 4, 13, 13, 13, 13, 2, 2, 2, 2, 13, 13, 13, 4, 13, 13, 13, 13, 4, 13, 13, 13, 13, 4, 13, 13, 10, 4, 13, 10, 2, 13, 10, 17, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 67, 2 ], [ 67, 11 ], [ 67, 12 ], [ 68, 18 ], [ 56, 19 ], [ 65, 20 ], [ 61, 24 ], [ 58, 27 ], [ 68, 31 ], [ 56, 32 ], [ 65, 33 ], [ 68, 38 ], [ 56, 39 ], [ 65, 40 ], [ 68, 43 ], [ 56, 44 ], [ 65, 45 ], [ 68, 48 ], [ 56, 49 ], [ 65, 50 ], [ 59, 53 ], [ 62, 53 ], [ 67, 56 ], [ 58, 59 ], [ 61, 62 ], [ 67, 65 ], [ 67, 68 ] ]

[ "A, B, C = map(int, input().split())\nif max(A, B, C) % 2 == 0:\n ans = 0\nelse:\n ans = min(A, B, C)*(A+B+C-max(A, B, C)-min(A, B, 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 max(A, B, C) % 2 == 0:\n ans = 0\nelse:\n ans = min(A, B, C)*(A+B+C-max(A, B, C)-min(A, B, C))", "max(A, B, C) % 2 == 0", "max(A, B, C) % 2", "max(A, B, C)", "max", "A", "B", "C", "2", "0", "ans = 0", "ans", "0", "ans = min(A, B, C)*(A+B+C-max(A, B, C)-min(A, B, C))", "ans", "min(A, B, C)*(A+B+C-max(A, B, C)-min(A, B, C))", "min(A, B, C)", "min", "A", "B", "C", "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", "print(ans)", "print", "ans", "B, C = map(int, input().split())", "map(int, input().split())", "B", "ans = min(A, B, C)*(A+B+C-max(A, B, C)-min(A, B, C))", "min(A, B, C)*(A+B+C-max(A, B, C)-min(A, B, C))", "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" ]

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

[ [ 54, 2 ], [ 55, 19 ], [ 55, 26 ], [ 55, 33 ], [ 55, 42 ], [ 55, 48 ], [ 55, 51 ], [ 54, 55 ] ]

[ "ABC =list( map(int,input().split()))\n\nif (ABC[0]%2==0) |(ABC[1]%2==0)|(ABC[2]%2==0):\n print(0)\nelse:\n ABC.sort()\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", "if (ABC[0]%2==0) |(ABC[1]%2==0)|(ABC[2]%2==0):\n print(0)\nelse:\n ABC.sort()\n print(ABC[0]*ABC[1])", "(ABC[0]%2==0) |(ABC[1]%2==0)|(ABC[2]%2==0)", "(ABC[0]%2==0) |(ABC[1]%2==0)", "ABC[0]%2==0", "ABC[0]%2", "ABC[0]", "ABC", "0", "2", "0", "ABC[1]%2==0", "ABC[1]%2", "ABC[1]", "ABC", "1", "2", "0", "ABC[2]%2==0", "ABC[2]%2", "ABC[2]", "ABC", "2", "2", "0", "print(0)", "print", "0", "ABC.sort()", "ABC.sort", "ABC", "sort", "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, 4, 13, 13, 4, 18, 4, 13, 13, 4, 18, 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 ]

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

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