#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int atoi(char *);
int /*<<< orphan*/ printf(char *, int);
int /*<<< orphan*/ *strdup(char const *);
char *strtok(int /*<<< orphan*/ *, char *);
int main(int argc, char *argv[]) {
  const char *input =
      "08 02 22 97 38 15 00 40 00 75 04 05 07 78 52 12 50 77 91 08 "
      "49 49 99 40 17 81 18 57 60 87 17 40 98 43 69 48 04 56 62 00 "
      "81 49 31 73 55 79 14 29 93 71 40 67 53 88 30 03 49 13 36 65 "
      "52 70 95 23 04 60 11 42 69 24 68 56 01 32 56 71 37 02 36 91 "
      "22 31 16 71 51 67 63 89 41 92 36 54 22 40 40 28 66 33 13 80 "
      "24 47 32 60 99 03 45 02 44 75 33 53 78 36 84 20 35 17 12 50 "
      "32 98 81 28 64 23 67 10 26 38 40 67 59 54 70 66 18 38 64 70 "
      "67 26 20 68 02 62 12 20 95 63 94 39 63 08 40 91 66 49 94 21 "
      "24 55 58 05 66 73 99 26 97 17 78 78 96 83 14 88 34 89 63 72 "
      "21 36 23 09 75 00 76 44 20 45 35 14 00 61 33 97 34 31 33 95 "
      "78 17 53 28 22 75 31 67 15 94 03 80 04 62 16 14 09 53 56 92 "
      "16 39 05 42 96 35 31 47 55 58 88 24 00 17 54 24 36 29 85 57 "
      "86 56 00 48 35 71 89 07 05 44 44 37 44 60 21 58 51 54 17 58 "
      "19 80 81 68 05 94 47 69 28 73 92 13 86 52 17 77 04 89 55 40 "
      "04 52 08 83 97 35 99 16 07 97 57 32 16 26 26 79 33 27 98 66 "
      "88 36 68 87 57 62 20 72 03 46 33 67 46 55 12 32 63 93 53 69 "
      "04 42 16 73 38 25 39 11 24 94 72 18 08 46 29 32 40 62 76 36 "
      "20 69 36 41 72 30 23 88 34 62 99 69 82 67 59 85 74 04 36 16 "
      "20 73 35 29 78 31 90 01 74 31 49 71 48 86 81 16 23 57 05 54 "
      "01 70 54 71 83 51 54 69 16 92 33 48 61 43 52 01 89 19 67 48 ";
  int nums[20][20];
  char *next = strtok(strdup(input), " ");
  int i = 0;
  int j = 0;
  while (next != NULL) {
    nums[i][j] = atoi(next);
    j++;
    if (j % 20 == 0) {
      j = 0;
      i++;
    }
    next = strtok(NULL, " ");
  }
  int max = 0;
  for (i = 0; i < 20; i++) {
    for (j = 0; j < 20; j++) {
      if (i > 3) {
        int x = nums[i][j] * nums[i - 1][j] * nums[i - 2][j] * nums[i - 3][j];
        max = (x > max) ? x : max;
      }
      if (i > 3 && j > 3) {
        int x = nums[i][j] * nums[i - 1][j - 1] * nums[i - 2][j - 2] *
                nums[i - 3][j - 3];
        max = (x > max) ? x : max;
      }
      if (i > 3 && j < 17) {
        int x = nums[i][j] * nums[i - 1][j + 1] * nums[i - 2][j + 2] *
                nums[i - 3][j + 3];
        max = (x > max) ? x : max;
      }
      if (j > 3) {
        int x = nums[i][j] * nums[i][j - 1] * nums[i][j - 2] * nums[i][j - 3];
        max = (x > max) ? x : max;
      }
      if (j < 17) {
        int x = nums[i][j] * nums[i][j + 1] * nums[i][j + 2] * nums[i][j + 3];
        max = (x > max) ? x : max;
      }
      if (i < 17) {
        int x = nums[i][j] * nums[i + 1][j] * nums[i + 2][j] * nums[i + 3][j];
        max = (x > max) ? x : max;
      }
      if (i < 17 && j > 3) {
        int x = nums[i][j] * nums[i + 1][j - 1] * nums[i + 2][j - 2] *
                nums[i + 3][j - 3];
        max = (x > max) ? x : max;
      }
      if (i < 17 && j < 17) {
        int x = nums[i][j] * nums[i + 1][j + 1] * nums[i + 2][j + 2] *
                nums[i + 3][j + 3];
        max = (x > max) ? x : max;
      }
    }
  }
  printf("%i", max);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x6c0,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
lea    0xea0(%rip),%rax
mov    %rax,-0x18(%rbp)
mov    -0x18(%rbp),%rdi
call   1060 <strdup@plt>
mov    %rax,%rdi
lea    0x1338(%rip),%rsi
call   1040 <strtok@plt>
mov    %rax,-0x668(%rbp)
movl   $0x0,-0x66c(%rbp)
movl   $0x0,-0x670(%rbp)
cmpq   $0x0,-0x668(%rbp)
je     122d <main+0xed>
mov    -0x668(%rbp),%rdi
call   1050 <atoi@plt>
mov    %eax,%edx
movslq -0x66c(%rbp),%rcx
lea    -0x660(%rbp),%rax
imul   $0x50,%rcx,%rcx
add    %rcx,%rax
movslq -0x670(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x670(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x670(%rbp)
mov    -0x670(%rbp),%eax
mov    $0x14,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    1211 <main+0xd1>
movl   $0x0,-0x670(%rbp)
mov    -0x66c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x66c(%rbp)
xor    %eax,%eax
mov    %eax,%edi
lea    0x1293(%rip),%rsi
call   1040 <strtok@plt>
mov    %rax,-0x668(%rbp)
jmp    1197 <main+0x57>
movl   $0x0,-0x674(%rbp)
movl   $0x0,-0x66c(%rbp)
cmpl   $0x14,-0x66c(%rbp)
jge    19e7 <main+0x8a7>
movl   $0x0,-0x670(%rbp)
cmpl   $0x14,-0x670(%rbp)
jge    19ce <main+0x88e>
cmpl   $0x3,-0x66c(%rbp)
jle    1341 <main+0x201>
movslq -0x66c(%rbp),%rcx
lea    -0x660(%rbp),%rax
imul   $0x50,%rcx,%rcx
add    %rcx,%rax
movslq -0x670(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x66c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rdx
lea    -0x660(%rbp),%rcx
imul   $0x50,%rdx,%rdx
add    %rdx,%rcx
movslq -0x670(%rbp),%rdx
imul   (%rcx,%rdx,4),%eax
mov    -0x66c(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rdx
lea    -0x660(%rbp),%rcx
imul   $0x50,%rdx,%rdx
add    %rdx,%rcx
movslq -0x670(%rbp),%rdx
imul   (%rcx,%rdx,4),%eax
mov    -0x66c(%rbp),%ecx
sub    $0x3,%ecx
movslq %ecx,%rdx
lea    -0x660(%rbp),%rcx
imul   $0x50,%rdx,%rdx
add    %rdx,%rcx
movslq -0x670(%rbp),%rdx
imul   (%rcx,%rdx,4),%eax
mov    %eax,-0x678(%rbp)
mov    -0x678(%rbp),%eax
cmp    -0x674(%rbp),%eax
jle    1329 <main+0x1e9>
mov    -0x678(%rbp),%eax
mov    %eax,-0x698(%rbp)
jmp    1335 <main+0x1f5>
mov    -0x674(%rbp),%eax
mov    %eax,-0x698(%rbp)
mov    -0x698(%rbp),%eax
mov    %eax,-0x674(%rbp)
cmpl   $0x3,-0x66c(%rbp)
jle    1439 <main+0x2f9>
cmpl   $0x3,-0x670(%rbp)
jle    1439 <main+0x2f9>
movslq -0x66c(%rbp),%rcx
lea    -0x660(%rbp),%rax
imul   $0x50,%rcx,%rcx
add    %rcx,%rax
movslq -0x670(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x66c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rdx
lea    -0x660(%rbp),%rcx
imul   $0x50,%rdx,%rdx
add    %rdx,%rcx
mov    -0x670(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
imul   (%rcx,%rdx,4),%eax
mov    -0x66c(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rdx
lea    -0x660(%rbp),%rcx
imul   $0x50,%rdx,%rdx
add    %rdx,%rcx
mov    -0x670(%rbp),%edx
sub    $0x2,%edx
movslq %edx,%rdx
imul   (%rcx,%rdx,4),%eax
mov    -0x66c(%rbp),%ecx
sub    $0x3,%ecx
movslq %ecx,%rdx
lea    -0x660(%rbp),%rcx
imul   $0x50,%rdx,%rdx
add    %rdx,%rcx
mov    -0x670(%rbp),%edx
sub    $0x3,%edx
movslq %edx,%rdx
imul   (%rcx,%rdx,4),%eax
mov    %eax,-0x67c(%rbp)
mov    -0x67c(%rbp),%eax
cmp    -0x674(%rbp),%eax
jle    1421 <main+0x2e1>
mov    -0x67c(%rbp),%eax
mov    %eax,-0x69c(%rbp)
jmp    142d <main+0x2ed>
mov    -0x674(%rbp),%eax
mov    %eax,-0x69c(%rbp)
mov    -0x69c(%rbp),%eax
mov    %eax,-0x674(%rbp)
cmpl   $0x3,-0x66c(%rbp)
jle    1531 <main+0x3f1>
cmpl   $0x11,-0x670(%rbp)
jge    1531 <main+0x3f1>
movslq -0x66c(%rbp),%rcx
lea    -0x660(%rbp),%rax
imul   $0x50,%rcx,%rcx
add    %rcx,%rax
movslq -0x670(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x66c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rdx
lea    -0x660(%rbp),%rcx
imul   $0x50,%rdx,%rdx
add    %rdx,%rcx
mov    -0x670(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
imul   (%rcx,%rdx,4),%eax
mov    -0x66c(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rdx
lea    -0x660(%rbp),%rcx
imul   $0x50,%rdx,%rdx
add    %rdx,%rcx
mov    -0x670(%rbp),%edx
add    $0x2,%edx
movslq %edx,%rdx
imul   (%rcx,%rdx,4),%eax
mov    -0x66c(%rbp),%ecx
sub    $0x3,%ecx
movslq %ecx,%rdx
lea    -0x660(%rbp),%rcx
imul   $0x50,%rdx,%rdx
add    %rdx,%rcx
mov    -0x670(%rbp),%edx
add    $0x3,%edx
movslq %edx,%rdx
imul   (%rcx,%rdx,4),%eax
mov    %eax,-0x680(%rbp)
mov    -0x680(%rbp),%eax
cmp    -0x674(%rbp),%eax
jle    1519 <main+0x3d9>
mov    -0x680(%rbp),%eax
mov    %eax,-0x6a0(%rbp)
jmp    1525 <main+0x3e5>
mov    -0x674(%rbp),%eax
mov    %eax,-0x6a0(%rbp)
mov    -0x6a0(%rbp),%eax
mov    %eax,-0x674(%rbp)
cmpl   $0x3,-0x670(%rbp)
jle    160d <main+0x4cd>
movslq -0x66c(%rbp),%rcx
lea    -0x660(%rbp),%rax
imul   $0x50,%rcx,%rcx
add    %rcx,%rax
movslq -0x670(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
movslq -0x66c(%rbp),%rdx
lea    -0x660(%rbp),%rcx
imul   $0x50,%rdx,%rdx
add    %rdx,%rcx
mov    -0x670(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
imul   (%rcx,%rdx,4),%eax
movslq -0x66c(%rbp),%rdx
lea    -0x660(%rbp),%rcx
imul   $0x50,%rdx,%rdx
add    %rdx,%rcx
mov    -0x670(%rbp),%edx
sub    $0x2,%edx
movslq %edx,%rdx
imul   (%rcx,%rdx,4),%eax
movslq -0x66c(%rbp),%rdx
lea    -0x660(%rbp),%rcx
imul   $0x50,%rdx,%rdx
add    %rdx,%rcx
mov    -0x670(%rbp),%edx
sub    $0x3,%edx
movslq %edx,%rdx
imul   (%rcx,%rdx,4),%eax
mov    %eax,-0x684(%rbp)
mov    -0x684(%rbp),%eax
cmp    -0x674(%rbp),%eax
jle    15f5 <main+0x4b5>
mov    -0x684(%rbp),%eax
mov    %eax,-0x6a4(%rbp)
jmp    1601 <main+0x4c1>
mov    -0x674(%rbp),%eax
mov    %eax,-0x6a4(%rbp)
mov    -0x6a4(%rbp),%eax
mov    %eax,-0x674(%rbp)
cmpl   $0x11,-0x670(%rbp)
jge    16e9 <main+0x5a9>
movslq -0x66c(%rbp),%rcx
lea    -0x660(%rbp),%rax
imul   $0x50,%rcx,%rcx
add    %rcx,%rax
movslq -0x670(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
movslq -0x66c(%rbp),%rdx
lea    -0x660(%rbp),%rcx
imul   $0x50,%rdx,%rdx
add    %rdx,%rcx
mov    -0x670(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
imul   (%rcx,%rdx,4),%eax
movslq -0x66c(%rbp),%rdx
lea    -0x660(%rbp),%rcx
imul   $0x50,%rdx,%rdx
add    %rdx,%rcx
mov    -0x670(%rbp),%edx
add    $0x2,%edx
movslq %edx,%rdx
imul   (%rcx,%rdx,4),%eax
movslq -0x66c(%rbp),%rdx
lea    -0x660(%rbp),%rcx
imul   $0x50,%rdx,%rdx
add    %rdx,%rcx
mov    -0x670(%rbp),%edx
add    $0x3,%edx
movslq %edx,%rdx
imul   (%rcx,%rdx,4),%eax
mov    %eax,-0x688(%rbp)
mov    -0x688(%rbp),%eax
cmp    -0x674(%rbp),%eax
jle    16d1 <main+0x591>
mov    -0x688(%rbp),%eax
mov    %eax,-0x6a8(%rbp)
jmp    16dd <main+0x59d>
mov    -0x674(%rbp),%eax
mov    %eax,-0x6a8(%rbp)
mov    -0x6a8(%rbp),%eax
mov    %eax,-0x674(%rbp)
cmpl   $0x11,-0x66c(%rbp)
jge    17c5 <main+0x685>
movslq -0x66c(%rbp),%rcx
lea    -0x660(%rbp),%rax
imul   $0x50,%rcx,%rcx
add    %rcx,%rax
movslq -0x670(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x66c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rdx
lea    -0x660(%rbp),%rcx
imul   $0x50,%rdx,%rdx
add    %rdx,%rcx
movslq -0x670(%rbp),%rdx
imul   (%rcx,%rdx,4),%eax
mov    -0x66c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rdx
lea    -0x660(%rbp),%rcx
imul   $0x50,%rdx,%rdx
add    %rdx,%rcx
movslq -0x670(%rbp),%rdx
imul   (%rcx,%rdx,4),%eax
mov    -0x66c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rdx
lea    -0x660(%rbp),%rcx
imul   $0x50,%rdx,%rdx
add    %rdx,%rcx
movslq -0x670(%rbp),%rdx
imul   (%rcx,%rdx,4),%eax
mov    %eax,-0x68c(%rbp)
mov    -0x68c(%rbp),%eax
cmp    -0x674(%rbp),%eax
jle    17ad <main+0x66d>
mov    -0x68c(%rbp),%eax
mov    %eax,-0x6ac(%rbp)
jmp    17b9 <main+0x679>
mov    -0x674(%rbp),%eax
mov    %eax,-0x6ac(%rbp)
mov    -0x6ac(%rbp),%eax
mov    %eax,-0x674(%rbp)
cmpl   $0x11,-0x66c(%rbp)
jge    18bd <main+0x77d>
cmpl   $0x3,-0x670(%rbp)
jle    18bd <main+0x77d>
movslq -0x66c(%rbp),%rcx
lea    -0x660(%rbp),%rax
imul   $0x50,%rcx,%rcx
add    %rcx,%rax
movslq -0x670(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x66c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rdx
lea    -0x660(%rbp),%rcx
imul   $0x50,%rdx,%rdx
add    %rdx,%rcx
mov    -0x670(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
imul   (%rcx,%rdx,4),%eax
mov    -0x66c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rdx
lea    -0x660(%rbp),%rcx
imul   $0x50,%rdx,%rdx
add    %rdx,%rcx
mov    -0x670(%rbp),%edx
sub    $0x2,%edx
movslq %edx,%rdx
imul   (%rcx,%rdx,4),%eax
mov    -0x66c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rdx
lea    -0x660(%rbp),%rcx
imul   $0x50,%rdx,%rdx
add    %rdx,%rcx
mov    -0x670(%rbp),%edx
sub    $0x3,%edx
movslq %edx,%rdx
imul   (%rcx,%rdx,4),%eax
mov    %eax,-0x690(%rbp)
mov    -0x690(%rbp),%eax
cmp    -0x674(%rbp),%eax
jle    18a5 <main+0x765>
mov    -0x690(%rbp),%eax
mov    %eax,-0x6b0(%rbp)
jmp    18b1 <main+0x771>
mov    -0x674(%rbp),%eax
mov    %eax,-0x6b0(%rbp)
mov    -0x6b0(%rbp),%eax
mov    %eax,-0x674(%rbp)
cmpl   $0x11,-0x66c(%rbp)
jge    19b5 <main+0x875>
cmpl   $0x11,-0x670(%rbp)
jge    19b5 <main+0x875>
movslq -0x66c(%rbp),%rcx
lea    -0x660(%rbp),%rax
imul   $0x50,%rcx,%rcx
add    %rcx,%rax
movslq -0x670(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x66c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rdx
lea    -0x660(%rbp),%rcx
imul   $0x50,%rdx,%rdx
add    %rdx,%rcx
mov    -0x670(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
imul   (%rcx,%rdx,4),%eax
mov    -0x66c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rdx
lea    -0x660(%rbp),%rcx
imul   $0x50,%rdx,%rdx
add    %rdx,%rcx
mov    -0x670(%rbp),%edx
add    $0x2,%edx
movslq %edx,%rdx
imul   (%rcx,%rdx,4),%eax
mov    -0x66c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rdx
lea    -0x660(%rbp),%rcx
imul   $0x50,%rdx,%rdx
add    %rdx,%rcx
mov    -0x670(%rbp),%edx
add    $0x3,%edx
movslq %edx,%rdx
imul   (%rcx,%rdx,4),%eax
mov    %eax,-0x694(%rbp)
mov    -0x694(%rbp),%eax
cmp    -0x674(%rbp),%eax
jle    199d <main+0x85d>
mov    -0x694(%rbp),%eax
mov    %eax,-0x6b4(%rbp)
jmp    19a9 <main+0x869>
mov    -0x674(%rbp),%eax
mov    %eax,-0x6b4(%rbp)
mov    -0x6b4(%rbp),%eax
mov    %eax,-0x674(%rbp)
jmp    19ba <main+0x87a>
mov    -0x670(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x670(%rbp)
jmp    1258 <main+0x118>
jmp    19d3 <main+0x893>
mov    -0x66c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x66c(%rbp)
jmp    1241 <main+0x101>
mov    -0x674(%rbp),%esi
lea    0xabd(%rip),%rdi
call   1030 <printf@plt>
xor    %eax,%eax
add    $0x6c0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x688,%rsp
lea    0xea8(%rip),%rdi
call   1060 <strdup@plt>
lea    0x134b(%rip),%rsi
mov    %rax,%rdi
call   1040 <strtok@plt>
test   %rax,%rax
je     11cb <main+0x8b>
xor    %r14d,%r14d
lea    0x1334(%rip),%r15
xor    %ebp,%ebp
xor    %ebx,%ebx
nop
mov    %rax,%rdi
call   1050 <atoi@plt>
mov    %ebp,%ecx
movslq %ebx,%rbx
lea    (%rcx,%rcx,4),%rcx
shl    $0x4,%rcx
add    %rsp,%rcx
add    $0x40,%rcx
mov    %eax,(%rcx,%rbx,4)
add    $0x1,%ebx
imul   $0xcccccccd,%ebx,%eax
add    $0x19999998,%eax
ror    $0x2,%eax
cmp    $0xccccccd,%eax
cmovb  %r14d,%ebx
adc    $0x0,%ebp
xor    %edi,%edi
mov    %r15,%rsi
call   1040 <strtok@plt>
test   %rax,%rax
jne    1180 <main+0x40>
xor    %r13d,%r13d
lea    0x40(%rsp),%rdx
mov    $0xffffffff,%ecx
mov    $0xfffffffe,%esi
mov    $0xfffffffd,%edi
xor    %eax,%eax
jmp    121b <main+0xdb>
cs nopw 0x0(%rax,%rax,1)
add    $0x50,%rdx
mov    0xc(%rsp),%ecx
add    $0x1,%ecx
mov    0x8(%rsp),%esi
add    $0x1,%esi
mov    0x4(%rsp),%edi
add    $0x1,%edi
mov    0x10(%rsp),%rbp
mov    %rbp,%r13
cmp    $0x14,%rbp
je     14e9 <main+0x3a9>
mov    %ecx,0xc(%rsp)
mov    %ecx,%ecx
lea    (%rcx,%rcx,4),%r10
shl    $0x4,%r10
lea    0x44(%rsp),%rcx
add    %rcx,%r10
mov    %esi,0x8(%rsp)
mov    %esi,%ecx
lea    (%rcx,%rcx,4),%r15
shl    $0x4,%r15
lea    0x48(%rsp),%rcx
add    %rcx,%r15
mov    %edi,0x4(%rsp)
mov    %edi,%esi
lea    (%rsi,%rsi,4),%rsi
shl    $0x4,%rsi
lea    (%rsp,%rsi,1),%r8
add    $0x40,%r8
mov    $0xfffffffe,%ecx
lea    0x1(%rcx,%r13,1),%esi
mov    %rsi,0x38(%rsp)
lea    (%rcx,%r13,1),%esi
mov    %rsi,0x30(%rsp)
lea    -0x1(%rcx,%r13,1),%ecx
mov    %rcx,0x28(%rsp)
lea    0x1(%r13),%rcx
mov    %rcx,0x10(%rsp)
lea    0x2(%r13),%rcx
mov    %rcx,0x20(%rsp)
lea    0x3(%r13),%rcx
mov    %rcx,0x18(%rsp)
xor    %r11d,%r11d
jmp    12b0 <main+0x170>
nop
mov    %ebp,%eax
add    $0x1,%r11
cmp    $0x14,%r11
je     11f0 <main+0xb0>
cmp    $0x3,%r13
jbe    1370 <main+0x230>
mov    (%rdx,%r11,4),%r14d
mov    -0x4(%r10,%r11,4),%esi
imul   %r14d,%esi
imul   -0x8(%r15,%r11,4),%esi
imul   (%r8,%r11,4),%esi
cmp    %eax,%esi
jg     12d8 <main+0x198>
mov    %eax,%esi
cmp    $0x4,%r11
jb     1348 <main+0x208>
mov    $0xfffffffe,%eax
lea    (%r11,%rax,1),%rbp
lea    0x1(%rbp),%eax
mov    0x38(%rsp),%rcx
lea    (%rcx,%rcx,4),%rbx
shl    $0x4,%rbx
add    %rsp,%rbx
add    $0x40,%rbx
mov    (%rbx,%rax,4),%eax
imul   %r14d,%eax
mov    %ebp,%ebx
mov    0x30(%rsp),%rcx
lea    (%rcx,%rcx,4),%rcx
shl    $0x4,%rcx
add    %rsp,%rcx
add    $0x40,%rcx
imul   (%rcx,%rbx,4),%eax
add    $0xffffffff,%ebp
mov    0x28(%rsp),%rcx
lea    (%rcx,%rcx,4),%rcx
shl    $0x4,%rcx
add    %rsp,%rcx
add    $0x40,%rcx
imul   (%rcx,%rbp,4),%eax
cmp    %esi,%eax
jg     1340 <main+0x200>
mov    %esi,%eax
cmp    $0x10,%r11
ja     139b <main+0x25b>
mov    %eax,%esi
mov    (%r10,%r11,4),%eax
imul   %r14d,%eax
imul   (%r15,%r11,4),%eax
imul   0xc(%r8,%r11,4),%eax
cmp    %esi,%eax
jg     1361 <main+0x221>
mov    %esi,%eax
mov    $0x1,%bpl
cmp    $0x4,%r11
jb     1390 <main+0x250>
jmp    139d <main+0x25d>
nopl   0x0(%rax)
cmp    $0x4,%r11
jb     1390 <main+0x250>
cmp    $0x11,%r11
setb   %bpl
mov    (%rdx,%r11,4),%r14d
jmp    139d <main+0x25d>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    (%rdx,%r11,4),%r14d
xor    %r9d,%r9d
mov    %eax,%esi
jmp    13e0 <main+0x2a0>
xor    %ebp,%ebp
mov    $0xfffffffe,%ecx
add    %r11,%rcx
lea    0x1(%rcx),%esi
lea    0x0(,%r13,4),%rbx
add    %r13,%rbx
shl    $0x4,%rbx
add    %rsp,%rbx
add    $0x40,%rbx
mov    (%rbx,%rsi,4),%esi
imul   %r14d,%esi
mov    %ecx,%edi
imul   (%rbx,%rdi,4),%esi
add    $0xffffffff,%ecx
imul   (%rbx,%rcx,4),%esi
cmp    %eax,%esi
jg     13d8 <main+0x298>
mov    %eax,%esi
mov    $0x1,%r9b
test   %bpl,%bpl
je     1440 <main+0x300>
imul   0x4(%rdx,%r11,4),%r14d
imul   0x8(%rdx,%r11,4),%r14d
imul   0xc(%rdx,%r11,4),%r14d
cmp    %esi,%r14d
jg     13fa <main+0x2ba>
mov    %esi,%r14d
mov    $0x1,%r12b
mov    %r14d,%esi
cmp    $0x10,%r13
ja     1449 <main+0x309>
mov    (%rdx,%r11,4),%ebp
mov    0x50(%rdx,%r11,4),%eax
imul   %ebp,%eax
imul   0xa0(%rdx,%r11,4),%eax
imul   0xf0(%rdx,%r11,4),%eax
cmp    %esi,%eax
jle    1450 <main+0x310>
test   %r9b,%r9b
jne    1457 <main+0x317>
test   %r12b,%r12b
je     12a2 <main+0x162>
jmp    14c2 <main+0x382>
nopl   0x0(%rax,%rax,1)
xor    %r12d,%r12d
cmp    $0x10,%r13
jbe    1406 <main+0x2c6>
mov    %esi,%eax
jmp    12a2 <main+0x162>
mov    %esi,%eax
test   %r9b,%r9b
je     142d <main+0x2ed>
mov    $0xfffffffe,%ecx
add    %r11,%rcx
lea    0x1(%rcx),%esi
mov    0x10(%rsp),%rdi
lea    (%rdi,%rdi,4),%rdi
shl    $0x4,%rdi
add    %rsp,%rdi
add    $0x40,%rdi
mov    (%rdi,%rsi,4),%esi
imul   %ebp,%esi
mov    %ecx,%edi
mov    0x20(%rsp),%rbx
lea    (%rbx,%rbx,4),%rbx
shl    $0x4,%rbx
add    %rsp,%rbx
add    $0x40,%rbx
imul   (%rbx,%rdi,4),%esi
add    $0xffffffff,%ecx
mov    0x18(%rsp),%rdi
lea    (%rdi,%rdi,4),%rdi
shl    $0x4,%rdi
add    %rsp,%rdi
add    $0x40,%rdi
imul   (%rdi,%rcx,4),%esi
cmp    %eax,%esi
jg     14b7 <main+0x377>
mov    %eax,%esi
mov    %esi,%eax
test   %r12b,%r12b
je     12a2 <main+0x162>
imul   0x54(%rdx,%r11,4),%ebp
imul   0xa8(%rdx,%r11,4),%ebp
imul   0xfc(%rdx,%r11,4),%ebp
cmp    %eax,%ebp
jg     12a0 <main+0x160>
mov    %eax,%ebp
jmp    12a0 <main+0x160>
lea    0xfc1(%rip),%rdi
mov    %eax,%esi
call   1030 <printf@plt>
xor    %eax,%eax
add    $0x688,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [1201 x i8] c"08 02 22 97 38 15 00 40 00 75 04 05 07 78 52 12 50 77 91 08 49 49 99 40 17 81 18 57 60 87 17 40 98 43 69 48 04 56 62 00 81 49 31 73 55 79 14 29 93 71 40 67 53 88 30 03 49 13 36 65 52 70 95 23 04 60 11 42 69 24 68 56 01 32 56 71 37 02 36 91 22 31 16 71 51 67 63 89 41 92 36 54 22 40 40 28 66 33 13 80 24 47 32 60 99 03 45 02 44 75 33 53 78 36 84 20 35 17 12 50 32 98 81 28 64 23 67 10 26 38 40 67 59 54 70 66 18 38 64 70 67 26 20 68 02 62 12 20 95 63 94 39 63 08 40 91 66 49 94 21 24 55 58 05 66 73 99 26 97 17 78 78 96 83 14 88 34 89 63 72 21 36 23 09 75 00 76 44 20 45 35 14 00 61 33 97 34 31 33 95 78 17 53 28 22 75 31 67 15 94 03 80 04 62 16 14 09 53 56 92 16 39 05 42 96 35 31 47 55 58 88 24 00 17 54 24 36 29 85 57 86 56 00 48 35 71 89 07 05 44 44 37 44 60 21 58 51 54 17 58 19 80 81 68 05 94 47 69 28 73 92 13 86 52 17 77 04 89 55 40 04 52 08 83 97 35 99 16 07 97 57 32 16 26 26 79 33 27 98 66 88 36 68 87 57 62 20 72 03 46 33 67 46 55 12 32 63 93 53 69 04 42 16 73 38 25 39 11 24 94 72 18 08 46 29 32 40 62 76 36 20 69 36 41 72 30 23 88 34 62 99 69 82 67 59 85 74 04 36 16 20 73 35 29 78 31 90 01 74 31 49 71 48 86 81 16 23 57 05 54 01 70 54 71 83 51 54 69 16 92 33 48 61 43 52 01 89 19 67 48 \00"
@.str.1 = [2 x i8] c" \00"
@.str.2 = [3 x i8] c"%i\00"
define i32 @main(i32 %0, i8** %1) {
%3 = alloca i32
%4 = alloca i32
%5 = alloca i8**
%6 = alloca i8*
%7 = alloca [20 x [20 x i32]]
%8 = alloca i8*
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
store i32 0, i32* %3
store i32 %0, i32* %4
store i8** %1, i8*** %5
store i8* getelementptr inbounds ([1201 x i8], [1201 x i8]* @.str, i64 0, i64 0), i8** %6
%20 = load i8*, i8** %6
%21 = call i32* @strdup(i8* %20)
%22 = call i8* @strtok(i32* %21, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
store i8* %22, i8** %8
store i32 0, i32* %9
store i32 0, i32* %10
br label %23
23: ; preds = %43, %2
%24 = load i8*, i8** %8
%25 = icmp ne i8* %24, null
br i1 %25, label %26, label %45
26: ; preds = %23
%27 = load i8*, i8** %8
%28 = call i32 @atoi(i8* %27)
%29 = load i32, i32* %9
%30 = sext i32 %29 to i64
%31 = getelementptr inbounds [20 x [20 x i32]], [20 x [20 x i32]]* %7, i64 0, i64 %30
%32 = load i32, i32* %10
%33 = sext i32 %32 to i64
%34 = getelementptr inbounds [20 x i32], [20 x i32]* %31, i64 0, i64 %33
store i32 %28, i32* %34
%35 = load i32, i32* %10
%36 = add nsw i32 %35, 1
store i32 %36, i32* %10
%37 = load i32, i32* %10
%38 = srem i32 %37, 20
%39 = icmp eq i32 %38, 0
br i1 %39, label %40, label %43
40: ; preds = %26
store i32 0, i32* %10
%41 = load i32, i32* %9
%42 = add nsw i32 %41, 1
store i32 %42, i32* %9
br label %43
43: ; preds = %40, %26
%44 = call i8* @strtok(i32* null, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
store i8* %44, i8** %8
br label %23
45: ; preds = %23
store i32 0, i32* %11
store i32 0, i32* %9
br label %46
46: ; preds = %458, %45
%47 = load i32, i32* %9
%48 = icmp slt i32 %47, 20
br i1 %48, label %49, label %461
49: ; preds = %46
store i32 0, i32* %10
br label %50
50: ; preds = %454, %49
%51 = load i32, i32* %10
%52 = icmp slt i32 %51, 20
br i1 %52, label %53, label %457
53: ; preds = %50
%54 = load i32, i32* %9
%55 = icmp sgt i32 %54, 3
br i1 %55, label %56, label %100
56: ; preds = %53
%57 = load i32, i32* %9
%58 = sext i32 %57 to i64
%59 = getelementptr inbounds [20 x [20 x i32]], [20 x [20 x i32]]* %7, i64 0, i64 %58
%60 = load i32, i32* %10
%61 = sext i32 %60 to i64
%62 = getelementptr inbounds [20 x i32], [20 x i32]* %59, i64 0, i64 %61
%63 = load i32, i32* %62
%64 = load i32, i32* %9
%65 = sub nsw i32 %64, 1
%66 = sext i32 %65 to i64
%67 = getelementptr inbounds [20 x [20 x i32]], [20 x [20 x i32]]* %7, i64 0, i64 %66
%68 = load i32, i32* %10
%69 = sext i32 %68 to i64
%70 = getelementptr inbounds [20 x i32], [20 x i32]* %67, i64 0, i64 %69
%71 = load i32, i32* %70
%72 = mul nsw i32 %63, %71
%73 = load i32, i32* %9
%74 = sub nsw i32 %73, 2
%75 = sext i32 %74 to i64
%76 = getelementptr inbounds [20 x [20 x i32]], [20 x [20 x i32]]* %7, i64 0, i64 %75
%77 = load i32, i32* %10
%78 = sext i32 %77 to i64
%79 = getelementptr inbounds [20 x i32], [20 x i32]* %76, i64 0, i64 %78
%80 = load i32, i32* %79
%81 = mul nsw i32 %72, %80
%82 = load i32, i32* %9
%83 = sub nsw i32 %82, 3
%84 = sext i32 %83 to i64
%85 = getelementptr inbounds [20 x [20 x i32]], [20 x [20 x i32]]* %7, i64 0, i64 %84
%86 = load i32, i32* %10
%87 = sext i32 %86 to i64
%88 = getelementptr inbounds [20 x i32], [20 x i32]* %85, i64 0, i64 %87
%89 = load i32, i32* %88
%90 = mul nsw i32 %81, %89
store i32 %90, i32* %12
%91 = load i32, i32* %12
%92 = load i32, i32* %11
%93 = icmp sgt i32 %91, %92
br i1 %93, label %94, label %96
94: ; preds = %56
%95 = load i32, i32* %12
br label %98
96: ; preds = %56
%97 = load i32, i32* %11
br label %98
98: ; preds = %96, %94
%99 = phi i32 [ %95, %94 ], [ %97, %96 ]
store i32 %99, i32* %11
br label %100
100: ; preds = %98, %53
%101 = load i32, i32* %9
%102 = icmp sgt i32 %101, 3
br i1 %102, label %103, label %153
103: ; preds = %100
%104 = load i32, i32* %10
%105 = icmp sgt i32 %104, 3
br i1 %105, label %106, label %153
106: ; preds = %103
%107 = load i32, i32* %9
%108 = sext i32 %107 to i64
%109 = getelementptr inbounds [20 x [20 x i32]], [20 x [20 x i32]]* %7, i64 0, i64 %108
%110 = load i32, i32* %10
%111 = sext i32 %110 to i64
%112 = getelementptr inbounds [20 x i32], [20 x i32]* %109, i64 0, i64 %111
%113 = load i32, i32* %112
%114 = load i32, i32* %9
%115 = sub nsw i32 %114, 1
%116 = sext i32 %115 to i64
%117 = getelementptr inbounds [20 x [20 x i32]], [20 x [20 x i32]]* %7, i64 0, i64 %116
%118 = load i32, i32* %10
%119 = sub nsw i32 %118, 1
%120 = sext i32 %119 to i64
%121 = getelementptr inbounds [20 x i32], [20 x i32]* %117, i64 0, i64 %120
%122 = load i32, i32* %121
%123 = mul nsw i32 %113, %122
%124 = load i32, i32* %9
%125 = sub nsw i32 %124, 2
%126 = sext i32 %125 to i64
%127 = getelementptr inbounds [20 x [20 x i32]], [20 x [20 x i32]]* %7, i64 0, i64 %126
%128 = load i32, i32* %10
%129 = sub nsw i32 %128, 2
%130 = sext i32 %129 to i64
%131 = getelementptr inbounds [20 x i32], [20 x i32]* %127, i64 0, i64 %130
%132 = load i32, i32* %131
%133 = mul nsw i32 %123, %132
%134 = load i32, i32* %9
%135 = sub nsw i32 %134, 3
%136 = sext i32 %135 to i64
%137 = getelementptr inbounds [20 x [20 x i32]], [20 x [20 x i32]]* %7, i64 0, i64 %136
%138 = load i32, i32* %10
%139 = sub nsw i32 %138, 3
%140 = sext i32 %139 to i64
%141 = getelementptr inbounds [20 x i32], [20 x i32]* %137, i64 0, i64 %140
%142 = load i32, i32* %141
%143 = mul nsw i32 %133, %142
store i32 %143, i32* %13
%144 = load i32, i32* %13
%145 = load i32, i32* %11
%146 = icmp sgt i32 %144, %145
br i1 %146, label %147, label %149
147: ; preds = %106
%148 = load i32, i32* %13
br label %151
149: ; preds = %106
%150 = load i32, i32* %11
br label %151
151: ; preds = %149, %147
%152 = phi i32 [ %148, %147 ], [ %150, %149 ]
store i32 %152, i32* %11
br label %153
153: ; preds = %151, %103, %100
%154 = load i32, i32* %9
%155 = icmp sgt i32 %154, 3
br i1 %155, label %156, label %206
156: ; preds = %153
%157 = load i32, i32* %10
%158 = icmp slt i32 %157, 17
br i1 %158, label %159, label %206
159: ; preds = %156
%160 = load i32, i32* %9
%161 = sext i32 %160 to i64
%162 = getelementptr inbounds [20 x [20 x i32]], [20 x [20 x i32]]* %7, i64 0, i64 %161
%163 = load i32, i32* %10
%164 = sext i32 %163 to i64
%165 = getelementptr inbounds [20 x i32], [20 x i32]* %162, i64 0, i64 %164
%166 = load i32, i32* %165
%167 = load i32, i32* %9
%168 = sub nsw i32 %167, 1
%169 = sext i32 %168 to i64
%170 = getelementptr inbounds [20 x [20 x i32]], [20 x [20 x i32]]* %7, i64 0, i64 %169
%171 = load i32, i32* %10
%172 = add nsw i32 %171, 1
%173 = sext i32 %172 to i64
%174 = getelementptr inbounds [20 x i32], [20 x i32]* %170, i64 0, i64 %173
%175 = load i32, i32* %174
%176 = mul nsw i32 %166, %175
%177 = load i32, i32* %9
%178 = sub nsw i32 %177, 2
%179 = sext i32 %178 to i64
%180 = getelementptr inbounds [20 x [20 x i32]], [20 x [20 x i32]]* %7, i64 0, i64 %179
%181 = load i32, i32* %10
%182 = add nsw i32 %181, 2
%183 = sext i32 %182 to i64
%184 = getelementptr inbounds [20 x i32], [20 x i32]* %180, i64 0, i64 %183
%185 = load i32, i32* %184
%186 = mul nsw i32 %176, %185
%187 = load i32, i32* %9
%188 = sub nsw i32 %187, 3
%189 = sext i32 %188 to i64
%190 = getelementptr inbounds [20 x [20 x i32]], [20 x [20 x i32]]* %7, i64 0, i64 %189
%191 = load i32, i32* %10
%192 = add nsw i32 %191, 3
%193 = sext i32 %192 to i64
%194 = getelementptr inbounds [20 x i32], [20 x i32]* %190, i64 0, i64 %193
%195 = load i32, i32* %194
%196 = mul nsw i32 %186, %195
store i32 %196, i32* %14
%197 = load i32, i32* %14
%198 = load i32, i32* %11
%199 = icmp sgt i32 %197, %198
br i1 %199, label %200, label %202
200: ; preds = %159
%201 = load i32, i32* %14
br label %204
202: ; preds = %159
%203 = load i32, i32* %11
br label %204
204: ; preds = %202, %200
%205 = phi i32 [ %201, %200 ], [ %203, %202 ]
store i32 %205, i32* %11
br label %206
206: ; preds = %204, %156, %153
%207 = load i32, i32* %10
%208 = icmp sgt i32 %207, 3
br i1 %208, label %209, label %253
209: ; preds = %206
%210 = load i32, i32* %9
%211 = sext i32 %210 to i64
%212 = getelementptr inbounds [20 x [20 x i32]], [20 x [20 x i32]]* %7, i64 0, i64 %211
%213 = load i32, i32* %10
%214 = sext i32 %213 to i64
%215 = getelementptr inbounds [20 x i32], [20 x i32]* %212, i64 0, i64 %214
%216 = load i32, i32* %215
%217 = load i32, i32* %9
%218 = sext i32 %217 to i64
%219 = getelementptr inbounds [20 x [20 x i32]], [20 x [20 x i32]]* %7, i64 0, i64 %218
%220 = load i32, i32* %10
%221 = sub nsw i32 %220, 1
%222 = sext i32 %221 to i64
%223 = getelementptr inbounds [20 x i32], [20 x i32]* %219, i64 0, i64 %222
%224 = load i32, i32* %223
%225 = mul nsw i32 %216, %224
%226 = load i32, i32* %9
%227 = sext i32 %226 to i64
%228 = getelementptr inbounds [20 x [20 x i32]], [20 x [20 x i32]]* %7, i64 0, i64 %227
%229 = load i32, i32* %10
%230 = sub nsw i32 %229, 2
%231 = sext i32 %230 to i64
%232 = getelementptr inbounds [20 x i32], [20 x i32]* %228, i64 0, i64 %231
%233 = load i32, i32* %232
%234 = mul nsw i32 %225, %233
%235 = load i32, i32* %9
%236 = sext i32 %235 to i64
%237 = getelementptr inbounds [20 x [20 x i32]], [20 x [20 x i32]]* %7, i64 0, i64 %236
%238 = load i32, i32* %10
%239 = sub nsw i32 %238, 3
%240 = sext i32 %239 to i64
%241 = getelementptr inbounds [20 x i32], [20 x i32]* %237, i64 0, i64 %240
%242 = load i32, i32* %241
%243 = mul nsw i32 %234, %242
store i32 %243, i32* %15
%244 = load i32, i32* %15
%245 = load i32, i32* %11
%246 = icmp sgt i32 %244, %245
br i1 %246, label %247, label %249
247: ; preds = %209
%248 = load i32, i32* %15
br label %251
249: ; preds = %209
%250 = load i32, i32* %11
br label %251
251: ; preds = %249, %247
%252 = phi i32 [ %248, %247 ], [ %250, %249 ]
store i32 %252, i32* %11
br label %253
253: ; preds = %251, %206
%254 = load i32, i32* %10
%255 = icmp slt i32 %254, 17
br i1 %255, label %256, label %300
256: ; preds = %253
%257 = load i32, i32* %9
%258 = sext i32 %257 to i64
%259 = getelementptr inbounds [20 x [20 x i32]], [20 x [20 x i32]]* %7, i64 0, i64 %258
%260 = load i32, i32* %10
%261 = sext i32 %260 to i64
%262 = getelementptr inbounds [20 x i32], [20 x i32]* %259, i64 0, i64 %261
%263 = load i32, i32* %262
%264 = load i32, i32* %9
%265 = sext i32 %264 to i64
%266 = getelementptr inbounds [20 x [20 x i32]], [20 x [20 x i32]]* %7, i64 0, i64 %265
%267 = load i32, i32* %10
%268 = add nsw i32 %267, 1
%269 = sext i32 %268 to i64
%270 = getelementptr inbounds [20 x i32], [20 x i32]* %266, i64 0, i64 %269
%271 = load i32, i32* %270
%272 = mul nsw i32 %263, %271
%273 = load i32, i32* %9
%274 = sext i32 %273 to i64
%275 = getelementptr inbounds [20 x [20 x i32]], [20 x [20 x i32]]* %7, i64 0, i64 %274
%276 = load i32, i32* %10
%277 = add nsw i32 %276, 2
%278 = sext i32 %277 to i64
%279 = getelementptr inbounds [20 x i32], [20 x i32]* %275, i64 0, i64 %278
%280 = load i32, i32* %279
%281 = mul nsw i32 %272, %280
%282 = load i32, i32* %9
%283 = sext i32 %282 to i64
%284 = getelementptr inbounds [20 x [20 x i32]], [20 x [20 x i32]]* %7, i64 0, i64 %283
%285 = load i32, i32* %10
%286 = add nsw i32 %285, 3
%287 = sext i32 %286 to i64
%288 = getelementptr inbounds [20 x i32], [20 x i32]* %284, i64 0, i64 %287
%289 = load i32, i32* %288
%290 = mul nsw i32 %281, %289
store i32 %290, i32* %16
%291 = load i32, i32* %16
%292 = load i32, i32* %11
%293 = icmp sgt i32 %291, %292
br i1 %293, label %294, label %296
294: ; preds = %256
%295 = load i32, i32* %16
br label %298
296: ; preds = %256
%297 = load i32, i32* %11
br label %298
298: ; preds = %296, %294
%299 = phi i32 [ %295, %294 ], [ %297, %296 ]
store i32 %299, i32* %11
br label %300
300: ; preds = %298, %253
%301 = load i32, i32* %9
%302 = icmp slt i32 %301, 17
br i1 %302, label %303, label %347
303: ; preds = %300
%304 = load i32, i32* %9
%305 = sext i32 %304 to i64
%306 = getelementptr inbounds [20 x [20 x i32]], [20 x [20 x i32]]* %7, i64 0, i64 %305
%307 = load i32, i32* %10
%308 = sext i32 %307 to i64
%309 = getelementptr inbounds [20 x i32], [20 x i32]* %306, i64 0, i64 %308
%310 = load i32, i32* %309
%311 = load i32, i32* %9
%312 = add nsw i32 %311, 1
%313 = sext i32 %312 to i64
%314 = getelementptr inbounds [20 x [20 x i32]], [20 x [20 x i32]]* %7, i64 0, i64 %313
%315 = load i32, i32* %10
%316 = sext i32 %315 to i64
%317 = getelementptr inbounds [20 x i32], [20 x i32]* %314, i64 0, i64 %316
%318 = load i32, i32* %317
%319 = mul nsw i32 %310, %318
%320 = load i32, i32* %9
%321 = add nsw i32 %320, 2
%322 = sext i32 %321 to i64
%323 = getelementptr inbounds [20 x [20 x i32]], [20 x [20 x i32]]* %7, i64 0, i64 %322
%324 = load i32, i32* %10
%325 = sext i32 %324 to i64
%326 = getelementptr inbounds [20 x i32], [20 x i32]* %323, i64 0, i64 %325
%327 = load i32, i32* %326
%328 = mul nsw i32 %319, %327
%329 = load i32, i32* %9
%330 = add nsw i32 %329, 3
%331 = sext i32 %330 to i64
%332 = getelementptr inbounds [20 x [20 x i32]], [20 x [20 x i32]]* %7, i64 0, i64 %331
%333 = load i32, i32* %10
%334 = sext i32 %333 to i64
%335 = getelementptr inbounds [20 x i32], [20 x i32]* %332, i64 0, i64 %334
%336 = load i32, i32* %335
%337 = mul nsw i32 %328, %336
store i32 %337, i32* %17
%338 = load i32, i32* %17
%339 = load i32, i32* %11
%340 = icmp sgt i32 %338, %339
br i1 %340, label %341, label %343
341: ; preds = %303
%342 = load i32, i32* %17
br label %345
343: ; preds = %303
%344 = load i32, i32* %11
br label %345
345: ; preds = %343, %341
%346 = phi i32 [ %342, %341 ], [ %344, %343 ]
store i32 %346, i32* %11
br label %347
347: ; preds = %345, %300
%348 = load i32, i32* %9
%349 = icmp slt i32 %348, 17
br i1 %349, label %350, label %400
350: ; preds = %347
%351 = load i32, i32* %10
%352 = icmp sgt i32 %351, 3
br i1 %352, label %353, label %400
353: ; preds = %350
%354 = load i32, i32* %9
%355 = sext i32 %354 to i64
%356 = getelementptr inbounds [20 x [20 x i32]], [20 x [20 x i32]]* %7, i64 0, i64 %355
%357 = load i32, i32* %10
%358 = sext i32 %357 to i64
%359 = getelementptr inbounds [20 x i32], [20 x i32]* %356, i64 0, i64 %358
%360 = load i32, i32* %359
%361 = load i32, i32* %9
%362 = add nsw i32 %361, 1
%363 = sext i32 %362 to i64
%364 = getelementptr inbounds [20 x [20 x i32]], [20 x [20 x i32]]* %7, i64 0, i64 %363
%365 = load i32, i32* %10
%366 = sub nsw i32 %365, 1
%367 = sext i32 %366 to i64
%368 = getelementptr inbounds [20 x i32], [20 x i32]* %364, i64 0, i64 %367
%369 = load i32, i32* %368
%370 = mul nsw i32 %360, %369
%371 = load i32, i32* %9
%372 = add nsw i32 %371, 2
%373 = sext i32 %372 to i64
%374 = getelementptr inbounds [20 x [20 x i32]], [20 x [20 x i32]]* %7, i64 0, i64 %373
%375 = load i32, i32* %10
%376 = sub nsw i32 %375, 2
%377 = sext i32 %376 to i64
%378 = getelementptr inbounds [20 x i32], [20 x i32]* %374, i64 0, i64 %377
%379 = load i32, i32* %378
%380 = mul nsw i32 %370, %379
%381 = load i32, i32* %9
%382 = add nsw i32 %381, 3
%383 = sext i32 %382 to i64
%384 = getelementptr inbounds [20 x [20 x i32]], [20 x [20 x i32]]* %7, i64 0, i64 %383
%385 = load i32, i32* %10
%386 = sub nsw i32 %385, 3
%387 = sext i32 %386 to i64
%388 = getelementptr inbounds [20 x i32], [20 x i32]* %384, i64 0, i64 %387
%389 = load i32, i32* %388
%390 = mul nsw i32 %380, %389
store i32 %390, i32* %18
%391 = load i32, i32* %18
%392 = load i32, i32* %11
%393 = icmp sgt i32 %391, %392
br i1 %393, label %394, label %396
394: ; preds = %353
%395 = load i32, i32* %18
br label %398
396: ; preds = %353
%397 = load i32, i32* %11
br label %398
398: ; preds = %396, %394
%399 = phi i32 [ %395, %394 ], [ %397, %396 ]
store i32 %399, i32* %11
br label %400
400: ; preds = %398, %350, %347
%401 = load i32, i32* %9
%402 = icmp slt i32 %401, 17
br i1 %402, label %403, label %453
403: ; preds = %400
%404 = load i32, i32* %10
%405 = icmp slt i32 %404, 17
br i1 %405, label %406, label %453
406: ; preds = %403
%407 = load i32, i32* %9
%408 = sext i32 %407 to i64
%409 = getelementptr inbounds [20 x [20 x i32]], [20 x [20 x i32]]* %7, i64 0, i64 %408
%410 = load i32, i32* %10
%411 = sext i32 %410 to i64
%412 = getelementptr inbounds [20 x i32], [20 x i32]* %409, i64 0, i64 %411
%413 = load i32, i32* %412
%414 = load i32, i32* %9
%415 = add nsw i32 %414, 1
%416 = sext i32 %415 to i64
%417 = getelementptr inbounds [20 x [20 x i32]], [20 x [20 x i32]]* %7, i64 0, i64 %416
%418 = load i32, i32* %10
%419 = add nsw i32 %418, 1
%420 = sext i32 %419 to i64
%421 = getelementptr inbounds [20 x i32], [20 x i32]* %417, i64 0, i64 %420
%422 = load i32, i32* %421
%423 = mul nsw i32 %413, %422
%424 = load i32, i32* %9
%425 = add nsw i32 %424, 2
%426 = sext i32 %425 to i64
%427 = getelementptr inbounds [20 x [20 x i32]], [20 x [20 x i32]]* %7, i64 0, i64 %426
%428 = load i32, i32* %10
%429 = add nsw i32 %428, 2
%430 = sext i32 %429 to i64
%431 = getelementptr inbounds [20 x i32], [20 x i32]* %427, i64 0, i64 %430
%432 = load i32, i32* %431
%433 = mul nsw i32 %423, %432
%434 = load i32, i32* %9
%435 = add nsw i32 %434, 3
%436 = sext i32 %435 to i64
%437 = getelementptr inbounds [20 x [20 x i32]], [20 x [20 x i32]]* %7, i64 0, i64 %436
%438 = load i32, i32* %10
%439 = add nsw i32 %438, 3
%440 = sext i32 %439 to i64
%441 = getelementptr inbounds [20 x i32], [20 x i32]* %437, i64 0, i64 %440
%442 = load i32, i32* %441
%443 = mul nsw i32 %433, %442
store i32 %443, i32* %19
%444 = load i32, i32* %19
%445 = load i32, i32* %11
%446 = icmp sgt i32 %444, %445
br i1 %446, label %447, label %449
447: ; preds = %406
%448 = load i32, i32* %19
br label %451
449: ; preds = %406
%450 = load i32, i32* %11
br label %451
451: ; preds = %449, %447
%452 = phi i32 [ %448, %447 ], [ %450, %449 ]
store i32 %452, i32* %11
br label %453
453: ; preds = %451, %403, %400
br label %454
454: ; preds = %453
%455 = load i32, i32* %10
%456 = add nsw i32 %455, 1
store i32 %456, i32* %10
br label %50
457: ; preds = %50
br label %458
458: ; preds = %457
%459 = load i32, i32* %9
%460 = add nsw i32 %459, 1
store i32 %460, i32* %9
br label %46
461: ; preds = %46
%462 = load i32, i32* %11
%463 = call i32 @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.2, i64 0, i64 0), i32 %462)
ret i32 0
}

LLVM IR (-O2):
@.str = [1201 x i8] c"08 02 22 97 38 15 00 40 00 75 04 05 07 78 52 12 50 77 91 08 49 49 99 40 17 81 18 57 60 87 17 40 98 43 69 48 04 56 62 00 81 49 31 73 55 79 14 29 93 71 40 67 53 88 30 03 49 13 36 65 52 70 95 23 04 60 11 42 69 24 68 56 01 32 56 71 37 02 36 91 22 31 16 71 51 67 63 89 41 92 36 54 22 40 40 28 66 33 13 80 24 47 32 60 99 03 45 02 44 75 33 53 78 36 84 20 35 17 12 50 32 98 81 28 64 23 67 10 26 38 40 67 59 54 70 66 18 38 64 70 67 26 20 68 02 62 12 20 95 63 94 39 63 08 40 91 66 49 94 21 24 55 58 05 66 73 99 26 97 17 78 78 96 83 14 88 34 89 63 72 21 36 23 09 75 00 76 44 20 45 35 14 00 61 33 97 34 31 33 95 78 17 53 28 22 75 31 67 15 94 03 80 04 62 16 14 09 53 56 92 16 39 05 42 96 35 31 47 55 58 88 24 00 17 54 24 36 29 85 57 86 56 00 48 35 71 89 07 05 44 44 37 44 60 21 58 51 54 17 58 19 80 81 68 05 94 47 69 28 73 92 13 86 52 17 77 04 89 55 40 04 52 08 83 97 35 99 16 07 97 57 32 16 26 26 79 33 27 98 66 88 36 68 87 57 62 20 72 03 46 33 67 46 55 12 32 63 93 53 69 04 42 16 73 38 25 39 11 24 94 72 18 08 46 29 32 40 62 76 36 20 69 36 41 72 30 23 88 34 62 99 69 82 67 59 85 74 04 36 16 20 73 35 29 78 31 90 01 74 31 49 71 48 86 81 16 23 57 05 54 01 70 54 71 83 51 54 69 16 92 33 48 61 43 52 01 89 19 67 48 \00"
@.str.1 = [2 x i8] c" \00"
@.str.2 = [3 x i8] c"%i\00"
define i32 @main(i32 %0, i8** nocapture readnone %1) {
%3 = alloca [20 x [20 x i32]]
%4 = bitcast [20 x [20 x i32]]* %3 to i8*
%5 = tail call i32* @strdup(i8* getelementptr inbounds ([1201 x i8], [1201 x i8]* @.str, i64 0, i64 0))
%6 = tail call i8* @strtok(i32* %5, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%7 = icmp eq i8* %6, null
br i1 %7, label %24, label %8
8: ; preds = %2, %8
%9 = phi i8* [ %22, %8 ], [ %6, %2 ]
%10 = phi i32 [ %21, %8 ], [ 0, %2 ]
%11 = phi i32 [ %19, %8 ], [ 0, %2 ]
%12 = tail call i32 @atoi(i8* %9)
%13 = zext i32 %10 to i64
%14 = sext i32 %11 to i64
%15 = getelementptr inbounds [20 x [20 x i32]], [20 x [20 x i32]]* %3, i64 0, i64 %13, i64 %14
store i32 %12, i32* %15
%16 = add nsw i32 %11, 1
%17 = srem i32 %16, 20
%18 = icmp eq i32 %17, 0
%19 = select i1 %18, i32 0, i32 %16
%20 = zext i1 %18 to i32
%21 = add nuw nsw i32 %10, %20
%22 = tail call i8* @strtok(i32* null, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%23 = icmp eq i8* %22, null
br i1 %23, label %24, label %8
24: ; preds = %8, %2
br label %25
25: ; preds = %24, %198
%26 = phi i64 [ %36, %198 ], [ 0, %24 ]
%27 = phi i32 [ %195, %198 ], [ 0, %24 ]
%28 = icmp ugt i64 %26, 3
%29 = icmp ult i64 %26, 17
%30 = add nuw i64 %26, 4294967295
%31 = and i64 %30, 4294967295
%32 = add nuw i64 %26, 4294967294
%33 = and i64 %32, 4294967295
%34 = add nuw i64 %26, 4294967293
%35 = and i64 %34, 4294967295
%36 = add nuw nsw i64 %26, 1
%37 = add nuw nsw i64 %26, 2
%38 = add nuw nsw i64 %26, 3
br label %39
39: ; preds = %25, %194
%40 = phi i64 [ 0, %25 ], [ %196, %194 ]
%41 = phi i32 [ %27, %25 ], [ %195, %194 ]
br i1 %28, label %48, label %42
42: ; preds = %39
%43 = icmp ugt i64 %40, 3
br i1 %43, label %44, label %119
44: ; preds = %42
%45 = icmp ult i64 %40, 17
%46 = getelementptr inbounds [20 x [20 x i32]], [20 x [20 x i32]]* %3, i64 0, i64 %26, i64 %40
%47 = load i32, i32* %46
br label %98
48: ; preds = %39
%49 = getelementptr inbounds [20 x [20 x i32]], [20 x [20 x i32]]* %3, i64 0, i64 %26, i64 %40
%50 = load i32, i32* %49
%51 = getelementptr inbounds [20 x [20 x i32]], [20 x [20 x i32]]* %3, i64 0, i64 %31, i64 %40
%52 = load i32, i32* %51
%53 = mul nsw i32 %52, %50
%54 = getelementptr inbounds [20 x [20 x i32]], [20 x [20 x i32]]* %3, i64 0, i64 %33, i64 %40
%55 = load i32, i32* %54
%56 = mul nsw i32 %53, %55
%57 = getelementptr inbounds [20 x [20 x i32]], [20 x [20 x i32]]* %3, i64 0, i64 %35, i64 %40
%58 = load i32, i32* %57
%59 = mul nsw i32 %56, %58
%60 = icmp sgt i32 %59, %41
%61 = select i1 %60, i32 %59, i32 %41
%62 = icmp ugt i64 %40, 3
br i1 %62, label %63, label %82
63: ; preds = %48
%64 = add nuw i64 %40, 4294967295
%65 = and i64 %64, 4294967295
%66 = getelementptr inbounds [20 x [20 x i32]], [20 x [20 x i32]]* %3, i64 0, i64 %31, i64 %65
%67 = load i32, i32* %66
%68 = mul nsw i32 %67, %50
%69 = add nuw i64 %40, 4294967294
%70 = and i64 %69, 4294967295
%71 = getelementptr inbounds [20 x [20 x i32]], [20 x [20 x i32]]* %3, i64 0, i64 %33, i64 %70
%72 = load i32, i32* %71
%73 = mul nsw i32 %68, %72
%74 = add nuw i64 %40, 4294967293
%75 = and i64 %74, 4294967295
%76 = getelementptr inbounds [20 x [20 x i32]], [20 x [20 x i32]]* %3, i64 0, i64 %35, i64 %75
%77 = load i32, i32* %76
%78 = mul nsw i32 %73, %77
%79 = icmp sgt i32 %78, %61
%80 = select i1 %79, i32 %78, i32 %61
%81 = icmp ult i64 %40, 17
br i1 %81, label %82, label %98
82: ; preds = %48, %63
%83 = phi i32 [ %80, %63 ], [ %61, %48 ]
%84 = add nuw nsw i64 %40, 1
%85 = getelementptr inbounds [20 x [20 x i32]], [20 x [20 x i32]]* %3, i64 0, i64 %31, i64 %84
%86 = load i32, i32* %85
%87 = mul nsw i32 %86, %50
%88 = add nuw nsw i64 %40, 2
%89 = getelementptr inbounds [20 x [20 x i32]], [20 x [20 x i32]]* %3, i64 0, i64 %33, i64 %88
%90 = load i32, i32* %89
%91 = mul nsw i32 %87, %90
%92 = add nuw nsw i64 %40, 3
%93 = getelementptr inbounds [20 x [20 x i32]], [20 x [20 x i32]]* %3, i64 0, i64 %35, i64 %92
%94 = load i32, i32* %93
%95 = mul nsw i32 %91, %94
%96 = icmp sgt i32 %95, %83
%97 = select i1 %96, i32 %95, i32 %83
br i1 %62, label %98, label %119
98: ; preds = %63, %44, %82
%99 = phi i32 [ %50, %82 ], [ %47, %44 ], [ %50, %63 ]
%100 = phi i32 [ %97, %82 ], [ %41, %44 ], [ %80, %63 ]
%101 = phi i1 [ true, %82 ], [ %45, %44 ], [ false, %63 ]
%102 = add nuw i64 %40, 4294967295
%103 = and i64 %102, 4294967295
%104 = getelementptr inbounds [20 x [20 x i32]], [20 x [20 x i32]]* %3, i64 0, i64 %26, i64 %103
%105 = load i32, i32* %104
%106 = mul nsw i32 %105, %99
%107 = add nuw i64 %40, 4294967294
%108 = and i64 %107, 4294967295
%109 = getelementptr inbounds [20 x [20 x i32]], [20 x [20 x i32]]* %3, i64 0, i64 %26, i64 %108
%110 = load i32, i32* %109
%111 = mul nsw i32 %106, %110
%112 = add nuw i64 %40, 4294967293
%113 = and i64 %112, 4294967295
%114 = getelementptr inbounds [20 x [20 x i32]], [20 x [20 x i32]]* %3, i64 0, i64 %26, i64 %113
%115 = load i32, i32* %114
%116 = mul nsw i32 %111, %115
%117 = icmp sgt i32 %116, %100
%118 = select i1 %117, i32 %116, i32 %100
br i1 %101, label %123, label %141
119: ; preds = %42, %82
%120 = phi i32 [ %97, %82 ], [ %41, %42 ]
%121 = getelementptr inbounds [20 x [20 x i32]], [20 x [20 x i32]]* %3, i64 0, i64 %26, i64 %40
%122 = load i32, i32* %121
br label %123
123: ; preds = %119, %98
%124 = phi i32 [ %99, %98 ], [ %122, %119 ]
%125 = phi i32 [ %118, %98 ], [ %120, %119 ]
%126 = phi i1 [ true, %98 ], [ false, %119 ]
%127 = add nuw nsw i64 %40, 1
%128 = getelementptr inbounds [20 x [20 x i32]], [20 x [20 x i32]]* %3, i64 0, i64 %26, i64 %127
%129 = load i32, i32* %128
%130 = mul nsw i32 %129, %124
%131 = add nuw nsw i64 %40, 2
%132 = getelementptr inbounds [20 x [20 x i32]], [20 x [20 x i32]]* %3, i64 0, i64 %26, i64 %131
%133 = load i32, i32* %132
%134 = mul nsw i32 %130, %133
%135 = add nuw nsw i64 %40, 3
%136 = getelementptr inbounds [20 x [20 x i32]], [20 x [20 x i32]]* %3, i64 0, i64 %26, i64 %135
%137 = load i32, i32* %136
%138 = mul nsw i32 %134, %137
%139 = icmp sgt i32 %138, %125
%140 = select i1 %139, i32 %138, i32 %125
br label %141
141: ; preds = %98, %123
%142 = phi i1 [ true, %123 ], [ false, %98 ]
%143 = phi i1 [ %126, %123 ], [ true, %98 ]
%144 = phi i32 [ %140, %123 ], [ %118, %98 ]
br i1 %29, label %145, label %194
145: ; preds = %141
%146 = getelementptr inbounds [20 x [20 x i32]], [20 x [20 x i32]]* %3, i64 0, i64 %26, i64 %40
%147 = load i32, i32* %146
%148 = getelementptr inbounds [20 x [20 x i32]], [20 x [20 x i32]]* %3, i64 0, i64 %36, i64 %40
%149 = load i32, i32* %148
%150 = mul nsw i32 %149, %147
%151 = getelementptr inbounds [20 x [20 x i32]], [20 x [20 x i32]]* %3, i64 0, i64 %37, i64 %40
%152 = load i32, i32* %151
%153 = mul nsw i32 %150, %152
%154 = getelementptr inbounds [20 x [20 x i32]], [20 x [20 x i32]]* %3, i64 0, i64 %38, i64 %40
%155 = load i32, i32* %154
%156 = mul nsw i32 %153, %155
%157 = icmp sgt i32 %156, %144
%158 = select i1 %157, i32 %156, i32 %144
br i1 %143, label %159, label %177
159: ; preds = %145
%160 = add nuw i64 %40, 4294967295
%161 = and i64 %160, 4294967295
%162 = getelementptr inbounds [20 x [20 x i32]], [20 x [20 x i32]]* %3, i64 0, i64 %36, i64 %161
%163 = load i32, i32* %162
%164 = mul nsw i32 %163, %147
%165 = add nuw i64 %40, 4294967294
%166 = and i64 %165, 4294967295
%167 = getelementptr inbounds [20 x [20 x i32]], [20 x [20 x i32]]* %3, i64 0, i64 %37, i64 %166
%168 = load i32, i32* %167
%169 = mul nsw i32 %164, %168
%170 = add nuw i64 %40, 4294967293
%171 = and i64 %170, 4294967295
%172 = getelementptr inbounds [20 x [20 x i32]], [20 x [20 x i32]]* %3, i64 0, i64 %38, i64 %171
%173 = load i32, i32* %172
%174 = mul nsw i32 %169, %173
%175 = icmp sgt i32 %174, %158
%176 = select i1 %175, i32 %174, i32 %158
br label %177
177: ; preds = %159, %145
%178 = phi i32 [ %176, %159 ], [ %158, %145 ]
br i1 %142, label %179, label %194
179: ; preds = %177
%180 = add nuw nsw i64 %40, 1
%181 = getelementptr inbounds [20 x [20 x i32]], [20 x [20 x i32]]* %3, i64 0, i64 %36, i64 %180
%182 = load i32, i32* %181
%183 = mul nsw i32 %182, %147
%184 = add nuw nsw i64 %40, 2
%185 = getelementptr inbounds [20 x [20 x i32]], [20 x [20 x i32]]* %3, i64 0, i64 %37, i64 %184
%186 = load i32, i32* %185
%187 = mul nsw i32 %183, %186
%188 = add nuw nsw i64 %40, 3
%189 = getelementptr inbounds [20 x [20 x i32]], [20 x [20 x i32]]* %3, i64 0, i64 %38, i64 %188
%190 = load i32, i32* %189
%191 = mul nsw i32 %187, %190
%192 = icmp sgt i32 %191, %178
%193 = select i1 %192, i32 %191, i32 %178
br label %194
194: ; preds = %141, %177, %179
%195 = phi i32 [ %193, %179 ], [ %178, %177 ], [ %144, %141 ]
%196 = add nuw nsw i64 %40, 1
%197 = icmp eq i64 %196, 20
br i1 %197, label %198, label %39
198: ; preds = %194
%199 = icmp eq i64 %36, 20
br i1 %199, label %200, label %25
200: ; preds = %198
%201 = tail call i32 @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.2, i64 0, i64 0), i32 %195)
ret i32 0
}