void qr_binary(int datastream[], int version, int target_binlen, char mode[],
               int jisdata[], int length, int gs1, int est_binlen) {
  int position = 0, debug = 0;
  int short_data_block_length, i, scheme = 1;
  char data_block, padbits;
  int current_binlen, current_bytes;
  int toggle, percent;
  char binary[est_binlen + 12];
  strcpy(binary, "");
  if (gs1) {
    concat(binary, "0101");
  }
  if (version <= 9) {
    scheme = 1;
  } else if ((version >= 10) && (version <= 26)) {
    scheme = 2;
  } else if (version >= 27) {
    scheme = 3;
  }
  if (debug) {
    for (i = 0; i < length; i++) {
      printf("%c", mode[i]);
    }
    printf("\n");
  }
  percent = 0;
  do {
    data_block = mode[position];
    short_data_block_length = 0;
    do {
      short_data_block_length++;
    } while (((short_data_block_length + position) < length) &&
             (mode[position + short_data_block_length] == data_block));
    switch (data_block) {
    case 'K':
      concat(binary, "1000");
      diran(binary, short_data_block_length, 0x20 << (scheme * 2));
      if (debug) {
        printf("Kanji block (length %d)\n\t", short_data_block_length);
      }
      for (i = 0; i < short_data_block_length; i++) {
        int jis = jisdata[position + i];
        int msb, lsb, prod;
        if (jis > 0x9fff) {
          jis -= 0xc140;
        }
        msb = (jis & 0xff00) >> 4;
        lsb = (jis & 0xff);
        prod = (msb * 0xc0) + lsb;
        diran(binary, prod, 0x1000);
        if (debug) {
          printf("0x%4X ", prod);
        }
      }
      if (debug) {
        printf("\n");
      }
      break;
    case 'B':
      concat(binary, "0100");
      diran(binary, short_data_block_length, scheme > 1 ? 0x8000 : 0x80);
      if (debug) {
        printf("Byte block (length %d)\n\t", short_data_block_length);
      }
      for (i = 0; i < short_data_block_length; i++) {
        int byte = jisdata[position + i];
        if (gs1 && (byte == '[')) {
          byte = 0x1d;
        }
        diran(binary, byte, 0x80);
        if (debug) {
          printf("0x%2X(%d) ", byte, byte);
        }
      }
      if (debug) {
        printf("\n");
      }
      break;
    case 'A':
      concat(binary, "0010");
      diran(binary, short_data_block_length, 0x40 << (2 * scheme));
      if (debug) {
        printf("Alpha block (length %d)\n\t", short_data_block_length);
      }
      i = 0;
      while (i < short_data_block_length) {
        int count;
        int first = 0, second = 0, prod;
        if (percent == 0) {
          if (gs1 && (jisdata[position + i] == '%')) {
            first = posn("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ $%*+-./:", '%');
            second = posn("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ $%*+-./:", '%');
            count = 2;
            prod = (first * 45) + second;
            i++;
          } else {
            if (gs1 && (jisdata[position + i] == '[')) {
              first =
                  posn("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ $%*+-./:", '%');
            } else {
              first = posn("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ $%*+-./:",
                           (char)jisdata[position + i]);
            }
            count = 1;
            i++;
            prod = first;
            if (mode[position + i] == 'A') {
              if (gs1 && (jisdata[position + i] == '%')) {
                second =
                    posn("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ $%*+-./:", '%');
                count = 2;
                prod = (first * 45) + second;
                percent = 1;
              } else {
                if (gs1 && (jisdata[position + i] == '[')) {
                  second = posn("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ $%*+-./:",
                                '%');
                } else {
                  second = posn("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ $%*+-./:",
                                (char)jisdata[position + i]);
                }
                count = 2;
                i++;
                prod = (first * 45) + second;
              }
            }
          }
        } else {
          first = posn("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ $%*+-./:", '%');
          count = 1;
          i++;
          prod = first;
          percent = 0;
          if (mode[position + i] == 'A') {
            if (gs1 && (jisdata[position + i] == '%')) {
              second =
                  posn("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ $%*+-./:", '%');
              count = 2;
              prod = (first * 45) + second;
              percent = 1;
            } else {
              if (gs1 && (jisdata[position + i] == '[')) {
                second =
                    posn("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ $%*+-./:", '%');
              } else {
                second = posn("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ $%*+-./:",
                              (char)jisdata[position + i]);
              }
              count = 2;
              i++;
              prod = (first * 45) + second;
            }
          }
        }
        diran(binary, prod, count == 2 ? 0x400 : 0x20);
        if (debug) {
          printf("0x%4X ", prod);
        }
      };
      if (debug) {
        printf("\n");
      }
      break;
    case 'N':
      concat(binary, "0001");
      diran(binary, short_data_block_length, 0x80 << (2 * scheme));
      if (debug) {
        printf("Number block (length %d)\n\t", short_data_block_length);
      }
      i = 0;
      while (i < short_data_block_length) {
        int count;
        int first = 0, second = 0, third = 0, prod;
        first = posn("0123456789", (char)jisdata[position + i]);
        count = 1;
        prod = first;
        if (mode[position + i + 1] == 'N') {
          second = posn("0123456789", (char)jisdata[position + i + 1]);
          count = 2;
          prod = (prod * 10) + second;
          if (mode[position + i + 2] == 'N') {
            third = posn("0123456789", (char)jisdata[position + i + 2]);
            count = 3;
            prod = (prod * 10) + third;
          }
        }
        diran(binary, prod, 1 << (3 * count));
        if (debug) {
          printf("0x%4X (%d)", prod, prod);
        }
        i += count;
      };
      if (debug) {
        printf("\n");
      }
      break;
    }
    position += short_data_block_length;
  } while (position < length);
  concat(binary, "0000");
  current_binlen = strlen(binary);
  padbits = 8 - (current_binlen % 8);
  if (padbits == 8) {
    padbits = 0;
  }
  current_bytes = (current_binlen + padbits) / 8;
  for (i = 0; i < padbits; i++) {
    concat(binary, "0");
  }
  for (i = 0; i < current_bytes; i++) {
    datastream[i] = 0x00;
    if (binary[i * 8] == '1') {
      datastream[i] += 0x80;
    }
    if (binary[i * 8 + 1] == '1') {
      datastream[i] += 0x40;
    }
    if (binary[i * 8 + 2] == '1') {
      datastream[i] += 0x20;
    }
    if (binary[i * 8 + 3] == '1') {
      datastream[i] += 0x10;
    }
    if (binary[i * 8 + 4] == '1') {
      datastream[i] += 0x08;
    }
    if (binary[i * 8 + 5] == '1') {
      datastream[i] += 0x04;
    }
    if (binary[i * 8 + 6] == '1') {
      datastream[i] += 0x02;
    }
    if (binary[i * 8 + 7] == '1') {
      datastream[i] += 0x01;
    }
  }
  toggle = 0;
  for (i = current_bytes; i < target_binlen; i++) {
    if (toggle == 0) {
      datastream[i] = 0xec;
      toggle = 1;
    } else {
      datastream[i] = 0x11;
      toggle = 0;
    }
  }
  if (debug) {
    printf("Resulting codewords:\n\t");
    for (i = 0; i < target_binlen; i++) {
      printf("0x%2X ", datastream[i]);
    }
    printf("\n");
  }
}


x86 assembly (clang, -O0):
<qr_binary>:
push   %rbp
mov    %rsp,%rbp
sub    $0xb0,%rsp
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%eax
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
mov    %r9d,-0x24(%rbp)
movl   $0x0,-0x28(%rbp)
movl   $0x0,-0x2c(%rbp)
movl   $0x1,-0x38(%rbp)
mov    0x18(%rbp),%eax
add    $0xc,%eax
mov    %rsp,%rcx
mov    %rcx,-0x58(%rbp)
mov    %rax,%rcx
add    $0xf,%rcx
and    $0xfffffffffffffff0,%rcx
mov    %rsp,%rdi
sub    %rcx,%rdi
mov    %rdi,-0xa0(%rbp)
mov    %rdi,%rsp
mov    %rax,-0x60(%rbp)
lea    0xee0(%rip),%rsi
call   1040 <strcpy@plt>
cmpl   $0x0,0x10(%rbp)
je     11f3 <qr_binary+0x93>
mov    -0xa0(%rbp),%rdi
lea    0xe4c(%rip),%rsi
mov    $0x0,%al
call   1070 <concat@plt>
cmpl   $0x9,-0xc(%rbp)
jg     1209 <qr_binary+0xa9>
movl   $0x1,-0x38(%rbp)
jmp    1244 <qr_binary+0xe4>
cmpl   $0xa,-0xc(%rbp)
jl     1229 <qr_binary+0xc9>
cmpl   $0x1a,-0xc(%rbp)
jg     1229 <qr_binary+0xc9>
movl   $0x2,-0x38(%rbp)
jmp    123f <qr_binary+0xdf>
cmpl   $0x1b,-0xc(%rbp)
jl     123a <qr_binary+0xda>
movl   $0x3,-0x38(%rbp)
jmp    123f <qr_binary+0xdf>
jmp    1244 <qr_binary+0xe4>
cmpl   $0x0,-0x2c(%rbp)
je     1297 <qr_binary+0x137>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1289 <qr_binary+0x129>
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsbl (%rax,%rcx,1),%esi
lea    0xdc9(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1255 <qr_binary+0xf5>
lea    0xdb0(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movl   $0x0,-0x4c(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x39(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%ecx
add    -0x28(%rbp),%ecx
xor    %eax,%eax
cmp    -0x24(%rbp),%ecx
mov    %al,-0xa1(%rbp)
jge    12f3 <qr_binary+0x193>
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
movsbl -0x39(%rbp),%ecx
cmp    %ecx,%eax
sete   %al
mov    %al,-0xa1(%rbp)
mov    -0xa1(%rbp),%al
test   $0x1,%al
jne    12b3 <qr_binary+0x153>
movsbl -0x39(%rbp),%eax
add    $0xffffffbf,%eax
mov    %eax,%ecx
mov    %rcx,-0xb0(%rbp)
sub    $0xd,%eax
ja     1b2d <qr_binary+0x9cd>
mov    -0xb0(%rbp),%rax
lea    0xcd8(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0xa0(%rbp),%rdi
lea    0xd03(%rip),%rsi
mov    $0x0,%al
call   1070 <concat@plt>
mov    -0xa0(%rbp),%rdi
mov    -0x30(%rbp),%esi
mov    -0x38(%rbp),%ecx
shl    $0x1,%ecx
mov    $0x20,%edx
shl    %cl,%edx
mov    $0x0,%al
call   1030 <diran@plt>
cmpl   $0x0,-0x2c(%rbp)
je     137f <qr_binary+0x21f>
mov    -0x30(%rbp),%esi
lea    0xccf(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    1427 <qr_binary+0x2c7>
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x64(%rbp)
cmpl   $0x9fff,-0x64(%rbp)
jle    13bd <qr_binary+0x25d>
mov    -0x64(%rbp),%eax
sub    $0xc140,%eax
mov    %eax,-0x64(%rbp)
mov    -0xa0(%rbp),%rdi
mov    -0x64(%rbp),%eax
and    $0xff00,%eax
sar    $0x4,%eax
mov    %eax,-0x68(%rbp)
mov    -0x64(%rbp),%eax
and    $0xff,%eax
mov    %eax,-0x6c(%rbp)
imul   $0xc0,-0x68(%rbp),%eax
add    -0x6c(%rbp),%eax
mov    %eax,-0x70(%rbp)
mov    -0x70(%rbp),%esi
mov    $0x1000,%edx
mov    $0x0,%al
call   1030 <diran@plt>
cmpl   $0x0,-0x2c(%rbp)
je     1414 <qr_binary+0x2b4>
mov    -0x70(%rbp),%esi
lea    0xc54(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
jmp    1419 <qr_binary+0x2b9>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1386 <qr_binary+0x226>
cmpl   $0x0,-0x2c(%rbp)
je     143f <qr_binary+0x2df>
lea    0xc08(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
jmp    1b2d <qr_binary+0x9cd>
mov    -0xa0(%rbp),%rdi
lea    0xc16(%rip),%rsi
mov    $0x0,%al
call   1070 <concat@plt>
mov    -0xa0(%rbp),%rdi
mov    -0x30(%rbp),%esi
mov    -0x38(%rbp),%ecx
mov    $0x80,%edx
mov    $0x8000,%eax
cmp    $0x1,%ecx
cmovg  %eax,%edx
mov    $0x0,%al
call   1030 <diran@plt>
cmpl   $0x0,-0x2c(%rbp)
je     1498 <qr_binary+0x338>
mov    -0x30(%rbp),%esi
lea    0xbdc(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    1520 <qr_binary+0x3c0>
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x74(%rbp)
cmpl   $0x0,0x10(%rbp)
je     14d9 <qr_binary+0x379>
cmpl   $0x5b,-0x74(%rbp)
jne    14d9 <qr_binary+0x379>
movl   $0x1d,-0x74(%rbp)
mov    -0xa0(%rbp),%rdi
mov    -0x74(%rbp),%esi
mov    $0x80,%edx
mov    $0x0,%al
call   1030 <diran@plt>
cmpl   $0x0,-0x2c(%rbp)
je     150d <qr_binary+0x3ad>
mov    -0x74(%rbp),%esi
mov    -0x74(%rbp),%edx
lea    0xb80(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
jmp    1512 <qr_binary+0x3b2>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    149f <qr_binary+0x33f>
cmpl   $0x0,-0x2c(%rbp)
je     1538 <qr_binary+0x3d8>
lea    0xb0f(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
jmp    1b2d <qr_binary+0x9cd>
mov    -0xa0(%rbp),%rdi
lea    0xb46(%rip),%rsi
mov    $0x0,%al
call   1070 <concat@plt>
mov    -0xa0(%rbp),%rdi
mov    -0x30(%rbp),%esi
mov    -0x38(%rbp),%ecx
shl    $0x1,%ecx
mov    $0x40,%edx
shl    %cl,%edx
mov    $0x0,%al
call   1030 <diran@plt>
cmpl   $0x0,-0x2c(%rbp)
je     158b <qr_binary+0x42b>
mov    -0x30(%rbp),%esi
lea    0xb12(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    1913 <qr_binary+0x7b3>
movl   $0x0,-0x7c(%rbp)
movl   $0x0,-0x80(%rbp)
cmpl   $0x0,-0x4c(%rbp)
jne    179b <qr_binary+0x63b>
cmpl   $0x0,0x10(%rbp)
je     1625 <qr_binary+0x4c5>
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
cmpl   $0x25,(%rax,%rcx,4)
jne    1625 <qr_binary+0x4c5>
lea    0xad2(%rip),%rdi
mov    $0x25,%esi
mov    $0x0,%al
call   1080 <posn@plt>
mov    %eax,-0x7c(%rbp)
lea    0xabc(%rip),%rdi
mov    $0x25,%esi
mov    $0x0,%al
call   1080 <posn@plt>
mov    %eax,-0x80(%rbp)
movl   $0x2,-0x78(%rbp)
imul   $0x2d,-0x7c(%rbp),%eax
add    -0x80(%rbp),%eax
mov    %eax,-0x84(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1796 <qr_binary+0x636>
cmpl   $0x0,0x10(%rbp)
je     1661 <qr_binary+0x501>
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
cmpl   $0x5b,(%rax,%rcx,4)
jne    1661 <qr_binary+0x501>
lea    0xa63(%rip),%rdi
mov    $0x25,%esi
mov    $0x0,%al
call   1080 <posn@plt>
mov    %eax,-0x7c(%rbp)
jmp    1685 <qr_binary+0x525>
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
movsbl %al,%esi
lea    0xa35(%rip),%rdi
mov    $0x0,%al
call   1080 <posn@plt>
mov    %eax,-0x7c(%rbp)
movl   $0x1,-0x78(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x7c(%rbp),%eax
mov    %eax,-0x84(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x41,%eax
jne    1791 <qr_binary+0x631>
cmpl   $0x0,0x10(%rbp)
je     170f <qr_binary+0x5af>
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
cmpl   $0x25,(%rax,%rcx,4)
jne    170f <qr_binary+0x5af>
lea    0x9d0(%rip),%rdi
mov    $0x25,%esi
mov    $0x0,%al
call   1080 <posn@plt>
mov    %eax,-0x80(%rbp)
movl   $0x2,-0x78(%rbp)
imul   $0x2d,-0x7c(%rbp),%eax
add    -0x80(%rbp),%eax
mov    %eax,-0x84(%rbp)
movl   $0x1,-0x4c(%rbp)
jmp    178c <qr_binary+0x62c>
cmpl   $0x0,0x10(%rbp)
je     174b <qr_binary+0x5eb>
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
cmpl   $0x5b,(%rax,%rcx,4)
jne    174b <qr_binary+0x5eb>
lea    0x979(%rip),%rdi
mov    $0x25,%esi
mov    $0x0,%al
call   1080 <posn@plt>
mov    %eax,-0x80(%rbp)
jmp    176f <qr_binary+0x60f>
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
movsbl %al,%esi
lea    0x94b(%rip),%rdi
mov    $0x0,%al
call   1080 <posn@plt>
mov    %eax,-0x80(%rbp)
movl   $0x2,-0x78(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
imul   $0x2d,-0x7c(%rbp),%eax
add    -0x80(%rbp),%eax
mov    %eax,-0x84(%rbp)
jmp    1791 <qr_binary+0x631>
jmp    1796 <qr_binary+0x636>
jmp    18c9 <qr_binary+0x769>
lea    0x90e(%rip),%rdi
mov    $0x25,%esi
mov    $0x0,%al
call   1080 <posn@plt>
mov    %eax,-0x7c(%rbp)
movl   $0x1,-0x78(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x7c(%rbp),%eax
mov    %eax,-0x84(%rbp)
movl   $0x0,-0x4c(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x41,%eax
jne    18c4 <qr_binary+0x764>
cmpl   $0x0,0x10(%rbp)
je     1842 <qr_binary+0x6e2>
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
cmpl   $0x25,(%rax,%rcx,4)
jne    1842 <qr_binary+0x6e2>
lea    0x89d(%rip),%rdi
mov    $0x25,%esi
mov    $0x0,%al
call   1080 <posn@plt>
mov    %eax,-0x80(%rbp)
movl   $0x2,-0x78(%rbp)
imul   $0x2d,-0x7c(%rbp),%eax
add    -0x80(%rbp),%eax
mov    %eax,-0x84(%rbp)
movl   $0x1,-0x4c(%rbp)
jmp    18bf <qr_binary+0x75f>
cmpl   $0x0,0x10(%rbp)
je     187e <qr_binary+0x71e>
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
cmpl   $0x5b,(%rax,%rcx,4)
jne    187e <qr_binary+0x71e>
lea    0x846(%rip),%rdi
mov    $0x25,%esi
mov    $0x0,%al
call   1080 <posn@plt>
mov    %eax,-0x80(%rbp)
jmp    18a2 <qr_binary+0x742>
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
movsbl %al,%esi
lea    0x818(%rip),%rdi
mov    $0x0,%al
call   1080 <posn@plt>
mov    %eax,-0x80(%rbp)
movl   $0x2,-0x78(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
imul   $0x2d,-0x7c(%rbp),%eax
add    -0x80(%rbp),%eax
mov    %eax,-0x84(%rbp)
jmp    18c4 <qr_binary+0x764>
jmp    18c9 <qr_binary+0x769>
mov    -0xa0(%rbp),%rdi
mov    -0x84(%rbp),%esi
mov    -0x78(%rbp),%ecx
mov    $0x20,%edx
mov    $0x400,%eax
cmp    $0x2,%ecx
cmove  %eax,%edx
mov    $0x0,%al
call   1030 <diran@plt>
cmpl   $0x0,-0x2c(%rbp)
je     190e <qr_binary+0x7ae>
mov    -0x84(%rbp),%esi
lea    0x75a(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
jmp    1592 <qr_binary+0x432>
cmpl   $0x0,-0x2c(%rbp)
je     192b <qr_binary+0x7cb>
lea    0x71c(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
jmp    1b2d <qr_binary+0x9cd>
mov    -0xa0(%rbp),%rdi
lea    0x7a0(%rip),%rsi
mov    $0x0,%al
call   1070 <concat@plt>
mov    -0xa0(%rbp),%rdi
mov    -0x30(%rbp),%esi
mov    -0x38(%rbp),%ecx
shl    $0x1,%ecx
mov    $0x80,%edx
shl    %cl,%edx
mov    $0x0,%al
call   1030 <diran@plt>
cmpl   $0x0,-0x2c(%rbp)
je     197e <qr_binary+0x81e>
mov    -0x30(%rbp),%esi
lea    0x76c(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    1b10 <qr_binary+0x9b0>
movl   $0x0,-0x8c(%rbp)
movl   $0x0,-0x90(%rbp)
movl   $0x0,-0x94(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
movsbl %al,%esi
lea    0x735(%rip),%rdi
mov    $0x0,%al
call   1080 <posn@plt>
mov    %eax,-0x8c(%rbp)
movl   $0x1,-0x88(%rbp)
mov    -0x8c(%rbp),%eax
mov    %eax,-0x98(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x4e,%eax
jne    1ab9 <qr_binary+0x959>
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
movsbl %al,%esi
lea    0x6d8(%rip),%rdi
mov    $0x0,%al
call   1080 <posn@plt>
mov    %eax,-0x90(%rbp)
movl   $0x2,-0x88(%rbp)
imul   $0xa,-0x98(%rbp),%eax
add    -0x90(%rbp),%eax
mov    %eax,-0x98(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    -0x34(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x4e,%eax
jne    1ab4 <qr_binary+0x954>
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    -0x34(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
movsbl %al,%esi
lea    0x674(%rip),%rdi
mov    $0x0,%al
call   1080 <posn@plt>
mov    %eax,-0x94(%rbp)
movl   $0x3,-0x88(%rbp)
imul   $0xa,-0x98(%rbp),%eax
add    -0x94(%rbp),%eax
mov    %eax,-0x98(%rbp)
jmp    1ab9 <qr_binary+0x959>
mov    -0xa0(%rbp),%rdi
mov    -0x98(%rbp),%esi
imul   $0x3,-0x88(%rbp),%ecx
mov    $0x1,%edx
shl    %cl,%edx
mov    $0x0,%al
call   1030 <diran@plt>
cmpl   $0x0,-0x2c(%rbp)
je     1aff <qr_binary+0x99f>
mov    -0x98(%rbp),%esi
mov    -0x98(%rbp),%edx
lea    0x611(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
mov    -0x88(%rbp),%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x34(%rbp)
jmp    1985 <qr_binary+0x825>
cmpl   $0x0,-0x2c(%rbp)
je     1b28 <qr_binary+0x9c8>
lea    0x51f(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
jmp    1b2d <qr_binary+0x9cd>
mov    -0x30(%rbp),%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jl     129e <qr_binary+0x13e>
mov    -0xa0(%rbp),%rdi
lea    0x5c4(%rip),%rsi
mov    $0x0,%al
call   1070 <concat@plt>
mov    -0xa0(%rbp),%rdi
call   1050 <strlen@plt>
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
mov    $0x8,%ecx
cltd
idiv   %ecx
mov    $0x8,%eax
sub    %edx,%eax
mov    %al,-0x3a(%rbp)
movsbl -0x3a(%rbp),%eax
cmp    $0x8,%eax
jne    1b8c <qr_binary+0xa2c>
movb   $0x0,-0x3a(%rbp)
mov    -0x40(%rbp),%eax
movsbl -0x3a(%rbp),%ecx
add    %ecx,%eax
mov    $0x8,%ecx
cltd
idiv   %ecx
mov    %eax,-0x44(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
movsbl -0x3a(%rbp),%ecx
cmp    %ecx,%eax
jge    1bd9 <qr_binary+0xa79>
mov    -0xa0(%rbp),%rdi
lea    0x553(%rip),%rsi
mov    $0x0,%al
call   1070 <concat@plt>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1ba7 <qr_binary+0xa47>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    1d96 <qr_binary+0xc36>
mov    -0xa0(%rbp),%rax
mov    -0x8(%rbp),%rcx
movslq -0x34(%rbp),%rdx
movl   $0x0,(%rcx,%rdx,4)
mov    -0x34(%rbp),%ecx
shl    $0x3,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x31,%eax
jne    1c2c <qr_binary+0xacc>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
add    $0x80,%edx
mov    %edx,(%rax,%rcx,4)
mov    -0xa0(%rbp),%rax
mov    -0x34(%rbp),%ecx
shl    $0x3,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x31,%eax
jne    1c5d <qr_binary+0xafd>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
add    $0x40,%edx
mov    %edx,(%rax,%rcx,4)
mov    -0xa0(%rbp),%rax
mov    -0x34(%rbp),%ecx
shl    $0x3,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x31,%eax
jne    1c8e <qr_binary+0xb2e>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
add    $0x20,%edx
mov    %edx,(%rax,%rcx,4)
mov    -0xa0(%rbp),%rax
mov    -0x34(%rbp),%ecx
shl    $0x3,%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x31,%eax
jne    1cbf <qr_binary+0xb5f>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
add    $0x10,%edx
mov    %edx,(%rax,%rcx,4)
mov    -0xa0(%rbp),%rax
mov    -0x34(%rbp),%ecx
shl    $0x3,%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x31,%eax
jne    1cf0 <qr_binary+0xb90>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
add    $0x8,%edx
mov    %edx,(%rax,%rcx,4)
mov    -0xa0(%rbp),%rax
mov    -0x34(%rbp),%ecx
shl    $0x3,%ecx
add    $0x5,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x31,%eax
jne    1d21 <qr_binary+0xbc1>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
add    $0x4,%edx
mov    %edx,(%rax,%rcx,4)
mov    -0xa0(%rbp),%rax
mov    -0x34(%rbp),%ecx
shl    $0x3,%ecx
add    $0x6,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x31,%eax
jne    1d52 <qr_binary+0xbf2>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
add    $0x2,%edx
mov    %edx,(%rax,%rcx,4)
mov    -0xa0(%rbp),%rax
mov    -0x34(%rbp),%ecx
shl    $0x3,%ecx
add    $0x7,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x31,%eax
jne    1d83 <qr_binary+0xc23>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    %edx,(%rax,%rcx,4)
jmp    1d88 <qr_binary+0xc28>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1be0 <qr_binary+0xa80>
movl   $0x0,-0x48(%rbp)
mov    -0x44(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1dfd <qr_binary+0xc9d>
cmpl   $0x0,-0x48(%rbp)
jne    1dd4 <qr_binary+0xc74>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movl   $0xec,(%rax,%rcx,4)
movl   $0x1,-0x48(%rbp)
jmp    1dea <qr_binary+0xc8a>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movl   $0x11,(%rax,%rcx,4)
movl   $0x0,-0x48(%rbp)
jmp    1def <qr_binary+0xc8f>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1da3 <qr_binary+0xc43>
cmpl   $0x0,-0x2c(%rbp)
je     1e5d <qr_binary+0xcfd>
lea    0x30b(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1e4f <qr_binary+0xcef>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
lea    0x2f6(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1e1c <qr_binary+0xcbc>
lea    0x1ea(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
mov    -0x58(%rbp),%rax
mov    %rax,%rsp
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<qr_binary>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x68,%rsp
mov    %r9d,%r12d
mov    %r8,-0x38(%rbp)
mov    %rcx,%r15
mov    %edx,-0x54(%rbp)
mov    %esi,%r14d
mov    %rdi,-0x80(%rbp)
mov    0x18(%rbp),%eax
add    $0xc,%eax
mov    %rsp,%rcx
add    $0xf,%rax
and    $0xfffffffffffffff0,%rax
mov    %rcx,%r13
sub    %rax,%r13
mov    %r13,%rsp
neg    %rax
movb   $0x0,(%rcx,%rax,1)
cmpl   $0x0,0x10(%rbp)
je     119d <qr_binary+0x5d>
lea    0xeb5(%rip),%rsi
mov    %r13,%rdi
xor    %eax,%eax
call   1050 <concat@plt>
cmp    $0x1b,%r14d
setge  %al
add    %al,%al
or     $0x4,%al
cmp    $0xa,%r14d
mov    $0x80,%edx
mov    $0x8000,%ecx
cmovl  %edx,%ecx
mov    %ecx,-0x60(%rbp)
movzbl %al,%eax
mov    $0x2,%ecx
cmovge %eax,%ecx
shl    %cl,%edx
mov    %edx,-0x64(%rbp)
mov    $0x40,%eax
shl    %cl,%eax
mov    %eax,-0x5c(%rbp)
mov    $0x20,%eax
shl    %cl,%eax
mov    %eax,-0x58(%rbp)
lea    0x1(%r15),%rax
mov    %rax,-0x88(%rbp)
lea    0xe9d(%rip),%r14
movl   $0x0,-0x2c(%rbp)
xor    %eax,%eax
mov    %r13,-0x78(%rbp)
mov    %r12d,-0x68(%rbp)
mov    %r15,-0x48(%rbp)
jmp    1234 <qr_binary+0xf4>
nopl   0x0(%rax)
mov    -0x78(%rbp),%r13
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    -0x68(%rbp),%r12d
mov    -0x6c(%rbp),%eax
cmp    %r12d,%eax
mov    -0x48(%rbp),%r15
jge    170c <qr_binary+0x5cc>
mov    %eax,%edx
mov    %eax,%ebx
movsbl (%r15,%rbx,1),%eax
lea    0x1(%rdx),%r8d
cmp    %r8d,%r12d
cmovg  %r12d,%r8d
not    %edx
add    %r8d,%edx
lea    0x1(%rdx),%r15
mov    %rdx,-0x50(%rbp)
neg    %rdx
mov    -0x88(%rbp),%rsi
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
cmp    %rcx,%rdx
je     1298 <qr_binary+0x158>
add    $0xffffffffffffffff,%rcx
lea    0x1(%rsi),%rdi
cmp    %al,(%rsi,%rbx,1)
mov    %rdi,%rsi
je     1270 <qr_binary+0x130>
mov    %ebx,%r8d
sub    %ecx,%r8d
mov    %rcx,%r15
neg    %r15
not    %rcx
mov    %rcx,-0x50(%rbp)
mov    %r8d,-0x6c(%rbp)
add    $0xffffffbf,%eax
cmp    $0xd,%eax
ja     1220 <qr_binary+0xe0>
mov    %rbx,-0x40(%rbp)
lea    0xd5d(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
xor    %r12d,%r12d
mov    %r13,%rdi
lea    0xd8e(%rip),%rsi
xor    %eax,%eax
call   1050 <concat@plt>
mov    %r13,%rdi
mov    %r15d,%esi
mov    -0x5c(%rbp),%edx
xor    %eax,%eax
call   1030 <diran@plt>
jmp    1309 <qr_binary+0x1c9>
mov    $0x20,%edx
nopw   0x0(%rax,%rax,1)
mov    %r13,%rdi
mov    %r15d,%esi
xor    %eax,%eax
call   1030 <diran@plt>
mov    %ebx,%r12d
cmp    -0x50(%rbp),%ebx
jg     1220 <qr_binary+0xe0>
cmpl   $0x0,-0x2c(%rbp)
jne    13e0 <qr_binary+0x2a0>
mov    -0x40(%rbp),%rdx
lea    (%r12,%rdx,1),%eax
cltq
mov    -0x38(%rbp),%rcx
mov    (%rcx,%rax,4),%eax
cmpl   $0x0,0x10(%rbp)
je     1380 <qr_binary+0x240>
cmp    $0x5b,%eax
je     1475 <qr_binary+0x335>
cmp    $0x25,%eax
jne    1380 <qr_binary+0x240>
movl   $0x0,-0x2c(%rbp)
lea    0xd16(%rip),%r14
mov    %r14,%rdi
mov    $0x25,%esi
xor    %eax,%eax
call   1060 <posn@plt>
mov    %eax,%ebx
mov    %r14,%rdi
lea    0xd2e(%rip),%r14
mov    $0x25,%esi
xor    %eax,%eax
call   1060 <posn@plt>
lea    (%rbx,%rbx,8),%ecx
lea    (%rcx,%rcx,4),%r15d
add    %eax,%r15d
add    $0x1,%r12d
jmp    14fc <qr_binary+0x3bc>
movsbl %al,%esi
movl   $0x0,-0x2c(%rbp)
lea    0xccb(%rip),%rdi
xor    %eax,%eax
call   1060 <posn@plt>
mov    %eax,%r15d
lea    0x1(%r12),%ebx
mov    -0x40(%rbp),%rax
add    %r12d,%eax
add    $0x1,%eax
cltq
mov    $0x20,%edx
mov    -0x48(%rbp),%rcx
cmpb   $0x41,(%rcx,%rax,1)
jne    12f0 <qr_binary+0x1b0>
cmpl   $0x0,0x10(%rbp)
jne    14c3 <qr_binary+0x383>
mov    -0x38(%rbp),%rcx
mov    (%rcx,%rax,4),%eax
jmp    1470 <qr_binary+0x330>
cs nopw 0x0(%rax,%rax,1)
nop
movl   $0x0,-0x2c(%rbp)
lea    0xc6e(%rip),%rdi
mov    $0x25,%esi
xor    %eax,%eax
call   1060 <posn@plt>
mov    %eax,%r15d
lea    0x1(%r12),%ebx
mov    -0x40(%rbp),%rax
add    %r12d,%eax
add    $0x1,%eax
cltq
mov    -0x48(%rbp),%rcx
cmpb   $0x41,(%rcx,%rax,1)
jne    12e2 <qr_binary+0x1a2>
mov    -0x38(%rbp),%rcx
mov    (%rcx,%rax,4),%eax
cmpl   $0x0,0x10(%rbp)
je     1470 <qr_binary+0x330>
cmp    $0x5b,%eax
je     14d3 <qr_binary+0x393>
cmp    $0x25,%eax
jne    1470 <qr_binary+0x330>
lea    0xc1e(%rip),%rdi
mov    $0x25,%esi
xor    %eax,%eax
call   1060 <posn@plt>
lea    (%r15,%r15,8),%ecx
lea    (%rcx,%rcx,4),%r15d
add    %eax,%r15d
mov    $0x400,%edx
movl   $0x1,-0x2c(%rbp)
jmp    12f0 <qr_binary+0x1b0>
cs nopw 0x0(%rax,%rax,1)
movsbl %al,%esi
jmp    14d8 <qr_binary+0x398>
movl   $0x0,-0x2c(%rbp)
lea    0xbd9(%rip),%rdi
mov    $0x25,%esi
xor    %eax,%eax
mov    %r13,%r14
mov    %rdx,%r13
call   1060 <posn@plt>
mov    %eax,%r15d
lea    0x1(%r12),%ebx
lea    (%r12,%r13,1),%eax
add    $0x1,%eax
mov    %r14,%r13
lea    0xbe1(%rip),%r14
cltq
mov    $0x20,%edx
mov    -0x48(%rbp),%rcx
cmpb   $0x41,(%rcx,%rax,1)
jne    12f0 <qr_binary+0x1b0>
mov    -0x38(%rbp),%rcx
mov    (%rcx,%rax,4),%eax
cmp    $0x5b,%eax
jne    1432 <qr_binary+0x2f2>
mov    $0x25,%esi
movl   $0x0,-0x2c(%rbp)
lea    0xb76(%rip),%rdi
xor    %eax,%eax
call   1060 <posn@plt>
add    $0x2,%r12d
lea    (%r15,%r15,8),%ecx
lea    (%rcx,%rcx,4),%r15d
add    %eax,%r15d
mov    $0x400,%edx
mov    %r12d,%ebx
jmp    12f0 <qr_binary+0x1b0>
nopl   0x0(%rax)
mov    %r13,%rdi
lea    0xb38(%rip),%rsi
xor    %eax,%eax
call   1050 <concat@plt>
mov    %r13,%rdi
mov    %r15d,%esi
mov    -0x60(%rbp),%edx
xor    %eax,%eax
call   1030 <diran@plt>
mov    %r15d,%r15d
mov    -0x38(%rbp),%rax
mov    -0x40(%rbp),%rcx
lea    (%rax,%rcx,4),%r14
xor    %ebx,%ebx
mov    0x10(%rbp),%r12d
cs nopw 0x0(%rax,%rax,1)
mov    (%r14,%rbx,4),%eax
cmp    $0x5b,%eax
mov    %eax,%esi
mov    $0x1d,%ecx
cmove  %ecx,%esi
test   %r12d,%r12d
cmove  %eax,%esi
mov    %r13,%rdi
mov    $0x80,%edx
xor    %eax,%eax
call   1030 <diran@plt>
add    $0x1,%rbx
cmp    %rbx,%r15
jne    1550 <qr_binary+0x410>
jmp    160b <qr_binary+0x4cb>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %r13,%rdi
lea    0xab3(%rip),%rsi
xor    %eax,%eax
call   1050 <concat@plt>
mov    %r13,%rdi
mov    %r15d,%esi
mov    -0x58(%rbp),%edx
xor    %eax,%eax
call   1030 <diran@plt>
mov    %r15d,%r15d
mov    -0x38(%rbp),%rax
mov    -0x40(%rbp),%rcx
lea    (%rax,%rcx,4),%r14
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    (%r14,%rbx,4),%eax
lea    -0xc140(%rax),%ecx
cmp    $0xa000,%eax
cmovl  %eax,%ecx
movzbl %cl,%eax
shl    $0x2,%ecx
and    $0x3fc00,%ecx
lea    (%rcx,%rcx,2),%esi
or     %eax,%esi
mov    %r13,%rdi
mov    $0x1000,%edx
xor    %eax,%eax
call   1030 <diran@plt>
add    $0x1,%rbx
cmp    %rbx,%r15
jne    15d0 <qr_binary+0x490>
lea    0xa7d(%rip),%r14
jmp    1220 <qr_binary+0xe0>
nopw   0x0(%rax,%rax,1)
xor    %r12d,%r12d
mov    %r13,%rdi
lea    0xa5d(%rip),%rsi
xor    %eax,%eax
call   1050 <concat@plt>
mov    %r13,%rdi
mov    %r15d,%esi
mov    -0x64(%rbp),%edx
xor    %eax,%eax
call   1030 <diran@plt>
jmp    1680 <qr_binary+0x540>
cs nopw 0x0(%rax,%rax,1)
mov    $0x1,%r13d
mov    %rdi,%r14
lea    0x0(%r13,%r13,2),%ecx
mov    $0x1,%edx
shl    %cl,%edx
mov    -0x78(%rbp),%rdi
mov    %r15d,%esi
xor    %eax,%eax
call   1030 <diran@plt>
add    %r13d,%r12d
cmp    -0x50(%rbp),%r12d
ja     1210 <qr_binary+0xd0>
mov    %r12d,%ebx
add    -0x40(%rbp),%rbx
mov    %ebx,%eax
mov    -0x38(%rbp),%r13
movsbl 0x0(%r13,%rax,4),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1060 <posn@plt>
mov    %eax,%r15d
mov    %r14,%rdi
mov    -0x48(%rbp),%r14
cmpb   $0x4e,0x1(%r14,%rbx,1)
jne    1650 <qr_binary+0x510>
movsbl 0x4(%r13,%rbx,4),%esi
xor    %eax,%eax
call   1060 <posn@plt>
lea    (%r15,%r15,4),%ecx
lea    (%rax,%rcx,2),%r15d
mov    %r13,%rax
mov    $0x2,%r13d
cmpb   $0x4e,0x2(%rbx,%r14,1)
jne    1700 <qr_binary+0x5c0>
movsbl 0x8(%rax,%rbx,4),%esi
lea    0x9ae(%rip),%r14
mov    %r14,%rdi
xor    %eax,%eax
call   1060 <posn@plt>
lea    (%r15,%r15,4),%ecx
lea    (%rax,%rcx,2),%r15d
mov    $0x3,%r13d
jmp    1659 <qr_binary+0x519>
xchg   %ax,%ax
lea    0x988(%rip),%r14
jmp    1659 <qr_binary+0x519>
lea    0x987(%rip),%rsi
xor    %r14d,%r14d
mov    %r13,%rdi
xor    %eax,%eax
call   1050 <concat@plt>
mov    %r13,%rdi
call   1040 <strlen@plt>
lea    0x7(%rax),%ecx
test   %eax,%eax
cmovns %eax,%ecx
and    $0xfffffff8,%ecx
mov    %eax,%edx
sub    %ecx,%edx
mov    $0x8,%ebx
sub    %edx,%ebx
test   %dl,%dl
cmove  %r14d,%ebx
mov    %ebx,%r12d
add    %eax,%r12d
lea    0x7(%rbx,%rax,1),%r14d
cmovns %r12d,%r14d
test   %ebx,%ebx
je     1772 <qr_binary+0x632>
lea    0x93f(%rip),%r15
xchg   %ax,%ax
mov    %r13,%rdi
mov    %r15,%rsi
xor    %eax,%eax
call   1050 <concat@plt>
add    $0xffffffff,%ebx
jne    1760 <qr_binary+0x620>
sar    $0x3,%r14d
cmp    $0x8,%r12d
mov    -0x80(%rbp),%rdi
jl     1851 <qr_binary+0x711>
mov    %r14d,%eax
xor    %ecx,%ecx
jmp    179d <qr_binary+0x65d>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rcx
cmp    %rcx,%rax
je     1851 <qr_binary+0x711>
xor    %edx,%edx
cmpb   $0x31,0x0(%r13,%rcx,8)
sete   %dl
shl    $0x7,%edx
mov    %edx,(%rdi,%rcx,4)
cmpb   $0x31,0x1(%r13,%rcx,8)
jne    1800 <qr_binary+0x6c0>
or     $0x40,%edx
mov    %edx,(%rdi,%rcx,4)
cmpb   $0x31,0x2(%r13,%rcx,8)
je     1808 <qr_binary+0x6c8>
cmpb   $0x31,0x3(%r13,%rcx,8)
jne    1816 <qr_binary+0x6d6>
add    $0x10,%edx
mov    %edx,(%rdi,%rcx,4)
cmpb   $0x31,0x4(%r13,%rcx,8)
je     181e <qr_binary+0x6de>
cmpb   $0x31,0x5(%r13,%rcx,8)
jne    182c <qr_binary+0x6ec>
add    $0x4,%edx
mov    %edx,(%rdi,%rcx,4)
cmpb   $0x31,0x6(%r13,%rcx,8)
je     1834 <qr_binary+0x6f4>
cmpb   $0x31,0x7(%r13,%rcx,8)
jne    1790 <qr_binary+0x650>
jmp    1846 <qr_binary+0x706>
nopw   0x0(%rax,%rax,1)
cmpb   $0x31,0x2(%r13,%rcx,8)
jne    17c4 <qr_binary+0x684>
add    $0x20,%edx
mov    %edx,(%rdi,%rcx,4)
cmpb   $0x31,0x3(%r13,%rcx,8)
je     17cc <qr_binary+0x68c>
cmpb   $0x31,0x4(%r13,%rcx,8)
jne    17da <qr_binary+0x69a>
add    $0x8,%edx
mov    %edx,(%rdi,%rcx,4)
cmpb   $0x31,0x5(%r13,%rcx,8)
je     17e2 <qr_binary+0x6a2>
cmpb   $0x31,0x6(%r13,%rcx,8)
jne    17f0 <qr_binary+0x6b0>
add    $0x2,%edx
mov    %edx,(%rdi,%rcx,4)
cmpb   $0x31,0x7(%r13,%rcx,8)
jne    1790 <qr_binary+0x650>
add    $0x1,%edx
mov    %edx,(%rdi,%rcx,4)
jmp    1790 <qr_binary+0x650>
mov    -0x54(%rbp),%eax
cmp    %eax,%r14d
jge    18c9 <qr_binary+0x789>
movslq %r14d,%rcx
movslq %eax,%rdx
mov    %rcx,%rsi
not    %rsi
add    %rdx,%rsi
sub    %rcx,%rdx
mov    %edx,%eax
and    $0x3,%eax
cmp    $0x3,%rsi
jb     189e <qr_binary+0x75e>
and    $0xfffffffffffffffc,%rdx
movaps 0x77f(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movups %xmm0,(%rdi,%rcx,4)
add    $0x4,%rcx
add    $0xfffffffffffffffc,%rdx
jne    1890 <qr_binary+0x750>
test   %rax,%rax
je     18c9 <qr_binary+0x789>
lea    (%rdi,%rcx,4),%rcx
xor    %edx,%edx
mov    $0xec,%esi
xor    %edi,%edi
test   %edx,%edx
mov    $0x11,%ebx
cmove  %esi,%ebx
xor    $0x1,%edx
mov    %ebx,(%rcx,%rdi,4)
add    $0x1,%rdi
cmp    %rdi,%rax
jne    18b0 <qr_binary+0x770>
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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