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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
scalar_t__ malloc(int);
unsigned char *bytemapmag(unsigned char *bytemap, int width, int height,
                          int magstep) {
  unsigned char *magnified = NULL;
  int irow, icol, mrow = 0, mcol = 0;
  int imap = (-1), byteval = 0;
  int isAdvMAME = 1;
  int icell[10], bmmdiff = 64;
  if (bytemap == NULL)
    goto end_of_job;
  if (width < 1 || height < 1)
    goto end_of_job;
  if (width * height > 100000)
    goto end_of_job;
  if (magstep < 1 || magstep > 10)
    goto end_of_job;
  if ((magnified = (unsigned char *)(malloc(magstep * width * magstep *
                                            height))) != NULL)
    for (irow = 0; irow < height; irow++)
      for (icol = 0; icol < width; icol++) {
        int imag1 = (icol + irow * (width * magstep)) * magstep;
        imap++;
        byteval = (int)(bytemap[imap]);
        for (mrow = 0; mrow < magstep; mrow++)
          for (mcol = 0; mcol < magstep; mcol++) {
            int idup = mcol + mrow * (width * magstep);
            int imag = imag1 + idup;
            magnified[imag] = (unsigned char)(byteval);
            if (isAdvMAME) {
              int mcell = 1 + mcol + magstep * mrow;
              icell[5] = byteval,
              icell[4] = (icol > 0 ? (int)(bytemap[imap - 1]) : byteval),
              icell[6] = (icol < width ? (int)(bytemap[imap + 1]) : byteval),
              icell[2] = (irow > 0 ? (int)(bytemap[imap - width]) : byteval),
              icell[8] =
                  (irow < height ? (int)(bytemap[imap + width]) : byteval),
              icell[1] =
                  (irow > 0 && icol > 0 ? (int)(bytemap[imap - width - 1])
                                        : byteval),
              icell[3] =
                  (irow > 0 && icol < width ? (int)(bytemap[imap - width + 1])
                                            : byteval),
              icell[7] =
                  (irow < height && icol > 0 ? (int)(bytemap[imap + width - 1])
                                             : byteval),
              icell[9] = (irow < height && icol < width
                              ? (int)(bytemap[imap + width + 1])
                              : byteval);
              switch (magstep) {
              default:
                break;
              case 2:
                if (mcell == 1)
                  if ((((((icell[4] - icell[2])) >= 0
                             ? ((icell[4] - icell[2]))
                             : (-((icell[4] - icell[2])))) <= bmmdiff)) &&
                      !(((((icell[4] - icell[8])) >= 0
                              ? ((icell[4] - icell[8]))
                              : (-((icell[4] - icell[8])))) <= bmmdiff)) &&
                      !(((((icell[2] - icell[6])) >= 0
                              ? ((icell[2] - icell[6]))
                              : (-((icell[2] - icell[6])))) <= bmmdiff)))
                    magnified[imag] = icell[2];
                if (mcell == 2)
                  if ((((((icell[2] - icell[6])) >= 0
                             ? ((icell[2] - icell[6]))
                             : (-((icell[2] - icell[6])))) <= bmmdiff)) &&
                      !(((((icell[2] - icell[4])) >= 0
                              ? ((icell[2] - icell[4]))
                              : (-((icell[2] - icell[4])))) <= bmmdiff)) &&
                      !(((((icell[6] - icell[8])) >= 0
                              ? ((icell[6] - icell[8]))
                              : (-((icell[6] - icell[8])))) <= bmmdiff)))
                    magnified[imag] = icell[6];
                if (mcell == 4)
                  if ((((((icell[6] - icell[8])) >= 0
                             ? ((icell[6] - icell[8]))
                             : (-((icell[6] - icell[8])))) <= bmmdiff)) &&
                      !(((((icell[6] - icell[2])) >= 0
                              ? ((icell[6] - icell[2]))
                              : (-((icell[6] - icell[2])))) <= bmmdiff)) &&
                      !(((((icell[8] - icell[4])) >= 0
                              ? ((icell[8] - icell[4]))
                              : (-((icell[8] - icell[4])))) <= bmmdiff)))
                    magnified[imag] = icell[8];
                if (mcell == 3)
                  if ((((((icell[8] - icell[4])) >= 0
                             ? ((icell[8] - icell[4]))
                             : (-((icell[8] - icell[4])))) <= bmmdiff)) &&
                      !(((((icell[8] - icell[6])) >= 0
                              ? ((icell[8] - icell[6]))
                              : (-((icell[8] - icell[6])))) <= bmmdiff)) &&
                      !(((((icell[4] - icell[2])) >= 0
                              ? ((icell[4] - icell[2]))
                              : (-((icell[4] - icell[2])))) <= bmmdiff)))
                    magnified[imag] = icell[4];
                break;
              case 3:
                if (mcell == 1)
                  if ((((((icell[4] - icell[2])) >= 0
                             ? ((icell[4] - icell[2]))
                             : (-((icell[4] - icell[2])))) <= bmmdiff)) &&
                      !(((((icell[4] - icell[8])) >= 0
                              ? ((icell[4] - icell[8]))
                              : (-((icell[4] - icell[8])))) <= bmmdiff)) &&
                      !(((((icell[2] - icell[6])) >= 0
                              ? ((icell[2] - icell[6]))
                              : (-((icell[2] - icell[6])))) <= bmmdiff)))
                    magnified[imag] = icell[4];
                if (mcell == 2)
                  if (((((((icell[4] - icell[2])) >= 0
                              ? ((icell[4] - icell[2]))
                              : (-((icell[4] - icell[2])))) <= bmmdiff)) &&
                       !(((((icell[4] - icell[8])) >= 0
                               ? ((icell[4] - icell[8]))
                               : (-((icell[4] - icell[8])))) <= bmmdiff)) &&
                       !(((((icell[2] - icell[6])) >= 0
                               ? ((icell[2] - icell[6]))
                               : (-((icell[2] - icell[6])))) <= bmmdiff)) &&
                       !(((((icell[5] - icell[3])) >= 0
                               ? ((icell[5] - icell[3]))
                               : (-((icell[5] - icell[3])))) <= bmmdiff))) ||
                      ((((((icell[2] - icell[6])) >= 0
                              ? ((icell[2] - icell[6]))
                              : (-((icell[2] - icell[6])))) <= bmmdiff)) &&
                       !(((((icell[2] - icell[4])) >= 0
                               ? ((icell[2] - icell[4]))
                               : (-((icell[2] - icell[4])))) <= bmmdiff)) &&
                       !(((((icell[6] - icell[8])) >= 0
                               ? ((icell[6] - icell[8]))
                               : (-((icell[6] - icell[8])))) <= bmmdiff)) &&
                       !(((((icell[5] - icell[1])) >= 0
                               ? ((icell[5] - icell[1]))
                               : (-((icell[5] - icell[1])))) <= bmmdiff))))
                    magnified[imag] = icell[2];
                if (mcell == 3)
                  if ((((((icell[2] - icell[6])) >= 0
                             ? ((icell[2] - icell[6]))
                             : (-((icell[2] - icell[6])))) <= bmmdiff)) &&
                      !(((((icell[2] - icell[4])) >= 0
                              ? ((icell[2] - icell[4]))
                              : (-((icell[2] - icell[4])))) <= bmmdiff)) &&
                      !(((((icell[6] - icell[8])) >= 0
                              ? ((icell[6] - icell[8]))
                              : (-((icell[6] - icell[8])))) <= bmmdiff)))
                    magnified[imag] = icell[6];
                if (mcell == 4)
                  if (((((((icell[8] - icell[4])) >= 0
                              ? ((icell[8] - icell[4]))
                              : (-((icell[8] - icell[4])))) <= bmmdiff)) &&
                       !(((((icell[8] - icell[6])) >= 0
                               ? ((icell[8] - icell[6]))
                               : (-((icell[8] - icell[6])))) <= bmmdiff)) &&
                       !(((((icell[4] - icell[2])) >= 0
                               ? ((icell[4] - icell[2]))
                               : (-((icell[4] - icell[2])))) <= bmmdiff)) &&
                       !(((((icell[5] - icell[1])) >= 0
                               ? ((icell[5] - icell[1]))
                               : (-((icell[5] - icell[1])))) <= bmmdiff))) ||
                      ((((((icell[4] - icell[2])) >= 0
                              ? ((icell[4] - icell[2]))
                              : (-((icell[4] - icell[2])))) <= bmmdiff)) &&
                       !(((((icell[4] - icell[8])) >= 0
                               ? ((icell[4] - icell[8]))
                               : (-((icell[4] - icell[8])))) <= bmmdiff)) &&
                       !(((((icell[2] - icell[6])) >= 0
                               ? ((icell[2] - icell[6]))
                               : (-((icell[2] - icell[6])))) <= bmmdiff)) &&
                       !(((((icell[5] - icell[7])) >= 0
                               ? ((icell[5] - icell[7]))
                               : (-((icell[5] - icell[7])))) <= bmmdiff))))
                    magnified[imag] = icell[4];
                if (mcell == 6)
                  if (((((((icell[2] - icell[6])) >= 0
                              ? ((icell[2] - icell[6]))
                              : (-((icell[2] - icell[6])))) <= bmmdiff)) &&
                       !(((((icell[2] - icell[4])) >= 0
                               ? ((icell[2] - icell[4]))
                               : (-((icell[2] - icell[4])))) <= bmmdiff)) &&
                       !(((((icell[6] - icell[8])) >= 0
                               ? ((icell[6] - icell[8]))
                               : (-((icell[6] - icell[8])))) <= bmmdiff)) &&
                       !(((((icell[5] - icell[9])) >= 0
                               ? ((icell[5] - icell[9]))
                               : (-((icell[5] - icell[9])))) <= bmmdiff))) ||
                      ((((((icell[6] - icell[8])) >= 0
                              ? ((icell[6] - icell[8]))
                              : (-((icell[6] - icell[8])))) <= bmmdiff)) &&
                       !(((((icell[6] - icell[2])) >= 0
                               ? ((icell[6] - icell[2]))
                               : (-((icell[6] - icell[2])))) <= bmmdiff)) &&
                       !(((((icell[8] - icell[4])) >= 0
                               ? ((icell[8] - icell[4]))
                               : (-((icell[8] - icell[4])))) <= bmmdiff)) &&
                       !(((((icell[5] - icell[3])) >= 0
                               ? ((icell[5] - icell[3]))
                               : (-((icell[5] - icell[3])))) <= bmmdiff))))
                    magnified[imag] = icell[6];
                if (mcell == 7)
                  if ((((((icell[8] - icell[4])) >= 0
                             ? ((icell[8] - icell[4]))
                             : (-((icell[8] - icell[4])))) <= bmmdiff)) &&
                      !(((((icell[8] - icell[6])) >= 0
                              ? ((icell[8] - icell[6]))
                              : (-((icell[8] - icell[6])))) <= bmmdiff)) &&
                      !(((((icell[4] - icell[2])) >= 0
                              ? ((icell[4] - icell[2]))
                              : (-((icell[4] - icell[2])))) <= bmmdiff)))
                    magnified[imag] = icell[4];
                if (mcell == 8)
                  if (((((((icell[6] - icell[8])) >= 0
                              ? ((icell[6] - icell[8]))
                              : (-((icell[6] - icell[8])))) <= bmmdiff)) &&
                       !(((((icell[6] - icell[2])) >= 0
                               ? ((icell[6] - icell[2]))
                               : (-((icell[6] - icell[2])))) <= bmmdiff)) &&
                       !(((((icell[8] - icell[4])) >= 0
                               ? ((icell[8] - icell[4]))
                               : (-((icell[8] - icell[4])))) <= bmmdiff)) &&
                       !(((((icell[5] - icell[7])) >= 0
                               ? ((icell[5] - icell[7]))
                               : (-((icell[5] - icell[7])))) <= bmmdiff))) ||
                      ((((((icell[8] - icell[4])) >= 0
                              ? ((icell[8] - icell[4]))
                              : (-((icell[8] - icell[4])))) <= bmmdiff)) &&
                       !(((((icell[8] - icell[6])) >= 0
                               ? ((icell[8] - icell[6]))
                               : (-((icell[8] - icell[6])))) <= bmmdiff)) &&
                       !(((((icell[4] - icell[2])) >= 0
                               ? ((icell[4] - icell[2]))
                               : (-((icell[4] - icell[2])))) <= bmmdiff)) &&
                       !(((((icell[5] - icell[9])) >= 0
                               ? ((icell[5] - icell[9]))
                               : (-((icell[5] - icell[9])))) <= bmmdiff))))
                    magnified[imag] = icell[8];
                if (mcell == 9)
                  if ((((((icell[6] - icell[8])) >= 0
                             ? ((icell[6] - icell[8]))
                             : (-((icell[6] - icell[8])))) <= bmmdiff)) &&
                      !(((((icell[6] - icell[2])) >= 0
                              ? ((icell[6] - icell[2]))
                              : (-((icell[6] - icell[2])))) <= bmmdiff)) &&
                      !(((((icell[8] - icell[4])) >= 0
                              ? ((icell[8] - icell[4]))
                              : (-((icell[8] - icell[4])))) <= bmmdiff)))
                    magnified[imag] = icell[6];
                break;
              }
            }
          }
      }
end_of_job:
  return (magnified);
}


x86 assembly (clang, -O0):
<bytemapmag>:
push   %rbp
mov    %rsp,%rbp
sub    $0x190,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %ecx,-0x14(%rbp)
movq   $0x0,-0x20(%rbp)
movl   $0x0,-0x2c(%rbp)
movl   $0x0,-0x30(%rbp)
movl   $0xffffffff,-0x34(%rbp)
movl   $0x0,-0x38(%rbp)
movl   $0x1,-0x3c(%rbp)
movl   $0x40,-0x74(%rbp)
cmpq   $0x0,-0x8(%rbp)
jne    116a <bytemapmag+0x5a>
jmp    249a <bytemapmag+0x138a>
cmpl   $0x1,-0xc(%rbp)
jl     117e <bytemapmag+0x6e>
cmpl   $0x1,-0x10(%rbp)
jge    1183 <bytemapmag+0x73>
jmp    249a <bytemapmag+0x138a>
mov    -0xc(%rbp),%eax
imul   -0x10(%rbp),%eax
cmp    $0x186a0,%eax
jle    119a <bytemapmag+0x8a>
jmp    249a <bytemapmag+0x138a>
cmpl   $0x1,-0x14(%rbp)
jl     11ae <bytemapmag+0x9e>
cmpl   $0xa,-0x14(%rbp)
jle    11b3 <bytemapmag+0xa3>
jmp    249a <bytemapmag+0x138a>
mov    -0x14(%rbp),%edi
imul   -0xc(%rbp),%edi
imul   -0x14(%rbp),%edi
imul   -0x10(%rbp),%edi
call   1030 <malloc@plt>
mov    %rax,-0x20(%rbp)
cmp    $0x0,%rax
je     2495 <bytemapmag+0x1385>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    2490 <bytemapmag+0x1380>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    247d <bytemapmag+0x136d>
mov    -0x28(%rbp),%eax
mov    -0x24(%rbp),%ecx
mov    -0xc(%rbp),%edx
imul   -0x14(%rbp),%edx
imul   %edx,%ecx
add    %ecx,%eax
imul   -0x14(%rbp),%eax
mov    %eax,-0x78(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x38(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    246a <bytemapmag+0x135a>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    2457 <bytemapmag+0x1347>
mov    -0x30(%rbp),%eax
mov    -0x2c(%rbp),%ecx
mov    -0xc(%rbp),%edx
imul   -0x14(%rbp),%edx
imul   %edx,%ecx
add    %ecx,%eax
mov    %eax,-0x7c(%rbp)
mov    -0x78(%rbp),%eax
add    -0x7c(%rbp),%eax
mov    %eax,-0x80(%rbp)
mov    -0x38(%rbp),%eax
mov    %al,%dl
mov    -0x20(%rbp),%rax
movslq -0x80(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
cmpl   $0x0,-0x3c(%rbp)
je     2444 <bytemapmag+0x1334>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    -0x14(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x84(%rbp)
mov    -0x38(%rbp),%eax
mov    %eax,-0x5c(%rbp)
cmpl   $0x0,-0x28(%rbp)
jle    12cb <bytemapmag+0x1bb>
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x88(%rbp)
jmp    12d4 <bytemapmag+0x1c4>
mov    -0x38(%rbp),%eax
mov    %eax,-0x88(%rbp)
mov    -0x88(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1305 <bytemapmag+0x1f5>
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x8c(%rbp)
jmp    130e <bytemapmag+0x1fe>
mov    -0x38(%rbp),%eax
mov    %eax,-0x8c(%rbp)
mov    -0x8c(%rbp),%eax
mov    %eax,-0x58(%rbp)
cmpl   $0x0,-0x24(%rbp)
jle    133d <bytemapmag+0x22d>
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    -0xc(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x90(%rbp)
jmp    1346 <bytemapmag+0x236>
mov    -0x38(%rbp),%eax
mov    %eax,-0x90(%rbp)
mov    -0x90(%rbp),%eax
mov    %eax,-0x68(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1377 <bytemapmag+0x267>
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0xc(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x94(%rbp)
jmp    1380 <bytemapmag+0x270>
mov    -0x38(%rbp),%eax
mov    %eax,-0x94(%rbp)
mov    -0x94(%rbp),%eax
mov    %eax,-0x50(%rbp)
cmpl   $0x0,-0x24(%rbp)
jle    13bc <bytemapmag+0x2ac>
cmpl   $0x0,-0x28(%rbp)
jle    13bc <bytemapmag+0x2ac>
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    -0xc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x98(%rbp)
jmp    13c5 <bytemapmag+0x2b5>
mov    -0x38(%rbp),%eax
mov    %eax,-0x98(%rbp)
mov    -0x98(%rbp),%eax
mov    %eax,-0x6c(%rbp)
cmpl   $0x0,-0x24(%rbp)
jle    1403 <bytemapmag+0x2f3>
mov    -0x28(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1403 <bytemapmag+0x2f3>
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    -0xc(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x9c(%rbp)
jmp    140c <bytemapmag+0x2fc>
mov    -0x38(%rbp),%eax
mov    %eax,-0x9c(%rbp)
mov    -0x9c(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    144a <bytemapmag+0x33a>
cmpl   $0x0,-0x28(%rbp)
jle    144a <bytemapmag+0x33a>
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0xc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0xa0(%rbp)
jmp    1453 <bytemapmag+0x343>
mov    -0x38(%rbp),%eax
mov    %eax,-0xa0(%rbp)
mov    -0xa0(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1493 <bytemapmag+0x383>
mov    -0x28(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1493 <bytemapmag+0x383>
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0xc(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0xa4(%rbp)
jmp    149c <bytemapmag+0x38c>
mov    -0x38(%rbp),%eax
mov    %eax,-0xa4(%rbp)
mov    -0xa4(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,-0xa8(%rbp)
sub    $0x2,%eax
je     14d5 <bytemapmag+0x3c5>
jmp    14bc <bytemapmag+0x3ac>
mov    -0xa8(%rbp),%eax
sub    $0x3,%eax
je     1856 <bytemapmag+0x746>
jmp    14d0 <bytemapmag+0x3c0>
jmp    243f <bytemapmag+0x132f>
cmpl   $0x1,-0x84(%rbp)
jne    15b4 <bytemapmag+0x4a4>
mov    -0x60(%rbp),%eax
sub    -0x68(%rbp),%eax
cmp    $0x0,%eax
jl     1502 <bytemapmag+0x3f2>
mov    -0x60(%rbp),%eax
sub    -0x68(%rbp),%eax
mov    %eax,-0xac(%rbp)
jmp    1512 <bytemapmag+0x402>
mov    -0x60(%rbp),%ecx
sub    -0x68(%rbp),%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0xac(%rbp)
mov    -0xac(%rbp),%eax
cmp    -0x74(%rbp),%eax
jg     15af <bytemapmag+0x49f>
mov    -0x60(%rbp),%eax
sub    -0x50(%rbp),%eax
cmp    $0x0,%eax
jl     1541 <bytemapmag+0x431>
mov    -0x60(%rbp),%eax
sub    -0x50(%rbp),%eax
mov    %eax,-0xb0(%rbp)
jmp    1551 <bytemapmag+0x441>
mov    -0x60(%rbp),%ecx
sub    -0x50(%rbp),%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0xb0(%rbp)
mov    -0xb0(%rbp),%eax
cmp    -0x74(%rbp),%eax
jle    15af <bytemapmag+0x49f>
mov    -0x68(%rbp),%eax
sub    -0x58(%rbp),%eax
cmp    $0x0,%eax
jl     1580 <bytemapmag+0x470>
mov    -0x68(%rbp),%eax
sub    -0x58(%rbp),%eax
mov    %eax,-0xb4(%rbp)
jmp    1590 <bytemapmag+0x480>
mov    -0x68(%rbp),%ecx
sub    -0x58(%rbp),%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0xb4(%rbp)
mov    -0xb4(%rbp),%eax
cmp    -0x74(%rbp),%eax
jle    15af <bytemapmag+0x49f>
mov    -0x68(%rbp),%eax
mov    %al,%dl
mov    -0x20(%rbp),%rax
movslq -0x80(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
jmp    15b4 <bytemapmag+0x4a4>
cmpl   $0x2,-0x84(%rbp)
jne    1693 <bytemapmag+0x583>
mov    -0x68(%rbp),%eax
sub    -0x58(%rbp),%eax
cmp    $0x0,%eax
jl     15e1 <bytemapmag+0x4d1>
mov    -0x68(%rbp),%eax
sub    -0x58(%rbp),%eax
mov    %eax,-0xb8(%rbp)
jmp    15f1 <bytemapmag+0x4e1>
mov    -0x68(%rbp),%ecx
sub    -0x58(%rbp),%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0xb8(%rbp)
mov    -0xb8(%rbp),%eax
cmp    -0x74(%rbp),%eax
jg     168e <bytemapmag+0x57e>
mov    -0x68(%rbp),%eax
sub    -0x60(%rbp),%eax
cmp    $0x0,%eax
jl     1620 <bytemapmag+0x510>
mov    -0x68(%rbp),%eax
sub    -0x60(%rbp),%eax
mov    %eax,-0xbc(%rbp)
jmp    1630 <bytemapmag+0x520>
mov    -0x68(%rbp),%ecx
sub    -0x60(%rbp),%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0xbc(%rbp)
mov    -0xbc(%rbp),%eax
cmp    -0x74(%rbp),%eax
jle    168e <bytemapmag+0x57e>
mov    -0x58(%rbp),%eax
sub    -0x50(%rbp),%eax
cmp    $0x0,%eax
jl     165f <bytemapmag+0x54f>
mov    -0x58(%rbp),%eax
sub    -0x50(%rbp),%eax
mov    %eax,-0xc0(%rbp)
jmp    166f <bytemapmag+0x55f>
mov    -0x58(%rbp),%ecx
sub    -0x50(%rbp),%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0xc0(%rbp)
mov    -0xc0(%rbp),%eax
cmp    -0x74(%rbp),%eax
jle    168e <bytemapmag+0x57e>
mov    -0x58(%rbp),%eax
mov    %al,%dl
mov    -0x20(%rbp),%rax
movslq -0x80(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
jmp    1693 <bytemapmag+0x583>
cmpl   $0x4,-0x84(%rbp)
jne    1772 <bytemapmag+0x662>
mov    -0x58(%rbp),%eax
sub    -0x50(%rbp),%eax
cmp    $0x0,%eax
jl     16c0 <bytemapmag+0x5b0>
mov    -0x58(%rbp),%eax
sub    -0x50(%rbp),%eax
mov    %eax,-0xc4(%rbp)
jmp    16d0 <bytemapmag+0x5c0>
mov    -0x58(%rbp),%ecx
sub    -0x50(%rbp),%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0xc4(%rbp)
mov    -0xc4(%rbp),%eax
cmp    -0x74(%rbp),%eax
jg     176d <bytemapmag+0x65d>
mov    -0x58(%rbp),%eax
sub    -0x68(%rbp),%eax
cmp    $0x0,%eax
jl     16ff <bytemapmag+0x5ef>
mov    -0x58(%rbp),%eax
sub    -0x68(%rbp),%eax
mov    %eax,-0xc8(%rbp)
jmp    170f <bytemapmag+0x5ff>
mov    -0x58(%rbp),%ecx
sub    -0x68(%rbp),%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0xc8(%rbp)
mov    -0xc8(%rbp),%eax
cmp    -0x74(%rbp),%eax
jle    176d <bytemapmag+0x65d>
mov    -0x50(%rbp),%eax
sub    -0x60(%rbp),%eax
cmp    $0x0,%eax
jl     173e <bytemapmag+0x62e>
mov    -0x50(%rbp),%eax
sub    -0x60(%rbp),%eax
mov    %eax,-0xcc(%rbp)
jmp    174e <bytemapmag+0x63e>
mov    -0x50(%rbp),%ecx
sub    -0x60(%rbp),%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0xcc(%rbp)
mov    -0xcc(%rbp),%eax
cmp    -0x74(%rbp),%eax
jle    176d <bytemapmag+0x65d>
mov    -0x50(%rbp),%eax
mov    %al,%dl
mov    -0x20(%rbp),%rax
movslq -0x80(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
jmp    1772 <bytemapmag+0x662>
cmpl   $0x3,-0x84(%rbp)
jne    1851 <bytemapmag+0x741>
mov    -0x50(%rbp),%eax
sub    -0x60(%rbp),%eax
cmp    $0x0,%eax
jl     179f <bytemapmag+0x68f>
mov    -0x50(%rbp),%eax
sub    -0x60(%rbp),%eax
mov    %eax,-0xd0(%rbp)
jmp    17af <bytemapmag+0x69f>
mov    -0x50(%rbp),%ecx
sub    -0x60(%rbp),%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0xd0(%rbp)
mov    -0xd0(%rbp),%eax
cmp    -0x74(%rbp),%eax
jg     184c <bytemapmag+0x73c>
mov    -0x50(%rbp),%eax
sub    -0x58(%rbp),%eax
cmp    $0x0,%eax
jl     17de <bytemapmag+0x6ce>
mov    -0x50(%rbp),%eax
sub    -0x58(%rbp),%eax
mov    %eax,-0xd4(%rbp)
jmp    17ee <bytemapmag+0x6de>
mov    -0x50(%rbp),%ecx
sub    -0x58(%rbp),%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0xd4(%rbp)
mov    -0xd4(%rbp),%eax
cmp    -0x74(%rbp),%eax
jle    184c <bytemapmag+0x73c>
mov    -0x60(%rbp),%eax
sub    -0x68(%rbp),%eax
cmp    $0x0,%eax
jl     181d <bytemapmag+0x70d>
mov    -0x60(%rbp),%eax
sub    -0x68(%rbp),%eax
mov    %eax,-0xd8(%rbp)
jmp    182d <bytemapmag+0x71d>
mov    -0x60(%rbp),%ecx
sub    -0x68(%rbp),%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0xd8(%rbp)
mov    -0xd8(%rbp),%eax
cmp    -0x74(%rbp),%eax
jle    184c <bytemapmag+0x73c>
mov    -0x60(%rbp),%eax
mov    %al,%dl
mov    -0x20(%rbp),%rax
movslq -0x80(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
jmp    1851 <bytemapmag+0x741>
jmp    243f <bytemapmag+0x132f>
cmpl   $0x1,-0x84(%rbp)
jne    1935 <bytemapmag+0x825>
mov    -0x60(%rbp),%eax
sub    -0x68(%rbp),%eax
cmp    $0x0,%eax
jl     1883 <bytemapmag+0x773>
mov    -0x60(%rbp),%eax
sub    -0x68(%rbp),%eax
mov    %eax,-0xdc(%rbp)
jmp    1893 <bytemapmag+0x783>
mov    -0x60(%rbp),%ecx
sub    -0x68(%rbp),%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0xdc(%rbp)
mov    -0xdc(%rbp),%eax
cmp    -0x74(%rbp),%eax
jg     1930 <bytemapmag+0x820>
mov    -0x60(%rbp),%eax
sub    -0x50(%rbp),%eax
cmp    $0x0,%eax
jl     18c2 <bytemapmag+0x7b2>
mov    -0x60(%rbp),%eax
sub    -0x50(%rbp),%eax
mov    %eax,-0xe0(%rbp)
jmp    18d2 <bytemapmag+0x7c2>
mov    -0x60(%rbp),%ecx
sub    -0x50(%rbp),%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0xe0(%rbp)
mov    -0xe0(%rbp),%eax
cmp    -0x74(%rbp),%eax
jle    1930 <bytemapmag+0x820>
mov    -0x68(%rbp),%eax
sub    -0x58(%rbp),%eax
cmp    $0x0,%eax
jl     1901 <bytemapmag+0x7f1>
mov    -0x68(%rbp),%eax
sub    -0x58(%rbp),%eax
mov    %eax,-0xe4(%rbp)
jmp    1911 <bytemapmag+0x801>
mov    -0x68(%rbp),%ecx
sub    -0x58(%rbp),%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0xe4(%rbp)
mov    -0xe4(%rbp),%eax
cmp    -0x74(%rbp),%eax
jle    1930 <bytemapmag+0x820>
mov    -0x60(%rbp),%eax
mov    %al,%dl
mov    -0x20(%rbp),%rax
movslq -0x80(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
jmp    1935 <bytemapmag+0x825>
cmpl   $0x2,-0x84(%rbp)
jne    1b4f <bytemapmag+0xa3f>
mov    -0x60(%rbp),%eax
sub    -0x68(%rbp),%eax
cmp    $0x0,%eax
jl     1962 <bytemapmag+0x852>
mov    -0x60(%rbp),%eax
sub    -0x68(%rbp),%eax
mov    %eax,-0xe8(%rbp)
jmp    1972 <bytemapmag+0x862>
mov    -0x60(%rbp),%ecx
sub    -0x68(%rbp),%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0xe8(%rbp)
mov    -0xe8(%rbp),%eax
cmp    -0x74(%rbp),%eax
jg     1a3e <bytemapmag+0x92e>
mov    -0x60(%rbp),%eax
sub    -0x50(%rbp),%eax
cmp    $0x0,%eax
jl     19a1 <bytemapmag+0x891>
mov    -0x60(%rbp),%eax
sub    -0x50(%rbp),%eax
mov    %eax,-0xec(%rbp)
jmp    19b1 <bytemapmag+0x8a1>
mov    -0x60(%rbp),%ecx
sub    -0x50(%rbp),%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0xec(%rbp)
mov    -0xec(%rbp),%eax
cmp    -0x74(%rbp),%eax
jle    1a3e <bytemapmag+0x92e>
mov    -0x68(%rbp),%eax
sub    -0x58(%rbp),%eax
cmp    $0x0,%eax
jl     19e0 <bytemapmag+0x8d0>
mov    -0x68(%rbp),%eax
sub    -0x58(%rbp),%eax
mov    %eax,-0xf0(%rbp)
jmp    19f0 <bytemapmag+0x8e0>
mov    -0x68(%rbp),%ecx
sub    -0x58(%rbp),%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0xf0(%rbp)
mov    -0xf0(%rbp),%eax
cmp    -0x74(%rbp),%eax
jle    1a3e <bytemapmag+0x92e>
mov    -0x5c(%rbp),%eax
sub    -0x64(%rbp),%eax
cmp    $0x0,%eax
jl     1a1f <bytemapmag+0x90f>
mov    -0x5c(%rbp),%eax
sub    -0x64(%rbp),%eax
mov    %eax,-0xf4(%rbp)
jmp    1a2f <bytemapmag+0x91f>
mov    -0x5c(%rbp),%ecx
sub    -0x64(%rbp),%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0xf4(%rbp)
mov    -0xf4(%rbp),%eax
cmp    -0x74(%rbp),%eax
jg     1b3a <bytemapmag+0xa2a>
mov    -0x68(%rbp),%eax
sub    -0x58(%rbp),%eax
cmp    $0x0,%eax
jl     1a5e <bytemapmag+0x94e>
mov    -0x68(%rbp),%eax
sub    -0x58(%rbp),%eax
mov    %eax,-0xf8(%rbp)
jmp    1a6e <bytemapmag+0x95e>
mov    -0x68(%rbp),%ecx
sub    -0x58(%rbp),%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0xf8(%rbp)
mov    -0xf8(%rbp),%eax
cmp    -0x74(%rbp),%eax
jg     1b4a <bytemapmag+0xa3a>
mov    -0x68(%rbp),%eax
sub    -0x60(%rbp),%eax
cmp    $0x0,%eax
jl     1a9d <bytemapmag+0x98d>
mov    -0x68(%rbp),%eax
sub    -0x60(%rbp),%eax
mov    %eax,-0xfc(%rbp)
jmp    1aad <bytemapmag+0x99d>
mov    -0x68(%rbp),%ecx
sub    -0x60(%rbp),%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0xfc(%rbp)
mov    -0xfc(%rbp),%eax
cmp    -0x74(%rbp),%eax
jle    1b4a <bytemapmag+0xa3a>
mov    -0x58(%rbp),%eax
sub    -0x50(%rbp),%eax
cmp    $0x0,%eax
jl     1adc <bytemapmag+0x9cc>
mov    -0x58(%rbp),%eax
sub    -0x50(%rbp),%eax
mov    %eax,-0x100(%rbp)
jmp    1aec <bytemapmag+0x9dc>
mov    -0x58(%rbp),%ecx
sub    -0x50(%rbp),%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0x100(%rbp)
mov    -0x100(%rbp),%eax
cmp    -0x74(%rbp),%eax
jle    1b4a <bytemapmag+0xa3a>
mov    -0x5c(%rbp),%eax
sub    -0x6c(%rbp),%eax
cmp    $0x0,%eax
jl     1b1b <bytemapmag+0xa0b>
mov    -0x5c(%rbp),%eax
sub    -0x6c(%rbp),%eax
mov    %eax,-0x104(%rbp)
jmp    1b2b <bytemapmag+0xa1b>
mov    -0x5c(%rbp),%ecx
sub    -0x6c(%rbp),%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0x104(%rbp)
mov    -0x104(%rbp),%eax
cmp    -0x74(%rbp),%eax
jle    1b4a <bytemapmag+0xa3a>
mov    -0x68(%rbp),%eax
mov    %al,%dl
mov    -0x20(%rbp),%rax
movslq -0x80(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
jmp    1b4f <bytemapmag+0xa3f>
cmpl   $0x3,-0x84(%rbp)
jne    1c2e <bytemapmag+0xb1e>
mov    -0x68(%rbp),%eax
sub    -0x58(%rbp),%eax
cmp    $0x0,%eax
jl     1b7c <bytemapmag+0xa6c>
mov    -0x68(%rbp),%eax
sub    -0x58(%rbp),%eax
mov    %eax,-0x108(%rbp)
jmp    1b8c <bytemapmag+0xa7c>
mov    -0x68(%rbp),%ecx
sub    -0x58(%rbp),%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0x108(%rbp)
mov    -0x108(%rbp),%eax
cmp    -0x74(%rbp),%eax
jg     1c29 <bytemapmag+0xb19>
mov    -0x68(%rbp),%eax
sub    -0x60(%rbp),%eax
cmp    $0x0,%eax
jl     1bbb <bytemapmag+0xaab>
mov    -0x68(%rbp),%eax
sub    -0x60(%rbp),%eax
mov    %eax,-0x10c(%rbp)
jmp    1bcb <bytemapmag+0xabb>
mov    -0x68(%rbp),%ecx
sub    -0x60(%rbp),%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0x10c(%rbp)
mov    -0x10c(%rbp),%eax
cmp    -0x74(%rbp),%eax
jle    1c29 <bytemapmag+0xb19>
mov    -0x58(%rbp),%eax
sub    -0x50(%rbp),%eax
cmp    $0x0,%eax
jl     1bfa <bytemapmag+0xaea>
mov    -0x58(%rbp),%eax
sub    -0x50(%rbp),%eax
mov    %eax,-0x110(%rbp)
jmp    1c0a <bytemapmag+0xafa>
mov    -0x58(%rbp),%ecx
sub    -0x50(%rbp),%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0x110(%rbp)
mov    -0x110(%rbp),%eax
cmp    -0x74(%rbp),%eax
jle    1c29 <bytemapmag+0xb19>
mov    -0x58(%rbp),%eax
mov    %al,%dl
mov    -0x20(%rbp),%rax
movslq -0x80(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
jmp    1c2e <bytemapmag+0xb1e>
cmpl   $0x4,-0x84(%rbp)
jne    1e48 <bytemapmag+0xd38>
mov    -0x50(%rbp),%eax
sub    -0x60(%rbp),%eax
cmp    $0x0,%eax
jl     1c5b <bytemapmag+0xb4b>
mov    -0x50(%rbp),%eax
sub    -0x60(%rbp),%eax
mov    %eax,-0x114(%rbp)
jmp    1c6b <bytemapmag+0xb5b>
mov    -0x50(%rbp),%ecx
sub    -0x60(%rbp),%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0x114(%rbp)
mov    -0x114(%rbp),%eax
cmp    -0x74(%rbp),%eax
jg     1d37 <bytemapmag+0xc27>
mov    -0x50(%rbp),%eax
sub    -0x58(%rbp),%eax
cmp    $0x0,%eax
jl     1c9a <bytemapmag+0xb8a>
mov    -0x50(%rbp),%eax
sub    -0x58(%rbp),%eax
mov    %eax,-0x118(%rbp)
jmp    1caa <bytemapmag+0xb9a>
mov    -0x50(%rbp),%ecx
sub    -0x58(%rbp),%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0x118(%rbp)
mov    -0x118(%rbp),%eax
cmp    -0x74(%rbp),%eax
jle    1d37 <bytemapmag+0xc27>
mov    -0x60(%rbp),%eax
sub    -0x68(%rbp),%eax
cmp    $0x0,%eax
jl     1cd9 <bytemapmag+0xbc9>
mov    -0x60(%rbp),%eax
sub    -0x68(%rbp),%eax
mov    %eax,-0x11c(%rbp)
jmp    1ce9 <bytemapmag+0xbd9>
mov    -0x60(%rbp),%ecx
sub    -0x68(%rbp),%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0x11c(%rbp)
mov    -0x11c(%rbp),%eax
cmp    -0x74(%rbp),%eax
jle    1d37 <bytemapmag+0xc27>
mov    -0x5c(%rbp),%eax
sub    -0x6c(%rbp),%eax
cmp    $0x0,%eax
jl     1d18 <bytemapmag+0xc08>
mov    -0x5c(%rbp),%eax
sub    -0x6c(%rbp),%eax
mov    %eax,-0x120(%rbp)
jmp    1d28 <bytemapmag+0xc18>
mov    -0x5c(%rbp),%ecx
sub    -0x6c(%rbp),%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0x120(%rbp)
mov    -0x120(%rbp),%eax
cmp    -0x74(%rbp),%eax
jg     1e33 <bytemapmag+0xd23>
mov    -0x60(%rbp),%eax
sub    -0x68(%rbp),%eax
cmp    $0x0,%eax
jl     1d57 <bytemapmag+0xc47>
mov    -0x60(%rbp),%eax
sub    -0x68(%rbp),%eax
mov    %eax,-0x124(%rbp)
jmp    1d67 <bytemapmag+0xc57>
mov    -0x60(%rbp),%ecx
sub    -0x68(%rbp),%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0x124(%rbp)
mov    -0x124(%rbp),%eax
cmp    -0x74(%rbp),%eax
jg     1e43 <bytemapmag+0xd33>
mov    -0x60(%rbp),%eax
sub    -0x50(%rbp),%eax
cmp    $0x0,%eax
jl     1d96 <bytemapmag+0xc86>
mov    -0x60(%rbp),%eax
sub    -0x50(%rbp),%eax
mov    %eax,-0x128(%rbp)
jmp    1da6 <bytemapmag+0xc96>
mov    -0x60(%rbp),%ecx
sub    -0x50(%rbp),%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0x128(%rbp)
mov    -0x128(%rbp),%eax
cmp    -0x74(%rbp),%eax
jle    1e43 <bytemapmag+0xd33>
mov    -0x68(%rbp),%eax
sub    -0x58(%rbp),%eax
cmp    $0x0,%eax
jl     1dd5 <bytemapmag+0xcc5>
mov    -0x68(%rbp),%eax
sub    -0x58(%rbp),%eax
mov    %eax,-0x12c(%rbp)
jmp    1de5 <bytemapmag+0xcd5>
mov    -0x68(%rbp),%ecx
sub    -0x58(%rbp),%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0x12c(%rbp)
mov    -0x12c(%rbp),%eax
cmp    -0x74(%rbp),%eax
jle    1e43 <bytemapmag+0xd33>
mov    -0x5c(%rbp),%eax
sub    -0x54(%rbp),%eax
cmp    $0x0,%eax
jl     1e14 <bytemapmag+0xd04>
mov    -0x5c(%rbp),%eax
sub    -0x54(%rbp),%eax
mov    %eax,-0x130(%rbp)
jmp    1e24 <bytemapmag+0xd14>
mov    -0x5c(%rbp),%ecx
sub    -0x54(%rbp),%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0x130(%rbp)
mov    -0x130(%rbp),%eax
cmp    -0x74(%rbp),%eax
jle    1e43 <bytemapmag+0xd33>
mov    -0x60(%rbp),%eax
mov    %al,%dl
mov    -0x20(%rbp),%rax
movslq -0x80(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
jmp    1e48 <bytemapmag+0xd38>
cmpl   $0x6,-0x84(%rbp)
jne    2062 <bytemapmag+0xf52>
mov    -0x68(%rbp),%eax
sub    -0x58(%rbp),%eax
cmp    $0x0,%eax
jl     1e75 <bytemapmag+0xd65>
mov    -0x68(%rbp),%eax
sub    -0x58(%rbp),%eax
mov    %eax,-0x134(%rbp)
jmp    1e85 <bytemapmag+0xd75>
mov    -0x68(%rbp),%ecx
sub    -0x58(%rbp),%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0x134(%rbp)
mov    -0x134(%rbp),%eax
cmp    -0x74(%rbp),%eax
jg     1f51 <bytemapmag+0xe41>
mov    -0x68(%rbp),%eax
sub    -0x60(%rbp),%eax
cmp    $0x0,%eax
jl     1eb4 <bytemapmag+0xda4>
mov    -0x68(%rbp),%eax
sub    -0x60(%rbp),%eax
mov    %eax,-0x138(%rbp)
jmp    1ec4 <bytemapmag+0xdb4>
mov    -0x68(%rbp),%ecx
sub    -0x60(%rbp),%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0x138(%rbp)
mov    -0x138(%rbp),%eax
cmp    -0x74(%rbp),%eax
jle    1f51 <bytemapmag+0xe41>
mov    -0x58(%rbp),%eax
sub    -0x50(%rbp),%eax
cmp    $0x0,%eax
jl     1ef3 <bytemapmag+0xde3>
mov    -0x58(%rbp),%eax
sub    -0x50(%rbp),%eax
mov    %eax,-0x13c(%rbp)
jmp    1f03 <bytemapmag+0xdf3>
mov    -0x58(%rbp),%ecx
sub    -0x50(%rbp),%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0x13c(%rbp)
mov    -0x13c(%rbp),%eax
cmp    -0x74(%rbp),%eax
jle    1f51 <bytemapmag+0xe41>
mov    -0x5c(%rbp),%eax
sub    -0x4c(%rbp),%eax
cmp    $0x0,%eax
jl     1f32 <bytemapmag+0xe22>
mov    -0x5c(%rbp),%eax
sub    -0x4c(%rbp),%eax
mov    %eax,-0x140(%rbp)
jmp    1f42 <bytemapmag+0xe32>
mov    -0x5c(%rbp),%ecx
sub    -0x4c(%rbp),%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0x140(%rbp)
mov    -0x140(%rbp),%eax
cmp    -0x74(%rbp),%eax
jg     204d <bytemapmag+0xf3d>
mov    -0x58(%rbp),%eax
sub    -0x50(%rbp),%eax
cmp    $0x0,%eax
jl     1f71 <bytemapmag+0xe61>
mov    -0x58(%rbp),%eax
sub    -0x50(%rbp),%eax
mov    %eax,-0x144(%rbp)
jmp    1f81 <bytemapmag+0xe71>
mov    -0x58(%rbp),%ecx
sub    -0x50(%rbp),%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0x144(%rbp)
mov    -0x144(%rbp),%eax
cmp    -0x74(%rbp),%eax
jg     205d <bytemapmag+0xf4d>
mov    -0x58(%rbp),%eax
sub    -0x68(%rbp),%eax
cmp    $0x0,%eax
jl     1fb0 <bytemapmag+0xea0>
mov    -0x58(%rbp),%eax
sub    -0x68(%rbp),%eax
mov    %eax,-0x148(%rbp)
jmp    1fc0 <bytemapmag+0xeb0>
mov    -0x58(%rbp),%ecx
sub    -0x68(%rbp),%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0x148(%rbp)
mov    -0x148(%rbp),%eax
cmp    -0x74(%rbp),%eax
jle    205d <bytemapmag+0xf4d>
mov    -0x50(%rbp),%eax
sub    -0x60(%rbp),%eax
cmp    $0x0,%eax
jl     1fef <bytemapmag+0xedf>
mov    -0x50(%rbp),%eax
sub    -0x60(%rbp),%eax
mov    %eax,-0x14c(%rbp)
jmp    1fff <bytemapmag+0xeef>
mov    -0x50(%rbp),%ecx
sub    -0x60(%rbp),%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0x14c(%rbp)
mov    -0x14c(%rbp),%eax
cmp    -0x74(%rbp),%eax
jle    205d <bytemapmag+0xf4d>
mov    -0x5c(%rbp),%eax
sub    -0x64(%rbp),%eax
cmp    $0x0,%eax
jl     202e <bytemapmag+0xf1e>
mov    -0x5c(%rbp),%eax
sub    -0x64(%rbp),%eax
mov    %eax,-0x150(%rbp)
jmp    203e <bytemapmag+0xf2e>
mov    -0x5c(%rbp),%ecx
sub    -0x64(%rbp),%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0x150(%rbp)
mov    -0x150(%rbp),%eax
cmp    -0x74(%rbp),%eax
jle    205d <bytemapmag+0xf4d>
mov    -0x58(%rbp),%eax
mov    %al,%dl
mov    -0x20(%rbp),%rax
movslq -0x80(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
jmp    2062 <bytemapmag+0xf52>
cmpl   $0x7,-0x84(%rbp)
jne    2141 <bytemapmag+0x1031>
mov    -0x50(%rbp),%eax
sub    -0x60(%rbp),%eax
cmp    $0x0,%eax
jl     208f <bytemapmag+0xf7f>
mov    -0x50(%rbp),%eax
sub    -0x60(%rbp),%eax
mov    %eax,-0x154(%rbp)
jmp    209f <bytemapmag+0xf8f>
mov    -0x50(%rbp),%ecx
sub    -0x60(%rbp),%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0x154(%rbp)
mov    -0x154(%rbp),%eax
cmp    -0x74(%rbp),%eax
jg     213c <bytemapmag+0x102c>
mov    -0x50(%rbp),%eax
sub    -0x58(%rbp),%eax
cmp    $0x0,%eax
jl     20ce <bytemapmag+0xfbe>
mov    -0x50(%rbp),%eax
sub    -0x58(%rbp),%eax
mov    %eax,-0x158(%rbp)
jmp    20de <bytemapmag+0xfce>
mov    -0x50(%rbp),%ecx
sub    -0x58(%rbp),%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0x158(%rbp)
mov    -0x158(%rbp),%eax
cmp    -0x74(%rbp),%eax
jle    213c <bytemapmag+0x102c>
mov    -0x60(%rbp),%eax
sub    -0x68(%rbp),%eax
cmp    $0x0,%eax
jl     210d <bytemapmag+0xffd>
mov    -0x60(%rbp),%eax
sub    -0x68(%rbp),%eax
mov    %eax,-0x15c(%rbp)
jmp    211d <bytemapmag+0x100d>
mov    -0x60(%rbp),%ecx
sub    -0x68(%rbp),%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0x15c(%rbp)
mov    -0x15c(%rbp),%eax
cmp    -0x74(%rbp),%eax
jle    213c <bytemapmag+0x102c>
mov    -0x60(%rbp),%eax
mov    %al,%dl
mov    -0x20(%rbp),%rax
movslq -0x80(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
jmp    2141 <bytemapmag+0x1031>
cmpl   $0x8,-0x84(%rbp)
jne    235b <bytemapmag+0x124b>
mov    -0x58(%rbp),%eax
sub    -0x50(%rbp),%eax
cmp    $0x0,%eax
jl     216e <bytemapmag+0x105e>
mov    -0x58(%rbp),%eax
sub    -0x50(%rbp),%eax
mov    %eax,-0x160(%rbp)
jmp    217e <bytemapmag+0x106e>
mov    -0x58(%rbp),%ecx
sub    -0x50(%rbp),%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0x160(%rbp)
mov    -0x160(%rbp),%eax
cmp    -0x74(%rbp),%eax
jg     224a <bytemapmag+0x113a>
mov    -0x58(%rbp),%eax
sub    -0x68(%rbp),%eax
cmp    $0x0,%eax
jl     21ad <bytemapmag+0x109d>
mov    -0x58(%rbp),%eax
sub    -0x68(%rbp),%eax
mov    %eax,-0x164(%rbp)
jmp    21bd <bytemapmag+0x10ad>
mov    -0x58(%rbp),%ecx
sub    -0x68(%rbp),%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0x164(%rbp)
mov    -0x164(%rbp),%eax
cmp    -0x74(%rbp),%eax
jle    224a <bytemapmag+0x113a>
mov    -0x50(%rbp),%eax
sub    -0x60(%rbp),%eax
cmp    $0x0,%eax
jl     21ec <bytemapmag+0x10dc>
mov    -0x50(%rbp),%eax
sub    -0x60(%rbp),%eax
mov    %eax,-0x168(%rbp)
jmp    21fc <bytemapmag+0x10ec>
mov    -0x50(%rbp),%ecx
sub    -0x60(%rbp),%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0x168(%rbp)
mov    -0x168(%rbp),%eax
cmp    -0x74(%rbp),%eax
jle    224a <bytemapmag+0x113a>
mov    -0x5c(%rbp),%eax
sub    -0x54(%rbp),%eax
cmp    $0x0,%eax
jl     222b <bytemapmag+0x111b>
mov    -0x5c(%rbp),%eax
sub    -0x54(%rbp),%eax
mov    %eax,-0x16c(%rbp)
jmp    223b <bytemapmag+0x112b>
mov    -0x5c(%rbp),%ecx
sub    -0x54(%rbp),%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0x16c(%rbp)
mov    -0x16c(%rbp),%eax
cmp    -0x74(%rbp),%eax
jg     2346 <bytemapmag+0x1236>
mov    -0x50(%rbp),%eax
sub    -0x60(%rbp),%eax
cmp    $0x0,%eax
jl     226a <bytemapmag+0x115a>
mov    -0x50(%rbp),%eax
sub    -0x60(%rbp),%eax
mov    %eax,-0x170(%rbp)
jmp    227a <bytemapmag+0x116a>
mov    -0x50(%rbp),%ecx
sub    -0x60(%rbp),%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0x170(%rbp)
mov    -0x170(%rbp),%eax
cmp    -0x74(%rbp),%eax
jg     2356 <bytemapmag+0x1246>
mov    -0x50(%rbp),%eax
sub    -0x58(%rbp),%eax
cmp    $0x0,%eax
jl     22a9 <bytemapmag+0x1199>
mov    -0x50(%rbp),%eax
sub    -0x58(%rbp),%eax
mov    %eax,-0x174(%rbp)
jmp    22b9 <bytemapmag+0x11a9>
mov    -0x50(%rbp),%ecx
sub    -0x58(%rbp),%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0x174(%rbp)
mov    -0x174(%rbp),%eax
cmp    -0x74(%rbp),%eax
jle    2356 <bytemapmag+0x1246>
mov    -0x60(%rbp),%eax
sub    -0x68(%rbp),%eax
cmp    $0x0,%eax
jl     22e8 <bytemapmag+0x11d8>
mov    -0x60(%rbp),%eax
sub    -0x68(%rbp),%eax
mov    %eax,-0x178(%rbp)
jmp    22f8 <bytemapmag+0x11e8>
mov    -0x60(%rbp),%ecx
sub    -0x68(%rbp),%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0x178(%rbp)
mov    -0x178(%rbp),%eax
cmp    -0x74(%rbp),%eax
jle    2356 <bytemapmag+0x1246>
mov    -0x5c(%rbp),%eax
sub    -0x4c(%rbp),%eax
cmp    $0x0,%eax
jl     2327 <bytemapmag+0x1217>
mov    -0x5c(%rbp),%eax
sub    -0x4c(%rbp),%eax
mov    %eax,-0x17c(%rbp)
jmp    2337 <bytemapmag+0x1227>
mov    -0x5c(%rbp),%ecx
sub    -0x4c(%rbp),%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0x17c(%rbp)
mov    -0x17c(%rbp),%eax
cmp    -0x74(%rbp),%eax
jle    2356 <bytemapmag+0x1246>
mov    -0x50(%rbp),%eax
mov    %al,%dl
mov    -0x20(%rbp),%rax
movslq -0x80(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
jmp    235b <bytemapmag+0x124b>
cmpl   $0x9,-0x84(%rbp)
jne    243a <bytemapmag+0x132a>
mov    -0x58(%rbp),%eax
sub    -0x50(%rbp),%eax
cmp    $0x0,%eax
jl     2388 <bytemapmag+0x1278>
mov    -0x58(%rbp),%eax
sub    -0x50(%rbp),%eax
mov    %eax,-0x180(%rbp)
jmp    2398 <bytemapmag+0x1288>
mov    -0x58(%rbp),%ecx
sub    -0x50(%rbp),%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0x180(%rbp)
mov    -0x180(%rbp),%eax
cmp    -0x74(%rbp),%eax
jg     2435 <bytemapmag+0x1325>
mov    -0x58(%rbp),%eax
sub    -0x68(%rbp),%eax
cmp    $0x0,%eax
jl     23c7 <bytemapmag+0x12b7>
mov    -0x58(%rbp),%eax
sub    -0x68(%rbp),%eax
mov    %eax,-0x184(%rbp)
jmp    23d7 <bytemapmag+0x12c7>
mov    -0x58(%rbp),%ecx
sub    -0x68(%rbp),%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0x184(%rbp)
mov    -0x184(%rbp),%eax
cmp    -0x74(%rbp),%eax
jle    2435 <bytemapmag+0x1325>
mov    -0x50(%rbp),%eax
sub    -0x60(%rbp),%eax
cmp    $0x0,%eax
jl     2406 <bytemapmag+0x12f6>
mov    -0x50(%rbp),%eax
sub    -0x60(%rbp),%eax
mov    %eax,-0x188(%rbp)
jmp    2416 <bytemapmag+0x1306>
mov    -0x50(%rbp),%ecx
sub    -0x60(%rbp),%ecx
xor    %eax,%eax
sub    %ecx,%eax
mov    %eax,-0x188(%rbp)
mov    -0x188(%rbp),%eax
cmp    -0x74(%rbp),%eax
jle    2435 <bytemapmag+0x1325>
mov    -0x58(%rbp),%eax
mov    %al,%dl
mov    -0x20(%rbp),%rax
movslq -0x80(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
jmp    243a <bytemapmag+0x132a>
jmp    243f <bytemapmag+0x132f>
jmp    2444 <bytemapmag+0x1334>
jmp    2449 <bytemapmag+0x1339>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1246 <bytemapmag+0x136>
jmp    245c <bytemapmag+0x134c>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1233 <bytemapmag+0x123>
jmp    246f <bytemapmag+0x135f>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    11ef <bytemapmag+0xdf>
jmp    2482 <bytemapmag+0x1372>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    11dc <bytemapmag+0xcc>
jmp    2495 <bytemapmag+0x1385>
jmp    249a <bytemapmag+0x138a>
mov    -0x20(%rbp),%rax
add    $0x190,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<bytemapmag>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xb8,%rsp
test   %rdi,%rdi
je     18b2 <bytemapmag+0x7a2>
mov    %esi,%r13d
xor    %eax,%eax
test   %esi,%esi
jle    18bb <bytemapmag+0x7ab>
mov    %edx,%r12d
test   %edx,%edx
jle    18bb <bytemapmag+0x7ab>
mov    %ecx,%r15d
mov    %r12d,%ecx
imul   %r13d,%ecx
cmp    $0x186a0,%ecx
jg     18bb <bytemapmag+0x7ab>
lea    -0xb(%r15),%ecx
cmp    $0xfffffff6,%ecx
jb     18bb <bytemapmag+0x7ab>
mov    %rdi,%r14
mov    %r15d,%ebx
imul   %r13d,%ebx
mov    %r15d,%edi
imul   %r12d,%edi
imul   %ebx,%edi
call   1030 <malloc@plt>
mov    %rax,0x28(%rsp)
test   %rax,%rax
je     18b2 <bytemapmag+0x7a2>
mov    %r15d,%ecx
mov    %r13d,%eax
mov    %rax,0x48(%rsp)
imul   %r15d,%r15d
imul   %r13d,%r15d
mov    %ebx,%eax
mov    %rax,0x68(%rsp)
mov    $0xffffffffffffffff,%rax
xor    %edi,%edi
mov    %rcx,0x98(%rsp)
xor    %r8d,%r8d
mov    %r15,0x38(%rsp)
mov    %r12d,0x34(%rsp)
mov    %r13,0x50(%rsp)
jmp    11ef <bytemapmag+0xdf>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r8d
mov    0x38(%rsp),%r15
mov    0x40(%rsp),%rdi
add    %r15,%rdi
mov    0x34(%rsp),%r12d
cmp    %r12d,%r8d
je     18b6 <bytemapmag+0x7a6>
movslq %eax,%rdx
xor    %esi,%esi
mov    %rdi,0x40(%rsp)
mov    %rdi,%rbp
jmp    121d <bytemapmag+0x10d>
xchg   %ax,%ax
add    $0x1,%esi
mov    0x58(%rsp),%rbp
add    %rcx,%rbp
mov    0x60(%rsp),%rax
mov    %rax,%rdx
mov    0x50(%rsp),%r13
cmp    %r13d,%esi
je     11d0 <bytemapmag+0xc0>
lea    0x1(%rdx),%r9
mov    0x1(%r14,%rdx,1),%al
mov    %al,0x13(%rsp)
movzbl %al,%eax
mov    %eax,0xc(%rsp)
mov    %r9,%rbx
mov    0x48(%rsp),%rax
sub    %rax,%rbx
mov    %rbx,0x90(%rsp)
lea    (%rdx,%rax,1),%rdi
add    $0x1,%rdi
mov    %edx,%eax
sub    %r13d,%eax
movslq %eax,%rbx
mov    %rbx,%rax
mov    %rbx,0x78(%rsp)
lea    0x2(%rbx),%eax
cltq
mov    %rax,0x88(%rsp)
mov    %r9,0x60(%rsp)
lea    (%r9,%r13,1),%eax
mov    %eax,0x14(%rsp)
lea    (%rdx,%r13,1),%eax
cltq
mov    %rax,0x80(%rsp)
mov    $0x1,%eax
mov    %rax,0x18(%rsp)
mov    %rbp,0x58(%rsp)
mov    %rbp,0x20(%rsp)
xor    %ebp,%ebp
mov    %rdx,0xa8(%rsp)
mov    %rdi,0xa0(%rsp)
jmp    12d6 <bytemapmag+0x1c6>
nopl   0x0(%rax)
mov    0x70(%rsp),%rbp
add    $0x1,%rbp
mov    0x20(%rsp),%rax
add    0x68(%rsp),%rax
mov    %rax,0x20(%rsp)
add    %rcx,0x18(%rsp)
cmp    %rcx,%rbp
je     1200 <bytemapmag+0xf0>
mov    %rbp,0x70(%rsp)
xor    %r12d,%r12d
jmp    131d <bytemapmag+0x20d>
mov    (%rsp),%eax
mov    %eax,%r10d
mov    0x28(%rsp),%rax
mov    0xb0(%rsp),%rcx
mov    %r10b,(%rax,%rcx,1)
nopw   0x0(%rax,%rax,1)
mov    0x98(%rsp),%rcx
cmp    %r12,%rcx
mov    0xa8(%rsp),%rdx
mov    0xa0(%rsp),%rdi
je     12b0 <bytemapmag+0x1a0>
mov    %r12,%r13
mov    0x20(%rsp),%rax
add    %r12d,%eax
movslq %eax,%rbp
mov    0x28(%rsp),%rax
movzbl 0x13(%rsp),%ebx
mov    %bl,(%rax,%rbp,1)
test   %esi,%esi
mov    %rbp,0xb0(%rsp)
je     1370 <bytemapmag+0x260>
movzbl (%r14,%rdx,1),%eax
mov    %eax,(%rsp)
movzbl 0x2(%r14,%rdx,1),%r10d
movzbl %r10b,%eax
mov    %eax,0x8(%rsp)
test   %r8d,%r8d
je     13c0 <bytemapmag+0x2b0>
mov    0x78(%rsp),%rax
movzbl (%r14,%rax,1),%r9d
jmp    1396 <bytemapmag+0x286>
nopl   0x0(%rax,%rax,1)
movzbl 0x2(%r14,%rdx,1),%r10d
movzbl %r10b,%eax
mov    %eax,0x8(%rsp)
mov    0xc(%rsp),%ebp
mov    %ebp,(%rsp)
mov    %ebp,%r9d
mov    %ebp,0x4(%rsp)
mov    0x14(%rsp),%r11d
test   %r8d,%r8d
je     13d0 <bytemapmag+0x2c0>
mov    0x90(%rsp),%rax
movzbl (%r14,%rax,1),%eax
mov    %eax,0x4(%rsp)
mov    0x88(%rsp),%rax
movzbl (%r14,%rax,1),%ebp
mov    %edi,%r11d
jmp    13d0 <bytemapmag+0x2c0>
nopl   0x0(%rax)
mov    0xc(%rsp),%ebp
mov    %ebp,%r9d
mov    %ebp,0x4(%rsp)
mov    0x14(%rsp),%r11d
movzbl (%r14,%rdi,1),%r15d
mov    0xc(%rsp),%eax
test   %esi,%esi
je     13ea <bytemapmag+0x2da>
mov    0x80(%rsp),%rax
movzbl (%r14,%rax,1),%eax
lea    0x1(%r13),%r12
movzbl %r15b,%ebx
cmp    $0x3,%ecx
je     1460 <bytemapmag+0x350>
cmp    $0x2,%ecx
jne    1300 <bytemapmag+0x1f0>
mov    0x18(%rsp),%rax
add    %r13d,%eax
add    $0xffffffff,%eax
cmp    $0x3,%eax
ja     1300 <bytemapmag+0x1f0>
lea    0xc09(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    (%rsp),%eax
sub    0x4(%rsp),%eax
mov    %eax,%edx
neg    %edx
cmovs  %eax,%edx
cmp    $0x40,%edx
ja     1300 <bytemapmag+0x1f0>
mov    (%rsp),%ecx
sub    %ebx,%ecx
mov    %ecx,%eax
neg    %eax
cmovs  %ecx,%eax
cmp    $0x41,%eax
jb     1300 <bytemapmag+0x1f0>
mov    0x4(%rsp),%eax
sub    0x8(%rsp),%eax
jmp    163c <bytemapmag+0x52c>
nopl   (%rax)
mov    0x18(%rsp),%rcx
lea    (%rcx,%r13,1),%edx
add    $0xffffffff,%edx
cmp    $0x8,%edx
ja     1300 <bytemapmag+0x1f0>
mov    %r8,%rcx
mov    %esi,%edi
movslq %r11d,%rsi
movzbl 0x1(%rsi,%r14,1),%r11d
lea    0xb76(%rip),%rsi
movslq (%rsi,%rdx,4),%rdx
add    %rsi,%rdx
mov    %edi,%esi
jmp    *%rdx
mov    (%rsp),%eax
sub    0x4(%rsp),%eax
mov    %eax,%edx
neg    %edx
cmovs  %eax,%edx
cmp    $0x40,%edx
ja     1300 <bytemapmag+0x1f0>
mov    (%rsp),%eax
sub    %ebx,%eax
mov    %eax,%ecx
neg    %ecx
cmovs  %eax,%ecx
cmp    $0x41,%ecx
jb     1300 <bytemapmag+0x1f0>
mov    0x4(%rsp),%ecx
sub    0x8(%rsp),%ecx
jmp    16f6 <bytemapmag+0x5e6>
mov    0x4(%rsp),%eax
sub    0x8(%rsp),%eax
mov    %eax,%edx
neg    %edx
cmovs  %eax,%edx
cmp    $0x40,%edx
ja     1300 <bytemapmag+0x1f0>
mov    0x4(%rsp),%ecx
sub    (%rsp),%ecx
mov    %ecx,%eax
neg    %eax
cmovs  %ecx,%eax
cmp    $0x41,%eax
jb     1300 <bytemapmag+0x1f0>
mov    0x8(%rsp),%ecx
sub    %ebx,%ecx
mov    %ecx,%eax
neg    %eax
cmovs  %ecx,%eax
cmp    $0x41,%eax
jae    12e6 <bytemapmag+0x1d6>
jmp    1300 <bytemapmag+0x1f0>
mov    %ebx,%eax
sub    (%rsp),%eax
mov    %eax,%edx
neg    %edx
cmovs  %eax,%edx
cmp    $0x40,%edx
ja     1300 <bytemapmag+0x1f0>
sub    0x8(%rsp),%ebx
mov    %ebx,%eax
neg    %eax
cmovs  %ebx,%eax
cmp    $0x41,%eax
jb     1300 <bytemapmag+0x1f0>
mov    (%rsp),%eax
sub    0x4(%rsp),%eax
mov    %eax,%ecx
neg    %ecx
cmovs  %eax,%ecx
cmp    $0x41,%ecx
jae    12e0 <bytemapmag+0x1d0>
jmp    1300 <bytemapmag+0x1f0>
mov    0x8(%rsp),%eax
sub    %ebx,%eax
mov    %eax,%edx
neg    %edx
cmovs  %eax,%edx
cmp    $0x40,%edx
ja     1300 <bytemapmag+0x1f0>
mov    0x8(%rsp),%ecx
sub    0x4(%rsp),%ecx
mov    %ecx,%eax
neg    %eax
cmovs  %ecx,%eax
cmp    $0x41,%eax
jb     1300 <bytemapmag+0x1f0>
sub    (%rsp),%ebx
mov    %ebx,%eax
neg    %eax
cmovs  %ebx,%eax
mov    %r15d,%r10d
cmp    $0x41,%eax
jae    12e6 <bytemapmag+0x1d6>
jmp    1300 <bytemapmag+0x1f0>
mov    (%rsp),%eax
sub    0x4(%rsp),%eax
mov    %eax,%edx
neg    %edx
cmovs  %eax,%edx
cmp    $0x40,%edx
ja     15f0 <bytemapmag+0x4e0>
mov    (%rsp),%eax
sub    %ebx,%eax
mov    %eax,%edx
neg    %edx
cmovs  %eax,%edx
cmp    $0x41,%edx
jb     15f0 <bytemapmag+0x4e0>
mov    0x4(%rsp),%eax
sub    0x8(%rsp),%eax
mov    %eax,%edx
neg    %edx
cmovs  %eax,%edx
cmp    $0x41,%edx
jb     15f0 <bytemapmag+0x4e0>
mov    0xc(%rsp),%eax
sub    %ebp,%eax
mov    %eax,%edx
neg    %edx
cmovs  %eax,%edx
cmp    $0x40,%edx
ja     164c <bytemapmag+0x53c>
mov    0x4(%rsp),%eax
sub    0x8(%rsp),%eax
mov    %eax,%edx
neg    %edx
cmovs  %eax,%edx
cmp    $0x40,%edx
ja     1300 <bytemapmag+0x1f0>
mov    0x4(%rsp),%eax
sub    (%rsp),%eax
mov    %eax,%edx
neg    %edx
cmovs  %eax,%edx
cmp    $0x41,%edx
jb     1300 <bytemapmag+0x1f0>
mov    0x8(%rsp),%ecx
sub    %ebx,%ecx
mov    %ecx,%eax
neg    %eax
cmovs  %ecx,%eax
cmp    $0x41,%eax
jb     1300 <bytemapmag+0x1f0>
mov    0xc(%rsp),%eax
sub    %r9d,%eax
mov    %eax,%ecx
neg    %ecx
cmovs  %eax,%ecx
cmp    $0x41,%ecx
jb     1300 <bytemapmag+0x1f0>
mov    0x4(%rsp),%eax
jmp    12e3 <bytemapmag+0x1d3>
mov    %ebx,%edx
sub    (%rsp),%edx
mov    %edx,%esi
neg    %esi
cmovs  %edx,%esi
cmp    $0x40,%esi
ja     16a7 <bytemapmag+0x597>
mov    %ebx,%edx
sub    0x8(%rsp),%edx
mov    %edx,%esi
neg    %esi
cmovs  %edx,%esi
cmp    $0x41,%esi
jb     16a7 <bytemapmag+0x597>
mov    (%rsp),%edx
sub    0x4(%rsp),%edx
mov    %edx,%esi
neg    %esi
cmovs  %edx,%esi
cmp    $0x41,%esi
jb     16a7 <bytemapmag+0x597>
mov    0xc(%rsp),%edx
sub    %r9d,%edx
mov    %edx,%esi
neg    %esi
cmovs  %edx,%esi
cmp    $0x40,%esi
mov    %edi,%esi
mov    %rcx,%r8
ja     12e0 <bytemapmag+0x1d0>
mov    (%rsp),%edx
sub    0x4(%rsp),%edx
mov    %edx,%esi
neg    %esi
cmovs  %edx,%esi
cmp    $0x40,%esi
mov    %edi,%esi
mov    %rcx,%r8
ja     1300 <bytemapmag+0x1f0>
mov    (%rsp),%edx
sub    %ebx,%edx
mov    %edx,%ecx
neg    %ecx
cmovs  %edx,%ecx
cmp    $0x41,%ecx
jb     1300 <bytemapmag+0x1f0>
mov    0x4(%rsp),%edx
sub    0x8(%rsp),%edx
mov    %edx,%ecx
neg    %ecx
cmovs  %edx,%ecx
cmp    $0x41,%ecx
jb     1300 <bytemapmag+0x1f0>
mov    0xc(%rsp),%ecx
sub    %eax,%ecx
mov    %ecx,%eax
neg    %eax
cmovs  %ecx,%eax
cmp    $0x41,%eax
jae    12e0 <bytemapmag+0x1d0>
jmp    1300 <bytemapmag+0x1f0>
mov    0x4(%rsp),%eax
sub    0x8(%rsp),%eax
mov    %eax,%edx
neg    %edx
cmovs  %eax,%edx
cmp    $0x40,%edx
ja     175b <bytemapmag+0x64b>
mov    0x4(%rsp),%eax
sub    (%rsp),%eax
mov    %eax,%edx
neg    %edx
cmovs  %eax,%edx
cmp    $0x41,%edx
jb     175b <bytemapmag+0x64b>
mov    0x8(%rsp),%eax
sub    %ebx,%eax
mov    %eax,%edx
neg    %edx
cmovs  %eax,%edx
cmp    $0x41,%edx
jb     175b <bytemapmag+0x64b>
mov    0xc(%rsp),%eax
sub    %r11d,%eax
mov    %eax,%edx
neg    %edx
cmovs  %eax,%edx
cmp    $0x40,%edx
ja     12e6 <bytemapmag+0x1d6>
mov    0x8(%rsp),%eax
sub    %ebx,%eax
mov    %eax,%edx
neg    %edx
cmovs  %eax,%edx
cmp    $0x40,%edx
ja     1300 <bytemapmag+0x1f0>
mov    0x8(%rsp),%ecx
sub    0x4(%rsp),%ecx
mov    %ecx,%eax
neg    %eax
cmovs  %ecx,%eax
cmp    $0x41,%eax
jb     1300 <bytemapmag+0x1f0>
sub    (%rsp),%ebx
mov    %ebx,%eax
neg    %eax
cmovs  %ebx,%eax
cmp    $0x41,%eax
jb     1300 <bytemapmag+0x1f0>
mov    0xc(%rsp),%eax
sub    %ebp,%eax
mov    %eax,%ecx
neg    %ecx
cmovs  %eax,%ecx
jmp    1851 <bytemapmag+0x741>
mov    0x8(%rsp),%edx
sub    %ebx,%edx
mov    %edx,%esi
neg    %esi
cmovs  %edx,%esi
cmp    $0x40,%esi
ja     17fb <bytemapmag+0x6eb>
mov    0x8(%rsp),%edx
sub    0x4(%rsp),%edx
mov    %edx,%esi
neg    %esi
cmovs  %edx,%esi
cmp    $0x41,%esi
jb     17fb <bytemapmag+0x6eb>
mov    %ebx,%edx
sub    (%rsp),%edx
mov    %edx,%esi
neg    %esi
cmovs  %edx,%esi
cmp    $0x41,%esi
jb     17fb <bytemapmag+0x6eb>
mov    0xc(%rsp),%edx
sub    %eax,%edx
mov    %edx,%eax
neg    %eax
cmovs  %edx,%eax
cmp    $0x40,%eax
ja     18a5 <bytemapmag+0x795>
mov    %ebx,%eax
sub    (%rsp),%eax
mov    %eax,%edx
neg    %edx
cmovs  %eax,%edx
cmp    $0x40,%edx
mov    %rcx,%r8
mov    %edi,%esi
ja     1300 <bytemapmag+0x1f0>
sub    0x8(%rsp),%ebx
mov    %ebx,%eax
neg    %eax
cmovs  %ebx,%eax
cmp    $0x41,%eax
jb     1300 <bytemapmag+0x1f0>
mov    (%rsp),%ecx
sub    0x4(%rsp),%ecx
mov    %ecx,%eax
neg    %eax
cmovs  %ecx,%eax
cmp    $0x41,%eax
jb     1300 <bytemapmag+0x1f0>
mov    0xc(%rsp),%eax
sub    %r11d,%eax
mov    %eax,%ecx
neg    %ecx
cmovs  %eax,%ecx
mov    %r15d,%r10d
cmp    $0x41,%ecx
jae    12e6 <bytemapmag+0x1d6>
jmp    1300 <bytemapmag+0x1f0>
mov    0x8(%rsp),%eax
sub    %ebx,%eax
mov    %eax,%edx
neg    %edx
cmovs  %eax,%edx
cmp    $0x40,%edx
ja     1300 <bytemapmag+0x1f0>
mov    0x8(%rsp),%ecx
sub    0x4(%rsp),%ecx
mov    %ecx,%eax
neg    %eax
cmovs  %ecx,%eax
cmp    $0x41,%eax
jb     1300 <bytemapmag+0x1f0>
sub    (%rsp),%ebx
mov    %ebx,%eax
neg    %eax
cmovs  %ebx,%eax
cmp    $0x41,%eax
jae    12e6 <bytemapmag+0x1d6>
jmp    1300 <bytemapmag+0x1f0>
mov    %r15d,%r10d
mov    %rcx,%r8
mov    %edi,%esi
jmp    12e6 <bytemapmag+0x1d6>
xor    %eax,%eax
jmp    18bb <bytemapmag+0x7ab>
mov    0x28(%rsp),%rax
add    $0xb8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define i8* @bytemapmag(i8* %0, i32 %1, i32 %2, i32 %3) {
%5 = icmp eq i8* %0, null
br i1 %5, label %371, label %6
6: ; preds = %4
%7 = icmp slt i32 %1, 1
%8 = icmp slt i32 %2, 1
%9 = or i1 %7, %8
%10 = mul nsw i32 %2, %1
%11 = icmp sgt i32 %10, 100000
%12 = select i1 %9, i1 true, i1 %11
%13 = add i32 %3, -11
%14 = icmp ult i32 %13, -10
%15 = or i1 %12, %14
br i1 %15, label %371, label %16
16: ; preds = %6
%17 = mul nsw i32 %3, %1
%18 = mul i32 %3, %2
%19 = mul i32 %18, %17
%20 = tail call i64 @malloc(i32 %19)
%21 = inttoptr i64 %20 to i8*
%22 = icmp eq i64 %20, 0
br i1 %22, label %371, label %23
23: ; preds = %16
%24 = zext i32 %3 to i64
%25 = zext i32 %1 to i64
%26 = zext i32 %3 to i64
br label %27
27: ; preds = %23, %368
%28 = phi i32 [ 0, %23 ], [ %369, %368 ]
%29 = phi i64 [ -1, %23 ], [ %39, %368 ]
%30 = mul nsw i32 %28, %17
%31 = icmp eq i32 %28, 0
%32 = shl i64 %29, 32
%33 = ashr exact i64 %32, 32
br label %34
34: ; preds = %27, %365
%35 = phi i64 [ %33, %27 ], [ %39, %365 ]
%36 = phi i32 [ 0, %27 ], [ %366, %365 ]
%37 = add nsw i32 %36, %30
%38 = mul nsw i32 %37, %3
%39 = add nsw i64 %35, 1
%40 = trunc i64 %39 to i32
%41 = getelementptr inbounds i8, i8* %0, i64 %39
%42 = load i8, i8* %41
%43 = zext i8 %42 to i32
%44 = icmp eq i32 %36, 0
%45 = getelementptr inbounds i8, i8* %0, i64 %35
%46 = add nsw i64 %35, 2
%47 = getelementptr inbounds i8, i8* %0, i64 %46
%48 = sub nsw i64 %39, %25
%49 = getelementptr inbounds i8, i8* %0, i64 %48
%50 = add nsw i64 %39, %25
%51 = getelementptr inbounds i8, i8* %0, i64 %50
%52 = trunc i64 %35 to i32
%53 = sub i32 %52, %1
%54 = sext i32 %53 to i64
%55 = getelementptr inbounds i8, i8* %0, i64 %54
%56 = add i32 %53, 2
%57 = sext i32 %56 to i64
%58 = getelementptr inbounds i8, i8* %0, i64 %57
%59 = add nsw i32 %40, %1
%60 = add i32 %52, %1
%61 = sext i32 %60 to i64
%62 = getelementptr inbounds i8, i8* %0, i64 %61
%63 = trunc i64 %50 to i32
br label %64
64: ; preds = %362, %34
%65 = phi i64 [ 0, %34 ], [ %363, %362 ]
%66 = trunc i64 %65 to i32
%67 = mul i32 %17, %66
%68 = add i32 %67, %38
%69 = mul i64 %65, %24
br label %70
70: ; preds = %64, %360
%71 = phi i64 [ 0, %64 ], [ %76, %360 ]
%72 = trunc i64 %71 to i32
%73 = add i32 %68, %72
%74 = sext i32 %73 to i64
%75 = getelementptr inbounds i8, i8* %21, i64 %74
store i8 %42, i8* %75
%76 = add nuw nsw i64 %71, 1
%77 = add i64 %76, %69
br i1 %44, label %78, label %81
78: ; preds = %70
%79 = load i8, i8* %47
%80 = zext i8 %79 to i32
br i1 %31, label %98, label %89
81: ; preds = %70
%82 = load i8, i8* %45
%83 = zext i8 %82 to i32
%84 = load i8, i8* %47
%85 = zext i8 %84 to i32
br i1 %31, label %98, label %86
86: ; preds = %81
%87 = load i8, i8* %55
%88 = zext i8 %87 to i32
br label %89
89: ; preds = %78, %86
%90 = phi i32 [ %83, %86 ], [ %43, %78 ]
%91 = phi i8 [ %84, %86 ], [ %79, %78 ]
%92 = phi i32 [ %85, %86 ], [ %80, %78 ]
%93 = phi i32 [ %88, %86 ], [ %43, %78 ]
%94 = load i8, i8* %49
%95 = zext i8 %94 to i32
%96 = load i8, i8* %58
%97 = zext i8 %96 to i32
br label %98
98: ; preds = %78, %81, %89
%99 = phi i32 [ %92, %89 ], [ %85, %81 ], [ %80, %78 ]
%100 = phi i8 [ %91, %89 ], [ %84, %81 ], [ %79, %78 ]
%101 = phi i32 [ %90, %89 ], [ %83, %81 ], [ %43, %78 ]
%102 = phi i32 [ %93, %89 ], [ %43, %81 ], [ %43, %78 ]
%103 = phi i32 [ %95, %89 ], [ %43, %81 ], [ %43, %78 ]
%104 = phi i32 [ %63, %89 ], [ %59, %81 ], [ %59, %78 ]
%105 = phi i32 [ %97, %89 ], [ %43, %81 ], [ %43, %78 ]
%106 = load i8, i8* %51
%107 = zext i8 %106 to i32
br i1 %44, label %111, label %108
108: ; preds = %98
%109 = load i8, i8* %62
%110 = zext i8 %109 to i32
br label %111
111: ; preds = %98, %108
%112 = phi i32 [ %110, %108 ], [ %43, %98 ]
%113 = add nsw i32 %104, 1
%114 = sext i32 %113 to i64
%115 = getelementptr inbounds i8, i8* %0, i64 %114
%116 = load i8, i8* %115
%117 = zext i8 %116 to i32
switch i32 %3, label %360 [
i32 2, label %118
i32 3, label %172
]
118: ; preds = %111
%119 = trunc i64 %77 to i32
switch i32 %119, label %360 [
i32 1, label %120
i32 2, label %134
i32 4, label %146
i32 3, label %158
]
120: ; preds = %118
%121 = sub nsw i32 %101, %103
%122 = tail call i32 @llvm.abs.i32(i32 %121, i1 true)
%123 = icmp ult i32 %122, 65
br i1 %123, label %124, label %360
124: ; preds = %120
%125 = sub nsw i32 %101, %107
%126 = tail call i32 @llvm.abs.i32(i32 %125, i1 true)
%127 = icmp ult i32 %126, 65
br i1 %127, label %360, label %128
128: ; preds = %124
%129 = sub nsw i32 %103, %99
%130 = tail call i32 @llvm.abs.i32(i32 %129, i1 true)
%131 = icmp ult i32 %130, 65
br i1 %131, label %360, label %132
132: ; preds = %128
%133 = trunc i32 %103 to i8
br label %358
134: ; preds = %118
%135 = sub nsw i32 %103, %99
%136 = tail call i32 @llvm.abs.i32(i32 %135, i1 true)
%137 = icmp ult i32 %136, 65
br i1 %137, label %138, label %360
138: ; preds = %134
%139 = sub nsw i32 %103, %101
%140 = tail call i32 @llvm.abs.i32(i32 %139, i1 true)
%141 = icmp ult i32 %140, 65
br i1 %141, label %360, label %142
142: ; preds = %138
%143 = sub nsw i32 %99, %107
%144 = tail call i32 @llvm.abs.i32(i32 %143, i1 true)
%145 = icmp ult i32 %144, 65
br i1 %145, label %360, label %358
146: ; preds = %118
%147 = sub nsw i32 %99, %107
%148 = tail call i32 @llvm.abs.i32(i32 %147, i1 true)
%149 = icmp ult i32 %148, 65
br i1 %149, label %150, label %360
150: ; preds = %146
%151 = sub nsw i32 %99, %103
%152 = tail call i32 @llvm.abs.i32(i32 %151, i1 true)
%153 = icmp ult i32 %152, 65
br i1 %153, label %360, label %154
154: ; preds = %150
%155 = sub nsw i32 %107, %101
%156 = tail call i32 @llvm.abs.i32(i32 %155, i1 true)
%157 = icmp ult i32 %156, 65
br i1 %157, label %360, label %358
158: ; preds = %118
%159 = sub nsw i32 %107, %101
%160 = tail call i32 @llvm.abs.i32(i32 %159, i1 true)
%161 = icmp ult i32 %160, 65
br i1 %161, label %162, label %360
162: ; preds = %158
%163 = sub nsw i32 %107, %99
%164 = tail call i32 @llvm.abs.i32(i32 %163, i1 true)
%165 = icmp ult i32 %164, 65
br i1 %165, label %360, label %166
166: ; preds = %162
%167 = sub nsw i32 %101, %103
%168 = tail call i32 @llvm.abs.i32(i32 %167, i1 true)
%169 = icmp ult i32 %168, 65
br i1 %169, label %360, label %170
170: ; preds = %166
%171 = trunc i32 %101 to i8
br label %358
172: ; preds = %111
%173 = trunc i64 %77 to i32
switch i32 %173, label %360 [
i32 1, label %174
i32 2, label %188
i32 3, label %222
i32 4, label %234
i32 6, label %268
i32 7, label %300
i32 8, label %314
i32 9, label %346
]
174: ; preds = %172
%175 = sub nsw i32 %101, %103
%176 = tail call i32 @llvm.abs.i32(i32 %175, i1 true)
%177 = icmp ult i32 %176, 65
br i1 %177, label %178, label %360
178: ; preds = %174
%179 = sub nsw i32 %101, %107
%180 = tail call i32 @llvm.abs.i32(i32 %179, i1 true)
%181 = icmp ult i32 %180, 65
br i1 %181, label %360, label %182
182: ; preds = %178
%183 = sub nsw i32 %103, %99
%184 = tail call i32 @llvm.abs.i32(i32 %183, i1 true)
%185 = icmp ult i32 %184, 65
br i1 %185, label %360, label %186
186: ; preds = %182
%187 = trunc i32 %101 to i8
br label %358
188: ; preds = %172
%189 = sub nsw i32 %101, %103
%190 = tail call i32 @llvm.abs.i32(i32 %189, i1 true)
%191 = icmp ult i32 %190, 65
br i1 %191, label %192, label %204
192: ; preds = %188
%193 = sub nsw i32 %101, %107
%194 = tail call i32 @llvm.abs.i32(i32 %193, i1 true)
%195 = icmp ult i32 %194, 65
br i1 %195, label %204, label %196
196: ; preds = %192
%197 = sub nsw i32 %103, %99
%198 = tail call i32 @llvm.abs.i32(i32 %197, i1 true)
%199 = icmp ult i32 %198, 65
br i1 %199, label %204, label %200
200: ; preds = %196
%201 = sub nsw i32 %43, %105
%202 = tail call i32 @llvm.abs.i32(i32 %201, i1 true)
%203 = icmp ult i32 %202, 65
br i1 %203, label %204, label %220
204: ; preds = %200, %196, %192, %188
%205 = sub nsw i32 %103, %99
%206 = tail call i32 @llvm.abs.i32(i32 %205, i1 true)
%207 = icmp ult i32 %206, 65
br i1 %207, label %208, label %360
208: ; preds = %204
%209 = sub nsw i32 %103, %101
%210 = tail call i32 @llvm.abs.i32(i32 %209, i1 true)
%211 = icmp ult i32 %210, 65
br i1 %211, label %360, label %212
212: ; preds = %208
%213 = sub nsw i32 %99, %107
%214 = tail call i32 @llvm.abs.i32(i32 %213, i1 true)
%215 = icmp ult i32 %214, 65
br i1 %215, label %360, label %216
216: ; preds = %212
%217 = sub nsw i32 %43, %102
%218 = tail call i32 @llvm.abs.i32(i32 %217, i1 true)
%219 = icmp ult i32 %218, 65
br i1 %219, label %360, label %220
220: ; preds = %216, %200
%221 = trunc i32 %103 to i8
br label %358
222: ; preds = %172
%223 = sub nsw i32 %103, %99
%224 = tail call i32 @llvm.abs.i32(i32 %223, i1 true)
%225 = icmp ult i32 %224, 65
br i1 %225, label %226, label %360
226: ; preds = %222
%227 = sub nsw i32 %103, %101
%228 = tail call i32 @llvm.abs.i32(i32 %227, i1 true)
%229 = icmp ult i32 %228, 65
br i1 %229, label %360, label %230
230: ; preds = %226
%231 = sub nsw i32 %99, %107
%232 = tail call i32 @llvm.abs.i32(i32 %231, i1 true)
%233 = icmp ult i32 %232, 65
br i1 %233, label %360, label %358
234: ; preds = %172
%235 = sub nsw i32 %107, %101
%236 = tail call i32 @llvm.abs.i32(i32 %235, i1 true)
%237 = icmp ult i32 %236, 65
br i1 %237, label %238, label %250
238: ; preds = %234
%239 = sub nsw i32 %107, %99
%240 = tail call i32 @llvm.abs.i32(i32 %239, i1 true)
%241 = icmp ult i32 %240, 65
br i1 %241, label %250, label %242
242: ; preds = %238
%243 = sub nsw i32 %101, %103
%244 = tail call i32 @llvm.abs.i32(i32 %243, i1 true)
%245 = icmp ult i32 %244, 65
br i1 %245, label %250, label %246
246: ; preds = %242
%247 = sub nsw i32 %43, %102
%248 = tail call i32 @llvm.abs.i32(i32 %247, i1 true)
%249 = icmp ult i32 %248, 65
br i1 %249, label %250, label %266
250: ; preds = %246, %242, %238, %234
%251 = sub nsw i32 %101, %103
%252 = tail call i32 @llvm.abs.i32(i32 %251, i1 true)
%253 = icmp ult i32 %252, 65
br i1 %253, label %254, label %360
254: ; preds = %250
%255 = sub nsw i32 %101, %107
%256 = tail call i32 @llvm.abs.i32(i32 %255, i1 true)
%257 = icmp ult i32 %256, 65
br i1 %257, label %360, label %258
258: ; preds = %254
%259 = sub nsw i32 %103, %99
%260 = tail call i32 @llvm.abs.i32(i32 %259, i1 true)
%261 = icmp ult i32 %260, 65
br i1 %261, label %360, label %262
262: ; preds = %258
%263 = sub nsw i32 %43, %112
%264 = tail call i32 @llvm.abs.i32(i32 %263, i1 true)
%265 = icmp ult i32 %264, 65
br i1 %265, label %360, label %266
266: ; preds = %262, %246
%267 = trunc i32 %101 to i8
br label %358
268: ; preds = %172
%269 = sub nsw i32 %103, %99
%270 = tail call i32 @llvm.abs.i32(i32 %269, i1 true)
%271 = icmp ult i32 %270, 65
br i1 %271, label %272, label %284
272: ; preds = %268
%273 = sub nsw i32 %103, %101
%274 = tail call i32 @llvm.abs.i32(i32 %273, i1 true)
%275 = icmp ult i32 %274, 65
br i1 %275, label %284, label %276
276: ; preds = %272
%277 = sub nsw i32 %99, %107
%278 = tail call i32 @llvm.abs.i32(i32 %277, i1 true)
%279 = icmp ult i32 %278, 65
br i1 %279, label %284, label %280
280: ; preds = %276
%281 = sub nsw i32 %43, %117
%282 = tail call i32 @llvm.abs.i32(i32 %281, i1 true)
%283 = icmp ult i32 %282, 65
br i1 %283, label %284, label %358
284: ; preds = %280, %276, %272, %268
%285 = sub nsw i32 %99, %107
%286 = tail call i32 @llvm.abs.i32(i32 %285, i1 true)
%287 = icmp ult i32 %286, 65
br i1 %287, label %288, label %360
288: ; preds = %284
%289 = sub nsw i32 %99, %103
%290 = tail call i32 @llvm.abs.i32(i32 %289, i1 true)
%291 = icmp ult i32 %290, 65
br i1 %291, label %360, label %292
292: ; preds = %288
%293 = sub nsw i32 %107, %101
%294 = tail call i32 @llvm.abs.i32(i32 %293, i1 true)
%295 = icmp ult i32 %294, 65
br i1 %295, label %360, label %296
296: ; preds = %292
%297 = sub nsw i32 %43, %105
%298 = tail call i32 @llvm.abs.i32(i32 %297, i1 true)
%299 = icmp ult i32 %298, 65
br i1 %299, label %360, label %358
300: ; preds = %172
%301 = sub nsw i32 %107, %101
%302 = tail call i32 @llvm.abs.i32(i32 %301, i1 true)
%303 = icmp ult i32 %302, 65
br i1 %303, label %304, label %360
304: ; preds = %300
%305 = sub nsw i32 %107, %99
%306 = tail call i32 @llvm.abs.i32(i32 %305, i1 true)
%307 = icmp ult i32 %306, 65
br i1 %307, label %360, label %308
308: ; preds = %304
%309 = sub nsw i32 %101, %103
%310 = tail call i32 @llvm.abs.i32(i32 %309, i1 true)
%311 = icmp ult i32 %310, 65
br i1 %311, label %360, label %312
312: ; preds = %308
%313 = trunc i32 %101 to i8
br label %358
314: ; preds = %172
%315 = sub nsw i32 %99, %107
%316 = tail call i32 @llvm.abs.i32(i32 %315, i1 true)
%317 = icmp ult i32 %316, 65
br i1 %317, label %318, label %330
318: ; preds = %314
%319 = sub nsw i32 %99, %103
%320 = tail call i32 @llvm.abs.i32(i32 %319, i1 true)
%321 = icmp ult i32 %320, 65
br i1 %321, label %330, label %322
322: ; preds = %318
%323 = sub nsw i32 %107, %101
%324 = tail call i32 @llvm.abs.i32(i32 %323, i1 true)
%325 = icmp ult i32 %324, 65
br i1 %325, label %330, label %326
326: ; preds = %322
%327 = sub nsw i32 %43, %112
%328 = tail call i32 @llvm.abs.i32(i32 %327, i1 true)
%329 = icmp ult i32 %328, 65
br i1 %329, label %330, label %358
330: ; preds = %326, %322, %318, %314
%331 = sub nsw i32 %107, %101
%332 = tail call i32 @llvm.abs.i32(i32 %331, i1 true)
%333 = icmp ult i32 %332, 65
br i1 %333, label %334, label %360
334: ; preds = %330
%335 = sub nsw i32 %107, %99
%336 = tail call i32 @llvm.abs.i32(i32 %335, i1 true)
%337 = icmp ult i32 %336, 65
br i1 %337, label %360, label %338
338: ; preds = %334
%339 = sub nsw i32 %101, %103
%340 = tail call i32 @llvm.abs.i32(i32 %339, i1 true)
%341 = icmp ult i32 %340, 65
br i1 %341, label %360, label %342
342: ; preds = %338
%343 = sub nsw i32 %43, %117
%344 = tail call i32 @llvm.abs.i32(i32 %343, i1 true)
%345 = icmp ult i32 %344, 65
br i1 %345, label %360, label %358
346: ; preds = %172
%347 = sub nsw i32 %99, %107
%348 = tail call i32 @llvm.abs.i32(i32 %347, i1 true)
%349 = icmp ult i32 %348, 65
br i1 %349, label %350, label %360
350: ; preds = %346
%351 = sub nsw i32 %99, %103
%352 = tail call i32 @llvm.abs.i32(i32 %351, i1 true)
%353 = icmp ult i32 %352, 65
br i1 %353, label %360, label %354
354: ; preds = %350
%355 = sub nsw i32 %107, %101
%356 = tail call i32 @llvm.abs.i32(i32 %355, i1 true)
%357 = icmp ult i32 %356, 65
br i1 %357, label %360, label %358
358: ; preds = %354, %326, %342, %280, %296, %230, %154, %142, %170, %132, %186, %220, %266, %312
%359 = phi i8 [ %313, %312 ], [ %267, %266 ], [ %221, %220 ], [ %187, %186 ], [ %133, %132 ], [ %171, %170 ], [ %100, %142 ], [ %106, %154 ], [ %100, %230 ], [ %100, %296 ], [ %100, %280 ], [ %106, %342 ], [ %106, %326 ], [ %100, %354 ]
store i8 %359, i8* %75
br label %360
360: ; preds = %358, %342, %338, %334, %330, %308, %304, %300, %296, %292, %288, %284, %262, %258, %254, %250, %230, %226, %222, %216, %212, %208, %204, %182, %178, %174, %154, %150, %146, %142, %138, %134, %128, %124, %120, %111, %158, %162, %166, %346, %350, %354, %118, %172
%361 = icmp eq i64 %76, %26
br i1 %361, label %362, label %70
362: ; preds = %360
%363 = add nuw nsw i64 %65, 1
%364 = icmp eq i64 %363, %26
br i1 %364, label %365, label %64
365: ; preds = %362
%366 = add nuw nsw i32 %36, 1
%367 = icmp eq i32 %366, %1
br i1 %367, label %368, label %34
368: ; preds = %365
%369 = add nuw nsw i32 %28, 1
%370 = icmp eq i32 %369, %2
br i1 %370, label %371, label %27
371: ; preds = %368, %16, %6, %4
%372 = phi i8* [ null, %4 ], [ null, %6 ], [ null, %16 ], [ %21, %368 ]
ret i8* %372
}