int main(int a, char **b) {
  return (a - 1 >> 1 ^ 1 ||
          main((long)(6 + !!main((long)(5), (char **)(((long *)(&a))))),
               (char **)(((long *)(&a))))) &&
         (a - 13 || !printf("\x1b[;H") ||
          ((((long *)(b))[4] = (long)(0)) & 0) ||
          main((long)(14), (char **)(b)) || 0) &&
         (a - 14 ||
          (*(((long *)(b)) + 4)) -
                  ((*(((long *)(b)) + 12)) * (*(((long *)(b)) + 13)) *
                   (*(((long *)(b)) + 14))) &&
              !(!((*(((long *)(b)) + 4)) % (*(((long *)(b)) + 12))) &&
                    !printf("%*s",
                            (int)((*(((long *)(b)) + 13)) -
                                  (((*(((long *)(b)) + 4)) %
                                    ((*(((long *)(b)) + 12)) *
                                     (*(((long *)(b)) + 13)))) /
                                   (*(((long *)(b)) + 12)))),
                            "") ||
                (((*(((long *)(b)) + 32 + (*(((long *)(b)) + 4))))) &&
                     !(!printf(
                         "%*ld", (int)(*(((long *)(b)) + 31)),
                         (*(((long *)(b)) + 32 + (*(((long *)(b)) + 4)))))) ||
                 (!printf("%*.*s", (int)(*(((long *)(b)) + 31)),
                          (int)(*(((long *)(b)) + 31)), "#####"))) &&
                    (0) ||
                ((((*(((long *)(b)) + 4)) % (*(((long *)(b)) + 12))) ==
                  (*(((long *)(b)) + 12)) - 1) &&
                     !(!printf("\n")) ||
                 (!printf("%*s", (int)((*(((long *)(b)) + 13)) + 1), ""))) &&
                    (0) ||
                (((*(((long *)(b)) + 4)) + 1) %
                         ((*(((long *)(b)) + 12)) * (*(((long *)(b)) + 13))) ==
                     0 &&
                 (*(((long *)(b)) + 13)) > 1) &&
                    !printf("\n") ||
                ((((long *)(b))[4] = (long)((*(((long *)(b)) + 4)) + 1)) & 0) ||
                0) &&
              main((long)(a), (char **)(b))) &&
         (14) &&
         (a - 1 & ~1 || !printf("Syntax: %s <x> <y> [<z>]\n", b[0]) ||
          main((long)(15), (char **)(b))) &&
         ((a & ~1) - 6 ||
          ((a & 1) * ((long)(((long *)(b)) - ((long *)(&a)))) +
           (~a & 1) * ((long)(((long *)(&a)) - ((long *)(b))))) >>
                  12 &&
              (*(((long *)(((a & 1) * ((long)(((long *)(&a)))) +
                            (~a & 1) * ((long)(b))))) +
                 8) =
                   *((long *)(((char *)(b)) + (((char *)(&b)) -
                                               ((char *)(((long *)(&a)))))))) &&
              (*(((long *)(((a & 1) * ((long)(((long *)(&a)))) +
                            (~a & 1) * ((long)(b))))) +
                 9) = *((long *)(b))) &&
              main((long)(8), (char **)(((a & 1) * ((long)(((long *)(&a)))) +
                                         (~a & 1) * ((long)(b))))) ||
          main((long)(a), (char **)(b))) &&
         (a - 8 ||
          (((*(((long *)(b)) + 9)) & 1) &&
               !(sscanf((((char **)(*(((long *)(b)) + 8)))[1]), "%ld",
                        &(*(((long *)(b)) + 1 + 11))) &
                     0 ||
                 sscanf((((char **)(*(((long *)(b)) + 8)))[2]), "%ld",
                        &(*(((long *)(b)) + 2 + 11))) &
                     0 ||
                 0) ||
           (sscanf((((char **)(*(((long *)(b)) + 8)))[1]), "%ld",
                   &(*(((long *)(b)) + 1 + 11))) &
                0 ||
            sscanf((((char **)(*(((long *)(b)) + 8)))[2]), "%ld",
                   &(*(((long *)(b)) + 2 + 11))) &
                0 ||
            sscanf((((char **)(*(((long *)(b)) + 8)))[3]), "%ld",
                   &(*(((long *)(b)) + 3 + 11))) &
                0 ||
            0)) &&
              (((((long *)(b))[14] = (long)((*(((long *)(b)) + 13)))) & 0) ||
               ((((long *)(b))[13] = (long)(1)) & 0) || 0) ||
          (srand(time(0)), 0) || ((((long *)(b))[4] = (long)(0)) & 0) ||
          main((long)(9), (char **)(b)) ||
          ((((long *)(b))[31] = (long)(snprintf(
                (((char **)(*(((long *)(b)) + 8)))[0]), 1, "%ld",
                ((*(((long *)(b)) + 12)) * (*(((long *)(b)) + 13)) *
                 (*(((long *)(b)) + 14)))))) &
           0) ||
          system("stty cbreak -echo") || !printf("\x1b[2J") ||
          main((long)(13), (char **)(b)) || main((long)(18), (char **)(b)) ||
          main((long)(15), (char **)(b))) &&
         (a - 9 ||
          (*(((long *)(b)) + 4)) -
                  ((*(((long *)(b)) + 12)) * (*(((long *)(b)) + 13)) *
                   (*(((long *)(b)) + 14))) &&
              !(main((long)(16), (char **)(b)) ||
                ((((long *)(b))[(*(((long *)(b)) + 4)) + 32] =
                      (long)((*(((long *)(b)) + 0)))) &
                 0) ||
                !(*(((long *)(b)) + 0)) &&
                    ((((long *)(b))[15] = (long)((*(((long *)(b)) + 4)))) &
                     0) ||
                0 ||
                ((((long *)(b))[4] = (long)((*(((long *)(b)) + 4)) + 1)) & 0) ||
                0) &&
              main((long)(a), (char **)(b))) &&
         (9) &&
         (a - 16 ||
          ((((long *)(b))[0] = (long)(rand() % ((*(((long *)(b)) + 12)) *
                                                (*(((long *)(b)) + 13)) *
                                                (*(((long *)(b)) + 14))))) &
           0) ||
          ((((long *)(b))[1] = (long)(0)) & 0) ||
          ((((long *)(b))[5] = (long)(0)) & 0) ||
          main((long)(17), (char **)(b)) ||
          (*(((long *)(b)) + 1)) && main((long)(16), (char **)(b))) &&
         (a - 17 ||
          (*(((long *)(b)) + 5)) - (*(((long *)(b)) + 4)) &&
              !(!((*(((long *)(b)) + 32 + (*(((long *)(b)) + 5)))) -
                  (*(((long *)(b)) + 0))) &&
                    !(((((long *)(b))[1] = (long)(1)) & 0) ||
                      ((((long *)(b))[5] = (long)((*(((long *)(b)) + 4)) - 1)) &
                       0) ||
                      0) ||
                ((((long *)(b))[5] = (long)((*(((long *)(b)) + 5)) + 1)) & 0) ||
                0) &&
              main((long)(a), (char **)(b))) &&
         (17) &&
         (a - 18 || ((((long *)(b))[0] = (long)(0)) & 0) ||
          ((((long *)(b))[4] = (long)(0)) & 0) ||
          main((long)(19), (char **)(b)) ||
          !(*(((long *)(b)) + 0)) && !printf("You win!\n") ||
          (*(((long *)(b)) + 0)) &&
              (((((long *)(b))[a] = (long)(getchar())) & 0) ||
               (*(((long *)(b)) + a)) == 'i' &&
                   0 < ((*(((long *)(b)) + 15)) /
                        ((*(((long *)(b)) + 12)) * (*(((long *)(b)) + 13)))) &&
                   (((((long *)(b))[32 + (*(((long *)(b)) + 15))] = (long)((
                          *(((long *)(b)) + 32 +
                            -(*(((long *)(b)) + 12)) * (*(((long *)(b)) + 13)) +
                            (*(((long *)(b)) + 15)))))) &
                     0) ||
                    ((((long *)(b))[32 +
                                    -(*(((long *)(b)) + 12)) *
                                        (*(((long *)(b)) + 13)) +
                                    (*(((long *)(b)) + 15))] = (long)(0)) &
                     0) ||
                    (((long *)(b))[15] +=
                     -(*(((long *)(b)) + 12)) * (*(((long *)(b)) + 13))) |
                        1) &&
                   main((long)(13), (char **)(b)) ||
               (*(((long *)(b)) + a)) == 'j' &&
                   0 < ((*(((long *)(b)) + 15)) % (*(((long *)(b)) + 12))) &&
                   (((((long *)(b))[32 + (*(((long *)(b)) + 15))] =
                          (long)((*(((long *)(b)) + 32 + -1 +
                                    (*(((long *)(b)) + 15)))))) &
                     0) ||
                    ((((long *)(b))[32 + -1 + (*(((long *)(b)) + 15))] =
                          (long)(0)) &
                     0) ||
                    (((long *)(b))[15] += -1) | 1) &&
                   main((long)(13), (char **)(b)) ||
               (*(((long *)(b)) + a)) == 'k' &&
                   ((*(((long *)(b)) + 15)) /
                    ((*(((long *)(b)) + 12)) * (*(((long *)(b)) + 13)))) <
                       (*(((long *)(b)) + 14)) - 1 &&
                   (((((long *)(b))[32 + (*(((long *)(b)) + 15))] = (long)((
                          *(((long *)(b)) + 32 +
                            (*(((long *)(b)) + 12)) * (*(((long *)(b)) + 13)) +
                            (*(((long *)(b)) + 15)))))) &
                     0) ||
                    ((((long *)(b))[32 +
                                    (*(((long *)(b)) + 12)) *
                                        (*(((long *)(b)) + 13)) +
                                    (*(((long *)(b)) + 15))] = (long)(0)) &
                     0) ||
                    (((long *)(b))[15] +=
                     (*(((long *)(b)) + 12)) * (*(((long *)(b)) + 13))) |
                        1) &&
                   main((long)(13), (char **)(b)) ||
               (*(((long *)(b)) + a)) == 'l' &&
                   ((*(((long *)(b)) + 15)) % (*(((long *)(b)) + 12))) <
                       (*(((long *)(b)) + 12)) - 1 &&
                   (((((long *)(b))[32 + (*(((long *)(b)) + 15))] = (long)((*(
                          ((long *)(b)) + 32 + 1 + (*(((long *)(b)) + 15)))))) &
                     0) ||
                    ((((long *)(b))[32 + 1 + (*(((long *)(b)) + 15))] =
                          (long)(0)) &
                     0) ||
                    (((long *)(b))[15] += 1) | 1) &&
                   main((long)(13), (char **)(b)) ||
               (*(((long *)(b)) + a)) == 'n' &&
                   (((*(((long *)(b)) + 15)) %
                     ((*(((long *)(b)) + 12)) * (*(((long *)(b)) + 13)))) /
                    (*(((long *)(b)) + 12))) < (*(((long *)(b)) + 13)) - 1 &&
                   (((((long *)(b))[32 + (*(((long *)(b)) + 15))] = (long)((
                          *(((long *)(b)) + 32 + (*(((long *)(b)) + 12)) +
                            (*(((long *)(b)) + 15)))))) &
                     0) ||
                    ((((long *)(b))[32 + (*(((long *)(b)) + 12)) +
                                    (*(((long *)(b)) + 15))] = (long)(0)) &
                     0) ||
                    (((long *)(b))[15] += (*(((long *)(b)) + 12))) | 1) &&
                   main((long)(13), (char **)(b)) ||
               (*(((long *)(b)) + a)) == 'o' &&
                   0 < (((*(((long *)(b)) + 15)) %
                         ((*(((long *)(b)) + 12)) * (*(((long *)(b)) + 13)))) /
                        (*(((long *)(b)) + 12))) &&
                   (((((long *)(b))[32 + (*(((long *)(b)) + 15))] = (long)((
                          *(((long *)(b)) + 32 + -(*(((long *)(b)) + 12)) +
                            (*(((long *)(b)) + 15)))))) &
                     0) ||
                    ((((long *)(b))[32 + -(*(((long *)(b)) + 12)) +
                                    (*(((long *)(b)) + 15))] = (long)(0)) &
                     0) ||
                    (((long *)(b))[15] += -(*(((long *)(b)) + 12))) | 1) &&
                   main((long)(13), (char **)(b)) ||
               (*(((long *)(b)) + a)) == 'q' && !!printf("You lose :-)\n") &&
                   main((long)(15), (char **)(b)) ||
               main((long)(a), (char **)(b)))) &&
         (a - 19 ||
          (*(((long *)(b)) + 4)) -
                  ((*(((long *)(b)) + 12)) * (*(((long *)(b)) + 13)) *
                   (*(((long *)(b)) + 14))) &&
              !((*(((long *)(b)) + 32 + (*(((long *)(b)) + 4)))) -
                        ((*(((long *)(b)) + 4)) + 1) %
                            ((*(((long *)(b)) + 12)) * (*(((long *)(b)) + 13)) *
                             (*(((long *)(b)) + 14))) &&
                    (((((long *)(b))[0] = (long)(1)) & 0) ||
                     ((((long *)(b))[4] = (long)(((*(((long *)(b)) + 12)) *
                                                  (*(((long *)(b)) + 13)) *
                                                  (*(((long *)(b)) + 14))) -
                                                 1)) &
                      0) ||
                     0) ||
                0 ||
                ((((long *)(b))[4] = (long)((*(((long *)(b)) + 4)) + 1)) & 0) ||
                0) &&
              main((long)(a), (char **)(b))) &&
         (19) && (a - 15 || system("stty sane") || (exit(0), a)) &&
         (a - 5 || ((long *)(&a)) < ((long *)(b)));
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x8(%rbp),%eax
sub    $0x1,%eax
sar    $0x1,%eax
xor    $0x1,%eax
cmp    $0x0,%eax
jne    1208 <main+0x68>
lea    -0x8(%rbp),%rsi
mov    $0x5,%edi
call   10a0 <main@plt>
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%eax
add    $0x6,%eax
cltq
mov    %eax,%edi
lea    -0x8(%rbp),%rsi
call   10a0 <main@plt>
mov    %eax,%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x11(%rbp)
je     2395 <main+0x11f5>
mov    -0x8(%rbp),%eax
sub    $0xd,%eax
cmp    $0x0,%eax
jne    1262 <main+0xc2>
lea    0x1de2(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
cmp    $0x0,%eax
je     1262 <main+0xc2>
mov    -0x10(%rbp),%rax
movq   $0x0,0x20(%rax)
xor    %eax,%eax
test   $0x1,%al
jne    1262 <main+0xc2>
mov    -0x10(%rbp),%rsi
mov    $0xe,%edi
call   10a0 <main@plt>
mov    %eax,%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x11(%rbp)
je     2395 <main+0x11f5>
mov    -0x8(%rbp),%eax
sub    $0xe,%eax
cmp    $0x0,%eax
jne    14e1 <main+0x341>
mov    -0x10(%rbp),%rax
mov    0x20(%rax),%rcx
mov    -0x10(%rbp),%rax
mov    0x60(%rax),%rax
mov    -0x10(%rbp),%rdx
imul   0x68(%rdx),%rax
mov    -0x10(%rbp),%rdx
imul   0x70(%rdx),%rax
sub    %rax,%rcx
xor    %eax,%eax
cmp    $0x0,%rcx
mov    %al,-0x11(%rbp)
je     2395 <main+0x11f5>
mov    -0x10(%rbp),%rax
mov    0x20(%rax),%rax
mov    -0x10(%rbp),%rcx
cqto
idivq  0x60(%rcx)
cmp    $0x0,%rdx
jne    1329 <main+0x189>
mov    -0x10(%rbp),%rax
mov    0x68(%rax),%rax
mov    %rax,-0x20(%rbp)
mov    -0x10(%rbp),%rax
mov    0x20(%rax),%rax
mov    -0x10(%rbp),%rcx
mov    0x60(%rcx),%rcx
mov    -0x10(%rbp),%rdx
imul   0x68(%rdx),%rcx
cqto
idiv   %rcx
mov    %rdx,%rax
mov    -0x10(%rbp),%rcx
cqto
idivq  0x60(%rcx)
mov    %rax,%rcx
mov    -0x20(%rbp),%rax
sub    %rcx,%rax
mov    %eax,%esi
lea    0x1cfa(%rip),%rdi
lea    0x1d46(%rip),%rdx
mov    $0x0,%al
call   1040 <printf@plt>
mov    %eax,%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x11(%rbp)
je     2395 <main+0x11f5>
mov    -0x10(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    0x20(%rcx),%rcx
cmpq   $0x0,0x100(%rax,%rcx,8)
je     137c <main+0x1dc>
mov    -0x10(%rbp),%rax
mov    0xf8(%rax),%rax
mov    %eax,%esi
mov    -0x10(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    0x20(%rcx),%rcx
mov    0x100(%rax,%rcx,8),%rdx
lea    0x1c9d(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
cmp    $0x0,%eax
jne    13b4 <main+0x214>
mov    -0x10(%rbp),%rax
mov    0xf8(%rax),%rax
mov    %eax,%esi
mov    -0x10(%rbp),%rax
mov    0xf8(%rax),%rax
mov    %eax,%edx
lea    0x1c71(%rip),%rdi
lea    0x1c70(%rip),%rcx
mov    $0x0,%al
call   1040 <printf@plt>
cmp    $0x0,%eax
jne    13c6 <main+0x226>
xor    %eax,%eax
test   $0x1,%al
mov    %al,-0x11(%rbp)
jne    2395 <main+0x11f5>
jmp    13c6 <main+0x226>
mov    -0x10(%rbp),%rax
mov    0x20(%rax),%rax
mov    -0x10(%rbp),%rcx
cqto
idivq  0x60(%rcx)
mov    -0x10(%rbp),%rax
mov    0x60(%rax),%rax
sub    $0x1,%rax
cmp    %rax,%rdx
jne    1404 <main+0x264>
lea    0x1c63(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
cmp    $0x0,%eax
jne    1430 <main+0x290>
mov    -0x10(%rbp),%rax
mov    0x68(%rax),%rax
add    $0x1,%rax
mov    %eax,%esi
lea    0x1bec(%rip),%rdi
lea    0x1c38(%rip),%rdx
mov    $0x0,%al
call   1040 <printf@plt>
cmp    $0x0,%eax
jne    1442 <main+0x2a2>
xor    %eax,%eax
test   $0x1,%al
mov    %al,-0x11(%rbp)
jne    2395 <main+0x11f5>
jmp    1442 <main+0x2a2>
mov    -0x10(%rbp),%rax
mov    0x20(%rax),%rax
add    $0x1,%rax
mov    -0x10(%rbp),%rcx
mov    0x60(%rcx),%rcx
mov    -0x10(%rbp),%rdx
imul   0x68(%rdx),%rcx
cqto
idiv   %rcx
cmp    $0x0,%rdx
jne    149b <main+0x2fb>
mov    -0x10(%rbp),%rax
cmpq   $0x1,0x68(%rax)
jle    149b <main+0x2fb>
lea    0x1bd3(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    %eax,%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x11(%rbp)
je     2395 <main+0x11f5>
mov    -0x10(%rbp),%rax
mov    0x20(%rax),%rcx
add    $0x1,%rcx
mov    -0x10(%rbp),%rax
mov    %rcx,0x20(%rax)
and    $0x0,%rcx
xor    %eax,%eax
cmp    $0x0,%rcx
mov    %al,-0x11(%rbp)
jne    2395 <main+0x11f5>
movslq -0x8(%rbp),%rax
mov    %eax,%edi
mov    -0x10(%rbp),%rsi
call   10a0 <main@plt>
mov    %eax,%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x11(%rbp)
je     2395 <main+0x11f5>
mov    -0x8(%rbp),%eax
sub    $0x1,%eax
and    $0xfffffffe,%eax
cmp    $0x0,%eax
jne    152f <main+0x38f>
mov    -0x10(%rbp),%rax
mov    (%rax),%rsi
lea    0x1b19(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
cmp    $0x0,%eax
je     152f <main+0x38f>
mov    -0x10(%rbp),%rsi
mov    $0xf,%edi
call   10a0 <main@plt>
mov    %eax,%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x11(%rbp)
je     2395 <main+0x11f5>
mov    -0x8(%rbp),%eax
and    $0xfffffffe,%eax
sub    $0x6,%eax
cmp    $0x0,%eax
jne    166b <main+0x4cb>
mov    -0x8(%rbp),%eax
and    $0x1,%eax
cltq
mov    -0x10(%rbp),%rcx
lea    -0x8(%rbp),%rdx
sub    %rdx,%rcx
sar    $0x3,%rcx
imul   %rcx,%rax
mov    -0x8(%rbp),%ecx
xor    $0xffffffff,%ecx
and    $0x1,%ecx
movslq %ecx,%rcx
lea    -0x8(%rbp),%rdx
mov    -0x10(%rbp),%rsi
sub    %rsi,%rdx
sar    $0x3,%rdx
imul   %rdx,%rcx
add    %rcx,%rax
sar    $0xc,%rax
cmp    $0x0,%rax
je     164c <main+0x4ac>
mov    -0x10(%rbp),%rax
lea    -0x10(%rbp),%rcx
lea    -0x8(%rbp),%rdx
sub    %rdx,%rcx
mov    (%rax,%rcx,1),%rax
mov    -0x8(%rbp),%ecx
and    $0x1,%ecx
movslq %ecx,%rcx
lea    -0x8(%rbp),%rdx
imul   %rdx,%rcx
mov    -0x8(%rbp),%edx
xor    $0xffffffff,%edx
and    $0x1,%edx
movslq %edx,%rdx
mov    -0x10(%rbp),%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
mov    %rax,0x40(%rcx)
cmp    $0x0,%rax
je     164c <main+0x4ac>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    -0x8(%rbp),%ecx
and    $0x1,%ecx
movslq %ecx,%rcx
lea    -0x8(%rbp),%rdx
imul   %rdx,%rcx
mov    -0x8(%rbp),%edx
xor    $0xffffffff,%edx
and    $0x1,%edx
movslq %edx,%rdx
mov    -0x10(%rbp),%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
mov    %rax,0x48(%rcx)
cmp    $0x0,%rax
je     164c <main+0x4ac>
mov    -0x8(%rbp),%eax
and    $0x1,%eax
movslq %eax,%rsi
lea    -0x8(%rbp),%rax
imul   %rax,%rsi
mov    -0x8(%rbp),%eax
xor    $0xffffffff,%eax
and    $0x1,%eax
cltq
mov    -0x10(%rbp),%rcx
imul   %rcx,%rax
add    %rax,%rsi
mov    $0x8,%edi
call   10a0 <main@plt>
cmp    $0x0,%eax
jne    166b <main+0x4cb>
movslq -0x8(%rbp),%rax
mov    %eax,%edi
mov    -0x10(%rbp),%rsi
call   10a0 <main@plt>
mov    %eax,%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x11(%rbp)
je     2395 <main+0x11f5>
mov    -0x8(%rbp),%eax
sub    $0x8,%eax
cmp    $0x0,%eax
jne    18d4 <main+0x734>
mov    -0x10(%rbp),%rax
mov    0x48(%rax),%rax
and    $0x1,%rax
cmp    $0x0,%rax
je     16f4 <main+0x554>
mov    -0x10(%rbp),%rax
mov    0x40(%rax),%rax
mov    0x8(%rax),%rdi
mov    -0x10(%rbp),%rdx
add    $0x8,%rdx
add    $0x58,%rdx
lea    0x1985(%rip),%rsi
mov    $0x0,%al
call   1090 <sscanf@plt>
and    $0x0,%eax
cmp    $0x0,%eax
jne    16f4 <main+0x554>
mov    -0x10(%rbp),%rax
mov    0x40(%rax),%rax
mov    0x10(%rax),%rdi
mov    -0x10(%rbp),%rdx
add    $0x10,%rdx
add    $0x58,%rdx
lea    0x1953(%rip),%rsi
mov    $0x0,%al
call   1090 <sscanf@plt>
and    $0x0,%eax
cmp    $0x0,%eax
je     178a <main+0x5ea>
mov    -0x10(%rbp),%rax
mov    0x40(%rax),%rax
mov    0x8(%rax),%rdi
mov    -0x10(%rbp),%rdx
add    $0x8,%rdx
add    $0x58,%rdx
lea    0x1921(%rip),%rsi
mov    $0x0,%al
call   1090 <sscanf@plt>
and    $0x0,%eax
cmp    $0x0,%eax
jne    178a <main+0x5ea>
mov    -0x10(%rbp),%rax
mov    0x40(%rax),%rax
mov    0x10(%rax),%rdi
mov    -0x10(%rbp),%rdx
add    $0x10,%rdx
add    $0x58,%rdx
lea    0x18ef(%rip),%rsi
mov    $0x0,%al
call   1090 <sscanf@plt>
and    $0x0,%eax
cmp    $0x0,%eax
jne    178a <main+0x5ea>
mov    -0x10(%rbp),%rax
mov    0x40(%rax),%rax
mov    0x18(%rax),%rdi
mov    -0x10(%rbp),%rdx
add    $0x18,%rdx
add    $0x58,%rdx
lea    0x18bd(%rip),%rsi
mov    $0x0,%al
call   1090 <sscanf@plt>
and    $0x0,%eax
cmp    $0x0,%eax
je     17be <main+0x61e>
mov    -0x10(%rbp),%rax
mov    0x68(%rax),%rax
mov    -0x10(%rbp),%rcx
mov    %rax,0x70(%rcx)
and    $0x0,%rax
cmp    $0x0,%rax
jne    18d4 <main+0x734>
mov    -0x10(%rbp),%rax
movq   $0x1,0x68(%rax)
xor    %eax,%eax
test   $0x1,%al
jne    18d4 <main+0x734>
xor    %edi,%edi
mov    $0x0,%al
call   1080 <time@plt>
mov    %eax,%edi
mov    $0x0,%al
call   1060 <srand@plt>
xor    %eax,%eax
test   $0x1,%al
jne    18d4 <main+0x734>
mov    -0x10(%rbp),%rax
movq   $0x0,0x20(%rax)
xor    %eax,%eax
test   $0x1,%al
jne    18d4 <main+0x734>
mov    -0x10(%rbp),%rsi
mov    $0x9,%edi
call   10a0 <main@plt>
cmp    $0x0,%eax
jne    18d4 <main+0x734>
mov    -0x10(%rbp),%rax
mov    0x40(%rax),%rax
mov    (%rax),%rdi
mov    -0x10(%rbp),%rax
mov    0x60(%rax),%rcx
mov    -0x10(%rbp),%rax
imul   0x68(%rax),%rcx
mov    -0x10(%rbp),%rax
imul   0x70(%rax),%rcx
mov    $0x1,%esi
lea    0x17fc(%rip),%rdx
mov    $0x0,%al
call   1050 <snprintf@plt>
cltq
mov    -0x10(%rbp),%rcx
mov    %rax,0xf8(%rcx)
and    $0x0,%rax
cmp    $0x0,%rax
jne    18d4 <main+0x734>
lea    0x17d7(%rip),%rdi
mov    $0x0,%al
call   1030 <system@plt>
cmp    $0x0,%eax
jne    18d4 <main+0x734>
lea    0x17d2(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
cmp    $0x0,%eax
je     18d4 <main+0x734>
mov    -0x10(%rbp),%rsi
mov    $0xd,%edi
call   10a0 <main@plt>
cmp    $0x0,%eax
jne    18d4 <main+0x734>
mov    -0x10(%rbp),%rsi
mov    $0x12,%edi
call   10a0 <main@plt>
cmp    $0x0,%eax
jne    18d4 <main+0x734>
mov    -0x10(%rbp),%rsi
mov    $0xf,%edi
call   10a0 <main@plt>
mov    %eax,%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x11(%rbp)
je     2395 <main+0x11f5>
mov    -0x8(%rbp),%eax
sub    $0x9,%eax
cmp    $0x0,%eax
jne    19da <main+0x83a>
mov    -0x10(%rbp),%rax
mov    0x20(%rax),%rcx
mov    -0x10(%rbp),%rax
mov    0x60(%rax),%rax
mov    -0x10(%rbp),%rdx
imul   0x68(%rdx),%rax
mov    -0x10(%rbp),%rdx
imul   0x70(%rdx),%rax
sub    %rax,%rcx
xor    %eax,%eax
cmp    $0x0,%rcx
mov    %al,-0x11(%rbp)
je     2395 <main+0x11f5>
mov    -0x10(%rbp),%rsi
mov    $0x10,%edi
call   10a0 <main@plt>
mov    %eax,%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x11(%rbp)
jne    2395 <main+0x11f5>
mov    -0x10(%rbp),%rax
mov    (%rax),%rcx
mov    -0x10(%rbp),%rax
mov    -0x10(%rbp),%rdx
mov    0x20(%rdx),%rdx
mov    %rcx,0x100(%rax,%rdx,8)
and    $0x0,%rcx
xor    %eax,%eax
cmp    $0x0,%rcx
mov    %al,-0x11(%rbp)
jne    2395 <main+0x11f5>
mov    -0x10(%rbp),%rax
cmpq   $0x0,(%rax)
jne    1994 <main+0x7f4>
mov    -0x10(%rbp),%rax
mov    0x20(%rax),%rcx
mov    -0x10(%rbp),%rax
mov    %rcx,0x78(%rax)
and    $0x0,%rcx
xor    %eax,%eax
cmp    $0x0,%rcx
mov    %al,-0x11(%rbp)
jne    2395 <main+0x11f5>
mov    -0x10(%rbp),%rax
mov    0x20(%rax),%rcx
add    $0x1,%rcx
mov    -0x10(%rbp),%rax
mov    %rcx,0x20(%rax)
and    $0x0,%rcx
xor    %eax,%eax
cmp    $0x0,%rcx
mov    %al,-0x11(%rbp)
jne    2395 <main+0x11f5>
movslq -0x8(%rbp),%rax
mov    %eax,%edi
mov    -0x10(%rbp),%rsi
call   10a0 <main@plt>
mov    %eax,%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x11(%rbp)
je     2395 <main+0x11f5>
mov    -0x8(%rbp),%eax
sub    $0x10,%eax
cmp    $0x0,%eax
jne    1a9b <main+0x8fb>
mov    $0x0,%al
call   10c0 <rand@plt>
cltq
mov    -0x10(%rbp),%rcx
mov    0x60(%rcx),%rcx
mov    -0x10(%rbp),%rdx
imul   0x68(%rdx),%rcx
mov    -0x10(%rbp),%rdx
imul   0x70(%rdx),%rcx
cqto
idiv   %rcx
mov    -0x10(%rbp),%rax
mov    %rdx,(%rax)
and    $0x0,%rdx
cmp    $0x0,%rdx
jne    1a9b <main+0x8fb>
mov    -0x10(%rbp),%rax
movq   $0x0,0x8(%rax)
xor    %eax,%eax
test   $0x1,%al
jne    1a9b <main+0x8fb>
mov    -0x10(%rbp),%rax
movq   $0x0,0x28(%rax)
xor    %eax,%eax
test   $0x1,%al
jne    1a9b <main+0x8fb>
mov    -0x10(%rbp),%rsi
mov    $0x11,%edi
call   10a0 <main@plt>
cmp    $0x0,%eax
jne    1a9b <main+0x8fb>
mov    -0x10(%rbp),%rcx
xor    %eax,%eax
cmpq   $0x0,0x8(%rcx)
mov    %al,-0x11(%rbp)
je     2395 <main+0x11f5>
mov    -0x10(%rbp),%rsi
mov    $0x10,%edi
call   10a0 <main@plt>
mov    %eax,%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x11(%rbp)
je     2395 <main+0x11f5>
mov    -0x8(%rbp),%eax
sub    $0x11,%eax
cmp    $0x0,%eax
jne    1b71 <main+0x9d1>
mov    -0x10(%rbp),%rax
mov    0x28(%rax),%rcx
mov    -0x10(%rbp),%rax
sub    0x20(%rax),%rcx
xor    %eax,%eax
cmp    $0x0,%rcx
mov    %al,-0x11(%rbp)
je     2395 <main+0x11f5>
mov    -0x10(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    0x28(%rcx),%rcx
mov    0x100(%rax,%rcx,8),%rax
mov    -0x10(%rbp),%rcx
sub    (%rcx),%rax
cmp    $0x0,%rax
jne    1b2b <main+0x98b>
mov    -0x10(%rbp),%rax
movq   $0x1,0x8(%rax)
xor    %eax,%eax
test   $0x1,%al
jne    1b2b <main+0x98b>
mov    -0x10(%rbp),%rax
mov    0x20(%rax),%rcx
sub    $0x1,%rcx
mov    -0x10(%rbp),%rax
mov    %rcx,0x28(%rax)
and    $0x0,%rcx
xor    %eax,%eax
cmp    $0x0,%rcx
mov    %al,-0x11(%rbp)
je     2395 <main+0x11f5>
mov    -0x10(%rbp),%rax
mov    0x28(%rax),%rcx
add    $0x1,%rcx
mov    -0x10(%rbp),%rax
mov    %rcx,0x28(%rax)
and    $0x0,%rcx
xor    %eax,%eax
cmp    $0x0,%rcx
mov    %al,-0x11(%rbp)
jne    2395 <main+0x11f5>
movslq -0x8(%rbp),%rax
mov    %eax,%edi
mov    -0x10(%rbp),%rsi
call   10a0 <main@plt>
mov    %eax,%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x11(%rbp)
je     2395 <main+0x11f5>
mov    -0x8(%rbp),%eax
sub    $0x12,%eax
cmp    $0x0,%eax
jne    220f <main+0x106f>
mov    -0x10(%rbp),%rax
movq   $0x0,(%rax)
xor    %eax,%eax
test   $0x1,%al
jne    220f <main+0x106f>
mov    -0x10(%rbp),%rax
movq   $0x0,0x20(%rax)
xor    %eax,%eax
test   $0x1,%al
jne    220f <main+0x106f>
mov    -0x10(%rbp),%rsi
mov    $0x13,%edi
call   10a0 <main@plt>
cmp    $0x0,%eax
jne    220f <main+0x106f>
mov    -0x10(%rbp),%rax
cmpq   $0x0,(%rax)
jne    1be7 <main+0xa47>
lea    0x1478(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
cmp    $0x0,%eax
je     220f <main+0x106f>
mov    -0x10(%rbp),%rcx
xor    %eax,%eax
cmpq   $0x0,(%rcx)
mov    %al,-0x11(%rbp)
je     2395 <main+0x11f5>
mov    $0x0,%al
call   1070 <getchar@plt>
cltq
mov    -0x10(%rbp),%rcx
movslq -0x8(%rbp),%rdx
mov    %rax,(%rcx,%rdx,8)
and    $0x0,%rax
cmp    $0x0,%rax
jne    220f <main+0x106f>
mov    -0x10(%rbp),%rax
movslq -0x8(%rbp),%rcx
cmpq   $0x69,(%rax,%rcx,8)
jne    1d27 <main+0xb87>
mov    -0x10(%rbp),%rax
mov    0x78(%rax),%rax
mov    -0x10(%rbp),%rcx
mov    0x60(%rcx),%rcx
mov    -0x10(%rbp),%rdx
imul   0x68(%rdx),%rcx
cqto
idiv   %rcx
mov    %rax,%rcx
xor    %eax,%eax
cmp    %rcx,%rax
jge    1d27 <main+0xb87>
mov    -0x10(%rbp),%rax
add    $0x100,%rax
mov    -0x10(%rbp),%rdx
xor    %ecx,%ecx
sub    0x60(%rdx),%rcx
mov    -0x10(%rbp),%rdx
imul   0x68(%rdx),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    -0x10(%rbp),%rcx
mov    0x78(%rcx),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x10(%rbp),%rcx
mov    -0x10(%rbp),%rdx
mov    0x78(%rdx),%rdx
add    $0x20,%rdx
mov    %rax,(%rcx,%rdx,8)
and    $0x0,%rax
cmp    $0x0,%rax
jne    1d10 <main+0xb70>
mov    -0x10(%rbp),%rax
mov    -0x10(%rbp),%rdx
xor    %ecx,%ecx
sub    0x60(%rdx),%rcx
mov    -0x10(%rbp),%rdx
imul   0x68(%rdx),%rcx
add    $0x20,%rcx
mov    -0x10(%rbp),%rdx
add    0x78(%rdx),%rcx
movq   $0x0,(%rax,%rcx,8)
xor    %eax,%eax
test   $0x1,%al
jne    1d10 <main+0xb70>
mov    -0x10(%rbp),%rcx
xor    %eax,%eax
sub    0x60(%rcx),%rax
mov    -0x10(%rbp),%rcx
imul   0x68(%rcx),%rax
mov    -0x10(%rbp),%rcx
add    0x78(%rcx),%rax
mov    %rax,0x78(%rcx)
or     $0x1,%rax
cmp    $0x0,%rax
je     1d27 <main+0xb87>
mov    -0x10(%rbp),%rsi
mov    $0xd,%edi
call   10a0 <main@plt>
cmp    $0x0,%eax
jne    220f <main+0x106f>
mov    -0x10(%rbp),%rax
movslq -0x8(%rbp),%rcx
cmpq   $0x6a,(%rax,%rcx,8)
jne    1de4 <main+0xc44>
mov    -0x10(%rbp),%rax
mov    0x78(%rax),%rax
mov    -0x10(%rbp),%rcx
cqto
idivq  0x60(%rcx)
xor    %eax,%eax
cmp    %rdx,%rax
jge    1de4 <main+0xc44>
mov    -0x10(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    0x78(%rcx),%rcx
mov    0xf8(%rax,%rcx,8),%rax
mov    -0x10(%rbp),%rcx
mov    -0x10(%rbp),%rdx
mov    0x78(%rdx),%rdx
add    $0x20,%rdx
mov    %rax,(%rcx,%rdx,8)
and    $0x0,%rax
cmp    $0x0,%rax
jne    1dcd <main+0xc2d>
mov    -0x10(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    0x78(%rcx),%rcx
add    $0x1f,%rcx
movq   $0x0,(%rax,%rcx,8)
xor    %eax,%eax
test   $0x1,%al
jne    1dcd <main+0xc2d>
mov    -0x10(%rbp),%rcx
mov    0x78(%rcx),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,0x78(%rcx)
or     $0x1,%rax
cmp    $0x0,%rax
je     1de4 <main+0xc44>
mov    -0x10(%rbp),%rsi
mov    $0xd,%edi
call   10a0 <main@plt>
cmp    $0x0,%eax
jne    220f <main+0x106f>
mov    -0x10(%rbp),%rax
movslq -0x8(%rbp),%rcx
cmpq   $0x6b,(%rax,%rcx,8)
jne    1eef <main+0xd4f>
mov    -0x10(%rbp),%rax
mov    0x78(%rax),%rax
mov    -0x10(%rbp),%rcx
mov    0x60(%rcx),%rcx
mov    -0x10(%rbp),%rdx
imul   0x68(%rdx),%rcx
cqto
idiv   %rcx
mov    -0x10(%rbp),%rcx
mov    0x70(%rcx),%rcx
sub    $0x1,%rcx
cmp    %rcx,%rax
jge    1eef <main+0xd4f>
mov    -0x10(%rbp),%rax
add    $0x100,%rax
mov    -0x10(%rbp),%rcx
mov    0x60(%rcx),%rcx
mov    -0x10(%rbp),%rdx
imul   0x68(%rdx),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    -0x10(%rbp),%rcx
mov    0x78(%rcx),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x10(%rbp),%rcx
mov    -0x10(%rbp),%rdx
mov    0x78(%rdx),%rdx
add    $0x20,%rdx
mov    %rax,(%rcx,%rdx,8)
and    $0x0,%rax
cmp    $0x0,%rax
jne    1ed8 <main+0xd38>
mov    -0x10(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    0x60(%rcx),%rcx
mov    -0x10(%rbp),%rdx
imul   0x68(%rdx),%rcx
add    $0x20,%rcx
mov    -0x10(%rbp),%rdx
add    0x78(%rdx),%rcx
movq   $0x0,(%rax,%rcx,8)
xor    %eax,%eax
test   $0x1,%al
jne    1ed8 <main+0xd38>
mov    -0x10(%rbp),%rax
mov    0x60(%rax),%rax
mov    -0x10(%rbp),%rcx
imul   0x68(%rcx),%rax
mov    -0x10(%rbp),%rcx
add    0x78(%rcx),%rax
mov    %rax,0x78(%rcx)
or     $0x1,%rax
cmp    $0x0,%rax
je     1eef <main+0xd4f>
mov    -0x10(%rbp),%rsi
mov    $0xd,%edi
call   10a0 <main@plt>
cmp    $0x0,%eax
jne    220f <main+0x106f>
mov    -0x10(%rbp),%rax
movslq -0x8(%rbp),%rcx
cmpq   $0x6c,(%rax,%rcx,8)
jne    1fb6 <main+0xe16>
mov    -0x10(%rbp),%rax
mov    0x78(%rax),%rax
mov    -0x10(%rbp),%rcx
cqto
idivq  0x60(%rcx)
mov    -0x10(%rbp),%rax
mov    0x60(%rax),%rax
sub    $0x1,%rax
cmp    %rax,%rdx
jge    1fb6 <main+0xe16>
mov    -0x10(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    0x78(%rcx),%rcx
mov    0x108(%rax,%rcx,8),%rax
mov    -0x10(%rbp),%rcx
mov    -0x10(%rbp),%rdx
mov    0x78(%rdx),%rdx
add    $0x20,%rdx
mov    %rax,(%rcx,%rdx,8)
and    $0x0,%rax
cmp    $0x0,%rax
jne    1f9f <main+0xdff>
mov    -0x10(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    0x78(%rcx),%rcx
add    $0x21,%rcx
movq   $0x0,(%rax,%rcx,8)
xor    %eax,%eax
test   $0x1,%al
jne    1f9f <main+0xdff>
mov    -0x10(%rbp),%rcx
mov    0x78(%rcx),%rax
add    $0x1,%rax
mov    %rax,0x78(%rcx)
or     $0x1,%rax
cmp    $0x0,%rax
je     1fb6 <main+0xe16>
mov    -0x10(%rbp),%rsi
mov    $0xd,%edi
call   10a0 <main@plt>
cmp    $0x0,%eax
jne    220f <main+0x106f>
mov    -0x10(%rbp),%rax
movslq -0x8(%rbp),%rcx
cmpq   $0x6e,(%rax,%rcx,8)
jne    20b3 <main+0xf13>
mov    -0x10(%rbp),%rax
mov    0x78(%rax),%rax
mov    -0x10(%rbp),%rcx
mov    0x60(%rcx),%rcx
mov    -0x10(%rbp),%rdx
imul   0x68(%rdx),%rcx
cqto
idiv   %rcx
mov    %rdx,%rax
mov    -0x10(%rbp),%rcx
cqto
idivq  0x60(%rcx)
mov    -0x10(%rbp),%rcx
mov    0x68(%rcx),%rcx
sub    $0x1,%rcx
cmp    %rcx,%rax
jge    20b3 <main+0xf13>
mov    -0x10(%rbp),%rax
add    $0x100,%rax
mov    -0x10(%rbp),%rcx
mov    0x60(%rcx),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    -0x10(%rbp),%rcx
mov    0x78(%rcx),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x10(%rbp),%rcx
mov    -0x10(%rbp),%rdx
mov    0x78(%rdx),%rdx
add    $0x20,%rdx
mov    %rax,(%rcx,%rdx,8)
and    $0x0,%rax
cmp    $0x0,%rax
jne    209c <main+0xefc>
mov    -0x10(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    0x60(%rcx),%rcx
add    $0x20,%rcx
mov    -0x10(%rbp),%rdx
add    0x78(%rdx),%rcx
movq   $0x0,(%rax,%rcx,8)
xor    %eax,%eax
test   $0x1,%al
jne    209c <main+0xefc>
mov    -0x10(%rbp),%rax
mov    0x60(%rax),%rax
mov    -0x10(%rbp),%rcx
add    0x78(%rcx),%rax
mov    %rax,0x78(%rcx)
or     $0x1,%rax
cmp    $0x0,%rax
je     20b3 <main+0xf13>
mov    -0x10(%rbp),%rsi
mov    $0xd,%edi
call   10a0 <main@plt>
cmp    $0x0,%eax
jne    220f <main+0x106f>
mov    -0x10(%rbp),%rax
movslq -0x8(%rbp),%rcx
cmpq   $0x6f,(%rax,%rcx,8)
jne    21af <main+0x100f>
mov    -0x10(%rbp),%rax
mov    0x78(%rax),%rax
mov    -0x10(%rbp),%rcx
mov    0x60(%rcx),%rcx
mov    -0x10(%rbp),%rdx
imul   0x68(%rdx),%rcx
cqto
idiv   %rcx
mov    %rdx,%rax
mov    -0x10(%rbp),%rcx
cqto
idivq  0x60(%rcx)
mov    %rax,%rcx
xor    %eax,%eax
cmp    %rcx,%rax
jge    21af <main+0x100f>
mov    -0x10(%rbp),%rax
add    $0x100,%rax
mov    -0x10(%rbp),%rdx
xor    %ecx,%ecx
sub    0x60(%rdx),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    -0x10(%rbp),%rcx
mov    0x78(%rcx),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x10(%rbp),%rcx
mov    -0x10(%rbp),%rdx
mov    0x78(%rdx),%rdx
add    $0x20,%rdx
mov    %rax,(%rcx,%rdx,8)
and    $0x0,%rax
cmp    $0x0,%rax
jne    2198 <main+0xff8>
mov    -0x10(%rbp),%rax
mov    -0x10(%rbp),%rdx
xor    %ecx,%ecx
sub    0x60(%rdx),%rcx
add    $0x20,%rcx
mov    -0x10(%rbp),%rdx
add    0x78(%rdx),%rcx
movq   $0x0,(%rax,%rcx,8)
xor    %eax,%eax
test   $0x1,%al
jne    2198 <main+0xff8>
mov    -0x10(%rbp),%rcx
xor    %eax,%eax
sub    0x60(%rcx),%rax
mov    -0x10(%rbp),%rcx
add    0x78(%rcx),%rax
mov    %rax,0x78(%rcx)
or     $0x1,%rax
cmp    $0x0,%rax
je     21af <main+0x100f>
mov    -0x10(%rbp),%rsi
mov    $0xd,%edi
call   10a0 <main@plt>
cmp    $0x0,%eax
jne    220f <main+0x106f>
mov    -0x10(%rbp),%rax
movslq -0x8(%rbp),%rcx
cmpq   $0x71,(%rax,%rcx,8)
jne    21f0 <main+0x1050>
lea    0xe90(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
cmp    $0x0,%eax
je     21f0 <main+0x1050>
mov    -0x10(%rbp),%rsi
mov    $0xf,%edi
call   10a0 <main@plt>
cmp    $0x0,%eax
jne    220f <main+0x106f>
movslq -0x8(%rbp),%rax
mov    %eax,%edi
mov    -0x10(%rbp),%rsi
call   10a0 <main@plt>
mov    %eax,%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x11(%rbp)
je     2395 <main+0x11f5>
mov    -0x8(%rbp),%eax
sub    $0x13,%eax
cmp    $0x0,%eax
jne    233d <main+0x119d>
mov    -0x10(%rbp),%rax
mov    0x20(%rax),%rcx
mov    -0x10(%rbp),%rax
mov    0x60(%rax),%rax
mov    -0x10(%rbp),%rdx
imul   0x68(%rdx),%rax
mov    -0x10(%rbp),%rdx
imul   0x70(%rdx),%rax
sub    %rax,%rcx
xor    %eax,%eax
cmp    $0x0,%rcx
mov    %al,-0x11(%rbp)
je     2395 <main+0x11f5>
mov    -0x10(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    0x20(%rcx),%rcx
mov    0x100(%rax,%rcx,8),%rax
mov    %rax,-0x28(%rbp)
mov    -0x10(%rbp),%rax
mov    0x20(%rax),%rax
add    $0x1,%rax
mov    -0x10(%rbp),%rcx
mov    0x60(%rcx),%rcx
mov    -0x10(%rbp),%rdx
imul   0x68(%rdx),%rcx
mov    -0x10(%rbp),%rdx
imul   0x70(%rdx),%rcx
cqto
idiv   %rcx
mov    -0x28(%rbp),%rax
sub    %rdx,%rax
cmp    $0x0,%rax
je     22f7 <main+0x1157>
mov    -0x10(%rbp),%rax
movq   $0x1,(%rax)
xor    %eax,%eax
test   $0x1,%al
mov    %al,-0x11(%rbp)
jne    2395 <main+0x11f5>
mov    -0x10(%rbp),%rax
mov    0x60(%rax),%rcx
mov    -0x10(%rbp),%rax
imul   0x68(%rax),%rcx
mov    -0x10(%rbp),%rax
imul   0x70(%rax),%rcx
sub    $0x1,%rcx
mov    -0x10(%rbp),%rax
mov    %rcx,0x20(%rax)
and    $0x0,%rcx
xor    %eax,%eax
cmp    $0x0,%rcx
mov    %al,-0x11(%rbp)
jne    2395 <main+0x11f5>
mov    -0x10(%rbp),%rax
mov    0x20(%rax),%rcx
add    $0x1,%rcx
mov    -0x10(%rbp),%rax
mov    %rcx,0x20(%rax)
and    $0x0,%rcx
xor    %eax,%eax
cmp    $0x0,%rcx
mov    %al,-0x11(%rbp)
jne    2395 <main+0x11f5>
movslq -0x8(%rbp),%rax
mov    %eax,%edi
mov    -0x10(%rbp),%rsi
call   10a0 <main@plt>
mov    %eax,%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x11(%rbp)
je     2395 <main+0x11f5>
mov    -0x8(%rbp),%eax
sub    $0xf,%eax
cmp    $0x0,%eax
jne    236a <main+0x11ca>
lea    0xd14(%rip),%rdi
mov    $0x0,%al
call   1030 <system@plt>
cmp    $0x0,%eax
jne    236a <main+0x11ca>
xor    %edi,%edi
call   10b0 <exit@plt>
mov    -0x8(%rbp),%ecx
sub    $0x5,%ecx
mov    $0x1,%al
cmp    $0x0,%ecx
mov    %al,-0x29(%rbp)
jne    238f <main+0x11ef>
lea    -0x8(%rbp),%rax
mov    -0x10(%rbp),%rcx
cmp    %rcx,%rax
setb   %al
mov    %al,-0x29(%rbp)
mov    -0x29(%rbp),%al
mov    %al,-0x11(%rbp)
mov    -0x11(%rbp),%al
and    $0x1,%al
movzbl %al,%eax
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r14
push   %rbx
sub    $0x10,%rsp
mov    %edi,0x4(%rsp)
mov    %rsi,0x8(%rsp)
lea    -0x1(%rdi),%eax
and    $0xfffffffe,%eax
cmp    $0x2,%eax
jne    11ed <main+0x4d>
lea    0x4(%rsp),%rbx
mov    $0x5,%edi
mov    %rbx,%rsi
call   10a0 <main@plt>
cmp    $0x1,%eax
mov    $0x7,%edi
sbb    $0x0,%edi
mov    %rbx,%rsi
call   10a0 <main@plt>
test   %eax,%eax
je     1cdd <main+0xb3d>
mov    0x4(%rsp),%edi
cmp    $0xd,%edi
jne    1226 <main+0x86>
lea    0xe07(%rip),%rdi
xor    %r14d,%r14d
xor    %eax,%eax
call   1040 <printf@plt>
test   %eax,%eax
je     1226 <main+0x86>
mov    0x8(%rsp),%rsi
movq   $0x0,0x20(%rsi)
mov    $0xe,%edi
call   10a0 <main@plt>
test   %eax,%eax
je     1ce0 <main+0xb40>
mov    0x4(%rsp),%eax
cmp    $0xe,%eax
jne    1418 <main+0x278>
mov    0x8(%rsp),%rbx
mov    0x20(%rbx),%rcx
mov    0x60(%rbx),%rdi
mov    0x68(%rbx),%rsi
mov    %rsi,%rbp
imul   %rdi,%rbp
mov    0x70(%rbx),%rax
imul   %rbp,%rax
xor    %r14d,%r14d
cmp    %rax,%rcx
je     1ce0 <main+0xb40>
mov    %rcx,%rax
or     %rdi,%rax
shr    $0x20,%rax
je     127a <main+0xda>
mov    %rcx,%rax
cqto
idiv   %rdi
test   %rdx,%rdx
jne    12e8 <main+0x148>
jmp    1285 <main+0xe5>
mov    %ecx,%eax
xor    %edx,%edx
div    %edi
test   %rdx,%rdx
jne    12e8 <main+0x148>
mov    %rcx,%rax
or     %rbp,%rax
shr    $0x20,%rax
je     129e <main+0xfe>
mov    %rcx,%rax
cqto
idiv   %rbp
mov    %rdx,%rax
jmp    12a6 <main+0x106>
mov    %ecx,%eax
xor    %edx,%edx
div    %ebp
mov    %edx,%eax
mov    %rax,%rcx
or     %rdi,%rcx
shr    $0x20,%rcx
je     12b9 <main+0x119>
cqto
idiv   %rdi
jmp    12bd <main+0x11d>
xor    %edx,%edx
div    %edi
sub    %eax,%esi
lea    0xd3f(%rip),%rdi
lea    0xd8b(%rip),%rdx
xor    %r14d,%r14d
xor    %eax,%eax
call   1040 <printf@plt>
test   %eax,%eax
je     1ce0 <main+0xb40>
mov    0x8(%rsp),%rbx
mov    0x20(%rbx),%rcx
mov    0x100(%rbx,%rcx,8),%rdx
test   %rdx,%rdx
je     1312 <main+0x172>
mov    0xf8(%rbx),%esi
lea    0xd07(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
test   %eax,%eax
jne    132f <main+0x18f>
mov    0x8(%rsp),%rbx
mov    0xf8(%rbx),%edx
lea    0xcef(%rip),%rdi
lea    0xcee(%rip),%rcx
mov    %edx,%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x8(%rsp),%rcx
mov    0x20(%rcx),%rax
mov    0x60(%rcx),%rsi
mov    %rax,%rdx
or     %rsi,%rdx
shr    $0x20,%rdx
je     134f <main+0x1af>
cqto
idiv   %rsi
jmp    1353 <main+0x1b3>
xor    %edx,%edx
div    %esi
add    $0xffffffffffffffff,%rsi
cmp    %rsi,%rdx
jne    1373 <main+0x1d3>
lea    0xcf4(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
test   %eax,%eax
jne    138e <main+0x1ee>
mov    0x8(%rsp),%rcx
mov    0x68(%rcx),%esi
add    $0x1,%esi
lea    0xc85(%rip),%rdi
lea    0xcd1(%rip),%rdx
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x8(%rsp),%rsi
mov    0x20(%rsi),%rcx
mov    0x68(%rsi),%rdi
add    $0x1,%rcx
mov    0x60(%rsi),%rbp
imul   %rdi,%rbp
mov    %rcx,%rax
or     %rbp,%rax
shr    $0x20,%rax
je     13c2 <main+0x222>
mov    %rcx,%rax
cqto
idiv   %rbp
test   %rdx,%rdx
je     13cd <main+0x22d>
jmp    13f9 <main+0x259>
mov    %ecx,%eax
xor    %edx,%edx
div    %ebp
test   %rdx,%rdx
jne    13f9 <main+0x259>
cmp    $0x2,%rdi
jl     13f9 <main+0x259>
lea    0xc7d(%rip),%rdi
xor    %r14d,%r14d
xor    %eax,%eax
call   1040 <printf@plt>
test   %eax,%eax
je     1ce0 <main+0xb40>
mov    0x8(%rsp),%rsi
mov    0x20(%rsi),%rcx
add    $0x1,%rcx
mov    %rcx,0x20(%rsi)
mov    0x4(%rsp),%edi
call   10a0 <main@plt>
mov    $0x0,%r14d
test   %eax,%eax
je     1ce0 <main+0xb40>
mov    0x4(%rsp),%eax
add    $0xffffffff,%eax
cmp    $0x1,%eax
ja     1454 <main+0x2b4>
mov    0x8(%rsp),%rax
mov    (%rax),%rsi
lea    0xbeb(%rip),%rdi
xor    %r14d,%r14d
xor    %eax,%eax
call   1040 <printf@plt>
test   %eax,%eax
je     1454 <main+0x2b4>
mov    0x8(%rsp),%rsi
mov    $0xf,%edi
call   10a0 <main@plt>
test   %eax,%eax
je     1ce0 <main+0xb40>
mov    0x4(%rsp),%edi
mov    %edi,%eax
and    $0xfffffffe,%eax
cmp    $0x6,%eax
jne    14fa <main+0x35a>
mov    %edi,%ecx
and    $0x1,%ecx
mov    0x8(%rsp),%rsi
lea    0x4(%rsp),%rbx
mov    %rsi,%rbp
sub    %rbx,%rbp
sar    $0x3,%rbp
imul   %rcx,%rbp
mov    %ecx,%eax
xor    $0x1,%eax
mov    %rbx,%rdx
sub    %rsi,%rdx
sar    $0x3,%rdx
imul   %rax,%rdx
add    %rbp,%rdx
cmp    $0x1000,%rdx
jb     14e9 <main+0x349>
lea    0x8(%rsp),%rdx
sub    %rbx,%rdx
mov    (%rsi,%rdx,1),%rdx
imul   %rbx,%rcx
imul   %rsi,%rax
mov    %rdx,0x40(%rax,%rcx,1)
test   %rdx,%rdx
je     14e9 <main+0x349>
add    %rcx,%rax
mov    (%rsi),%rcx
mov    %rcx,0x48(%rax)
test   %rcx,%rcx
je     14e9 <main+0x349>
mov    $0x8,%edi
mov    %rax,%rsi
call   10a0 <main@plt>
test   %eax,%eax
jne    14f6 <main+0x356>
mov    0x4(%rsp),%edi
mov    0x8(%rsp),%rsi
call   10a0 <main@plt>
test   %eax,%eax
je     1cdd <main+0xb3d>
mov    0x4(%rsp),%edi
cmp    $0x8,%edi
jne    15f7 <main+0x457>
mov    0x8(%rsp),%rdx
mov    0x48(%rdx),%bl
mov    0x40(%rdx),%rax
mov    0x8(%rax),%rdi
add    $0x60,%rdx
lea    0xb16(%rip),%rbp
mov    %rbp,%rsi
xor    %eax,%eax
call   1090 <sscanf@plt>
mov    0x8(%rsp),%rdx
mov    0x40(%rdx),%rax
mov    0x10(%rax),%rdi
add    $0x68,%rdx
mov    %rbp,%rsi
xor    %eax,%eax
call   1090 <sscanf@plt>
mov    0x8(%rsp),%rdx
test   $0x1,%bl
jne    1569 <main+0x3c9>
mov    0x40(%rdx),%rax
mov    0x18(%rax),%rdi
add    $0x70,%rdx
lea    0xad4(%rip),%rsi
xor    %eax,%eax
call   1090 <sscanf@plt>
jmp    1579 <main+0x3d9>
mov    0x68(%rdx),%rax
mov    %rax,0x70(%rdx)
movq   $0x1,0x68(%rdx)
xor    %edi,%edi
xor    %eax,%eax
call   1080 <time@plt>
mov    %eax,%edi
xor    %eax,%eax
call   1060 <srand@plt>
mov    0x8(%rsp),%rsi
movq   $0x0,0x20(%rsi)
mov    $0x9,%edi
call   10a0 <main@plt>
test   %eax,%eax
jne    15f7 <main+0x457>
mov    0x8(%rsp),%rax
mov    0x40(%rax),%rdx
mov    0x68(%rax),%rcx
mov    (%rdx),%rdi
imul   0x60(%rax),%rcx
imul   0x70(%rax),%rcx
lea    0xa6d(%rip),%rdx
mov    $0x1,%esi
xor    %eax,%eax
call   1050 <snprintf@plt>
cltq
mov    0x8(%rsp),%rcx
mov    %rax,0xf8(%rcx)
lea    0xa50(%rip),%rdi
xor    %eax,%eax
call   1030 <system@plt>
test   %eax,%eax
je     1740 <main+0x5a0>
mov    0x4(%rsp),%eax
cmp    $0x9,%eax
jne    1671 <main+0x4d1>
mov    0x8(%rsp),%rsi
mov    0x68(%rsi),%rax
imul   0x60(%rsi),%rax
imul   0x70(%rsi),%rax
xor    %r14d,%r14d
cmp    %rax,0x20(%rsi)
je     1ce0 <main+0xb40>
mov    $0x10,%edi
call   10a0 <main@plt>
test   %eax,%eax
jne    1ce0 <main+0xb40>
mov    0x8(%rsp),%rsi
mov    (%rsi),%rax
mov    0x20(%rsi),%rcx
mov    %rax,0x100(%rsi,%rcx,8)
cmpq   $0x0,(%rsi)
mov    0x20(%rsi),%rax
jne    1654 <main+0x4b4>
mov    %rax,0x78(%rsi)
add    $0x1,%rax
mov    %rax,0x20(%rsi)
mov    0x4(%rsp),%edi
call   10a0 <main@plt>
test   %eax,%eax
je     1ce0 <main+0xb40>
mov    0x4(%rsp),%eax
cmp    $0x10,%eax
jne    16ce <main+0x52e>
xor    %eax,%eax
call   10c0 <rand@plt>
movslq %eax,%rcx
mov    0x8(%rsp),%rsi
mov    0x68(%rsi),%rdi
imul   0x60(%rsi),%rdi
imul   0x70(%rsi),%rdi
mov    %rcx,%rdx
or     %rdi,%rdx
shr    $0x20,%rdx
je     16a9 <main+0x509>
mov    %rcx,%rax
cqto
idiv   %rdi
jmp    16ad <main+0x50d>
xor    %edx,%edx
div    %edi
mov    %rdx,(%rsi)
movq   $0x0,0x8(%rsi)
movq   $0x0,0x28(%rsi)
mov    $0x11,%edi
call   10a0 <main@plt>
test   %eax,%eax
je     171a <main+0x57a>
mov    0x4(%rsp),%eax
cmp    $0x11,%eax
jne    17be <main+0x61e>
mov    0x8(%rsp),%rsi
mov    0x20(%rsi),%rax
mov    0x28(%rsi),%rcx
xor    %r14d,%r14d
cmp    %rax,%rcx
je     1ce0 <main+0xb40>
mov    0x100(%rsi,%rcx,8),%rdx
cmp    (%rsi),%rdx
jne    17a0 <main+0x600>
movq   $0x1,0x8(%rsi)
add    $0xffffffffffffffff,%rax
mov    %rax,0x28(%rsi)
jmp    1ce0 <main+0xb40>
mov    0x8(%rsp),%rsi
xor    %r14d,%r14d
cmpq   $0x0,0x8(%rsi)
je     1ce0 <main+0xb40>
mov    $0x10,%edi
call   10a0 <main@plt>
test   %eax,%eax
jne    16ce <main+0x52e>
jmp    1ce0 <main+0xb40>
lea    0x903(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
test   %eax,%eax
je     15f7 <main+0x457>
mov    0x8(%rsp),%rsi
mov    $0xd,%edi
call   10a0 <main@plt>
test   %eax,%eax
jne    15f7 <main+0x457>
mov    0x8(%rsp),%rsi
mov    $0x12,%edi
call   10a0 <main@plt>
test   %eax,%eax
jne    15f7 <main+0x457>
mov    0x8(%rsp),%rsi
mov    $0xf,%edi
call   10a0 <main@plt>
test   %eax,%eax
jne    15f7 <main+0x457>
jmp    1cdd <main+0xb3d>
add    $0x1,%rcx
mov    %rcx,0x28(%rsi)
mov    $0x11,%edi
call   10a0 <main@plt>
test   %eax,%eax
je     1ce0 <main+0xb40>
mov    0x4(%rsp),%eax
cmp    $0x12,%eax
jne    17e5 <main+0x645>
mov    0x8(%rsp),%rsi
movq   $0x0,(%rsi)
movq   $0x0,0x20(%rsi)
mov    $0x13,%edi
call   10a0 <main@plt>
test   %eax,%eax
je     1837 <main+0x697>
mov    0x4(%rsp),%eax
cmp    $0x13,%eax
jne    18c7 <main+0x727>
mov    0x8(%rsp),%rsi
mov    0x20(%rsi),%rcx
mov    0x68(%rsi),%rdi
imul   0x60(%rsi),%rdi
imul   0x70(%rsi),%rdi
xor    %r14d,%r14d
cmp    %rdi,%rcx
je     1ce0 <main+0xb40>
mov    0x100(%rsi,%rcx,8),%rbp
add    $0x1,%rcx
mov    %rcx,%rax
or     %rdi,%rax
shr    $0x20,%rax
je     1890 <main+0x6f0>
mov    %rcx,%rax
cqto
idiv   %rdi
jmp    1896 <main+0x6f6>
mov    0x8(%rsp),%rax
cmpq   $0x0,(%rax)
je     1904 <main+0x764>
xor    %eax,%eax
call   1070 <getchar@plt>
cltq
mov    0x8(%rsp),%rsi
movslq 0x4(%rsp),%rcx
mov    %rax,(%rsi,%rcx,8)
cmp    $0x69,%eax
jne    19a3 <main+0x803>
mov    0x68(%rsi),%rdi
mov    0x78(%rsi),%rcx
imul   0x60(%rsi),%rdi
mov    %rcx,%rax
or     %rdi,%rax
shr    $0x20,%rax
je     1931 <main+0x791>
mov    %rcx,%rax
cqto
idiv   %rdi
jmp    1937 <main+0x797>
mov    %ecx,%eax
xor    %edx,%edx
div    %edi
cmp    %rdx,%rbp
je     18ad <main+0x70d>
movq   $0x1,(%rsi)
lea    -0x1(%rdi),%rax
mov    %rax,0x20(%rsi)
mov    %rdi,%rcx
mov    %rcx,0x20(%rsi)
mov    $0x13,%edi
call   10a0 <main@plt>
test   %eax,%eax
je     1ce0 <main+0xb40>
mov    0x4(%rsp),%eax
cmp    $0xf,%eax
jne    18e6 <main+0x746>
lea    0x794(%rip),%rdi
xor    %eax,%eax
call   1030 <system@plt>
test   %eax,%eax
je     1cec <main+0xb4c>
mov    0x4(%rsp),%eax
cmp    $0x5,%eax
setne  %al
lea    0x4(%rsp),%rcx
cmp    %rcx,0x8(%rsp)
seta   %cl
or     %al,%cl
movzbl %cl,%r14d
jmp    1ce0 <main+0xb40>
lea    0x744(%rip),%rdi
xor    %r14d,%r14d
xor    %eax,%eax
call   1040 <printf@plt>
test   %eax,%eax
je     17e5 <main+0x645>
mov    0x8(%rsp),%rax
cmpq   $0x0,(%rax)
jne    1846 <main+0x6a6>
jmp    1ce0 <main+0xb40>
mov    %ecx,%eax
xor    %edx,%edx
div    %edi
test   %rax,%rax
jle    1cc7 <main+0xb27>
shl    $0x3,%rdi
mov    %rsi,%rax
sub    %rdi,%rax
mov    0x100(%rax,%rcx,8),%rax
mov    %rax,0x100(%rsi,%rcx,8)
mov    0x68(%rsi),%rax
mov    0x78(%rsi),%rcx
imul   0x60(%rsi),%rax
sub    %rax,%rcx
movq   $0x0,0x100(%rsi,%rcx,8)
mov    0x68(%rsi),%rax
imul   0x60(%rsi),%rax
sub    %rax,0x78(%rsi)
mov    $0xd,%edi
call   10a0 <main@plt>
test   %eax,%eax
jne    17e5 <main+0x645>
mov    0x8(%rsp),%rsi
movslq 0x4(%rsp),%rax
mov    (%rsi,%rax,8),%rax
cmp    $0x6a,%rax
jne    1a1b <main+0x87b>
mov    0x60(%rsi),%rdi
mov    0x78(%rsi),%rcx
mov    %rcx,%rax
or     %rdi,%rax
shr    $0x20,%rax
je     19c7 <main+0x827>
mov    %rcx,%rax
cqto
idiv   %rdi
jmp    19cd <main+0x82d>
mov    %ecx,%eax
xor    %edx,%edx
div    %edi
test   %rdx,%rdx
jle    1cc7 <main+0xb27>
mov    0xf8(%rsi,%rcx,8),%rax
mov    %rax,0x100(%rsi,%rcx,8)
mov    0x78(%rsi),%rax
movq   $0x0,0xf8(%rsi,%rax,8)
addq   $0xffffffffffffffff,0x78(%rsi)
mov    $0xd,%edi
call   10a0 <main@plt>
test   %eax,%eax
jne    17e5 <main+0x645>
mov    0x8(%rsp),%rsi
movslq 0x4(%rsp),%rax
mov    (%rsi,%rax,8),%rax
cmp    $0x6b,%rax
jne    1ab9 <main+0x919>
mov    0x68(%rsi),%rdi
mov    0x78(%rsi),%rcx
imul   0x60(%rsi),%rdi
mov    %rcx,%rax
or     %rdi,%rax
shr    $0x20,%rax
je     1a48 <main+0x8a8>
mov    %rcx,%rax
cqto
idiv   %rdi
jmp    1a4e <main+0x8ae>
mov    %ecx,%eax
xor    %edx,%edx
div    %edi
mov    0x70(%rsi),%rdx
add    $0xffffffffffffffff,%rdx
cmp    %rdx,%rax
jge    1cc7 <main+0xb27>
lea    (%rsi,%rdi,8),%rax
mov    0x100(%rax,%rcx,8),%rax
mov    %rax,0x100(%rsi,%rcx,8)
mov    0x68(%rsi),%rax
imul   0x60(%rsi),%rax
add    0x78(%rsi),%rax
movq   $0x0,0x100(%rsi,%rax,8)
mov    0x68(%rsi),%rax
imul   0x60(%rsi),%rax
add    %rax,0x78(%rsi)
mov    $0xd,%edi
call   10a0 <main@plt>
test   %eax,%eax
jne    17e5 <main+0x645>
mov    0x8(%rsp),%rsi
movslq 0x4(%rsp),%rax
mov    (%rsi,%rax,8),%rax
cmp    $0x6c,%rax
jne    1b35 <main+0x995>
mov    0x60(%rsi),%rdi
mov    0x78(%rsi),%rcx
mov    %rcx,%rax
or     %rdi,%rax
shr    $0x20,%rax
je     1add <main+0x93d>
mov    %rcx,%rax
cqto
idiv   %rdi
jmp    1ae3 <main+0x943>
mov    %ecx,%eax
xor    %edx,%edx
div    %edi
add    $0xffffffffffffffff,%rdi
cmp    %rdi,%rdx
jge    1cc7 <main+0xb27>
mov    0x108(%rsi,%rcx,8),%rax
mov    %rax,0x100(%rsi,%rcx,8)
mov    0x78(%rsi),%rax
movq   $0x0,0x108(%rsi,%rax,8)
addq   $0x1,0x78(%rsi)
mov    $0xd,%edi
call   10a0 <main@plt>
test   %eax,%eax
jne    17e5 <main+0x645>
mov    0x8(%rsp),%rsi
movslq 0x4(%rsp),%rax
mov    (%rsi,%rax,8),%rax
cmp    $0x6e,%rax
jne    1be7 <main+0xa47>
mov    0x78(%rsi),%rcx
mov    0x60(%rsi),%rdi
mov    0x68(%rsi),%rbx
mov    %rbx,%rbp
imul   %rdi,%rbp
mov    %rcx,%rax
or     %rbp,%rax
shr    $0x20,%rax
je     1b6b <main+0x9cb>
mov    %rcx,%rax
cqto
idiv   %rbp
mov    %rdx,%rax
jmp    1b73 <main+0x9d3>
mov    %ecx,%eax
xor    %edx,%edx
div    %ebp
mov    %edx,%eax
mov    %rax,%rdx
or     %rdi,%rdx
shr    $0x20,%rdx
je     1b86 <main+0x9e6>
cqto
idiv   %rdi
jmp    1b8a <main+0x9ea>
xor    %edx,%edx
div    %edi
add    $0xffffffffffffffff,%rbx
cmp    %rbx,%rax
jge    1cc7 <main+0xb27>
lea    (%rsi,%rdi,8),%rax
mov    0x100(%rax,%rcx,8),%rax
mov    %rax,0x100(%rsi,%rcx,8)
mov    0x60(%rsi),%rax
add    0x78(%rsi),%rax
movq   $0x0,0x100(%rsi,%rax,8)
mov    0x60(%rsi),%rax
add    %rax,0x78(%rsi)
mov    $0xd,%edi
call   10a0 <main@plt>
test   %eax,%eax
jne    17e5 <main+0x645>
mov    0x8(%rsp),%rsi
movslq 0x4(%rsp),%rax
mov    (%rsi,%rax,8),%rax
cmp    $0x6f,%rax
jne    1c98 <main+0xaf8>
mov    0x60(%rsi),%rdi
mov    0x78(%rsi),%rcx
mov    0x68(%rsi),%rbp
imul   %rdi,%rbp
mov    %rcx,%rax
or     %rbp,%rax
shr    $0x20,%rax
je     1c1a <main+0xa7a>
mov    %rcx,%rax
cqto
idiv   %rbp
mov    %rdx,%rax
jmp    1c22 <main+0xa82>
mov    %ecx,%eax
xor    %edx,%edx
div    %ebp
mov    %edx,%eax
mov    %rax,%rdx
or     %rdi,%rdx
shr    $0x20,%rdx
je     1c35 <main+0xa95>
cqto
idiv   %rdi
jmp    1c39 <main+0xa99>
xor    %edx,%edx
div    %edi
test   %rax,%rax
jle    1cc7 <main+0xb27>
shl    $0x3,%rdi
mov    %rsi,%rax
sub    %rdi,%rax
mov    0x100(%rax,%rcx,8),%rax
mov    %rax,0x100(%rsi,%rcx,8)
mov    0x78(%rsi),%rax
sub    0x60(%rsi),%rax
movq   $0x0,0x100(%rsi,%rax,8)
mov    0x60(%rsi),%rax
sub    %rax,0x78(%rsi)
mov    $0xd,%edi
call   10a0 <main@plt>
test   %eax,%eax
jne    17e5 <main+0x645>
mov    0x8(%rsp),%rax
movslq 0x4(%rsp),%rcx
mov    (%rax,%rcx,8),%rax
cmp    $0x71,%rax
jne    1cc7 <main+0xb27>
lea    0x3b4(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
test   %eax,%eax
je     1cc7 <main+0xb27>
mov    0x8(%rsp),%rsi
mov    $0xf,%edi
call   10a0 <main@plt>
test   %eax,%eax
jne    17e5 <main+0x645>
mov    0x4(%rsp),%edi
mov    0x8(%rsp),%rsi
call   10a0 <main@plt>
test   %eax,%eax
jne    17e5 <main+0x645>
xor    %r14d,%r14d
mov    %r14d,%eax
add    $0x10,%rsp
pop    %rbx
pop    %r14
pop    %rbp
ret
xor    %edi,%edi
call   10b0 <exit@plt>

LLVM IR (-O0):
@.str = [5 x i8] c"\1B[;H\00"
@.str.1 = [4 x i8] c"%*s\00"
@.str.2 = [1 x i8] zeroinitializer
@.str.3 = [5 x i8] c"%*ld\00"
@.str.4 = [6 x i8] c"%*.*s\00"
@.str.5 = [6 x i8] c"#####\00"
@.str.6 = [2 x i8] c"\0A\00"
@.str.7 = [26 x i8] c"Syntax: %s <x> <y> [<z>]\0A\00"
@.str.8 = [4 x i8] c"%ld\00"
@.str.9 = [18 x i8] c"stty cbreak -echo\00"
@.str.10 = [5 x i8] c"\1B[2J\00"
@.str.11 = [10 x i8] c"You win!\0A\00"
@.str.12 = [14 x i8] c"You lose :-)\0A\00"
@.str.13 = [10 x i8] c"stty sane\00"
define i32 @main(i32 %0, i8** %1) {
%3 = alloca i32
%4 = alloca i32
%5 = alloca i8**
store i32 0, i32* %3
store i32 %0, i32* %4
store i8** %1, i8*** %5
%6 = load i32, i32* %4
%7 = sub nsw i32 %6, 1
%8 = ashr i32 %7, 1
%9 = xor i32 %8, 1
%10 = icmp ne i32 %9, 0
br i1 %10, label %26, label %11
11: ; preds = %2
%12 = bitcast i32* %4 to i64*
%13 = bitcast i64* %12 to i8**
%14 = call i32 @main(i32 5, i8** %13)
%15 = icmp ne i32 %14, 0
%16 = xor i1 %15, true
%17 = xor i1 %16, true
%18 = zext i1 %17 to i32
%19 = add nsw i32 6, %18
%20 = sext i32 %19 to i64
%21 = trunc i64 %20 to i32
%22 = bitcast i32* %4 to i64*
%23 = bitcast i64* %22 to i8**
%24 = call i32 @main(i32 %21, i8** %23)
%25 = icmp ne i32 %24, 0
br i1 %25, label %26, label %1375
26: ; preds = %11, %2
%27 = load i32, i32* %4
%28 = sub nsw i32 %27, 13
%29 = icmp ne i32 %28, 0
br i1 %29, label %41, label %30
30: ; preds = %26
%31 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0))
%32 = icmp ne i32 %31, 0
br i1 %32, label %33, label %41
33: ; preds = %30
%34 = load i8**, i8*** %5
%35 = bitcast i8** %34 to i64*
%36 = getelementptr inbounds i64, i64* %35, i64 4
store i64 0, i64* %36
br i1 false, label %41, label %37
37: ; preds = %33
%38 = load i8**, i8*** %5
%39 = call i32 @main(i32 14, i8** %38)
%40 = icmp ne i32 %39, 0
br i1 %40, label %41, label %1375
41: ; preds = %37, %33, %30, %26
%42 = load i32, i32* %4
%43 = sub nsw i32 %42, 14
%44 = icmp ne i32 %43, 0
br i1 %44, label %220, label %45
45: ; preds = %41
%46 = load i8**, i8*** %5
%47 = bitcast i8** %46 to i64*
%48 = getelementptr inbounds i64, i64* %47, i64 4
%49 = load i64, i64* %48
%50 = load i8**, i8*** %5
%51 = bitcast i8** %50 to i64*
%52 = getelementptr inbounds i64, i64* %51, i64 12
%53 = load i64, i64* %52
%54 = load i8**, i8*** %5
%55 = bitcast i8** %54 to i64*
%56 = getelementptr inbounds i64, i64* %55, i64 13
%57 = load i64, i64* %56
%58 = mul nsw i64 %53, %57
%59 = load i8**, i8*** %5
%60 = bitcast i8** %59 to i64*
%61 = getelementptr inbounds i64, i64* %60, i64 14
%62 = load i64, i64* %61
%63 = mul nsw i64 %58, %62
%64 = sub nsw i64 %49, %63
%65 = icmp ne i64 %64, 0
br i1 %65, label %66, label %1375
66: ; preds = %45
%67 = load i8**, i8*** %5
%68 = bitcast i8** %67 to i64*
%69 = getelementptr inbounds i64, i64* %68, i64 4
%70 = load i64, i64* %69
%71 = load i8**, i8*** %5
%72 = bitcast i8** %71 to i64*
%73 = getelementptr inbounds i64, i64* %72, i64 12
%74 = load i64, i64* %73
%75 = srem i64 %70, %74
%76 = icmp ne i64 %75, 0
br i1 %76, label %105, label %77
77: ; preds = %66
%78 = load i8**, i8*** %5
%79 = bitcast i8** %78 to i64*
%80 = getelementptr inbounds i64, i64* %79, i64 13
%81 = load i64, i64* %80
%82 = load i8**, i8*** %5
%83 = bitcast i8** %82 to i64*
%84 = getelementptr inbounds i64, i64* %83, i64 4
%85 = load i64, i64* %84
%86 = load i8**, i8*** %5
%87 = bitcast i8** %86 to i64*
%88 = getelementptr inbounds i64, i64* %87, i64 12
%89 = load i64, i64* %88
%90 = load i8**, i8*** %5
%91 = bitcast i8** %90 to i64*
%92 = getelementptr inbounds i64, i64* %91, i64 13
%93 = load i64, i64* %92
%94 = mul nsw i64 %89, %93
%95 = srem i64 %85, %94
%96 = load i8**, i8*** %5
%97 = bitcast i8** %96 to i64*
%98 = getelementptr inbounds i64, i64* %97, i64 12
%99 = load i64, i64* %98
%100 = sdiv i64 %95, %99
%101 = sub nsw i64 %81, %100
%102 = trunc i64 %101 to i32
%103 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), i32 %102, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.2, i64 0, i64 0))
%104 = icmp ne i32 %103, 0
br i1 %104, label %105, label %1375
105: ; preds = %77, %66
%106 = load i8**, i8*** %5
%107 = bitcast i8** %106 to i64*
%108 = getelementptr inbounds i64, i64* %107, i64 32
%109 = load i8**, i8*** %5
%110 = bitcast i8** %109 to i64*
%111 = getelementptr inbounds i64, i64* %110, i64 4
%112 = load i64, i64* %111
%113 = getelementptr inbounds i64, i64* %108, i64 %112
%114 = load i64, i64* %113
%115 = icmp ne i64 %114, 0
br i1 %115, label %116, label %133
116: ; preds = %105
%117 = load i8**, i8*** %5
%118 = bitcast i8** %117 to i64*
%119 = getelementptr inbounds i64, i64* %118, i64 31
%120 = load i64, i64* %119
%121 = trunc i64 %120 to i32
%122 = load i8**, i8*** %5
%123 = bitcast i8** %122 to i64*
%124 = getelementptr inbounds i64, i64* %123, i64 32
%125 = load i8**, i8*** %5
%126 = bitcast i8** %125 to i64*
%127 = getelementptr inbounds i64, i64* %126, i64 4
%128 = load i64, i64* %127
%129 = getelementptr inbounds i64, i64* %124, i64 %128
%130 = load i64, i64* %129
%131 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.3, i64 0, i64 0), i32 %121, i64 %130)
%132 = icmp ne i32 %131, 0
br i1 %132, label %146, label %133
133: ; preds = %116, %105
%134 = load i8**, i8*** %5
%135 = bitcast i8** %134 to i64*
%136 = getelementptr inbounds i64, i64* %135, i64 31
%137 = load i64, i64* %136
%138 = trunc i64 %137 to i32
%139 = load i8**, i8*** %5
%140 = bitcast i8** %139 to i64*
%141 = getelementptr inbounds i64, i64* %140, i64 31
%142 = load i64, i64* %141
%143 = trunc i64 %142 to i32
%144 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.4, i64 0, i64 0), i32 %138, i32 %143, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.5, i64 0, i64 0))
%145 = icmp ne i32 %144, 0
br i1 %145, label %147, label %146
146: ; preds = %133, %116
br i1 false, label %1375, label %147
147: ; preds = %146, %133
%148 = load i8**, i8*** %5
%149 = bitcast i8** %148 to i64*
%150 = getelementptr inbounds i64, i64* %149, i64 4
%151 = load i64, i64* %150
%152 = load i8**, i8*** %5
%153 = bitcast i8** %152 to i64*
%154 = getelementptr inbounds i64, i64* %153, i64 12
%155 = load i64, i64* %154
%156 = srem i64 %151, %155
%157 = load i8**, i8*** %5
%158 = bitcast i8** %157 to i64*
%159 = getelementptr inbounds i64, i64* %158, i64 12
%160 = load i64, i64* %159
%161 = sub nsw i64 %160, 1
%162 = icmp eq i64 %156, %161
br i1 %162, label %163, label %166
163: ; preds = %147
%164 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0))
%165 = icmp ne i32 %164, 0
br i1 %165, label %175, label %166
166: ; preds = %163, %147
%167 = load i8**, i8*** %5
%168 = bitcast i8** %167 to i64*
%169 = getelementptr inbounds i64, i64* %168, i64 13
%170 = load i64, i64* %169
%171 = add nsw i64 %170, 1
%172 = trunc i64 %171 to i32
%173 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), i32 %172, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.2, i64 0, i64 0))
%174 = icmp ne i32 %173, 0
br i1 %174, label %176, label %175
175: ; preds = %166, %163
br i1 false, label %1375, label %176
176: ; preds = %175, %166
%177 = load i8**, i8*** %5
%178 = bitcast i8** %177 to i64*
%179 = getelementptr inbounds i64, i64* %178, i64 4
%180 = load i64, i64* %179
%181 = add nsw i64 %180, 1
%182 = load i8**, i8*** %5
%183 = bitcast i8** %182 to i64*
%184 = getelementptr inbounds i64, i64* %183, i64 12
%185 = load i64, i64* %184
%186 = load i8**, i8*** %5
%187 = bitcast i8** %186 to i64*
%188 = getelementptr inbounds i64, i64* %187, i64 13
%189 = load i64, i64* %188
%190 = mul nsw i64 %185, %189
%191 = srem i64 %181, %190
%192 = icmp eq i64 %191, 0
br i1 %192, label %193, label %202
193: ; preds = %176
%194 = load i8**, i8*** %5
%195 = bitcast i8** %194 to i64*
%196 = getelementptr inbounds i64, i64* %195, i64 13
%197 = load i64, i64* %196
%198 = icmp sgt i64 %197, 1
br i1 %198, label %199, label %202
199: ; preds = %193
%200 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0))
%201 = icmp ne i32 %200, 0
br i1 %201, label %202, label %1375
202: ; preds = %199, %193, %176
%203 = load i8**, i8*** %5
%204 = bitcast i8** %203 to i64*
%205 = getelementptr inbounds i64, i64* %204, i64 4
%206 = load i64, i64* %205
%207 = add nsw i64 %206, 1
%208 = load i8**, i8*** %5
%209 = bitcast i8** %208 to i64*
%210 = getelementptr inbounds i64, i64* %209, i64 4
store i64 %207, i64* %210
%211 = and i64 %207, 0
%212 = icmp ne i64 %211, 0
br i1 %212, label %1375, label %213
213: ; preds = %202
%214 = load i32, i32* %4
%215 = sext i32 %214 to i64
%216 = trunc i64 %215 to i32
%217 = load i8**, i8*** %5
%218 = call i32 @main(i32 %216, i8** %217)
%219 = icmp ne i32 %218, 0
br i1 %219, label %220, label %1375
220: ; preds = %213, %41
%221 = load i32, i32* %4
%222 = sub nsw i32 %221, 1
%223 = and i32 %222, -2
%224 = icmp ne i32 %223, 0
br i1 %224, label %235, label %225
225: ; preds = %220
%226 = load i8**, i8*** %5
%227 = getelementptr inbounds i8*, i8** %226, i64 0
%228 = load i8*, i8** %227
%229 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str.7, i64 0, i64 0), i8* %228)
%230 = icmp ne i32 %229, 0
br i1 %230, label %231, label %235
231: ; preds = %225
%232 = load i8**, i8*** %5
%233 = call i32 @main(i32 15, i8** %232)
%234 = icmp ne i32 %233, 0
br i1 %234, label %235, label %1375
235: ; preds = %231, %225, %220
%236 = load i32, i32* %4
%237 = and i32 %236, -2
%238 = sub nsw i32 %237, 6
%239 = icmp ne i32 %238, 0
br i1 %239, label %342, label %240
240: ; preds = %235
%241 = load i32, i32* %4
%242 = and i32 %241, 1
%243 = sext i32 %242 to i64
%244 = load i8**, i8*** %5
%245 = bitcast i8** %244 to i64*
%246 = bitcast i32* %4 to i64*
%247 = ptrtoint i64* %245 to i64
%248 = ptrtoint i64* %246 to i64
%249 = sub i64 %247, %248
%250 = sdiv exact i64 %249, 8
%251 = mul nsw i64 %243, %250
%252 = load i32, i32* %4
%253 = xor i32 %252, -1
%254 = and i32 %253, 1
%255 = sext i32 %254 to i64
%256 = bitcast i32* %4 to i64*
%257 = load i8**, i8*** %5
%258 = bitcast i8** %257 to i64*
%259 = ptrtoint i64* %256 to i64
%260 = ptrtoint i64* %258 to i64
%261 = sub i64 %259, %260
%262 = sdiv exact i64 %261, 8
%263 = mul nsw i64 %255, %262
%264 = add nsw i64 %251, %263
%265 = ashr i64 %264, 12
%266 = icmp ne i64 %265, 0
br i1 %266, label %267, label %335
267: ; preds = %240
%268 = load i8**, i8*** %5
%269 = bitcast i8** %268 to i8*
%270 = bitcast i8*** %5 to i8*
%271 = bitcast i32* %4 to i64*
%272 = bitcast i64* %271 to i8*
%273 = ptrtoint i8* %270 to i64
%274 = ptrtoint i8* %272 to i64
%275 = sub i64 %273, %274
%276 = getelementptr inbounds i8, i8* %269, i64 %275
%277 = bitcast i8* %276 to i64*
%278 = load i64, i64* %277
%279 = load i32, i32* %4
%280 = and i32 %279, 1
%281 = sext i32 %280 to i64
%282 = bitcast i32* %4 to i64*
%283 = ptrtoint i64* %282 to i64
%284 = mul nsw i64 %281, %283
%285 = load i32, i32* %4
%286 = xor i32 %285, -1
%287 = and i32 %286, 1
%288 = sext i32 %287 to i64
%289 = load i8**, i8*** %5
%290 = ptrtoint i8** %289 to i64
%291 = mul nsw i64 %288, %290
%292 = add nsw i64 %284, %291
%293 = inttoptr i64 %292 to i64*
%294 = getelementptr inbounds i64, i64* %293, i64 8
store i64 %278, i64* %294
%295 = icmp ne i64 %278, 0
br i1 %295, label %296, label %335
296: ; preds = %267
%297 = load i8**, i8*** %5
%298 = bitcast i8** %297 to i64*
%299 = load i64, i64* %298
%300 = load i32, i32* %4
%301 = and i32 %300, 1
%302 = sext i32 %301 to i64
%303 = bitcast i32* %4 to i64*
%304 = ptrtoint i64* %303 to i64
%305 = mul nsw i64 %302, %304
%306 = load i32, i32* %4
%307 = xor i32 %306, -1
%308 = and i32 %307, 1
%309 = sext i32 %308 to i64
%310 = load i8**, i8*** %5
%311 = ptrtoint i8** %310 to i64
%312 = mul nsw i64 %309, %311
%313 = add nsw i64 %305, %312
%314 = inttoptr i64 %313 to i64*
%315 = getelementptr inbounds i64, i64* %314, i64 9
store i64 %299, i64* %315
%316 = icmp ne i64 %299, 0
br i1 %316, label %317, label %335
317: ; preds = %296
%318 = load i32, i32* %4
%319 = and i32 %318, 1
%320 = sext i32 %319 to i64
%321 = bitcast i32* %4 to i64*
%322 = ptrtoint i64* %321 to i64
%323 = mul nsw i64 %320, %322
%324 = load i32, i32* %4
%325 = xor i32 %324, -1
%326 = and i32 %325, 1
%327 = sext i32 %326 to i64
%328 = load i8**, i8*** %5
%329 = ptrtoint i8** %328 to i64
%330 = mul nsw i64 %327, %329
%331 = add nsw i64 %323, %330
%332 = inttoptr i64 %331 to i8**
%333 = call i32 @main(i32 8, i8** %332)
%334 = icmp ne i32 %333, 0
br i1 %334, label %342, label %335
335: ; preds = %317, %296, %267, %240
%336 = load i32, i32* %4
%337 = sext i32 %336 to i64
%338 = trunc i64 %337 to i32
%339 = load i8**, i8*** %5
%340 = call i32 @main(i32 %338, i8** %339)
%341 = icmp ne i32 %340, 0
br i1 %341, label %342, label %1375
342: ; preds = %335, %317, %235
%343 = load i32, i32* %4
%344 = sub nsw i32 %343, 8
%345 = icmp ne i32 %344, 0
br i1 %345, label %500, label %346
346: ; preds = %342
%347 = load i8**, i8*** %5
%348 = bitcast i8** %347 to i64*
%349 = getelementptr inbounds i64, i64* %348, i64 9
%350 = load i64, i64* %349
%351 = and i64 %350, 1
%352 = icmp ne i64 %351, 0
br i1 %352, label %353, label %383
353: ; preds = %346
%354 = load i8**, i8*** %5
%355 = bitcast i8** %354 to i64*
%356 = getelementptr inbounds i64, i64* %355, i64 8
%357 = load i64, i64* %356
%358 = inttoptr i64 %357 to i8**
%359 = getelementptr inbounds i8*, i8** %358, i64 1
%360 = load i8*, i8** %359
%361 = load i8**, i8*** %5
%362 = bitcast i8** %361 to i64*
%363 = getelementptr inbounds i64, i64* %362, i64 1
%364 = getelementptr inbounds i64, i64* %363, i64 11
%365 = call i32 (i8*, i8*, ...) @sscanf(i8* %360, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.8, i64 0, i64 0), i64* %364)
%366 = and i32 %365, 0
%367 = icmp ne i32 %366, 0
br i1 %367, label %383, label %368
368: ; preds = %353
%369 = load i8**, i8*** %5
%370 = bitcast i8** %369 to i64*
%371 = getelementptr inbounds i64, i64* %370, i64 8
%372 = load i64, i64* %371
%373 = inttoptr i64 %372 to i8**
%374 = getelementptr inbounds i8*, i8** %373, i64 2
%375 = load i8*, i8** %374
%376 = load i8**, i8*** %5
%377 = bitcast i8** %376 to i64*
%378 = getelementptr inbounds i64, i64* %377, i64 2
%379 = getelementptr inbounds i64, i64* %378, i64 11
%380 = call i32 (i8*, i8*, ...) @sscanf(i8* %375, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.8, i64 0, i64 0), i64* %379)
%381 = and i32 %380, 0
%382 = icmp ne i32 %381, 0
br i1 %382, label %383, label %428
383: ; preds = %368, %353, %346
%384 = load i8**, i8*** %5
%385 = bitcast i8** %384 to i64*
%386 = getelementptr inbounds i64, i64* %385, i64 8
%387 = load i64, i64* %386
%388 = inttoptr i64 %387 to i8**
%389 = getelementptr inbounds i8*, i8** %388, i64 1
%390 = load i8*, i8** %389
%391 = load i8**, i8*** %5
%392 = bitcast i8** %391 to i64*
%393 = getelementptr inbounds i64, i64* %392, i64 1
%394 = getelementptr inbounds i64, i64* %393, i64 11
%395 = call i32 (i8*, i8*, ...) @sscanf(i8* %390, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.8, i64 0, i64 0), i64* %394)
%396 = and i32 %395, 0
%397 = icmp ne i32 %396, 0
br i1 %397, label %428, label %398
398: ; preds = %383
%399 = load i8**, i8*** %5
%400 = bitcast i8** %399 to i64*
%401 = getelementptr inbounds i64, i64* %400, i64 8
%402 = load i64, i64* %401
%403 = inttoptr i64 %402 to i8**
%404 = getelementptr inbounds i8*, i8** %403, i64 2
%405 = load i8*, i8** %404
%406 = load i8**, i8*** %5
%407 = bitcast i8** %406 to i64*
%408 = getelementptr inbounds i64, i64* %407, i64 2
%409 = getelementptr inbounds i64, i64* %408, i64 11
%410 = call i32 (i8*, i8*, ...) @sscanf(i8* %405, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.8, i64 0, i64 0), i64* %409)
%411 = and i32 %410, 0
%412 = icmp ne i32 %411, 0
br i1 %412, label %428, label %413
413: ; preds = %398
%414 = load i8**, i8*** %5
%415 = bitcast i8** %414 to i64*
%416 = getelementptr inbounds i64, i64* %415, i64 8
%417 = load i64, i64* %416
%418 = inttoptr i64 %417 to i8**
%419 = getelementptr inbounds i8*, i8** %418, i64 3
%420 = load i8*, i8** %419
%421 = load i8**, i8*** %5
%422 = bitcast i8** %421 to i64*
%423 = getelementptr inbounds i64, i64* %422, i64 3
%424 = getelementptr inbounds i64, i64* %423, i64 11
%425 = call i32 (i8*, i8*, ...) @sscanf(i8* %420, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.8, i64 0, i64 0), i64* %424)
%426 = and i32 %425, 0
%427 = icmp ne i32 %426, 0
br i1 %427, label %428, label %442
428: ; preds = %413, %398, %383, %368
%429 = load i8**, i8*** %5
%430 = bitcast i8** %429 to i64*
%431 = getelementptr inbounds i64, i64* %430, i64 13
%432 = load i64, i64* %431
%433 = load i8**, i8*** %5
%434 = bitcast i8** %433 to i64*
%435 = getelementptr inbounds i64, i64* %434, i64 14
store i64 %432, i64* %435
%436 = and i64 %432, 0
%437 = icmp ne i64 %436, 0
br i1 %437, label %500, label %438
438: ; preds = %428
%439 = load i8**, i8*** %5
%440 = bitcast i8** %439 to i64*
%441 = getelementptr inbounds i64, i64* %440, i64 13
store i64 1, i64* %441
br i1 false, label %500, label %442
442: ; preds = %438, %413
%443 = call i32 (i32, ...) bitcast (i32 (...)* @time to i32 (i32, ...)*)(i32 0)
%444 = call i32 (i32, ...) bitcast (i32 (...)* @srand to i32 (i32, ...)*)(i32 %443)
br i1 false, label %500, label %445
445: ; preds = %442
%446 = load i8**, i8*** %5
%447 = bitcast i8** %446 to i64*
%448 = getelementptr inbounds i64, i64* %447, i64 4
store i64 0, i64* %448
br i1 false, label %500, label %449
449: ; preds = %445
%450 = load i8**, i8*** %5
%451 = call i32 @main(i32 9, i8** %450)
%452 = icmp ne i32 %451, 0
br i1 %452, label %500, label %453
453: ; preds = %449
%454 = load i8**, i8*** %5
%455 = bitcast i8** %454 to i64*
%456 = getelementptr inbounds i64, i64* %455, i64 8
%457 = load i64, i64* %456
%458 = inttoptr i64 %457 to i8**
%459 = getelementptr inbounds i8*, i8** %458, i64 0
%460 = load i8*, i8** %459
%461 = load i8**, i8*** %5
%462 = bitcast i8** %461 to i64*
%463 = getelementptr inbounds i64, i64* %462, i64 12
%464 = load i64, i64* %463
%465 = load i8**, i8*** %5
%466 = bitcast i8** %465 to i64*
%467 = getelementptr inbounds i64, i64* %466, i64 13
%468 = load i64, i64* %467
%469 = mul nsw i64 %464, %468
%470 = load i8**, i8*** %5
%471 = bitcast i8** %470 to i64*
%472 = getelementptr inbounds i64, i64* %471, i64 14
%473 = load i64, i64* %472
%474 = mul nsw i64 %469, %473
%475 = call i32 (i8*, i64, i8*, ...) @snprintf(i8* %460, i64 1, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.8, i64 0, i64 0), i64 %474)
%476 = sext i32 %475 to i64
%477 = load i8**, i8*** %5
%478 = bitcast i8** %477 to i64*
%479 = getelementptr inbounds i64, i64* %478, i64 31
store i64 %476, i64* %479
%480 = and i64 %476, 0
%481 = icmp ne i64 %480, 0
br i1 %481, label %500, label %482
482: ; preds = %453
%483 = call i32 (i8*, ...) bitcast (i32 (...)* @system to i32 (i8*, ...)*)(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.9, i64 0, i64 0))
%484 = icmp ne i32 %483, 0
br i1 %484, label %500, label %485
485: ; preds = %482
%486 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.10, i64 0, i64 0))
%487 = icmp ne i32 %486, 0
br i1 %487, label %488, label %500
488: ; preds = %485
%489 = load i8**, i8*** %5
%490 = call i32 @main(i32 13, i8** %489)
%491 = icmp ne i32 %490, 0
br i1 %491, label %500, label %492
492: ; preds = %488
%493 = load i8**, i8*** %5
%494 = call i32 @main(i32 18, i8** %493)
%495 = icmp ne i32 %494, 0
br i1 %495, label %500, label %496
496: ; preds = %492
%497 = load i8**, i8*** %5
%498 = call i32 @main(i32 15, i8** %497)
%499 = icmp ne i32 %498, 0
br i1 %499, label %500, label %1375
500: ; preds = %496, %492, %488, %485, %482, %453, %449, %445, %442, %438, %428, %342
%501 = load i32, i32* %4
%502 = sub nsw i32 %501, 9
%503 = icmp ne i32 %502, 0
br i1 %503, label %578, label %504
504: ; preds = %500
%505 = load i8**, i8*** %5
%506 = bitcast i8** %505 to i64*
%507 = getelementptr inbounds i64, i64* %506, i64 4
%508 = load i64, i64* %507
%509 = load i8**, i8*** %5
%510 = bitcast i8** %509 to i64*
%511 = getelementptr inbounds i64, i64* %510, i64 12
%512 = load i64, i64* %511
%513 = load i8**, i8*** %5
%514 = bitcast i8** %513 to i64*
%515 = getelementptr inbounds i64, i64* %514, i64 13
%516 = load i64, i64* %515
%517 = mul nsw i64 %512, %516
%518 = load i8**, i8*** %5
%519 = bitcast i8** %518 to i64*
%520 = getelementptr inbounds i64, i64* %519, i64 14
%521 = load i64, i64* %520
%522 = mul nsw i64 %517, %521
%523 = sub nsw i64 %508, %522
%524 = icmp ne i64 %523, 0
br i1 %524, label %525, label %1375
525: ; preds = %504
%526 = load i8**, i8*** %5
%527 = call i32 @main(i32 16, i8** %526)
%528 = icmp ne i32 %527, 0
br i1 %528, label %1375, label %529
529: ; preds = %525
%530 = load i8**, i8*** %5
%531 = bitcast i8** %530 to i64*
%532 = getelementptr inbounds i64, i64* %531, i64 0
%533 = load i64, i64* %532
%534 = load i8**, i8*** %5
%535 = bitcast i8** %534 to i64*
%536 = load i8**, i8*** %5
%537 = bitcast i8** %536 to i64*
%538 = getelementptr inbounds i64, i64* %537, i64 4
%539 = load i64, i64* %538
%540 = add nsw i64 %539, 32
%541 = getelementptr inbounds i64, i64* %535, i64 %540
store i64 %533, i64* %541
%542 = and i64 %533, 0
%543 = icmp ne i64 %542, 0
br i1 %543, label %1375, label %544
544: ; preds = %529
%545 = load i8**, i8*** %5
%546 = bitcast i8** %545 to i64*
%547 = getelementptr inbounds i64, i64* %546, i64 0
%548 = load i64, i64* %547
%549 = icmp ne i64 %548, 0
br i1 %549, label %560, label %550
550: ; preds = %544
%551 = load i8**, i8*** %5
%552 = bitcast i8** %551 to i64*
%553 = getelementptr inbounds i64, i64* %552, i64 4
%554 = load i64, i64* %553
%555 = load i8**, i8*** %5
%556 = bitcast i8** %555 to i64*
%557 = getelementptr inbounds i64, i64* %556, i64 15
store i64 %554, i64* %557
%558 = and i64 %554, 0
%559 = icmp ne i64 %558, 0
br i1 %559, label %1375, label %560
560: ; preds = %550, %544
%561 = load i8**, i8*** %5
%562 = bitcast i8** %561 to i64*
%563 = getelementptr inbounds i64, i64* %562, i64 4
%564 = load i64, i64* %563
%565 = add nsw i64 %564, 1
%566 = load i8**, i8*** %5
%567 = bitcast i8** %566 to i64*
%568 = getelementptr inbounds i64, i64* %567, i64 4
store i64 %565, i64* %568
%569 = and i64 %565, 0
%570 = icmp ne i64 %569, 0
br i1 %570, label %1375, label %571
571: ; preds = %560
%572 = load i32, i32* %4
%573 = sext i32 %572 to i64
%574 = trunc i64 %573 to i32
%575 = load i8**, i8*** %5
%576 = call i32 @main(i32 %574, i8** %575)
%577 = icmp ne i32 %576, 0
br i1 %577, label %578, label %1375
578: ; preds = %571, %500
%579 = load i32, i32* %4
%580 = sub nsw i32 %579, 16
%581 = icmp ne i32 %580, 0
br i1 %581, label %627, label %582
582: ; preds = %578
%583 = call i32 (...) @rand()
%584 = sext i32 %583 to i64
%585 = load i8**, i8*** %5
%586 = bitcast i8** %585 to i64*
%587 = getelementptr inbounds i64, i64* %586, i64 12
%588 = load i64, i64* %587
%589 = load i8**, i8*** %5
%590 = bitcast i8** %589 to i64*
%591 = getelementptr inbounds i64, i64* %590, i64 13
%592 = load i64, i64* %591
%593 = mul nsw i64 %588, %592
%594 = load i8**, i8*** %5
%595 = bitcast i8** %594 to i64*
%596 = getelementptr inbounds i64, i64* %595, i64 14
%597 = load i64, i64* %596
%598 = mul nsw i64 %593, %597
%599 = srem i64 %584, %598
%600 = load i8**, i8*** %5
%601 = bitcast i8** %600 to i64*
%602 = getelementptr inbounds i64, i64* %601, i64 0
store i64 %599, i64* %602
%603 = and i64 %599, 0
%604 = icmp ne i64 %603, 0
br i1 %604, label %627, label %605
605: ; preds = %582
%606 = load i8**, i8*** %5
%607 = bitcast i8** %606 to i64*
%608 = getelementptr inbounds i64, i64* %607, i64 1
store i64 0, i64* %608
br i1 false, label %627, label %609
609: ; preds = %605
%610 = load i8**, i8*** %5
%611 = bitcast i8** %610 to i64*
%612 = getelementptr inbounds i64, i64* %611, i64 5
store i64 0, i64* %612
br i1 false, label %627, label %613
613: ; preds = %609
%614 = load i8**, i8*** %5
%615 = call i32 @main(i32 17, i8** %614)
%616 = icmp ne i32 %615, 0
br i1 %616, label %627, label %617
617: ; preds = %613
%618 = load i8**, i8*** %5
%619 = bitcast i8** %618 to i64*
%620 = getelementptr inbounds i64, i64* %619, i64 1
%621 = load i64, i64* %620
%622 = icmp ne i64 %621, 0
br i1 %622, label %623, label %1375
623: ; preds = %617
%624 = load i8**, i8*** %5
%625 = call i32 @main(i32 16, i8** %624)
%626 = icmp ne i32 %625, 0
br i1 %626, label %627, label %1375
627: ; preds = %623, %613, %609, %605, %582, %578
%628 = load i32, i32* %4
%629 = sub nsw i32 %628, 17
%630 = icmp ne i32 %629, 0
br i1 %630, label %691, label %631
631: ; preds = %627
%632 = load i8**, i8*** %5
%633 = bitcast i8** %632 to i64*
%634 = getelementptr inbounds i64, i64* %633, i64 5
%635 = load i64, i64* %634
%636 = load i8**, i8*** %5
%637 = bitcast i8** %636 to i64*
%638 = getelementptr inbounds i64, i64* %637, i64 4
%639 = load i64, i64* %638
%640 = sub nsw i64 %635, %639
%641 = icmp ne i64 %640, 0
br i1 %641, label %642, label %1375
642: ; preds = %631
%643 = load i8**, i8*** %5
%644 = bitcast i8** %643 to i64*
%645 = getelementptr inbounds i64, i64* %644, i64 32
%646 = load i8**, i8*** %5
%647 = bitcast i8** %646 to i64*
%648 = getelementptr inbounds i64, i64* %647, i64 5
%649 = load i64, i64* %648
%650 = getelementptr inbounds i64, i64* %645, i64 %649
%651 = load i64, i64* %650
%652 = load i8**, i8*** %5
%653 = bitcast i8** %652 to i64*
%654 = getelementptr inbounds i64, i64* %653, i64 0
%655 = load i64, i64* %654
%656 = sub nsw i64 %651, %655
%657 = icmp ne i64 %656, 0
br i1 %657, label %673, label %658
658: ; preds = %642
%659 = load i8**, i8*** %5
%660 = bitcast i8** %659 to i64*
%661 = getelementptr inbounds i64, i64* %660, i64 1
store i64 1, i64* %661
br i1 false, label %673, label %662
662: ; preds = %658
%663 = load i8**, i8*** %5
%664 = bitcast i8** %663 to i64*
%665 = getelementptr inbounds i64, i64* %664, i64 4
%666 = load i64, i64* %665
%667 = sub nsw i64 %666, 1
%668 = load i8**, i8*** %5
%669 = bitcast i8** %668 to i64*
%670 = getelementptr inbounds i64, i64* %669, i64 5
store i64 %667, i64* %670
%671 = and i64 %667, 0
%672 = icmp ne i64 %671, 0
br i1 %672, label %673, label %1375
673: ; preds = %662, %658, %642
%674 = load i8**, i8*** %5
%675 = bitcast i8** %674 to i64*
%676 = getelementptr inbounds i64, i64* %675, i64 5
%677 = load i64, i64* %676
%678 = add nsw i64 %677, 1
%679 = load i8**, i8*** %5
%680 = bitcast i8** %679 to i64*
%681 = getelementptr inbounds i64, i64* %680, i64 5
store i64 %678, i64* %681
%682 = and i64 %678, 0
%683 = icmp ne i64 %682, 0
br i1 %683, label %1375, label %684
684: ; preds = %673
%685 = load i32, i32* %4
%686 = sext i32 %685 to i64
%687 = trunc i64 %686 to i32
%688 = load i8**, i8*** %5
%689 = call i32 @main(i32 %687, i8** %688)
%690 = icmp ne i32 %689, 0
br i1 %690, label %691, label %1375
691: ; preds = %684, %627
%692 = load i32, i32* %4
%693 = sub nsw i32 %692, 18
%694 = icmp ne i32 %693, 0
br i1 %694, label %1253, label %695
695: ; preds = %691
%696 = load i8**, i8*** %5
%697 = bitcast i8** %696 to i64*
%698 = getelementptr inbounds i64, i64* %697, i64 0
store i64 0, i64* %698
br i1 false, label %1253, label %699
699: ; preds = %695
%700 = load i8**, i8*** %5
%701 = bitcast i8** %700 to i64*
%702 = getelementptr inbounds i64, i64* %701, i64 4
store i64 0, i64* %702
br i1 false, label %1253, label %703
703: ; preds = %699
%704 = load i8**, i8*** %5
%705 = call i32 @main(i32 19, i8** %704)
%706 = icmp ne i32 %705, 0
br i1 %706, label %1253, label %707
707: ; preds = %703
%708 = load i8**, i8*** %5
%709 = bitcast i8** %708 to i64*
%710 = getelementptr inbounds i64, i64* %709, i64 0
%711 = load i64, i64* %710
%712 = icmp ne i64 %711, 0
br i1 %712, label %716, label %713
713: ; preds = %707
%714 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.11, i64 0, i64 0))
%715 = icmp ne i32 %714, 0
br i1 %715, label %716, label %1253
716: ; preds = %713, %707
%717 = load i8**, i8*** %5
%718 = bitcast i8** %717 to i64*
%719 = getelementptr inbounds i64, i64* %718, i64 0
%720 = load i64, i64* %719
%721 = icmp ne i64 %720, 0
br i1 %721, label %722, label %1375
722: ; preds = %716
%723 = call i32 (...) @getchar()
%724 = sext i32 %723 to i64
%725 = load i8**, i8*** %5
%726 = bitcast i8** %725 to i64*
%727 = load i32, i32* %4
%728 = sext i32 %727 to i64
%729 = getelementptr inbounds i64, i64* %726, i64 %728
store i64 %724, i64* %729
%730 = and i64 %724, 0
%731 = icmp ne i64 %730, 0
br i1 %731, label %1253, label %732
732: ; preds = %722
%733 = load i8**, i8*** %5
%734 = bitcast i8** %733 to i64*
%735 = load i32, i32* %4
%736 = sext i32 %735 to i64
%737 = getelementptr inbounds i64, i64* %734, i64 %736
%738 = load i64, i64* %737
%739 = icmp eq i64 %738, 105
br i1 %739, label %740, label %829
740: ; preds = %732
%741 = load i8**, i8*** %5
%742 = bitcast i8** %741 to i64*
%743 = getelementptr inbounds i64, i64* %742, i64 15
%744 = load i64, i64* %743
%745 = load i8**, i8*** %5
%746 = bitcast i8** %745 to i64*
%747 = getelementptr inbounds i64, i64* %746, i64 12
%748 = load i64, i64* %747
%749 = load i8**, i8*** %5
%750 = bitcast i8** %749 to i64*
%751 = getelementptr inbounds i64, i64* %750, i64 13
%752 = load i64, i64* %751
%753 = mul nsw i64 %748, %752
%754 = sdiv i64 %744, %753
%755 = icmp slt i64 0, %754
br i1 %755, label %756, label %829
756: ; preds = %740
%757 = load i8**, i8*** %5
%758 = bitcast i8** %757 to i64*
%759 = getelementptr inbounds i64, i64* %758, i64 32
%760 = load i8**, i8*** %5
%761 = bitcast i8** %760 to i64*
%762 = getelementptr inbounds i64, i64* %761, i64 12
%763 = load i64, i64* %762
%764 = sub nsw i64 0, %763
%765 = load i8**, i8*** %5
%766 = bitcast i8** %765 to i64*
%767 = getelementptr inbounds i64, i64* %766, i64 13
%768 = load i64, i64* %767
%769 = mul nsw i64 %764, %768
%770 = getelementptr inbounds i64, i64* %759, i64 %769
%771 = load i8**, i8*** %5
%772 = bitcast i8** %771 to i64*
%773 = getelementptr inbounds i64, i64* %772, i64 15
%774 = load i64, i64* %773
%775 = getelementptr inbounds i64, i64* %770, i64 %774
%776 = load i64, i64* %775
%777 = load i8**, i8*** %5
%778 = bitcast i8** %777 to i64*
%779 = load i8**, i8*** %5
%780 = bitcast i8** %779 to i64*
%781 = getelementptr inbounds i64, i64* %780, i64 15
%782 = load i64, i64* %781
%783 = add nsw i64 32, %782
%784 = getelementptr inbounds i64, i64* %778, i64 %783
store i64 %776, i64* %784
%785 = and i64 %776, 0
%786 = icmp ne i64 %785, 0
br i1 %786, label %825, label %787
787: ; preds = %756
%788 = load i8**, i8*** %5
%789 = bitcast i8** %788 to i64*
%790 = load i8**, i8*** %5
%791 = bitcast i8** %790 to i64*
%792 = getelementptr inbounds i64, i64* %791, i64 12
%793 = load i64, i64* %792
%794 = sub nsw i64 0, %793
%795 = load i8**, i8*** %5
%796 = bitcast i8** %795 to i64*
%797 = getelementptr inbounds i64, i64* %796, i64 13
%798 = load i64, i64* %797
%799 = mul nsw i64 %794, %798
%800 = add nsw i64 32, %799
%801 = load i8**, i8*** %5
%802 = bitcast i8** %801 to i64*
%803 = getelementptr inbounds i64, i64* %802, i64 15
%804 = load i64, i64* %803
%805 = add nsw i64 %800, %804
%806 = getelementptr inbounds i64, i64* %789, i64 %805
store i64 0, i64* %806
br i1 false, label %825, label %807
807: ; preds = %787
%808 = load i8**, i8*** %5
%809 = bitcast i8** %808 to i64*
%810 = getelementptr inbounds i64, i64* %809, i64 12
%811 = load i64, i64* %810
%812 = sub nsw i64 0, %811
%813 = load i8**, i8*** %5
%814 = bitcast i8** %813 to i64*
%815 = getelementptr inbounds i64, i64* %814, i64 13
%816 = load i64, i64* %815
%817 = mul nsw i64 %812, %816
%818 = load i8**, i8*** %5
%819 = bitcast i8** %818 to i64*
%820 = getelementptr inbounds i64, i64* %819, i64 15
%821 = load i64, i64* %820
%822 = add nsw i64 %821, %817
store i64 %822, i64* %820
%823 = or i64 %822, 1
%824 = icmp ne i64 %823, 0
br i1 %824, label %825, label %829
825: ; preds = %807, %787, %756
%826 = load i8**, i8*** %5
%827 = call i32 @main(i32 13, i8** %826)
%828 = icmp ne i32 %827, 0
br i1 %828, label %1253, label %829
829: ; preds = %825, %807, %740, %732
%830 = load i8**, i8*** %5
%831 = bitcast i8** %830 to i64*
%832 = load i32, i32* %4
%833 = sext i32 %832 to i64
%834 = getelementptr inbounds i64, i64* %831, i64 %833
%835 = load i64, i64* %834
%836 = icmp eq i64 %835, 106
br i1 %836, label %837, label %890
837: ; preds = %829
%838 = load i8**, i8*** %5
%839 = bitcast i8** %838 to i64*
%840 = getelementptr inbounds i64, i64* %839, i64 15
%841 = load i64, i64* %840
%842 = load i8**, i8*** %5
%843 = bitcast i8** %842 to i64*
%844 = getelementptr inbounds i64, i64* %843, i64 12
%845 = load i64, i64* %844
%846 = srem i64 %841, %845
%847 = icmp slt i64 0, %846
br i1 %847, label %848, label %890
848: ; preds = %837
%849 = load i8**, i8*** %5
%850 = bitcast i8** %849 to i64*
%851 = getelementptr inbounds i64, i64* %850, i64 32
%852 = getelementptr inbounds i64, i64* %851, i64 -1
%853 = load i8**, i8*** %5
%854 = bitcast i8** %853 to i64*
%855 = getelementptr inbounds i64, i64* %854, i64 15
%856 = load i64, i64* %855
%857 = getelementptr inbounds i64, i64* %852, i64 %856
%858 = load i64, i64* %857
%859 = load i8**, i8*** %5
%860 = bitcast i8** %859 to i64*
%861 = load i8**, i8*** %5
%862 = bitcast i8** %861 to i64*
%863 = getelementptr inbounds i64, i64* %862, i64 15
%864 = load i64, i64* %863
%865 = add nsw i64 32, %864
%866 = getelementptr inbounds i64, i64* %860, i64 %865
store i64 %858, i64* %866
%867 = and i64 %858, 0
%868 = icmp ne i64 %867, 0
br i1 %868, label %886, label %869
869: ; preds = %848
%870 = load i8**, i8*** %5
%871 = bitcast i8** %870 to i64*
%872 = load i8**, i8*** %5
%873 = bitcast i8** %872 to i64*
%874 = getelementptr inbounds i64, i64* %873, i64 15
%875 = load i64, i64* %874
%876 = add nsw i64 31, %875
%877 = getelementptr inbounds i64, i64* %871, i64 %876
store i64 0, i64* %877
br i1 false, label %886, label %878
878: ; preds = %869
%879 = load i8**, i8*** %5
%880 = bitcast i8** %879 to i64*
%881 = getelementptr inbounds i64, i64* %880, i64 15
%882 = load i64, i64* %881
%883 = add nsw i64 %882, -1
store i64 %883, i64* %881
%884 = or i64 %883, 1
%885 = icmp ne i64 %884, 0
br i1 %885, label %886, label %890
886: ; preds = %878, %869, %848
%887 = load i8**, i8*** %5
%888 = call i32 @main(i32 13, i8** %887)
%889 = icmp ne i32 %888, 0
br i1 %889, label %1253, label %890
890: ; preds = %886, %878, %837, %829
%891 = load i8**, i8*** %5
%892 = bitcast i8** %891 to i64*
%893 = load i32, i32* %4
%894 = sext i32 %893 to i64
%895 = getelementptr inbounds i64, i64* %892, i64 %894
%896 = load i64, i64* %895
%897 = icmp eq i64 %896, 107
br i1 %897, label %898, label %989
898: ; preds = %890
%899 = load i8**, i8*** %5
%900 = bitcast i8** %899 to i64*
%901 = getelementptr inbounds i64, i64* %900, i64 15
%902 = load i64, i64* %901
%903 = load i8**, i8*** %5
%904 = bitcast i8** %903 to i64*
%905 = getelementptr inbounds i64, i64* %904, i64 12
%906 = load i64, i64* %905
%907 = load i8**, i8*** %5
%908 = bitcast i8** %907 to i64*
%909 = getelementptr inbounds i64, i64* %908, i64 13
%910 = load i64, i64* %909
%911 = mul nsw i64 %906, %910
%912 = sdiv i64 %902, %911
%913 = load i8**, i8*** %5
%914 = bitcast i8** %913 to i64*
%915 = getelementptr inbounds i64, i64* %914, i64 14
%916 = load i64, i64* %915
%917 = sub nsw i64 %916, 1
%918 = icmp slt i64 %912, %917
br i1 %918, label %919, label %989
919: ; preds = %898
%920 = load i8**, i8*** %5
%921 = bitcast i8** %920 to i64*
%922 = getelementptr inbounds i64, i64* %921, i64 32
%923 = load i8**, i8*** %5
%924 = bitcast i8** %923 to i64*
%925 = getelementptr inbounds i64, i64* %924, i64 12
%926 = load i64, i64* %925
%927 = load i8**, i8*** %5
%928 = bitcast i8** %927 to i64*
%929 = getelementptr inbounds i64, i64* %928, i64 13
%930 = load i64, i64* %929
%931 = mul nsw i64 %926, %930
%932 = getelementptr inbounds i64, i64* %922, i64 %931
%933 = load i8**, i8*** %5
%934 = bitcast i8** %933 to i64*
%935 = getelementptr inbounds i64, i64* %934, i64 15
%936 = load i64, i64* %935
%937 = getelementptr inbounds i64, i64* %932, i64 %936
%938 = load i64, i64* %937
%939 = load i8**, i8*** %5
%940 = bitcast i8** %939 to i64*
%941 = load i8**, i8*** %5
%942 = bitcast i8** %941 to i64*
%943 = getelementptr inbounds i64, i64* %942, i64 15
%944 = load i64, i64* %943
%945 = add nsw i64 32, %944
%946 = getelementptr inbounds i64, i64* %940, i64 %945
store i64 %938, i64* %946
%947 = and i64 %938, 0
%948 = icmp ne i64 %947, 0
br i1 %948, label %985, label %949
949: ; preds = %919
%950 = load i8**, i8*** %5
%951 = bitcast i8** %950 to i64*
%952 = load i8**, i8*** %5
%953 = bitcast i8** %952 to i64*
%954 = getelementptr inbounds i64, i64* %953, i64 12
%955 = load i64, i64* %954
%956 = load i8**, i8*** %5
%957 = bitcast i8** %956 to i64*
%958 = getelementptr inbounds i64, i64* %957, i64 13
%959 = load i64, i64* %958
%960 = mul nsw i64 %955, %959
%961 = add nsw i64 32, %960
%962 = load i8**, i8*** %5
%963 = bitcast i8** %962 to i64*
%964 = getelementptr inbounds i64, i64* %963, i64 15
%965 = load i64, i64* %964
%966 = add nsw i64 %961, %965
%967 = getelementptr inbounds i64, i64* %951, i64 %966
store i64 0, i64* %967
br i1 false, label %985, label %968
968: ; preds = %949
%969 = load i8**, i8*** %5
%970 = bitcast i8** %969 to i64*
%971 = getelementptr inbounds i64, i64* %970, i64 12
%972 = load i64, i64* %971
%973 = load i8**, i8*** %5
%974 = bitcast i8** %973 to i64*
%975 = getelementptr inbounds i64, i64* %974, i64 13
%976 = load i64, i64* %975
%977 = mul nsw i64 %972, %976
%978 = load i8**, i8*** %5
%979 = bitcast i8** %978 to i64*
%980 = getelementptr inbounds i64, i64* %979, i64 15
%981 = load i64, i64* %980
%982 = add nsw i64 %981, %977
store i64 %982, i64* %980
%983 = or i64 %982, 1
%984 = icmp ne i64 %983, 0
br i1 %984, label %985, label %989
985: ; preds = %968, %949, %919
%986 = load i8**, i8*** %5
%987 = call i32 @main(i32 13, i8** %986)
%988 = icmp ne i32 %987, 0
br i1 %988, label %1253, label %989
989: ; preds = %985, %968, %898, %890
%990 = load i8**, i8*** %5
%991 = bitcast i8** %990 to i64*
%992 = load i32, i32* %4
%993 = sext i32 %992 to i64
%994 = getelementptr inbounds i64, i64* %991, i64 %993
%995 = load i64, i64* %994
%996 = icmp eq i64 %995, 108
br i1 %996, label %997, label %1055
997: ; preds = %989
%998 = load i8**, i8*** %5
%999 = bitcast i8** %998 to i64*
%1000 = getelementptr inbounds i64, i64* %999, i64 15
%1001 = load i64, i64* %1000
%1002 = load i8**, i8*** %5
%1003 = bitcast i8** %1002 to i64*
%1004 = getelementptr inbounds i64, i64* %1003, i64 12
%1005 = load i64, i64* %1004
%1006 = srem i64 %1001, %1005
%1007 = load i8**, i8*** %5
%1008 = bitcast i8** %1007 to i64*
%1009 = getelementptr inbounds i64, i64* %1008, i64 12
%1010 = load i64, i64* %1009
%1011 = sub nsw i64 %1010, 1
%1012 = icmp slt i64 %1006, %1011
br i1 %1012, label %1013, label %1055
1013: ; preds = %997
%1014 = load i8**, i8*** %5
%1015 = bitcast i8** %1014 to i64*
%1016 = getelementptr inbounds i64, i64* %1015, i64 32
%1017 = getelementptr inbounds i64, i64* %1016, i64 1
%1018 = load i8**, i8*** %5
%1019 = bitcast i8** %1018 to i64*
%1020 = getelementptr inbounds i64, i64* %1019, i64 15
%1021 = load i64, i64* %1020
%1022 = getelementptr inbounds i64, i64* %1017, i64 %1021
%1023 = load i64, i64* %1022
%1024 = load i8**, i8*** %5
%1025 = bitcast i8** %1024 to i64*
%1026 = load i8**, i8*** %5
%1027 = bitcast i8** %1026 to i64*
%1028 = getelementptr inbounds i64, i64* %1027, i64 15
%1029 = load i64, i64* %1028
%1030 = add nsw i64 32, %1029
%1031 = getelementptr inbounds i64, i64* %1025, i64 %1030
store i64 %1023, i64* %1031
%1032 = and i64 %1023, 0
%1033 = icmp ne i64 %1032, 0
br i1 %1033, label %1051, label %1034
1034: ; preds = %1013
%1035 = load i8**, i8*** %5
%1036 = bitcast i8** %1035 to i64*
%1037 = load i8**, i8*** %5
%1038 = bitcast i8** %1037 to i64*
%1039 = getelementptr inbounds i64, i64* %1038, i64 15
%1040 = load i64, i64* %1039
%1041 = add nsw i64 33, %1040
%1042 = getelementptr inbounds i64, i64* %1036, i64 %1041
store i64 0, i64* %1042
br i1 false, label %1051, label %1043
1043: ; preds = %1034
%1044 = load i8**, i8*** %5
%1045 = bitcast i8** %1044 to i64*
%1046 = getelementptr inbounds i64, i64* %1045, i64 15
%1047 = load i64, i64* %1046
%1048 = add nsw i64 %1047, 1
store i64 %1048, i64* %1046
%1049 = or i64 %1048, 1
%1050 = icmp ne i64 %1049, 0
br i1 %1050, label %1051, label %1055
1051: ; preds = %1043, %1034, %1013
%1052 = load i8**, i8*** %5
%1053 = call i32 @main(i32 13, i8** %1052)
%1054 = icmp ne i32 %1053, 0
br i1 %1054, label %1253, label %1055
1055: ; preds = %1051, %1043, %997, %989
%1056 = load i8**, i8*** %5
%1057 = bitcast i8** %1056 to i64*
%1058 = load i32, i32* %4
%1059 = sext i32 %1058 to i64
%1060 = getelementptr inbounds i64, i64* %1057, i64 %1059
%1061 = load i64, i64* %1060
%1062 = icmp eq i64 %1061, 110
br i1 %1062, label %1063, label %1144
1063: ; preds = %1055
%1064 = load i8**, i8*** %5
%1065 = bitcast i8** %1064 to i64*
%1066 = getelementptr inbounds i64, i64* %1065, i64 15
%1067 = load i64, i64* %1066
%1068 = load i8**, i8*** %5
%1069 = bitcast i8** %1068 to i64*
%1070 = getelementptr inbounds i64, i64* %1069, i64 12
%1071 = load i64, i64* %1070
%1072 = load i8**, i8*** %5
%1073 = bitcast i8** %1072 to i64*
%1074 = getelementptr inbounds i64, i64* %1073, i64 13
%1075 = load i64, i64* %1074
%1076 = mul nsw i64 %1071, %1075
%1077 = srem i64 %1067, %1076
%1078 = load i8**, i8*** %5
%1079 = bitcast i8** %1078 to i64*
%1080 = getelementptr inbounds i64, i64* %1079, i64 12
%1081 = load i64, i64* %1080
%1082 = sdiv i64 %1077, %1081
%1083 = load i8**, i8*** %5
%1084 = bitcast i8** %1083 to i64*
%1085 = getelementptr inbounds i64, i64* %1084, i64 13
%1086 = load i64, i64* %1085
%1087 = sub nsw i64 %1086, 1
%1088 = icmp slt i64 %1082, %1087
br i1 %1088, label %1089, label %1144
1089: ; preds = %1063
%1090 = load i8**, i8*** %5
%1091 = bitcast i8** %1090 to i64*
%1092 = getelementptr inbounds i64, i64* %1091, i64 32
%1093 = load i8**, i8*** %5
%1094 = bitcast i8** %1093 to i64*
%1095 = getelementptr inbounds i64, i64* %1094, i64 12
%1096 = load i64, i64* %1095
%1097 = getelementptr inbounds i64, i64* %1092, i64 %1096
%1098 = load i8**, i8*** %5
%1099 = bitcast i8** %1098 to i64*
%1100 = getelementptr inbounds i64, i64* %1099, i64 15
%1101 = load i64, i64* %1100
%1102 = getelementptr inbounds i64, i64* %1097, i64 %1101
%1103 = load i64, i64* %1102
%1104 = load i8**, i8*** %5
%1105 = bitcast i8** %1104 to i64*
%1106 = load i8**, i8*** %5
%1107 = bitcast i8** %1106 to i64*
%1108 = getelementptr inbounds i64, i64* %1107, i64 15
%1109 = load i64, i64* %1108
%1110 = add nsw i64 32, %1109
%1111 = getelementptr inbounds i64, i64* %1105, i64 %1110
store i64 %1103, i64* %1111
%1112 = and i64 %1103, 0
%1113 = icmp ne i64 %1112, 0
br i1 %1113, label %1140, label %1114
1114: ; preds = %1089
%1115 = load i8**, i8*** %5
%1116 = bitcast i8** %1115 to i64*
%1117 = load i8**, i8*** %5
%1118 = bitcast i8** %1117 to i64*
%1119 = getelementptr inbounds i64, i64* %1118, i64 12
%1120 = load i64, i64* %1119
%1121 = add nsw i64 32, %1120
%1122 = load i8**, i8*** %5
%1123 = bitcast i8** %1122 to i64*
%1124 = getelementptr inbounds i64, i64* %1123, i64 15
%1125 = load i64, i64* %1124
%1126 = add nsw i64 %1121, %1125
%1127 = getelementptr inbounds i64, i64* %1116, i64 %1126
store i64 0, i64* %1127
br i1 false, label %1140, label %1128
1128: ; preds = %1114
%1129 = load i8**, i8*** %5
%1130 = bitcast i8** %1129 to i64*
%1131 = getelementptr inbounds i64, i64* %1130, i64 12
%1132 = load i64, i64* %1131
%1133 = load i8**, i8*** %5
%1134 = bitcast i8** %1133 to i64*
%1135 = getelementptr inbounds i64, i64* %1134, i64 15
%1136 = load i64, i64* %1135
%1137 = add nsw i64 %1136, %1132
store i64 %1137, i64* %1135
%1138 = or i64 %1137, 1
%1139 = icmp ne i64 %1138, 0
br i1 %1139, label %1140, label %1144
1140: ; preds = %1128, %1114, %1089
%1141 = load i8**, i8*** %5
%1142 = call i32 @main(i32 13, i8** %1141)
%1143 = icmp ne i32 %1142, 0
br i1 %1143, label %1253, label %1144
1144: ; preds = %1140, %1128, %1063, %1055
%1145 = load i8**, i8*** %5
%1146 = bitcast i8** %1145 to i64*
%1147 = load i32, i32* %4
%1148 = sext i32 %1147 to i64
%1149 = getelementptr inbounds i64, i64* %1146, i64 %1148
%1150 = load i64, i64* %1149
%1151 = icmp eq i64 %1150, 111
br i1 %1151, label %1152, label %1231
1152: ; preds = %1144
%1153 = load i8**, i8*** %5
%1154 = bitcast i8** %1153 to i64*
%1155 = getelementptr inbounds i64, i64* %1154, i64 15
%1156 = load i64, i64* %1155
%1157 = load i8**, i8*** %5
%1158 = bitcast i8** %1157 to i64*
%1159 = getelementptr inbounds i64, i64* %1158, i64 12
%1160 = load i64, i64* %1159
%1161 = load i8**, i8*** %5
%1162 = bitcast i8** %1161 to i64*
%1163 = getelementptr inbounds i64, i64* %1162, i64 13
%1164 = load i64, i64* %1163
%1165 = mul nsw i64 %1160, %1164
%1166 = srem i64 %1156, %1165
%1167 = load i8**, i8*** %5
%1168 = bitcast i8** %1167 to i64*
%1169 = getelementptr inbounds i64, i64* %1168, i64 12
%1170 = load i64, i64* %1169
%1171 = sdiv i64 %1166, %1170
%1172 = icmp slt i64 0, %1171
br i1 %1172, label %1173, label %1231
1173: ; preds = %1152
%1174 = load i8**, i8*** %5
%1175 = bitcast i8** %1174 to i64*
%1176 = getelementptr inbounds i64, i64* %1175, i64 32
%1177 = load i8**, i8*** %5
%1178 = bitcast i8** %1177 to i64*
%1179 = getelementptr inbounds i64, i64* %1178, i64 12
%1180 = load i64, i64* %1179
%1181 = sub nsw i64 0, %1180
%1182 = getelementptr inbounds i64, i64* %1176, i64 %1181
%1183 = load i8**, i8*** %5
%1184 = bitcast i8** %1183 to i64*
%1185 = getelementptr inbounds i64, i64* %1184, i64 15
%1186 = load i64, i64* %1185
%1187 = getelementptr inbounds i64, i64* %1182, i64 %1186
%1188 = load i64, i64* %1187
%1189 = load i8**, i8*** %5
%1190 = bitcast i8** %1189 to i64*
%1191 = load i8**, i8*** %5
%1192 = bitcast i8** %1191 to i64*
%1193 = getelementptr inbounds i64, i64* %1192, i64 15
%1194 = load i64, i64* %1193
%1195 = add nsw i64 32, %1194
%1196 = getelementptr inbounds i64, i64* %1190, i64 %1195
store i64 %1188, i64* %1196
%1197 = and i64 %1188, 0
%1198 = icmp ne i64 %1197, 0
br i1 %1198, label %1227, label %1199
1199: ; preds = %1173
%1200 = load i8**, i8*** %5
%1201 = bitcast i8** %1200 to i64*
%1202 = load i8**, i8*** %5
%1203 = bitcast i8** %1202 to i64*
%1204 = getelementptr inbounds i64, i64* %1203, i64 12
%1205 = load i64, i64* %1204
%1206 = sub nsw i64 0, %1205
%1207 = add nsw i64 32, %1206
%1208 = load i8**, i8*** %5
%1209 = bitcast i8** %1208 to i64*
%1210 = getelementptr inbounds i64, i64* %1209, i64 15
%1211 = load i64, i64* %1210
%1212 = add nsw i64 %1207, %1211
%1213 = getelementptr inbounds i64, i64* %1201, i64 %1212
store i64 0, i64* %1213
br i1 false, label %1227, label %1214
1214: ; preds = %1199
%1215 = load i8**, i8*** %5
%1216 = bitcast i8** %1215 to i64*
%1217 = getelementptr inbounds i64, i64* %1216, i64 12
%1218 = load i64, i64* %1217
%1219 = sub nsw i64 0, %1218
%1220 = load i8**, i8*** %5
%1221 = bitcast i8** %1220 to i64*
%1222 = getelementptr inbounds i64, i64* %1221, i64 15
%1223 = load i64, i64* %1222
%1224 = add nsw i64 %1223, %1219
store i64 %1224, i64* %1222
%1225 = or i64 %1224, 1
%1226 = icmp ne i64 %1225, 0
br i1 %1226, label %1227, label %1231
1227: ; preds = %1214, %1199, %1173
%1228 = load i8**, i8*** %5
%1229 = call i32 @main(i32 13, i8** %1228)
%1230 = icmp ne i32 %1229, 0
br i1 %1230, label %1253, label %1231
1231: ; preds = %1227, %1214, %1152, %1144
%1232 = load i8**, i8*** %5
%1233 = bitcast i8** %1232 to i64*
%1234 = load i32, i32* %4
%1235 = sext i32 %1234 to i64
%1236 = getelementptr inbounds i64, i64* %1233, i64 %1235
%1237 = load i64, i64* %1236
%1238 = icmp eq i64 %1237, 113
br i1 %1238, label %1239, label %1246
1239: ; preds = %1231
%1240 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.12, i64 0, i64 0))
%1241 = icmp ne i32 %1240, 0
br i1 %1241, label %1242, label %1246
1242: ; preds = %1239
%1243 = load i8**, i8*** %5
%1244 = call i32 @main(i32 15, i8** %1243)
%1245 = icmp ne i32 %1244, 0
br i1 %1245, label %1253, label %1246
1246: ; preds = %1242, %1239, %1231
%1247 = load i32, i32* %4
%1248 = sext i32 %1247 to i64
%1249 = trunc i64 %1248 to i32
%1250 = load i8**, i8*** %5
%1251 = call i32 @main(i32 %1249, i8** %1250)
%1252 = icmp ne i32 %1251, 0
br i1 %1252, label %1253, label %1375
1253: ; preds = %1246, %1242, %1227, %1140, %1051, %985, %886, %825, %722, %713, %703, %699, %695, %691
%1254 = load i32, i32* %4
%1255 = sub nsw i32 %1254, 19
%1256 = icmp ne i32 %1255, 0
br i1 %1256, label %1353, label %1257
1257: ; preds = %1253
%1258 = load i8**, i8*** %5
%1259 = bitcast i8** %1258 to i64*
%1260 = getelementptr inbounds i64, i64* %1259, i64 4
%1261 = load i64, i64* %1260
%1262 = load i8**, i8*** %5
%1263 = bitcast i8** %1262 to i64*
%1264 = getelementptr inbounds i64, i64* %1263, i64 12
%1265 = load i64, i64* %1264
%1266 = load i8**, i8*** %5
%1267 = bitcast i8** %1266 to i64*
%1268 = getelementptr inbounds i64, i64* %1267, i64 13
%1269 = load i64, i64* %1268
%1270 = mul nsw i64 %1265, %1269
%1271 = load i8**, i8*** %5
%1272 = bitcast i8** %1271 to i64*
%1273 = getelementptr inbounds i64, i64* %1272, i64 14
%1274 = load i64, i64* %1273
%1275 = mul nsw i64 %1270, %1274
%1276 = sub nsw i64 %1261, %1275
%1277 = icmp ne i64 %1276, 0
br i1 %1277, label %1278, label %1375
1278: ; preds = %1257
%1279 = load i8**, i8*** %5
%1280 = bitcast i8** %1279 to i64*
%1281 = getelementptr inbounds i64, i64* %1280, i64 32
%1282 = load i8**, i8*** %5
%1283 = bitcast i8** %1282 to i64*
%1284 = getelementptr inbounds i64, i64* %1283, i64 4
%1285 = load i64, i64* %1284
%1286 = getelementptr inbounds i64, i64* %1281, i64 %1285
%1287 = load i64, i64* %1286
%1288 = load i8**, i8*** %5
%1289 = bitcast i8** %1288 to i64*
%1290 = getelementptr inbounds i64, i64* %1289, i64 4
%1291 = load i64, i64* %1290
%1292 = add nsw i64 %1291, 1
%1293 = load i8**, i8*** %5
%1294 = bitcast i8** %1293 to i64*
%1295 = getelementptr inbounds i64, i64* %1294, i64 12
%1296 = load i64, i64* %1295
%1297 = load i8**, i8*** %5
%1298 = bitcast i8** %1297 to i64*
%1299 = getelementptr inbounds i64, i64* %1298, i64 13
%1300 = load i64, i64* %1299
%1301 = mul nsw i64 %1296, %1300
%1302 = load i8**, i8*** %5
%1303 = bitcast i8** %1302 to i64*
%1304 = getelementptr inbounds i64, i64* %1303, i64 14
%1305 = load i64, i64* %1304
%1306 = mul nsw i64 %1301, %1305
%1307 = srem i64 %1292, %1306
%1308 = sub nsw i64 %1287, %1307
%1309 = icmp ne i64 %1308, 0
br i1 %1309, label %1310, label %1335
1310: ; preds = %1278
%1311 = load i8**, i8*** %5
%1312 = bitcast i8** %1311 to i64*
%1313 = getelementptr inbounds i64, i64* %1312, i64 0
store i64 1, i64* %1313
br i1 false, label %1375, label %1314
1314: ; preds = %1310
%1315 = load i8**, i8*** %5
%1316 = bitcast i8** %1315 to i64*
%1317 = getelementptr inbounds i64, i64* %1316, i64 12
%1318 = load i64, i64* %1317
%1319 = load i8**, i8*** %5
%1320 = bitcast i8** %1319 to i64*
%1321 = getelementptr inbounds i64, i64* %1320, i64 13
%1322 = load i64, i64* %1321
%1323 = mul nsw i64 %1318, %1322
%1324 = load i8**, i8*** %5
%1325 = bitcast i8** %1324 to i64*
%1326 = getelementptr inbounds i64, i64* %1325, i64 14
%1327 = load i64, i64* %1326
%1328 = mul nsw i64 %1323, %1327
%1329 = sub nsw i64 %1328, 1
%1330 = load i8**, i8*** %5
%1331 = bitcast i8** %1330 to i64*
%1332 = getelementptr inbounds i64, i64* %1331, i64 4
store i64 %1329, i64* %1332
%1333 = and i64 %1329, 0
%1334 = icmp ne i64 %1333, 0
br i1 %1334, label %1375, label %1335
1335: ; preds = %1314, %1278
%1336 = load i8**, i8*** %5
%1337 = bitcast i8** %1336 to i64*
%1338 = getelementptr inbounds i64, i64* %1337, i64 4
%1339 = load i64, i64* %1338
%1340 = add nsw i64 %1339, 1
%1341 = load i8**, i8*** %5
%1342 = bitcast i8** %1341 to i64*
%1343 = getelementptr inbounds i64, i64* %1342, i64 4
store i64 %1340, i64* %1343
%1344 = and i64 %1340, 0
%1345 = icmp ne i64 %1344, 0
br i1 %1345, label %1375, label %1346
1346: ; preds = %1335
%1347 = load i32, i32* %4
%1348 = sext i32 %1347 to i64
%1349 = trunc i64 %1348 to i32
%1350 = load i8**, i8*** %5
%1351 = call i32 @main(i32 %1349, i8** %1350)
%1352 = icmp ne i32 %1351, 0
br i1 %1352, label %1353, label %1375
1353: ; preds = %1346, %1253
%1354 = load i32, i32* %4
%1355 = sub nsw i32 %1354, 15
%1356 = icmp ne i32 %1355, 0
br i1 %1356, label %1364, label %1357
1357: ; preds = %1353
%1358 = call i32 (i8*, ...) bitcast (i32 (...)* @system to i32 (i8*, ...)*)(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.13, i64 0, i64 0))
%1359 = icmp ne i32 %1358, 0
br i1 %1359, label %1364, label %1360
1360: ; preds = %1357
unreachable
1361: ; No predecessors!
%1362 = load i32, i32* %4
%1363 = icmp ne i32 %1362, 0
br i1 %1363, label %1364, label %1375
1364: ; preds = %1361, %1357, %1353
%1365 = load i32, i32* %4
%1366 = sub nsw i32 %1365, 5
%1367 = icmp ne i32 %1366, 0
br i1 %1367, label %1373, label %1368
1368: ; preds = %1364
%1369 = bitcast i32* %4 to i64*
%1370 = load i8**, i8*** %5
%1371 = bitcast i8** %1370 to i64*
%1372 = icmp ult i64* %1369, %1371
br label %1373
1373: ; preds = %1368, %1364
%1374 = phi i1 [ true, %1364 ], [ %1372, %1368 ]
br label %1375
1375: ; preds = %1373, %1361, %1346, %1335, %1314, %1310, %1257, %1246, %716, %684, %673, %662, %631, %623, %617, %571, %560, %550, %529, %525, %504, %496, %335, %231, %213, %202, %199, %175, %146, %77, %45, %37, %11
%1376 = phi i1 [ false, %1361 ], [ false, %1346 ], [ false, %1335 ], [ false, %1314 ], [ false, %1310 ], [ false, %1257 ], [ false, %1246 ], [ false, %716 ], [ false, %684 ], [ false, %673 ], [ false, %662 ], [ false, %631 ], [ false, %623 ], [ false, %617 ], [ false, %571 ], [ false, %560 ], [ false, %550 ], [ false, %529 ], [ false, %525 ], [ false, %504 ], [ false, %496 ], [ false, %335 ], [ false, %231 ], [ false, %213 ], [ false, %202 ], [ false, %199 ], [ false, %175 ], [ false, %146 ], [ false, %77 ], [ false, %45 ], [ false, %37 ], [ false, %11 ], [ %1374, %1373 ]
%1377 = zext i1 %1376 to i32
ret i32 %1377
}

LLVM IR (-O2):
@.str = [5 x i8] c"\1B[;H\00"
@.str.1 = [4 x i8] c"%*s\00"
@.str.2 = [1 x i8] zeroinitializer
@.str.3 = [5 x i8] c"%*ld\00"
@.str.4 = [6 x i8] c"%*.*s\00"
@.str.5 = [6 x i8] c"#####\00"
@.str.6 = [2 x i8] c"\0A\00"
@.str.7 = [26 x i8] c"Syntax: %s <x> <y> [<z>]\0A\00"
@.str.8 = [4 x i8] c"%ld\00"
@.str.9 = [18 x i8] c"stty cbreak -echo\00"
@.str.10 = [5 x i8] c"\1B[2J\00"
@.str.11 = [10 x i8] c"You win!\0A\00"
@.str.12 = [14 x i8] c"You lose :-)\0A\00"
@.str.13 = [10 x i8] c"stty sane\00"
define i32 @main(i32 %0, i8** %1) {
%3 = alloca i32
%4 = alloca i8**
store i32 %0, i32* %3
store i8** %1, i8*** %4
%5 = add nsw i32 %0, -1
%6 = and i32 %5, -2
%7 = icmp eq i32 %6, 2
br i1 %7, label %8, label %17
8: ; preds = %2
%9 = bitcast i32* %3 to i8**
%10 = call i32 @main(i32 5, i8** %9)
%11 = icmp eq i32 %10, 0
%12 = select i1 %11, i32 6, i32 7
%13 = call i32 @main(i32 %12, i8** %9)
%14 = icmp eq i32 %13, 0
br i1 %14, label %710, label %15
15: ; preds = %8
%16 = load i32, i32* %3
br label %17
17: ; preds = %15, %2
%18 = phi i32 [ %16, %15 ], [ %0, %2 ]
%19 = icmp eq i32 %18, 13
br i1 %19, label %20, label %30
20: ; preds = %17
%21 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0))
%22 = icmp eq i32 %21, 0
br i1 %22, label %30, label %23
23: ; preds = %20
%24 = bitcast i8*** %4 to i64**
%25 = load i64*, i64** %24
%26 = getelementptr inbounds i64, i64* %25, i64 4
store i64 0, i64* %26
%27 = bitcast i64* %25 to i8**
%28 = call i32 @main(i32 14, i8** %27)
%29 = icmp eq i32 %28, 0
br i1 %29, label %710, label %30
30: ; preds = %23, %20, %17
%31 = load i32, i32* %3
%32 = icmp eq i32 %31, 14
br i1 %32, label %33, label %135
33: ; preds = %30
%34 = bitcast i8*** %4 to i64**
%35 = load i64*, i64** %34
%36 = getelementptr inbounds i64, i64* %35, i64 4
%37 = load i64, i64* %36
%38 = getelementptr inbounds i64, i64* %35, i64 12
%39 = load i64, i64* %38
%40 = getelementptr inbounds i64, i64* %35, i64 13
%41 = load i64, i64* %40
%42 = mul nsw i64 %41, %39
%43 = getelementptr inbounds i64, i64* %35, i64 14
%44 = load i64, i64* %43
%45 = mul nsw i64 %42, %44
%46 = icmp eq i64 %37, %45
br i1 %46, label %710, label %47
47: ; preds = %33
%48 = srem i64 %37, %39
%49 = icmp eq i64 %48, 0
br i1 %49, label %50, label %61
50: ; preds = %47
%51 = srem i64 %37, %42
%52 = sdiv i64 %51, %39
%53 = sub nsw i64 %41, %52
%54 = trunc i64 %53 to i32
%55 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), i32 %54, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.2, i64 0, i64 0))
%56 = icmp eq i32 %55, 0
br i1 %56, label %710, label %57
57: ; preds = %50
%58 = load i64*, i64** %34
%59 = getelementptr inbounds i64, i64* %58, i64 4
%60 = load i64, i64* %59
br label %61
61: ; preds = %57, %47
%62 = phi i64 [ %60, %57 ], [ %37, %47 ]
%63 = phi i64* [ %58, %57 ], [ %35, %47 ]
%64 = getelementptr inbounds i64, i64* %63, i64 32
%65 = getelementptr inbounds i64, i64* %64, i64 %62
%66 = load i64, i64* %65
%67 = icmp eq i64 %66, 0
br i1 %67, label %76, label %68
68: ; preds = %61
%69 = getelementptr inbounds i64, i64* %63, i64 31
%70 = load i64, i64* %69
%71 = trunc i64 %70 to i32
%72 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.3, i64 0, i64 0), i32 %71, i64 %66)
%73 = icmp eq i32 %72, 0
br i1 %73, label %74, label %82
74: ; preds = %68
%75 = load i64*, i64** %34
br label %76
76: ; preds = %74, %61
%77 = phi i64* [ %75, %74 ], [ %63, %61 ]
%78 = getelementptr inbounds i64, i64* %77, i64 31
%79 = load i64, i64* %78
%80 = trunc i64 %79 to i32
%81 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.4, i64 0, i64 0), i32 %80, i32 %80, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.5, i64 0, i64 0))
br label %82
82: ; preds = %76, %68
%83 = load i64*, i64** %34
%84 = getelementptr inbounds i64, i64* %83, i64 4
%85 = load i64, i64* %84
%86 = getelementptr inbounds i64, i64* %83, i64 12
%87 = load i64, i64* %86
%88 = srem i64 %85, %87
%89 = add nsw i64 %87, -1
%90 = icmp eq i64 %88, %89
br i1 %90, label %91, label %96
91: ; preds = %82
%92 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0))
%93 = icmp eq i32 %92, 0
br i1 %93, label %94, label %103
94: ; preds = %91
%95 = load i64*, i64** %34
br label %96
96: ; preds = %94, %82
%97 = phi i64* [ %95, %94 ], [ %83, %82 ]
%98 = getelementptr inbounds i64, i64* %97, i64 13
%99 = load i64, i64* %98
%100 = trunc i64 %99 to i32
%101 = add i32 %100, 1
%102 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), i32 %101, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.2, i64 0, i64 0))
br label %103
103: ; preds = %96, %91
%104 = load i64*, i64** %34
%105 = getelementptr inbounds i64, i64* %104, i64 4
%106 = load i64, i64* %105
%107 = add nsw i64 %106, 1
%108 = getelementptr inbounds i64, i64* %104, i64 12
%109 = load i64, i64* %108
%110 = getelementptr inbounds i64, i64* %104, i64 13
%111 = load i64, i64* %110
%112 = mul nsw i64 %111, %109
%113 = srem i64 %107, %112
%114 = icmp eq i64 %113, 0
%115 = icmp sgt i64 %111, 1
%116 = select i1 %114, i1 %115, i1 false
br i1 %116, label %117, label %125
117: ; preds = %103
%118 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0))
%119 = icmp eq i32 %118, 0
br i1 %119, label %710, label %120
120: ; preds = %117
%121 = load i64*, i64** %34
%122 = getelementptr inbounds i64, i64* %121, i64 4
%123 = load i64, i64* %122
%124 = add nsw i64 %123, 1
br label %125
125: ; preds = %120, %103
%126 = phi i64 [ %124, %120 ], [ %107, %103 ]
%127 = phi i64* [ %121, %120 ], [ %104, %103 ]
%128 = getelementptr inbounds i64, i64* %127, i64 4
store i64 %126, i64* %128
%129 = load i32, i32* %3
%130 = bitcast i64* %127 to i8**
%131 = call i32 @main(i32 %129, i8** %130)
%132 = icmp eq i32 %131, 0
br i1 %132, label %710, label %133
133: ; preds = %125
%134 = load i32, i32* %3
br label %135
135: ; preds = %133, %30
%136 = phi i32 [ %134, %133 ], [ %31, %30 ]
%137 = add nsw i32 %136, -1
%138 = icmp ult i32 %137, 2
br i1 %138, label %139, label %148
139: ; preds = %135
%140 = load i8**, i8*** %4
%141 = load i8*, i8** %140
%142 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([26 x i8], [26 x i8]* @.str.7, i64 0, i64 0), i8* %141)
%143 = icmp eq i32 %142, 0
br i1 %143, label %148, label %144
144: ; preds = %139
%145 = load i8**, i8*** %4
%146 = call i32 @main(i32 15, i8** %145)
%147 = icmp eq i32 %146, 0
br i1 %147, label %710, label %148
148: ; preds = %144, %139, %135
%149 = load i32, i32* %3
%150 = and i32 %149, -2
%151 = icmp eq i32 %150, 6
br i1 %151, label %152, label %200
152: ; preds = %148
%153 = and i32 %149, 1
%154 = zext i32 %153 to i64
%155 = load i8**, i8*** %4
%156 = ptrtoint i8** %155 to i64
%157 = ptrtoint i32* %3 to i64
%158 = sub i64 %156, %157
%159 = ashr exact i64 %158, 3
%160 = mul nuw nsw i64 %159, %154
%161 = xor i32 %153, 1
%162 = zext i32 %161 to i64
%163 = sub i64 %157, %156
%164 = ashr exact i64 %163, 3
%165 = mul nuw nsw i64 %164, %162
%166 = add nsw i64 %160, %165
%167 = icmp ult i64 %166, 4096
br i1 %167, label %193, label %168
168: ; preds = %152
%169 = bitcast i8** %155 to i8*
%170 = ptrtoint i8*** %4 to i64
%171 = sub i64 %170, %157
%172 = getelementptr inbounds i8, i8* %169, i64 %171
%173 = bitcast i8* %172 to i64*
%174 = load i64, i64* %173
%175 = mul nuw nsw i64 %154, %157
%176 = mul nuw nsw i64 %156, %162
%177 = add nsw i64 %176, %175
%178 = inttoptr i64 %177 to i64*
%179 = getelementptr inbounds i64, i64* %178, i64 8
store i64 %174, i64* %179
%180 = icmp eq i64 %174, 0
br i1 %180, label %193, label %181
181: ; preds = %168
%182 = bitcast i8** %155 to i64*
%183 = load i64, i64* %182
%184 = getelementptr inbounds i64, i64* %178, i64 9
store i64 %183, i64* %184
%185 = icmp eq i64 %183, 0
br i1 %185, label %193, label %186
186: ; preds = %181
%187 = inttoptr i64 %177 to i8**
%188 = call i32 @main(i32 8, i8** %187)
%189 = icmp eq i32 %188, 0
br i1 %189, label %190, label %198
190: ; preds = %186
%191 = load i32, i32* %3
%192 = load i8**, i8*** %4
br label %193
193: ; preds = %190, %181, %168, %152
%194 = phi i8** [ %192, %190 ], [ %155, %181 ], [ %155, %168 ], [ %155, %152 ]
%195 = phi i32 [ %191, %190 ], [ %149, %181 ], [ %149, %168 ], [ %149, %152 ]
%196 = call i32 @main(i32 %195, i8** %194)
%197 = icmp eq i32 %196, 0
br i1 %197, label %710, label %198
198: ; preds = %186, %193
%199 = load i32, i32* %3
br label %200
200: ; preds = %198, %148
%201 = phi i32 [ %199, %198 ], [ %149, %148 ]
%202 = icmp eq i32 %201, 8
br i1 %202, label %203, label %281
203: ; preds = %200
%204 = bitcast i8*** %4 to i64**
%205 = load i64*, i64** %204
%206 = getelementptr inbounds i64, i64* %205, i64 9
%207 = load i64, i64* %206
%208 = and i64 %207, 1
%209 = icmp eq i64 %208, 0
%210 = getelementptr inbounds i64, i64* %205, i64 8
%211 = load i64, i64* %210
%212 = inttoptr i64 %211 to i8**
%213 = getelementptr inbounds i8*, i8** %212, i64 1
%214 = load i8*, i8** %213
%215 = getelementptr inbounds i64, i64* %205, i64 12
%216 = call i32 (i8*, i8*, ...) @sscanf(i8* %214, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.8, i64 0, i64 0), i64* %215)
%217 = load i64*, i64** %204
%218 = getelementptr inbounds i64, i64* %217, i64 8
%219 = load i64, i64* %218
%220 = inttoptr i64 %219 to i8**
%221 = getelementptr inbounds i8*, i8** %220, i64 2
%222 = load i8*, i8** %221
%223 = getelementptr inbounds i64, i64* %217, i64 13
%224 = call i32 (i8*, i8*, ...) @sscanf(i8* %222, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.8, i64 0, i64 0), i64* %223)
%225 = load i64*, i64** %204
br i1 %209, label %230, label %226
226: ; preds = %203
%227 = getelementptr inbounds i64, i64* %225, i64 13
%228 = load i64, i64* %227
%229 = getelementptr inbounds i64, i64* %225, i64 14
store i64 %228, i64* %229
store i64 1, i64* %227
br label %238
230: ; preds = %203
%231 = getelementptr inbounds i64, i64* %225, i64 8
%232 = load i64, i64* %231
%233 = inttoptr i64 %232 to i8**
%234 = getelementptr inbounds i8*, i8** %233, i64 3
%235 = load i8*, i8** %234
%236 = getelementptr inbounds i64, i64* %225, i64 14
%237 = call i32 (i8*, i8*, ...) @sscanf(i8* %235, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.8, i64 0, i64 0), i64* %236)
br label %238
238: ; preds = %230, %226
%239 = call i32 (i32, ...) bitcast (i32 (...)* @time to i32 (i32, ...)*)(i32 0)
%240 = call i32 (i32, ...) bitcast (i32 (...)* @srand to i32 (i32, ...)*)(i32 %239)
%241 = load i64*, i64** %204
%242 = getelementptr inbounds i64, i64* %241, i64 4
store i64 0, i64* %242
%243 = bitcast i64* %241 to i8**
%244 = call i32 @main(i32 9, i8** %243)
%245 = icmp eq i32 %244, 0
br i1 %245, label %246, label %281
246: ; preds = %238
%247 = load i64*, i64** %204
%248 = getelementptr inbounds i64, i64* %247, i64 8
%249 = load i64, i64* %248
%250 = inttoptr i64 %249 to i8**
%251 = load i8*, i8** %250
%252 = getelementptr inbounds i64, i64* %247, i64 12
%253 = load i64, i64* %252
%254 = getelementptr inbounds i64, i64* %247, i64 13
%255 = load i64, i64* %254
%256 = mul nsw i64 %255, %253
%257 = getelementptr inbounds i64, i64* %247, i64 14
%258 = load i64, i64* %257
%259 = mul nsw i64 %256, %258
%260 = call i32 (i8*, i64, i8*, ...) @snprintf(i8* dereferenceable(1) %251, i64 1, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.8, i64 0, i64 0), i64 %259)
%261 = sext i32 %260 to i64
%262 = load i64*, i64** %204
%263 = getelementptr inbounds i64, i64* %262, i64 31
store i64 %261, i64* %263
%264 = call i32 (i8*, ...) bitcast (i32 (...)* @system to i32 (i8*, ...)*)(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.9, i64 0, i64 0))
%265 = icmp eq i32 %264, 0
br i1 %265, label %266, label %281
266: ; preds = %246
%267 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.10, i64 0, i64 0))
%268 = icmp eq i32 %267, 0
br i1 %268, label %281, label %269
269: ; preds = %266
%270 = load i8**, i8*** %4
%271 = call i32 @main(i32 13, i8** %270)
%272 = icmp eq i32 %271, 0
br i1 %272, label %273, label %281
273: ; preds = %269
%274 = load i8**, i8*** %4
%275 = call i32 @main(i32 18, i8** %274)
%276 = icmp eq i32 %275, 0
br i1 %276, label %277, label %281
277: ; preds = %273
%278 = load i8**, i8*** %4
%279 = call i32 @main(i32 15, i8** %278)
%280 = icmp eq i32 %279, 0
br i1 %280, label %710, label %281
281: ; preds = %277, %273, %269, %266, %246, %238, %200
%282 = load i32, i32* %3
%283 = icmp eq i32 %282, 9
br i1 %283, label %284, label %325
284: ; preds = %281
%285 = load i8**, i8*** %4
%286 = getelementptr inbounds i8*, i8** %285, i64 4
%287 = bitcast i8** %286 to i64*
%288 = load i64, i64* %287
%289 = getelementptr inbounds i8*, i8** %285, i64 12
%290 = bitcast i8** %289 to i64*
%291 = load i64, i64* %290
%292 = getelementptr inbounds i8*, i8** %285, i64 13
%293 = bitcast i8** %292 to i64*
%294 = load i64, i64* %293
%295 = mul nsw i64 %294, %291
%296 = getelementptr inbounds i8*, i8** %285, i64 14
%297 = bitcast i8** %296 to i64*
%298 = load i64, i64* %297
%299 = mul nsw i64 %295, %298
%300 = icmp eq i64 %288, %299
br i1 %300, label %710, label %301
301: ; preds = %284
%302 = call i32 @main(i32 16, i8** %285)
%303 = icmp eq i32 %302, 0
br i1 %303, label %304, label %710
304: ; preds = %301
%305 = bitcast i8*** %4 to i64**
%306 = load i64*, i64** %305
%307 = load i64, i64* %306
%308 = getelementptr inbounds i64, i64* %306, i64 4
%309 = load i64, i64* %308
%310 = add nsw i64 %309, 32
%311 = getelementptr inbounds i64, i64* %306, i64 %310
store i64 %307, i64* %311
%312 = load i64, i64* %306
%313 = icmp eq i64 %312, 0
%314 = bitcast i64* %306 to i8**
%315 = load i64, i64* %308
br i1 %313, label %316, label %318
316: ; preds = %304
%317 = getelementptr inbounds i64, i64* %306, i64 15
store i64 %315, i64* %317
br label %318
318: ; preds = %304, %316
%319 = add nsw i64 %315, 1
store i64 %319, i64* %308
%320 = load i32, i32* %3
%321 = call i32 @main(i32 %320, i8** %314)
%322 = icmp eq i32 %321, 0
br i1 %322, label %710, label %323
323: ; preds = %318
%324 = load i32, i32* %3
br label %325
325: ; preds = %323, %281
%326 = phi i32 [ %324, %323 ], [ %282, %281 ]
%327 = icmp eq i32 %326, 16
br i1 %327, label %328, label %356
328: ; preds = %325
%329 = call i32 (...) @rand()
%330 = sext i32 %329 to i64
%331 = bitcast i8*** %4 to i64**
%332 = load i64*, i64** %331
%333 = getelementptr inbounds i64, i64* %332, i64 12
%334 = load i64, i64* %333
%335 = getelementptr inbounds i64, i64* %332, i64 13
%336 = load i64, i64* %335
%337 = mul nsw i64 %336, %334
%338 = getelementptr inbounds i64, i64* %332, i64 14
%339 = load i64, i64* %338
%340 = mul nsw i64 %337, %339
%341 = srem i64 %330, %340
store i64 %341, i64* %332
%342 = getelementptr inbounds i64, i64* %332, i64 1
store i64 0, i64* %342
%343 = getelementptr inbounds i64, i64* %332, i64 5
store i64 0, i64* %343
%344 = bitcast i64* %332 to i8**
%345 = call i32 @main(i32 17, i8** %344)
%346 = icmp eq i32 %345, 0
br i1 %346, label %347, label %356
347: ; preds = %328
%348 = load i8**, i8*** %4
%349 = getelementptr inbounds i8*, i8** %348, i64 1
%350 = bitcast i8** %349 to i64*
%351 = load i64, i64* %350
%352 = icmp eq i64 %351, 0
br i1 %352, label %710, label %353
353: ; preds = %347
%354 = call i32 @main(i32 16, i8** %348)
%355 = icmp eq i32 %354, 0
br i1 %355, label %710, label %356
356: ; preds = %353, %328, %325
%357 = load i32, i32* %3
%358 = icmp eq i32 %357, 17
br i1 %358, label %359, label %383
359: ; preds = %356
%360 = bitcast i8*** %4 to i64**
%361 = load i64*, i64** %360
%362 = getelementptr inbounds i64, i64* %361, i64 5
%363 = load i64, i64* %362
%364 = getelementptr inbounds i64, i64* %361, i64 4
%365 = load i64, i64* %364
%366 = icmp eq i64 %363, %365
%367 = bitcast i64* %361 to i8**
br i1 %366, label %710, label %368
368: ; preds = %359
%369 = getelementptr inbounds i64, i64* %361, i64 32
%370 = getelementptr inbounds i64, i64* %369, i64 %363
%371 = load i64, i64* %370
%372 = load i64, i64* %361
%373 = icmp eq i64 %371, %372
br i1 %373, label %374, label %377
374: ; preds = %368
%375 = getelementptr inbounds i64, i64* %361, i64 1
store i64 1, i64* %375
%376 = add nsw i64 %365, -1
store i64 %376, i64* %362
br label %710
377: ; preds = %368
%378 = add nsw i64 %363, 1
store i64 %378, i64* %362
%379 = call i32 @main(i32 17, i8** %367)
%380 = icmp eq i32 %379, 0
br i1 %380, label %710, label %381
381: ; preds = %377
%382 = load i32, i32* %3
br label %383
383: ; preds = %381, %356
%384 = phi i32 [ %382, %381 ], [ %357, %356 ]
%385 = icmp eq i32 %384, 18
br i1 %385, label %386, label %659
386: ; preds = %383
%387 = bitcast i8*** %4 to i64**
%388 = load i64*, i64** %387
store i64 0, i64* %388
%389 = getelementptr inbounds i64, i64* %388, i64 4
store i64 0, i64* %389
%390 = bitcast i64* %388 to i8**
%391 = call i32 @main(i32 19, i8** %390)
%392 = icmp eq i32 %391, 0
br i1 %392, label %393, label %659
393: ; preds = %386
%394 = load i64*, i64** %387
%395 = load i64, i64* %394
%396 = icmp eq i64 %395, 0
br i1 %396, label %397, label %404
397: ; preds = %393
%398 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([10 x i8], [10 x i8]* @.str.11, i64 0, i64 0))
%399 = icmp eq i32 %398, 0
br i1 %399, label %659, label %400
400: ; preds = %397
%401 = load i64*, i64** %387
%402 = load i64, i64* %401
%403 = icmp eq i64 %402, 0
br i1 %403, label %710, label %404
404: ; preds = %393, %400
%405 = call i32 (...) @getchar()
%406 = sext i32 %405 to i64
%407 = load i64*, i64** %387
%408 = load i32, i32* %3
%409 = sext i32 %408 to i64
%410 = getelementptr inbounds i64, i64* %407, i64 %409
store i64 %406, i64* %410
%411 = icmp eq i32 %405, 105
%412 = bitcast i64* %407 to i8**
br i1 %411, label %413, label %452
413: ; preds = %404
%414 = getelementptr inbounds i64, i64* %407, i64 15
%415 = load i64, i64* %414
%416 = getelementptr inbounds i64, i64* %407, i64 12
%417 = load i64, i64* %416
%418 = getelementptr inbounds i64, i64* %407, i64 13
%419 = load i64, i64* %418
%420 = mul nsw i64 %419, %417
%421 = sdiv i64 %415, %420
%422 = icmp sgt i64 %421, 0
br i1 %422, label %423, label %654
423: ; preds = %413
%424 = getelementptr inbounds i64, i64* %407, i64 32
%425 = sub i64 0, %420
%426 = getelementptr inbounds i64, i64* %424, i64 %425
%427 = getelementptr inbounds i64, i64* %426, i64 %415
%428 = load i64, i64* %427
%429 = add nsw i64 %415, 32
%430 = getelementptr inbounds i64, i64* %407, i64 %429
store i64 %428, i64* %430
%431 = load i64, i64* %416
%432 = load i64, i64* %418
%433 = mul i64 %432, %431
%434 = load i64, i64* %414
%435 = add i64 %434, 32
%436 = sub i64 %435, %433
%437 = getelementptr inbounds i64, i64* %407, i64 %436
store i64 0, i64* %437
%438 = load i64, i64* %416
%439 = load i64, i64* %418
%440 = mul i64 %439, %438
%441 = load i64, i64* %414
%442 = sub i64 %441, %440
store i64 %442, i64* %414
%443 = call i32 @main(i32 13, i8** %412)
%444 = icmp eq i32 %443, 0
br i1 %444, label %445, label %659
445: ; preds = %423
%446 = load i64*, i64** %387
%447 = load i32, i32* %3
%448 = sext i32 %447 to i64
%449 = getelementptr inbounds i64, i64* %446, i64 %448
%450 = load i64, i64* %449
%451 = bitcast i64* %446 to i8**
br label %452
452: ; preds = %445, %404
%453 = phi i8** [ %451, %445 ], [ %412, %404 ]
%454 = phi i64 [ %450, %445 ], [ %406, %404 ]
%455 = phi i64* [ %446, %445 ], [ %407, %404 ]
%456 = icmp eq i64 %454, 106
br i1 %456, label %457, label %484
457: ; preds = %452
%458 = getelementptr inbounds i64, i64* %455, i64 15
%459 = load i64, i64* %458
%460 = getelementptr inbounds i64, i64* %455, i64 12
%461 = load i64, i64* %460
%462 = srem i64 %459, %461
%463 = icmp sgt i64 %462, 0
br i1 %463, label %464, label %654
464: ; preds = %457
%465 = getelementptr inbounds i64, i64* %455, i64 31
%466 = getelementptr inbounds i64, i64* %465, i64 %459
%467 = load i64, i64* %466
%468 = add nsw i64 %459, 32
%469 = getelementptr inbounds i64, i64* %455, i64 %468
store i64 %467, i64* %469
%470 = load i64, i64* %458
%471 = add nsw i64 %470, 31
%472 = getelementptr inbounds i64, i64* %455, i64 %471
store i64 0, i64* %472
%473 = load i64, i64* %458
%474 = add nsw i64 %473, -1
store i64 %474, i64* %458
%475 = call i32 @main(i32 13, i8** %453)
%476 = icmp eq i32 %475, 0
br i1 %476, label %477, label %659
477: ; preds = %464
%478 = load i64*, i64** %387
%479 = load i32, i32* %3
%480 = sext i32 %479 to i64
%481 = getelementptr inbounds i64, i64* %478, i64 %480
%482 = load i64, i64* %481
%483 = bitcast i64* %478 to i8**
br label %484
484: ; preds = %477, %452
%485 = phi i8** [ %483, %477 ], [ %453, %452 ]
%486 = phi i64 [ %482, %477 ], [ %454, %452 ]
%487 = phi i64* [ %478, %477 ], [ %455, %452 ]
%488 = icmp eq i64 %486, 107
br i1 %488, label %489, label %530
489: ; preds = %484
%490 = getelementptr inbounds i64, i64* %487, i64 15
%491 = load i64, i64* %490
%492 = getelementptr inbounds i64, i64* %487, i64 12
%493 = load i64, i64* %492
%494 = getelementptr inbounds i64, i64* %487, i64 13
%495 = load i64, i64* %494
%496 = mul nsw i64 %495, %493
%497 = sdiv i64 %491, %496
%498 = getelementptr inbounds i64, i64* %487, i64 14
%499 = load i64, i64* %498
%500 = add nsw i64 %499, -1
%501 = icmp slt i64 %497, %500
br i1 %501, label %502, label %654
502: ; preds = %489
%503 = getelementptr inbounds i64, i64* %487, i64 32
%504 = getelementptr inbounds i64, i64* %503, i64 %496
%505 = getelementptr inbounds i64, i64* %504, i64 %491
%506 = load i64, i64* %505
%507 = add nsw i64 %491, 32
%508 = getelementptr inbounds i64, i64* %487, i64 %507
store i64 %506, i64* %508
%509 = load i64, i64* %492
%510 = load i64, i64* %494
%511 = mul nsw i64 %510, %509
%512 = add nsw i64 %511, 32
%513 = load i64, i64* %490
%514 = add nsw i64 %512, %513
%515 = getelementptr inbounds i64, i64* %487, i64 %514
store i64 0, i64* %515
%516 = load i64, i64* %492
%517 = load i64, i64* %494
%518 = mul nsw i64 %517, %516
%519 = load i64, i64* %490
%520 = add nsw i64 %519, %518
store i64 %520, i64* %490
%521 = call i32 @main(i32 13, i8** %485)
%522 = icmp eq i32 %521, 0
br i1 %522, label %523, label %659
523: ; preds = %502
%524 = load i64*, i64** %387
%525 = load i32, i32* %3
%526 = sext i32 %525 to i64
%527 = getelementptr inbounds i64, i64* %524, i64 %526
%528 = load i64, i64* %527
%529 = bitcast i64* %524 to i8**
br label %530
530: ; preds = %523, %484
%531 = phi i8** [ %529, %523 ], [ %485, %484 ]
%532 = phi i64 [ %528, %523 ], [ %486, %484 ]
%533 = phi i64* [ %524, %523 ], [ %487, %484 ]
%534 = icmp eq i64 %532, 108
br i1 %534, label %535, label %563
535: ; preds = %530
%536 = getelementptr inbounds i64, i64* %533, i64 15
%537 = load i64, i64* %536
%538 = getelementptr inbounds i64, i64* %533, i64 12
%539 = load i64, i64* %538
%540 = srem i64 %537, %539
%541 = add nsw i64 %539, -1
%542 = icmp slt i64 %540, %541
br i1 %542, label %543, label %654
543: ; preds = %535
%544 = getelementptr inbounds i64, i64* %533, i64 33
%545 = getelementptr inbounds i64, i64* %544, i64 %537
%546 = load i64, i64* %545
%547 = add nsw i64 %537, 32
%548 = getelementptr inbounds i64, i64* %533, i64 %547
store i64 %546, i64* %548
%549 = load i64, i64* %536
%550 = add nsw i64 %549, 33
%551 = getelementptr inbounds i64, i64* %533, i64 %550
store i64 0, i64* %551
%552 = load i64, i64* %536
%553 = add nsw i64 %552, 1
store i64 %553, i64* %536
%554 = call i32 @main(i32 13, i8** %531)
%555 = icmp eq i32 %554, 0
br i1 %555, label %556, label %659
556: ; preds = %543
%557 = load i64*, i64** %387
%558 = load i32, i32* %3
%559 = sext i32 %558 to i64
%560 = getelementptr inbounds i64, i64* %557, i64 %559
%561 = load i64, i64* %560
%562 = bitcast i64* %557 to i8**
br label %563
563: ; preds = %556, %530
%564 = phi i8** [ %562, %556 ], [ %531, %530 ]
%565 = phi i64 [ %561, %556 ], [ %532, %530 ]
%566 = phi i64* [ %557, %556 ], [ %533, %530 ]
%567 = icmp eq i64 %565, 110
br i1 %567, label %568, label %604
568: ; preds = %563
%569 = getelementptr inbounds i64, i64* %566, i64 15
%570 = load i64, i64* %569
%571 = getelementptr inbounds i64, i64* %566, i64 12
%572 = load i64, i64* %571
%573 = getelementptr inbounds i64, i64* %566, i64 13
%574 = load i64, i64* %573
%575 = mul nsw i64 %574, %572
%576 = srem i64 %570, %575
%577 = sdiv i64 %576, %572
%578 = add nsw i64 %574, -1
%579 = icmp slt i64 %577, %578
br i1 %579, label %580, label %654
580: ; preds = %568
%581 = getelementptr inbounds i64, i64* %566, i64 32
%582 = getelementptr inbounds i64, i64* %581, i64 %572
%583 = getelementptr inbounds i64, i64* %582, i64 %570
%584 = load i64, i64* %583
%585 = add nsw i64 %570, 32
%586 = getelementptr inbounds i64, i64* %566, i64 %585
store i64 %584, i64* %586
%587 = load i64, i64* %571
%588 = add nsw i64 %587, 32
%589 = load i64, i64* %569
%590 = add nsw i64 %588, %589
%591 = getelementptr inbounds i64, i64* %566, i64 %590
store i64 0, i64* %591
%592 = load i64, i64* %571
%593 = load i64, i64* %569
%594 = add nsw i64 %593, %592
store i64 %594, i64* %569
%595 = call i32 @main(i32 13, i8** %564)
%596 = icmp eq i32 %595, 0
br i1 %596, label %597, label %659
597: ; preds = %580
%598 = load i64*, i64** %387
%599 = load i32, i32* %3
%600 = sext i32 %599 to i64
%601 = getelementptr inbounds i64, i64* %598, i64 %600
%602 = load i64, i64* %601
%603 = bitcast i64* %598 to i8**
br label %604
604: ; preds = %597, %563
%605 = phi i8** [ %603, %597 ], [ %564, %563 ]
%606 = phi i64 [ %602, %597 ], [ %565, %563 ]
%607 = phi i64* [ %598, %597 ], [ %566, %563 ]
%608 = icmp eq i64 %606, 111
br i1 %608, label %609, label %644
609: ; preds = %604
%610 = getelementptr inbounds i64, i64* %607, i64 15
%611 = load i64, i64* %610
%612 = getelementptr inbounds i64, i64* %607, i64 12
%613 = load i64, i64* %612
%614 = getelementptr inbounds i64, i64* %607, i64 13
%615 = load i64, i64* %614
%616 = mul nsw i64 %615, %613
%617 = srem i64 %611, %616
%618 = sdiv i64 %617, %613
%619 = icmp sgt i64 %618, 0
br i1 %619, label %620, label %654
620: ; preds = %609
%621 = getelementptr inbounds i64, i64* %607, i64 32
%622 = sub nsw i64 0, %613
%623 = getelementptr inbounds i64, i64* %621, i64 %622
%624 = getelementptr inbounds i64, i64* %623, i64 %611
%625 = load i64, i64* %624
%626 = add nsw i64 %611, 32
%627 = getelementptr inbounds i64, i64* %607, i64 %626
store i64 %625, i64* %627
%628 = load i64, i64* %612
%629 = sub i64 32, %628
%630 = load i64, i64* %610
%631 = add nsw i64 %629, %630
%632 = getelementptr inbounds i64, i64* %607, i64 %631
store i64 0, i64* %632
%633 = load i64, i64* %612
%634 = load i64, i64* %610
%635 = sub i64 %634, %633
store i64 %635, i64* %610
%636 = call i32 @main(i32 13, i8** %605)
%637 = icmp eq i32 %636, 0
br i1 %637, label %638, label %659
638: ; preds = %620
%639 = load i64*, i64** %387
%640 = load i32, i32* %3
%641 = sext i32 %640 to i64
%642 = getelementptr inbounds i64, i64* %639, i64 %641
%643 = load i64, i64* %642
br label %644
644: ; preds = %638, %604
%645 = phi i64 [ %643, %638 ], [ %606, %604 ]
%646 = icmp eq i64 %645, 113
br i1 %646, label %647, label %654
647: ; preds = %644
%648 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([14 x i8], [14 x i8]* @.str.12, i64 0, i64 0))
%649 = icmp eq i32 %648, 0
br i1 %649, label %654, label %650
650: ; preds = %647
%651 = load i8**, i8*** %4
%652 = call i32 @main(i32 15, i8** %651)
%653 = icmp eq i32 %652, 0
br i1 %653, label %654, label %659
654: ; preds = %413, %457, %489, %535, %568, %609, %650, %647, %644
%655 = load i32, i32* %3
%656 = load i8**, i8*** %4
%657 = call i32 @main(i32 %655, i8** %656)
%658 = icmp eq i32 %657, 0
br i1 %658, label %710, label %659
659: ; preds = %654, %650, %620, %580, %543, %502, %464, %423, %397, %386, %383
%660 = load i32, i32* %3
%661 = icmp eq i32 %660, 19
br i1 %661, label %662, label %692
662: ; preds = %659
%663 = bitcast i8*** %4 to i64**
%664 = load i64*, i64** %663
%665 = getelementptr inbounds i64, i64* %664, i64 4
%666 = load i64, i64* %665
%667 = getelementptr inbounds i64, i64* %664, i64 12
%668 = load i64, i64* %667
%669 = getelementptr inbounds i64, i64* %664, i64 13
%670 = load i64, i64* %669
%671 = mul nsw i64 %670, %668
%672 = getelementptr inbounds i64, i64* %664, i64 14
%673 = load i64, i64* %672
%674 = mul nsw i64 %671, %673
%675 = icmp eq i64 %666, %674
%676 = bitcast i64* %664 to i8**
br i1 %675, label %710, label %677
677: ; preds = %662
%678 = getelementptr inbounds i64, i64* %664, i64 32
%679 = getelementptr inbounds i64, i64* %678, i64 %666
%680 = load i64, i64* %679
%681 = add nsw i64 %666, 1
%682 = srem i64 %681, %674
%683 = icmp eq i64 %680, %682
br i1 %683, label %686, label %684
684: ; preds = %677
store i64 1, i64* %664
%685 = add nsw i64 %674, -1
store i64 %685, i64* %665
br label %686
686: ; preds = %684, %677
%687 = phi i64 [ %674, %684 ], [ %681, %677 ]
store i64 %687, i64* %665
%688 = call i32 @main(i32 19, i8** %676)
%689 = icmp eq i32 %688, 0
br i1 %689, label %710, label %690
690: ; preds = %686
%691 = load i32, i32* %3
br label %692
692: ; preds = %690, %659
%693 = phi i32 [ %691, %690 ], [ %660, %659 ]
%694 = icmp eq i32 %693, 15
br i1 %694, label %695, label %701
695: ; preds = %692
%696 = call i32 (i8*, ...) bitcast (i32 (...)* @system to i32 (i8*, ...)*)(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.13, i64 0, i64 0))
%697 = icmp eq i32 %696, 0
br i1 %697, label %700, label %698
698: ; preds = %695
%699 = load i32, i32* %3
br label %701
700: ; preds = %695
unreachable
701: ; preds = %698, %692
%702 = phi i32 [ %699, %698 ], [ %693, %692 ]
%703 = icmp ne i32 %702, 5
%704 = bitcast i32* %3 to i64*
%705 = bitcast i8*** %4 to i64**
%706 = load i64*, i64** %705
%707 = icmp ugt i64* %706, %704
%708 = select i1 %703, i1 true, i1 %707
%709 = zext i1 %708 to i32
br label %710
710: ; preds = %374, %701, %686, %662, %654, %400, %377, %359, %353, %347, %318, %301, %284, %277, %193, %144, %125, %117, %50, %33, %23, %8
%711 = phi i32 [ 0, %686 ], [ 0, %662 ], [ 0, %654 ], [ 0, %400 ], [ 0, %377 ], [ 0, %374 ], [ 0, %359 ], [ 0, %353 ], [ 0, %347 ], [ 0, %318 ], [ 0, %301 ], [ 0, %284 ], [ 0, %277 ], [ 0, %193 ], [ 0, %144 ], [ 0, %125 ], [ 0, %117 ], [ 0, %50 ], [ 0, %33 ], [ 0, %23 ], [ 0, %8 ], [ %709, %701 ]
ret i32 %711
}