main(int c, char *C[]) {
  (C[c] = C[1] + 2)[0] = printf("%c", 52 * printf("%c", 'C' + '4' / 4));
  for (c = 0; c < 491; ++c)
    for (**C = C[1]['c' + c] = 0; *C[0] < 8; (**C)++)
      C[1][c + 'c'] =
          *(C[1] + c + 'c') + C[1][99 + c] + (C[1][**C + 8 * c + 99] == 32);
  (*C)[4] = *C[2] == 75 ? *((C[2] += 3) - 2) == 70 ? 1 : 0 : 0;
  ((int *)(C[1] + 6))[0] = ((int *)(C[1] + 6))[1] = c = 0;
  while (*C[2] ? C[2][1] ? *(C[2] + 2) ? 1 : 0 : 0 : 0) {
    if (*C[2] > 'w') {
      ((int *)(C[1] + 6))[1] = 0;
      C[1][2]++;
      *C[2] = 0;
    } else
      ((int *)(C[1] + 6))[1] += *C[2] == 58 ? 2 + (C[2][3] && *(C[2] + 3) < 'x')
                                : *C[2] == 's' ? (C[2][1] -= 48)
                                : *C[2] >= 65  ? 3 - (*C[2] == 'm' ? 1 : 0)
                                               : 1;
    ((int *)(C[1] + 6))[0] = ((int *)(C[1] + 6))[1] > ((int *)(C[1] + 6))[0]
                                 ? ((int *)(C[1] + 6))[1]
                                 : ((int *)(C[1] + 6))[0];
    c += 3;
    *(C + 2) += 3;
  }
  printf("  %d          %d\n", 56 + 8 * ((int *)(C[1] + 6))[0], 80 * *(C[3]++));
  *C[2] = 0;
  C[2] -= c;
  *C[3] = 0;
  while (C[3][1, -1]--) {
    ;
    for (**C = 0; **C < 80; (**C)++) {
      C[2] -= 3 * *C[3];
      *C[3]++ = 0;
      *C[3] = **C >= 51 || **C < 18 || **C % 8 != 2 ? 0 : 255;
      printf("%c", 1 - 1);
      printf("%c", *C[3]);
      for ((*C)[1] = 0; (*C)[1] < 3; (*C)[1]++)
        printf("%c",
               *C[3] | ((*C)[4]                 ? **C > 18 && **C < 42
                                                      ? C[1][42 + *(*C + 1) + 3 * **C]
                                                      : 0
                        : **C >= 11 && **C < 64 ? ~C[1][7 * **C + 97 + (*C)[1]]
                                                : 0));
      printf("%c", *C[3]++);
      for (((int *)(C[1] + 6))[1] = 0;
           (((int *)(C[1] + 6))[2] = ((int *)(C[1] + 6))[1]) <
           ((int *)(C[1] + 6))[0];) {
        (*C)[2] = C[2][1] - 49;
        c = (*C[2] <= 63);
        c = (*C)[0] -
            4 * (C[3][0] = 105 - C[2][c] - 7 * (*(C[2] + c) < 'c') -
                           18 * (C[2][c] < 77) + 2 * (*C)[4] -
                           7 * (C[2][c] < 'C')) -
            6;
        for (((int *)(C[1] + 6))[3] = 0;
             ((int *)(C[1] + 6))[3] <
             (*C[2] ? *C[2] > 'r' ? C[2][1]
                                  : (1 + 2 * (*C[2] > 64) +
                                     (2 - !C[2][3]) * (58 == (*(C + 2))[0]) -
                                     (C[2][0] == 'm'))
              : ((int *)(C[1] + 6))[2]
                  ? ((int *)(C[1] + 6))[0] - ((int *)(C[1] + 6))[2]
                  : 0);
             ((int *)(C[1] + 6))[3]++)
          ((int *)(C[1] + 6))[1] += printf(
              "%c",
              C[1][4] |
                  (*C[2] && *C[2] < 's'
                       ? *C[2] == 58 ? ((int *)(C[1] + 6))[3] == 1
                                           ? **C > 17 && **C < 51
                                                 ? C[2][1] == 59   ? 39
                                                   : C[2][1] == 58 ? 9
                                                                   : 1
                                                 : 0
                                           : 0
                         : 63 > *C[2]
                             ? (c < 7 && c > -9
                                    ? C[1][(*C[2] < 45   ? 'c' * 5 + 2 * '%'
                                            : *C[2] < 61 ? 570
                                                         : 571) +
                                           3 * c]
                                    : 0)
                         : *C[2] > 'o'
                             ? **C > 26 && **C < 29 && !(*C)[2] ||
                                       (*C)[2] == 1 && (&*C[0])[0] < 34 &&
                                           31 < **C
                                   ? ((int *)(C[1] + 6))[3] < 2
                                         ? 15 + 225 * ((int *)(C[1] + 6))[3]
                                         : 0
                               : (*C)[2] == 3
                                   ? ((int *)(C[1] + 6))[3] < 2 && **C > 22 &&
                                             **C < 45 &&
                                             ((int *)(C[1] + 6))[3] < 2
                                         ? C[1][7 * *(*C) + 151 +
                                                ((int *)(C[1] + 6))[3]]
                                         : 0
                               : 7 == (*C)[2] && **C > 26 && **C < 42 &&
                                       ((int *)(C[1] + 6))[3] < 2
                                   ? C[1]
                                      [7 * **C + 135 + ((int *)(C[1] + 6))[3]]
                                   : 0
                         : *C[2] < 'k'
                             ? (c > -5 && c < 5
                                    ? ((int *)(C[1] + 6))[3] < 2
                                          ? C[1][((*C)[2] < 3 ? 207 : 205) +
                                                 7 * c + ((int *)(C[1] + 6))[3]]
                                      : C[2][2] == 46 &&
                                              (c == -2 ||
                                               c == -1 - 2 * (*C[3] % 2))
                                          ? 96
                                          : 0
                                    : 0) |
                                   ((*C)[2]
                                        ? ((int *)(C[1] + 6))[3]
                                              ? ((int *)(C[1] + 6))[3] < 2 &&
                                                        *C[3] > 7 && c < 1 &&
                                                        c > -24
                                                    ? 8
                                                    : 0
                                          : *C[3] < 8 && c > 1 && c < 24 ? ' '
                                                                         : 0
                                        : 0) |
                                   (((int *)(C[1] + 6))[3] < 2 &&
                                            (**C == 66 && *C[3] > 14 ||
                                             *C[3] > 12 && 58 == **C ||
                                             *C[3] < 2 && **C == 10)
                                        ? 5 * 51
                                        : 0) |
                                   (7 == (*C)[2]
                                        ? *C[3] < 8
                                              ? c > 13 && c < 23 &&
                                                        ((int *)(C[1] + 6))[3] <
                                                            2
                                                    ? C[1]
                                                       [144 + 7 * c +
                                                        ((int *)(C[1] + 6))[3]]
                                                    : 0
                                          : ((int *)(C[1] + 6))[3] && c < -14 &&
                                                  c > -24
                                              ? C[1][7 * c + 400 +
                                                     ((int *)(C[1] + 6))[3]]
                                              : 0
                                        : 0)
                         : !((int *)(C[1] + 6))[3]
                             ? **C > 21 && C[0][0] < 32
                                   ? C[1][(*C)[2] + 323 + 7 * **C]
                               : 36 + 1 < **C && '0' > **C
                                   ? C[1][C[2][2] + 162 + 7 * **C]
                                   : 0
                             : 0
                       : 0));
        C[1][3]++;
        C[2] += 3;
      }
      printf("%c", 0);
      C[3] -= 2;
    }
    *C[3] = 0;
  }
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0xf0,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
lea    0x1ed0(%rip),%rdi
mov    $0x50,%esi
mov    $0x0,%al
call   1030 <printf@plt>
imul   $0x34,%eax,%esi
lea    0x1eba(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rax
mov    %rax,%rdi
add    $0x2,%rdi
mov    -0x10(%rbp),%rdx
movslq -0x8(%rbp),%rsi
mov    %rdi,(%rdx,%rsi,8)
mov    %cl,0x2(%rax)
movl   $0x0,-0x8(%rbp)
cmpl   $0x1eb,-0x8(%rbp)
jge    1249 <main+0x139>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rax
mov    -0x8(%rbp),%ecx
add    $0x63,%ecx
movslq %ecx,%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
movb   $0x0,(%rax)
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
movsbl (%rax),%eax
cmp    $0x8,%eax
jge    1236 <main+0x126>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x8(%rbp),%rcx
movsbl 0x63(%rax,%rcx,1),%eax
mov    -0x10(%rbp),%rcx
mov    0x8(%rcx),%rcx
mov    -0x8(%rbp),%edx
add    $0x63,%edx
movslq %edx,%rdx
movsbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
mov    -0x10(%rbp),%rcx
mov    0x8(%rcx),%rcx
mov    -0x10(%rbp),%rdx
mov    (%rdx),%rdx
movsbl (%rdx),%edx
mov    -0x8(%rbp),%esi
shl    $0x3,%esi
add    %esi,%edx
add    $0x63,%edx
movslq %edx,%rdx
movsbl (%rcx,%rdx,1),%ecx
cmp    $0x20,%ecx
sete   %cl
and    $0x1,%cl
movzbl %cl,%ecx
add    %ecx,%eax
mov    %al,%dl
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rax
mov    -0x8(%rbp),%ecx
add    $0x63,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    (%rax),%cl
add    $0x1,%cl
mov    %cl,(%rax)
jmp    11a0 <main+0x90>
jmp    123b <main+0x12b>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1174 <main+0x64>
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rax
movsbl (%rax),%eax
cmp    $0x4b,%eax
jne    1289 <main+0x179>
mov    -0x10(%rbp),%rcx
mov    0x10(%rcx),%rax
mov    %rax,%rdx
add    $0x3,%rdx
mov    %rdx,0x10(%rcx)
movsbl 0x1(%rax),%edx
xor    %eax,%eax
mov    $0x1,%ecx
cmp    $0x46,%edx
cmove  %ecx,%eax
mov    %eax,-0x14(%rbp)
jmp    1293 <main+0x183>
xor    %eax,%eax
mov    %eax,-0x14(%rbp)
jmp    1293 <main+0x183>
mov    -0x14(%rbp),%eax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    %cl,0x4(%rax)
movl   $0x0,-0x8(%rbp)
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rax
movl   $0x0,0xa(%rax)
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rax
movl   $0x0,0x6(%rax)
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rax
movsbl (%rax),%eax
cmp    $0x0,%eax
je     1326 <main+0x216>
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rax
movsbl 0x1(%rax),%eax
cmp    $0x0,%eax
je     1311 <main+0x201>
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rax
movsbl 0x2(%rax),%edx
xor    %eax,%eax
mov    $0x1,%ecx
cmp    $0x0,%edx
cmovne %ecx,%eax
mov    %eax,-0x18(%rbp)
jmp    131b <main+0x20b>
xor    %eax,%eax
mov    %eax,-0x18(%rbp)
jmp    131b <main+0x20b>
mov    -0x18(%rbp),%eax
mov    %eax,-0x1c(%rbp)
jmp    1330 <main+0x220>
xor    %eax,%eax
mov    %eax,-0x1c(%rbp)
jmp    1330 <main+0x220>
mov    -0x1c(%rbp),%eax
cmp    $0x0,%eax
je     14d5 <main+0x3c5>
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rax
movsbl (%rax),%eax
cmp    $0x77,%eax
jle    1380 <main+0x270>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rax
movl   $0x0,0xa(%rax)
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rax
mov    0x2(%rax),%cl
add    $0x1,%cl
mov    %cl,0x2(%rax)
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rax
movb   $0x0,(%rax)
jmp    146c <main+0x35c>
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rax
movsbl (%rax),%eax
cmp    $0x3a,%eax
jne    13d6 <main+0x2c6>
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rax
movsbl 0x3(%rax),%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x1d(%rbp)
je     13c3 <main+0x2b3>
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rax
movsbl 0x3(%rax),%eax
cmp    $0x78,%eax
setl   %al
mov    %al,-0x1d(%rbp)
mov    -0x1d(%rbp),%al
and    $0x1,%al
movzbl %al,%eax
add    $0x2,%eax
mov    %eax,-0x24(%rbp)
jmp    145b <main+0x34b>
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rax
movsbl (%rax),%eax
cmp    $0x73,%eax
jne    1407 <main+0x2f7>
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rcx
movsbl 0x1(%rcx),%eax
sub    $0x30,%eax
mov    %al,0x1(%rcx)
movsbl %al,%eax
mov    %eax,-0x28(%rbp)
jmp    1455 <main+0x345>
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rax
movsbl (%rax),%eax
cmp    $0x41,%eax
jl     1442 <main+0x332>
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rax
movsbl (%rax),%edx
xor    %ecx,%ecx
mov    $0x1,%eax
cmp    $0x6d,%edx
cmove  %eax,%ecx
mov    $0x3,%eax
sub    %ecx,%eax
mov    %eax,-0x2c(%rbp)
jmp    144f <main+0x33f>
mov    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    144f <main+0x33f>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%ecx
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rax
add    0xa(%rax),%ecx
mov    %ecx,0xa(%rax)
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rax
mov    0xa(%rax),%eax
mov    -0x10(%rbp),%rcx
mov    0x8(%rcx),%rcx
cmp    0x6(%rcx),%eax
jle    149b <main+0x38b>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rax
mov    0xa(%rax),%eax
mov    %eax,-0x30(%rbp)
jmp    14a9 <main+0x399>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rax
mov    0x6(%rax),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%ecx
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rax
mov    %ecx,0x6(%rax)
mov    -0x8(%rbp),%eax
add    $0x3,%eax
mov    %eax,-0x8(%rbp)
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rcx
add    $0x3,%rcx
mov    %rcx,0x10(%rax)
jmp    12c7 <main+0x1b7>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rax
mov    0x6(%rax),%esi
shl    $0x3,%esi
add    $0x38,%esi
mov    -0x10(%rbp),%rcx
mov    0x18(%rcx),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,0x18(%rcx)
movsbl (%rax),%eax
imul   $0x50,%eax,%edx
lea    0x1afd(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rax
movb   $0x0,(%rax)
mov    -0x8(%rbp),%edx
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rcx
movslq %edx,%rsi
xor    %edx,%edx
sub    %rsi,%rdx
add    %rdx,%rcx
mov    %rcx,0x10(%rax)
mov    -0x10(%rbp),%rax
mov    0x18(%rax),%rax
movb   $0x0,(%rax)
mov    -0x10(%rbp),%rax
mov    0x18(%rax),%rcx
mov    -0x1(%rcx),%al
mov    %al,%dl
add    $0xff,%dl
mov    %dl,-0x1(%rcx)
cmp    $0x0,%al
je     2448 <main+0x1338>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
movb   $0x0,(%rax)
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
movsbl (%rax),%eax
cmp    $0x50,%eax
jge    2438 <main+0x1328>
mov    -0x10(%rbp),%rax
mov    0x18(%rax),%rax
movsbl (%rax),%eax
imul   $0x3,%eax,%edx
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rcx
movslq %edx,%rsi
xor    %edx,%edx
sub    %rsi,%rdx
add    %rdx,%rcx
mov    %rcx,0x10(%rax)
mov    -0x10(%rbp),%rcx
mov    0x18(%rcx),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,0x18(%rcx)
movb   $0x0,(%rax)
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
movsbl (%rax),%ecx
mov    $0x1,%al
cmp    $0x33,%ecx
mov    %al,-0x31(%rbp)
jge    15fb <main+0x4eb>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
movsbl (%rax),%ecx
mov    $0x1,%al
cmp    $0x12,%ecx
mov    %al,-0x31(%rbp)
jl     15fb <main+0x4eb>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
movsbl (%rax),%eax
mov    $0x8,%ecx
cltd
idiv   %ecx
cmp    $0x2,%edx
setne  %al
mov    %al,-0x31(%rbp)
mov    -0x31(%rbp),%dl
mov    $0xff,%eax
xor    %ecx,%ecx
test   $0x1,%dl
cmovne %ecx,%eax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    0x18(%rax),%rax
mov    %cl,(%rax)
lea    0x19e2(%rip),%rdi
xor    %esi,%esi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x10(%rbp),%rax
mov    0x18(%rax),%rax
movsbl (%rax),%esi
lea    0x19c7(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
movb   $0x0,0x1(%rax)
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
movsbl 0x1(%rax),%eax
cmp    $0x3,%eax
jge    1788 <main+0x678>
mov    -0x10(%rbp),%rax
mov    0x18(%rax),%rax
movsbl (%rax),%eax
mov    %eax,-0x38(%rbp)
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
movsbl 0x4(%rax),%eax
cmp    $0x0,%eax
je     16f0 <main+0x5e0>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
movsbl (%rax),%eax
cmp    $0x12,%eax
jle    16db <main+0x5cb>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
movsbl (%rax),%eax
cmp    $0x2a,%eax
jge    16db <main+0x5cb>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rax
mov    -0x10(%rbp),%rcx
mov    (%rcx),%rcx
movsbl 0x1(%rcx),%ecx
add    $0x2a,%ecx
mov    -0x10(%rbp),%rdx
mov    (%rdx),%rdx
movsbl (%rdx),%edx
imul   $0x3,%edx,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
mov    %eax,-0x3c(%rbp)
jmp    16e5 <main+0x5d5>
xor    %eax,%eax
mov    %eax,-0x3c(%rbp)
jmp    16e5 <main+0x5d5>
mov    -0x3c(%rbp),%eax
mov    %eax,-0x40(%rbp)
jmp    175d <main+0x64d>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
movsbl (%rax),%eax
cmp    $0xb,%eax
jl     174d <main+0x63d>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
movsbl (%rax),%eax
cmp    $0x40,%eax
jge    174d <main+0x63d>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rax
mov    -0x10(%rbp),%rcx
mov    (%rcx),%rcx
movsbl (%rcx),%ecx
imul   $0x7,%ecx,%ecx
add    $0x61,%ecx
mov    -0x10(%rbp),%rdx
mov    (%rdx),%rdx
movsbl 0x1(%rdx),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
xor    $0xffffffff,%eax
mov    %eax,-0x44(%rbp)
jmp    1757 <main+0x647>
xor    %eax,%eax
mov    %eax,-0x44(%rbp)
jmp    1757 <main+0x647>
mov    -0x44(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x38(%rbp),%esi
mov    -0x40(%rbp),%eax
or     %eax,%esi
lea    0x1894(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    0x1(%rax),%cl
add    $0x1,%cl
mov    %cl,0x1(%rax)
jmp    164b <main+0x53b>
mov    -0x10(%rbp),%rcx
mov    0x18(%rcx),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,0x18(%rcx)
movsbl (%rax),%esi
lea    0x185b(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rax
movl   $0x0,0xa(%rax)
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rax
mov    0xa(%rax),%eax
mov    -0x10(%rbp),%rcx
mov    0x8(%rcx),%rcx
mov    %eax,0xe(%rcx)
mov    -0x10(%rbp),%rcx
mov    0x8(%rcx),%rcx
cmp    0x6(%rcx),%eax
jge    2405 <main+0x12f5>
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rax
movsbl 0x1(%rax),%eax
sub    $0x31,%eax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    %cl,0x2(%rax)
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rax
movsbl (%rax),%eax
cmp    $0x3f,%eax
setle  %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x8(%rbp)
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
movsbl (%rax),%eax
mov    -0x10(%rbp),%rcx
mov    0x10(%rcx),%rcx
movslq -0x8(%rbp),%rdx
movsbl (%rcx,%rdx,1),%edx
mov    $0x69,%ecx
sub    %edx,%ecx
mov    -0x10(%rbp),%rdx
mov    0x10(%rdx),%rdx
movslq -0x8(%rbp),%rsi
movsbl (%rdx,%rsi,1),%edx
cmp    $0x63,%edx
setl   %dl
and    $0x1,%dl
movzbl %dl,%edx
imul   $0x7,%edx,%edx
sub    %edx,%ecx
mov    -0x10(%rbp),%rdx
mov    0x10(%rdx),%rdx
movslq -0x8(%rbp),%rsi
movsbl (%rdx,%rsi,1),%edx
cmp    $0x4d,%edx
setl   %dl
and    $0x1,%dl
movzbl %dl,%edx
imul   $0x12,%edx,%edx
sub    %edx,%ecx
mov    -0x10(%rbp),%rdx
mov    (%rdx),%rdx
movsbl 0x4(%rdx),%edx
shl    $0x1,%edx
add    %edx,%ecx
mov    -0x10(%rbp),%rdx
mov    0x10(%rdx),%rdx
movslq -0x8(%rbp),%rsi
movsbl (%rdx,%rsi,1),%edx
cmp    $0x43,%edx
setl   %dl
and    $0x1,%dl
movzbl %dl,%edx
imul   $0x7,%edx,%edx
sub    %edx,%ecx
mov    -0x10(%rbp),%rdx
mov    0x18(%rdx),%rdx
mov    %cl,(%rdx)
movsbl %cl,%ecx
shl    $0x2,%ecx
sub    %ecx,%eax
sub    $0x6,%eax
mov    %eax,-0x8(%rbp)
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rax
movl   $0x0,0x12(%rax)
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rax
mov    0x12(%rax),%eax
mov    %eax,-0x48(%rbp)
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rax
movsbl (%rax),%eax
cmp    $0x0,%eax
je     199d <main+0x88d>
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rax
movsbl (%rax),%eax
cmp    $0x72,%eax
jle    191b <main+0x80b>
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rax
movsbl 0x1(%rax),%eax
mov    %eax,-0x4c(%rbp)
jmp    1992 <main+0x882>
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rax
movsbl (%rax),%eax
cmp    $0x40,%eax
setg   %al
and    $0x1,%al
movzbl %al,%eax
shl    $0x1,%eax
add    $0x1,%eax
mov    -0x10(%rbp),%rcx
mov    0x10(%rcx),%rcx
cmpb   $0x0,0x3(%rcx)
setne  %cl
xor    $0xff,%cl
and    $0x1,%cl
movzbl %cl,%edx
mov    $0x2,%ecx
sub    %edx,%ecx
mov    -0x10(%rbp),%rdx
mov    0x10(%rdx),%rdx
movsbl (%rdx),%esi
mov    $0x3a,%edx
cmp    %esi,%edx
sete   %dl
and    $0x1,%dl
movzbl %dl,%edx
imul   %edx,%ecx
add    %ecx,%eax
mov    -0x10(%rbp),%rcx
mov    0x10(%rcx),%rcx
movsbl (%rcx),%ecx
cmp    $0x6d,%ecx
sete   %cl
and    $0x1,%cl
movzbl %cl,%ecx
sub    %ecx,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
mov    %eax,-0x50(%rbp)
jmp    19dd <main+0x8cd>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rax
cmpl   $0x0,0xe(%rax)
je     19cd <main+0x8bd>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rax
mov    0x6(%rax),%eax
mov    -0x10(%rbp),%rcx
mov    0x8(%rcx),%rcx
sub    0xe(%rcx),%eax
mov    %eax,-0x54(%rbp)
jmp    19d7 <main+0x8c7>
xor    %eax,%eax
mov    %eax,-0x54(%rbp)
jmp    19d7 <main+0x8c7>
mov    -0x54(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x48(%rbp),%eax
mov    -0x50(%rbp),%ecx
cmp    %ecx,%eax
jge    23df <main+0x12cf>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rax
movsbl 0x4(%rax),%eax
mov    %eax,-0x58(%rbp)
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rax
movsbl (%rax),%eax
cmp    $0x0,%eax
je     2393 <main+0x1283>
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rax
movsbl (%rax),%eax
cmp    $0x73,%eax
jge    2393 <main+0x1283>
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rax
movsbl (%rax),%eax
cmp    $0x3a,%eax
jne    1ae4 <main+0x9d4>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rax
cmpl   $0x1,0x12(%rax)
jne    1acf <main+0x9bf>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
movsbl (%rax),%eax
cmp    $0x11,%eax
jle    1aba <main+0x9aa>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
movsbl (%rax),%eax
cmp    $0x33,%eax
jge    1aba <main+0x9aa>
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rax
movsbl 0x1(%rax),%eax
cmp    $0x3b,%eax
jne    1a90 <main+0x980>
mov    $0x27,%eax
mov    %eax,-0x5c(%rbp)
jmp    1aaf <main+0x99f>
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rax
movsbl 0x1(%rax),%edx
mov    $0x1,%eax
mov    $0x9,%ecx
cmp    $0x3a,%edx
cmove  %ecx,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
mov    %eax,-0x60(%rbp)
jmp    1ac4 <main+0x9b4>
xor    %eax,%eax
mov    %eax,-0x60(%rbp)
jmp    1ac4 <main+0x9b4>
mov    -0x60(%rbp),%eax
mov    %eax,-0x64(%rbp)
jmp    1ad9 <main+0x9c9>
xor    %eax,%eax
mov    %eax,-0x64(%rbp)
jmp    1ad9 <main+0x9c9>
mov    -0x64(%rbp),%eax
mov    %eax,-0x68(%rbp)
jmp    2385 <main+0x1275>
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rax
movsbl (%rax),%ecx
mov    $0x3f,%eax
cmp    %ecx,%eax
jle    1b8c <main+0xa7c>
cmpl   $0x7,-0x8(%rbp)
jge    1b77 <main+0xa67>
cmpl   $0xfffffff7,-0x8(%rbp)
jle    1b77 <main+0xa67>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rax
mov    %rax,-0x70(%rbp)
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rax
movsbl (%rax),%eax
cmp    $0x2d,%eax
jge    1b3d <main+0xa2d>
mov    $0x239,%eax
mov    %eax,-0x74(%rbp)
jmp    1b5b <main+0xa4b>
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rax
movsbl (%rax),%edx
mov    $0x23b,%eax
mov    $0x23a,%ecx
cmp    $0x3d,%edx
cmovl  %ecx,%eax
mov    %eax,-0x74(%rbp)
mov    -0x70(%rbp),%rax
mov    -0x74(%rbp),%ecx
imul   $0x3,-0x8(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
mov    %eax,-0x78(%rbp)
jmp    1b81 <main+0xa71>
xor    %eax,%eax
mov    %eax,-0x78(%rbp)
jmp    1b81 <main+0xa71>
mov    -0x78(%rbp),%eax
mov    %eax,-0x7c(%rbp)
jmp    237f <main+0x126f>
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rax
movsbl (%rax),%eax
cmp    $0x6f,%eax
jle    1dcb <main+0xcbb>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
movsbl (%rax),%eax
cmp    $0x1a,%eax
jle    1bd7 <main+0xac7>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
movsbl (%rax),%eax
cmp    $0x1d,%eax
jge    1bd7 <main+0xac7>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
cmpb   $0x0,0x2(%rax)
je     1c15 <main+0xb05>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
movsbl 0x2(%rax),%eax
cmp    $0x1,%eax
jne    1c59 <main+0xb49>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
movsbl (%rax),%eax
cmp    $0x22,%eax
jge    1c59 <main+0xb49>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
movsbl (%rax),%ecx
mov    $0x1f,%eax
cmp    %ecx,%eax
jge    1c59 <main+0xb49>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rax
cmpl   $0x2,0x12(%rax)
jge    1c41 <main+0xb31>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rax
imul   $0xe1,0x12(%rax),%eax
add    $0xf,%eax
mov    %eax,-0x80(%rbp)
jmp    1c4b <main+0xb3b>
xor    %eax,%eax
mov    %eax,-0x80(%rbp)
jmp    1c4b <main+0xb3b>
mov    -0x80(%rbp),%eax
mov    %eax,-0x84(%rbp)
jmp    1dba <main+0xcaa>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
movsbl 0x2(%rax),%eax
cmp    $0x3,%eax
jne    1d0d <main+0xbfd>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rax
cmpl   $0x2,0x12(%rax)
jge    1cef <main+0xbdf>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
movsbl (%rax),%eax
cmp    $0x16,%eax
jle    1cef <main+0xbdf>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
movsbl (%rax),%eax
cmp    $0x2d,%eax
jge    1cef <main+0xbdf>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rax
cmpl   $0x2,0x12(%rax)
jge    1cef <main+0xbdf>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rax
mov    -0x10(%rbp),%rcx
mov    (%rcx),%rcx
movsbl (%rcx),%ecx
imul   $0x7,%ecx,%ecx
add    $0x97,%ecx
mov    -0x10(%rbp),%rdx
mov    0x8(%rdx),%rdx
add    0x12(%rdx),%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
mov    %eax,-0x88(%rbp)
jmp    1cfc <main+0xbec>
xor    %eax,%eax
mov    %eax,-0x88(%rbp)
jmp    1cfc <main+0xbec>
mov    -0x88(%rbp),%eax
mov    %eax,-0x8c(%rbp)
jmp    1dae <main+0xc9e>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
movsbl 0x2(%rax),%ecx
mov    $0x7,%eax
cmp    %ecx,%eax
jne    1d95 <main+0xc85>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
movsbl (%rax),%eax
cmp    $0x1a,%eax
jle    1d95 <main+0xc85>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
movsbl (%rax),%eax
cmp    $0x2a,%eax
jge    1d95 <main+0xc85>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rax
cmpl   $0x2,0x12(%rax)
jge    1d95 <main+0xc85>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rax
mov    -0x10(%rbp),%rcx
mov    (%rcx),%rcx
movsbl (%rcx),%ecx
imul   $0x7,%ecx,%ecx
add    $0x87,%ecx
mov    -0x10(%rbp),%rdx
mov    0x8(%rdx),%rdx
add    0x12(%rdx),%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
mov    %eax,-0x90(%rbp)
jmp    1da2 <main+0xc92>
xor    %eax,%eax
mov    %eax,-0x90(%rbp)
jmp    1da2 <main+0xc92>
mov    -0x90(%rbp),%eax
mov    %eax,-0x8c(%rbp)
mov    -0x8c(%rbp),%eax
mov    %eax,-0x84(%rbp)
mov    -0x84(%rbp),%eax
mov    %eax,-0x94(%rbp)
jmp    2376 <main+0x1266>
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rax
movsbl (%rax),%eax
cmp    $0x6b,%eax
jge    224c <main+0x113c>
cmpl   $0xfffffffb,-0x8(%rbp)
jle    1ee7 <main+0xdd7>
cmpl   $0x5,-0x8(%rbp)
jge    1ee7 <main+0xdd7>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rax
cmpl   $0x2,0x12(%rax)
jge    1e4b <main+0xd3b>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rax
mov    -0x10(%rbp),%rcx
mov    (%rcx),%rcx
movsbl 0x2(%rcx),%esi
mov    $0xcd,%ecx
mov    $0xcf,%edx
cmp    $0x3,%esi
cmovl  %edx,%ecx
imul   $0x7,-0x8(%rbp),%edx
add    %edx,%ecx
mov    -0x10(%rbp),%rdx
mov    0x8(%rdx),%rdx
add    0x12(%rdx),%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
mov    %eax,-0x98(%rbp)
jmp    1ed6 <main+0xdc6>
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rax
movsbl 0x2(%rax),%ecx
xor    %eax,%eax
cmp    $0x2e,%ecx
mov    %al,-0x99(%rbp)
jne    1ebd <main+0xdad>
mov    $0x1,%al
cmpl   $0xfffffffe,-0x8(%rbp)
mov    %al,-0x9a(%rbp)
je     1eb1 <main+0xda1>
mov    -0x8(%rbp),%eax
mov    %eax,-0xa0(%rbp)
mov    -0x10(%rbp),%rax
mov    0x18(%rax),%rax
movsbl (%rax),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    -0xa0(%rbp),%eax
shl    $0x1,%edx
mov    $0xffffffff,%ecx
sub    %edx,%ecx
cmp    %ecx,%eax
sete   %al
mov    %al,-0x9a(%rbp)
mov    -0x9a(%rbp),%al
mov    %al,-0x99(%rbp)
mov    -0x99(%rbp),%dl
xor    %eax,%eax
mov    $0x60,%ecx
test   $0x1,%dl
cmovne %ecx,%eax
mov    %eax,-0x98(%rbp)
mov    -0x98(%rbp),%eax
mov    %eax,-0xa4(%rbp)
jmp    1ef4 <main+0xde4>
xor    %eax,%eax
mov    %eax,-0xa4(%rbp)
jmp    1ef4 <main+0xde4>
mov    -0xa4(%rbp),%eax
mov    %eax,-0xa8(%rbp)
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
movsbl 0x2(%rax),%eax
cmp    $0x0,%eax
je     1ffe <main+0xeee>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rax
cmpl   $0x0,0x12(%rax)
je     1f99 <main+0xe89>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rcx
xor    %eax,%eax
cmpl   $0x2,0x12(%rcx)
mov    %al,-0xa9(%rbp)
jge    1f7b <main+0xe6b>
mov    -0x10(%rbp),%rax
mov    0x18(%rax),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x7,%ecx
mov    %al,-0xa9(%rbp)
jle    1f7b <main+0xe6b>
xor    %eax,%eax
cmpl   $0x1,-0x8(%rbp)
mov    %al,-0xa9(%rbp)
jge    1f7b <main+0xe6b>
cmpl   $0xffffffe8,-0x8(%rbp)
setg   %al
mov    %al,-0xa9(%rbp)
mov    -0xa9(%rbp),%dl
xor    %eax,%eax
mov    $0x8,%ecx
test   $0x1,%dl
cmovne %ecx,%eax
mov    %eax,-0xb0(%rbp)
jmp    1fed <main+0xedd>
mov    -0x10(%rbp),%rax
mov    0x18(%rax),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x8,%ecx
mov    %al,-0xb1(%rbp)
jge    1fd4 <main+0xec4>
xor    %eax,%eax
cmpl   $0x1,-0x8(%rbp)
mov    %al,-0xb1(%rbp)
jle    1fd4 <main+0xec4>
cmpl   $0x18,-0x8(%rbp)
setl   %al
mov    %al,-0xb1(%rbp)
mov    -0xb1(%rbp),%dl
xor    %eax,%eax
mov    $0x20,%ecx
test   $0x1,%dl
cmovne %ecx,%eax
mov    %eax,-0xb0(%rbp)
mov    -0xb0(%rbp),%eax
mov    %eax,-0xb8(%rbp)
jmp    200b <main+0xefb>
xor    %eax,%eax
mov    %eax,-0xb8(%rbp)
jmp    200b <main+0xefb>
mov    -0xa8(%rbp),%eax
mov    -0xb8(%rbp),%ecx
or     %ecx,%eax
mov    %eax,-0xc0(%rbp)
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rcx
xor    %eax,%eax
cmpl   $0x2,0x12(%rcx)
mov    %al,-0xb9(%rbp)
jge    20e5 <main+0xfd5>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
movsbl (%rax),%eax
cmp    $0x42,%eax
jne    2068 <main+0xf58>
mov    -0x10(%rbp),%rax
mov    0x18(%rax),%rax
movsbl (%rax),%ecx
mov    $0x1,%al
cmp    $0xe,%ecx
mov    %al,-0xc1(%rbp)
jg     20d9 <main+0xfc9>
mov    -0x10(%rbp),%rax
mov    0x18(%rax),%rax
movsbl (%rax),%eax
cmp    $0xc,%eax
jle    209b <main+0xf8b>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
movsbl (%rax),%edx
mov    $0x1,%al
mov    $0x3a,%ecx
cmp    %edx,%ecx
mov    %al,-0xc1(%rbp)
je     20d9 <main+0xfc9>
mov    -0x10(%rbp),%rax
mov    0x18(%rax),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x2,%ecx
mov    %al,-0xc2(%rbp)
jge    20cd <main+0xfbd>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
movsbl (%rax),%eax
cmp    $0xa,%eax
sete   %al
mov    %al,-0xc2(%rbp)
mov    -0xc2(%rbp),%al
mov    %al,-0xc1(%rbp)
mov    -0xc1(%rbp),%al
mov    %al,-0xb9(%rbp)
mov    -0xc0(%rbp),%eax
mov    -0xb9(%rbp),%sil
xor    %ecx,%ecx
mov    $0xff,%edx
test   $0x1,%sil
cmovne %edx,%ecx
or     %ecx,%eax
mov    %eax,-0xc8(%rbp)
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
movsbl 0x2(%rax),%ecx
mov    $0x7,%eax
cmp    %ecx,%eax
jne    2226 <main+0x1116>
mov    -0x10(%rbp),%rax
mov    0x18(%rax),%rax
movsbl (%rax),%eax
cmp    $0x8,%eax
jge    21a7 <main+0x1097>
cmpl   $0xd,-0x8(%rbp)
jle    2189 <main+0x1079>
cmpl   $0x17,-0x8(%rbp)
jge    2189 <main+0x1079>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rax
cmpl   $0x2,0x12(%rax)
jge    2189 <main+0x1079>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rax
imul   $0x7,-0x8(%rbp),%ecx
add    $0x90,%ecx
mov    -0x10(%rbp),%rdx
mov    0x8(%rdx),%rdx
add    0x12(%rdx),%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
mov    %eax,-0xcc(%rbp)
jmp    2196 <main+0x1086>
xor    %eax,%eax
mov    %eax,-0xcc(%rbp)
jmp    2196 <main+0x1086>
mov    -0xcc(%rbp),%eax
mov    %eax,-0xd0(%rbp)
jmp    2215 <main+0x1105>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rax
cmpl   $0x0,0x12(%rax)
je     21fc <main+0x10ec>
cmpl   $0xfffffff2,-0x8(%rbp)
jge    21fc <main+0x10ec>
cmpl   $0xffffffe8,-0x8(%rbp)
jle    21fc <main+0x10ec>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rax
imul   $0x7,-0x8(%rbp),%ecx
add    $0x190,%ecx
mov    -0x10(%rbp),%rdx
mov    0x8(%rdx),%rdx
add    0x12(%rdx),%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
mov    %eax,-0xd4(%rbp)
jmp    2209 <main+0x10f9>
xor    %eax,%eax
mov    %eax,-0xd4(%rbp)
jmp    2209 <main+0x10f9>
mov    -0xd4(%rbp),%eax
mov    %eax,-0xd0(%rbp)
mov    -0xd0(%rbp),%eax
mov    %eax,-0xd8(%rbp)
jmp    2233 <main+0x1123>
xor    %eax,%eax
mov    %eax,-0xd8(%rbp)
jmp    2233 <main+0x1123>
mov    -0xc8(%rbp),%eax
mov    -0xd8(%rbp),%ecx
or     %ecx,%eax
mov    %eax,-0xdc(%rbp)
jmp    236a <main+0x125a>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rax
cmpl   $0x0,0x12(%rax)
jne    2351 <main+0x1241>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
movsbl (%rax),%eax
cmp    $0x15,%eax
jle    22be <main+0x11ae>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
movsbl (%rax),%eax
cmp    $0x20,%eax
jge    22be <main+0x11ae>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rax
mov    -0x10(%rbp),%rcx
mov    (%rcx),%rcx
movsbl 0x2(%rcx),%ecx
add    $0x143,%ecx
mov    -0x10(%rbp),%rdx
mov    (%rdx),%rdx
movsbl (%rdx),%edx
imul   $0x7,%edx,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
mov    %eax,-0xe0(%rbp)
jmp    2340 <main+0x1230>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
movsbl (%rax),%ecx
mov    $0x25,%eax
cmp    %ecx,%eax
jge    2327 <main+0x1217>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
movsbl (%rax),%ecx
mov    $0x30,%eax
cmp    %ecx,%eax
jle    2327 <main+0x1217>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rax
mov    -0x10(%rbp),%rcx
mov    0x10(%rcx),%rcx
movsbl 0x2(%rcx),%ecx
add    $0xa2,%ecx
mov    -0x10(%rbp),%rdx
mov    (%rdx),%rdx
movsbl (%rdx),%edx
imul   $0x7,%edx,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
mov    %eax,-0xe4(%rbp)
jmp    2334 <main+0x1224>
xor    %eax,%eax
mov    %eax,-0xe4(%rbp)
jmp    2334 <main+0x1224>
mov    -0xe4(%rbp),%eax
mov    %eax,-0xe0(%rbp)
mov    -0xe0(%rbp),%eax
mov    %eax,-0xe8(%rbp)
jmp    235e <main+0x124e>
xor    %eax,%eax
mov    %eax,-0xe8(%rbp)
jmp    235e <main+0x124e>
mov    -0xe8(%rbp),%eax
mov    %eax,-0xdc(%rbp)
mov    -0xdc(%rbp),%eax
mov    %eax,-0x94(%rbp)
mov    -0x94(%rbp),%eax
mov    %eax,-0x7c(%rbp)
mov    -0x7c(%rbp),%eax
mov    %eax,-0x68(%rbp)
mov    -0x68(%rbp),%eax
mov    %eax,-0xec(%rbp)
jmp    23a0 <main+0x1290>
xor    %eax,%eax
mov    %eax,-0xec(%rbp)
jmp    23a0 <main+0x1290>
mov    -0x58(%rbp),%esi
mov    -0xec(%rbp),%eax
or     %eax,%esi
lea    0xc4e(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    %eax,%ecx
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rax
add    0xa(%rax),%ecx
mov    %ecx,0xa(%rax)
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rax
mov    0x12(%rax),%ecx
add    $0x1,%ecx
mov    %ecx,0x12(%rax)
jmp    18d1 <main+0x7c1>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rax
mov    0x3(%rax),%cl
add    $0x1,%cl
mov    %cl,0x3(%rax)
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rcx
add    $0x3,%rcx
mov    %rcx,0x10(%rax)
jmp    17bb <main+0x6ab>
lea    0xbf4(%rip),%rdi
xor    %esi,%esi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x10(%rbp),%rax
mov    0x18(%rax),%rcx
add    $0xfffffffffffffffe,%rcx
mov    %rcx,0x18(%rax)
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    (%rax),%cl
add    $0x1,%cl
mov    %cl,(%rax)
jmp    1562 <main+0x452>
mov    -0x10(%rbp),%rax
mov    0x18(%rax),%rax
movb   $0x0,(%rax)
jmp    153d <main+0x42d>
mov    -0x4(%rbp),%eax
add    $0xf0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    %rsi,%r13
mov    %edi,%r15d
lea    0xec5(%rip),%r14
xor    %ebx,%ebx
mov    %r14,%rdi
mov    $0x50,%esi
xor    %eax,%eax
call   1040 <printf@plt>
imul   $0x34,%eax,%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x8(%r13),%rcx
lea    0x2(%rcx),%rdx
movslq %r15d,%rsi
mov    %rdx,0x0(%r13,%rsi,8)
mov    %al,0x2(%rcx)
jmp    117d <main+0x5d>
xchg   %ax,%ax
add    $0x1,%rbx
cmp    $0x1eb,%rbx
je     11d4 <main+0xb4>
mov    0x8(%r13),%rax
movb   $0x0,0x63(%rbx,%rax,1)
mov    0x0(%r13),%rax
movb   $0x0,(%rax)
mov    0x0(%r13),%rax
mov    (%rax),%dl
cmp    $0x7,%dl
jg     1170 <main+0x50>
lea    0x63(,%rbx,8),%esi
nop
movsbl %dl,%eax
add    %esi,%eax
mov    0x8(%r13),%rdx
movzbl 0x63(%rdx,%rbx,1),%ecx
add    %cl,%cl
cltq
cmpb   $0x20,(%rdx,%rax,1)
sete   %al
or     %cl,%al
mov    %al,0x63(%rdx,%rbx,1)
mov    0x0(%r13),%rax
addb   $0x1,(%rax)
mov    0x0(%r13),%rax
movzbl (%rax),%edx
cmp    $0x8,%dl
jl     11a0 <main+0x80>
jmp    1170 <main+0x50>
mov    0x10(%r13),%rcx
xor    %r14d,%r14d
cmpb   $0x4b,(%rcx)
mov    $0x0,%edx
jne    11f4 <main+0xd4>
lea    0x3(%rcx),%rdx
mov    %rdx,0x10(%r13)
cmpb   $0x46,0x1(%rcx)
sete   %dl
mov    %dl,0x4(%rax)
mov    0x8(%r13),%rax
movq   $0x0,0x6(%rax)
mov    0x10(%r13),%rdx
mov    (%rdx),%bl
test   %bl,%bl
je     12d6 <main+0x1b6>
xor    %esi,%esi
xor    %r14d,%r14d
jmp    125c <main+0x13c>
nopl   0x0(%rax,%rax,1)
movl   $0x0,0xa(%rax)
addb   $0x1,0x2(%rax)
mov    0x10(%r13),%rax
movb   $0x0,(%rax)
mov    0x8(%r13),%rax
mov    0xa(%rax),%esi
mov    0x6(%rax),%ecx
cmp    %ecx,%esi
cmovg  %esi,%ecx
mov    %ecx,0x6(%rax)
add    $0x3,%r14d
mov    0x10(%r13),%rcx
lea    0x3(%rcx),%rdx
mov    %rdx,0x10(%r13)
movzbl 0x3(%rcx),%ebx
test   %bl,%bl
je     12ca <main+0x1aa>
movzbl 0x1(%rdx),%ecx
test   %cl,%cl
je     12ca <main+0x1aa>
cmpb   $0x0,0x2(%rdx)
je     12ca <main+0x1aa>
cmp    $0x78,%bl
jge    1220 <main+0x100>
cmp    $0x73,%bl
je     1292 <main+0x172>
cmp    $0x3a,%bl
jne    12a4 <main+0x184>
movzbl 0x3(%rdx),%ecx
test   %cl,%cl
setne  %dl
cmp    $0x78,%cl
setl   %cl
and    %dl,%cl
movzbl %cl,%edx
or     $0x2,%edx
jmp    12c0 <main+0x1a0>
add    $0xd0,%cl
mov    %cl,0x1(%rdx)
movsbl %cl,%edx
mov    0x8(%r13),%rax
mov    0xa(%rax),%esi
jmp    12c0 <main+0x1a0>
mov    $0x1,%edx
cmp    $0x41,%bl
jl     12c0 <main+0x1a0>
xor    %edx,%edx
cmp    $0x6d,%bl
sete   %dl
xor    $0x3,%edx
nopl   0x0(%rax)
add    %edx,%esi
mov    %esi,0xa(%rax)
jmp    1239 <main+0x119>
mov    0x6(%rax),%eax
lea    0x38(,%rax,8),%esi
jmp    12db <main+0x1bb>
mov    $0x38,%esi
mov    0x18(%r13),%rax
lea    0x1(%rax),%rcx
mov    %rcx,0x18(%r13)
movsbl (%rax),%eax
shl    $0x4,%eax
lea    (%rax,%rax,4),%edx
lea    0xd0c(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x10(%r13),%rax
movb   $0x0,(%rax)
mov    %r14d,%eax
sub    %rax,0x10(%r13)
mov    0x18(%r13),%rax
movb   $0x0,(%rax)
mov    0x18(%r13),%rax
subb   $0x1,-0x1(%rax)
jae    132e <main+0x20e>
xor    %eax,%eax
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    0xccb(%rip),%r14
jmp    1351 <main+0x231>
nopw   0x0(%rax,%rax,1)
mov    0x18(%r13),%rax
movb   $0x0,(%rax)
mov    0x18(%r13),%rax
subb   $0x1,-0x1(%rax)
jb     131d <main+0x1fd>
mov    0x0(%r13),%rax
movb   $0x0,(%rax)
mov    0x0(%r13),%rax
cmpb   $0x4f,(%rax)
jle    138c <main+0x26c>
jmp    1340 <main+0x220>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
xor    %edi,%edi
call   1030 <putchar@plt>
addq   $0xfffffffffffffffe,0x18(%r13)
mov    0x0(%r13),%rax
addb   $0x1,(%rax)
mov    0x0(%r13),%rax
cmpb   $0x50,(%rax)
jge    1340 <main+0x220>
mov    0x18(%r13),%rax
movsbq (%rax),%rcx
lea    (%rcx,%rcx,2),%rcx
sub    %rcx,0x10(%r13)
lea    0x1(%rax),%rcx
mov    %rcx,0x18(%r13)
movb   $0x0,(%rax)
mov    0x0(%r13),%rax
mov    0x18(%r13),%rcx
mov    (%rax),%al
lea    -0x12(%rax),%edx
cmp    $0x21,%dl
setb   %dl
and    $0x7,%al
cmp    $0x2,%al
sete   %al
and    %dl,%al
neg    %al
mov    %al,(%rcx)
xor    %edi,%edi
call   1030 <putchar@plt>
mov    0x18(%r13),%rax
movsbl (%rax),%edi
call   1030 <putchar@plt>
mov    0x0(%r13),%rax
movb   $0x0,0x1(%rax)
mov    0x0(%r13),%rcx
mov    0x1(%rcx),%al
cmp    $0x2,%al
jle    1976 <main+0x856>
mov    0x18(%r13),%rax
lea    0x1(%rax),%rcx
mov    %rcx,0x18(%r13)
movsbl (%rax),%edi
call   1030 <putchar@plt>
mov    0x8(%r13),%rax
movq   $0x0,0xa(%rax)
cmpl   $0x0,0x6(%rax)
jle    1370 <main+0x250>
mov    0x10(%r13),%rax
jmp    1453 <main+0x333>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
addb   $0x1,0x3(%rcx)
mov    0x8(%r13),%rcx
mov    0x10(%r13),%rax
add    $0x3,%rax
mov    %rax,0x10(%r13)
mov    0xa(%rcx),%edx
mov    %edx,0xe(%rcx)
cmp    0x6(%rcx),%edx
jge    1370 <main+0x250>
mov    0x1(%rax),%al
add    $0xcf,%al
mov    0x0(%r13),%rcx
mov    %al,0x2(%rcx)
mov    0x0(%r13),%rcx
mov    0x10(%r13),%rdx
xor    %esi,%esi
cmpb   $0x40,(%rdx)
setl   %sil
movsbl (%rcx),%eax
mov    (%rdx,%rsi,1),%bl
xor    %edx,%edx
cmp    $0x63,%bl
mov    $0x0,%esi
mov    $0xf9,%r8d
cmovl  %r8d,%esi
sub    %bl,%sil
cmp    $0x4d,%bl
mov    $0x0,%edi
mov    $0xee,%ebp
cmovl  %ebp,%edi
add    %sil,%dil
mov    0x4(%rcx),%cl
add    %cl,%cl
add    %dil,%cl
cmp    $0x43,%bl
mov    $0x0,%esi
cmovl  %r8d,%esi
add    %cl,%sil
add    $0x69,%sil
mov    0x18(%r13),%rcx
mov    %sil,(%rcx)
movsbl %sil,%esi
shl    $0x2,%esi
mov    %eax,%r12d
sub    %esi,%r12d
lea    -0x6(%r12),%edi
mov    0x8(%r13),%rcx
movl   $0x0,0x12(%rcx)
lea    -0x2(%r12),%ebp
mov    %ebp,0x14(%rsp)
lea    -0x5(%r12),%ebp
mov    %ebp,0x4(%rsp)
lea    -0x30(,%r12,8),%r15d
ff
sub    %edi,%r15d
lea    0x190(%r15),%ebp
mov    %ebp,0x8(%rsp)
lea    -0x1d(%r12),%ebp
mov    %ebp,0x10(%rsp)
lea    0x90(%r15),%ebp
mov    %ebp,0xc(%rsp)
neg    %esi
add    %esi,%eax
add    $0x2,%eax
mov    %eax,0x1c(%rsp)
mov    %rdi,0x20(%rsp)
lea    (%rdi,%rdi,2),%eax
mov    %eax,0x18(%rsp)
jmp    155c <main+0x43c>
add    %edx,%ebx
movslq %ebx,%rdx
movsbl (%rcx,%rdx,1),%edi
or     %edi,%esi
nop
or     %eax,%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x8(%r13),%rcx
add    %eax,0xa(%rcx)
mov    0x12(%rcx),%edx
add    $0x1,%edx
mov    %edx,0x12(%rcx)
mov    0x10(%r13),%rdi
movzbl (%rdi),%ebx
test   %bl,%bl
je     1580 <main+0x460>
cmp    $0x73,%bl
jl     15a0 <main+0x480>
movsbl 0x1(%rdi),%eax
cmp    %eax,%edx
jl     15f0 <main+0x4d0>
jmp    1430 <main+0x310>
nopl   0x0(%rax)
mov    0xe(%rcx),%esi
test   %esi,%esi
je     15da <main+0x4ba>
mov    0x6(%rcx),%eax
sub    %esi,%eax
cmp    %eax,%edx
jl     15f0 <main+0x4d0>
jmp    1430 <main+0x310>
cs nopw 0x0(%rax,%rax,1)
nop
xor    %eax,%eax
cmp    $0x41,%bl
setge  %al
add    %eax,%eax
cmpb   $0x1,0x3(%rdi)
mov    $0x2,%esi
sbb    $0x0,%esi
cmp    $0x3a,%bl
mov    $0x0,%ebp
cmovne %ebp,%esi
xor    %ebp,%ebp
cmp    $0x6d,%bl
sete   %bpl
sub    %ebp,%eax
add    %esi,%eax
add    $0x1,%eax
cmp    %eax,%edx
jl     15f0 <main+0x4d0>
jmp    1430 <main+0x310>
xor    %eax,%eax
cmp    %eax,%edx
jge    1430 <main+0x310>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsbl 0x4(%rcx),%eax
xor    %esi,%esi
test   %bl,%bl
je     1540 <main+0x420>
cmp    $0x72,%bl
jg     1540 <main+0x420>
cmp    $0x3a,%bl
jne    1650 <main+0x530>
cmp    $0x1,%edx
jne    1540 <main+0x420>
mov    0x0(%r13),%rcx
movzbl (%rcx),%ecx
add    $0xee,%cl
cmp    $0x20,%cl
ja     1540 <main+0x420>
movzbl 0x1(%rdi),%ecx
mov    $0x27,%esi
cmp    $0x3b,%cl
je     1540 <main+0x420>
xor    %edx,%edx
cmp    $0x3a,%cl
sete   %dl
lea    0x1(,%rdx,8),%esi
jmp    1540 <main+0x420>
xchg   %ax,%ax
cmp    $0x3e,%bl
jg     1686 <main+0x566>
cmpl   $0xe,0x1c(%rsp)
ja     1540 <main+0x420>
xor    %edx,%edx
cmp    $0x3d,%bl
setl   %dl
xor    $0x23b,%edx
cmp    $0x2d,%bl
mov    $0x239,%esi
cmovl  %esi,%edx
add    0x18(%rsp),%edx
movsbl (%rcx,%rdx,1),%esi
jmp    1540 <main+0x420>
cmp    $0x70,%bl
jb     16bd <main+0x59d>
mov    0x0(%r13),%rbp
movzbl 0x0(%rbp),%r8d
lea    -0x1b(%r8),%edi
movzbl 0x2(%rbp),%ebx
cmp    $0x1,%dil
ja     16ff <main+0x5df>
test   %bl,%bl
jne    16ff <main+0x5df>
cmp    $0x1,%edx
jg     1540 <main+0x420>
imul   $0xe1,%edx,%esi
add    $0xf,%esi
jmp    1540 <main+0x420>
cmp    $0x6a,%bl
ja     1732 <main+0x612>
xor    %esi,%esi
cmpl   $0x8,0x14(%rsp)
ja     17a1 <main+0x681>
cmp    $0x1,%edx
jg     176a <main+0x64a>
mov    0x0(%r13),%rsi
xor    %edi,%edi
cmpb   $0x3,0x2(%rsi)
setl   %dil
lea    (%rdx,%r15,1),%esi
lea    (%rsi,%rdi,2),%esi
add    $0xcd,%esi
movslq %esi,%rsi
movsbl (%rcx,%rsi,1),%esi
jmp    17a1 <main+0x681>
cmp    $0x7,%bl
je     17fb <main+0x6db>
cmp    $0x3,%bl
je     1829 <main+0x709>
cmp    $0x1,%bl
jne    1540 <main+0x420>
and    $0xfe,%r8b
cmp    $0x20,%r8b
jne    1540 <main+0x420>
cmp    $0x2,%edx
jl     16af <main+0x58f>
jmp    1540 <main+0x420>
test   %edx,%edx
jne    1540 <main+0x420>
mov    0x0(%r13),%rbx
movsbq (%rbx),%rdx
lea    -0x16(%rdx),%ebp
cmp    $0x9,%bpl
ja     18b3 <main+0x793>
movsbl 0x2(%rbx),%esi
lea    0x0(,%rdx,8),%edi
sub    %edx,%edi
lea    (%rdi,%rsi,1),%edx
add    $0x143,%edx
jmp    167d <main+0x55d>
cmpb   $0x2e,0x2(%rdi)
jne    17a1 <main+0x681>
cmpl   $0xfffffffe,0x20(%rsp)
je     179c <main+0x67c>
mov    0x18(%r13),%rdi
movzbl (%rdi),%edi
mov    %edi,%ebx
shr    $0x7,%bl
add    %dil,%bl
and    $0x7e,%bl
sub    %bl,%dil
add    %dil,%dil
neg    %dil
movsbl %dil,%edi
cmp    %edi,0x4(%rsp)
jne    17a1 <main+0x681>
mov    $0x60,%esi
mov    0x0(%r13),%rbp
movzbl 0x2(%rbp),%r8d
test   %r8b,%r8b
je     17eb <main+0x6cb>
test   %edx,%edx
je     185b <main+0x73b>
cmp    $0x1,%edx
jg     18ac <main+0x78c>
cmp    $0xffffffef,%r12d
setge  %r9b
cmp    $0x7,%r12d
setl   %bl
mov    0x18(%r13),%rdi
cmpb   $0x8,(%rdi)
setge  %dil
and    %r9b,%bl
and    %dil,%bl
movzbl %bl,%edi
shl    $0x3,%edi
jmp    1881 <main+0x761>
xor    %edi,%edi
cmp    $0x1,%edx
jg     153d <main+0x41d>
jmp    1883 <main+0x763>
cmp    $0xe,%dil
ja     1540 <main+0x420>
cmp    $0x1,%edx
jg     1540 <main+0x420>
lea    0x0(,%r8,8),%esi
sub    %r8d,%esi
add    %esi,%edx
add    $0x87,%edx
movslq %edx,%rdx
jmp    167d <main+0x55d>
cmp    $0x1,%edx
jg     1540 <main+0x420>
lea    -0x17(%r8),%edi
cmp    $0x15,%dil
ja     1540 <main+0x420>
lea    0x0(,%r8,8),%esi
sub    %r8d,%esi
add    %esi,%edx
add    $0x97,%edx
movslq %edx,%rdx
jmp    167d <main+0x55d>
cmp    $0x1e,%r12d
setl   %r9b
cmp    $0x8,%r12d
setge  %bl
mov    0x18(%r13),%rdi
cmpb   $0x8,(%rdi)
setl   %dil
and    %r9b,%bl
and    %dil,%bl
movzbl %bl,%edi
shl    $0x5,%edi
or     %edi,%esi
movzbl 0x0(%rbp),%edi
mov    0x18(%r13),%rbp
movzbl 0x0(%rbp),%ebx
xor    %r9d,%r9d
cmp    $0x42,%dil
jne    189f <main+0x77f>
cmp    $0xe,%bl
jg     18e6 <main+0x7c6>
jmp    18f0 <main+0x7d0>
cmp    $0xd,%bl
jl     18db <main+0x7bb>
cmp    $0x3a,%dil
jne    18f0 <main+0x7d0>
jmp    18e6 <main+0x7c6>
xor    %edi,%edi
mov    $0x1,%r9b
jmp    18f2 <main+0x7d2>
lea    -0x26(%rdx),%ebp
cmp    $0x9,%bpl
ja     1540 <main+0x420>
movsbl 0x2(%rdi),%esi
lea    0x0(,%rdx,8),%edi
sub    %edx,%edi
lea    (%rdi,%rsi,1),%edx
add    $0xa2,%edx
jmp    167d <main+0x55d>
cmp    $0x1,%bl
jg     18f0 <main+0x7d0>
cmp    $0xa,%dil
jne    18f0 <main+0x7d0>
mov    $0xff,%edi
xor    %r9d,%r9d
jmp    18f2 <main+0x7d2>
xor    %edi,%edi
or     %edi,%esi
xor    %edi,%edi
cmp    $0x7,%r8b
jne    153d <main+0x41d>
mov    0x18(%r13),%rbp
cmpb   $0x7,0x0(%rbp)
jg     1924 <main+0x804>
cmpl   $0xfffffff7,0x10(%rsp)
setb   %bl
or     %r9b,%bl
mov    0xc(%rsp),%ebx
je     1534 <main+0x414>
jmp    153d <main+0x41d>
test   %edx,%edx
je     153d <main+0x41d>
cmp    $0xfffffff7,%r12d
jg     153d <main+0x41d>
mov    0x8(%rsp),%ebx
cmp    $0xffffffef,%r12d
jge    1534 <main+0x414>
jmp    153d <main+0x41d>
nopl   0x0(%rax)
mov    0x18(%r13),%rax
movsbl (%rax),%edi
or     %edx,%edi
call   1030 <putchar@plt>
mov    0x0(%r13),%rax
addb   $0x1,0x1(%rax)
mov    0x0(%r13),%rcx
movzbl 0x1(%rcx),%eax
cmp    $0x3,%al
jge    13f1 <main+0x2d1>
movsbl %al,%eax
cmpb   $0x0,0x4(%rcx)
movzbl (%rcx),%ecx
je     19b0 <main+0x890>
lea    -0x13(%rcx),%esi
xor    %edx,%edx
cmp    $0x16,%sil
ja     1950 <main+0x830>
mov    0x8(%r13),%rdx
cltq
lea    (%rcx,%rcx,2),%rcx
add    %rax,%rcx
movsbl 0x2a(%rdx,%rcx,1),%edx
jmp    1950 <main+0x830>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    -0xb(%rcx),%esi
xor    %edx,%edx
cmp    $0x34,%sil
ja     1950 <main+0x830>
mov    0x8(%r13),%rdx
lea    0x0(,%rcx,8),%esi
sub    %ecx,%esi
add    %esi,%eax
add    $0x61,%eax
movsbl (%rdx,%rax,1),%edx
not    %edx
jmp    1950 <main+0x830>

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

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