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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int posn(char *, char);
int /*<<< orphan*/ printf(char *, ...);
int /*<<< orphan*/ qr_diran(char *, int, int);
int /*<<< orphan*/ strcat(char *, char *);
int /*<<< orphan*/ strcpy(char *, char *);
int strlen(char *);
void qr_binary(int datastream[], int version, int target_binlen, char mode[],
               int jisdata[], int length, int gs1, int eci, 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) {
    strcat(binary, "0101");
  }
  if (eci != 3) {
    strcat(binary, "0111");
    qr_diran(binary, eci, 0x80);
  }
  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':
      strcat(binary, "1000");
      qr_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;
        qr_diran(binary, prod, 0x1000);
        if (debug) {
          printf("0x%4X ", prod);
        }
      }
      if (debug) {
        printf("\n");
      }
      break;
    case 'B':
      strcat(binary, "0100");
      qr_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;
        }
        qr_diran(binary, byte, 0x80);
        if (debug) {
          printf("0x%2X(%d) ", byte, byte);
        }
      }
      if (debug) {
        printf("\n");
      }
      break;
    case 'A':
      strcat(binary, "0010");
      qr_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 (i < short_data_block_length && 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 (i < short_data_block_length && 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;
            }
          }
        }
        qr_diran(binary, prod, count == 2 ? 0x400 : 0x20);
        if (debug) {
          printf("0x%4X ", prod);
        }
      };
      if (debug) {
        printf("\n");
      }
      break;
    case 'N':
      strcat(binary, "0001");
      qr_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 (i + 1 < short_data_block_length && mode[position + i + 1] == 'N') {
          second = posn("0123456789", (char)jisdata[position + i + 1]);
          count = 2;
          prod = (prod * 10) + second;
          if (i + 2 < short_data_block_length &&
              mode[position + i + 2] == 'N') {
            third = posn("0123456789", (char)jisdata[position + i + 2]);
            count = 3;
            prod = (prod * 10) + third;
          }
        }
        qr_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);
  strcat(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++) {
    strcat(binary, "0");
  }
  for (i = 0; i < current_bytes; i++) {
    int p;
    datastream[i] = 0x00;
    for (p = 0; p < 8; p++) {
      if (binary[i * 8 + p] == '1') {
        datastream[i] += (0x80 >> p);
      }
    }
  }
  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    $0xc0,%rsp
mov    0x20(%rbp),%eax
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    0x20(%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,-0xa8(%rbp)
mov    %rdi,%rsp
mov    %rax,-0x60(%rbp)
lea    0xee2(%rip),%rsi
call   1030 <strcpy@plt>
cmpl   $0x0,0x10(%rbp)
je     11f4 <qr_binary+0x94>
mov    -0xa8(%rbp),%rdi
lea    0xe49(%rip),%rsi
call   1080 <strcat@plt>
cmpl   $0x3,0x18(%rbp)
je     1225 <qr_binary+0xc5>
mov    -0xa8(%rbp),%rdi
lea    0xe31(%rip),%rsi
call   1080 <strcat@plt>
mov    -0xa8(%rbp),%rdi
mov    0x18(%rbp),%esi
mov    $0x80,%edx
call   1070 <qr_diran@plt>
cmpl   $0x9,-0xc(%rbp)
jg     123b <qr_binary+0xdb>
movl   $0x1,-0x38(%rbp)
jmp    1276 <qr_binary+0x116>
cmpl   $0xa,-0xc(%rbp)
jl     125b <qr_binary+0xfb>
cmpl   $0x1a,-0xc(%rbp)
jg     125b <qr_binary+0xfb>
movl   $0x2,-0x38(%rbp)
jmp    1271 <qr_binary+0x111>
cmpl   $0x1b,-0xc(%rbp)
jl     126c <qr_binary+0x10c>
movl   $0x3,-0x38(%rbp)
jmp    1271 <qr_binary+0x111>
jmp    1276 <qr_binary+0x116>
cmpl   $0x0,-0x2c(%rbp)
je     12c9 <qr_binary+0x169>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    12bb <qr_binary+0x15b>
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsbl (%rax,%rcx,1),%esi
lea    0xd9c(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1287 <qr_binary+0x127>
lea    0xd83(%rip),%rdi
mov    $0x0,%al
call   1050 <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,-0xa9(%rbp)
jge    1325 <qr_binary+0x1c5>
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,-0xa9(%rbp)
mov    -0xa9(%rbp),%al
test   $0x1,%al
jne    12e5 <qr_binary+0x185>
movsbl -0x39(%rbp),%eax
add    $0xffffffbf,%eax
mov    %eax,%ecx
mov    %rcx,-0xb8(%rbp)
sub    $0xd,%eax
ja     1b61 <qr_binary+0xa01>
mov    -0xb8(%rbp),%rax
lea    0xca6(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0xa8(%rbp),%rdi
lea    0xcd6(%rip),%rsi
call   1080 <strcat@plt>
mov    -0xa8(%rbp),%rdi
mov    -0x30(%rbp),%esi
mov    -0x38(%rbp),%ecx
shl    $0x1,%ecx
mov    $0x20,%edx
shl    %cl,%edx
call   1070 <qr_diran@plt>
cmpl   $0x0,-0x2c(%rbp)
je     13ad <qr_binary+0x24d>
mov    -0x30(%rbp),%esi
lea    0xca6(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    1453 <qr_binary+0x2f3>
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    13eb <qr_binary+0x28b>
mov    -0x64(%rbp),%eax
sub    $0xc140,%eax
mov    %eax,-0x64(%rbp)
mov    -0xa8(%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
call   1070 <qr_diran@plt>
cmpl   $0x0,-0x2c(%rbp)
je     1440 <qr_binary+0x2e0>
mov    -0x70(%rbp),%esi
lea    0xc2d(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    1445 <qr_binary+0x2e5>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    13b4 <qr_binary+0x254>
cmpl   $0x0,-0x2c(%rbp)
je     146b <qr_binary+0x30b>
lea    0xbe1(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    1b61 <qr_binary+0xa01>
mov    -0xa8(%rbp),%rdi
lea    0xbef(%rip),%rsi
call   1080 <strcat@plt>
mov    -0xa8(%rbp),%rdi
mov    -0x30(%rbp),%esi
mov    -0x38(%rbp),%ecx
mov    $0x80,%edx
mov    $0x8000,%eax
cmp    $0x1,%ecx
cmovg  %eax,%edx
call   1070 <qr_diran@plt>
cmpl   $0x0,-0x2c(%rbp)
je     14c0 <qr_binary+0x360>
mov    -0x30(%rbp),%esi
lea    0xbb9(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    1546 <qr_binary+0x3e6>
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     1501 <qr_binary+0x3a1>
cmpl   $0x5b,-0x74(%rbp)
jne    1501 <qr_binary+0x3a1>
movl   $0x1d,-0x74(%rbp)
mov    -0xa8(%rbp),%rdi
mov    -0x74(%rbp),%esi
mov    $0x80,%edx
call   1070 <qr_diran@plt>
cmpl   $0x0,-0x2c(%rbp)
je     1533 <qr_binary+0x3d3>
mov    -0x74(%rbp),%esi
mov    -0x74(%rbp),%edx
lea    0xb5f(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    1538 <qr_binary+0x3d8>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    14c7 <qr_binary+0x367>
cmpl   $0x0,-0x2c(%rbp)
je     155e <qr_binary+0x3fe>
lea    0xaee(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    1b61 <qr_binary+0xa01>
mov    -0xa8(%rbp),%rdi
lea    0xb25(%rip),%rsi
call   1080 <strcat@plt>
mov    -0xa8(%rbp),%rdi
mov    -0x30(%rbp),%esi
mov    -0x38(%rbp),%ecx
shl    $0x1,%ecx
mov    $0x40,%edx
shl    %cl,%edx
call   1070 <qr_diran@plt>
cmpl   $0x0,-0x2c(%rbp)
je     15ad <qr_binary+0x44d>
mov    -0x30(%rbp),%esi
lea    0xaf5(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    1935 <qr_binary+0x7d5>
movl   $0x0,-0x7c(%rbp)
movl   $0x0,-0x80(%rbp)
cmpl   $0x0,-0x4c(%rbp)
jne    17bb <qr_binary+0x65b>
cmpl   $0x0,0x10(%rbp)
je     1643 <qr_binary+0x4e3>
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
cmpl   $0x25,(%rax,%rcx,4)
jne    1643 <qr_binary+0x4e3>
lea    0xab5(%rip),%rdi
mov    $0x25,%esi
call   1060 <posn@plt>
mov    %eax,-0x7c(%rbp)
lea    0xaa1(%rip),%rdi
mov    $0x25,%esi
call   1060 <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    17b6 <qr_binary+0x656>
cmpl   $0x0,0x10(%rbp)
je     167d <qr_binary+0x51d>
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
cmpl   $0x5b,(%rax,%rcx,4)
jne    167d <qr_binary+0x51d>
lea    0xa4a(%rip),%rdi
mov    $0x25,%esi
call   1060 <posn@plt>
mov    %eax,-0x7c(%rbp)
jmp    169f <qr_binary+0x53f>
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
lea    0xa21(%rip),%rdi
movsbl %al,%esi
call   1060 <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    -0x34(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    17b1 <qr_binary+0x651>
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x41,%eax
jne    17b1 <qr_binary+0x651>
cmpl   $0x0,0x10(%rbp)
je     1733 <qr_binary+0x5d3>
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
cmpl   $0x25,(%rax,%rcx,4)
jne    1733 <qr_binary+0x5d3>
lea    0x9af(%rip),%rdi
mov    $0x25,%esi
call   1060 <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    17ac <qr_binary+0x64c>
cmpl   $0x0,0x10(%rbp)
je     176d <qr_binary+0x60d>
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
cmpl   $0x5b,(%rax,%rcx,4)
jne    176d <qr_binary+0x60d>
lea    0x95a(%rip),%rdi
mov    $0x25,%esi
call   1060 <posn@plt>
mov    %eax,-0x80(%rbp)
jmp    178f <qr_binary+0x62f>
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
lea    0x931(%rip),%rdi
movsbl %al,%esi
call   1060 <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    17b1 <qr_binary+0x651>
jmp    17b6 <qr_binary+0x656>
jmp    18ed <qr_binary+0x78d>
lea    0x8f3(%rip),%rdi
mov    $0x25,%esi
call   1060 <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    -0x34(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    18e8 <qr_binary+0x788>
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x41,%eax
jne    18e8 <qr_binary+0x788>
cmpl   $0x0,0x10(%rbp)
je     186a <qr_binary+0x70a>
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
cmpl   $0x25,(%rax,%rcx,4)
jne    186a <qr_binary+0x70a>
lea    0x878(%rip),%rdi
mov    $0x25,%esi
call   1060 <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    18e3 <qr_binary+0x783>
cmpl   $0x0,0x10(%rbp)
je     18a4 <qr_binary+0x744>
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
cmpl   $0x5b,(%rax,%rcx,4)
jne    18a4 <qr_binary+0x744>
lea    0x823(%rip),%rdi
mov    $0x25,%esi
call   1060 <posn@plt>
mov    %eax,-0x80(%rbp)
jmp    18c6 <qr_binary+0x766>
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
lea    0x7fa(%rip),%rdi
movsbl %al,%esi
call   1060 <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    18e8 <qr_binary+0x788>
jmp    18ed <qr_binary+0x78d>
mov    -0xa8(%rbp),%rdi
mov    -0x84(%rbp),%esi
mov    -0x78(%rbp),%ecx
mov    $0x20,%edx
mov    $0x400,%eax
cmp    $0x2,%ecx
cmove  %eax,%edx
call   1070 <qr_diran@plt>
cmpl   $0x0,-0x2c(%rbp)
je     1930 <qr_binary+0x7d0>
mov    -0x84(%rbp),%esi
lea    0x73d(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    15b4 <qr_binary+0x454>
cmpl   $0x0,-0x2c(%rbp)
je     194d <qr_binary+0x7ed>
lea    0x6ff(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    1b61 <qr_binary+0xa01>
mov    -0xa8(%rbp),%rdi
lea    0x783(%rip),%rsi
call   1080 <strcat@plt>
mov    -0xa8(%rbp),%rdi
mov    -0x30(%rbp),%esi
mov    -0x38(%rbp),%ecx
shl    $0x1,%ecx
mov    $0x80,%edx
shl    %cl,%edx
call   1070 <qr_diran@plt>
cmpl   $0x0,-0x2c(%rbp)
je     199c <qr_binary+0x83c>
mov    -0x30(%rbp),%esi
lea    0x753(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    1b44 <qr_binary+0x9e4>
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
lea    0x71f(%rip),%rdi
movsbl %al,%esi
call   1060 <posn@plt>
mov    %eax,-0x8c(%rbp)
movl   $0x1,-0x88(%rbp)
mov    -0x8c(%rbp),%eax
mov    %eax,-0x98(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
cmp    -0x30(%rbp),%eax
jge    1aef <qr_binary+0x98f>
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    1aef <qr_binary+0x98f>
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
lea    0x6b5(%rip),%rdi
movsbl %al,%esi
call   1060 <posn@plt>
mov    %eax,-0x90(%rbp)
movl   $0x2,-0x88(%rbp)
imul   $0xa,-0x98(%rbp),%eax
add    -0x90(%rbp),%eax
mov    %eax,-0x98(%rbp)
mov    -0x34(%rbp),%eax
add    $0x2,%eax
cmp    -0x30(%rbp),%eax
jge    1aea <qr_binary+0x98a>
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    1aea <qr_binary+0x98a>
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    -0x34(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
lea    0x644(%rip),%rdi
movsbl %al,%esi
call   1060 <posn@plt>
mov    %eax,-0x94(%rbp)
movl   $0x3,-0x88(%rbp)
imul   $0xa,-0x98(%rbp),%eax
add    -0x94(%rbp),%eax
mov    %eax,-0x98(%rbp)
jmp    1aef <qr_binary+0x98f>
mov    -0xa8(%rbp),%rdi
mov    -0x98(%rbp),%esi
imul   $0x3,-0x88(%rbp),%ecx
mov    $0x1,%edx
shl    %cl,%edx
call   1070 <qr_diran@plt>
cmpl   $0x0,-0x2c(%rbp)
je     1b33 <qr_binary+0x9d3>
mov    -0x98(%rbp),%esi
mov    -0x98(%rbp),%edx
lea    0x5e2(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x88(%rbp),%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x34(%rbp)
jmp    19a3 <qr_binary+0x843>
cmpl   $0x0,-0x2c(%rbp)
je     1b5c <qr_binary+0x9fc>
lea    0x4f0(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    1b61 <qr_binary+0xa01>
mov    -0x30(%rbp),%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jl     12d0 <qr_binary+0x170>
mov    -0xa8(%rbp),%rdi
lea    0x595(%rip),%rsi
call   1080 <strcat@plt>
mov    -0xa8(%rbp),%rdi
call   1040 <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    1bbe <qr_binary+0xa5e>
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    1c09 <qr_binary+0xaa9>
mov    -0xa8(%rbp),%rdi
lea    0x526(%rip),%rsi
call   1080 <strcat@plt>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1bd9 <qr_binary+0xa79>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    1cac <qr_binary+0xb4c>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
movl   $0x0,-0x9c(%rbp)
cmpl   $0x8,-0x9c(%rbp)
jge    1c99 <qr_binary+0xb39>
mov    -0xa8(%rbp),%rax
mov    -0x34(%rbp),%ecx
shl    $0x3,%ecx
add    -0x9c(%rbp),%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x31,%eax
jne    1c80 <qr_binary+0xb20>
mov    -0x9c(%rbp),%ecx
mov    $0x80,%edx
sar    %cl,%edx
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
add    (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
jmp    1c85 <qr_binary+0xb25>
mov    -0x9c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c(%rbp)
jmp    1c35 <qr_binary+0xad5>
jmp    1c9e <qr_binary+0xb3e>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1c10 <qr_binary+0xab0>
movl   $0x0,-0x48(%rbp)
mov    -0x44(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1d13 <qr_binary+0xbb3>
cmpl   $0x0,-0x48(%rbp)
jne    1cea <qr_binary+0xb8a>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movl   $0xec,(%rax,%rcx,4)
movl   $0x1,-0x48(%rbp)
jmp    1d00 <qr_binary+0xba0>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movl   $0x11,(%rax,%rcx,4)
movl   $0x0,-0x48(%rbp)
jmp    1d05 <qr_binary+0xba5>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1cb9 <qr_binary+0xb59>
cmpl   $0x0,-0x2c(%rbp)
je     1d73 <qr_binary+0xc13>
lea    0x3fa(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1d65 <qr_binary+0xc05>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
lea    0x3e5(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1d32 <qr_binary+0xbd2>
lea    0x2d9(%rip),%rdi
mov    $0x0,%al
call   1050 <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,%ebx
mov    %r8,-0x30(%rbp)
mov    %rcx,-0x40(%rbp)
mov    %edx,-0x4c(%rbp)
mov    %esi,%r14d
mov    %rdi,-0x78(%rbp)
mov    0x18(%rbp),%r12d
mov    0x20(%rbp),%eax
add    $0xc,%eax
mov    %rsp,%r13
add    $0xf,%rax
and    $0xfffffffffffffff0,%rax
sub    %rax,%r13
mov    %r13,%rsp
lea    0xf0b(%rip),%rsi
mov    %r13,%rdi
call   1030 <strcpy@plt>
cmpl   $0x0,0x10(%rbp)
je     11b5 <qr_binary+0x65>
lea    0xe9b(%rip),%rsi
mov    %r13,%rdi
call   1070 <strcat@plt>
cmp    $0x3,%r12d
je     11da <qr_binary+0x8a>
lea    0xe8b(%rip),%rsi
mov    %r13,%rdi
call   1070 <strcat@plt>
mov    %r13,%rdi
mov    %r12d,%esi
mov    $0x80,%edx
call   1060 <qr_diran@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,-0x58(%rbp)
movzbl %al,%eax
mov    $0x2,%ecx
cmovge %eax,%ecx
shl    %cl,%edx
mov    %edx,-0x5c(%rbp)
mov    $0x40,%eax
shl    %cl,%eax
mov    %eax,-0x54(%rbp)
mov    $0x20,%eax
shl    %cl,%eax
mov    %eax,-0x50(%rbp)
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x80(%rbp)
xor    %eax,%eax
mov    %rax,-0x48(%rbp)
xor    %eax,%eax
mov    0x10(%rbp),%r12d
mov    %r13,-0x70(%rbp)
mov    %ebx,-0x60(%rbp)
jmp    1262 <qr_binary+0x112>
xchg   %ax,%ax
mov    -0x70(%rbp),%r13
mov    0x10(%rbp),%r12d
nopl   0x0(%rax,%rax,1)
mov    -0x60(%rbp),%ebx
cmp    %ebx,-0x88(%rbp)
mov    -0x64(%rbp),%eax
jge    1645 <qr_binary+0x4f5>
mov    %eax,%ecx
mov    %eax,%esi
mov    -0x40(%rbp),%rax
movsbl (%rax,%rsi,1),%eax
lea    0x1(%rcx),%r8d
cmp    %r8d,%ebx
cmovg  %ebx,%r8d
not    %ecx
add    %r8d,%ecx
mov    -0x80(%rbp),%rdx
mov    %rsi,-0x38(%rbp)
add    %rsi,%rdx
mov    $0x1,%esi
xor    %edi,%edi
mov    %rdi,%r14
mov    %esi,%ebx
cmp    %rdi,%rcx
je     12b0 <qr_binary+0x160>
lea    0x1(%r14),%rdi
lea    0x1(%rbx),%esi
cmp    %al,(%rdx,%r14,1)
je     1290 <qr_binary+0x140>
add    -0x38(%rbp),%edi
mov    %edi,%r8d
jmp    12bb <qr_binary+0x16b>
nop
mov    -0x38(%rbp),%rcx
lea    (%rcx,%r14,1),%edi
add    $0x1,%edi
mov    %rdi,-0x88(%rbp)
mov    %r8d,-0x64(%rbp)
add    $0xffffffbf,%eax
cmp    $0xd,%eax
ja     1250 <qr_binary+0x100>
lea    0x1(%r14),%r15
lea    0xd37(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    %r13,%rdi
lea    0xd70(%rip),%rsi
call   1070 <strcat@plt>
mov    %r13,%rdi
mov    %r15d,%esi
mov    -0x54(%rbp),%edx
call   1060 <qr_diran@plt>
xor    %r15d,%r15d
jmp    1347 <qr_binary+0x1f7>
mov    $0x25,%al
movsbl %al,%esi
lea    0xd51(%rip),%rdi
call   1050 <posn@plt>
add    $0x2,%r15d
lea    (%r12,%r12,8),%ecx
lea    (%rcx,%rcx,4),%r12d
add    %eax,%r12d
mov    $0x400,%edx
mov    %r15d,%ebx
mov    %r13,%rdi
mov    %r12d,%esi
call   1060 <qr_diran@plt>
mov    %ebx,%r15d
cmp    %r14d,%ebx
mov    0x10(%rbp),%r12d
jg     1250 <qr_binary+0x100>
cmpl   $0x0,-0x48(%rbp)
jne    13c0 <qr_binary+0x270>
mov    -0x38(%rbp),%rax
add    %r15d,%eax
cltq
test   %r12d,%r12d
je     13b0 <qr_binary+0x260>
mov    -0x30(%rbp),%rcx
mov    (%rcx,%rax,4),%ecx
cmp    $0x5b,%ecx
je     13ce <qr_binary+0x27e>
cmp    $0x25,%ecx
jne    13b0 <qr_binary+0x260>
lea    0xcee(%rip),%r12
mov    %r12,%rdi
mov    $0x25,%esi
call   1050 <posn@plt>
mov    %eax,%ebx
mov    %r12,%rdi
mov    $0x25,%esi
call   1050 <posn@plt>
lea    (%rbx,%rbx,8),%ecx
lea    (%rcx,%rcx,4),%r12d
add    %eax,%r12d
add    $0x1,%r15d
mov    $0x400,%edx
xor    %eax,%eax
mov    %rax,-0x48(%rbp)
jmp    1329 <qr_binary+0x1d9>
nopl   (%rax)
mov    -0x30(%rbp),%rcx
movzbl (%rcx,%rax,4),%eax
jmp    13d0 <qr_binary+0x280>
nopw   0x0(%rax,%rax,1)
lea    0xc9a(%rip),%rdi
mov    $0x25,%esi
jmp    13da <qr_binary+0x28a>
mov    $0x25,%al
movsbl %al,%esi
lea    0xc87(%rip),%rdi
call   1050 <posn@plt>
mov    %eax,%r12d
lea    0x1(%r15),%ebx
mov    $0x20,%edx
xor    %eax,%eax
mov    %rax,-0x48(%rbp)
cmp    %r14d,%r15d
jge    132c <qr_binary+0x1dc>
mov    -0x38(%rbp),%rax
add    %ebx,%eax
cltq
mov    -0x40(%rbp),%rcx
cmpb   $0x41,(%rcx,%rax,1)
jne    132c <qr_binary+0x1dc>
mov    -0x30(%rbp),%rcx
mov    (%rcx,%rax,4),%eax
cmpl   $0x0,0x10(%rbp)
je     1306 <qr_binary+0x1b6>
cmp    $0x5b,%eax
je     1304 <qr_binary+0x1b4>
cmp    $0x25,%eax
jne    1306 <qr_binary+0x1b6>
lea    0xc27(%rip),%rdi
mov    $0x25,%esi
call   1050 <posn@plt>
lea    (%r12,%r12,8),%ecx
lea    (%rcx,%rcx,4),%r12d
add    %eax,%r12d
mov    $0x400,%edx
mov    $0x1,%eax
mov    %rax,-0x48(%rbp)
jmp    132c <qr_binary+0x1dc>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %r13,%rdi
lea    0xbdd(%rip),%rsi
call   1070 <strcat@plt>
mov    %r13,%rdi
mov    %r15d,%esi
mov    -0x58(%rbp),%edx
call   1060 <qr_diran@plt>
mov    -0x30(%rbp),%rax
mov    -0x38(%rbp),%rcx
lea    (%rax,%rcx,4),%r14
mov    %ebx,%r15d
xor    %ebx,%ebx
xchg   %ax,%ax
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
call   1060 <qr_diran@plt>
add    $0x1,%rbx
cmp    %rbx,%r15
jne    14a0 <qr_binary+0x350>
jmp    1250 <qr_binary+0x100>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %r13,%rdi
lea    0xb68(%rip),%rsi
call   1070 <strcat@plt>
mov    %r13,%rdi
mov    %r15d,%esi
mov    -0x50(%rbp),%edx
call   1060 <qr_diran@plt>
mov    -0x30(%rbp),%rax
mov    -0x38(%rbp),%rcx
lea    (%rax,%rcx,4),%r14
mov    %ebx,%r15d
xor    %ebx,%ebx
xchg   %ax,%ax
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
call   1060 <qr_diran@plt>
add    $0x1,%rbx
cmp    %rbx,%r15
jne    1510 <qr_binary+0x3c0>
jmp    1250 <qr_binary+0x100>
xchg   %ax,%ax
mov    %r13,%rdi
lea    0xb35(%rip),%rsi
call   1070 <strcat@plt>
mov    %r13,%rdi
mov    %r15d,%esi
mov    -0x5c(%rbp),%edx
call   1060 <qr_diran@plt>
xor    %ebx,%ebx
jmp    15a4 <qr_binary+0x454>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    0x0(%r13,%r13,2),%ecx
mov    $0x1,%edx
shl    %cl,%edx
mov    -0x70(%rbp),%rdi
mov    %r15d,%esi
call   1060 <qr_diran@plt>
add    %r13d,%ebx
cmp    %r14d,%ebx
ja     1240 <qr_binary+0xf0>
mov    %ebx,%r12d
add    -0x38(%rbp),%r12
mov    %r12d,%eax
mov    -0x30(%rbp),%rcx
movsbl (%rcx,%rax,4),%esi
lea    0xad7(%rip),%rdi
call   1050 <posn@plt>
mov    %eax,%r15d
mov    $0x1,%r13d
cmp    %r14d,%ebx
jae    1580 <qr_binary+0x430>
mov    -0x40(%rbp),%rax
cmpb   $0x4e,0x1(%r12,%rax,1)
jne    1580 <qr_binary+0x430>
mov    -0x30(%rbp),%rax
movsbl 0x4(%rax,%r12,4),%esi
lea    0xaa7(%rip),%rdi
call   1050 <posn@plt>
lea    (%r15,%r15,4),%ecx
lea    (%rax,%rcx,2),%r15d
lea    0x2(%rbx),%eax
mov    $0x2,%r13d
cmp    %r14d,%eax
ja     1580 <qr_binary+0x430>
mov    -0x40(%rbp),%rax
cmpb   $0x4e,0x2(%r12,%rax,1)
jne    1580 <qr_binary+0x430>
mov    -0x30(%rbp),%rax
movsbl 0x8(%rax,%r12,4),%esi
lea    0xa67(%rip),%rdi
call   1050 <posn@plt>
lea    (%r15,%r15,4),%ecx
lea    (%rax,%rcx,2),%r15d
mov    $0x3,%r13d
jmp    1580 <qr_binary+0x430>
lea    0xa53(%rip),%rsi
mov    %r13,%rdi
call   1070 <strcat@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,%ecx
sub    %edx,%ecx
xor    %ebx,%ebx
test   %dl,%dl
cmovne %ecx,%ebx
mov    %ebx,%r12d
add    %eax,%r12d
lea    0x7(%rbx,%rax,1),%r14d
cmovns %r12d,%r14d
test   %ebx,%ebx
je     16b0 <qr_binary+0x560>
lea    0xa0f(%rip),%r15
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %r13,%rdi
mov    %r15,%rsi
call   1070 <strcat@plt>
add    $0xffffffff,%ebx
jne    16a0 <qr_binary+0x550>
sar    $0x3,%r14d
cmp    $0x8,%r12d
mov    -0x78(%rbp),%rdi
jl     1793 <qr_binary+0x643>
mov    %r14d,%eax
xor    %ecx,%ecx
jmp    16dd <qr_binary+0x58d>
nopl   0x0(%rax)
add    $0x1,%rcx
cmp    %rcx,%rax
je     1793 <qr_binary+0x643>
movl   $0x0,(%rdi,%rcx,4)
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)
je     1730 <qr_binary+0x5e0>
cmpb   $0x31,0x2(%r13,%rcx,8)
je     173e <qr_binary+0x5ee>
cmpb   $0x31,0x3(%r13,%rcx,8)
je     174c <qr_binary+0x5fc>
cmpb   $0x31,0x4(%r13,%rcx,8)
je     175a <qr_binary+0x60a>
cmpb   $0x31,0x5(%r13,%rcx,8)
je     1768 <qr_binary+0x618>
cmpb   $0x31,0x6(%r13,%rcx,8)
je     1776 <qr_binary+0x626>
cmpb   $0x31,0x7(%r13,%rcx,8)
jne    16d0 <qr_binary+0x580>
jmp    1788 <qr_binary+0x638>
nop
or     $0x40,%edx
mov    %edx,(%rdi,%rcx,4)
cmpb   $0x31,0x2(%r13,%rcx,8)
jne    1705 <qr_binary+0x5b5>
add    $0x20,%edx
mov    %edx,(%rdi,%rcx,4)
cmpb   $0x31,0x3(%r13,%rcx,8)
jne    170d <qr_binary+0x5bd>
add    $0x10,%edx
mov    %edx,(%rdi,%rcx,4)
cmpb   $0x31,0x4(%r13,%rcx,8)
jne    1715 <qr_binary+0x5c5>
add    $0x8,%edx
mov    %edx,(%rdi,%rcx,4)
cmpb   $0x31,0x5(%r13,%rcx,8)
jne    171d <qr_binary+0x5cd>
add    $0x4,%edx
mov    %edx,(%rdi,%rcx,4)
cmpb   $0x31,0x6(%r13,%rcx,8)
jne    1725 <qr_binary+0x5d5>
add    $0x2,%edx
mov    %edx,(%rdi,%rcx,4)
cmpb   $0x31,0x7(%r13,%rcx,8)
jne    16d0 <qr_binary+0x580>
add    $0x1,%edx
mov    %edx,(%rdi,%rcx,4)
jmp    16d0 <qr_binary+0x580>
mov    -0x4c(%rbp),%eax
cmp    %eax,%r14d
jge    1809 <qr_binary+0x6b9>
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     17de <qr_binary+0x68e>
and    $0xfffffffffffffffc,%rdx
movaps 0x83d(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups %xmm0,(%rdi,%rcx,4)
add    $0x4,%rcx
add    $0xfffffffffffffffc,%rdx
jne    17d0 <qr_binary+0x680>
test   %rax,%rax
je     1809 <qr_binary+0x6b9>
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    17f0 <qr_binary+0x6a0>
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 = [5 x i8] c"0111\00"
@.str.3 = [3 x i8] c"%c\00"
@.str.4 = [2 x i8] c"\0A\00"
@.str.5 = [5 x i8] c"1000\00"
@.str.6 = [26 x i8] c"Kanji block (length %d)\0A\09\00"
@.str.7 = [7 x i8] c"0x%4X \00"
@.str.8 = [5 x i8] c"0100\00"
@.str.9 = [25 x i8] c"Byte block (length %d)\0A\09\00"
@.str.10 = [11 x i8] c"0x%2X(%d) \00"
@.str.11 = [5 x i8] c"0010\00"
@.str.12 = [26 x i8] c"Alpha block (length %d)\0A\09\00"
@.str.13 = [46 x i8] c"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ $%*+-./:\00"
@.str.14 = [5 x i8] c"0001\00"
@.str.15 = [27 x i8] c"Number block (length %d)\0A\09\00"
@.str.16 = [11 x i8] c"0123456789\00"
@.str.17 = [11 x i8] c"0x%4X (%d)\00"
@.str.18 = [5 x i8] c"0000\00"
@.str.19 = [2 x i8] c"0\00"
@.str.20 = [23 x i8] c"Resulting codewords:\0A\09\00"
@.str.21 = [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, i32 %8) {
%10 = alloca i32*
%11 = alloca i32
%12 = alloca i32
%13 = alloca i8*
%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 i32
%23 = alloca i32
%24 = alloca i8
%25 = alloca i8
%26 = alloca i32
%27 = alloca i32
%28 = alloca i32
%29 = alloca i32
%30 = alloca i8*
%31 = alloca i64
%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
%44 = alloca i32
%45 = alloca i32
%46 = alloca i32
store i32* %0, i32** %10
store i32 %1, i32* %11
store i32 %2, i32* %12
store i8* %3, i8** %13
store i32* %4, i32** %14
store i32 %5, i32* %15
store i32 %6, i32* %16
store i32 %7, i32* %17
store i32 %8, i32* %18
store i32 0, i32* %19
store i32 0, i32* %20
store i32 1, i32* %23
%47 = load i32, i32* %18
%48 = add nsw i32 %47, 12
%49 = zext i32 %48 to i64
%50 = call i8* @llvm.stacksave()
store i8* %50, i8** %30
%51 = alloca i8, i64 %49
store i64 %49, i64* %31
%52 = call i32 @strcpy(i8* %51, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str, i64 0, i64 0))
%53 = load i32, i32* %16
%54 = icmp ne i32 %53, 0
br i1 %54, label %55, label %57
55: ; preds = %9
%56 = call i32 @strcat(i8* %51, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0))
br label %57
57: ; preds = %55, %9
%58 = load i32, i32* %17
%59 = icmp ne i32 %58, 3
br i1 %59, label %60, label %64
60: ; preds = %57
%61 = call i32 @strcat(i8* %51, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.2, i64 0, i64 0))
%62 = load i32, i32* %17
%63 = call i32 @qr_diran(i8* %51, i32 %62, i32 128)
br label %64
64: ; preds = %60, %57
%65 = load i32, i32* %11
%66 = icmp sle i32 %65, 9
br i1 %66, label %67, label %68
67: ; preds = %64
store i32 1, i32* %23
br label %81
68: ; preds = %64
%69 = load i32, i32* %11
%70 = icmp sge i32 %69, 10
br i1 %70, label %71, label %75
71: ; preds = %68
%72 = load i32, i32* %11
%73 = icmp sle i32 %72, 26
br i1 %73, label %74, label %75
74: ; preds = %71
store i32 2, i32* %23
br label %80
75: ; preds = %71, %68
%76 = load i32, i32* %11
%77 = icmp sge i32 %76, 27
br i1 %77, label %78, label %79
78: ; preds = %75
store i32 3, i32* %23
br label %79
79: ; preds = %78, %75
br label %80
80: ; preds = %79, %74
br label %81
81: ; preds = %80, %67
%82 = load i32, i32* %20
%83 = icmp ne i32 %82, 0
br i1 %83, label %84, label %102
84: ; preds = %81
store i32 0, i32* %22
br label %85
85: ; preds = %97, %84
%86 = load i32, i32* %22
%87 = load i32, i32* %15
%88 = icmp slt i32 %86, %87
br i1 %88, label %89, label %100
89: ; preds = %85
%90 = load i8*, i8** %13
%91 = load i32, i32* %22
%92 = sext i32 %91 to i64
%93 = getelementptr inbounds i8, i8* %90, i64 %92
%94 = load i8, i8* %93
%95 = sext i8 %94 to i32
%96 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), i32 %95)
br label %97
97: ; preds = %89
%98 = load i32, i32* %22
%99 = add nsw i32 %98, 1
store i32 %99, i32* %22
br label %85
100: ; preds = %85
%101 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0))
br label %102
102: ; preds = %100, %81
store i32 0, i32* %29
br label %103
103: ; preds = %580, %102
%104 = load i8*, i8** %13
%105 = load i32, i32* %19
%106 = sext i32 %105 to i64
%107 = getelementptr inbounds i8, i8* %104, i64 %106
%108 = load i8, i8* %107
store i8 %108, i8* %24
store i32 0, i32* %21
br label %109
109: ; preds = %130, %103
%110 = load i32, i32* %21
%111 = add nsw i32 %110, 1
store i32 %111, i32* %21
br label %112
112: ; preds = %109
%113 = load i32, i32* %21
%114 = load i32, i32* %19
%115 = add nsw i32 %113, %114
%116 = load i32, i32* %15
%117 = icmp slt i32 %115, %116
br i1 %117, label %118, label %130
118: ; preds = %112
%119 = load i8*, i8** %13
%120 = load i32, i32* %19
%121 = load i32, i32* %21
%122 = add nsw i32 %120, %121
%123 = sext i32 %122 to i64
%124 = getelementptr inbounds i8, i8* %119, i64 %123
%125 = load i8, i8* %124
%126 = sext i8 %125 to i32
%127 = load i8, i8* %24
%128 = sext i8 %127 to i32
%129 = icmp eq i32 %126, %128
br label %130
130: ; preds = %118, %112
%131 = phi i1 [ false, %112 ], [ %129, %118 ]
br i1 %131, label %109, label %132
132: ; preds = %130
%133 = load i8, i8* %24
%134 = sext i8 %133 to i32
switch i32 %134, label %576 [
i32 75, label %135
i32 66, label %192
i32 65, label %243
i32 78, label %465
]
135: ; preds = %132
%136 = call i32 @strcat(i8* %51, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.5, i64 0, i64 0))
%137 = load i32, i32* %21
%138 = load i32, i32* %23
%139 = mul nsw i32 %138, 2
%140 = shl i32 32, %139
%141 = call i32 @qr_diran(i8* %51, i32 %137, i32 %140)
%142 = load i32, i32* %20
%143 = icmp ne i32 %142, 0
br i1 %143, label %144, label %147
144: ; preds = %135
%145 = load i32, i32* %21
%146 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str.6, i64 0, i64 0), i32 %145)
br label %147
147: ; preds = %144, %135
store i32 0, i32* %22
br label %148
148: ; preds = %183, %147
%149 = load i32, i32* %22
%150 = load i32, i32* %21
%151 = icmp slt i32 %149, %150
br i1 %151, label %152, label %186
152: ; preds = %148
%153 = load i32*, i32** %14
%154 = load i32, i32* %19
%155 = load i32, i32* %22
%156 = add nsw i32 %154, %155
%157 = sext i32 %156 to i64
%158 = getelementptr inbounds i32, i32* %153, i64 %157
%159 = load i32, i32* %158
store i32 %159, i32* %32
%160 = load i32, i32* %32
%161 = icmp sgt i32 %160, 40959
br i1 %161, label %162, label %165
162: ; preds = %152
%163 = load i32, i32* %32
%164 = sub nsw i32 %163, 49472
store i32 %164, i32* %32
br label %165
165: ; preds = %162, %152
%166 = load i32, i32* %32
%167 = and i32 %166, 65280
%168 = ashr i32 %167, 4
store i32 %168, i32* %33
%169 = load i32, i32* %32
%170 = and i32 %169, 255
store i32 %170, i32* %34
%171 = load i32, i32* %33
%172 = mul nsw i32 %171, 192
%173 = load i32, i32* %34
%174 = add nsw i32 %172, %173
store i32 %174, i32* %35
%175 = load i32, i32* %35
%176 = call i32 @qr_diran(i8* %51, i32 %175, i32 4096)
%177 = load i32, i32* %20
%178 = icmp ne i32 %177, 0
br i1 %178, label %179, label %182
179: ; preds = %165
%180 = load i32, i32* %35
%181 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.7, i64 0, i64 0), i32 %180)
br label %182
182: ; preds = %179, %165
br label %183
183: ; preds = %182
%184 = load i32, i32* %22
%185 = add nsw i32 %184, 1
store i32 %185, i32* %22
br label %148
186: ; preds = %148
%187 = load i32, i32* %20
%188 = icmp ne i32 %187, 0
br i1 %188, label %189, label %191
189: ; preds = %186
%190 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0))
br label %191
191: ; preds = %189, %186
br label %576
192: ; preds = %132
%193 = call i32 @strcat(i8* %51, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.8, i64 0, i64 0))
%194 = load i32, i32* %21
%195 = load i32, i32* %23
%196 = icmp sgt i32 %195, 1
%197 = zext i1 %196 to i64
%198 = select i1 %196, i32 32768, i32 128
%199 = call i32 @qr_diran(i8* %51, i32 %194, i32 %198)
%200 = load i32, i32* %20
%201 = icmp ne i32 %200, 0
br i1 %201, label %202, label %205
202: ; preds = %192
%203 = load i32, i32* %21
%204 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.9, i64 0, i64 0), i32 %203)
br label %205
205: ; preds = %202, %192
store i32 0, i32* %22
br label %206
206: ; preds = %234, %205
%207 = load i32, i32* %22
%208 = load i32, i32* %21
%209 = icmp slt i32 %207, %208
br i1 %209, label %210, label %237
210: ; preds = %206
%211 = load i32*, i32** %14
%212 = load i32, i32* %19
%213 = load i32, i32* %22
%214 = add nsw i32 %212, %213
%215 = sext i32 %214 to i64
%216 = getelementptr inbounds i32, i32* %211, i64 %215
%217 = load i32, i32* %216
store i32 %217, i32* %36
%218 = load i32, i32* %16
%219 = icmp ne i32 %218, 0
br i1 %219, label %220, label %224
220: ; preds = %210
%221 = load i32, i32* %36
%222 = icmp eq i32 %221, 91
br i1 %222, label %223, label %224
223: ; preds = %220
store i32 29, i32* %36
br label %224
224: ; preds = %223, %220, %210
%225 = load i32, i32* %36
%226 = call i32 @qr_diran(i8* %51, i32 %225, i32 128)
%227 = load i32, i32* %20
%228 = icmp ne i32 %227, 0
br i1 %228, label %229, label %233
229: ; preds = %224
%230 = load i32, i32* %36
%231 = load i32, i32* %36
%232 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.10, i64 0, i64 0), i32 %230, i32 %231)
br label %233
233: ; preds = %229, %224
br label %234
234: ; preds = %233
%235 = load i32, i32* %22
%236 = add nsw i32 %235, 1
store i32 %236, i32* %22
br label %206
237: ; preds = %206
%238 = load i32, i32* %20
%239 = icmp ne i32 %238, 0
br i1 %239, label %240, label %242
240: ; preds = %237
%241 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0))
br label %242
242: ; preds = %240, %237
br label %576
243: ; preds = %132
%244 = call i32 @strcat(i8* %51, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.11, i64 0, i64 0))
%245 = load i32, i32* %21
%246 = load i32, i32* %23
%247 = mul nsw i32 2, %246
%248 = shl i32 64, %247
%249 = call i32 @qr_diran(i8* %51, i32 %245, i32 %248)
%250 = load i32, i32* %20
%251 = icmp ne i32 %250, 0
br i1 %251, label %252, label %255
252: ; preds = %243
%253 = load i32, i32* %21
%254 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str.12, i64 0, i64 0), i32 %253)
br label %255
255: ; preds = %252, %243
store i32 0, i32* %22
br label %256
256: ; preds = %458, %255
%257 = load i32, i32* %22
%258 = load i32, i32* %21
%259 = icmp slt i32 %257, %258
br i1 %259, label %260, label %459
260: ; preds = %256
store i32 0, i32* %38
store i32 0, i32* %39
%261 = load i32, i32* %29
%262 = icmp eq i32 %261, 0
br i1 %262, label %263, label %377
263: ; preds = %260
%264 = load i32, i32* %16
%265 = icmp ne i32 %264, 0
br i1 %265, label %266, label %284
266: ; preds = %263
%267 = load i32*, i32** %14
%268 = load i32, i32* %19
%269 = load i32, i32* %22
%270 = add nsw i32 %268, %269
%271 = sext i32 %270 to i64
%272 = getelementptr inbounds i32, i32* %267, i64 %271
%273 = load i32, i32* %272
%274 = icmp eq i32 %273, 37
br i1 %274, label %275, label %284
275: ; preds = %266
%276 = call i32 @posn(i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.13, i64 0, i64 0), i8 signext 37)
store i32 %276, i32* %38
%277 = call i32 @posn(i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.13, i64 0, i64 0), i8 signext 37)
store i32 %277, i32* %39
store i32 2, i32* %37
%278 = load i32, i32* %38
%279 = mul nsw i32 %278, 45
%280 = load i32, i32* %39
%281 = add nsw i32 %279, %280
store i32 %281, i32* %40
%282 = load i32, i32* %22
%283 = add nsw i32 %282, 1
store i32 %283, i32* %22
br label %376
284: ; preds = %266, %263
%285 = load i32, i32* %16
%286 = icmp ne i32 %285, 0
br i1 %286, label %287, label %298
287: ; preds = %284
%288 = load i32*, i32** %14
%289 = load i32, i32* %19
%290 = load i32, i32* %22
%291 = add nsw i32 %289, %290
%292 = sext i32 %291 to i64
%293 = getelementptr inbounds i32, i32* %288, i64 %292
%294 = load i32, i32* %293
%295 = icmp eq i32 %294, 91
br i1 %295, label %296, label %298
296: ; preds = %287
%297 = call i32 @posn(i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.13, i64 0, i64 0), i8 signext 37)
store i32 %297, i32* %38
br label %308
298: ; preds = %287, %284
%299 = load i32*, i32** %14
%300 = load i32, i32* %19
%301 = load i32, i32* %22
%302 = add nsw i32 %300, %301
%303 = sext i32 %302 to i64
%304 = getelementptr inbounds i32, i32* %299, i64 %303
%305 = load i32, i32* %304
%306 = trunc i32 %305 to i8
%307 = call i32 @posn(i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.13, i64 0, i64 0), i8 signext %306)
store i32 %307, i32* %38
br label %308
308: ; preds = %298, %296
store i32 1, i32* %37
%309 = load i32, i32* %22
%310 = add nsw i32 %309, 1
store i32 %310, i32* %22
%311 = load i32, i32* %38
store i32 %311, i32* %40
%312 = load i32, i32* %22
%313 = load i32, i32* %21
%314 = icmp slt i32 %312, %313
br i1 %314, label %315, label %375
315: ; preds = %308
%316 = load i8*, i8** %13
%317 = load i32, i32* %19
%318 = load i32, i32* %22
%319 = add nsw i32 %317, %318
%320 = sext i32 %319 to i64
%321 = getelementptr inbounds i8, i8* %316, i64 %320
%322 = load i8, i8* %321
%323 = sext i8 %322 to i32
%324 = icmp eq i32 %323, 65
br i1 %324, label %325, label %375
325: ; preds = %315
%326 = load i32, i32* %16
%327 = icmp ne i32 %326, 0
br i1 %327, label %328, label %343
328: ; preds = %325
%329 = load i32*, i32** %14
%330 = load i32, i32* %19
%331 = load i32, i32* %22
%332 = add nsw i32 %330, %331
%333 = sext i32 %332 to i64
%334 = getelementptr inbounds i32, i32* %329, i64 %333
%335 = load i32, i32* %334
%336 = icmp eq i32 %335, 37
br i1 %336, label %337, label %343
337: ; preds = %328
%338 = call i32 @posn(i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.13, i64 0, i64 0), i8 signext 37)
store i32 %338, i32* %39
store i32 2, i32* %37
%339 = load i32, i32* %38
%340 = mul nsw i32 %339, 45
%341 = load i32, i32* %39
%342 = add nsw i32 %340, %341
store i32 %342, i32* %40
store i32 1, i32* %29
br label %374
343: ; preds = %328, %325
%344 = load i32, i32* %16
%345 = icmp ne i32 %344, 0
br i1 %345, label %346, label %357
346: ; preds = %343
%347 = load i32*, i32** %14
%348 = load i32, i32* %19
%349 = load i32, i32* %22
%350 = add nsw i32 %348, %349
%351 = sext i32 %350 to i64
%352 = getelementptr inbounds i32, i32* %347, i64 %351
%353 = load i32, i32* %352
%354 = icmp eq i32 %353, 91
br i1 %354, label %355, label %357
355: ; preds = %346
%356 = call i32 @posn(i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.13, i64 0, i64 0), i8 signext 37)
store i32 %356, i32* %39
br label %367
357: ; preds = %346, %343
%358 = load i32*, i32** %14
%359 = load i32, i32* %19
%360 = load i32, i32* %22
%361 = add nsw i32 %359, %360
%362 = sext i32 %361 to i64
%363 = getelementptr inbounds i32, i32* %358, i64 %362
%364 = load i32, i32* %363
%365 = trunc i32 %364 to i8
%366 = call i32 @posn(i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.13, i64 0, i64 0), i8 signext %365)
store i32 %366, i32* %39
br label %367
367: ; preds = %357, %355
store i32 2, i32* %37
%368 = load i32, i32* %22
%369 = add nsw i32 %368, 1
store i32 %369, i32* %22
%370 = load i32, i32* %38
%371 = mul nsw i32 %370, 45
%372 = load i32, i32* %39
%373 = add nsw i32 %371, %372
store i32 %373, i32* %40
br label %374
374: ; preds = %367, %337
br label %375
375: ; preds = %374, %315, %308
br label %376
376: ; preds = %375, %275
br label %446
377: ; preds = %260
%378 = call i32 @posn(i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.13, i64 0, i64 0), i8 signext 37)
store i32 %378, i32* %38
store i32 1, i32* %37
%379 = load i32, i32* %22
%380 = add nsw i32 %379, 1
store i32 %380, i32* %22
%381 = load i32, i32* %38
store i32 %381, i32* %40
store i32 0, i32* %29
%382 = load i32, i32* %22
%383 = load i32, i32* %21
%384 = icmp slt i32 %382, %383
br i1 %384, label %385, label %445
385: ; preds = %377
%386 = load i8*, i8** %13
%387 = load i32, i32* %19
%388 = load i32, i32* %22
%389 = add nsw i32 %387, %388
%390 = sext i32 %389 to i64
%391 = getelementptr inbounds i8, i8* %386, i64 %390
%392 = load i8, i8* %391
%393 = sext i8 %392 to i32
%394 = icmp eq i32 %393, 65
br i1 %394, label %395, label %445
395: ; preds = %385
%396 = load i32, i32* %16
%397 = icmp ne i32 %396, 0
br i1 %397, label %398, label %413
398: ; preds = %395
%399 = load i32*, i32** %14
%400 = load i32, i32* %19
%401 = load i32, i32* %22
%402 = add nsw i32 %400, %401
%403 = sext i32 %402 to i64
%404 = getelementptr inbounds i32, i32* %399, i64 %403
%405 = load i32, i32* %404
%406 = icmp eq i32 %405, 37
br i1 %406, label %407, label %413
407: ; preds = %398
%408 = call i32 @posn(i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.13, i64 0, i64 0), i8 signext 37)
store i32 %408, i32* %39
store i32 2, i32* %37
%409 = load i32, i32* %38
%410 = mul nsw i32 %409, 45
%411 = load i32, i32* %39
%412 = add nsw i32 %410, %411
store i32 %412, i32* %40
store i32 1, i32* %29
br label %444
413: ; preds = %398, %395
%414 = load i32, i32* %16
%415 = icmp ne i32 %414, 0
br i1 %415, label %416, label %427
416: ; preds = %413
%417 = load i32*, i32** %14
%418 = load i32, i32* %19
%419 = load i32, i32* %22
%420 = add nsw i32 %418, %419
%421 = sext i32 %420 to i64
%422 = getelementptr inbounds i32, i32* %417, i64 %421
%423 = load i32, i32* %422
%424 = icmp eq i32 %423, 91
br i1 %424, label %425, label %427
425: ; preds = %416
%426 = call i32 @posn(i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.13, i64 0, i64 0), i8 signext 37)
store i32 %426, i32* %39
br label %437
427: ; preds = %416, %413
%428 = load i32*, i32** %14
%429 = load i32, i32* %19
%430 = load i32, i32* %22
%431 = add nsw i32 %429, %430
%432 = sext i32 %431 to i64
%433 = getelementptr inbounds i32, i32* %428, i64 %432
%434 = load i32, i32* %433
%435 = trunc i32 %434 to i8
%436 = call i32 @posn(i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.13, i64 0, i64 0), i8 signext %435)
store i32 %436, i32* %39
br label %437
437: ; preds = %427, %425
store i32 2, i32* %37
%438 = load i32, i32* %22
%439 = add nsw i32 %438, 1
store i32 %439, i32* %22
%440 = load i32, i32* %38
%441 = mul nsw i32 %440, 45
%442 = load i32, i32* %39
%443 = add nsw i32 %441, %442
store i32 %443, i32* %40
br label %444
444: ; preds = %437, %407
br label %445
445: ; preds = %444, %385, %377
br label %446
446: ; preds = %445, %376
%447 = load i32, i32* %40
%448 = load i32, i32* %37
%449 = icmp eq i32 %448, 2
%450 = zext i1 %449 to i64
%451 = select i1 %449, i32 1024, i32 32
%452 = call i32 @qr_diran(i8* %51, i32 %447, i32 %451)
%453 = load i32, i32* %20
%454 = icmp ne i32 %453, 0
br i1 %454, label %455, label %458
455: ; preds = %446
%456 = load i32, i32* %40
%457 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.7, i64 0, i64 0), i32 %456)
br label %458
458: ; preds = %455, %446
br label %256
459: ; preds = %256
%460 = load i32, i32* %20
%461 = icmp ne i32 %460, 0
br i1 %461, label %462, label %464
462: ; preds = %459
%463 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0))
br label %464
464: ; preds = %462, %459
br label %576
465: ; preds = %132
%466 = call i32 @strcat(i8* %51, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.14, i64 0, i64 0))
%467 = load i32, i32* %21
%468 = load i32, i32* %23
%469 = mul nsw i32 2, %468
%470 = shl i32 128, %469
%471 = call i32 @qr_diran(i8* %51, i32 %467, i32 %470)
%472 = load i32, i32* %20
%473 = icmp ne i32 %472, 0
br i1 %473, label %474, label %477
474: ; preds = %465
%475 = load i32, i32* %21
%476 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str.15, i64 0, i64 0), i32 %475)
br label %477
477: ; preds = %474, %465
store i32 0, i32* %22
br label %478
478: ; preds = %566, %477
%479 = load i32, i32* %22
%480 = load i32, i32* %21
%481 = icmp slt i32 %479, %480
br i1 %481, label %482, label %570
482: ; preds = %478
store i32 0, i32* %42
store i32 0, i32* %43
store i32 0, i32* %44
%483 = load i32*, i32** %14
%484 = load i32, i32* %19
%485 = load i32, i32* %22
%486 = add nsw i32 %484, %485
%487 = sext i32 %486 to i64
%488 = getelementptr inbounds i32, i32* %483, i64 %487
%489 = load i32, i32* %488
%490 = trunc i32 %489 to i8
%491 = call i32 @posn(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.16, i64 0, i64 0), i8 signext %490)
store i32 %491, i32* %42
store i32 1, i32* %41
%492 = load i32, i32* %42
store i32 %492, i32* %45
%493 = load i32, i32* %22
%494 = add nsw i32 %493, 1
%495 = load i32, i32* %21
%496 = icmp slt i32 %494, %495
br i1 %496, label %497, label %554
497: ; preds = %482
%498 = load i8*, i8** %13
%499 = load i32, i32* %19
%500 = load i32, i32* %22
%501 = add nsw i32 %499, %500
%502 = add nsw i32 %501, 1
%503 = sext i32 %502 to i64
%504 = getelementptr inbounds i8, i8* %498, i64 %503
%505 = load i8, i8* %504
%506 = sext i8 %505 to i32
%507 = icmp eq i32 %506, 78
br i1 %507, label %508, label %554
508: ; preds = %497
%509 = load i32*, i32** %14
%510 = load i32, i32* %19
%511 = load i32, i32* %22
%512 = add nsw i32 %510, %511
%513 = add nsw i32 %512, 1
%514 = sext i32 %513 to i64
%515 = getelementptr inbounds i32, i32* %509, i64 %514
%516 = load i32, i32* %515
%517 = trunc i32 %516 to i8
%518 = call i32 @posn(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.16, i64 0, i64 0), i8 signext %517)
store i32 %518, i32* %43
store i32 2, i32* %41
%519 = load i32, i32* %45
%520 = mul nsw i32 %519, 10
%521 = load i32, i32* %43
%522 = add nsw i32 %520, %521
store i32 %522, i32* %45
%523 = load i32, i32* %22
%524 = add nsw i32 %523, 2
%525 = load i32, i32* %21
%526 = icmp slt i32 %524, %525
br i1 %526, label %527, label %553
527: ; preds = %508
%528 = load i8*, i8** %13
%529 = load i32, i32* %19
%530 = load i32, i32* %22
%531 = add nsw i32 %529, %530
%532 = add nsw i32 %531, 2
%533 = sext i32 %532 to i64
%534 = getelementptr inbounds i8, i8* %528, i64 %533
%535 = load i8, i8* %534
%536 = sext i8 %535 to i32
%537 = icmp eq i32 %536, 78
br i1 %537, label %538, label %553
538: ; preds = %527
%539 = load i32*, i32** %14
%540 = load i32, i32* %19
%541 = load i32, i32* %22
%542 = add nsw i32 %540, %541
%543 = add nsw i32 %542, 2
%544 = sext i32 %543 to i64
%545 = getelementptr inbounds i32, i32* %539, i64 %544
%546 = load i32, i32* %545
%547 = trunc i32 %546 to i8
%548 = call i32 @posn(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.16, i64 0, i64 0), i8 signext %547)
store i32 %548, i32* %44
store i32 3, i32* %41
%549 = load i32, i32* %45
%550 = mul nsw i32 %549, 10
%551 = load i32, i32* %44
%552 = add nsw i32 %550, %551
store i32 %552, i32* %45
br label %553
553: ; preds = %538, %527, %508
br label %554
554: ; preds = %553, %497, %482
%555 = load i32, i32* %45
%556 = load i32, i32* %41
%557 = mul nsw i32 3, %556
%558 = shl i32 1, %557
%559 = call i32 @qr_diran(i8* %51, i32 %555, i32 %558)
%560 = load i32, i32* %20
%561 = icmp ne i32 %560, 0
br i1 %561, label %562, label %566
562: ; preds = %554
%563 = load i32, i32* %45
%564 = load i32, i32* %45
%565 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.17, i64 0, i64 0), i32 %563, i32 %564)
br label %566
566: ; preds = %562, %554
%567 = load i32, i32* %41
%568 = load i32, i32* %22
%569 = add nsw i32 %568, %567
store i32 %569, i32* %22
br label %478
570: ; preds = %478
%571 = load i32, i32* %20
%572 = icmp ne i32 %571, 0
br i1 %572, label %573, label %575
573: ; preds = %570
%574 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0))
br label %575
575: ; preds = %573, %570
br label %576
576: ; preds = %132, %575, %464, %242, %191
%577 = load i32, i32* %21
%578 = load i32, i32* %19
%579 = add nsw i32 %578, %577
store i32 %579, i32* %19
br label %580
580: ; preds = %576
%581 = load i32, i32* %19
%582 = load i32, i32* %15
%583 = icmp slt i32 %581, %582
br i1 %583, label %103, label %584
584: ; preds = %580
%585 = call i32 @strcat(i8* %51, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.18, i64 0, i64 0))
%586 = call i32 @strlen(i8* %51)
store i32 %586, i32* %26
%587 = load i32, i32* %26
%588 = srem i32 %587, 8
%589 = sub nsw i32 8, %588
%590 = trunc i32 %589 to i8
store i8 %590, i8* %25
%591 = load i8, i8* %25
%592 = sext i8 %591 to i32
%593 = icmp eq i32 %592, 8
br i1 %593, label %594, label %595
594: ; preds = %584
store i8 0, i8* %25
br label %595
595: ; preds = %594, %584
%596 = load i32, i32* %26
%597 = load i8, i8* %25
%598 = sext i8 %597 to i32
%599 = add nsw i32 %596, %598
%600 = sdiv i32 %599, 8
store i32 %600, i32* %27
store i32 0, i32* %22
br label %601
601: ; preds = %608, %595
%602 = load i32, i32* %22
%603 = load i8, i8* %25
%604 = sext i8 %603 to i32
%605 = icmp slt i32 %602, %604
br i1 %605, label %606, label %611
606: ; preds = %601
%607 = call i32 @strcat(i8* %51, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.19, i64 0, i64 0))
br label %608
608: ; preds = %606
%609 = load i32, i32* %22
%610 = add nsw i32 %609, 1
store i32 %610, i32* %22
br label %601
611: ; preds = %601
store i32 0, i32* %22
br label %612
612: ; preds = %648, %611
%613 = load i32, i32* %22
%614 = load i32, i32* %27
%615 = icmp slt i32 %613, %614
br i1 %615, label %616, label %651
616: ; preds = %612
%617 = load i32*, i32** %10
%618 = load i32, i32* %22
%619 = sext i32 %618 to i64
%620 = getelementptr inbounds i32, i32* %617, i64 %619
store i32 0, i32* %620
store i32 0, i32* %46
br label %621
621: ; preds = %644, %616
%622 = load i32, i32* %46
%623 = icmp slt i32 %622, 8
br i1 %623, label %624, label %647
624: ; preds = %621
%625 = load i32, i32* %22
%626 = mul nsw i32 %625, 8
%627 = load i32, i32* %46
%628 = add nsw i32 %626, %627
%629 = sext i32 %628 to i64
%630 = getelementptr inbounds i8, i8* %51, i64 %629
%631 = load i8, i8* %630
%632 = sext i8 %631 to i32
%633 = icmp eq i32 %632, 49
br i1 %633, label %634, label %643
634: ; preds = %624
%635 = load i32, i32* %46
%636 = ashr i32 128, %635
%637 = load i32*, i32** %10
%638 = load i32, i32* %22
%639 = sext i32 %638 to i64
%640 = getelementptr inbounds i32, i32* %637, i64 %639
%641 = load i32, i32* %640
%642 = add nsw i32 %641, %636
store i32 %642, i32* %640
br label %643
643: ; preds = %634, %624
br label %644
644: ; preds = %643
%645 = load i32, i32* %46
%646 = add nsw i32 %645, 1
store i32 %646, i32* %46
br label %621
647: ; preds = %621
br label %648
648: ; preds = %647
%649 = load i32, i32* %22
%650 = add nsw i32 %649, 1
store i32 %650, i32* %22
br label %612
651: ; preds = %612
store i32 0, i32* %28
%652 = load i32, i32* %27
store i32 %652, i32* %22
br label %653
653: ; preds = %671, %651
%654 = load i32, i32* %22
%655 = load i32, i32* %12
%656 = icmp slt i32 %654, %655
br i1 %656, label %657, label %674
657: ; preds = %653
%658 = load i32, i32* %28
%659 = icmp eq i32 %658, 0
br i1 %659, label %660, label %665
660: ; preds = %657
%661 = load i32*, i32** %10
%662 = load i32, i32* %22
%663 = sext i32 %662 to i64
%664 = getelementptr inbounds i32, i32* %661, i64 %663
store i32 236, i32* %664
store i32 1, i32* %28
br label %670
665: ; preds = %657
%666 = load i32*, i32** %10
%667 = load i32, i32* %22
%668 = sext i32 %667 to i64
%669 = getelementptr inbounds i32, i32* %666, i64 %668
store i32 17, i32* %669
store i32 0, i32* %28
br label %670
670: ; preds = %665, %660
br label %671
671: ; preds = %670
%672 = load i32, i32* %22
%673 = add nsw i32 %672, 1
store i32 %673, i32* %22
br label %653
674: ; preds = %653
%675 = load i32, i32* %20
%676 = icmp ne i32 %675, 0
br i1 %676, label %677, label %695
677: ; preds = %674
%678 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str.20, i64 0, i64 0))
store i32 0, i32* %22
br label %679
679: ; preds = %690, %677
%680 = load i32, i32* %22
%681 = load i32, i32* %12
%682 = icmp slt i32 %680, %681
br i1 %682, label %683, label %693
683: ; preds = %679
%684 = load i32*, i32** %10
%685 = load i32, i32* %22
%686 = sext i32 %685 to i64
%687 = getelementptr inbounds i32, i32* %684, i64 %686
%688 = load i32, i32* %687
%689 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.21, i64 0, i64 0), i32 %688)
br label %690
690: ; preds = %683
%691 = load i32, i32* %22
%692 = add nsw i32 %691, 1
store i32 %692, i32* %22
br label %679
693: ; preds = %679
%694 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0))
br label %695
695: ; preds = %693, %674
%696 = load i8*, i8** %30
ret void
}

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