Datasets:

---

codefuse-ai

/

GALLa

like 1

Follow

CodeFuse AI 145

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

[ [ 69, 2 ], [ 69, 11 ], [ 69, 12 ], [ 70, 21 ], [ 67, 22 ], [ 64, 25 ], [ 64, 27 ], [ 64, 30 ], [ 70, 36 ], [ 64, 37 ], [ 67, 40 ], [ 67, 42 ], [ 67, 45 ], [ 64, 51 ], [ 67, 52 ], [ 70, 55 ], [ 70, 57 ], [ 70, 60 ], [ 69, 64 ], [ 69, 67 ], [ 69, 70 ] ]

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

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

[ [ 67, 2 ], [ 64, 8 ], [ 61, 20 ], [ 65, 23 ], [ 68, 23 ], [ 62, 30 ], [ 65, 30 ], [ 68, 30 ], [ 62, 37 ], [ 65, 37 ], [ 68, 37 ], [ 62, 44 ], [ 65, 44 ], [ 68, 44 ], [ 62, 55 ], [ 65, 55 ], [ 68, 55 ], [ 62, 58 ], [ 65, 58 ], [ 68, 58 ], [ 61, 62 ], [ 64, 65 ], [ 67, 68 ] ]

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

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

[ [ 61, 2 ], [ 61, 11 ], [ 61, 12 ], [ 59, 18 ], [ 56, 23 ], [ 62, 28 ], [ 52, 35 ], [ 53, 46 ], [ 53, 49 ], [ 52, 53 ], [ 61, 56 ], [ 61, 59 ], [ 61, 62 ] ]

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

[ [ 42, 2 ], [ 42, 15 ], [ 42, 16 ], [ 40, 22 ], [ 37, 23 ], [ 43, 24 ], [ 40, 33 ], [ 37, 34 ], [ 42, 37 ], [ 42, 40 ], [ 42, 43 ] ]

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

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

[ [ 4, 3 ], [ 3, 12 ], [ 59, 14 ], [ 59, 16 ], [ 59, 17 ], [ 57, 23 ], [ 54, 28 ], [ 60, 33 ], [ 57, 44 ], [ 54, 45 ], [ 54, 47 ], [ 60, 48 ], [ 60, 50 ], [ 57, 51 ], [ 59, 54 ], [ 59, 57 ], [ 59, 60 ] ]

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

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

[ [ 69, 2 ], [ 69, 8 ], [ 69, 9 ], [ 60, 11 ], [ 70, 14 ], [ 66, 16 ], [ 55, 19 ], [ 63, 21 ], [ 58, 24 ], [ 72, 26 ], [ 73, 37 ], [ 73, 48 ], [ 73, 51 ], [ 69, 55 ], [ 69, 58 ], [ 60, 61 ], [ 63, 64 ], [ 66, 67 ], [ 69, 70 ], [ 72, 73 ] ]

[ "a,b,c=input().split()\na=int(a)\nb=int(b)\nc=int(c)\nabc=sorted([a,b,c])\nif abc[2]%2==0:\n print(0)\nelse:\n print(abc[0]*abc[1])", "a,b,c=input().split()", "a", "input().split()", "().split", "()", "input", "split", "b", "c", "a=int(a)", "a", "int(a)", "int", "a", "b=int(b)", "b", "int(b)", "int", "b", "c=int(c)", "c", "int(c)", "int", "c", "abc=sorted([a,b,c])", "abc", "sorted([a,b,c])", "sorted", "[a,b,c]", "a", "b", "c", "if abc[2]%2==0:\n print(0)\nelse:\n print(abc[0]*abc[1])", "abc[2]%2==0", "abc[2]%2", "abc[2]", "abc", "2", "2", "0", "print(0)", "print", "0", "print(abc[0]*abc[1])", "print", "abc[0]*abc[1]", "abc[0]", "abc", "0", "abc[1]", "abc", "1", "b,c=input().split()", "input().split()", "b", "c=input().split()", "input().split()", "c", "a=int(a)", "int(a)", "a", "c=int(c)", "int(c)", "c", "b=int(b)", "int(b)", "b", "a,b,c=input().split()", "input().split()", "a", "abc=sorted([a,b,c])", "sorted([a,b,c])", "abc" ]

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

[ [ 112, 4 ], [ 27, 14 ], [ 24, 17 ], [ 113, 21 ], [ 25, 24 ], [ 28, 27 ], [ 36, 34 ], [ 36, 36 ], [ 38, 38 ], [ 51, 44 ], [ 53, 45 ], [ 116, 47 ], [ 51, 48 ], [ 53, 49 ], [ 51, 51 ], [ 53, 53 ], [ 58, 57 ], [ 110, 59 ], [ 58, 60 ], [ 58, 61 ], [ 64, 63 ], [ 67, 66 ], [ 57, 70 ], [ 60, 72 ], [ 61, 73 ], [ 76, 75 ], [ 60, 79 ], [ 61, 81 ], [ 57, 82 ], [ 85, 84 ], [ 61, 88 ], [ 57, 90 ], [ 60, 91 ], [ 94, 93 ], [ 66, 96 ], [ 75, 97 ], [ 84, 98 ], [ 93, 101 ], [ 63, 101 ], [ 119, 107 ], [ 112, 113 ] ]

[ "import sys\ninput = sys.stdin.readline\n \ndef linput(ty=int, cvt=list):\n\treturn cvt(map(ty,input().split()))\n \ndef gcd(a: int, b: int):\n\twhile b: a, b = b, a%b\n\treturn a\n \ndef lcm(a: int, b: int):\n\treturn a * b // gcd(a, b)\n \ndef main():\n\t#n=int(input())\n\t#vA=linput()\n\ta,b,c = linput()\n\t\n\tres = 0\n\t\n\tx = (a%2)*b*c\n\ty = (b%2)*c*a\n\tz = (c%2)*a*b\n\t\n\tres = min(x,y,z)\n\t\n\t#sT = \"No Yes\".split()\n\t#print(sT[res])\n\tprint(res)\n \nif __name__ == \"__main__\":\n\tmain()", "import sys", "sys", "input = sys.stdin.readline", "input", "sys.stdin.readline", "sys.stdin", "sys", "stdin", "readline", "def linput(ty=int, cvt=list):\n\treturn cvt(map(ty,input().split()))\n ", "linput", "return cvt(map(ty,input().split()))", "cvt(map(ty,input().split()))", "cvt", "map(ty,input().split())", "map", "ty", "input().split()", "().split", "()", "input", "split", "ty=int", "ty", "int", "cvt=list", "cvt", "list", "def gcd(a: int, b: int):\n\twhile b: a, b = b, a%b\n\treturn a\n ", "gcd", "while b: a, b = b, a%b\n\t", "b", "return a", "a", "a: int", "a", "b: int", "b", "def lcm(a: int, b: int):\n\treturn a * b // gcd(a, b)\n ", "lcm", "return a * b // gcd(a, b)", "a * b // gcd(a, b)", "a * b", "a", "b", "gcd(a, b)", "gcd", "a", "b", "a: int", "a", "b: int", "b", "def main():\n\t#n=int(input())\n\t#vA=linput()\n\ta,b,c = linput()\n\t\n\tres = 0\n\t\n\tx = (a%2)*b*c\n\ty = (b%2)*c*a\n\tz = (c%2)*a*b\n\t\n\tres = min(x,y,z)\n\t\n\t#sT = \"No Yes\".split()\n\t#print(sT[res])\n\tprint(res)\n ", "main", "a,b,c = linput()", "a", "linput()", "linput", "b", "c", "res = 0", "res", "0", "x = (a%2)*b*c", "x", "(a%2)*b*c", "(a%2)*b", "a%2", "a", "2", "b", "c", "y = (b%2)*c*a", "y", "(b%2)*c*a", "(b%2)*c", "b%2", "b", "2", "c", "a", "z = (c%2)*a*b", "z", "(c%2)*a*b", "(c%2)*a", "c%2", "c", "2", "a", "b", "res = min(x,y,z)", "res", "min(x,y,z)", "min", "x", "y", "z", "print(res)", "print", "res", "if __name__ == \"__main__\":\n\tmain()", "__name__ == \"__main__\"", "__name__", "\"__main__\"", "main()", "main", "def linput(ty=int, cvt=list):\n\treturn cvt(map(ty,input().split()))\n ", "def linput(ty=int, cvt=list):\n\treturn cvt(map(ty,input().split()))\n ", "linput", "input = sys.stdin.readline", "sys.stdin.readline", "input", "def gcd(a: int, b: int):\n\twhile b: a, b = b, a%b\n\treturn a\n ", "def gcd(a: int, b: int):\n\twhile b: a, b = b, a%b\n\treturn a\n ", "gcd", "def main():\n\t#n=int(input())\n\t#vA=linput()\n\ta,b,c = linput()\n\t\n\tres = 0\n\t\n\tx = (a%2)*b*c\n\ty = (b%2)*c*a\n\tz = (c%2)*a*b\n\t\n\tres = min(x,y,z)\n\t\n\t#sT = \"No Yes\".split()\n\t#print(sT[res])\n\tprint(res)\n ", "def main():\n\t#n=int(input())\n\t#vA=linput()\n\ta,b,c = linput()\n\t\n\tres = 0\n\t\n\tx = (a%2)*b*c\n\ty = (b%2)*c*a\n\tz = (c%2)*a*b\n\t\n\tres = min(x,y,z)\n\t\n\t#sT = \"No Yes\".split()\n\t#print(sT[res])\n\tprint(res)\n ", "main", "def lcm(a: int, b: int):\n\treturn a * b // gcd(a, b)\n ", "def lcm(a: int, b: int):\n\treturn a * b // gcd(a, b)\n ", "lcm" ]

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

[ [ 38, 2 ], [ 35, 14 ], [ 39, 17 ], [ 36, 29 ], [ 39, 29 ], [ 36, 32 ], [ 39, 32 ], [ 35, 36 ], [ 38, 39 ] ]

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

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

[ [ 71, 2 ], [ 71, 13 ], [ 71, 14 ], [ 65, 16 ], [ 72, 23 ], [ 60, 28 ], [ 69, 33 ], [ 62, 37 ], [ 63, 44 ], [ 63, 50 ], [ 63, 53 ], [ 71, 60 ], [ 62, 63 ], [ 65, 66 ], [ 71, 69 ], [ 71, 72 ] ]

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

[ [ 44, 2 ], [ 44, 11 ], [ 44, 12 ], [ 39, 17 ], [ 42, 18 ], [ 45, 19 ], [ 39, 26 ], [ 42, 27 ], [ 42, 29 ], [ 45, 30 ], [ 45, 32 ], [ 39, 33 ], [ 44, 39 ], [ 44, 42 ], [ 44, 45 ] ]

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

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

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

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

[ [ 84, 2 ], [ 81, 14 ], [ 18, 17 ], [ 85, 17 ], [ 17, 22 ], [ 75, 26 ], [ 78, 31 ], [ 69, 34 ], [ 38, 37 ], [ 43, 42 ], [ 37, 46 ], [ 70, 51 ], [ 85, 55 ], [ 37, 56 ], [ 85, 58 ], [ 42, 59 ], [ 72, 61 ], [ 70, 64 ], [ 73, 67 ], [ 79, 67 ], [ 69, 70 ], [ 72, 73 ], [ 75, 76 ], [ 78, 79 ], [ 81, 82 ], [ 84, 85 ] ]

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

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

[ [ 129, 14 ], [ 132, 25 ], [ 132, 34 ], [ 132, 35 ], [ 120, 37 ], [ 109, 40 ], [ 118, 41 ], [ 133, 42 ], [ 114, 44 ], [ 109, 47 ], [ 118, 48 ], [ 133, 49 ], [ 111, 51 ], [ 109, 54 ], [ 118, 55 ], [ 133, 56 ], [ 126, 58 ], [ 109, 63 ], [ 118, 64 ], [ 133, 65 ], [ 115, 66 ], [ 112, 67 ], [ 123, 69 ], [ 115, 73 ], [ 112, 75 ], [ 127, 76 ], [ 105, 78 ], [ 115, 83 ], [ 112, 86 ], [ 127, 87 ], [ 115, 91 ], [ 124, 102 ], [ 106, 103 ], [ 105, 106 ], [ 132, 109 ], [ 111, 112 ], [ 114, 115 ], [ 132, 118 ], [ 120, 121 ], [ 123, 124 ], [ 126, 127 ], [ 129, 130 ], [ 132, 133 ] ]

[ "import collections\nimport sys\nimport numpy as np\nsys.setrecursionlimit(1000000000)\nfrom heapq import heapify,heappop,heappush,heappushpop\nMOD = 10**9+7\nimport itertools\nimport math\n\na,b,c = map(int,input().split())\nmax_block = a*b*c\nmax_edge = max(a,b,c)\nmin_edge = min(a,b,c)\nmiddle_edge = (a+b+c) - max_edge - min_edge\nchoku1 = (max_edge//2)*min_edge*middle_edge\nchoku2 = (max_edge//2+1) * min_edge * middle_edge\nif max_edge%2 == 0:\n print(\"0\")\nelse:\n print(abs(choku1-choku2))", "import collections", "collections", "import sys", "sys", "import numpy as np", "numpy", "sys.setrecursionlimit(1000000000)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "1000000000", "from heapq import heapify,heappop,heappush,heappushpop", "MOD = 10**9+7", "MOD", "10**9+7", "10**9", "10", "9", "7", "import itertools", "itertools", "import math", "math", "a,b,c = map(int,input().split())", "a", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "c", "max_block = a*b*c", "max_block", "a*b*c", "a*b", "a", "b", "c", "max_edge = max(a,b,c)", "max_edge", "max(a,b,c)", "max", "a", "b", "c", "min_edge = min(a,b,c)", "min_edge", "min(a,b,c)", "min", "a", "b", "c", "middle_edge = (a+b+c) - max_edge - min_edge", "middle_edge", "(a+b+c) - max_edge - min_edge", "(a+b+c) - max_edge", "a+b+c", "a+b", "a", "b", "c", "max_edge", "min_edge", "choku1 = (max_edge//2)*min_edge*middle_edge", "choku1", "(max_edge//2)*min_edge*middle_edge", "(max_edge//2)*min_edge", "max_edge//2", "max_edge", "2", "min_edge", "middle_edge", "choku2 = (max_edge//2+1) * min_edge * middle_edge", "choku2", "(max_edge//2+1) * min_edge * middle_edge", "(max_edge//2+1) * min_edge", "max_edge//2+1", "max_edge//2", "max_edge", "2", "1", "min_edge", "middle_edge", "if max_edge%2 == 0:\n print(\"0\")\nelse:\n print(abs(choku1-choku2))", "max_edge%2 == 0", "max_edge%2", "max_edge", "2", "0", "print(\"0\")", "print", "\"0\"", "print(abs(choku1-choku2))", "print", "abs(choku1-choku2)", "abs", "choku1-choku2", "choku1", "choku2", "choku2 = (max_edge//2+1) * min_edge * middle_edge", "(max_edge//2+1) * min_edge * middle_edge", "choku2", "a,b,c = map(int,input().split())", "map(int,input().split())", "a", "min_edge = min(a,b,c)", "min(a,b,c)", "min_edge", "max_edge = max(a,b,c)", "max(a,b,c)", "max_edge", "b,c = map(int,input().split())", "map(int,input().split())", "b", "max_block = a*b*c", "a*b*c", "max_block", "choku1 = (max_edge//2)*min_edge*middle_edge", "(max_edge//2)*min_edge*middle_edge", "choku1", "middle_edge = (a+b+c) - max_edge - min_edge", "(a+b+c) - max_edge - min_edge", "middle_edge", "MOD = 10**9+7", "10**9+7", "MOD", "c = map(int,input().split())", "map(int,input().split())", "c" ]

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

[ [ 64, 2 ], [ 67, 16 ], [ 65, 19 ], [ 58, 23 ], [ 68, 25 ], [ 55, 28 ], [ 68, 30 ], [ 68, 32 ], [ 61, 35 ], [ 65, 38 ], [ 65, 41 ], [ 62, 49 ], [ 59, 50 ], [ 62, 52 ], [ 56, 53 ], [ 55, 56 ], [ 58, 59 ], [ 61, 62 ], [ 64, 65 ], [ 67, 68 ] ]

[ "s = sorted(list(map(int, input().split())))\na = s.pop(-1)\nb = a // 2\nc = a - (a//2)\nd = s[0] * s[1]\nprint(abs(d * b - d * c))", "s = sorted(list(map(int, input().split())))", "s", "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 = s.pop(-1)", "a", "s.pop(-1)", "s.pop", "s", "pop", "-1", "b = a // 2", "b", "a // 2", "a", "2", "c = a - (a//2)", "c", "a - (a//2)", "a", "a//2", "a", "2", "d = s[0] * s[1]", "d", "s[0] * s[1]", "s[0]", "s", "0", "s[1]", "s", "1", "print(abs(d * b - d * c))", "print", "abs(d * b - d * c)", "abs", "d * b - d * c", "d * b", "d", "b", "d * c", "d", "c", "c = a - (a//2)", "a - (a//2)", "c", "b = a // 2", "a // 2", "b", "d = s[0] * s[1]", "s[0] * s[1]", "d", "s = sorted(list(map(int, input().split())))", "sorted(list(map(int, input().split())))", "s", "a = s.pop(-1)", "s.pop(-1)", "a" ]

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

[ [ 5, 4 ], [ 4, 13 ], [ 94, 15 ], [ 94, 17 ], [ 94, 18 ], [ 88, 20 ], [ 80, 23 ], [ 92, 24 ], [ 95, 25 ], [ 97, 27 ], [ 85, 35 ], [ 80, 38 ], [ 92, 39 ], [ 95, 40 ], [ 86, 44 ], [ 82, 51 ], [ 89, 54 ], [ 98, 55 ], [ 86, 57 ], [ 76, 60 ], [ 89, 63 ], [ 98, 64 ], [ 86, 67 ], [ 77, 73 ], [ 83, 74 ], [ 76, 77 ], [ 94, 80 ], [ 82, 83 ], [ 85, 86 ], [ 88, 89 ], [ 94, 92 ], [ 94, 95 ], [ 97, 98 ] ]

[ "from statistics import median\n\nA, B, C = [int(x) for x in input().split()]\n\nlow = min(A, B, C)\nmid = median([A, B, C])\nhuge = max(A, B, C)\n\nif huge % 2 == 0:\n print(0)\nelse:\n red = low*mid*(huge//2)\n blue = low*mid*(huge//2+1)\n\n print(blue-red)", "from statistics import median", "int(x) for x in input().split()", "for x in input().split()", "x", "input().split()", "().split", "()", "input", "split", "for x in input().split()", "int(x)", "int", "x", "A, B, C = [int(x) for x in input().split()]", "A", "[int(x) for x in input().split()]", "B", "C", "low = min(A, B, C)", "low", "min(A, B, C)", "min", "A", "B", "C", "mid = median([A, B, C])", "mid", "median([A, B, C])", "median", "[A, B, C]", "A", "B", "C", "huge = max(A, B, C)", "huge", "max(A, B, C)", "max", "A", "B", "C", "if huge % 2 == 0:\n print(0)\nelse:\n red = low*mid*(huge//2)\n blue = low*mid*(huge//2+1)\n\n print(blue-red)", "huge % 2 == 0", "huge % 2", "huge", "2", "0", "print(0)", "print", "0", "red = low*mid*(huge//2)", "red", "low*mid*(huge//2)", "low*mid", "low", "mid", "huge//2", "huge", "2", "blue = low*mid*(huge//2+1)", "blue", "low*mid*(huge//2+1)", "low*mid", "low", "mid", "huge//2+1", "huge//2", "huge", "2", "1", "print(blue-red)", "print", "blue-red", "blue", "red", "blue = low*mid*(huge//2+1)", "low*mid*(huge//2+1)", "blue", "A, B, C = [int(x) for x in input().split()]", "[int(x) for x in input().split()]", "A", "red = low*mid*(huge//2)", "low*mid*(huge//2)", "red", "huge = max(A, B, C)", "max(A, B, C)", "huge", "low = min(A, B, C)", "min(A, B, C)", "low", "B, C = [int(x) for x in input().split()]", "[int(x) for x in input().split()]", "B", "C = [int(x) for x in input().split()]", "[int(x) for x in input().split()]", "C", "mid = median([A, B, C])", "median([A, B, C])", "mid" ]

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

[ [ 60, 2 ], [ 61, 15 ], [ 61, 20 ], [ 66, 29 ], [ 61, 32 ], [ 61, 35 ], [ 63, 38 ], [ 61, 41 ], [ 67, 50 ], [ 64, 51 ], [ 67, 53 ], [ 61, 56 ], [ 64, 58 ], [ 60, 61 ], [ 63, 64 ], [ 66, 67 ] ]

[ "a = list(map(int,input().split()))\n\na.sort()\n\nif a[2] == 0:\n print(0)\n exit()\nm = a[0]*a[1]\nn = a[2]//2\nprint(abs(m*n-m*(a[2]-n)))", "a = list(map(int,input().split()))", "a", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "a.sort()", "a.sort", "a", "sort", "if a[2] == 0:\n print(0)\n exit()", "a[2] == 0", "a[2]", "a", "2", "0", "print(0)", "print", "0", "exit()", "exit", "m = a[0]*a[1]", "m", "a[0]*a[1]", "a[0]", "a", "0", "a[1]", "a", "1", "n = a[2]//2", "n", "a[2]//2", "a[2]", "a", "2", "2", "print(abs(m*n-m*(a[2]-n)))", "print", "abs(m*n-m*(a[2]-n))", "abs", "m*n-m*(a[2]-n)", "m*n", "m", "n", "m*(a[2]-n)", "m", "a[2]-n", "a[2]", "a", "2", "n", "a = list(map(int,input().split()))", "list(map(int,input().split()))", "a", "n = a[2]//2", "a[2]//2", "n", "m = a[0]*a[1]", "a[0]*a[1]", "m" ]

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

[ [ 10, 9 ], [ 91, 13 ], [ 9, 16 ], [ 22, 21 ], [ 91, 25 ], [ 21, 30 ], [ 84, 34 ], [ 94, 36 ], [ 85, 44 ], [ 85, 49 ], [ 85, 52 ], [ 85, 57 ], [ 85, 62 ], [ 85, 65 ], [ 85, 70 ], [ 85, 75 ], [ 85, 78 ], [ 84, 85 ] ]

[ "import sys\ndef rs(): return sys.stdin.readline().rstrip()\ndef ri(): return int(rs())\ndef rs_(): return [_ for _ in rs().split()]\ndef ri_(): return [int(_) for _ in rs().split()]\n\na = ri_()\nprint(min((a[0] % 2) * (a[1] * a[2]), (a[1] % 2) * (a[0] * a[2]), (a[2] % 2) * (a[0] * a[1])))", "import sys", "sys", "def rs(): return sys.stdin.readline().rstrip()", "rs", "def ri(): return int(rs())", "ri", "_ for _ in rs().split()", "for _ in rs().split()", "_", "rs().split()", "().split", "()", "rs", "split", "for _ in rs().split()", "_", "def rs_(): return [_ for _ in rs().split()]", "rs_", "int(_) for _ in rs().split()", "for _ in rs().split()", "_", "rs().split()", "().split", "()", "rs", "split", "for _ in rs().split()", "int(_)", "int", "_", "def ri_(): return [int(_) for _ in rs().split()]", "ri_", "a = ri_()", "a", "ri_()", "ri_", "print(min((a[0] % 2) * (a[1] * a[2]), (a[1] % 2) * (a[0] * a[2]), (a[2] % 2) * (a[0] * a[1])))", "print", "min((a[0] % 2) * (a[1] * a[2]), (a[1] % 2) * (a[0] * a[2]), (a[2] % 2) * (a[0] * a[1]))", "min", "(a[0] % 2) * (a[1] * a[2])", "a[0] % 2", "a[0]", "a", "0", "2", "a[1] * a[2]", "a[1]", "a", "1", "a[2]", "a", "2", "(a[1] % 2) * (a[0] * a[2])", "a[1] % 2", "a[1]", "a", "1", "2", "a[0] * a[2]", "a[0]", "a", "0", "a[2]", "a", "2", "(a[2] % 2) * (a[0] * a[1])", "a[2] % 2", "a[2]", "a", "2", "2", "a[0] * a[1]", "a[0]", "a", "0", "a[1]", "a", "1", "def rs_(): return [_ for _ in rs().split()]", "def rs_(): return [_ for _ in rs().split()]", "rs_", "a = ri_()", "ri_()", "a", "def ri(): return int(rs())", "def ri(): return int(rs())", "ri", "def rs(): return sys.stdin.readline().rstrip()", "def rs(): return sys.stdin.readline().rstrip()", "rs", "def ri_(): return [int(_) for _ in rs().split()]", "def ri_(): return [int(_) for _ in rs().split()]", "ri_" ]

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

[ [ 93, 2 ], [ 93, 11 ], [ 93, 12 ], [ 96, 14 ], [ 82, 17 ], [ 94, 18 ], [ 85, 19 ], [ 99, 21 ], [ 97, 22 ], [ 102, 24 ], [ 100, 27 ], [ 82, 36 ], [ 94, 38 ], [ 85, 39 ], [ 97, 40 ], [ 87, 42 ], [ 103, 45 ], [ 100, 45 ], [ 94, 54 ], [ 85, 56 ], [ 82, 57 ], [ 97, 58 ], [ 90, 60 ], [ 88, 63 ], [ 103, 63 ], [ 100, 63 ], [ 85, 72 ], [ 82, 74 ], [ 94, 75 ], [ 97, 76 ], [ 91, 79 ], [ 88, 79 ], [ 103, 79 ], [ 100, 79 ], [ 93, 82 ], [ 93, 85 ], [ 87, 88 ], [ 90, 91 ], [ 93, 94 ], [ 96, 97 ], [ 97, 99 ], [ 99, 100 ], [ 102, 103 ] ]

[ "A,B,C = map(int,input().split())\nN = A*B*C\ncmin = N\ncmin = min(cmin,abs(2*(A//2)*B*C-N))\ncmin = min(cmin,abs(2*(B//2)*C*A-N))\ncmin = min(cmin,abs(2*(C//2)*A*B-N))\nprint(cmin)", "A,B,C = map(int,input().split())", "A", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "B", "C", "N = A*B*C", "N", "A*B*C", "A*B", "A", "B", "C", "cmin = N", "cmin", "N", "cmin = min(cmin,abs(2*(A//2)*B*C-N))", "cmin", "min(cmin,abs(2*(A//2)*B*C-N))", "min", "cmin", "abs(2*(A//2)*B*C-N)", "abs", "2*(A//2)*B*C-N", "2*(A//2)*B*C", "2*(A//2)*B", "2*(A//2)", "2", "A//2", "A", "2", "B", "C", "N", "cmin = min(cmin,abs(2*(B//2)*C*A-N))", "cmin", "min(cmin,abs(2*(B//2)*C*A-N))", "min", "cmin", "abs(2*(B//2)*C*A-N)", "abs", "2*(B//2)*C*A-N", "2*(B//2)*C*A", "2*(B//2)*C", "2*(B//2)", "2", "B//2", "B", "2", "C", "A", "N", "cmin = min(cmin,abs(2*(C//2)*A*B-N))", "cmin", "min(cmin,abs(2*(C//2)*A*B-N))", "min", "cmin", "abs(2*(C//2)*A*B-N)", "abs", "2*(C//2)*A*B-N", "2*(C//2)*A*B", "2*(C//2)*A", "2*(C//2)", "2", "C//2", "C", "2", "A", "B", "N", "print(cmin)", "print", "cmin", "A,B,C = map(int,input().split())", "map(int,input().split())", "A", "C = map(int,input().split())", "map(int,input().split())", "C", "cmin = min(cmin,abs(2*(B//2)*C*A-N))", "min(cmin,abs(2*(B//2)*C*A-N))", "cmin", "cmin = min(cmin,abs(2*(C//2)*A*B-N))", "min(cmin,abs(2*(C//2)*A*B-N))", "cmin", "B,C = map(int,input().split())", "map(int,input().split())", "B", "N = A*B*C", "A*B*C", "N", "cmin = N", "N", "cmin", "cmin = min(cmin,abs(2*(A//2)*B*C-N))", "min(cmin,abs(2*(A//2)*B*C-N))", "cmin" ]

[ 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 ], [ 52, 18 ], [ 55, 23 ], [ 49, 28 ], [ 52, 39 ], [ 55, 40 ], [ 55, 42 ], [ 49, 43 ], [ 49, 45 ], [ 52, 46 ], [ 54, 49 ], [ 54, 52 ], [ 54, 55 ] ]

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

[ [ 84, 2 ], [ 84, 11 ], [ 84, 12 ], [ 87, 14 ], [ 79, 17 ], [ 85, 18 ], [ 82, 23 ], [ 82, 26 ], [ 82, 28 ], [ 72, 31 ], [ 85, 34 ], [ 82, 35 ], [ 79, 40 ], [ 79, 43 ], [ 79, 45 ], [ 75, 48 ], [ 79, 51 ], [ 82, 52 ], [ 85, 57 ], [ 85, 60 ], [ 85, 62 ], [ 88, 68 ], [ 73, 69 ], [ 76, 70 ], [ 72, 73 ], [ 75, 76 ], [ 84, 79 ], [ 84, 82 ], [ 84, 85 ], [ 87, 88 ] ]

[ "a,b,c = map(int, input().split())\n\nans1=a*b*abs(c//2 - (c-c//2))\nans2=b*c*abs(a//2 - (a-a//2))\nans3=a*c*abs(b//2 - (b-b//2))\n\nprint(min(ans1,ans2,ans3))", "a,b,c = map(int, input().split())", "a", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "c", "ans1=a*b*abs(c//2 - (c-c//2))", "ans1", "a*b*abs(c//2 - (c-c//2))", "a*b", "a", "b", "abs(c//2 - (c-c//2))", "abs", "c//2 - (c-c//2)", "c//2", "c", "2", "c-c//2", "c", "c//2", "c", "2", "ans2=b*c*abs(a//2 - (a-a//2))", "ans2", "b*c*abs(a//2 - (a-a//2))", "b*c", "b", "c", "abs(a//2 - (a-a//2))", "abs", "a//2 - (a-a//2)", "a//2", "a", "2", "a-a//2", "a", "a//2", "a", "2", "ans3=a*c*abs(b//2 - (b-b//2))", "ans3", "a*c*abs(b//2 - (b-b//2))", "a*c", "a", "c", "abs(b//2 - (b-b//2))", "abs", "b//2 - (b-b//2)", "b//2", "b", "2", "b-b//2", "b", "b//2", "b", "2", "print(min(ans1,ans2,ans3))", "print", "min(ans1,ans2,ans3)", "min", "ans1", "ans2", "ans3", "ans2=b*c*abs(a//2 - (a-a//2))", "b*c*abs(a//2 - (a-a//2))", "ans2", "ans3=a*c*abs(b//2 - (b-b//2))", "a*c*abs(b//2 - (b-b//2))", "ans3", "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", "ans1=a*b*abs(c//2 - (c-c//2))", "a*b*abs(c//2 - (c-c//2))", "ans1" ]

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

[ [ 31, 2 ], [ 31, 13 ], [ 31, 14 ], [ 26, 19 ], [ 29, 20 ], [ 32, 22 ], [ 31, 26 ], [ 31, 29 ], [ 31, 32 ] ]

[ "i, j, k = sorted(map(int, input().split()))\nprint(i*j*(k%2))", "i, j, k = sorted(map(int, input().split()))", "i", "sorted(map(int, input().split()))", "sorted", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "j", "k", "print(i*j*(k%2))", "print", "i*j*(k%2)", "i*j", "i", "j", "k%2", "k", "2", "i, j, k = sorted(map(int, input().split()))", "sorted(map(int, input().split()))", "i", "j, k = sorted(map(int, input().split()))", "sorted(map(int, input().split()))", "j", "k = sorted(map(int, input().split()))", "sorted(map(int, input().split()))", "k" ]

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

[ [ 57, 2 ], [ 57, 11 ], [ 57, 12 ], [ 60, 14 ], [ 49, 17 ], [ 58, 18 ], [ 52, 19 ], [ 63, 21 ], [ 61, 27 ], [ 49, 29 ], [ 58, 30 ], [ 52, 31 ], [ 61, 32 ], [ 54, 34 ], [ 49, 38 ], [ 58, 39 ], [ 52, 40 ], [ 64, 41 ], [ 55, 45 ], [ 64, 46 ], [ 57, 49 ], [ 57, 52 ], [ 54, 55 ], [ 57, 58 ], [ 60, 61 ], [ 63, 64 ] ]

[ "a, b, c = map(int, input().split())\nmaxx = max(a, b, c)\nred = (maxx // 2 * a * b * c // maxx)\nblue = a * b * c - red\nprint(blue - red)", "a, b, c = map(int, input().split())", "a", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "c", "maxx = max(a, b, c)", "maxx", "max(a, b, c)", "max", "a", "b", "c", "red = (maxx // 2 * a * b * c // maxx)", "red", "maxx // 2 * a * b * c // maxx", "maxx // 2 * a * b * c", "maxx // 2 * a * b", "maxx // 2 * a", "maxx // 2", "maxx", "2", "a", "b", "c", "maxx", "blue = a * b * c - red", "blue", "a * b * c - red", "a * b * c", "a * b", "a", "b", "c", "red", "print(blue - red)", "print", "blue - red", "blue", "red", "a, b, c = map(int, input().split())", "map(int, input().split())", "a", "c = map(int, input().split())", "map(int, input().split())", "c", "blue = a * b * c - red", "a * b * c - red", "blue", "b, c = map(int, input().split())", "map(int, input().split())", "b", "maxx = max(a, b, c)", "max(a, b, c)", "maxx", "red = (maxx // 2 * a * b * c // maxx)", "maxx // 2 * a * b * c // maxx", "red" ]

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

[ [ 16, 15 ], [ 15, 33 ], [ 39, 39 ], [ 104, 45 ], [ 99, 47 ], [ 104, 48 ], [ 104, 49 ], [ 87, 57 ], [ 105, 62 ], [ 93, 67 ], [ 87, 74 ], [ 105, 75 ], [ 105, 77 ], [ 93, 78 ], [ 93, 80 ], [ 87, 81 ], [ 104, 87 ], [ 104, 93 ], [ 104, 105 ] ]

[ "import sys\nimport math\ndef I():return int(sys.stdin.readline().replace(\"\\n\",\"\"))\ndef I2():return map(int,sys.stdin.readline().replace(\"\\n\",\"\").split())\ndef S():return str(sys.stdin.readline().replace(\"\\n\",\"\"))\ndef L():return list(sys.stdin.readline().replace(\"\\n\",\"\"))\ndef Intl():return [int(k) for k in sys.stdin.readline().replace(\"\\n\",\"\").split()]\ndef Lx(k):return list(map(lambda x:int(x)*-k,sys.stdin.readline().replace(\"\\n\",\"\").split()))\n\nif __name__ == \"__main__\":\n a,b,c = I2()\n print(0 if a%2 == 0 or b%2 == 0 or c%2 == 0 else min(a*b,b*c,c*a))", "import sys", "sys", "import math", "math", "def I():return int(sys.stdin.readline().replace(\"\\n\",\"\"))", "I", "def I2():return map(int,sys.stdin.readline().replace(\"\\n\",\"\").split())", "I2", "def S():return str(sys.stdin.readline().replace(\"\\n\",\"\"))", "S", "def L():return list(sys.stdin.readline().replace(\"\\n\",\"\"))", "L", "int(k) for k in sys.stdin.readline().replace(\"\\n\",\"\").split()", "for k in sys.stdin.readline().replace(\"\\n\",\"\").split()", "k", "sys.stdin.readline().replace(\"\\n\",\"\").split()", "sys.stdin.readline().replace(\"\\n\",\"\").split", "sys.stdin.readline().replace(\"\\n\",\"\")", "sys.stdin.readline().replace", "sys.stdin.readline()", "sys.stdin.readline", "sys.stdin", "sys", "stdin", "readline", "replace", "\"\\n\"", "\"\"", "split", "for k in sys.stdin.readline().replace(\"\\n\",\"\").split()", "int(k)", "int", "k", "def Intl():return [int(k) for k in sys.stdin.readline().replace(\"\\n\",\"\").split()]", "Intl", "def Lx(k):return list(map(lambda x:int(x)*-k,sys.stdin.readline().replace(\"\\n\",\"\").split()))", "Lx", "k", "k", "if __name__ == \"__main__\":\n a,b,c = I2()\n print(0 if a%2 == 0 or b%2 == 0 or c%2 == 0 else min(a*b,b*c,c*a))", "__name__ == \"__main__\"", "__name__", "\"__main__\"", "a,b,c = I2()", "a", "I2()", "I2", "b", "c", "print(0 if a%2 == 0 or b%2 == 0 or c%2 == 0 else min(a*b,b*c,c*a))", "print", "0 if a%2 == 0 or b%2 == 0 or c%2 == 0 else 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", "0", "min(a*b,b*c,c*a)", "min", "a*b", "a", "b", "b*c", "b", "c", "c*a", "c", "a", "def L():return list(sys.stdin.readline().replace(\"\\n\",\"\"))", "def L():return list(sys.stdin.readline().replace(\"\\n\",\"\"))", "L", "a,b,c = I2()", "I2()", "a", "def I():return int(sys.stdin.readline().replace(\"\\n\",\"\"))", "def I():return int(sys.stdin.readline().replace(\"\\n\",\"\"))", "I", "c = I2()", "I2()", "c", "def Lx(k):return list(map(lambda x:int(x)*-k,sys.stdin.readline().replace(\"\\n\",\"\").split()))", "def Lx(k):return list(map(lambda x:int(x)*-k,sys.stdin.readline().replace(\"\\n\",\"\").split()))", "Lx", "def I2():return map(int,sys.stdin.readline().replace(\"\\n\",\"\").split())", "def I2():return map(int,sys.stdin.readline().replace(\"\\n\",\"\").split())", "I2", "def Intl():return [int(k) for k in sys.stdin.readline().replace(\"\\n\",\"\").split()]", "def Intl():return [int(k) for k in sys.stdin.readline().replace(\"\\n\",\"\").split()]", "Intl", "b,c = I2()", "I2()", "b", "def S():return str(sys.stdin.readline().replace(\"\\n\",\"\"))", "def S():return str(sys.stdin.readline().replace(\"\\n\",\"\"))", "S" ]

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

[ [ 116, 16 ], [ 119, 43 ], [ 123, 45 ], [ 119, 46 ], [ 119, 47 ], [ 114, 58 ], [ 120, 60 ], [ 111, 61 ], [ 114, 65 ], [ 114, 67 ], [ 120, 69 ], [ 111, 70 ], [ 114, 76 ], [ 120, 78 ], [ 111, 80 ], [ 114, 83 ], [ 120, 85 ], [ 120, 87 ], [ 111, 89 ], [ 114, 95 ], [ 120, 96 ], [ 111, 98 ], [ 114, 102 ], [ 120, 103 ], [ 111, 105 ], [ 111, 107 ], [ 119, 111 ], [ 119, 114 ], [ 116, 117 ], [ 119, 120 ] ]

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

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

[ [ 46, 2 ], [ 46, 11 ], [ 46, 12 ], [ 47, 18 ], [ 44, 19 ], [ 41, 20 ], [ 47, 28 ], [ 44, 29 ], [ 44, 31 ], [ 41, 32 ], [ 47, 34 ], [ 41, 35 ], [ 46, 41 ], [ 46, 44 ], [ 46, 47 ] ]

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

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

[ [ 74, 3 ], [ 74, 12 ], [ 74, 13 ], [ 77, 15 ], [ 75, 24 ], [ 72, 29 ], [ 63, 34 ], [ 65, 38 ], [ 68, 51 ], [ 78, 54 ], [ 69, 54 ], [ 69, 60 ], [ 66, 60 ], [ 78, 60 ], [ 74, 63 ], [ 65, 66 ], [ 68, 69 ], [ 74, 72 ], [ 74, 75 ], [ 77, 78 ] ]

[ "from itertools import *\nA,B,C = map(int,input().split())\nans = 10**18\nif A%2 == 0 or B%2 == 0 or C%2 == 0:\n ans = 0\nelse:\n for i,j in combinations([A,B,C],2):\n ans = min(ans,i*j)\nprint(ans)", "from itertools import *", "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 or B%2 == 0 or C%2 == 0:\n ans = 0\nelse:\n for i,j in combinations([A,B,C],2):\n ans = min(ans,i*j)", "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", "for i,j in combinations([A,B,C],2):\n ans = min(ans,i*j)", "i", "j", "combinations([A,B,C],2)", "combinations", "[A,B,C]", "A", "B", "C", "2", "ans = min(ans,i*j)", "ans", "min(ans,i*j)", "min", "ans", "i*j", "i", "j", "print(ans)", "print", "ans", "C = map(int,input().split())", "map(int,input().split())", "C", "ans = 0", "0", "ans", "ans = min(ans,i*j)", "min(ans,i*j)", "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 = 10**18", "10**18", "ans" ]

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

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

[ "a, b, c = map(int, input().split())\nif a % 2 == 1 and b % 2 == 1 and c % 2 == 1:\n print(a*b*c//max(a, b, c))\nelse:\n print(0)", "a, b, c = map(int, input().split())", "a", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "c", "if a % 2 == 1 and b % 2 == 1 and c % 2 == 1:\n print(a*b*c//max(a, b, c))\nelse:\n print(0)", "a % 2 == 1 and b % 2 == 1 and c % 2 == 1", "a % 2 == 1 and b % 2 == 1", "a % 2 == 1", "a % 2", "a", "2", "1", "b % 2 == 1", "b % 2", "b", "2", "1", "c % 2 == 1", "c % 2", "c", "2", "1", "print(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", "print(0)", "print", "0", "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, 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 ], [ 52, 23 ], [ 46, 24 ], [ 49, 25 ], [ 52, 36 ], [ 46, 37 ], [ 46, 39 ], [ 49, 40 ], [ 49, 42 ], [ 52, 43 ], [ 51, 46 ], [ 51, 49 ], [ 51, 52 ] ]

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

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

[ [ 64, 4 ], [ 18, 17 ], [ 62, 19 ], [ 17, 22 ], [ 26, 25 ], [ 29, 28 ], [ 17, 28 ], [ 28, 33 ], [ 38, 37 ], [ 37, 42 ], [ 25, 42 ], [ 17, 46 ], [ 17, 49 ], [ 68, 56 ], [ 64, 65 ] ]

[ "#create date: 2020-08-10 07:34\n\nimport sys\nstdin = sys.stdin\n\ndef ns(): return stdin.readline().rstrip()\ndef ni(): return int(ns())\ndef na(): return list(map(int, stdin.readline().split()))\n\ndef main():\n a = na()\n a.sort()\n zero = False\n for ai in a:\n if ai % 2== 0:\n zero =True\n print(0 if zero else a[0]*a[1])\n\nif __name__ == \"__main__\":\n main()", "import sys", "sys", "stdin = sys.stdin", "stdin", "sys.stdin", "sys", "stdin", "def ns(): return stdin.readline().rstrip()", "ns", "def ni(): return int(ns())", "ni", "def na(): return list(map(int, stdin.readline().split()))", "na", "def main():\n a = na()\n a.sort()\n zero = False\n for ai in a:\n if ai % 2== 0:\n zero =True\n print(0 if zero else a[0]*a[1])", "main", "a = na()", "a", "na()", "na", "a.sort()", "a.sort", "a", "sort", "zero = False", "zero", "False", "for ai in a:\n if ai % 2== 0:\n zero =True\n ", "ai", "a", "if ai % 2== 0:\n zero =True\n ", "ai % 2== 0", "ai % 2", "ai", "2", "0", "zero =True", "zero", "True", "print(0 if zero else a[0]*a[1])", "print", "0 if zero else a[0]*a[1]", "zero", "0", "a[0]*a[1]", "a[0]", "a", "0", "a[1]", "a", "1", "if __name__ == \"__main__\":\n main()", "__name__ == \"__main__\"", "__name__", "\"__main__\"", "main()", "main", "def ni(): return int(ns())", "def ni(): return int(ns())", "ni", "def na(): return list(map(int, stdin.readline().split()))", "def na(): return list(map(int, stdin.readline().split()))", "na", "stdin = sys.stdin", "sys.stdin", "stdin", "def main():\n a = na()\n a.sort()\n zero = False\n for ai in a:\n if ai % 2== 0:\n zero =True\n print(0 if zero else a[0]*a[1])", "def main():\n a = na()\n a.sort()\n zero = False\n for ai in a:\n if ai % 2== 0:\n zero =True\n print(0 if zero else a[0]*a[1])", "main", "def ns(): return stdin.readline().rstrip()", "def ns(): return stdin.readline().rstrip()", "ns" ]

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

[ [ 30, 2 ], [ 30, 11 ], [ 30, 12 ], [ 31, 18 ], [ 28, 19 ], [ 25, 20 ], [ 30, 25 ], [ 30, 28 ], [ 30, 31 ] ]

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

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

[ [ 72, 2 ], [ 72, 11 ], [ 72, 12 ], [ 67, 18 ], [ 70, 19 ], [ 73, 20 ], [ 63, 27 ], [ 67, 30 ], [ 70, 31 ], [ 73, 32 ], [ 67, 42 ], [ 70, 43 ], [ 73, 44 ], [ 64, 45 ], [ 64, 47 ], [ 67, 53 ], [ 70, 54 ], [ 73, 55 ], [ 64, 56 ], [ 64, 60 ], [ 63, 64 ], [ 72, 67 ], [ 72, 70 ], [ 72, 73 ] ]

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

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

[ [ 102, 4 ], [ 99, 13 ], [ 96, 22 ], [ 34, 33 ], [ 39, 38 ], [ 59, 39 ], [ 40, 39 ], [ 41, 40 ], [ 61, 41 ], [ 42, 41 ], [ 43, 42 ], [ 38, 43 ], [ 57, 43 ], [ 38, 47 ], [ 57, 47 ], [ 40, 54 ], [ 59, 54 ], [ 42, 55 ], [ 61, 55 ], [ 57, 57 ], [ 59, 59 ], [ 61, 61 ], [ 93, 63 ], [ 103, 70 ], [ 93, 72 ], [ 93, 73 ], [ 85, 79 ], [ 91, 80 ], [ 88, 81 ], [ 94, 82 ], [ 93, 88 ], [ 93, 91 ], [ 93, 94 ], [ 96, 97 ], [ 99, 100 ], [ 102, 103 ] ]

[ "import sys\n\nread = sys.stdin.buffer.read\nreadline = sys.stdin.buffer.readline\nreadlines = sys.stdin.buffer.readlines\n\ndef f(A, B, C):\n for _ in range(3):\n A, B, C = B, C, A\n if A % 2 == 0:\n yield 0\n yield B * C\n\nA, B, C = map(int, read().split())\nprint(min(f(A, B, C)))", "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 f(A, B, C):\n for _ in range(3):\n A, B, C = B, C, A\n if A % 2 == 0:\n yield 0\n yield B * C", "f", "for _ in range(3):\n A, B, C = B, C, A\n if A % 2 == 0:\n yield 0\n yield B * C", "_", "range(3)", "range", "3", "A, B, C = B, C, A", "A", "B", "B", "C", "C", "A", "if A % 2 == 0:\n yield 0\n ", "A % 2 == 0", "A % 2", "A", "2", "0", "yield 0", "0", "yield B * C", "B * C", "B", "C", "A", "A", "B", "B", "C", "C", "A, B, C = map(int, read().split())", "A", "map(int, read().split())", "map", "int", "read().split()", "().split", "()", "read", "split", "B", "C", "print(min(f(A, B, C)))", "print", "min(f(A, B, C))", "min", "f(A, B, C)", "f", "A", "B", "C", "def f(A, B, C):\n for _ in range(3):\n A, B, C = B, C, A\n if A % 2 == 0:\n yield 0\n yield B * C", "def f(A, B, C):\n for _ in range(3):\n A, B, C = B, C, A\n if A % 2 == 0:\n yield 0\n yield B * C", "f", "B, C = map(int, read().split())", "map(int, read().split())", "B", "A, B, C = map(int, read().split())", "map(int, read().split())", "A", "C = map(int, read().split())", "map(int, read().split())", "C", "readlines = sys.stdin.buffer.readlines", "sys.stdin.buffer.readlines", "readlines", "readline = sys.stdin.buffer.readline", "sys.stdin.buffer.readline", "readline", "read = sys.stdin.buffer.read", "sys.stdin.buffer.read", "read" ]

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

[ [ 75, 29 ], [ 78, 34 ], [ 44, 43 ], [ 91, 45 ], [ 43, 48 ], [ 43, 55 ], [ 43, 58 ], [ 43, 62 ], [ 82, 70 ], [ 75, 76 ], [ 78, 79 ] ]

[ "import sys\nimport re\nfrom collections import deque, defaultdict, Counter\nfrom math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians\nfrom itertools import permutations, combinations, product, accumulate\nfrom operator import itemgetter, mul\nfrom copy import deepcopy, copy\nfrom string import ascii_lowercase, ascii_uppercase, digits\nfrom fractions import gcd\nfrom queue import Queue\n\n\ndef input(): return sys.stdin.readline().strip()\n\n\ndef INT(): return int(input())\n\n\ndef MAP(): return map(int, input().split())\n\n\ndef LIST(): return list(map(int, input().split()))\n\n\nsys.setrecursionlimit(10 ** 9)\nINF = float('inf')\nmod = 10 ** 9 + 7\n\n\ndef main():\n abc = LIST()\n abc.sort()\n print(abc[0] * abc[1] * (abc[2] % 2))\n\n\nif __name__ == '__main__':\n main()", "import sys", "sys", "import re", "re", "from collections import deque, defaultdict, Counter", "from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians", "from itertools import permutations, combinations, product, accumulate", "from operator import itemgetter, mul", "from copy import deepcopy, copy", "from string import ascii_lowercase, ascii_uppercase, digits", "from fractions import gcd", "from queue import Queue", "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", "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", "def main():\n abc = LIST()\n abc.sort()\n print(abc[0] * abc[1] * (abc[2] % 2))", "main", "abc = LIST()", "abc", "LIST()", "LIST", "abc.sort()", "abc.sort", "abc", "sort", "print(abc[0] * abc[1] * (abc[2] % 2))", "print", "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", "if __name__ == '__main__':\n main()", "__name__ == '__main__'", "__name__", "'__main__'", "main()", "main", "def input(): return sys.stdin.readline().strip()", "def input(): return sys.stdin.readline().strip()", "input", "INF = float('inf')", "float('inf')", "INF", "mod = 10 ** 9 + 7", "10 ** 9 + 7", "mod", "def main():\n abc = LIST()\n abc.sort()\n print(abc[0] * abc[1] * (abc[2] % 2))", "def main():\n abc = LIST()\n abc.sort()\n print(abc[0] * abc[1] * (abc[2] % 2))", "main", "def MAP(): return map(int, input().split())", "def MAP(): return map(int, input().split())", "MAP", "def INT(): return int(input())", "def INT(): return int(input())", "INT", "def LIST(): return list(map(int, input().split()))", "def LIST(): return list(map(int, input().split()))", "LIST" ]

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

[ [ 64, 2 ], [ 64, 14 ], [ 64, 15 ], [ 65, 21 ], [ 62, 26 ], [ 56, 31 ], [ 58, 38 ], [ 65, 43 ], [ 62, 44 ], [ 62, 46 ], [ 56, 47 ], [ 56, 49 ], [ 65, 50 ], [ 59, 53 ], [ 64, 56 ], [ 58, 59 ], [ 64, 62 ], [ 64, 65 ] ]

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

[ [ 55, 2 ], [ 56, 19 ], [ 56, 26 ], [ 56, 33 ], [ 58, 41 ], [ 56, 44 ], [ 59, 49 ], [ 59, 52 ], [ 55, 56 ], [ 58, 59 ] ]

[ "#!/usr/bin/env python\n# coding: utf-8\n\n# In[12]:\n\n\nabc = list(map(int, input().split()))\n\n\n# In[13]:\n\n\nif abc[0]%2 == 0 or abc[1]%2 == 0 or abc[2]%2 == 0:\n print(0)\nelse:\n abc_s = sorted(abc)\n print(abc_s[0]*abc_s[1])\n\n\n# In[ ]:\n\n\n\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", "if abc[0]%2 == 0 or abc[1]%2 == 0 or abc[2]%2 == 0:\n print(0)\nelse:\n abc_s = sorted(abc)\n print(abc_s[0]*abc_s[1])\n\n\n# In[ ]:", "abc[0]%2 == 0 or abc[1]%2 == 0 or abc[2]%2 == 0", "abc[0]%2 == 0 or 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_s = sorted(abc)", "abc_s", "sorted(abc)", "sorted", "abc", "print(abc_s[0]*abc_s[1])", "print", "abc_s[0]*abc_s[1]", "abc_s[0]", "abc_s", "0", "abc_s[1]", "abc_s", "1", "abc = list(map(int, input().split()))", "list(map(int, input().split()))", "abc", "abc_s = sorted(abc)", "sorted(abc)", "abc_s" ]

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

[ [ 66, 2 ], [ 66, 11 ], [ 66, 12 ], [ 67, 18 ], [ 61, 19 ], [ 58, 20 ], [ 63, 27 ], [ 67, 30 ], [ 61, 31 ], [ 58, 32 ], [ 64, 35 ], [ 67, 36 ], [ 61, 40 ], [ 58, 41 ], [ 64, 44 ], [ 61, 45 ], [ 67, 49 ], [ 58, 50 ], [ 67, 54 ], [ 61, 55 ], [ 66, 58 ], [ 66, 61 ], [ 63, 64 ], [ 66, 67 ] ]

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

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

[ [ 61, 2 ], [ 61, 15 ], [ 61, 16 ], [ 59, 22 ], [ 56, 27 ], [ 62, 32 ], [ 64, 39 ], [ 59, 43 ], [ 56, 44 ], [ 56, 46 ], [ 62, 47 ], [ 62, 49 ], [ 59, 50 ], [ 65, 53 ], [ 61, 56 ], [ 61, 59 ], [ 61, 62 ], [ 64, 65 ] ]

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

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

[ [ 47, 2 ], [ 48, 15 ], [ 50, 18 ], [ 48, 19 ], [ 50, 20 ], [ 50, 21 ], [ 45, 27 ], [ 42, 28 ], [ 51, 29 ], [ 45, 38 ], [ 42, 39 ], [ 48, 41 ], [ 50, 42 ], [ 48, 44 ], [ 50, 45 ], [ 47, 48 ], [ 48, 50 ], [ 50, 51 ] ]

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

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

[ [ 69, 2 ], [ 69, 11 ], [ 69, 12 ], [ 66, 14 ], [ 58, 18 ], [ 61, 22 ], [ 70, 23 ], [ 63, 26 ], [ 61, 30 ], [ 58, 34 ], [ 70, 35 ], [ 72, 38 ], [ 70, 42 ], [ 58, 46 ], [ 61, 47 ], [ 67, 53 ], [ 64, 54 ], [ 73, 55 ], [ 69, 58 ], [ 69, 61 ], [ 63, 64 ], [ 66, 67 ], [ 69, 70 ], [ 72, 73 ] ]

[ "a, b, c = map(int, input().split())\n\nx = b * c if a % 2 == 1 else 0\ny = a * c if b % 2 == 1 else 0\nz = a * b if c % 2 == 1 else 0\nprint(min(x, y, z))", "a, b, c = map(int, input().split())", "a", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "c", "x = b * c if a % 2 == 1 else 0", "x", "b * c if a % 2 == 1 else 0", "a % 2 == 1", "a % 2", "a", "2", "1", "b * c", "b", "c", "0", "y = a * c if b % 2 == 1 else 0", "y", "a * c if b % 2 == 1 else 0", "b % 2 == 1", "b % 2", "b", "2", "1", "a * c", "a", "c", "0", "z = a * b if c % 2 == 1 else 0", "z", "a * b if c % 2 == 1 else 0", "c % 2 == 1", "c % 2", "c", "2", "1", "a * b", "a", "b", "0", "print(min(x, y, z))", "print", "min(x, y, z)", "min", "x", "y", "z", "a, b, c = map(int, input().split())", "map(int, input().split())", "a", "b, c = map(int, input().split())", "map(int, input().split())", "b", "y = a * c if b % 2 == 1 else 0", "a * c if b % 2 == 1 else 0", "y", "x = b * c if a % 2 == 1 else 0", "b * c if a % 2 == 1 else 0", "x", "c = map(int, input().split())", "map(int, input().split())", "c", "z = a * b if c % 2 == 1 else 0", "a * b if c % 2 == 1 else 0", "z" ]

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

[ [ 69, 2 ], [ 69, 11 ], [ 69, 12 ], [ 34, 18 ], [ 34, 26 ], [ 38, 31 ], [ 36, 32 ], [ 34, 34 ], [ 36, 36 ], [ 38, 38 ], [ 64, 45 ], [ 70, 46 ], [ 67, 47 ], [ 61, 48 ], [ 64, 50 ], [ 67, 51 ], [ 61, 52 ], [ 70, 53 ], [ 64, 55 ], [ 61, 56 ], [ 70, 57 ], [ 67, 58 ], [ 69, 61 ], [ 69, 67 ], [ 69, 70 ] ]

[ "A, B, C = map(int, input().split())\ndef diff(x,n, m):\n if x%2 == 0:\n return 0\n if x%2 == 1:\n return m*n\nprint(min([diff(A,B,C), diff(B,C,A), diff(C,A,B)]))", "A, B, C = map(int, input().split())", "A", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "B", "C", "def diff(x,n, m):\n if x%2 == 0:\n return 0\n if x%2 == 1:\n return m*n", "diff", "if x%2 == 0:\n return 0\n ", "x%2 == 0", "x%2", "x", "2", "0", "return 0", "0", "if x%2 == 1:\n return m*n", "x%2 == 1", "x%2", "x", "2", "1", "return m*n", "m*n", "m", "n", "x", "x", "n", "n", "m", "m", "print(min([diff(A,B,C), diff(B,C,A), diff(C,A,B)]))", "print", "min([diff(A,B,C), diff(B,C,A), diff(C,A,B)])", "min", "[diff(A,B,C), diff(B,C,A), diff(C,A,B)]", "diff(A,B,C)", "diff", "A", "B", "C", "diff(B,C,A)", "diff", "B", "C", "A", "diff(C,A,B)", "diff", "C", "A", "B", "C = map(int, input().split())", "map(int, input().split())", "C", "def diff(x,n, m):\n if x%2 == 0:\n return 0\n if x%2 == 1:\n return m*n", "def diff(x,n, m):\n if x%2 == 0:\n return 0\n if x%2 == 1:\n return m*n", "diff", "B, C = map(int, input().split())", "map(int, input().split())", "B", "A, B, C = map(int, input().split())", "map(int, input().split())", "A" ]

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

[ [ 57, 2 ], [ 57, 11 ], [ 57, 12 ], [ 63, 14 ], [ 52, 21 ], [ 55, 26 ], [ 58, 31 ], [ 60, 35 ], [ 52, 39 ], [ 55, 40 ], [ 52, 42 ], [ 58, 43 ], [ 55, 45 ], [ 58, 46 ], [ 61, 49 ], [ 64, 49 ], [ 57, 52 ], [ 57, 55 ], [ 57, 58 ], [ 60, 61 ], [ 63, 64 ] ]

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

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

[ [ 5, 4 ], [ 4, 13 ], [ 77, 15 ], [ 77, 17 ], [ 77, 18 ], [ 80, 20 ], [ 78, 23 ], [ 69, 24 ], [ 72, 25 ], [ 74, 27 ], [ 65, 35 ], [ 78, 38 ], [ 69, 39 ], [ 72, 40 ], [ 81, 46 ], [ 75, 47 ], [ 66, 51 ], [ 81, 55 ], [ 75, 56 ], [ 66, 58 ], [ 66, 62 ], [ 65, 66 ], [ 77, 69 ], [ 77, 72 ], [ 74, 75 ], [ 77, 78 ], [ 80, 81 ] ]

[ "from statistics import median\n\nA, B, C = [int(x) for x in input().split()]\n\nmin_num = min(A, B, C)\nmid_num = median([A, B, C])\nhigh_num = max(A, B, C)\n\nprint(min_num * mid_num * -(-high_num // 2) -\n min_num * mid_num * (high_num - -(-high_num // 2)))", "from statistics import median", "int(x) for x in input().split()", "for x in input().split()", "x", "input().split()", "().split", "()", "input", "split", "for x in input().split()", "int(x)", "int", "x", "A, B, C = [int(x) for x in input().split()]", "A", "[int(x) for x in input().split()]", "B", "C", "min_num = min(A, B, C)", "min_num", "min(A, B, C)", "min", "A", "B", "C", "mid_num = median([A, B, C])", "mid_num", "median([A, B, C])", "median", "[A, B, C]", "A", "B", "C", "high_num = max(A, B, C)", "high_num", "max(A, B, C)", "max", "A", "B", "C", "print(min_num * mid_num * -(-high_num // 2) -\n min_num * mid_num * (high_num - -(-high_num // 2)))", "print", "min_num * mid_num * -(-high_num // 2) -\n min_num * mid_num * (high_num - -(-high_num // 2))", "min_num * mid_num * -(-high_num // 2)", "min_num * mid_num", "min_num", "mid_num", "-(-high_num // 2)", "-high_num // 2", "-high_num", "high_num", "2", "min_num * mid_num * (high_num - -(-high_num // 2))", "min_num * mid_num", "min_num", "mid_num", "high_num - -(-high_num // 2)", "high_num", "-(-high_num // 2)", "-high_num // 2", "-high_num", "high_num", "2", "high_num = max(A, B, C)", "max(A, B, C)", "high_num", "B, C = [int(x) for x in input().split()]", "[int(x) for x in input().split()]", "B", "C = [int(x) for x in input().split()]", "[int(x) for x in input().split()]", "C", "mid_num = median([A, B, C])", "median([A, B, C])", "mid_num", "A, B, C = [int(x) for x in input().split()]", "[int(x) for x in input().split()]", "A", "min_num = min(A, B, C)", "min(A, B, C)", "min_num" ]

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

[ [ 62, 4 ], [ 68, 11 ], [ 63, 20 ], [ 69, 24 ], [ 71, 27 ], [ 69, 28 ], [ 71, 29 ], [ 71, 30 ], [ 65, 32 ], [ 54, 39 ], [ 57, 40 ], [ 72, 41 ], [ 59, 45 ], [ 54, 47 ], [ 57, 48 ], [ 60, 51 ], [ 66, 51 ], [ 69, 53 ], [ 71, 54 ], [ 69, 56 ], [ 71, 57 ], [ 59, 60 ], [ 62, 63 ], [ 65, 66 ], [ 68, 69 ], [ 69, 71 ], [ 71, 72 ] ]

[ "import sys\ninput = sys.stdin.readline\n\nL = list(map(int, input().split()))\nL.sort()\nA, B, C = L\n\nans = 0\nif (A * B * C) % 2 != 0:\n ans = A*B\nprint(ans)", "import sys", "sys", "input = sys.stdin.readline", "input", "sys.stdin.readline", "sys.stdin", "sys", "stdin", "readline", "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", "A, B, C = L", "A", "L", "B", "C", "ans = 0", "ans", "0", "if (A * B * C) % 2 != 0:\n ans = A*B", "(A * B * C) % 2 != 0", "(A * B * C) % 2", "A * B * C", "A * B", "A", "B", "C", "2", "0", "ans = A*B", "ans", "A*B", "A", "B", "print(ans)", "print", "ans", "A, B, C = L", "L", "A", "B, C = L", "L", "B", "ans = A*B", "A*B", "ans", "input = sys.stdin.readline", "sys.stdin.readline", "input", "ans = 0", "0", "ans", "L = list(map(int, input().split()))", "list(map(int, input().split()))", "L", "C = L", "L", "C" ]

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

[ [ 64, 2 ], [ 64, 11 ], [ 64, 12 ], [ 62, 18 ], [ 65, 23 ], [ 56, 28 ], [ 67, 37 ], [ 67, 44 ], [ 67, 45 ], [ 59, 49 ], [ 62, 49 ], [ 53, 50 ], [ 65, 50 ], [ 67, 53 ], [ 64, 56 ], [ 67, 59 ], [ 64, 62 ], [ 64, 65 ], [ 67, 68 ] ]

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

[ [ 76, 2 ], [ 77, 15 ], [ 77, 23 ], [ 77, 30 ], [ 77, 37 ], [ 73, 42 ], [ 77, 47 ], [ 77, 50 ], [ 77, 54 ], [ 77, 57 ], [ 77, 61 ], [ 77, 64 ], [ 74, 68 ], [ 73, 74 ], [ 76, 77 ] ]

[ "ll = list(map(int, input().split()))\nll.sort()\nif ll[0]%2 == 1 and ll[1]%2 == 1 and ll[2] %2 == 1:\n v = min(ll[0]*ll[1],ll[1]*ll[2],ll[2]*ll[0])\n print(v)\nelse:\n print(0) ", "ll = list(map(int, input().split()))", "ll", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "ll.sort()", "ll.sort", "ll", "sort", "if ll[0]%2 == 1 and ll[1]%2 == 1 and ll[2] %2 == 1:\n v = min(ll[0]*ll[1],ll[1]*ll[2],ll[2]*ll[0])\n print(v)\nelse:\n print(0) ", "ll[0]%2 == 1 and ll[1]%2 == 1 and ll[2] %2 == 1", "ll[0]%2 == 1 and ll[1]%2 == 1", "ll[0]%2 == 1", "ll[0]%2", "ll[0]", "ll", "0", "2", "1", "ll[1]%2 == 1", "ll[1]%2", "ll[1]", "ll", "1", "2", "1", "ll[2] %2 == 1", "ll[2] %2", "ll[2]", "ll", "2", "2", "1", "v = min(ll[0]*ll[1],ll[1]*ll[2],ll[2]*ll[0])", "v", "min(ll[0]*ll[1],ll[1]*ll[2],ll[2]*ll[0])", "min", "ll[0]*ll[1]", "ll[0]", "ll", "0", "ll[1]", "ll", "1", "ll[1]*ll[2]", "ll[1]", "ll", "1", "ll[2]", "ll", "2", "ll[2]*ll[0]", "ll[2]", "ll", "2", "ll[0]", "ll", "0", "print(v)", "print", "v", "print(0)", "print", "0", "v = min(ll[0]*ll[1],ll[1]*ll[2],ll[2]*ll[0])", "min(ll[0]*ll[1],ll[1]*ll[2],ll[2]*ll[0])", "v", "ll = list(map(int, input().split()))", "list(map(int, input().split()))", "ll" ]

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

[ [ 64, 2 ], [ 64, 11 ], [ 64, 12 ], [ 67, 14 ], [ 62, 21 ], [ 65, 26 ], [ 59, 31 ], [ 55, 35 ], [ 70, 38 ], [ 62, 43 ], [ 65, 44 ], [ 65, 46 ], [ 59, 47 ], [ 59, 49 ], [ 62, 50 ], [ 71, 53 ], [ 56, 53 ], [ 68, 53 ], [ 55, 56 ], [ 64, 59 ], [ 64, 62 ], [ 64, 65 ], [ 67, 68 ], [ 70, 71 ] ]

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

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

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

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

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

[ [ 4, 3 ], [ 3, 13 ], [ 63, 15 ], [ 60, 27 ], [ 64, 31 ], [ 64, 34 ], [ 64, 38 ], [ 64, 41 ], [ 64, 45 ], [ 64, 48 ], [ 61, 52 ], [ 64, 52 ], [ 61, 57 ], [ 64, 57 ], [ 60, 61 ], [ 63, 64 ] ]

[ "BOX = [int(j) for j in input().split(' ')]\nif len([j for j in BOX if j % 2 == 0]) > 0:\n print(0)\nelse:\n BOX = [BOX[0] * BOX[1],BOX[1]*BOX[2],BOX[0]*BOX[2]]\n BOX.sort()\n print(BOX[0])", "int(j) for j in input().split(' ')", "for j in input().split(' ')", "j", "input().split(' ')", "().split", "()", "input", "split", "' '", "for j in input().split(' ')", "int(j)", "int", "j", "BOX = [int(j) for j in input().split(' ')]", "BOX", "[int(j) for j in input().split(' ')]", "if len([j for j in BOX if j % 2 == 0]) > 0:\n print(0)\nelse:\n BOX = [BOX[0] * BOX[1],BOX[1]*BOX[2],BOX[0]*BOX[2]]\n BOX.sort()\n print(BOX[0])", "len([j for j in BOX if j % 2 == 0]) > 0", "len([j for j in BOX if j % 2 == 0])", "len", "[j for j in BOX if j % 2 == 0]", "0", "print(0)", "print", "0", "BOX = [BOX[0] * BOX[1],BOX[1]*BOX[2],BOX[0]*BOX[2]]", "BOX", "[BOX[0] * BOX[1],BOX[1]*BOX[2],BOX[0]*BOX[2]]", "BOX[0] * BOX[1]", "BOX[0]", "BOX", "0", "BOX[1]", "BOX", "1", "BOX[1]*BOX[2]", "BOX[1]", "BOX", "1", "BOX[2]", "BOX", "2", "BOX[0]*BOX[2]", "BOX[0]", "BOX", "0", "BOX[2]", "BOX", "2", "BOX.sort()", "BOX.sort", "BOX", "sort", "print(BOX[0])", "print", "BOX[0]", "BOX", "0", "BOX = [BOX[0] * BOX[1],BOX[1]*BOX[2],BOX[0]*BOX[2]]", "[BOX[0] * BOX[1],BOX[1]*BOX[2],BOX[0]*BOX[2]]", "BOX", "BOX = [int(j) for j in input().split(' ')]", "[int(j) for j in input().split(' ')]", "BOX" ]

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

[ [ 45, 2 ], [ 15, 14 ], [ 46, 22 ], [ 14, 23 ], [ 46, 33 ], [ 46, 39 ], [ 46, 42 ], [ 45, 46 ] ]

[ "abc = list(map(int, input().split()))\nfor i in range(3):\n if abc[i] % 2 == 0:\n print(0)\n exit()\nabc.sort()\nprint(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", "for i in range(3):\n if abc[i] % 2 == 0:\n print(0)\n exit()", "i", "range(3)", "range", "3", "if abc[i] % 2 == 0:\n print(0)\n exit()", "abc[i] % 2 == 0", "abc[i] % 2", "abc[i]", "abc", "i", "2", "0", "print(0)", "print", "0", "exit()", "exit", "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, 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, 2, 13, 13, 2, 13, 13, 2, 13, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 46, 2 ], [ 46, 11 ], [ 46, 12 ], [ 44, 18 ], [ 41, 19 ], [ 47, 20 ], [ 44, 31 ], [ 41, 32 ], [ 41, 34 ], [ 47, 35 ], [ 47, 37 ], [ 44, 38 ], [ 46, 41 ], [ 46, 44 ], [ 46, 47 ] ]

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

[ [ 39, 2 ], [ 42, 14 ], [ 40, 17 ], [ 43, 21 ], [ 40, 29 ], [ 40, 33 ], [ 39, 40 ], [ 42, 43 ] ]

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

[ 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 ], [ 52, 18 ], [ 49, 23 ], [ 55, 28 ], [ 52, 39 ], [ 49, 40 ], [ 49, 42 ], [ 55, 43 ], [ 55, 45 ], [ 52, 46 ], [ 54, 49 ], [ 54, 52 ], [ 54, 55 ] ]

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

[ [ 25, 24 ], [ 136, 30 ], [ 34, 34 ], [ 141, 43 ], [ 138, 48 ], [ 153, 55 ], [ 136, 57 ], [ 153, 58 ], [ 153, 59 ], [ 151, 65 ], [ 130, 70 ], [ 154, 75 ], [ 165, 84 ], [ 144, 92 ], [ 166, 96 ], [ 166, 99 ], [ 166, 103 ], [ 156, 107 ], [ 166, 111 ], [ 166, 114 ], [ 166, 120 ], [ 157, 126 ], [ 145, 127 ], [ 153, 130 ], [ 138, 139 ], [ 141, 142 ], [ 144, 145 ], [ 153, 151 ], [ 153, 154 ], [ 156, 157 ], [ 165, 166 ] ]

[ "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()\nif A%2==0 or B%2==0 or C%2==0:\n\tprint(0)\n\texit()\n\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", "if A%2==0 or B%2==0 or C%2==0:\n\tprint(0)\n\texit()", "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", "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", "B, C = MAP()", "MAP()", "B", "def input(): return sys.stdin.readline().strip()", "def input(): return sys.stdin.readline().strip()", "input", "def MAP(): return map(int, input().split())", "def MAP(): return map(int, input().split())", "MAP", "mod = 10 ** 9 + 7", "10 ** 9 + 7", "mod", "INF = float('inf')", "float('inf')", "INF", "rV = l[0]*l[1]*(l[2]//2)", "l[0]*l[1]*(l[2]//2)", "rV", "def ZIP(n): return zip(*(MAP() for _ in range(n)))", "def ZIP(n): return zip(*(MAP() for _ in range(n)))", "ZIP", "A, B, C = MAP()", "MAP()", "A", "C = MAP()", "MAP()", "C", "bV = l[0]*l[1]*(-(-l[2]//2))", "l[0]*l[1]*(-(-l[2]//2))", "bV", "def INT(): return int(input())", "def INT(): return int(input())", "INT", "def LIST(): return list(map(int, input().split()))", "def LIST(): return list(map(int, input().split()))", "LIST", "l = sorted([A, B, C])", "sorted([A, B, C])", "l" ]

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

[ [ 56, 2 ], [ 59, 14 ], [ 18, 17 ], [ 57, 25 ], [ 17, 26 ], [ 53, 30 ], [ 54, 34 ], [ 60, 34 ], [ 57, 38 ], [ 57, 44 ], [ 57, 47 ], [ 53, 54 ], [ 56, 57 ], [ 59, 60 ] ]

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

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

[ [ 53, 2 ], [ 54, 15 ], [ 50, 18 ], [ 54, 21 ], [ 54, 30 ], [ 54, 33 ], [ 54, 37 ], [ 51, 39 ], [ 54, 43 ], [ 54, 46 ], [ 51, 48 ], [ 50, 51 ], [ 53, 54 ] ]

[ "ABC=list(map(int,input().split()))\nABC.sort()\ntemp=ABC[2]//2\nprint(ABC[0]*ABC[1]*(ABC[2]-temp)-ABC[0]*ABC[1]*temp)", "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", "temp=ABC[2]//2", "temp", "ABC[2]//2", "ABC[2]", "ABC", "2", "2", "print(ABC[0]*ABC[1]*(ABC[2]-temp)-ABC[0]*ABC[1]*temp)", "print", "ABC[0]*ABC[1]*(ABC[2]-temp)-ABC[0]*ABC[1]*temp", "ABC[0]*ABC[1]*(ABC[2]-temp)", "ABC[0]*ABC[1]", "ABC[0]", "ABC", "0", "ABC[1]", "ABC", "1", "ABC[2]-temp", "ABC[2]", "ABC", "2", "temp", "ABC[0]*ABC[1]*temp", "ABC[0]*ABC[1]", "ABC[0]", "ABC", "0", "ABC[1]", "ABC", "1", "temp", "temp=ABC[2]//2", "ABC[2]//2", "temp", "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, 4, 13, 4, 13, 39, 2, 2, 2, 13, 17, 13, 13, 2, 2, 13, 2, 13, 17, 13, 2, 2, 13, 13, 2, 13, 17, 10, 4, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 46, 2 ], [ 46, 11 ], [ 46, 12 ], [ 41, 21 ], [ 47, 23 ], [ 44, 24 ], [ 41, 27 ], [ 47, 29 ], [ 44, 31 ], [ 41, 34 ], [ 47, 35 ], [ 44, 37 ], [ 46, 41 ], [ 46, 44 ], [ 46, 47 ] ]

[ "A, B, C = map(int, input().split())\nprint(min([(A%2)*B*C,A*(B%2)*C,A*B*(C%2)]))", "A, B, C = map(int, input().split())", "A", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "B", "C", "print(min([(A%2)*B*C,A*(B%2)*C,A*B*(C%2)]))", "print", "min([(A%2)*B*C,A*(B%2)*C,A*B*(C%2)])", "min", "[(A%2)*B*C,A*(B%2)*C,A*B*(C%2)]", "(A%2)*B*C", "(A%2)*B", "A%2", "A", "2", "B", "C", "A*(B%2)*C", "A*(B%2)", "A", "B%2", "B", "2", "C", "A*B*(C%2)", "A*B", "A", "B", "C%2", "C", "2", "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, 15, 13, 0, 13, 18, 18, 18, 13, 13, 13, 13, 12, 13, 12, 13, 12, 13, 12, 13, 12, 13, 12, 13, 12, 13, 12, 13, 12, 13, 0, 13, 4, 13, 4, 18, 13, 13, 0, 13, 17, 14, 2, 2, 2, 18, 13, 17, 17, 2, 18, 13, 17, 17, 2, 18, 13, 17, 17, 0, 13, 2, 18, 13, 17, 18, 13, 17, 4, 13, 13, 14, 2, 13, 17, 4, 13, 10, 12, 13, 10, 12, 13, 10, 12, 13, 10, 18, 13, 10, 12, 13, 10, 12, 13, 10, 12, 13, 10, 12, 13, 10, 12, 13, 10, 12, 13 ]

[ [ 87, 4 ], [ 32, 31 ], [ 97, 33 ], [ 31, 36 ], [ 40, 39 ], [ 31, 46 ], [ 31, 51 ], [ 31, 56 ], [ 61, 60 ], [ 31, 63 ], [ 31, 66 ], [ 60, 70 ], [ 39, 70 ], [ 103, 76 ], [ 87, 88 ] ]

[ "import sys\ninput = sys.stdin.buffer.readline\n\n#sys.setrecursionlimit(10**9)\n#from functools import lru_cache\n\ndef RD(): return input().rstrip().decode()\ndef II(): return int(input())\ndef FI(): return int(input())\ndef MI(): return map(int,input().split())\ndef MF(): return map(float,input().split())\ndef LI(): return list(map(int,input().split()))\ndef LF(): return list(map(float,input().split()))\ndef TI(): return tuple(map(int,input().split()))\n# rstrip().decode()\n\n\n\ndef main():\n\tA=LI()\n\tA.sort()\n\tans=0\n\n\tif A[0]%2 and A[1]%2 and A[2]%2:\n\t\tans=A[0]*A[1]\n\n\tprint(ans)\n\n\n\n\nif __name__ == \"__main__\":\n\tmain()", "import sys", "sys", "input = sys.stdin.buffer.readline", "input", "sys.stdin.buffer.readline", "sys.stdin.buffer", "sys.stdin", "sys", "stdin", "buffer", "readline", "def RD(): return input().rstrip().decode()", "RD", "def II(): return int(input())", "II", "def FI(): return int(input())", "FI", "def MI(): return map(int,input().split())", "MI", "def MF(): return map(float,input().split())", "MF", "def LI(): return list(map(int,input().split()))", "LI", "def LF(): return list(map(float,input().split()))", "LF", "def TI(): return tuple(map(int,input().split()))\n# rstrip().decode()", "TI", "def main():\n\tA=LI()\n\tA.sort()\n\tans=0\n\n\tif A[0]%2 and A[1]%2 and A[2]%2:\n\t\tans=A[0]*A[1]\n\n\tprint(ans)", "main", "A=LI()", "A", "LI()", "LI", "A.sort()", "A.sort", "A", "sort", "ans=0", "ans", "0", "if A[0]%2 and A[1]%2 and A[2]%2:\n\t\tans=A[0]*A[1]\n\n\t", "A[0]%2 and A[1]%2 and A[2]%2", "A[0]%2 and 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", "ans=A[0]*A[1]", "ans", "A[0]*A[1]", "A[0]", "A", "0", "A[1]", "A", "1", "print(ans)", "print", "ans", "if __name__ == \"__main__\":\n\tmain()", "__name__ == \"__main__\"", "__name__", "\"__main__\"", "main()", "main", "def MF(): return map(float,input().split())", "def MF(): return map(float,input().split())", "MF", "def LF(): return list(map(float,input().split()))", "def LF(): return list(map(float,input().split()))", "LF", "def FI(): return int(input())", "def FI(): return int(input())", "FI", "input = sys.stdin.buffer.readline", "sys.stdin.buffer.readline", "input", "def MI(): return map(int,input().split())", "def MI(): return map(int,input().split())", "MI", "def TI(): return tuple(map(int,input().split()))\n# rstrip().decode()", "def TI(): return tuple(map(int,input().split()))\n# rstrip().decode()", "TI", "def LI(): return list(map(int,input().split()))", "def LI(): return list(map(int,input().split()))", "LI", "def II(): return int(input())", "def II(): return int(input())", "II", "def main():\n\tA=LI()\n\tA.sort()\n\tans=0\n\n\tif A[0]%2 and A[1]%2 and A[2]%2:\n\t\tans=A[0]*A[1]\n\n\tprint(ans)", "def main():\n\tA=LI()\n\tA.sort()\n\tans=0\n\n\tif A[0]%2 and A[1]%2 and A[2]%2:\n\t\tans=A[0]*A[1]\n\n\tprint(ans)", "main", "def RD(): return input().rstrip().decode()", "def RD(): return input().rstrip().decode()", "RD" ]

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

[ [ 76, 2 ], [ 76, 11 ], [ 76, 12 ], [ 67, 14 ], [ 67, 21 ], [ 67, 22 ], [ 68, 26 ], [ 77, 26 ], [ 82, 33 ], [ 68, 35 ], [ 77, 35 ], [ 79, 37 ], [ 68, 40 ], [ 77, 40 ], [ 70, 44 ], [ 65, 46 ], [ 74, 46 ], [ 62, 47 ], [ 59, 47 ], [ 83, 54 ], [ 80, 55 ], [ 71, 56 ], [ 76, 59 ], [ 67, 62 ], [ 67, 65 ], [ 67, 68 ], [ 70, 71 ], [ 76, 74 ], [ 76, 77 ], [ 79, 80 ], [ 82, 83 ] ]

[ "A, B, C = map(int, input().split())\nA, B, C = sorted([A, B, C])\n\nif C % 2 == 0:\n print(0)\nelse:\n d1, d2 = C // 2, (C // 2) + 1\n e = A * B\n print(abs(d1 - d2) * e)", "A, B, C = map(int, input().split())", "A", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "B", "C", "A, B, C = sorted([A, B, C])", "A", "sorted([A, B, C])", "sorted", "[A, B, C]", "A", "B", "C", "B", "C", "if C % 2 == 0:\n print(0)\nelse:\n d1, d2 = C // 2, (C // 2) + 1\n e = A * B\n print(abs(d1 - d2) * e)", "C % 2 == 0", "C % 2", "C", "2", "0", "print(0)", "print", "0", "d1, d2 = C // 2, (C // 2) + 1", "d1", "C // 2", "C", "2", "d2", "(C // 2) + 1", "C // 2", "C", "2", "1", "e = A * B", "e", "A * B", "A", "B", "print(abs(d1 - d2) * e)", "print", "abs(d1 - d2) * e", "abs(d1 - d2)", "abs", "d1 - d2", "d1", "d2", "e", "B, C = map(int, input().split())", "map(int, input().split())", "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 = sorted([A, B, C])", "sorted([A, B, C])", "C", "e = A * B", "A * B", "e", "A, B, C = map(int, input().split())", "map(int, input().split())", "A", "C = map(int, input().split())", "map(int, input().split())", "C", "d2 = C // 2, (C // 2) + 1", "(C // 2) + 1", "d2", "d1, d2 = C // 2, (C // 2) + 1", "C // 2", "d1" ]

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

[ [ 80, 4 ], [ 89, 9 ], [ 86, 21 ], [ 36, 35 ], [ 87, 42 ], [ 36, 44 ], [ 36, 45 ], [ 35, 51 ], [ 44, 55 ], [ 45, 59 ], [ 35, 69 ], [ 44, 70 ], [ 44, 72 ], [ 45, 73 ], [ 45, 75 ], [ 35, 76 ], [ 84, 78 ], [ 80, 81 ], [ 86, 87 ], [ 89, 90 ] ]

[ "import sys\nINF = 1 << 60\nMOD = 10**9 + 7 # 998244353\nsys.setrecursionlimit(2147483647)\ninput = lambda:sys.stdin.readline().rstrip()\ndef resolve():\n a, b, c = map(int, input().split())\n if ~a&1 or ~b&1 or ~c&1:\n print(0)\n else:\n print(min(a * b, b * c, c * a))\nresolve()", "import sys", "sys", "INF = 1 << 60", "INF", "1 << 60", "1", "60", "MOD = 10**9 + 7", "MOD", "10**9 + 7", "10**9", "10", "9", "7", "sys.setrecursionlimit(2147483647)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "2147483647", "input = lambda:sys.stdin.readline().rstrip()", "input", "lambda:sys.stdin.readline().rstrip()", "sys.stdin.readline().rstrip()", "sys.stdin.readline().rstrip", "sys.stdin.readline()", "sys.stdin.readline", "sys.stdin", "sys", "stdin", "readline", "rstrip", "def resolve():\n a, b, c = map(int, input().split())\n if ~a&1 or ~b&1 or ~c&1:\n print(0)\n else:\n print(min(a * b, b * c, c * a))", "resolve", "a, b, c = map(int, input().split())", "a", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "c", "if ~a&1 or ~b&1 or ~c&1:\n print(0)\n else:\n print(min(a * b, b * c, c * a))", "~a&1 or ~b&1 or ~c&1", "~a&1 or ~b&1", "~a&1", "~a", "a", "1", "~b&1", "~b", "b", "1", "~c&1", "~c", "c", "1", "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", "resolve()", "resolve", "INF = 1 << 60", "1 << 60", "INF", "def resolve():\n a, b, c = map(int, input().split())\n if ~a&1 or ~b&1 or ~c&1:\n print(0)\n else:\n print(min(a * b, b * c, c * a))", "def resolve():\n a, b, c = map(int, input().split())\n if ~a&1 or ~b&1 or ~c&1:\n print(0)\n else:\n print(min(a * b, b * c, c * a))", "resolve", "input = lambda:sys.stdin.readline().rstrip()", "lambda:sys.stdin.readline().rstrip()", "input", "MOD = 10**9 + 7", "10**9 + 7", "MOD" ]

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

[ [ 7, 6 ], [ 19, 18 ], [ 6, 18 ], [ 18, 23 ], [ 32, 31 ], [ 37, 36 ], [ 6, 41 ], [ 45, 44 ], [ 48, 47 ], [ 36, 47 ], [ 51, 50 ], [ 47, 51 ], [ 54, 53 ], [ 31, 56 ], [ 53, 56 ], [ 50, 57 ], [ 44, 57 ], [ 53, 60 ], [ 31, 60 ], [ 69, 66 ] ]

[ "import itertools\ndef main():\n a=list(map(int,input().split()))\n for i in a:\n if i%2==0:\n print(0)\n return\n ans = float(\"inf\")\n for x in itertools.combinations(a, 2):\n d = 1\n for y in x:\n d *= y\n ans = min(ans, d)\n print(ans)\n \nif __name__ == \"__main__\":\n main()", "import itertools", "itertools", "def main():\n a=list(map(int,input().split()))\n for i in a:\n if i%2==0:\n print(0)\n return\n ans = float(\"inf\")\n for x in itertools.combinations(a, 2):\n d = 1\n for y in x:\n d *= y\n ans = min(ans, d)\n print(ans)\n ", "main", "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 a:\n if i%2==0:\n print(0)\n return\n ", "i", "a", "if i%2==0:\n print(0)\n return\n ", "i%2==0", "i%2", "i", "2", "0", "print(0)", "print", "0", "return", "ans = float(\"inf\")", "ans", "float(\"inf\")", "float", "\"inf\"", "for x in itertools.combinations(a, 2):\n d = 1\n for y in x:\n d *= y\n ans = min(ans, d)\n ", "x", "itertools.combinations(a, 2)", "itertools.combinations", "itertools", "combinations", "a", "2", "d = 1", "d", "1", "for y in x:\n d *= y\n ", "y", "x", "d *= y", "d", "y", "ans = min(ans, d)", "ans", "min(ans, d)", "min", "ans", "d", "print(ans)", "print", "ans", "if __name__ == \"__main__\":\n main()", "__name__ == \"__main__\"", "__name__", "\"__main__\"", "main()", "main", "def main():\n a=list(map(int,input().split()))\n for i in a:\n if i%2==0:\n print(0)\n return\n ans = float(\"inf\")\n for x in itertools.combinations(a, 2):\n d = 1\n for y in x:\n d *= y\n ans = min(ans, d)\n print(ans)\n ", "def main():\n a=list(map(int,input().split()))\n for i in a:\n if i%2==0:\n print(0)\n return\n ans = float(\"inf\")\n for x in itertools.combinations(a, 2):\n d = 1\n for y in x:\n d *= y\n ans = min(ans, d)\n print(ans)\n ", "main" ]

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

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

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

[ 7, 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 ] ]

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

[ [ 68, 2 ], [ 68, 11 ], [ 68, 12 ], [ 69, 18 ], [ 63, 23 ], [ 66, 28 ], [ 69, 37 ], [ 63, 38 ], [ 69, 40 ], [ 66, 41 ], [ 63, 45 ], [ 66, 46 ], [ 63, 49 ], [ 66, 50 ], [ 69, 54 ], [ 66, 55 ], [ 69, 59 ], [ 63, 60 ], [ 68, 63 ], [ 68, 66 ], [ 68, 69 ] ]

[ "A, B, C = map(int, input().split())\n\nif A % 2 == 0 or B % 2 == 0 or C % 2 == 0:\n print(0)\n\nelse:\n if A >= B and A >= C:\n print(B * C)\n\n elif B >= C:\n print(A * C)\n\n else:\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 % 2 == 0 or B % 2 == 0 or C % 2 == 0:\n print(0)\n\nelse:\n if A >= B and A >= C:\n print(B * C)\n\n elif B >= C:\n print(A * C)\n\n else:\n print(A * B)", "A % 2 == 0 or B % 2 == 0 or C % 2 == 0", "A % 2 == 0 or B % 2 == 0", "A % 2 == 0", "A % 2", "A", "2", "0", "B % 2 == 0", "B % 2", "B", "2", "0", "C % 2 == 0", "C % 2", "C", "2", "0", "print(0)", "print", "0", "if A >= B and A >= C:\n print(B * C)\n\n elif B >= C:\n print(A * C)\n\n else:\n print(A * B)", "A >= B and A >= C", "A >= B", "A", "B", "A >= C", "A", "C", "print(B * C)", "print", "B * C", "B", "C", "elif B >= C:\n print(A * C)\n\n ", "B >= C", "B", "C", "print(A * C)", "print", "A * C", "A", "C", "print(A * B)", "print", "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, 41, 28, 13, 4, 18, 4, 13, 13, 4, 4, 13, 13, 0, 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, 13, 13, 10, 13, 13, 10, 13, 13 ]

[ [ 4, 3 ], [ 3, 12 ], [ 49, 14 ], [ 49, 16 ], [ 49, 17 ], [ 44, 25 ], [ 50, 26 ], [ 47, 27 ], [ 44, 34 ], [ 50, 35 ], [ 50, 37 ], [ 47, 38 ], [ 47, 40 ], [ 44, 41 ], [ 49, 44 ], [ 49, 47 ], [ 49, 50 ] ]

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

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

[ [ 47, 2 ], [ 48, 15 ], [ 44, 18 ], [ 48, 22 ], [ 48, 25 ], [ 48, 31 ], [ 48, 34 ], [ 48, 37 ], [ 45, 42 ], [ 44, 45 ], [ 47, 48 ] ]

[ "ABC = list(map(int, input().split()))\n\nABC.sort()\n\nans = ABC[0] * ABC[1] * ((ABC[1] * ABC[1] * ABC[2]) % 2)\n\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", "ABC.sort()", "ABC.sort", "ABC", "sort", "ans = ABC[0] * ABC[1] * ((ABC[1] * ABC[1] * ABC[2]) % 2)", "ans", "ABC[0] * ABC[1] * ((ABC[1] * ABC[1] * ABC[2]) % 2)", "ABC[0] * ABC[1]", "ABC[0]", "ABC", "0", "ABC[1]", "ABC", "1", "(ABC[1] * ABC[1] * ABC[2]) % 2", "ABC[1] * ABC[1] * ABC[2]", "ABC[1] * ABC[1]", "ABC[1]", "ABC", "1", "ABC[1]", "ABC", "1", "ABC[2]", "ABC", "2", "2", "print(ans)", "print", "ans", "ans = ABC[0] * ABC[1] * ((ABC[1] * ABC[1] * ABC[2]) % 2)", "ABC[0] * ABC[1] * ((ABC[1] * ABC[1] * ABC[2]) % 2)", "ans", "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, 12, 13, 14, 2, 2, 13, 17, 17, 29, 17, 29, 2, 13, 13, 23, 13, 23, 13, 23, 13, 4, 13, 4, 13, 4, 13, 13, 13, 13, 4, 13, 13, 13, 13, 4, 13, 13, 13, 13, 10, 12, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 62, 2 ], [ 62, 11 ], [ 62, 12 ], [ 28, 18 ], [ 30, 25 ], [ 32, 26 ], [ 28, 28 ], [ 30, 30 ], [ 32, 32 ], [ 54, 38 ], [ 57, 39 ], [ 63, 40 ], [ 60, 41 ], [ 54, 43 ], [ 63, 44 ], [ 60, 45 ], [ 57, 46 ], [ 54, 48 ], [ 60, 49 ], [ 57, 50 ], [ 63, 51 ], [ 62, 57 ], [ 62, 60 ], [ 62, 63 ] ]

[ "A, B, C = map(int, input().split())\ndef f(x, y, z):\n if x % 2 == 0:\n return 0\n else:\n return y * z\nprint(min(f(A, B, C), f(B, C, A), f(C, A, B)))", "A, B, C = map(int, input().split())", "A", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "B", "C", "def f(x, y, z):\n if x % 2 == 0:\n return 0\n else:\n return y * z", "f", "if x % 2 == 0:\n return 0\n else:\n return y * z", "x % 2 == 0", "x % 2", "x", "2", "0", "return 0", "0", "return y * z", "y * z", "y", "z", "x", "x", "y", "y", "z", "z", "print(min(f(A, B, C), f(B, C, A), f(C, A, B)))", "print", "min(f(A, B, C), f(B, C, A), f(C, A, B))", "min", "f(A, B, C)", "f", "A", "B", "C", "f(B, C, A)", "f", "B", "C", "A", "f(C, A, B)", "f", "C", "A", "B", "def f(x, y, z):\n if x % 2 == 0:\n return 0\n else:\n return y * z", "def f(x, y, z):\n if x % 2 == 0:\n return 0\n else:\n return y * z", "f", "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, 0, 13, 18, 13, 17, 0, 13, 18, 13, 17, 0, 13, 18, 13, 17, 14, 2, 2, 2, 2, 13, 17, 17, 2, 2, 13, 17, 17, 2, 2, 13, 17, 17, 4, 13, 17, 4, 13, 17, 0, 13, 17, 13, 17, 0, 13, 2, 2, 13, 13, 13, 0, 13, 2, 2, 2, 13, 17, 13, 13, 0, 13, 2, 13, 13, 4, 13, 2, 13, 13, 10, 2, 13, 10, 2, 13, 10, 4, 13, 10, 18, 13, 10, 18, 13, 10, 18, 13, 10, 17, 13, 10, 17, 13, 10, 2, 13 ]

[ [ 94, 2 ], [ 95, 15 ], [ 100, 18 ], [ 95, 20 ], [ 97, 23 ], [ 95, 25 ], [ 103, 28 ], [ 95, 30 ], [ 101, 37 ], [ 98, 42 ], [ 104, 47 ], [ 106, 57 ], [ 109, 59 ], [ 88, 62 ], [ 101, 65 ], [ 98, 66 ], [ 104, 67 ], [ 91, 69 ], [ 104, 73 ], [ 101, 75 ], [ 98, 76 ], [ 112, 78 ], [ 89, 80 ], [ 92, 81 ], [ 110, 81 ], [ 113, 85 ], [ 107, 85 ], [ 92, 86 ], [ 110, 86 ], [ 88, 89 ], [ 91, 92 ], [ 94, 95 ], [ 97, 98 ], [ 100, 101 ], [ 103, 104 ], [ 106, 107 ], [ 109, 110 ], [ 112, 113 ] ]

[ "l = list(map(int,input().split()))\nl.sort()\na = l[0]\nb = l[1]\nc = l[2]\nif a%2 == 0 or b%2 == 0 or c%2 == 0:\n print(0)\n exit(0)\nvmax,vmin = 0,0\nv = a*b*c\nvmin = (c//2)*a*b\nvmax = v - vmin\nprint(vmax-vmin)\n", "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", "a = l[0]", "a", "l[0]", "l", "0", "b = l[1]", "b", "l[1]", "l", "1", "c = l[2]", "c", "l[2]", "l", "2", "if a%2 == 0 or b%2 == 0 or c%2 == 0:\n print(0)\n exit(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", "exit(0)", "exit", "0", "vmax,vmin = 0,0", "vmax", "0", "vmin", "0", "v = a*b*c", "v", "a*b*c", "a*b", "a", "b", "c", "vmin = (c//2)*a*b", "vmin", "(c//2)*a*b", "(c//2)*a", "c//2", "c", "2", "a", "b", "vmax = v - vmin", "vmax", "v - vmin", "v", "vmin", "print(vmax-vmin)", "print", "vmax-vmin", "vmax", "vmin", "v = a*b*c", "a*b*c", "v", "vmin = (c//2)*a*b", "(c//2)*a*b", "vmin", "l = list(map(int,input().split()))", "list(map(int,input().split()))", "l", "b = l[1]", "l[1]", "b", "a = l[0]", "l[0]", "a", "c = l[2]", "l[2]", "c", "vmax,vmin = 0,0", "0", "vmax", "vmin = 0,0", "0", "vmin", "vmax = v - vmin", "v - vmin", "vmax" ]

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

[ [ 66, 2 ], [ 66, 11 ], [ 66, 12 ], [ 63, 14 ], [ 67, 20 ], [ 61, 22 ], [ 58, 23 ], [ 67, 31 ], [ 61, 36 ], [ 58, 41 ], [ 67, 47 ], [ 61, 48 ], [ 61, 50 ], [ 58, 51 ], [ 58, 53 ], [ 67, 54 ], [ 66, 58 ], [ 66, 61 ], [ 63, 64 ], [ 66, 67 ] ]

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

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

[ [ 13, 10 ], [ 13, 13 ], [ 17, 16 ], [ 16, 30 ], [ 82, 32 ], [ 82, 34 ], [ 82, 35 ], [ 83, 41 ], [ 77, 46 ], [ 74, 51 ], [ 80, 67 ], [ 82, 74 ], [ 82, 77 ], [ 82, 83 ] ]

[ "from sys import stdin\nfrom heapq import nsmallest\n\ndef second_smallest(numbers):\n return nsmallest(2, numbers)[-1]\n\na,b,c = [int(x) for x in stdin.readline().strip().split()]\n\nif a%2==0 or b%2==0 or c%2==0:\n print(0)\nelse:\n print(min([a,b,c]) * second_smallest([a,b,c]))", "from sys import stdin", "from heapq import nsmallest", "def second_smallest(numbers):\n return nsmallest(2, numbers)[-1]", "second_smallest", "return nsmallest(2, numbers)[-1]", "nsmallest(2, numbers)[-1]", "(2, numbers)", "nsmallest", "2", "numbers", "-1", "numbers", "numbers", "int(x) for x in stdin.readline().strip().split()", "for x in stdin.readline().strip().split()", "x", "stdin.readline().strip().split()", "stdin.readline().strip().split", "stdin.readline().strip()", "stdin.readline().strip", "stdin.readline()", "stdin.readline", "stdin", "readline", "strip", "split", "for x in stdin.readline().strip().split()", "int(x)", "int", "x", "a,b,c = [int(x) for x in stdin.readline().strip().split()]", "a", "[int(x) for x in stdin.readline().strip().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]) * second_smallest([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]) * second_smallest([a,b,c]))", "print", "min([a,b,c]) * second_smallest([a,b,c])", "min([a,b,c])", "min", "[a,b,c]", "a", "b", "c", "second_smallest([a,b,c])", "second_smallest", "[a,b,c]", "a", "b", "c", "c = [int(x) for x in stdin.readline().strip().split()]", "[int(x) for x in stdin.readline().strip().split()]", "c", "b,c = [int(x) for x in stdin.readline().strip().split()]", "[int(x) for x in stdin.readline().strip().split()]", "b", "def second_smallest(numbers):\n return nsmallest(2, numbers)[-1]", "def second_smallest(numbers):\n return nsmallest(2, numbers)[-1]", "second_smallest", "a,b,c = [int(x) for x in stdin.readline().strip().split()]", "[int(x) for x in stdin.readline().strip().split()]", "a" ]

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

[ [ 5, 4 ], [ 19, 18 ], [ 4, 22 ], [ 4, 25 ], [ 4, 29 ], [ 18, 34 ], [ 43, 40 ] ]

[ "# coding: utf-8\n\ndef main():\n N = sorted(list(map(int, input().split())))\n ans = N[0] * N[1] * (N[2] % 2)\n print(ans)\n\nif __name__ == \"__main__\":\n main()", "def main():\n N = sorted(list(map(int, input().split())))\n ans = N[0] * N[1] * (N[2] % 2)\n print(ans)", "main", "N = sorted(list(map(int, input().split())))", "N", "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 = N[0] * N[1] * (N[2] % 2)", "ans", "N[0] * N[1] * (N[2] % 2)", "N[0] * N[1]", "N[0]", "N", "0", "N[1]", "N", "1", "N[2] % 2", "N[2]", "N", "2", "2", "print(ans)", "print", "ans", "if __name__ == \"__main__\":\n main()", "__name__ == \"__main__\"", "__name__", "\"__main__\"", "main()", "main", "def main():\n N = sorted(list(map(int, input().split())))\n ans = N[0] * N[1] * (N[2] % 2)\n print(ans)", "def main():\n N = sorted(list(map(int, input().split())))\n ans = N[0] * N[1] * (N[2] % 2)\n print(ans)", "main" ]

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

[ [ 59, 2 ], [ 59, 11 ], [ 59, 12 ], [ 60, 18 ], [ 54, 23 ], [ 51, 28 ], [ 56, 32 ], [ 60, 36 ], [ 54, 37 ], [ 54, 39 ], [ 51, 40 ], [ 60, 42 ], [ 51, 43 ], [ 57, 48 ], [ 59, 51 ], [ 59, 54 ], [ 56, 57 ], [ 59, 60 ] ]

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

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

[ [ 62, 12 ], [ 66, 14 ], [ 62, 15 ], [ 62, 16 ], [ 45, 22 ], [ 48, 23 ], [ 63, 24 ], [ 45, 35 ], [ 48, 36 ], [ 63, 37 ], [ 45, 40 ], [ 48, 41 ], [ 63, 42 ], [ 62, 45 ], [ 62, 48 ], [ 62, 63 ] ]

[ "def ii():return int(input())\ndef iim():return map(int,input().split())\ndef iil():return list(map(int,input().split()))\ndef ism():return map(str,input().split())\ndef isl():return list(map(str,input().split()))\n\na,b,c = iim()\nif (a*b*c)%2 == 0:\n print(0)\nelse:\n print(a*b*c//max(a,b,c))", "def ii():return int(input())", "ii", "def iim():return map(int,input().split())", "iim", "def iil():return list(map(int,input().split()))", "iil", "def ism():return map(str,input().split())", "ism", "def isl():return list(map(str,input().split()))", "isl", "a,b,c = iim()", "a", "iim()", "iim", "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", "a,b,c = iim()", "iim()", "a", "b,c = iim()", "iim()", "b", "def iil():return list(map(int,input().split()))", "def iil():return list(map(int,input().split()))", "iil", "def ii():return int(input())", "def ii():return int(input())", "ii", "def ism():return map(str,input().split())", "def ism():return map(str,input().split())", "ism", "def isl():return list(map(str,input().split()))", "def isl():return list(map(str,input().split()))", "isl", "c = iim()", "iim()", "c", "def iim():return map(int,input().split())", "def iim():return map(int,input().split())", "iim" ]

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

[ [ 108, 2 ], [ 111, 14 ], [ 109, 17 ], [ 20, 19 ], [ 102, 22 ], [ 112, 24 ], [ 109, 24 ], [ 126, 26 ], [ 112, 28 ], [ 109, 28 ], [ 123, 30 ], [ 112, 32 ], [ 109, 32 ], [ 105, 35 ], [ 103, 37 ], [ 96, 39 ], [ 127, 41 ], [ 117, 43 ], [ 124, 45 ], [ 106, 51 ], [ 97, 54 ], [ 118, 57 ], [ 93, 60 ], [ 120, 63 ], [ 103, 67 ], [ 127, 69 ], [ 124, 70 ], [ 99, 72 ], [ 103, 78 ], [ 127, 82 ], [ 124, 83 ], [ 114, 85 ], [ 100, 87 ], [ 121, 88 ], [ 97, 88 ], [ 115, 91 ], [ 94, 91 ], [ 93, 94 ], [ 96, 97 ], [ 99, 100 ], [ 102, 103 ], [ 105, 106 ], [ 108, 109 ], [ 111, 112 ], [ 114, 115 ], [ 117, 118 ], [ 120, 121 ], [ 123, 124 ], [ 126, 127 ] ]

[ "#A - Divide a Cuboid \nABC = list(map(int,input().split()))\nABC = sorted(ABC,reverse = True)\nA,B,C = ABC[0],ABC[1],ABC[2]\na,b,c = A%2,B%2,C%2\n\nif a == 0 or b == 0 or c == 0:\n diff = 0\nelse:\n b = (A//2)*B*C\n r = ((A+2-1)//2)*B*C\n diff = r-b\nprint(diff)", "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 = sorted(ABC,reverse = True)", "ABC", "sorted(ABC,reverse = True)", "sorted", "ABC", "reverse = True", "reverse", "True", "A,B,C = ABC[0],ABC[1],ABC[2]", "A", "ABC[0]", "ABC", "0", "B", "ABC[1]", "ABC", "1", "C", "ABC[2]", "ABC", "2", "a,b,c = A%2,B%2,C%2", "a", "A%2", "A", "2", "b", "B%2", "B", "2", "c", "C%2", "C", "2", "if a == 0 or b == 0 or c == 0:\n diff = 0\nelse:\n b = (A//2)*B*C\n r = ((A+2-1)//2)*B*C\n diff = r-b", "a == 0 or b == 0 or c == 0", "a == 0 or b == 0", "a == 0", "a", "0", "b == 0", "b", "0", "c == 0", "c", "0", "diff = 0", "diff", "0", "b = (A//2)*B*C", "b", "(A//2)*B*C", "(A//2)*B", "A//2", "A", "2", "B", "C", "r = ((A+2-1)//2)*B*C", "r", "((A+2-1)//2)*B*C", "((A+2-1)//2)*B", "(A+2-1)//2", "A+2-1", "A+2", "A", "2", "1", "2", "B", "C", "diff = r-b", "diff", "r-b", "r", "b", "print(diff)", "print", "diff", "diff = 0", "0", "diff", "b,c = A%2,B%2,C%2", "B%2", "b", "r = ((A+2-1)//2)*B*C", "((A+2-1)//2)*B*C", "r", "A,B,C = ABC[0],ABC[1],ABC[2]", "ABC[0]", "A", "a,b,c = A%2,B%2,C%2", "A%2", "a", "ABC = list(map(int,input().split()))", "list(map(int,input().split()))", "ABC", "ABC = sorted(ABC,reverse = True)", "sorted(ABC,reverse = True)", "ABC", "diff = r-b", "r-b", "diff", "c = A%2,B%2,C%2", "C%2", "c", "b = (A//2)*B*C", "(A//2)*B*C", "b", "C = ABC[0],ABC[1],ABC[2]", "ABC[2]", "C", "B,C = ABC[0],ABC[1],ABC[2]", "ABC[1]", "B" ]

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

[ [ 76, 4 ], [ 76, 13 ], [ 76, 14 ], [ 64, 16 ], [ 65, 23 ], [ 73, 26 ], [ 65, 28 ], [ 74, 40 ], [ 65, 43 ], [ 65, 46 ], [ 74, 55 ], [ 65, 58 ], [ 65, 61 ], [ 64, 65 ], [ 76, 68 ], [ 76, 71 ], [ 73, 74 ], [ 76, 77 ] ]

[ "import math\na, b, c = map(int, input().split())\nl = [a, b, c]\nl.sort()\nx = l[2]\nprint(math.ceil(x / 2) * l[0] * l[1] - math.floor(x / 2) * l[0] * l[1])", "import math", "math", "a, b, c = map(int, input().split())", "a", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "c", "l = [a, b, c]", "l", "[a, b, c]", "a", "b", "c", "l.sort()", "l.sort", "l", "sort", "x = l[2]", "x", "l[2]", "l", "2", "print(math.ceil(x / 2) * l[0] * l[1] - math.floor(x / 2) * l[0] * l[1])", "print", "math.ceil(x / 2) * l[0] * l[1] - math.floor(x / 2) * l[0] * l[1]", "math.ceil(x / 2) * l[0] * l[1]", "math.ceil(x / 2) * l[0]", "math.ceil(x / 2)", "math.ceil", "math", "ceil", "x / 2", "x", "2", "l[0]", "l", "0", "l[1]", "l", "1", "math.floor(x / 2) * l[0] * l[1]", "math.floor(x / 2) * l[0]", "math.floor(x / 2)", "math.floor", "math", "floor", "x / 2", "x", "2", "l[0]", "l", "0", "l[1]", "l", "1", "l = [a, b, c]", "[a, b, c]", "l", "c = map(int, input().split())", "map(int, input().split())", "c", "a, b, c = map(int, input().split())", "map(int, input().split())", "a", "x = l[2]", "l[2]", "x", "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, 39, 13, 13, 13, 0, 13, 18, 13, 17, 14, 2, 2, 13, 17, 17, 4, 13, 17, 4, 13, 2, 18, 13, 17, 18, 13, 17, 10, 18, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 57, 2 ], [ 57, 11 ], [ 57, 12 ], [ 51, 14 ], [ 45, 22 ], [ 52, 24 ], [ 46, 29 ], [ 52, 39 ], [ 52, 42 ], [ 45, 46 ], [ 57, 49 ], [ 51, 52 ], [ 57, 55 ], [ 57, 58 ] ]

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

[ [ 58, 2 ], [ 58, 11 ], [ 58, 12 ], [ 53, 18 ], [ 50, 19 ], [ 59, 20 ], [ 64, 27 ], [ 53, 29 ], [ 50, 30 ], [ 55, 32 ], [ 53, 34 ], [ 59, 35 ], [ 61, 37 ], [ 50, 39 ], [ 59, 40 ], [ 65, 45 ], [ 62, 46 ], [ 56, 47 ], [ 58, 50 ], [ 58, 53 ], [ 55, 56 ], [ 58, 59 ], [ 61, 62 ], [ 64, 65 ] ]

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

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

[ [ 132, 11 ], [ 24, 23 ], [ 23, 36 ], [ 123, 38 ], [ 129, 42 ], [ 126, 54 ], [ 67, 66 ], [ 78, 77 ], [ 124, 79 ], [ 78, 80 ], [ 78, 81 ], [ 77, 87 ], [ 80, 92 ], [ 81, 97 ], [ 104, 103 ], [ 103, 113 ], [ 103, 116 ], [ 136, 121 ], [ 123, 124 ], [ 126, 127 ], [ 129, 130 ], [ 132, 133 ] ]

[ "import sys\n\nsys.setrecursionlimit(10 ** 8)\nini = lambda: int(sys.stdin.readline())\ninl = lambda: [int(x) for x in sys.stdin.readline().split()]\nins = lambda: sys.stdin.readline().rstrip()\ndebug = lambda *a, **kw: print(\"\\033[33m\", *a, \"\\033[0m\", **dict(file=sys.stderr, **kw))\n\n\ndef solve():\n A, B, C = inl()\n if A % 2 == 0 or B % 2 == 0 or C % 2 == 0:\n return 0\n x = sorted([A, B, C])\n\n return x[0] * x[1]\n\n\nprint(solve())", "import sys", "sys", "sys.setrecursionlimit(10 ** 8)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "10 ** 8", "10", "8", "ini = lambda: int(sys.stdin.readline())", "ini", "lambda: int(sys.stdin.readline())", "int(sys.stdin.readline())", "int", "sys.stdin.readline()", "sys.stdin.readline", "sys.stdin", "sys", "stdin", "readline", "int(x) for x in sys.stdin.readline().split()", "for x in sys.stdin.readline().split()", "x", "sys.stdin.readline().split()", "sys.stdin.readline().split", "sys.stdin.readline()", "sys.stdin.readline", "sys.stdin", "sys", "stdin", "readline", "split", "for x in sys.stdin.readline().split()", "int(x)", "int", "x", "inl = lambda: [int(x) for x in sys.stdin.readline().split()]", "inl", "lambda: [int(x) for x in sys.stdin.readline().split()]", "[int(x) for x in sys.stdin.readline().split()]", "ins = lambda: sys.stdin.readline().rstrip()", "ins", "lambda: sys.stdin.readline().rstrip()", "sys.stdin.readline().rstrip()", "sys.stdin.readline().rstrip", "sys.stdin.readline()", "sys.stdin.readline", "sys.stdin", "sys", "stdin", "readline", "rstrip", "debug = lambda *a, **kw: print(\"\\033[33m\", *a, \"\\033[0m\", **dict(file=sys.stderr, **kw))", "debug", "lambda *a, **kw: print(\"\\033[33m\", *a, \"\\033[0m\", **dict(file=sys.stderr, **kw))", "print(\"\\033[33m\", *a, \"\\033[0m\", **dict(file=sys.stderr, **kw))", "print", "\"\\033[33m\"", "*a", "a", "\"\\033[0m\"", "**dict(file=sys.stderr, **kw)", "dict(file=sys.stderr, **kw)", "dict", "file=sys.stderr", "file", "sys.stderr", "sys", "stderr", "**kw", "kw", "*a", "**kw", "def solve():\n A, B, C = inl()\n if A % 2 == 0 or B % 2 == 0 or C % 2 == 0:\n return 0\n x = sorted([A, B, C])\n\n return x[0] * x[1]", "solve", "A, B, C = inl()", "A", "inl()", "inl", "B", "C", "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", "x = sorted([A, B, C])", "x", "sorted([A, B, C])", "sorted", "[A, B, C]", "A", "B", "C", "return x[0] * x[1]", "x[0] * x[1]", "x[0]", "x", "0", "x[1]", "x", "1", "print(solve())", "print", "solve()", "solve", "inl = lambda: [int(x) for x in sys.stdin.readline().split()]", "lambda: [int(x) for x in sys.stdin.readline().split()]", "inl", "debug = lambda *a, **kw: print(\"\\033[33m\", *a, \"\\033[0m\", **dict(file=sys.stderr, **kw))", "lambda *a, **kw: print(\"\\033[33m\", *a, \"\\033[0m\", **dict(file=sys.stderr, **kw))", "debug", "ins = lambda: sys.stdin.readline().rstrip()", "lambda: sys.stdin.readline().rstrip()", "ins", "ini = lambda: int(sys.stdin.readline())", "lambda: int(sys.stdin.readline())", "ini", "def solve():\n A, B, C = inl()\n if A % 2 == 0 or B % 2 == 0 or C % 2 == 0:\n return 0\n x = sorted([A, B, C])\n\n return x[0] * x[1]", "def solve():\n A, B, C = inl()\n if A % 2 == 0 or B % 2 == 0 or C % 2 == 0:\n return 0\n x = sorted([A, B, C])\n\n return x[0] * x[1]", "solve" ]

[ 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 ], [ 42, 29 ], [ 39, 30 ], [ 39, 32 ], [ 45, 33 ], [ 45, 35 ], [ 42, 36 ], [ 44, 39 ], [ 44, 42 ], [ 44, 45 ] ]

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

[ [ 108, 2 ], [ 105, 14 ], [ 109, 18 ], [ 109, 21 ], [ 109, 26 ], [ 109, 31 ], [ 109, 35 ], [ 102, 39 ], [ 109, 43 ], [ 109, 46 ], [ 109, 51 ], [ 109, 56 ], [ 109, 60 ], [ 111, 64 ], [ 109, 68 ], [ 109, 71 ], [ 109, 76 ], [ 109, 81 ], [ 109, 85 ], [ 106, 94 ], [ 103, 97 ], [ 112, 100 ], [ 102, 103 ], [ 105, 106 ], [ 108, 109 ], [ 111, 112 ] ]

[ "L = list(map(int, input().split()))\n\nans1 = L[0]*L[1]*(L[2]//2-(L[2]-L[2]//2))\nans2 = L[0]*L[2]*(L[1]//2-(L[1]-L[1]//2))\nans3 = L[1]*L[2]*(L[0]//2-(L[0]-L[0]//2))\nprint(min(abs(ans1), abs(ans2), abs(ans3)))", "L = list(map(int, input().split()))", "L", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "ans1 = L[0]*L[1]*(L[2]//2-(L[2]-L[2]//2))", "ans1", "L[0]*L[1]*(L[2]//2-(L[2]-L[2]//2))", "L[0]*L[1]", "L[0]", "L", "0", "L[1]", "L", "1", "L[2]//2-(L[2]-L[2]//2)", "L[2]//2", "L[2]", "L", "2", "2", "L[2]-L[2]//2", "L[2]", "L", "2", "L[2]//2", "L[2]", "L", "2", "2", "ans2 = L[0]*L[2]*(L[1]//2-(L[1]-L[1]//2))", "ans2", "L[0]*L[2]*(L[1]//2-(L[1]-L[1]//2))", "L[0]*L[2]", "L[0]", "L", "0", "L[2]", "L", "2", "L[1]//2-(L[1]-L[1]//2)", "L[1]//2", "L[1]", "L", "1", "2", "L[1]-L[1]//2", "L[1]", "L", "1", "L[1]//2", "L[1]", "L", "1", "2", "ans3 = L[1]*L[2]*(L[0]//2-(L[0]-L[0]//2))", "ans3", "L[1]*L[2]*(L[0]//2-(L[0]-L[0]//2))", "L[1]*L[2]", "L[1]", "L", "1", "L[2]", "L", "2", "L[0]//2-(L[0]-L[0]//2)", "L[0]//2", "L[0]", "L", "0", "2", "L[0]-L[0]//2", "L[0]", "L", "0", "L[0]//2", "L[0]", "L", "0", "2", "print(min(abs(ans1), abs(ans2), abs(ans3)))", "print", "min(abs(ans1), abs(ans2), abs(ans3))", "min", "abs(ans1)", "abs", "ans1", "abs(ans2)", "abs", "ans2", "abs(ans3)", "abs", "ans3", "ans2 = L[0]*L[2]*(L[1]//2-(L[1]-L[1]//2))", "L[0]*L[2]*(L[1]//2-(L[1]-L[1]//2))", "ans2", "ans1 = L[0]*L[1]*(L[2]//2-(L[2]-L[2]//2))", "L[0]*L[1]*(L[2]//2-(L[2]-L[2]//2))", "ans1", "L = list(map(int, input().split()))", "list(map(int, input().split()))", "L", "ans3 = L[1]*L[2]*(L[0]//2-(L[0]-L[0]//2))", "L[1]*L[2]*(L[0]//2-(L[0]-L[0]//2))", "ans3" ]

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

[ [ 4, 2 ] ]

[ "#!/usr/bin/env python3\n(*a, ) = map(int, input().split())\nif sum(i % 2 for i in a) > 2:\n print(a[0]*a[1]*a[2]//max(a))\nelse:\n print(0)", "(*a, ) = map(int, input().split())", "*a", "a", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "if sum(i % 2 for i in a) > 2:\n print(a[0]*a[1]*a[2]//max(a))\nelse:\n print(0)", "sum(i % 2 for i in a) > 2", "sum(i % 2 for i in a)", "sum", "i % 2", "i", "2", "2", "print(a[0]*a[1]*a[2]//max(a))", "print", "a[0]*a[1]*a[2]//max(a)", "a[0]*a[1]*a[2]", "a[0]*a[1]", "a[0]", "a", "0", "a[1]", "a", "1", "a[2]", "a", "2", "max(a)", "max", "a", "print(0)", "print", "0" ]

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

[ [ 100, 2 ], [ 100, 11 ], [ 100, 12 ], [ 103, 14 ], [ 94, 19 ], [ 104, 22 ], [ 98, 26 ], [ 89, 27 ], [ 101, 30 ], [ 98, 35 ], [ 89, 36 ], [ 101, 38 ], [ 106, 41 ], [ 95, 44 ], [ 104, 44 ], [ 89, 48 ], [ 101, 49 ], [ 98, 52 ], [ 89, 57 ], [ 101, 58 ], [ 98, 60 ], [ 91, 63 ], [ 107, 66 ], [ 95, 66 ], [ 104, 66 ], [ 101, 70 ], [ 98, 71 ], [ 89, 74 ], [ 101, 79 ], [ 98, 80 ], [ 89, 82 ], [ 92, 86 ], [ 107, 86 ], [ 95, 86 ], [ 104, 86 ], [ 100, 89 ], [ 91, 92 ], [ 94, 95 ], [ 100, 98 ], [ 100, 101 ], [ 103, 104 ], [ 106, 107 ] ]

[ "a, b, c = map(int, input().split())\nans = float('inf')\nans = min(ans, a * b * ((c + 1) // 2) - a * b * (c // 2))\nans = min(ans, b * c * ((a + 1) // 2) - b * c * (a // 2))\nans = min(ans, c * a * ((b + 1) // 2) - c * a * (b // 2))\nprint(ans)", "a, b, c = map(int, input().split())", "a", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "c", "ans = float('inf')", "ans", "float('inf')", "float", "'inf'", "ans = min(ans, a * b * ((c + 1) // 2) - a * b * (c // 2))", "ans", "min(ans, a * b * ((c + 1) // 2) - a * b * (c // 2))", "min", "ans", "a * b * ((c + 1) // 2) - a * b * (c // 2)", "a * b * ((c + 1) // 2)", "a * b", "a", "b", "(c + 1) // 2", "c + 1", "c", "1", "2", "a * b * (c // 2)", "a * b", "a", "b", "c // 2", "c", "2", "ans = min(ans, b * c * ((a + 1) // 2) - b * c * (a // 2))", "ans", "min(ans, b * c * ((a + 1) // 2) - b * c * (a // 2))", "min", "ans", "b * c * ((a + 1) // 2) - b * c * (a // 2)", "b * c * ((a + 1) // 2)", "b * c", "b", "c", "(a + 1) // 2", "a + 1", "a", "1", "2", "b * c * (a // 2)", "b * c", "b", "c", "a // 2", "a", "2", "ans = min(ans, c * a * ((b + 1) // 2) - c * a * (b // 2))", "ans", "min(ans, c * a * ((b + 1) // 2) - c * a * (b // 2))", "min", "ans", "c * a * ((b + 1) // 2) - c * a * (b // 2)", "c * a * ((b + 1) // 2)", "c * a", "c", "a", "(b + 1) // 2", "b + 1", "b", "1", "2", "c * a * (b // 2)", "c * a", "c", "a", "b // 2", "b", "2", "print(ans)", "print", "ans", "b, c = map(int, input().split())", "map(int, input().split())", "b", "ans = min(ans, c * a * ((b + 1) // 2) - c * a * (b // 2))", "min(ans, c * a * ((b + 1) // 2) - c * a * (b // 2))", "ans", "ans = min(ans, a * b * ((c + 1) // 2) - a * b * (c // 2))", "min(ans, a * b * ((c + 1) // 2) - a * b * (c // 2))", "ans", "a, b, c = map(int, input().split())", "map(int, input().split())", "a", "c = map(int, input().split())", "map(int, input().split())", "c", "ans = float('inf')", "float('inf')", "ans", "ans = min(ans, b * c * ((a + 1) // 2) - b * c * (a // 2))", "min(ans, b * c * ((a + 1) // 2) - b * c * (a // 2))", "ans" ]

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

[ [ 53, 2 ], [ 53, 11 ], [ 53, 12 ], [ 51, 18 ], [ 45, 19 ], [ 54, 20 ], [ 47, 27 ], [ 48, 38 ], [ 48, 41 ], [ 53, 45 ], [ 47, 48 ], [ 53, 51 ], [ 53, 54 ] ]

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

[ [ 45, 2 ], [ 48, 16 ], [ 46, 19 ], [ 46, 22 ], [ 26, 25 ], [ 46, 33 ], [ 25, 34 ], [ 51, 38 ], [ 52, 43 ], [ 49, 43 ], [ 45, 46 ], [ 48, 49 ], [ 51, 52 ] ]

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

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

[ [ 125, 11 ], [ 134, 16 ], [ 38, 37 ], [ 129, 44 ], [ 38, 46 ], [ 38, 47 ], [ 50, 49 ], [ 37, 56 ], [ 46, 58 ], [ 47, 59 ], [ 37, 63 ], [ 37, 65 ], [ 46, 67 ], [ 47, 68 ], [ 71, 70 ], [ 46, 77 ], [ 37, 79 ], [ 47, 80 ], [ 46, 84 ], [ 46, 86 ], [ 37, 88 ], [ 47, 89 ], [ 92, 91 ], [ 47, 98 ], [ 46, 100 ], [ 37, 101 ], [ 47, 105 ], [ 47, 107 ], [ 46, 109 ], [ 37, 110 ], [ 49, 115 ], [ 70, 116 ], [ 91, 117 ], [ 132, 123 ], [ 125, 126 ], [ 134, 135 ] ]

[ "import sys\n\nsys.setrecursionlimit(10 ** 6)\nINF = float(\"inf\")\nMOD = 10 ** 9 + 7\n\n\ndef input():\n return sys.stdin.readline().strip()\n\n\ndef main():\n A, B, C = map(int, input().split())\n\n ans1 = abs(A // 2 * B * C - (A - A // 2) * B * C)\n ans2 = abs(B // 2 * A * C - (B - B // 2) * A * C)\n ans3 = abs(C // 2 * B * A - (C - C // 2) * B * A)\n print(min(ans1, ans2, ans3))\n\n\nif __name__ == \"__main__\":\n main()", "import sys", "sys", "sys.setrecursionlimit(10 ** 6)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "10 ** 6", "10", "6", "INF = float(\"inf\")", "INF", "float(\"inf\")", "float", "\"inf\"", "MOD = 10 ** 9 + 7", "MOD", "10 ** 9 + 7", "10 ** 9", "10", "9", "7", "def input():\n return sys.stdin.readline().strip()", "input", "return sys.stdin.readline().strip()", "sys.stdin.readline().strip()", "sys.stdin.readline().strip", "sys.stdin.readline()", "sys.stdin.readline", "sys.stdin", "sys", "stdin", "readline", "strip", "def main():\n A, B, C = map(int, input().split())\n\n ans1 = abs(A // 2 * B * C - (A - A // 2) * B * C)\n ans2 = abs(B // 2 * A * C - (B - B // 2) * A * C)\n ans3 = abs(C // 2 * B * A - (C - C // 2) * B * A)\n print(min(ans1, ans2, ans3))", "main", "A, B, C = map(int, input().split())", "A", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "B", "C", "ans1 = abs(A // 2 * B * C - (A - A // 2) * B * C)", "ans1", "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", "ans2 = abs(B // 2 * A * C - (B - B // 2) * A * C)", "ans2", "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", "ans3 = abs(C // 2 * B * A - (C - C // 2) * B * A)", "ans3", "abs(C // 2 * B * A - (C - C // 2) * B * A)", "abs", "C // 2 * B * A - (C - C // 2) * B * A", "C // 2 * B * A", "C // 2 * B", "C // 2", "C", "2", "B", "A", "(C - C // 2) * B * A", "(C - C // 2) * B", "C - C // 2", "C", "C // 2", "C", "2", "B", "A", "print(min(ans1, ans2, ans3))", "print", "min(ans1, ans2, ans3)", "min", "ans1", "ans2", "ans3", "if __name__ == \"__main__\":\n main()", "__name__ == \"__main__\"", "__name__", "\"__main__\"", "main()", "main", "INF = float(\"inf\")", "float(\"inf\")", "INF", "def input():\n return sys.stdin.readline().strip()", "def input():\n return sys.stdin.readline().strip()", "input", "def main():\n A, B, C = map(int, input().split())\n\n ans1 = abs(A // 2 * B * C - (A - A // 2) * B * C)\n ans2 = abs(B // 2 * A * C - (B - B // 2) * A * C)\n ans3 = abs(C // 2 * B * A - (C - C // 2) * B * A)\n print(min(ans1, ans2, ans3))", "def main():\n A, B, C = map(int, input().split())\n\n ans1 = abs(A // 2 * B * C - (A - A // 2) * B * C)\n ans2 = abs(B // 2 * A * C - (B - B // 2) * A * C)\n ans3 = abs(C // 2 * B * A - (C - C // 2) * B * A)\n print(min(ans1, ans2, ans3))", "main", "MOD = 10 ** 9 + 7", "10 ** 9 + 7", "MOD" ]

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

[ [ 129, 2 ], [ 129, 11 ], [ 129, 12 ], [ 132, 14 ], [ 130, 17 ], [ 127, 18 ], [ 124, 19 ], [ 130, 25 ], [ 127, 30 ], [ 124, 35 ], [ 130, 47 ], [ 127, 52 ], [ 124, 57 ], [ 133, 61 ], [ 130, 62 ], [ 127, 66 ], [ 124, 67 ], [ 130, 74 ], [ 127, 79 ], [ 124, 84 ], [ 133, 88 ], [ 127, 89 ], [ 130, 93 ], [ 124, 94 ], [ 130, 101 ], [ 127, 106 ], [ 124, 111 ], [ 133, 115 ], [ 124, 116 ], [ 127, 120 ], [ 130, 121 ], [ 129, 124 ], [ 129, 127 ], [ 129, 130 ], [ 132, 133 ] ]

[ "a,b,c=map(int,input().split())\nd=max(a,b,c)\nif a%2==0 or b%2==0 or c%2==0:\n print(0)\nelif a%2==1 and b%2==1 and c%2==1 and d==a:\n print(b*c)\nelif a%2==1 and b%2==1 and c%2==1 and d==b:\n print(a*c)\nelif a%2==1 and b%2==1 and c%2==1 and d==c:\n print(b*a)", "a,b,c=map(int,input().split())", "a", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "c", "d=max(a,b,c)", "d", "max(a,b,c)", "max", "a", "b", "c", "if a%2==0 or b%2==0 or c%2==0:\n print(0)\nelif a%2==1 and b%2==1 and c%2==1 and d==a:\n print(b*c)\nelif a%2==1 and b%2==1 and c%2==1 and d==b:\n print(a*c)\nelif a%2==1 and b%2==1 and c%2==1 and d==c:\n print(b*a)", "a%2==0 or b%2==0 or c%2==0", "a%2==0 or b%2==0", "a%2==0", "a%2", "a", "2", "0", "b%2==0", "b%2", "b", "2", "0", "c%2==0", "c%2", "c", "2", "0", "print(0)", "print", "0", "elif a%2==1 and b%2==1 and c%2==1 and d==a:\n print(b*c)", "a%2==1 and b%2==1 and c%2==1 and d==a", "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", "d==a", "d", "a", "print(b*c)", "print", "b*c", "b", "c", "elif a%2==1 and b%2==1 and c%2==1 and d==b:\n print(a*c)", "a%2==1 and b%2==1 and c%2==1 and d==b", "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", "d==b", "d", "b", "print(a*c)", "print", "a*c", "a", "c", "elif a%2==1 and b%2==1 and c%2==1 and d==c:\n print(b*a)", "a%2==1 and b%2==1 and c%2==1 and d==c", "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", "d==c", "d", "c", "print(b*a)", "print", "b*a", "b", "a", "c=map(int,input().split())", "map(int,input().split())", "c", "b,c=map(int,input().split())", "map(int,input().split())", "b", "a,b,c=map(int,input().split())", "map(int,input().split())", "a", "d=max(a,b,c)", "max(a,b,c)", "d" ]

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

[ [ 44, 2 ], [ 45, 15 ], [ 45, 22 ], [ 45, 25 ], [ 45, 28 ], [ 45, 35 ], [ 45, 38 ], [ 44, 45 ] ]

[ "a =list( map(int,input().split()))\n\n\na.sort()\nif (a[0]*a[1]*a[2])%2 :\n print(a[0]*a[1])\n\n\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 :\n print(a[0]*a[1])\n\n\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", "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, 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, 40, 13, 0, 13, 2, 18, 13, 17, 18, 13, 17, 4, 13, 8, 13, 17, 13, 10, 4, 13, 10, 2, 13, 10, 17, 13, 10, 17, 13 ]

[ [ 54, 2 ], [ 60, 16 ], [ 20, 19 ], [ 55, 27 ], [ 19, 28 ], [ 63, 32 ], [ 64, 37 ], [ 61, 37 ], [ 57, 39 ], [ 55, 42 ], [ 55, 45 ], [ 64, 50 ], [ 61, 50 ], [ 58, 52 ], [ 54, 55 ], [ 57, 58 ], [ 60, 61 ], [ 63, 64 ] ]

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

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

[ [ 39, 2 ], [ 39, 13 ], [ 39, 14 ], [ 40, 18 ], [ 42, 25 ], [ 37, 27 ], [ 34, 28 ], [ 43, 31 ], [ 39, 34 ], [ 39, 37 ], [ 39, 40 ], [ 42, 43 ] ]

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

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

[ [ 104, 2 ], [ 104, 11 ], [ 104, 12 ], [ 95, 16 ], [ 105, 22 ], [ 86, 25 ], [ 105, 27 ], [ 96, 28 ], [ 98, 30 ], [ 84, 36 ], [ 101, 39 ], [ 84, 41 ], [ 99, 42 ], [ 92, 44 ], [ 90, 50 ], [ 107, 53 ], [ 90, 55 ], [ 93, 56 ], [ 108, 64 ], [ 93, 65 ], [ 105, 66 ], [ 84, 67 ], [ 87, 71 ], [ 96, 72 ], [ 90, 73 ], [ 84, 74 ], [ 102, 78 ], [ 99, 79 ], [ 105, 80 ], [ 90, 81 ], [ 104, 84 ], [ 86, 87 ], [ 104, 90 ], [ 92, 93 ], [ 95, 96 ], [ 98, 99 ], [ 101, 102 ], [ 104, 105 ], [ 107, 108 ] ]

[ "A, B, C = map(int, input().split())\n\nimport math\n\nAsmall = math.floor(A/2)\nAbig = A- Asmall\nBsmall = math.floor(B/2)\nBbig = B- Bsmall\nCsmall = math.floor(C/2)\nCbig = C- Csmall\n\nprint(min((Cbig-Csmall)*A*B, (Abig-Asmall)*C*B, (Bbig-Bsmall)*A*C))", "A, B, C = map(int, input().split())", "A", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "B", "C", "import math", "math", "Asmall = math.floor(A/2)", "Asmall", "math.floor(A/2)", "math.floor", "math", "floor", "A/2", "A", "2", "Abig = A- Asmall", "Abig", "A- Asmall", "A", "Asmall", "Bsmall = math.floor(B/2)", "Bsmall", "math.floor(B/2)", "math.floor", "math", "floor", "B/2", "B", "2", "Bbig = B- Bsmall", "Bbig", "B- Bsmall", "B", "Bsmall", "Csmall = math.floor(C/2)", "Csmall", "math.floor(C/2)", "math.floor", "math", "floor", "C/2", "C", "2", "Cbig = C- Csmall", "Cbig", "C- Csmall", "C", "Csmall", "print(min((Cbig-Csmall)*A*B, (Abig-Asmall)*C*B, (Bbig-Bsmall)*A*C))", "print", "min((Cbig-Csmall)*A*B, (Abig-Asmall)*C*B, (Bbig-Bsmall)*A*C)", "min", "(Cbig-Csmall)*A*B", "(Cbig-Csmall)*A", "Cbig-Csmall", "Cbig", "Csmall", "A", "B", "(Abig-Asmall)*C*B", "(Abig-Asmall)*C", "Abig-Asmall", "Abig", "Asmall", "C", "B", "(Bbig-Bsmall)*A*C", "(Bbig-Bsmall)*A", "Bbig-Bsmall", "Bbig", "Bsmall", "A", "C", "B, C = map(int, input().split())", "map(int, input().split())", "B", "Abig = A- Asmall", "A- Asmall", "Abig", "C = map(int, input().split())", "map(int, input().split())", "C", "Csmall = math.floor(C/2)", "math.floor(C/2)", "Csmall", "Asmall = math.floor(A/2)", "math.floor(A/2)", "Asmall", "Bsmall = math.floor(B/2)", "math.floor(B/2)", "Bsmall", "Bbig = B- Bsmall", "B- Bsmall", "Bbig", "A, B, C = map(int, input().split())", "map(int, input().split())", "A", "Cbig = C- Csmall", "C- Csmall", "Cbig" ]

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

[ [ 7, 6 ], [ 15, 14 ], [ 6, 20 ], [ 14, 27 ], [ 30, 29 ], [ 30, 31 ], [ 30, 32 ], [ 29, 38 ], [ 31, 39 ], [ 32, 40 ], [ 49, 48 ], [ 49, 55 ], [ 49, 56 ], [ 48, 60 ], [ 29, 60 ], [ 55, 61 ], [ 31, 61 ], [ 70, 67 ] ]

[ "\ndef resolve():\n import sys\n input = sys.stdin.readline\n\n a, b, c = [int(x) for x in input().rstrip().split(\" \")]\n\n if (a * b * c) % 2 == 0:\n print(0)\n return\n\n a, b, c = sorted([a, b, c])\n\n print(a * b)\n\n\n\nif __name__ == \"__main__\":\n resolve()", "def resolve():\n import sys\n input = sys.stdin.readline\n\n a, b, c = [int(x) for x in input().rstrip().split(\" \")]\n\n if (a * b * c) % 2 == 0:\n print(0)\n return\n\n a, b, c = sorted([a, b, c])\n\n print(a * b)", "resolve", "import sys", "sys", "input = sys.stdin.readline", "input", "sys.stdin.readline", "sys.stdin", "sys", "stdin", "readline", "int(x) for x in input().rstrip().split(\" \")", "for x in input().rstrip().split(\" \")", "x", "input().rstrip().split(\" \")", "().rstrip().split", "().rstrip()", "().rstrip", "()", "input", "rstrip", "split", "\" \"", "for x in input().rstrip().split(\" \")", "int(x)", "int", "x", "a, b, c = [int(x) for x in input().rstrip().split(\" \")]", "a", "[int(x) for x in input().rstrip().split(\" \")]", "b", "c", "if (a * b * c) % 2 == 0:\n print(0)\n return\n\n ", "(a * b * c) % 2 == 0", "(a * b * c) % 2", "a * b * c", "a * b", "a", "b", "c", "2", "0", "print(0)", "print", "0", "return", "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", "if __name__ == \"__main__\":\n resolve()", "__name__ == \"__main__\"", "__name__", "\"__main__\"", "resolve()", "resolve", "def resolve():\n import sys\n input = sys.stdin.readline\n\n a, b, c = [int(x) for x in input().rstrip().split(\" \")]\n\n if (a * b * c) % 2 == 0:\n print(0)\n return\n\n a, b, c = sorted([a, b, c])\n\n print(a * b)", "def resolve():\n import sys\n input = sys.stdin.readline\n\n a, b, c = [int(x) for x in input().rstrip().split(\" \")]\n\n if (a * b * c) % 2 == 0:\n print(0)\n return\n\n a, b, c = sorted([a, b, c])\n\n print(a * b)", "resolve" ]

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

[ [ 43, 4 ], [ 46, 16 ], [ 44, 28 ], [ 49, 31 ], [ 44, 34 ], [ 44, 37 ], [ 50, 41 ], [ 47, 41 ], [ 43, 44 ], [ 46, 47 ], [ 49, 50 ] ]

[ "import itertools\n\nl = list(map(int, input().split()))\nans = 0\n\nif all(elem %2 ==1 for elem in l):\n l.sort()\n ans = l[0] * l[1]\n \nprint(ans)\n", "import itertools", "itertools", "l = list(map(int, input().split()))", "l", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "ans = 0", "ans", "0", "if all(elem %2 ==1 for elem in l):\n l.sort()\n ans = l[0] * l[1]\n ", "all(elem %2 ==1 for elem in l)", "all", "elem %2 ==1", "elem %2", "elem", "2", "1", "l.sort()", "l.sort", "l", "sort", "ans = l[0] * l[1]", "ans", "l[0] * l[1]", "l[0]", "l", "0", "l[1]", "l", "1", "print(ans)", "print", "ans", "l = list(map(int, input().split()))", "list(map(int, input().split()))", "l", "ans = 0", "0", "ans", "ans = l[0] * l[1]", "l[0] * l[1]", "ans" ]

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

[ [ 85, 2 ], [ 85, 11 ], [ 85, 12 ], [ 88, 14 ], [ 86, 17 ], [ 77, 18 ], [ 74, 21 ], [ 74, 24 ], [ 74, 26 ], [ 82, 29 ], [ 86, 32 ], [ 77, 35 ], [ 77, 38 ], [ 77, 40 ], [ 74, 42 ], [ 79, 44 ], [ 86, 49 ], [ 86, 52 ], [ 86, 54 ], [ 77, 56 ], [ 74, 57 ], [ 89, 65 ], [ 83, 68 ], [ 80, 71 ], [ 85, 74 ], [ 85, 77 ], [ 79, 80 ], [ 82, 83 ], [ 85, 86 ], [ 88, 89 ] ]

[ "a, b, c = map(int, input().split())\nans1 = a*b*(c//2-(c-c//2))\nans2 = a*(b//2-(b-b//2))*c\nans3 = (a//2-(a-a//2))*b*c\nprint(min([abs(ans1), abs(ans2),abs(ans3)]))", "a, b, c = map(int, input().split())", "a", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "c", "ans1 = a*b*(c//2-(c-c//2))", "ans1", "a*b*(c//2-(c-c//2))", "a*b", "a", "b", "c//2-(c-c//2)", "c//2", "c", "2", "c-c//2", "c", "c//2", "c", "2", "ans2 = a*(b//2-(b-b//2))*c", "ans2", "a*(b//2-(b-b//2))*c", "a*(b//2-(b-b//2))", "a", "b//2-(b-b//2)", "b//2", "b", "2", "b-b//2", "b", "b//2", "b", "2", "c", "ans3 = (a//2-(a-a//2))*b*c", "ans3", "(a//2-(a-a//2))*b*c", "(a//2-(a-a//2))*b", "a//2-(a-a//2)", "a//2", "a", "2", "a-a//2", "a", "a//2", "a", "2", "b", "c", "print(min([abs(ans1), abs(ans2),abs(ans3)]))", "print", "min([abs(ans1), abs(ans2),abs(ans3)])", "min", "[abs(ans1), abs(ans2),abs(ans3)]", "abs(ans1)", "abs", "ans1", "abs(ans2)", "abs", "ans2", "abs(ans3)", "abs", "ans3", "c = map(int, input().split())", "map(int, input().split())", "c", "b, c = map(int, input().split())", "map(int, input().split())", "b", "ans3 = (a//2-(a-a//2))*b*c", "(a//2-(a-a//2))*b*c", "ans3", "ans2 = a*(b//2-(b-b//2))*c", "a*(b//2-(b-b//2))*c", "ans2", "a, b, c = map(int, input().split())", "map(int, input().split())", "a", "ans1 = a*b*(c//2-(c-c//2))", "a*b*(c//2-(c-c//2))", "ans1" ]

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

[ [ 88, 4 ], [ 88, 13 ], [ 88, 14 ], [ 73, 16 ], [ 70, 22 ], [ 74, 25 ], [ 85, 27 ], [ 71, 30 ], [ 74, 30 ], [ 71, 33 ], [ 74, 33 ], [ 82, 36 ], [ 71, 43 ], [ 74, 43 ], [ 79, 47 ], [ 71, 54 ], [ 74, 54 ], [ 86, 61 ], [ 83, 62 ], [ 77, 62 ], [ 86, 64 ], [ 80, 65 ], [ 88, 68 ], [ 70, 71 ], [ 73, 74 ], [ 88, 77 ], [ 79, 80 ], [ 82, 83 ], [ 85, 86 ], [ 88, 89 ] ]

[ "import math\n\na, b ,c = map(int, input().split())\nlis = [a, b, c]\nlis = sorted(lis)\n\nt = lis[0] * lis[1]\n\nb = math.ceil(lis[2]/2)\ns = math.floor(lis[2]/2)\n\nprint(t*b - t*s)", "import math", "math", "a, b ,c = map(int, input().split())", "a", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "c", "lis = [a, b, c]", "lis", "[a, b, c]", "a", "b", "c", "lis = sorted(lis)", "lis", "sorted(lis)", "sorted", "lis", "t = lis[0] * lis[1]", "t", "lis[0] * lis[1]", "lis[0]", "lis", "0", "lis[1]", "lis", "1", "b = math.ceil(lis[2]/2)", "b", "math.ceil(lis[2]/2)", "math.ceil", "math", "ceil", "lis[2]/2", "lis[2]", "lis", "2", "2", "s = math.floor(lis[2]/2)", "s", "math.floor(lis[2]/2)", "math.floor", "math", "floor", "lis[2]/2", "lis[2]", "lis", "2", "2", "print(t*b - t*s)", "print", "t*b - t*s", "t*b", "t", "b", "t*s", "t", "s", "a, b ,c = map(int, input().split())", "map(int, input().split())", "a", "lis = sorted(lis)", "sorted(lis)", "lis", "lis = [a, b, c]", "[a, b, c]", "lis", "b ,c = map(int, input().split())", "map(int, input().split())", "b", "s = math.floor(lis[2]/2)", "math.floor(lis[2]/2)", "s", "b = math.ceil(lis[2]/2)", "math.ceil(lis[2]/2)", "b", "t = lis[0] * lis[1]", "lis[0] * lis[1]", "t", "c = map(int, input().split())", "map(int, input().split())", "c" ]

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

[ [ 109, 4 ], [ 110, 21 ], [ 110, 28 ], [ 110, 35 ], [ 94, 43 ], [ 110, 46 ], [ 97, 48 ], [ 110, 51 ], [ 95, 53 ], [ 100, 55 ], [ 59, 58 ], [ 110, 63 ], [ 98, 66 ], [ 58, 67 ], [ 106, 69 ], [ 95, 76 ], [ 95, 83 ], [ 103, 86 ], [ 110, 88 ], [ 58, 89 ], [ 104, 92 ], [ 107, 92 ], [ 101, 92 ], [ 94, 95 ], [ 97, 98 ], [ 100, 101 ], [ 103, 104 ], [ 106, 107 ], [ 109, 110 ] ]

[ "# A\nimport math\nA_B_C = list(map(int,input().split()))\n\nif A_B_C[0] % 2 == 0 or A_B_C[1] % 2 == 0 or A_B_C[2] % 2 == 0:\n print(0)\nelse:\n max_v = max(A_B_C)\n max_i = A_B_C.index(max_v)\n ans = 1\n for i in range(len(A_B_C)):\n if max_i == i:\n ans *= (math.ceil(max_v/2) - math.floor(max_v/2))\n else:\n ans *= A_B_C[i]\n \n print(ans)", "import math", "math", "A_B_C = list(map(int,input().split()))", "A_B_C", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "if A_B_C[0] % 2 == 0 or A_B_C[1] % 2 == 0 or A_B_C[2] % 2 == 0:\n print(0)\nelse:\n max_v = max(A_B_C)\n max_i = A_B_C.index(max_v)\n ans = 1\n for i in range(len(A_B_C)):\n if max_i == i:\n ans *= (math.ceil(max_v/2) - math.floor(max_v/2))\n else:\n ans *= A_B_C[i]\n \n print(ans)", "A_B_C[0] % 2 == 0 or A_B_C[1] % 2 == 0 or A_B_C[2] % 2 == 0", "A_B_C[0] % 2 == 0 or A_B_C[1] % 2 == 0", "A_B_C[0] % 2 == 0", "A_B_C[0] % 2", "A_B_C[0]", "A_B_C", "0", "2", "0", "A_B_C[1] % 2 == 0", "A_B_C[1] % 2", "A_B_C[1]", "A_B_C", "1", "2", "0", "A_B_C[2] % 2 == 0", "A_B_C[2] % 2", "A_B_C[2]", "A_B_C", "2", "2", "0", "print(0)", "print", "0", "max_v = max(A_B_C)", "max_v", "max(A_B_C)", "max", "A_B_C", "max_i = A_B_C.index(max_v)", "max_i", "A_B_C.index(max_v)", "A_B_C.index", "A_B_C", "index", "max_v", "ans = 1", "ans", "1", "for i in range(len(A_B_C)):\n if max_i == i:\n ans *= (math.ceil(max_v/2) - math.floor(max_v/2))\n else:\n ans *= A_B_C[i]\n \n ", "i", "range(len(A_B_C))", "range", "len(A_B_C)", "len", "A_B_C", "if max_i == i:\n ans *= (math.ceil(max_v/2) - math.floor(max_v/2))\n else:\n ans *= A_B_C[i]\n \n ", "max_i == i", "max_i", "i", "ans *= (math.ceil(max_v/2) - math.floor(max_v/2))", "ans", "math.ceil(max_v/2) - math.floor(max_v/2)", "math.ceil(max_v/2)", "math.ceil", "math", "ceil", "max_v/2", "max_v", "2", "math.floor(max_v/2)", "math.floor", "math", "floor", "max_v/2", "max_v", "2", "ans *= A_B_C[i]", "ans", "A_B_C[i]", "A_B_C", "i", "print(ans)", "print", "ans", "max_v = max(A_B_C)", "max(A_B_C)", "max_v", "max_i = A_B_C.index(max_v)", "A_B_C.index(max_v)", "max_i", "ans = 1", "1", "ans", "ans *= A_B_C[i]", "A_B_C[i]", "ans", "ans *= (math.ceil(max_v/2) - math.floor(max_v/2))", "math.ceil(max_v/2) - math.floor(max_v/2)", "ans", "A_B_C = list(map(int,input().split()))", "list(map(int,input().split()))", "A_B_C" ]

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

[ [ 59, 2 ], [ 59, 11 ], [ 59, 12 ], [ 54, 18 ], [ 60, 23 ], [ 57, 28 ], [ 62, 37 ], [ 54, 41 ], [ 60, 42 ], [ 60, 44 ], [ 57, 45 ], [ 57, 47 ], [ 54, 48 ], [ 63, 51 ], [ 59, 54 ], [ 59, 57 ], [ 59, 60 ], [ 62, 63 ] ]

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

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

[ [ 111, 2 ], [ 111, 11 ], [ 111, 12 ], [ 96, 14 ], [ 112, 16 ], [ 114, 18 ], [ 112, 21 ], [ 99, 25 ], [ 103, 28 ], [ 88, 29 ], [ 115, 31 ], [ 97, 32 ], [ 84, 34 ], [ 103, 36 ], [ 81, 38 ], [ 103, 41 ], [ 90, 45 ], [ 112, 48 ], [ 88, 49 ], [ 82, 51 ], [ 85, 52 ], [ 105, 54 ], [ 88, 56 ], [ 108, 58 ], [ 88, 61 ], [ 93, 65 ], [ 112, 68 ], [ 103, 69 ], [ 109, 71 ], [ 106, 72 ], [ 100, 77 ], [ 91, 78 ], [ 94, 79 ], [ 81, 82 ], [ 84, 85 ], [ 111, 88 ], [ 90, 91 ], [ 93, 94 ], [ 96, 97 ], [ 99, 100 ], [ 111, 103 ], [ 105, 106 ], [ 108, 109 ], [ 111, 112 ], [ 114, 115 ] ]

[ "a, b, c = map(int, input().split())\na1, a2 = a//2, (a+1)//2\nx = b*c*(a2-a1)\nb1, b2 = b//2, (b+1)//2\ny = a*c*(b2-b1)\nc1, c2 = c//2, (c+1)//2\nz = a*b*(c2-c1)\nprint(min(x, y, z))", "a, b, c = map(int, input().split())", "a", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "c", "a1, a2 = a//2, (a+1)//2", "a1", "a//2", "a", "2", "a2", "(a+1)//2", "a+1", "a", "1", "2", "x = b*c*(a2-a1)", "x", "b*c*(a2-a1)", "b*c", "b", "c", "a2-a1", "a2", "a1", "b1, b2 = b//2, (b+1)//2", "b1", "b//2", "b", "2", "b2", "(b+1)//2", "b+1", "b", "1", "2", "y = a*c*(b2-b1)", "y", "a*c*(b2-b1)", "a*c", "a", "c", "b2-b1", "b2", "b1", "c1, c2 = c//2, (c+1)//2", "c1", "c//2", "c", "2", "c2", "(c+1)//2", "c+1", "c", "1", "2", "z = a*b*(c2-c1)", "z", "a*b*(c2-c1)", "a*b", "a", "b", "c2-c1", "c2", "c1", "print(min(x, y, z))", "print", "min(x, y, z)", "min", "x", "y", "z", "b2 = b//2, (b+1)//2", "(b+1)//2", "b2", "b1, b2 = b//2, (b+1)//2", "b//2", "b1", "c = map(int, input().split())", "map(int, input().split())", "c", "y = a*c*(b2-b1)", "a*c*(b2-b1)", "y", "z = a*b*(c2-c1)", "a*b*(c2-c1)", "z", "a1, a2 = a//2, (a+1)//2", "a//2", "a1", "x = b*c*(a2-a1)", "b*c*(a2-a1)", "x", "b, c = map(int, input().split())", "map(int, input().split())", "b", "c1, c2 = c//2, (c+1)//2", "c//2", "c1", "c2 = c//2, (c+1)//2", "(c+1)//2", "c2", "a, b, c = map(int, input().split())", "map(int, input().split())", "a", "a2 = a//2, (a+1)//2", "(a+1)//2", "a2" ]

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

[ [ 68, 2 ], [ 68, 12 ], [ 68, 13 ], [ 62, 15 ], [ 59, 21 ], [ 63, 24 ], [ 66, 30 ], [ 69, 35 ], [ 57, 40 ], [ 60, 47 ], [ 60, 50 ], [ 68, 57 ], [ 59, 60 ], [ 62, 63 ], [ 68, 66 ], [ 68, 69 ] ]

[ "A,B,C = map(int,input().split(' '))\nnum_list = [A,B,C]\nlist_s = sorted(num_list)\nif A % 2 == 1 and B % 2 == 1 and C % 2 == 1:\n print(list_s[0]*list_s[1])\nelse:\n print(0)", "A,B,C = map(int,input().split(' '))", "A", "map(int,input().split(' '))", "map", "int", "input().split(' ')", "().split", "()", "input", "split", "' '", "B", "C", "num_list = [A,B,C]", "num_list", "[A,B,C]", "A", "B", "C", "list_s = sorted(num_list)", "list_s", "sorted(num_list)", "sorted", "num_list", "if A % 2 == 1 and B % 2 == 1 and C % 2 == 1:\n print(list_s[0]*list_s[1])\nelse:\n print(0)", "A % 2 == 1 and B % 2 == 1 and C % 2 == 1", "A % 2 == 1 and B % 2 == 1", "A % 2 == 1", "A % 2", "A", "2", "1", "B % 2 == 1", "B % 2", "B", "2", "1", "C % 2 == 1", "C % 2", "C", "2", "1", "print(list_s[0]*list_s[1])", "print", "list_s[0]*list_s[1]", "list_s[0]", "list_s", "0", "list_s[1]", "list_s", "1", "print(0)", "print", "0", "C = map(int,input().split(' '))", "map(int,input().split(' '))", "C", "list_s = sorted(num_list)", "sorted(num_list)", "list_s", "num_list = [A,B,C]", "[A,B,C]", "num_list", "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, 4, 13, 4, 13, 4, 13, 2, 13, 13, 2, 13, 13, 2, 13, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 48, 2 ], [ 48, 11 ], [ 48, 12 ], [ 43, 18 ], [ 46, 19 ], [ 49, 20 ], [ 43, 33 ], [ 46, 34 ], [ 46, 36 ], [ 49, 37 ], [ 43, 39 ], [ 49, 40 ], [ 48, 43 ], [ 48, 46 ], [ 48, 49 ] ]

[ "#!/usr/bin/env python\n\na, b, c = map(int, input().split())\n\nif a*b*c%2 == 0:\n print(0)\n exit()\n\nprint(min(a*b, b*c, a*c)) ", "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)\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", "print(min(a*b, b*c, a*c))", "print", "min(a*b, b*c, a*c)", "min", "a*b", "a", "b", "b*c", "b", "c", "a*c", "a", "c", "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, 2, 2, 13, 17, 17, 2, 2, 13, 17, 17, 2, 2, 13, 17, 17, 4, 13, 17, 4, 13, 0, 13, 4, 13, 13, 13, 13, 0, 13, 2, 13, 17, 0, 13, 2, 13, 13, 14, 2, 13, 13, 4, 13, 2, 2, 2, 13, 13, 13, 13, 4, 13, 14, 2, 13, 13, 4, 13, 2, 2, 2, 13, 13, 13, 13, 4, 13, 14, 2, 13, 13, 4, 13, 2, 2, 2, 13, 13, 13, 13, 4, 13, 10, 4, 13, 10, 4, 13, 10, 2, 13, 10, 4, 13, 10, 2, 13, 10, 4, 13 ]

[ [ 114, 2 ], [ 114, 11 ], [ 114, 12 ], [ 100, 18 ], [ 109, 23 ], [ 109, 28 ], [ 102, 37 ], [ 100, 40 ], [ 109, 41 ], [ 115, 42 ], [ 105, 44 ], [ 103, 46 ], [ 111, 49 ], [ 103, 51 ], [ 106, 52 ], [ 103, 55 ], [ 100, 56 ], [ 112, 62 ], [ 106, 63 ], [ 109, 64 ], [ 115, 65 ], [ 103, 70 ], [ 109, 71 ], [ 112, 77 ], [ 106, 78 ], [ 100, 79 ], [ 115, 80 ], [ 103, 85 ], [ 115, 86 ], [ 112, 92 ], [ 106, 93 ], [ 100, 94 ], [ 109, 95 ], [ 114, 100 ], [ 102, 103 ], [ 105, 106 ], [ 114, 109 ], [ 111, 112 ], [ 114, 115 ] ]

[ "a,b,c = map(int,input().split())\n#a,b,cの中に偶数があれば0, 無かったら最大の数を半分にした数\nif a%2 == 0 or b%2 == 0 or b%2 == 0:\n print(0)\n exit()\n\nmax_num = max(a,b,c)\nnum = max_num//2\nnum2 = max_num - num\n\nif max_num == a:\n print((num2- num)*b*c)\n exit()\nif max_num == b:\n print((num2 - num)*a*c)\n exit()\nif max_num == c:\n print((num2 - num)*a*b)\n exit()", "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 b%2 == 0:\n print(0)\n exit()", "a%2 == 0 or b%2 == 0 or b%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", "b%2 == 0", "b%2", "b", "2", "0", "print(0)", "print", "0", "exit()", "exit", "max_num = max(a,b,c)", "max_num", "max(a,b,c)", "max", "a", "b", "c", "num = max_num//2", "num", "max_num//2", "max_num", "2", "num2 = max_num - num", "num2", "max_num - num", "max_num", "num", "if max_num == a:\n print((num2- num)*b*c)\n exit()", "max_num == a", "max_num", "a", "print((num2- num)*b*c)", "print", "(num2- num)*b*c", "(num2- num)*b", "num2- num", "num2", "num", "b", "c", "exit()", "exit", "if max_num == b:\n print((num2 - num)*a*c)\n exit()", "max_num == b", "max_num", "b", "print((num2 - num)*a*c)", "print", "(num2 - num)*a*c", "(num2 - num)*a", "num2 - num", "num2", "num", "a", "c", "exit()", "exit", "if max_num == c:\n print((num2 - num)*a*b)\n exit()", "max_num == c", "max_num", "c", "print((num2 - num)*a*b)", "print", "(num2 - num)*a*b", "(num2 - num)*a", "num2 - num", "num2", "num", "a", "b", "exit()", "exit", "a,b,c = map(int,input().split())", "map(int,input().split())", "a", "max_num = max(a,b,c)", "max(a,b,c)", "max_num", "num = max_num//2", "max_num//2", "num", "b,c = map(int,input().split())", "map(int,input().split())", "b", "num2 = max_num - num", "max_num - num", "num2", "c = map(int,input().split())", "map(int,input().split())", "c" ]

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

[ [ 40, 2 ], [ 37, 16 ], [ 41, 19 ], [ 41, 22 ], [ 26, 25 ], [ 41, 25 ], [ 25, 30 ], [ 38, 35 ], [ 37, 38 ], [ 40, 41 ] ]

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