#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 /*<<< orphan*/ bin_append(int const, int, char *);
int posn(char *, char);
int /*<<< orphan*/ printf(char *, ...);
int /*<<< orphan*/ strcat(char *, char *);
int /*<<< orphan*/ strcpy(char *, char *);
scalar_t__ strlen(char *);
int tribus(int const, int, int, int);
void qr_binary(int datastream[], const int version, const int target_binlen,
               const char mode[], const int jisdata[], const size_t length,
               const int gs1, const int eci, const int est_binlen,
               const int debug) {
  int position = 0;
  int i;
  char 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");
    if (eci <= 127) {
      bin_append(eci, 8, binary);
    } else if (eci <= 16383) {
      bin_append(0x8000 + eci, 16, binary);
    } else {
      bin_append(0xC00000 + eci, 24, binary);
    }
  }
  if (debug) {
    for (i = 0; i < length; i++) {
      printf("%c", mode[i]);
    }
    printf("\n");
  }
  percent = 0;
  do {
    char data_block = mode[position];
    int 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");
      bin_append(short_data_block_length, tribus(version, 8, 10, 12), binary);
      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 prod;
        if (jis >= 0x8140 && jis <= 0x9ffc)
          jis -= 0x8140;
        else if (jis >= 0xe040 && jis <= 0xebbf)
          jis -= 0xc140;
        prod = ((jis >> 8) * 0xc0) + (jis & 0xff);
        bin_append(prod, 13, binary);
        if (debug) {
          printf("0x%4X ", prod);
        }
      }
      if (debug) {
        printf("\n");
      }
      break;
    case 'B':
      strcat(binary, "0100");
      bin_append(short_data_block_length, tribus(version, 8, 16, 16), binary);
      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;
        }
        bin_append(byte, 8, binary);
        if (debug) {
          printf("0x%2X(%d) ", byte, byte);
        }
      }
      if (debug) {
        printf("\n");
      }
      break;
    case 'A':
      strcat(binary, "0010");
      bin_append(short_data_block_length, tribus(version, 9, 11, 13), binary);
      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;
            }
          }
        }
        bin_append(prod, 1 + (5 * count), binary);
        if (debug) {
          printf("0x%4X ", prod);
        }
      };
      if (debug) {
        printf("\n");
      }
      break;
    case 'N':
      strcat(binary, "0001");
      bin_append(short_data_block_length, tribus(version, 10, 12, 14), binary);
      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, prod;
        first = posn("0123456789", (char)jisdata[position + i]);
        count = 1;
        prod = first;
        if (i + 1 < short_data_block_length && mode[position + i + 1] == 'N') {
          int 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') {
            int third = posn("0123456789", (char)jisdata[position + i + 2]);
            count = 3;
            prod = (prod * 10) + third;
          }
        }
        bin_append(prod, 1 + (3 * count), binary);
        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 = (int)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    0x28(%rbp),%eax
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    %r9,-0x28(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    0x20(%rbp),%eax
add    $0xc,%eax
mov    %rsp,%rcx
mov    %rcx,-0x50(%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,-0x58(%rbp)
lea    0xedd(%rip),%rsi
call   1030 <strcpy@plt>
cmpl   $0x0,0x10(%rbp)
je     11f9 <qr_binary+0x89>
mov    -0xa0(%rbp),%rdi
lea    0xe44(%rip),%rsi
call   1090 <strcat@plt>
cmpl   $0x3,0x18(%rbp)
je     1289 <qr_binary+0x119>
mov    -0xa0(%rbp),%rdi
lea    0xe2c(%rip),%rsi
call   1090 <strcat@plt>
cmpl   $0x7f,0x18(%rbp)
jg     1239 <qr_binary+0xc9>
mov    -0xa0(%rbp),%rdx
mov    0x18(%rbp),%edi
mov    $0x8,%esi
call   1070 <bin_append@plt>
jmp    1284 <qr_binary+0x114>
cmpl   $0x3fff,0x18(%rbp)
jg     1265 <qr_binary+0xf5>
mov    -0xa0(%rbp),%rdx
mov    0x18(%rbp),%edi
add    $0x8000,%edi
mov    $0x10,%esi
call   1070 <bin_append@plt>
jmp    127f <qr_binary+0x10f>
mov    -0xa0(%rbp),%rdx
mov    0x18(%rbp),%edi
add    $0xc00000,%edi
mov    $0x18,%esi
call   1070 <bin_append@plt>
jmp    1284 <qr_binary+0x114>
jmp    1289 <qr_binary+0x119>
cmpl   $0x0,0x28(%rbp)
je     12de <qr_binary+0x16e>
movl   $0x0,-0x30(%rbp)
movslq -0x30(%rbp),%rax
cmp    -0x28(%rbp),%rax
jae    12d0 <qr_binary+0x160>
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsbl (%rax,%rcx,1),%esi
lea    0xd87(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    129a <qr_binary+0x12a>
lea    0xd6e(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movl   $0x0,-0x44(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x59(%rbp)
movl   $0x0,-0x60(%rbp)
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%eax
add    -0x2c(%rbp),%eax
movslq %eax,%rcx
xor    %eax,%eax
cmp    -0x28(%rbp),%rcx
mov    %al,-0xa1(%rbp)
jae    133e <qr_binary+0x1ce>
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    -0x60(%rbp),%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
movsbl -0x59(%rbp),%ecx
cmp    %ecx,%eax
sete   %al
mov    %al,-0xa1(%rbp)
mov    -0xa1(%rbp),%al
test   $0x1,%al
jne    12fa <qr_binary+0x18a>
movsbl -0x59(%rbp),%eax
add    $0xffffffbf,%eax
mov    %eax,%ecx
mov    %rcx,-0xb0(%rbp)
sub    $0xd,%eax
ja     1bb3 <qr_binary+0xa43>
mov    -0xb0(%rbp),%rax
lea    0xc8d(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0xa0(%rbp),%rdi
lea    0xcbd(%rip),%rsi
call   1090 <strcat@plt>
mov    -0x60(%rbp),%eax
mov    %eax,-0xb4(%rbp)
mov    -0xc(%rbp),%edi
mov    $0x8,%esi
mov    $0xa,%edx
mov    $0xc,%ecx
call   1060 <tribus@plt>
mov    -0xb4(%rbp),%edi
mov    -0xa0(%rbp),%rdx
mov    %eax,%esi
call   1070 <bin_append@plt>
cmpl   $0x0,0x28(%rbp)
je     13de <qr_binary+0x26e>
mov    -0x60(%rbp),%esi
lea    0xc75(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x60(%rbp),%eax
jge    14b4 <qr_binary+0x344>
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x64(%rbp)
cmpl   $0x8140,-0x64(%rbp)
jl     142e <qr_binary+0x2be>
cmpl   $0x9ffc,-0x64(%rbp)
jg     142e <qr_binary+0x2be>
mov    -0x64(%rbp),%eax
sub    $0x8140,%eax
mov    %eax,-0x64(%rbp)
jmp    1458 <qr_binary+0x2e8>
cmpl   $0xe040,-0x64(%rbp)
jl     1453 <qr_binary+0x2e3>
cmpl   $0xebbf,-0x64(%rbp)
jg     1453 <qr_binary+0x2e3>
mov    -0x64(%rbp),%eax
sub    $0xc140,%eax
mov    %eax,-0x64(%rbp)
jmp    1458 <qr_binary+0x2e8>
mov    -0xa0(%rbp),%rdx
mov    -0x64(%rbp),%eax
sar    $0x8,%eax
imul   $0xc0,%eax,%eax
mov    -0x64(%rbp),%ecx
and    $0xff,%ecx
add    %ecx,%eax
mov    %eax,-0x68(%rbp)
mov    -0x68(%rbp),%edi
mov    $0xd,%esi
call   1070 <bin_append@plt>
cmpl   $0x0,0x28(%rbp)
je     14a1 <qr_binary+0x331>
mov    -0x68(%rbp),%esi
lea    0xbcc(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    14a6 <qr_binary+0x336>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    13e5 <qr_binary+0x275>
cmpl   $0x0,0x28(%rbp)
je     14cc <qr_binary+0x35c>
lea    0xb80(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    1bb3 <qr_binary+0xa43>
mov    -0xa0(%rbp),%rdi
lea    0xb8e(%rip),%rsi
call   1090 <strcat@plt>
mov    -0x60(%rbp),%eax
mov    %eax,-0xb8(%rbp)
mov    -0xc(%rbp),%edi
mov    $0x8,%esi
mov    $0x10,%ecx
mov    %ecx,%edx
call   1060 <tribus@plt>
mov    -0xb8(%rbp),%edi
mov    -0xa0(%rbp),%rdx
mov    %eax,%esi
call   1070 <bin_append@plt>
cmpl   $0x0,0x28(%rbp)
je     1530 <qr_binary+0x3c0>
mov    -0x60(%rbp),%esi
lea    0xb49(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x60(%rbp),%eax
jge    15b6 <qr_binary+0x446>
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x6c(%rbp)
cmpl   $0x0,0x10(%rbp)
je     1571 <qr_binary+0x401>
cmpl   $0x5b,-0x6c(%rbp)
jne    1571 <qr_binary+0x401>
movl   $0x1d,-0x6c(%rbp)
mov    -0xa0(%rbp),%rdx
mov    -0x6c(%rbp),%edi
mov    $0x8,%esi
call   1070 <bin_append@plt>
cmpl   $0x0,0x28(%rbp)
je     15a3 <qr_binary+0x433>
mov    -0x6c(%rbp),%esi
mov    -0x6c(%rbp),%edx
lea    0xaef(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    15a8 <qr_binary+0x438>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1537 <qr_binary+0x3c7>
cmpl   $0x0,0x28(%rbp)
je     15ce <qr_binary+0x45e>
lea    0xa7e(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    1bb3 <qr_binary+0xa43>
mov    -0xa0(%rbp),%rdi
lea    0xab5(%rip),%rsi
call   1090 <strcat@plt>
mov    -0x60(%rbp),%eax
mov    %eax,-0xbc(%rbp)
mov    -0xc(%rbp),%edi
mov    $0x9,%esi
mov    $0xb,%edx
mov    $0xd,%ecx
call   1060 <tribus@plt>
mov    -0xbc(%rbp),%edi
mov    -0xa0(%rbp),%rdx
mov    %eax,%esi
call   1070 <bin_append@plt>
cmpl   $0x0,0x28(%rbp)
je     1635 <qr_binary+0x4c5>
mov    -0x60(%rbp),%esi
lea    0xa6d(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x60(%rbp),%eax
jge    1996 <qr_binary+0x826>
movl   $0x0,-0x74(%rbp)
movl   $0x0,-0x78(%rbp)
cmpl   $0x0,-0x44(%rbp)
jne    1837 <qr_binary+0x6c7>
cmpl   $0x0,0x10(%rbp)
je     16c8 <qr_binary+0x558>
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
cmpl   $0x25,(%rax,%rcx,4)
jne    16c8 <qr_binary+0x558>
lea    0xa2d(%rip),%rdi
mov    $0x25,%esi
call   1080 <posn@plt>
mov    %eax,-0x74(%rbp)
lea    0xa19(%rip),%rdi
mov    $0x25,%esi
call   1080 <posn@plt>
mov    %eax,-0x78(%rbp)
movl   $0x2,-0x70(%rbp)
imul   $0x2d,-0x74(%rbp),%eax
add    -0x78(%rbp),%eax
mov    %eax,-0x7c(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1832 <qr_binary+0x6c2>
cmpl   $0x0,0x10(%rbp)
je     1702 <qr_binary+0x592>
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
cmpl   $0x5b,(%rax,%rcx,4)
jne    1702 <qr_binary+0x592>
lea    0x9c5(%rip),%rdi
mov    $0x25,%esi
call   1080 <posn@plt>
mov    %eax,-0x74(%rbp)
jmp    1724 <qr_binary+0x5b4>
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
lea    0x99c(%rip),%rdi
movsbl %al,%esi
call   1080 <posn@plt>
mov    %eax,-0x74(%rbp)
movl   $0x1,-0x70(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x74(%rbp),%eax
mov    %eax,-0x7c(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x60(%rbp),%eax
jge    182d <qr_binary+0x6bd>
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x41,%eax
jne    182d <qr_binary+0x6bd>
cmpl   $0x0,0x10(%rbp)
je     17b2 <qr_binary+0x642>
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
cmpl   $0x25,(%rax,%rcx,4)
jne    17b2 <qr_binary+0x642>
lea    0x92d(%rip),%rdi
mov    $0x25,%esi
call   1080 <posn@plt>
mov    %eax,-0x78(%rbp)
movl   $0x2,-0x70(%rbp)
imul   $0x2d,-0x74(%rbp),%eax
add    -0x78(%rbp),%eax
mov    %eax,-0x7c(%rbp)
movl   $0x1,-0x44(%rbp)
jmp    1828 <qr_binary+0x6b8>
cmpl   $0x0,0x10(%rbp)
je     17ec <qr_binary+0x67c>
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
cmpl   $0x5b,(%rax,%rcx,4)
jne    17ec <qr_binary+0x67c>
lea    0x8db(%rip),%rdi
mov    $0x25,%esi
call   1080 <posn@plt>
mov    %eax,-0x78(%rbp)
jmp    180e <qr_binary+0x69e>
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
lea    0x8b2(%rip),%rdi
movsbl %al,%esi
call   1080 <posn@plt>
mov    %eax,-0x78(%rbp)
movl   $0x2,-0x70(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
imul   $0x2d,-0x74(%rbp),%eax
add    -0x78(%rbp),%eax
mov    %eax,-0x7c(%rbp)
jmp    182d <qr_binary+0x6bd>
jmp    1832 <qr_binary+0x6c2>
jmp    1960 <qr_binary+0x7f0>
lea    0x877(%rip),%rdi
mov    $0x25,%esi
call   1080 <posn@plt>
mov    %eax,-0x74(%rbp)
movl   $0x1,-0x70(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x74(%rbp),%eax
mov    %eax,-0x7c(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x60(%rbp),%eax
jge    195b <qr_binary+0x7eb>
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x41,%eax
jne    195b <qr_binary+0x7eb>
cmpl   $0x0,0x10(%rbp)
je     18e0 <qr_binary+0x770>
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
cmpl   $0x25,(%rax,%rcx,4)
jne    18e0 <qr_binary+0x770>
lea    0x7ff(%rip),%rdi
mov    $0x25,%esi
call   1080 <posn@plt>
mov    %eax,-0x78(%rbp)
movl   $0x2,-0x70(%rbp)
imul   $0x2d,-0x74(%rbp),%eax
add    -0x78(%rbp),%eax
mov    %eax,-0x7c(%rbp)
movl   $0x1,-0x44(%rbp)
jmp    1956 <qr_binary+0x7e6>
cmpl   $0x0,0x10(%rbp)
je     191a <qr_binary+0x7aa>
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
cmpl   $0x5b,(%rax,%rcx,4)
jne    191a <qr_binary+0x7aa>
lea    0x7ad(%rip),%rdi
mov    $0x25,%esi
call   1080 <posn@plt>
mov    %eax,-0x78(%rbp)
jmp    193c <qr_binary+0x7cc>
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
lea    0x784(%rip),%rdi
movsbl %al,%esi
call   1080 <posn@plt>
mov    %eax,-0x78(%rbp)
movl   $0x2,-0x70(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
imul   $0x2d,-0x74(%rbp),%eax
add    -0x78(%rbp),%eax
mov    %eax,-0x7c(%rbp)
jmp    195b <qr_binary+0x7eb>
jmp    1960 <qr_binary+0x7f0>
mov    -0xa0(%rbp),%rdx
mov    -0x7c(%rbp),%edi
imul   $0x5,-0x70(%rbp),%esi
add    $0x1,%esi
call   1070 <bin_append@plt>
cmpl   $0x0,0x28(%rbp)
je     1991 <qr_binary+0x821>
mov    -0x7c(%rbp),%esi
lea    0x6dc(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    163c <qr_binary+0x4cc>
cmpl   $0x0,0x28(%rbp)
je     19ae <qr_binary+0x83e>
lea    0x69e(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    1bb3 <qr_binary+0xa43>
mov    -0xa0(%rbp),%rdi
lea    0x722(%rip),%rsi
call   1090 <strcat@plt>
mov    -0x60(%rbp),%eax
mov    %eax,-0xc0(%rbp)
mov    -0xc(%rbp),%edi
mov    $0xa,%esi
mov    $0xc,%edx
mov    $0xe,%ecx
call   1060 <tribus@plt>
mov    -0xc0(%rbp),%edi
mov    -0xa0(%rbp),%rdx
mov    %eax,%esi
call   1070 <bin_append@plt>
cmpl   $0x0,0x28(%rbp)
je     1a15 <qr_binary+0x8a5>
mov    -0x60(%rbp),%esi
lea    0x6da(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x60(%rbp),%eax
jge    1b96 <qr_binary+0xa26>
movl   $0x0,-0x84(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
lea    0x6ba(%rip),%rdi
movsbl %al,%esi
call   1080 <posn@plt>
mov    %eax,-0x84(%rbp)
movl   $0x1,-0x80(%rbp)
mov    -0x84(%rbp),%eax
mov    %eax,-0x88(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
cmp    -0x60(%rbp),%eax
jge    1b4b <qr_binary+0x9db>
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x4e,%eax
jne    1b4b <qr_binary+0x9db>
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
lea    0x653(%rip),%rdi
movsbl %al,%esi
call   1080 <posn@plt>
mov    %eax,-0x8c(%rbp)
movl   $0x2,-0x80(%rbp)
imul   $0xa,-0x88(%rbp),%eax
add    -0x8c(%rbp),%eax
mov    %eax,-0x88(%rbp)
mov    -0x30(%rbp),%eax
add    $0x2,%eax
cmp    -0x60(%rbp),%eax
jge    1b46 <qr_binary+0x9d6>
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    -0x30(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x4e,%eax
jne    1b46 <qr_binary+0x9d6>
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    -0x30(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
lea    0x5e5(%rip),%rdi
movsbl %al,%esi
call   1080 <posn@plt>
mov    %eax,-0x90(%rbp)
movl   $0x3,-0x80(%rbp)
imul   $0xa,-0x88(%rbp),%eax
add    -0x90(%rbp),%eax
mov    %eax,-0x88(%rbp)
jmp    1b4b <qr_binary+0x9db>
mov    -0xa0(%rbp),%rdx
mov    -0x88(%rbp),%edi
imul   $0x3,-0x80(%rbp),%esi
add    $0x1,%esi
call   1070 <bin_append@plt>
cmpl   $0x0,0x28(%rbp)
je     1b88 <qr_binary+0xa18>
mov    -0x88(%rbp),%esi
mov    -0x88(%rbp),%edx
lea    0x58d(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x80(%rbp),%eax
add    -0x30(%rbp),%eax
mov    %eax,-0x30(%rbp)
jmp    1a1c <qr_binary+0x8ac>
cmpl   $0x0,0x28(%rbp)
je     1bae <qr_binary+0xa3e>
lea    0x49e(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    1bb3 <qr_binary+0xa43>
mov    -0x60(%rbp),%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
movslq -0x2c(%rbp),%rax
cmp    -0x28(%rbp),%rax
jb     12e5 <qr_binary+0x175>
mov    -0xa0(%rbp),%rdi
lea    0x541(%rip),%rsi
call   1090 <strcat@plt>
mov    -0xa0(%rbp),%rdi
call   1040 <strlen@plt>
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    $0x8,%ecx
cltd
idiv   %ecx
mov    $0x8,%eax
sub    %edx,%eax
mov    %al,-0x31(%rbp)
movsbl -0x31(%rbp),%eax
cmp    $0x8,%eax
jne    1c12 <qr_binary+0xaa2>
movb   $0x0,-0x31(%rbp)
mov    -0x38(%rbp),%eax
movsbl -0x31(%rbp),%ecx
add    %ecx,%eax
mov    $0x8,%ecx
cltd
idiv   %ecx
mov    %eax,-0x3c(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
movsbl -0x31(%rbp),%ecx
cmp    %ecx,%eax
jge    1c5d <qr_binary+0xaed>
mov    -0xa0(%rbp),%rdi
lea    0x4d2(%rip),%rsi
call   1090 <strcat@plt>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1c2d <qr_binary+0xabd>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    1d00 <qr_binary+0xb90>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
movl   $0x0,-0x94(%rbp)
cmpl   $0x8,-0x94(%rbp)
jge    1ced <qr_binary+0xb7d>
mov    -0xa0(%rbp),%rax
mov    -0x30(%rbp),%ecx
shl    $0x3,%ecx
add    -0x94(%rbp),%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x31,%eax
jne    1cd4 <qr_binary+0xb64>
mov    -0x94(%rbp),%ecx
mov    $0x80,%edx
sar    %cl,%edx
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
add    (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
jmp    1cd9 <qr_binary+0xb69>
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    1c89 <qr_binary+0xb19>
jmp    1cf2 <qr_binary+0xb82>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1c64 <qr_binary+0xaf4>
movl   $0x0,-0x40(%rbp)
mov    -0x3c(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1d67 <qr_binary+0xbf7>
cmpl   $0x0,-0x40(%rbp)
jne    1d3e <qr_binary+0xbce>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
movl   $0xec,(%rax,%rcx,4)
movl   $0x1,-0x40(%rbp)
jmp    1d54 <qr_binary+0xbe4>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
movl   $0x11,(%rax,%rcx,4)
movl   $0x0,-0x40(%rbp)
jmp    1d59 <qr_binary+0xbe9>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1d0d <qr_binary+0xb9d>
cmpl   $0x0,0x28(%rbp)
je     1dc7 <qr_binary+0xc57>
lea    0x3a6(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1db9 <qr_binary+0xc49>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
lea    0x391(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1d86 <qr_binary+0xc16>
lea    0x285(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x50(%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    %r9,-0x60(%rbp)
mov    %r8,-0x38(%rbp)
mov    %rcx,%rbx
mov    %edx,-0x64(%rbp)
mov    %esi,-0x3c(%rbp)
mov    %rdi,%r15
mov    0x18(%rbp),%r14d
mov    0x20(%rbp),%eax
add    $0xc,%eax
mov    %rsp,%r13
add    $0xf,%rax
and    $0xfffffffffffffff0,%rax
sub    %rax,%r13
mov    %r13,%rsp
lea    0xef8(%rip),%rsi
mov    %r13,%rdi
call   1040 <strcpy@plt>
cmpl   $0x0,0x10(%rbp)
je     11e4 <qr_binary+0x64>
lea    0xe6c(%rip),%rsi
mov    %r13,%rdi
call   10a0 <strcat@plt>
mov    0x28(%rbp),%r12d
cmp    $0x3,%r14d
je     123e <qr_binary+0xbe>
lea    0xe58(%rip),%rsi
mov    %r13,%rdi
call   10a0 <strcat@plt>
cmp    $0x7f,%r14d
jg     120d <qr_binary+0x8d>
mov    %r14d,%edi
mov    $0x8,%esi
jmp    1236 <qr_binary+0xb6>
cmp    $0x3fff,%r14d
ja     1227 <qr_binary+0xa7>
add    $0x8000,%r14d
mov    %r14d,%edi
mov    $0x10,%esi
jmp    1236 <qr_binary+0xb6>
add    $0xc00000,%r14d
mov    %r14d,%edi
mov    $0x18,%esi
mov    %r13,%rdx
call   1080 <bin_append@plt>
test   %r12d,%r12d
mov    %r15,-0x70(%rbp)
je     1280 <qr_binary+0x100>
mov    %rbx,%r15
mov    -0x60(%rbp),%r14
test   %r14,%r14
je     1273 <qr_binary+0xf3>
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nop
movsbl (%r15,%rbx,1),%edi
call   1030 <putchar@plt>
add    $0x1,%rbx
cmp    %rbx,%r14
jne    1260 <qr_binary+0xe0>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    %r15,%rbx
lea    0x1(%rbx),%rax
mov    %rax,-0x78(%rbp)
movl   $0x0,-0x2c(%rbp)
xor    %eax,%eax
mov    -0x60(%rbp),%rdi
mov    %r13,-0x48(%rbp)
mov    %rbx,-0x58(%rbp)
jmp    12c7 <qr_binary+0x147>
nop
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    -0x60(%rbp),%rdi
cmp    %rdi,-0x88(%rbp)
mov    -0x48(%rbp),%r13
mov    -0x58(%rbp),%rbx
mov    -0x80(%rbp),%rax
jae    1847 <qr_binary+0x6c7>
mov    %eax,%edx
movsbl (%rbx,%rdx,1),%eax
mov    -0x78(%rbp),%rcx
add    %rdx,%rcx
mov    %rdx,-0x50(%rbp)
add    $0x1,%rdx
xor    %esi,%esi
xchg   %ax,%ax
mov    %rsi,%r14
lea    (%rdx,%rsi,1),%rbx
cmp    %rdi,%rbx
jae    12f6 <qr_binary+0x176>
lea    0x1(%r14),%rsi
cmp    %al,(%rcx,%r14,1)
je     12e0 <qr_binary+0x160>
mov    %rbx,-0x88(%rbp)
mov    -0x50(%rbp),%rcx
add    $0x1,%ecx
add    %r14,%rcx
mov    %rcx,-0x80(%rbp)
add    $0xffffffbf,%eax
cmp    $0xd,%eax
ja     12aa <qr_binary+0x12a>
lea    0x1(%r14),%r15
lea    0xcf2(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x48(%rbp),%rbx
mov    %rbx,%rdi
lea    0xd6c(%rip),%rsi
call   10a0 <strcat@plt>
mov    -0x3c(%rbp),%edi
mov    $0x9,%esi
mov    $0xb,%edx
mov    $0xd,%ecx
call   1070 <tribus@plt>
mov    %r15d,%edi
mov    %eax,%esi
mov    %rbx,%rdx
call   1080 <bin_append@plt>
test   %r12d,%r12d
je     1374 <qr_binary+0x1f4>
lea    0xd3c(%rip),%rdi
mov    %r15d,%esi
xor    %eax,%eax
call   1060 <printf@plt>
xor    %r13d,%r13d
jmp    1389 <qr_binary+0x209>
nopl   0x0(%rax)
cmp    %r14d,%r13d
jg     12aa <qr_binary+0x12a>
cmpl   $0x0,-0x2c(%rbp)
jne    1410 <qr_binary+0x290>
mov    -0x50(%rbp),%rax
add    %r13d,%eax
cltq
cmpl   $0x0,0x10(%rbp)
je     1400 <qr_binary+0x280>
mov    -0x38(%rbp),%rcx
mov    (%rcx,%rax,4),%ecx
cmp    $0x5b,%ecx
je     141e <qr_binary+0x29e>
cmp    $0x25,%ecx
jne    1400 <qr_binary+0x280>
lea    0xd06(%rip),%r15
mov    %r15,%rdi
mov    $0x25,%esi
call   1090 <posn@plt>
mov    %eax,%ebx
mov    %r15,%rdi
mov    $0x25,%esi
call   1090 <posn@plt>
lea    (%rbx,%rbx,8),%ecx
lea    (%rcx,%rcx,4),%r15d
add    %eax,%r15d
add    $0x1,%r13d
mov    $0xb,%esi
movl   $0x0,-0x2c(%rbp)
jmp    14f0 <qr_binary+0x370>
cs nopw 0x0(%rax,%rax,1)
nop
mov    -0x38(%rbp),%rcx
movzbl (%rcx,%rax,4),%eax
jmp    1420 <qr_binary+0x2a0>
nopw   0x0(%rax,%rax,1)
lea    0xca9(%rip),%rdi
mov    $0x25,%esi
jmp    142a <qr_binary+0x2aa>
mov    $0x25,%al
movsbl %al,%esi
lea    0xc96(%rip),%rdi
call   1090 <posn@plt>
mov    %eax,%r15d
lea    0x1(%r13),%ebx
mov    $0x6,%esi
cmp    %r14d,%r13d
jge    14a0 <qr_binary+0x320>
mov    -0x50(%rbp),%rax
add    %ebx,%eax
cltq
mov    -0x58(%rbp),%rcx
cmpb   $0x41,(%rcx,%rax,1)
jne    14a0 <qr_binary+0x320>
mov    -0x38(%rbp),%rcx
mov    (%rcx,%rax,4),%eax
cmpl   $0x0,0x10(%rbp)
je     14ac <qr_binary+0x32c>
cmp    $0x5b,%eax
je     14b5 <qr_binary+0x335>
cmp    $0x25,%eax
jne    14ac <qr_binary+0x32c>
lea    0xc50(%rip),%rdi
mov    $0x25,%esi
call   1090 <posn@plt>
lea    (%r15,%r15,8),%ecx
lea    (%rcx,%rcx,4),%r15d
add    %eax,%r15d
mov    $0xb,%esi
movl   $0x1,-0x2c(%rbp)
mov    %ebx,%r13d
jmp    14f0 <qr_binary+0x370>
cs nopw 0x0(%rax,%rax,1)
movl   $0x0,-0x2c(%rbp)
mov    %ebx,%r13d
jmp    14f0 <qr_binary+0x370>
movl   $0x0,-0x2c(%rbp)
jmp    14be <qr_binary+0x33e>
movl   $0x0,-0x2c(%rbp)
mov    $0x25,%al
movsbl %al,%esi
lea    0xbf8(%rip),%rdi
call   1090 <posn@plt>
add    $0x2,%r13d
lea    (%r15,%r15,8),%ecx
lea    (%rcx,%rcx,4),%r15d
add    %eax,%r15d
mov    $0xb,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %r15d,%edi
mov    -0x48(%rbp),%rdx
call   1080 <bin_append@plt>
test   %r12d,%r12d
je     1380 <qr_binary+0x200>
lea    0xb65(%rip),%rdi
mov    %r15d,%esi
xor    %eax,%eax
call   1060 <printf@plt>
cmp    %r14d,%r13d
jle    1389 <qr_binary+0x209>
jmp    12a0 <qr_binary+0x120>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    -0x48(%rbp),%r13
mov    %r13,%rdi
lea    0xb3a(%rip),%rsi
call   10a0 <strcat@plt>
mov    -0x3c(%rbp),%edi
mov    $0x8,%esi
mov    $0x10,%edx
mov    $0x10,%ecx
call   1070 <tribus@plt>
mov    %r15d,%edi
mov    %eax,%esi
mov    %r13,%rdx
call   1080 <bin_append@plt>
test   %r12d,%r12d
je     157d <qr_binary+0x3fd>
lea    0xb0a(%rip),%rdi
mov    %r15d,%esi
xor    %eax,%eax
call   1060 <printf@plt>
add    $0x1,%r14d
xor    %r15d,%r15d
jmp    159d <qr_binary+0x41d>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%r15
cmp    %r14,%r15
je     12aa <qr_binary+0x12a>
mov    -0x50(%rbp),%rax
add    %r15,%rax
mov    -0x38(%rbp),%rcx
mov    (%rcx,%rax,4),%eax
cmp    $0x5b,%eax
mov    %eax,%ebx
mov    $0x1d,%ecx
cmove  %ecx,%ebx
cmpl   $0x0,0x10(%rbp)
cmove  %eax,%ebx
mov    %ebx,%edi
mov    $0x8,%esi
mov    %r13,%rdx
call   1080 <bin_append@plt>
test   %r12d,%r12d
je     1590 <qr_binary+0x410>
lea    0xabc(%rip),%rdi
mov    %ebx,%esi
mov    %ebx,%edx
xor    %eax,%eax
call   1060 <printf@plt>
add    $0x1,%r15
cmp    %r14,%r15
jne    159d <qr_binary+0x41d>
jmp    12a0 <qr_binary+0x120>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    -0x48(%rbp),%r13
mov    %r13,%rdi
lea    0xa44(%rip),%rsi
call   10a0 <strcat@plt>
mov    -0x3c(%rbp),%edi
mov    $0x8,%esi
mov    $0xa,%edx
mov    $0xc,%ecx
call   1070 <tribus@plt>
mov    %r15d,%edi
mov    %eax,%esi
mov    %r13,%rdx
call   1080 <bin_append@plt>
test   %r12d,%r12d
je     164d <qr_binary+0x4cd>
lea    0xa14(%rip),%rdi
mov    %r15d,%esi
xor    %eax,%eax
call   1060 <printf@plt>
add    $0x1,%r14d
xor    %r15d,%r15d
jmp    166d <qr_binary+0x4ed>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%r15
cmp    %r14,%r15
je     12aa <qr_binary+0x12a>
mov    -0x50(%rbp),%rax
add    %r15,%rax
mov    -0x38(%rbp),%rcx
mov    (%rcx,%rax,4),%eax
lea    -0x8140(%rax),%ecx
lea    -0xe040(%rax),%edx
lea    -0xc140(%rax),%esi
cmp    $0xb80,%edx
cmovae %eax,%esi
cmp    $0x1ebd,%ecx
cmovb  %ecx,%esi
movzbl %sil,%ebx
mov    %esi,%eax
sar    $0x8,%eax
lea    (%rax,%rax,2),%eax
shl    $0x6,%eax
add    %eax,%ebx
mov    %ebx,%edi
mov    $0xd,%esi
mov    %r13,%rdx
call   1080 <bin_append@plt>
test   %r12d,%r12d
je     1660 <qr_binary+0x4e0>
lea    0x9a6(%rip),%rdi
mov    %ebx,%esi
xor    %eax,%eax
call   1060 <printf@plt>
add    $0x1,%r15
cmp    %r14,%r15
jne    166d <qr_binary+0x4ed>
jmp    12a0 <qr_binary+0x120>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    -0x48(%rbp),%rbx
mov    %rbx,%rdi
lea    0x9f0(%rip),%rsi
call   10a0 <strcat@plt>
mov    -0x3c(%rbp),%edi
mov    $0xa,%esi
mov    $0xc,%edx
mov    $0xe,%ecx
call   1070 <tribus@plt>
mov    %r15d,%edi
mov    %eax,%esi
mov    %rbx,%rdx
call   1080 <bin_append@plt>
test   %r12d,%r12d
je     173d <qr_binary+0x5bd>
lea    0x9c0(%rip),%rdi
mov    %r15d,%esi
xor    %eax,%eax
call   1060 <printf@plt>
xor    %r13d,%r13d
jmp    175f <qr_binary+0x5df>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    %r13d,%ebx
mov    %ebx,%r13d
cmp    %r14d,%ebx
ja     12aa <qr_binary+0x12a>
mov    %r13d,%r12d
add    -0x50(%rbp),%r12
mov    %r12d,%eax
mov    -0x38(%rbp),%rcx
movsbl (%rcx,%rax,4),%esi
lea    0x996(%rip),%rdi
call   1090 <posn@plt>
mov    %eax,%r15d
mov    $0x1,%ebx
cmp    %r14d,%r13d
jae    1800 <qr_binary+0x680>
mov    -0x58(%rbp),%rax
cmpb   $0x4e,0x1(%r12,%rax,1)
jne    1800 <qr_binary+0x680>
mov    -0x38(%rbp),%rax
movsbl 0x4(%rax,%r12,4),%esi
lea    0x967(%rip),%rdi
call   1090 <posn@plt>
lea    (%r15,%r15,4),%ecx
lea    (%rax,%rcx,2),%r15d
lea    0x2(%r13),%eax
mov    $0x2,%ebx
cmp    %r14d,%eax
ja     1800 <qr_binary+0x680>
mov    -0x58(%rbp),%rax
cmpb   $0x4e,0x2(%r12,%rax,1)
jne    1800 <qr_binary+0x680>
mov    -0x38(%rbp),%rax
movsbl 0x8(%rax,%r12,4),%esi
lea    0x92f(%rip),%rdi
call   1090 <posn@plt>
lea    (%r15,%r15,4),%ecx
lea    (%rax,%rcx,2),%r15d
mov    $0x3,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    (%rbx,%rbx,2),%esi
add    $0x1,%esi
mov    %r15d,%edi
mov    -0x48(%rbp),%rdx
call   1080 <bin_append@plt>
mov    0x28(%rbp),%r12d
test   %r12d,%r12d
je     1750 <qr_binary+0x5d0>
lea    0x8f3(%rip),%rdi
mov    %r15d,%esi
mov    %r15d,%edx
xor    %eax,%eax
call   1060 <printf@plt>
add    %r13d,%ebx
mov    %ebx,%r13d
cmp    %r14d,%ebx
jbe    175f <qr_binary+0x5df>
jmp    12a0 <qr_binary+0x120>
lea    0x8d6(%rip),%rsi
mov    %r13,%rdi
call   10a0 <strcat@plt>
mov    %r13,%rdi
call   1050 <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     18b0 <qr_binary+0x730>
lea    0x892(%rip),%r15
cs nopw 0x0(%rax,%rax,1)
nop
mov    %r13,%rdi
mov    %r15,%rsi
call   10a0 <strcat@plt>
add    $0xffffffff,%ebx
jne    18a0 <qr_binary+0x720>
sar    $0x3,%r14d
cmp    $0x8,%r12d
mov    -0x70(%rbp),%r12
mov    -0x64(%rbp),%r15d
jl     19aa <qr_binary+0x82a>
mov    %r14d,%eax
xor    %ecx,%ecx
jmp    18dd <qr_binary+0x75d>
nopl   (%rax)
add    $0x1,%rcx
cmp    %rcx,%rax
je     19aa <qr_binary+0x82a>
movl   $0x0,(%r12,%rcx,4)
xor    %edx,%edx
cmpb   $0x31,0x0(%r13,%rcx,8)
sete   %dl
shl    $0x7,%edx
mov    %edx,(%r12,%rcx,4)
cmpb   $0x31,0x1(%r13,%rcx,8)
je     1940 <qr_binary+0x7c0>
cmpb   $0x31,0x2(%r13,%rcx,8)
je     194f <qr_binary+0x7cf>
cmpb   $0x31,0x3(%r13,%rcx,8)
je     195e <qr_binary+0x7de>
cmpb   $0x31,0x4(%r13,%rcx,8)
je     196d <qr_binary+0x7ed>
cmpb   $0x31,0x5(%r13,%rcx,8)
je     197c <qr_binary+0x7fc>
cmpb   $0x31,0x6(%r13,%rcx,8)
je     198b <qr_binary+0x80b>
cmpb   $0x31,0x7(%r13,%rcx,8)
jne    18d0 <qr_binary+0x750>
jmp    199e <qr_binary+0x81e>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
or     $0x40,%edx
mov    %edx,(%r12,%rcx,4)
cmpb   $0x31,0x2(%r13,%rcx,8)
jne    1907 <qr_binary+0x787>
add    $0x20,%edx
mov    %edx,(%r12,%rcx,4)
cmpb   $0x31,0x3(%r13,%rcx,8)
jne    190f <qr_binary+0x78f>
add    $0x10,%edx
mov    %edx,(%r12,%rcx,4)
cmpb   $0x31,0x4(%r13,%rcx,8)
jne    1917 <qr_binary+0x797>
add    $0x8,%edx
mov    %edx,(%r12,%rcx,4)
cmpb   $0x31,0x5(%r13,%rcx,8)
jne    191f <qr_binary+0x79f>
add    $0x4,%edx
mov    %edx,(%r12,%rcx,4)
cmpb   $0x31,0x6(%r13,%rcx,8)
jne    1927 <qr_binary+0x7a7>
add    $0x2,%edx
mov    %edx,(%r12,%rcx,4)
cmpb   $0x31,0x7(%r13,%rcx,8)
jne    18d0 <qr_binary+0x750>
add    $0x1,%edx
mov    %edx,(%r12,%rcx,4)
jmp    18d0 <qr_binary+0x750>
cmp    %r15d,%r14d
jge    1a29 <qr_binary+0x8a9>
movslq %r14d,%rcx
movslq %r15d,%rdx
mov    %rcx,%rsi
not    %rsi
add    %rdx,%rsi
sub    %rcx,%rdx
mov    %edx,%eax
and    $0x3,%eax
cmp    $0x3,%rsi
jb     19ef <qr_binary+0x86f>
and    $0xfffffffffffffffc,%rdx
movaps 0x629(%rip),%xmm0
nopw   0x0(%rax,%rax,1)
movups %xmm0,(%r12,%rcx,4)
add    $0x4,%rcx
add    $0xfffffffffffffffc,%rdx
jne    19e0 <qr_binary+0x860>
test   %rax,%rax
je     1a29 <qr_binary+0x8a9>
lea    (%r12,%rcx,4),%rcx
xor    %edx,%edx
mov    $0xec,%esi
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
test   %edx,%edx
mov    $0x11,%ebx
cmove  %esi,%ebx
xor    $0x1,%edx
mov    %ebx,(%rcx,%rdi,4)
add    $0x1,%rdi
cmp    %rdi,%rax
jne    1a10 <qr_binary+0x890>
cmpl   $0x0,0x28(%rbp)
je     1a71 <qr_binary+0x8f1>
lea    0x6f3(%rip),%rdi
xor    %eax,%eax
call   1060 <printf@plt>
test   %r15d,%r15d
jle    1a67 <qr_binary+0x8e7>
mov    %r15d,%r15d
lea    0x6f4(%rip),%r14
xor    %ebx,%ebx
xchg   %ax,%ax
mov    (%r12,%rbx,4),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1060 <printf@plt>
add    $0x1,%rbx
cmp    %rbx,%r15
jne    1a50 <qr_binary+0x8d0>
mov    $0xa,%edi
call   1030 <putchar@plt>
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, i64 %5, i32 %6, i32 %7, i32 %8, i32 %9) {
%11 = alloca i32*
%12 = alloca i32
%13 = alloca i32
%14 = alloca i8*
%15 = alloca i32*
%16 = alloca i64
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
%20 = alloca i32
%21 = alloca i32
%22 = alloca i32
%23 = alloca i8
%24 = alloca i32
%25 = alloca i32
%26 = alloca i32
%27 = alloca i32
%28 = alloca i8*
%29 = alloca i64
%30 = alloca i8
%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
%44 = alloca i32
store i32* %0, i32** %11
store i32 %1, i32* %12
store i32 %2, i32* %13
store i8* %3, i8** %14
store i32* %4, i32** %15
store i64 %5, i64* %16
store i32 %6, i32* %17
store i32 %7, i32* %18
store i32 %8, i32* %19
store i32 %9, i32* %20
store i32 0, i32* %21
%45 = load i32, i32* %19
%46 = add nsw i32 %45, 12
%47 = zext i32 %46 to i64
%48 = call i8* @llvm.stacksave()
store i8* %48, i8** %28
%49 = alloca i8, i64 %47
store i64 %47, i64* %29
%50 = call i32 @strcpy(i8* %49, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str, i64 0, i64 0))
%51 = load i32, i32* %17
%52 = icmp ne i32 %51, 0
br i1 %52, label %53, label %55
53: ; preds = %10
%54 = call i32 @strcat(i8* %49, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0))
br label %55
55: ; preds = %53, %10
%56 = load i32, i32* %18
%57 = icmp ne i32 %56, 3
br i1 %57, label %58, label %78
58: ; preds = %55
%59 = call i32 @strcat(i8* %49, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.2, i64 0, i64 0))
%60 = load i32, i32* %18
%61 = icmp sle i32 %60, 127
br i1 %61, label %62, label %65
62: ; preds = %58
%63 = load i32, i32* %18
%64 = call i32 @bin_append(i32 %63, i32 8, i8* %49)
br label %77
65: ; preds = %58
%66 = load i32, i32* %18
%67 = icmp sle i32 %66, 16383
br i1 %67, label %68, label %72
68: ; preds = %65
%69 = load i32, i32* %18
%70 = add nsw i32 32768, %69
%71 = call i32 @bin_append(i32 %70, i32 16, i8* %49)
br label %76
72: ; preds = %65
%73 = load i32, i32* %18
%74 = add nsw i32 12582912, %73
%75 = call i32 @bin_append(i32 %74, i32 24, i8* %49)
br label %76
76: ; preds = %72, %68
br label %77
77: ; preds = %76, %62
br label %78
78: ; preds = %77, %55
%79 = load i32, i32* %20
%80 = icmp ne i32 %79, 0
br i1 %80, label %81, label %100
81: ; preds = %78
store i32 0, i32* %22
br label %82
82: ; preds = %95, %81
%83 = load i32, i32* %22
%84 = sext i32 %83 to i64
%85 = load i64, i64* %16
%86 = icmp ult i64 %84, %85
br i1 %86, label %87, label %98
87: ; preds = %82
%88 = load i8*, i8** %14
%89 = load i32, i32* %22
%90 = sext i32 %89 to i64
%91 = getelementptr inbounds i8, i8* %88, i64 %90
%92 = load i8, i8* %91
%93 = sext i8 %92 to i32
%94 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), i32 %93)
br label %95
95: ; preds = %87
%96 = load i32, i32* %22
%97 = add nsw i32 %96, 1
store i32 %97, i32* %22
br label %82
98: ; preds = %82
%99 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0))
br label %100
100: ; preds = %98, %78
store i32 0, i32* %27
br label %101
101: ; preds = %583, %100
%102 = load i8*, i8** %14
%103 = load i32, i32* %21
%104 = sext i32 %103 to i64
%105 = getelementptr inbounds i8, i8* %102, i64 %104
%106 = load i8, i8* %105
store i8 %106, i8* %30
store i32 0, i32* %31
br label %107
107: ; preds = %129, %101
%108 = load i32, i32* %31
%109 = add nsw i32 %108, 1
store i32 %109, i32* %31
br label %110
110: ; preds = %107
%111 = load i32, i32* %31
%112 = load i32, i32* %21
%113 = add nsw i32 %111, %112
%114 = sext i32 %113 to i64
%115 = load i64, i64* %16
%116 = icmp ult i64 %114, %115
br i1 %116, label %117, label %129
117: ; preds = %110
%118 = load i8*, i8** %14
%119 = load i32, i32* %21
%120 = load i32, i32* %31
%121 = add nsw i32 %119, %120
%122 = sext i32 %121 to i64
%123 = getelementptr inbounds i8, i8* %118, i64 %122
%124 = load i8, i8* %123
%125 = sext i8 %124 to i32
%126 = load i8, i8* %30
%127 = sext i8 %126 to i32
%128 = icmp eq i32 %125, %127
br label %129
129: ; preds = %117, %110
%130 = phi i1 [ false, %110 ], [ %128, %117 ]
br i1 %130, label %107, label %131
131: ; preds = %129
%132 = load i8, i8* %30
%133 = sext i8 %132 to i32
switch i32 %133, label %579 [
i32 75, label %134
i32 66, label %200
i32 65, label %249
i32 78, label %469
]
134: ; preds = %131
%135 = call i32 @strcat(i8* %49, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.5, i64 0, i64 0))
%136 = load i32, i32* %31
%137 = load i32, i32* %12
%138 = call i32 @tribus(i32 %137, i32 8, i32 10, i32 12)
%139 = call i32 @bin_append(i32 %136, i32 %138, i8* %49)
%140 = load i32, i32* %20
%141 = icmp ne i32 %140, 0
br i1 %141, label %142, label %145
142: ; preds = %134
%143 = load i32, i32* %31
%144 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str.6, i64 0, i64 0), i32 %143)
br label %145
145: ; preds = %142, %134
store i32 0, i32* %22
br label %146
146: ; preds = %191, %145
%147 = load i32, i32* %22
%148 = load i32, i32* %31
%149 = icmp slt i32 %147, %148
br i1 %149, label %150, label %194
150: ; preds = %146
%151 = load i32*, i32** %15
%152 = load i32, i32* %21
%153 = load i32, i32* %22
%154 = add nsw i32 %152, %153
%155 = sext i32 %154 to i64
%156 = getelementptr inbounds i32, i32* %151, i64 %155
%157 = load i32, i32* %156
store i32 %157, i32* %32
%158 = load i32, i32* %32
%159 = icmp sge i32 %158, 33088
br i1 %159, label %160, label %166
160: ; preds = %150
%161 = load i32, i32* %32
%162 = icmp sle i32 %161, 40956
br i1 %162, label %163, label %166
163: ; preds = %160
%164 = load i32, i32* %32
%165 = sub nsw i32 %164, 33088
store i32 %165, i32* %32
br label %176
166: ; preds = %160, %150
%167 = load i32, i32* %32
%168 = icmp sge i32 %167, 57408
br i1 %168, label %169, label %175
169: ; preds = %166
%170 = load i32, i32* %32
%171 = icmp sle i32 %170, 60351
br i1 %171, label %172, label %175
172: ; preds = %169
%173 = load i32, i32* %32
%174 = sub nsw i32 %173, 49472
store i32 %174, i32* %32
br label %175
175: ; preds = %172, %169, %166
br label %176
176: ; preds = %175, %163
%177 = load i32, i32* %32
%178 = ashr i32 %177, 8
%179 = mul nsw i32 %178, 192
%180 = load i32, i32* %32
%181 = and i32 %180, 255
%182 = add nsw i32 %179, %181
store i32 %182, i32* %33
%183 = load i32, i32* %33
%184 = call i32 @bin_append(i32 %183, i32 13, i8* %49)
%185 = load i32, i32* %20
%186 = icmp ne i32 %185, 0
br i1 %186, label %187, label %190
187: ; preds = %176
%188 = load i32, i32* %33
%189 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.7, i64 0, i64 0), i32 %188)
br label %190
190: ; preds = %187, %176
br label %191
191: ; preds = %190
%192 = load i32, i32* %22
%193 = add nsw i32 %192, 1
store i32 %193, i32* %22
br label %146
194: ; preds = %146
%195 = load i32, i32* %20
%196 = icmp ne i32 %195, 0
br i1 %196, label %197, label %199
197: ; preds = %194
%198 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0))
br label %199
199: ; preds = %197, %194
br label %579
200: ; preds = %131
%201 = call i32 @strcat(i8* %49, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.8, i64 0, i64 0))
%202 = load i32, i32* %31
%203 = load i32, i32* %12
%204 = call i32 @tribus(i32 %203, i32 8, i32 16, i32 16)
%205 = call i32 @bin_append(i32 %202, i32 %204, i8* %49)
%206 = load i32, i32* %20
%207 = icmp ne i32 %206, 0
br i1 %207, label %208, label %211
208: ; preds = %200
%209 = load i32, i32* %31
%210 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.9, i64 0, i64 0), i32 %209)
br label %211
211: ; preds = %208, %200
store i32 0, i32* %22
br label %212
212: ; preds = %240, %211
%213 = load i32, i32* %22
%214 = load i32, i32* %31
%215 = icmp slt i32 %213, %214
br i1 %215, label %216, label %243
216: ; preds = %212
%217 = load i32*, i32** %15
%218 = load i32, i32* %21
%219 = load i32, i32* %22
%220 = add nsw i32 %218, %219
%221 = sext i32 %220 to i64
%222 = getelementptr inbounds i32, i32* %217, i64 %221
%223 = load i32, i32* %222
store i32 %223, i32* %34
%224 = load i32, i32* %17
%225 = icmp ne i32 %224, 0
br i1 %225, label %226, label %230
226: ; preds = %216
%227 = load i32, i32* %34
%228 = icmp eq i32 %227, 91
br i1 %228, label %229, label %230
229: ; preds = %226
store i32 29, i32* %34
br label %230
230: ; preds = %229, %226, %216
%231 = load i32, i32* %34
%232 = call i32 @bin_append(i32 %231, i32 8, i8* %49)
%233 = load i32, i32* %20
%234 = icmp ne i32 %233, 0
br i1 %234, label %235, label %239
235: ; preds = %230
%236 = load i32, i32* %34
%237 = load i32, i32* %34
%238 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.10, i64 0, i64 0), i32 %236, i32 %237)
br label %239
239: ; preds = %235, %230
br label %240
240: ; preds = %239
%241 = load i32, i32* %22
%242 = add nsw i32 %241, 1
store i32 %242, i32* %22
br label %212
243: ; preds = %212
%244 = load i32, i32* %20
%245 = icmp ne i32 %244, 0
br i1 %245, label %246, label %248
246: ; preds = %243
%247 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0))
br label %248
248: ; preds = %246, %243
br label %579
249: ; preds = %131
%250 = call i32 @strcat(i8* %49, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.11, i64 0, i64 0))
%251 = load i32, i32* %31
%252 = load i32, i32* %12
%253 = call i32 @tribus(i32 %252, i32 9, i32 11, i32 13)
%254 = call i32 @bin_append(i32 %251, i32 %253, i8* %49)
%255 = load i32, i32* %20
%256 = icmp ne i32 %255, 0
br i1 %256, label %257, label %260
257: ; preds = %249
%258 = load i32, i32* %31
%259 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str.12, i64 0, i64 0), i32 %258)
br label %260
260: ; preds = %257, %249
store i32 0, i32* %22
br label %261
261: ; preds = %462, %260
%262 = load i32, i32* %22
%263 = load i32, i32* %31
%264 = icmp slt i32 %262, %263
br i1 %264, label %265, label %463
265: ; preds = %261
store i32 0, i32* %36
store i32 0, i32* %37
%266 = load i32, i32* %27
%267 = icmp eq i32 %266, 0
br i1 %267, label %268, label %382
268: ; preds = %265
%269 = load i32, i32* %17
%270 = icmp ne i32 %269, 0
br i1 %270, label %271, label %289
271: ; preds = %268
%272 = load i32*, i32** %15
%273 = load i32, i32* %21
%274 = load i32, i32* %22
%275 = add nsw i32 %273, %274
%276 = sext i32 %275 to i64
%277 = getelementptr inbounds i32, i32* %272, i64 %276
%278 = load i32, i32* %277
%279 = icmp eq i32 %278, 37
br i1 %279, label %280, label %289
280: ; preds = %271
%281 = call i32 @posn(i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.13, i64 0, i64 0), i8 signext 37)
store i32 %281, i32* %36
%282 = call i32 @posn(i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.13, i64 0, i64 0), i8 signext 37)
store i32 %282, i32* %37
store i32 2, i32* %35
%283 = load i32, i32* %36
%284 = mul nsw i32 %283, 45
%285 = load i32, i32* %37
%286 = add nsw i32 %284, %285
store i32 %286, i32* %38
%287 = load i32, i32* %22
%288 = add nsw i32 %287, 1
store i32 %288, i32* %22
br label %381
289: ; preds = %271, %268
%290 = load i32, i32* %17
%291 = icmp ne i32 %290, 0
br i1 %291, label %292, label %303
292: ; preds = %289
%293 = load i32*, i32** %15
%294 = load i32, i32* %21
%295 = load i32, i32* %22
%296 = add nsw i32 %294, %295
%297 = sext i32 %296 to i64
%298 = getelementptr inbounds i32, i32* %293, i64 %297
%299 = load i32, i32* %298
%300 = icmp eq i32 %299, 91
br i1 %300, label %301, label %303
301: ; preds = %292
%302 = call i32 @posn(i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.13, i64 0, i64 0), i8 signext 37)
store i32 %302, i32* %36
br label %313
303: ; preds = %292, %289
%304 = load i32*, i32** %15
%305 = load i32, i32* %21
%306 = load i32, i32* %22
%307 = add nsw i32 %305, %306
%308 = sext i32 %307 to i64
%309 = getelementptr inbounds i32, i32* %304, i64 %308
%310 = load i32, i32* %309
%311 = trunc i32 %310 to i8
%312 = call i32 @posn(i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.13, i64 0, i64 0), i8 signext %311)
store i32 %312, i32* %36
br label %313
313: ; preds = %303, %301
store i32 1, i32* %35
%314 = load i32, i32* %22
%315 = add nsw i32 %314, 1
store i32 %315, i32* %22
%316 = load i32, i32* %36
store i32 %316, i32* %38
%317 = load i32, i32* %22
%318 = load i32, i32* %31
%319 = icmp slt i32 %317, %318
br i1 %319, label %320, label %380
320: ; preds = %313
%321 = load i8*, i8** %14
%322 = load i32, i32* %21
%323 = load i32, i32* %22
%324 = add nsw i32 %322, %323
%325 = sext i32 %324 to i64
%326 = getelementptr inbounds i8, i8* %321, i64 %325
%327 = load i8, i8* %326
%328 = sext i8 %327 to i32
%329 = icmp eq i32 %328, 65
br i1 %329, label %330, label %380
330: ; preds = %320
%331 = load i32, i32* %17
%332 = icmp ne i32 %331, 0
br i1 %332, label %333, label %348
333: ; preds = %330
%334 = load i32*, i32** %15
%335 = load i32, i32* %21
%336 = load i32, i32* %22
%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, 37
br i1 %341, label %342, label %348
342: ; preds = %333
%343 = call i32 @posn(i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.13, i64 0, i64 0), i8 signext 37)
store i32 %343, i32* %37
store i32 2, i32* %35
%344 = load i32, i32* %36
%345 = mul nsw i32 %344, 45
%346 = load i32, i32* %37
%347 = add nsw i32 %345, %346
store i32 %347, i32* %38
store i32 1, i32* %27
br label %379
348: ; preds = %333, %330
%349 = load i32, i32* %17
%350 = icmp ne i32 %349, 0
br i1 %350, label %351, label %362
351: ; preds = %348
%352 = load i32*, i32** %15
%353 = load i32, i32* %21
%354 = load i32, i32* %22
%355 = add nsw i32 %353, %354
%356 = sext i32 %355 to i64
%357 = getelementptr inbounds i32, i32* %352, i64 %356
%358 = load i32, i32* %357
%359 = icmp eq i32 %358, 91
br i1 %359, label %360, label %362
360: ; preds = %351
%361 = call i32 @posn(i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.13, i64 0, i64 0), i8 signext 37)
store i32 %361, i32* %37
br label %372
362: ; preds = %351, %348
%363 = load i32*, i32** %15
%364 = load i32, i32* %21
%365 = load i32, i32* %22
%366 = add nsw i32 %364, %365
%367 = sext i32 %366 to i64
%368 = getelementptr inbounds i32, i32* %363, i64 %367
%369 = load i32, i32* %368
%370 = trunc i32 %369 to i8
%371 = call i32 @posn(i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.13, i64 0, i64 0), i8 signext %370)
store i32 %371, i32* %37
br label %372
372: ; preds = %362, %360
store i32 2, i32* %35
%373 = load i32, i32* %22
%374 = add nsw i32 %373, 1
store i32 %374, i32* %22
%375 = load i32, i32* %36
%376 = mul nsw i32 %375, 45
%377 = load i32, i32* %37
%378 = add nsw i32 %376, %377
store i32 %378, i32* %38
br label %379
379: ; preds = %372, %342
br label %380
380: ; preds = %379, %320, %313
br label %381
381: ; preds = %380, %280
br label %451
382: ; preds = %265
%383 = call i32 @posn(i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.13, i64 0, i64 0), i8 signext 37)
store i32 %383, i32* %36
store i32 1, i32* %35
%384 = load i32, i32* %22
%385 = add nsw i32 %384, 1
store i32 %385, i32* %22
%386 = load i32, i32* %36
store i32 %386, i32* %38
store i32 0, i32* %27
%387 = load i32, i32* %22
%388 = load i32, i32* %31
%389 = icmp slt i32 %387, %388
br i1 %389, label %390, label %450
390: ; preds = %382
%391 = load i8*, i8** %14
%392 = load i32, i32* %21
%393 = load i32, i32* %22
%394 = add nsw i32 %392, %393
%395 = sext i32 %394 to i64
%396 = getelementptr inbounds i8, i8* %391, i64 %395
%397 = load i8, i8* %396
%398 = sext i8 %397 to i32
%399 = icmp eq i32 %398, 65
br i1 %399, label %400, label %450
400: ; preds = %390
%401 = load i32, i32* %17
%402 = icmp ne i32 %401, 0
br i1 %402, label %403, label %418
403: ; preds = %400
%404 = load i32*, i32** %15
%405 = load i32, i32* %21
%406 = load i32, i32* %22
%407 = add nsw i32 %405, %406
%408 = sext i32 %407 to i64
%409 = getelementptr inbounds i32, i32* %404, i64 %408
%410 = load i32, i32* %409
%411 = icmp eq i32 %410, 37
br i1 %411, label %412, label %418
412: ; preds = %403
%413 = call i32 @posn(i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.13, i64 0, i64 0), i8 signext 37)
store i32 %413, i32* %37
store i32 2, i32* %35
%414 = load i32, i32* %36
%415 = mul nsw i32 %414, 45
%416 = load i32, i32* %37
%417 = add nsw i32 %415, %416
store i32 %417, i32* %38
store i32 1, i32* %27
br label %449
418: ; preds = %403, %400
%419 = load i32, i32* %17
%420 = icmp ne i32 %419, 0
br i1 %420, label %421, label %432
421: ; preds = %418
%422 = load i32*, i32** %15
%423 = load i32, i32* %21
%424 = load i32, i32* %22
%425 = add nsw i32 %423, %424
%426 = sext i32 %425 to i64
%427 = getelementptr inbounds i32, i32* %422, i64 %426
%428 = load i32, i32* %427
%429 = icmp eq i32 %428, 91
br i1 %429, label %430, label %432
430: ; preds = %421
%431 = call i32 @posn(i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.13, i64 0, i64 0), i8 signext 37)
store i32 %431, i32* %37
br label %442
432: ; preds = %421, %418
%433 = load i32*, i32** %15
%434 = load i32, i32* %21
%435 = load i32, i32* %22
%436 = add nsw i32 %434, %435
%437 = sext i32 %436 to i64
%438 = getelementptr inbounds i32, i32* %433, i64 %437
%439 = load i32, i32* %438
%440 = trunc i32 %439 to i8
%441 = call i32 @posn(i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.13, i64 0, i64 0), i8 signext %440)
store i32 %441, i32* %37
br label %442
442: ; preds = %432, %430
store i32 2, i32* %35
%443 = load i32, i32* %22
%444 = add nsw i32 %443, 1
store i32 %444, i32* %22
%445 = load i32, i32* %36
%446 = mul nsw i32 %445, 45
%447 = load i32, i32* %37
%448 = add nsw i32 %446, %447
store i32 %448, i32* %38
br label %449
449: ; preds = %442, %412
br label %450
450: ; preds = %449, %390, %382
br label %451
451: ; preds = %450, %381
%452 = load i32, i32* %38
%453 = load i32, i32* %35
%454 = mul nsw i32 5, %453
%455 = add nsw i32 1, %454
%456 = call i32 @bin_append(i32 %452, i32 %455, i8* %49)
%457 = load i32, i32* %20
%458 = icmp ne i32 %457, 0
br i1 %458, label %459, label %462
459: ; preds = %451
%460 = load i32, i32* %38
%461 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.7, i64 0, i64 0), i32 %460)
br label %462
462: ; preds = %459, %451
br label %261
463: ; preds = %261
%464 = load i32, i32* %20
%465 = icmp ne i32 %464, 0
br i1 %465, label %466, label %468
466: ; preds = %463
%467 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0))
br label %468
468: ; preds = %466, %463
br label %579
469: ; preds = %131
%470 = call i32 @strcat(i8* %49, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.14, i64 0, i64 0))
%471 = load i32, i32* %31
%472 = load i32, i32* %12
%473 = call i32 @tribus(i32 %472, i32 10, i32 12, i32 14)
%474 = call i32 @bin_append(i32 %471, i32 %473, i8* %49)
%475 = load i32, i32* %20
%476 = icmp ne i32 %475, 0
br i1 %476, label %477, label %480
477: ; preds = %469
%478 = load i32, i32* %31
%479 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str.15, i64 0, i64 0), i32 %478)
br label %480
480: ; preds = %477, %469
store i32 0, i32* %22
br label %481
481: ; preds = %569, %480
%482 = load i32, i32* %22
%483 = load i32, i32* %31
%484 = icmp slt i32 %482, %483
br i1 %484, label %485, label %573
485: ; preds = %481
store i32 0, i32* %40
%486 = load i32*, i32** %15
%487 = load i32, i32* %21
%488 = load i32, i32* %22
%489 = add nsw i32 %487, %488
%490 = sext i32 %489 to i64
%491 = getelementptr inbounds i32, i32* %486, i64 %490
%492 = load i32, i32* %491
%493 = trunc i32 %492 to i8
%494 = call i32 @posn(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.16, i64 0, i64 0), i8 signext %493)
store i32 %494, i32* %40
store i32 1, i32* %39
%495 = load i32, i32* %40
store i32 %495, i32* %41
%496 = load i32, i32* %22
%497 = add nsw i32 %496, 1
%498 = load i32, i32* %31
%499 = icmp slt i32 %497, %498
br i1 %499, label %500, label %557
500: ; preds = %485
%501 = load i8*, i8** %14
%502 = load i32, i32* %21
%503 = load i32, i32* %22
%504 = add nsw i32 %502, %503
%505 = add nsw i32 %504, 1
%506 = sext i32 %505 to i64
%507 = getelementptr inbounds i8, i8* %501, i64 %506
%508 = load i8, i8* %507
%509 = sext i8 %508 to i32
%510 = icmp eq i32 %509, 78
br i1 %510, label %511, label %557
511: ; preds = %500
%512 = load i32*, i32** %15
%513 = load i32, i32* %21
%514 = load i32, i32* %22
%515 = add nsw i32 %513, %514
%516 = add nsw i32 %515, 1
%517 = sext i32 %516 to i64
%518 = getelementptr inbounds i32, i32* %512, i64 %517
%519 = load i32, i32* %518
%520 = trunc i32 %519 to i8
%521 = call i32 @posn(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.16, i64 0, i64 0), i8 signext %520)
store i32 %521, i32* %42
store i32 2, i32* %39
%522 = load i32, i32* %41
%523 = mul nsw i32 %522, 10
%524 = load i32, i32* %42
%525 = add nsw i32 %523, %524
store i32 %525, i32* %41
%526 = load i32, i32* %22
%527 = add nsw i32 %526, 2
%528 = load i32, i32* %31
%529 = icmp slt i32 %527, %528
br i1 %529, label %530, label %556
530: ; preds = %511
%531 = load i8*, i8** %14
%532 = load i32, i32* %21
%533 = load i32, i32* %22
%534 = add nsw i32 %532, %533
%535 = add nsw i32 %534, 2
%536 = sext i32 %535 to i64
%537 = getelementptr inbounds i8, i8* %531, i64 %536
%538 = load i8, i8* %537
%539 = sext i8 %538 to i32
%540 = icmp eq i32 %539, 78
br i1 %540, label %541, label %556
541: ; preds = %530
%542 = load i32*, i32** %15
%543 = load i32, i32* %21
%544 = load i32, i32* %22
%545 = add nsw i32 %543, %544
%546 = add nsw i32 %545, 2
%547 = sext i32 %546 to i64
%548 = getelementptr inbounds i32, i32* %542, i64 %547
%549 = load i32, i32* %548
%550 = trunc i32 %549 to i8
%551 = call i32 @posn(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.16, i64 0, i64 0), i8 signext %550)
store i32 %551, i32* %43
store i32 3, i32* %39
%552 = load i32, i32* %41
%553 = mul nsw i32 %552, 10
%554 = load i32, i32* %43
%555 = add nsw i32 %553, %554
store i32 %555, i32* %41
br label %556
556: ; preds = %541, %530, %511
br label %557
557: ; preds = %556, %500, %485
%558 = load i32, i32* %41
%559 = load i32, i32* %39
%560 = mul nsw i32 3, %559
%561 = add nsw i32 1, %560
%562 = call i32 @bin_append(i32 %558, i32 %561, i8* %49)
%563 = load i32, i32* %20
%564 = icmp ne i32 %563, 0
br i1 %564, label %565, label %569
565: ; preds = %557
%566 = load i32, i32* %41
%567 = load i32, i32* %41
%568 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.17, i64 0, i64 0), i32 %566, i32 %567)
br label %569
569: ; preds = %565, %557
%570 = load i32, i32* %39
%571 = load i32, i32* %22
%572 = add nsw i32 %571, %570
store i32 %572, i32* %22
br label %481
573: ; preds = %481
%574 = load i32, i32* %20
%575 = icmp ne i32 %574, 0
br i1 %575, label %576, label %578
576: ; preds = %573
%577 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0))
br label %578
578: ; preds = %576, %573
br label %579
579: ; preds = %131, %578, %468, %248, %199
%580 = load i32, i32* %31
%581 = load i32, i32* %21
%582 = add nsw i32 %581, %580
store i32 %582, i32* %21
br label %583
583: ; preds = %579
%584 = load i32, i32* %21
%585 = sext i32 %584 to i64
%586 = load i64, i64* %16
%587 = icmp ult i64 %585, %586
br i1 %587, label %101, label %588
588: ; preds = %583
%589 = call i32 @strcat(i8* %49, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.18, i64 0, i64 0))
%590 = call i64 @strlen(i8* %49)
%591 = trunc i64 %590 to i32
store i32 %591, i32* %24
%592 = load i32, i32* %24
%593 = srem i32 %592, 8
%594 = sub nsw i32 8, %593
%595 = trunc i32 %594 to i8
store i8 %595, i8* %23
%596 = load i8, i8* %23
%597 = sext i8 %596 to i32
%598 = icmp eq i32 %597, 8
br i1 %598, label %599, label %600
599: ; preds = %588
store i8 0, i8* %23
br label %600
600: ; preds = %599, %588
%601 = load i32, i32* %24
%602 = load i8, i8* %23
%603 = sext i8 %602 to i32
%604 = add nsw i32 %601, %603
%605 = sdiv i32 %604, 8
store i32 %605, i32* %25
store i32 0, i32* %22
br label %606
606: ; preds = %613, %600
%607 = load i32, i32* %22
%608 = load i8, i8* %23
%609 = sext i8 %608 to i32
%610 = icmp slt i32 %607, %609
br i1 %610, label %611, label %616
611: ; preds = %606
%612 = call i32 @strcat(i8* %49, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.19, i64 0, i64 0))
br label %613
613: ; preds = %611
%614 = load i32, i32* %22
%615 = add nsw i32 %614, 1
store i32 %615, i32* %22
br label %606
616: ; preds = %606
store i32 0, i32* %22
br label %617
617: ; preds = %653, %616
%618 = load i32, i32* %22
%619 = load i32, i32* %25
%620 = icmp slt i32 %618, %619
br i1 %620, label %621, label %656
621: ; preds = %617
%622 = load i32*, i32** %11
%623 = load i32, i32* %22
%624 = sext i32 %623 to i64
%625 = getelementptr inbounds i32, i32* %622, i64 %624
store i32 0, i32* %625
store i32 0, i32* %44
br label %626
626: ; preds = %649, %621
%627 = load i32, i32* %44
%628 = icmp slt i32 %627, 8
br i1 %628, label %629, label %652
629: ; preds = %626
%630 = load i32, i32* %22
%631 = mul nsw i32 %630, 8
%632 = load i32, i32* %44
%633 = add nsw i32 %631, %632
%634 = sext i32 %633 to i64
%635 = getelementptr inbounds i8, i8* %49, 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 %648
639: ; preds = %629
%640 = load i32, i32* %44
%641 = ashr i32 128, %640
%642 = load i32*, i32** %11
%643 = load i32, i32* %22
%644 = sext i32 %643 to i64
%645 = getelementptr inbounds i32, i32* %642, i64 %644
%646 = load i32, i32* %645
%647 = add nsw i32 %646, %641
store i32 %647, i32* %645
br label %648
648: ; preds = %639, %629
br label %649
649: ; preds = %648
%650 = load i32, i32* %44
%651 = add nsw i32 %650, 1
store i32 %651, i32* %44
br label %626
652: ; preds = %626
br label %653
653: ; preds = %652
%654 = load i32, i32* %22
%655 = add nsw i32 %654, 1
store i32 %655, i32* %22
br label %617
656: ; preds = %617
store i32 0, i32* %26
%657 = load i32, i32* %25
store i32 %657, i32* %22
br label %658
658: ; preds = %676, %656
%659 = load i32, i32* %22
%660 = load i32, i32* %13
%661 = icmp slt i32 %659, %660
br i1 %661, label %662, label %679
662: ; preds = %658
%663 = load i32, i32* %26
%664 = icmp eq i32 %663, 0
br i1 %664, label %665, label %670
665: ; preds = %662
%666 = load i32*, i32** %11
%667 = load i32, i32* %22
%668 = sext i32 %667 to i64
%669 = getelementptr inbounds i32, i32* %666, i64 %668
store i32 236, i32* %669
store i32 1, i32* %26
br label %675
670: ; preds = %662
%671 = load i32*, i32** %11
%672 = load i32, i32* %22
%673 = sext i32 %672 to i64
%674 = getelementptr inbounds i32, i32* %671, i64 %673
store i32 17, i32* %674
store i32 0, i32* %26
br label %675
675: ; preds = %670, %665
br label %676
676: ; preds = %675
%677 = load i32, i32* %22
%678 = add nsw i32 %677, 1
store i32 %678, i32* %22
br label %658
679: ; preds = %658
%680 = load i32, i32* %20
%681 = icmp ne i32 %680, 0
br i1 %681, label %682, label %700
682: ; preds = %679
%683 = 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 %684
684: ; preds = %695, %682
%685 = load i32, i32* %22
%686 = load i32, i32* %13
%687 = icmp slt i32 %685, %686
br i1 %687, label %688, label %698
688: ; preds = %684
%689 = load i32*, i32** %11
%690 = load i32, i32* %22
%691 = sext i32 %690 to i64
%692 = getelementptr inbounds i32, i32* %689, i64 %691
%693 = load i32, i32* %692
%694 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.21, i64 0, i64 0), i32 %693)
br label %695
695: ; preds = %688
%696 = load i32, i32* %22
%697 = add nsw i32 %696, 1
store i32 %697, i32* %22
br label %684
698: ; preds = %684
%699 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0))
br label %700
700: ; preds = %698, %679
%701 = load i8*, i8** %28
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.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* nocapture %0, i32 %1, i32 %2, i8* nocapture %3, i32* nocapture %4, i64 %5, i32 %6, i32 %7, i32 %8, i32 %9) {
%11 = add nsw i32 %8, 12
%12 = zext i32 %11 to i64
%13 = alloca i8, i64 %12
%14 = call i32 @strcpy(i8* %13, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str, i64 0, i64 0))
%15 = icmp ne i32 %6, 0
br i1 %15, label %16, label %18
16: ; preds = %10
%17 = call i32 @strcat(i8* %13, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0))
br label %18
18: ; preds = %16, %10
%19 = icmp eq i32 %7, 3
br i1 %19, label %33, label %20
20: ; preds = %18
%21 = call i32 @strcat(i8* %13, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.2, i64 0, i64 0))
%22 = icmp slt i32 %7, 128
br i1 %22, label %23, label %25
23: ; preds = %20
%24 = call i32 @bin_append(i32 %7, i32 8, i8* %13)
br label %33
25: ; preds = %20
%26 = icmp ult i32 %7, 16384
br i1 %26, label %27, label %30
27: ; preds = %25
%28 = add nuw nsw i32 %7, 32768
%29 = call i32 @bin_append(i32 %28, i32 16, i8* %13)
br label %33
30: ; preds = %25
%31 = add nuw nsw i32 %7, 12582912
%32 = call i32 @bin_append(i32 %31, i32 24, i8* %13)
br label %33
33: ; preds = %23, %30, %27, %18
%34 = icmp eq i32 %9, 0
br i1 %34, label %47, label %35
35: ; preds = %33
%36 = icmp eq i64 %5, 0
br i1 %36, label %45, label %37
37: ; preds = %35, %37
%38 = phi i64 [ %43, %37 ], [ 0, %35 ]
%39 = getelementptr inbounds i8, i8* %3, i64 %38
%40 = load i8, i8* %39
%41 = sext i8 %40 to i32
%42 = call i32 @putchar(i32 %41)
%43 = add nuw i64 %38, 1
%44 = icmp eq i64 %43, %5
br i1 %44, label %45, label %37
45: ; preds = %37, %35
%46 = call i32 @putchar(i32 10)
br label %47
47: ; preds = %45, %33
br label %48
48: ; preds = %47, %284
%49 = phi i32 [ %285, %284 ], [ 0, %47 ]
%50 = phi i32 [ %64, %284 ], [ 0, %47 ]
%51 = zext i32 %50 to i64
%52 = getelementptr inbounds i8, i8* %3, i64 %51
%53 = load i8, i8* %52
br label %54
54: ; preds = %59, %48
%55 = phi i64 [ %56, %59 ], [ 0, %48 ]
%56 = add nuw i64 %55, 1
%57 = add nuw nsw i64 %56, %51
%58 = icmp ult i64 %57, %5
br i1 %58, label %59, label %63
59: ; preds = %54
%60 = getelementptr inbounds i8, i8* %3, i64 %57
%61 = load i8, i8* %60
%62 = icmp eq i8 %61, %53
br i1 %62, label %54, label %63
63: ; preds = %54, %59
%64 = trunc i64 %57 to i32
%65 = trunc i64 %56 to i32
%66 = trunc i64 %55 to i32
%67 = sext i8 %53 to i32
switch i32 %67, label %284 [
i32 75, label %68
i32 66, label %103
i32 65, label %130
i32 78, label %222
]
68: ; preds = %63
%69 = call i32 @strcat(i8* %13, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.5, i64 0, i64 0))
%70 = call i32 @tribus(i32 %1, i32 8, i32 10, i32 12)
%71 = call i32 @bin_append(i32 %65, i32 %70, i8* %13)
br i1 %34, label %74, label %72
72: ; preds = %68
%73 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([26 x i8], [26 x i8]* @.str.6, i64 0, i64 0), i32 %65)
br label %74
74: ; preds = %72, %68
%75 = add i64 %55, 1
%76 = and i64 %75, 4294967295
br label %77
77: ; preds = %97, %74
%78 = phi i64 [ 0, %74 ], [ %98, %97 ]
%79 = add nuw nsw i64 %78, %51
%80 = getelementptr inbounds i32, i32* %4, i64 %79
%81 = load i32, i32* %80
%82 = add i32 %81, -33088
%83 = icmp ult i32 %82, 7869
%84 = add i32 %81, -57408
%85 = icmp ult i32 %84, 2944
%86 = add nsw i32 %81, -49472
%87 = select i1 %85, i32 %86, i32 %81
%88 = select i1 %83, i32 %82, i32 %87
%89 = ashr i32 %88, 8
%90 = mul nsw i32 %89, 192
%91 = and i32 %88, 255
%92 = add nsw i32 %90, %91
%93 = call i32 @bin_append(i32 %92, i32 13, i8* %13)
br i1 %34, label %94, label %99
94: ; preds = %77
%95 = add nuw nsw i64 %78, 1
%96 = icmp eq i64 %95, %76
br i1 %96, label %284, label %97
97: ; preds = %94, %99
%98 = phi i64 [ %95, %94 ], [ %101, %99 ]
br label %77
99: ; preds = %77
%100 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.7, i64 0, i64 0), i32 %92)
%101 = add nuw nsw i64 %78, 1
%102 = icmp eq i64 %101, %76
br i1 %102, label %281, label %97
103: ; preds = %63
%104 = call i32 @strcat(i8* %13, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.8, i64 0, i64 0))
%105 = call i32 @tribus(i32 %1, i32 8, i32 16, i32 16)
%106 = call i32 @bin_append(i32 %65, i32 %105, i8* %13)
br i1 %34, label %109, label %107
107: ; preds = %103
%108 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([25 x i8], [25 x i8]* @.str.9, i64 0, i64 0), i32 %65)
br label %109
109: ; preds = %107, %103
%110 = add i64 %55, 1
%111 = and i64 %110, 4294967295
br label %112
112: ; preds = %124, %109
%113 = phi i64 [ 0, %109 ], [ %125, %124 ]
%114 = add nuw nsw i64 %113, %51
%115 = getelementptr inbounds i32, i32* %4, i64 %114
%116 = load i32, i32* %115
%117 = icmp eq i32 %116, 91
%118 = select i1 %15, i1 %117, i1 false
%119 = select i1 %118, i32 29, i32 %116
%120 = call i32 @bin_append(i32 %119, i32 8, i8* %13)
br i1 %34, label %121, label %126
121: ; preds = %112
%122 = add nuw nsw i64 %113, 1
%123 = icmp eq i64 %122, %111
br i1 %123, label %284, label %124
124: ; preds = %121, %126
%125 = phi i64 [ %122, %121 ], [ %128, %126 ]
br label %112
126: ; preds = %112
%127 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([11 x i8], [11 x i8]* @.str.10, i64 0, i64 0), i32 %119, i32 %119)
%128 = add nuw nsw i64 %113, 1
%129 = icmp eq i64 %128, %111
br i1 %129, label %281, label %124
130: ; preds = %63
%131 = call i32 @strcat(i8* %13, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.11, i64 0, i64 0))
%132 = call i32 @tribus(i32 %1, i32 9, i32 11, i32 13)
%133 = call i32 @bin_append(i32 %65, i32 %132, i8* %13)
br i1 %34, label %136, label %134
134: ; preds = %130
%135 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([26 x i8], [26 x i8]* @.str.12, i64 0, i64 0), i32 %65)
br label %136
136: ; preds = %134, %130
br label %137
137: ; preds = %218, %136
%138 = phi i32 [ 0, %136 ], [ %214, %218 ]
%139 = phi i32 [ %49, %136 ], [ %211, %218 ]
%140 = icmp eq i32 %139, 0
br i1 %140, label %141, label %184
141: ; preds = %137
%142 = add nsw i32 %138, %50
%143 = sext i32 %142 to i64
br i1 %15, label %144, label %153
144: ; preds = %141
%145 = getelementptr inbounds i32, i32* %4, i64 %143
%146 = load i32, i32* %145
switch i32 %146, label %153 [
i32 37, label %147
i32 91, label %157
]
147: ; preds = %144
%148 = call i32 @posn(i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.13, i64 0, i64 0), i8 signext 37)
%149 = call i32 @posn(i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.13, i64 0, i64 0), i8 signext 37)
%150 = mul nsw i32 %148, 45
%151 = add nsw i32 %150, %149
%152 = add nsw i32 %138, 1
br label %210
153: ; preds = %141, %144
%154 = getelementptr inbounds i32, i32* %4, i64 %143
%155 = load i32, i32* %154
%156 = trunc i32 %155 to i8
br label %157
157: ; preds = %144, %153
%158 = phi i8 [ %156, %153 ], [ 37, %144 ]
%159 = call i32 @posn(i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.13, i64 0, i64 0), i8 signext %158)
%160 = add nsw i32 %138, 1
%161 = icmp slt i32 %138, %66
br i1 %161, label %162, label %210
162: ; preds = %157
%163 = add nsw i32 %160, %50
%164 = sext i32 %163 to i64
%165 = getelementptr inbounds i8, i8* %3, i64 %164
%166 = load i8, i8* %165
%167 = icmp eq i8 %166, 65
br i1 %167, label %168, label %210
168: ; preds = %162
%169 = getelementptr inbounds i32, i32* %4, i64 %164
%170 = load i32, i32* %169
br i1 %15, label %171, label %176
171: ; preds = %168
switch i32 %170, label %176 [
i32 37, label %172
i32 91, label %178
]
172: ; preds = %171
%173 = call i32 @posn(i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.13, i64 0, i64 0), i8 signext 37)
%174 = mul nsw i32 %159, 45
%175 = add nsw i32 %173, %174
br label %210
176: ; preds = %168, %171
%177 = trunc i32 %170 to i8
br label %178
178: ; preds = %171, %176
%179 = phi i8 [ %177, %176 ], [ 37, %171 ]
%180 = call i32 @posn(i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.13, i64 0, i64 0), i8 signext %179)
%181 = add nsw i32 %138, 2
%182 = mul nsw i32 %159, 45
%183 = add nsw i32 %180, %182
br label %210
184: ; preds = %137
%185 = call i32 @posn(i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.13, i64 0, i64 0), i8 signext 37)
%186 = add nsw i32 %138, 1
%187 = icmp slt i32 %138, %66
br i1 %187, label %188, label %210
188: ; preds = %184
%189 = add nsw i32 %186, %50
%190 = sext i32 %189 to i64
%191 = getelementptr inbounds i8, i8* %3, i64 %190
%192 = load i8, i8* %191
%193 = icmp eq i8 %192, 65
br i1 %193, label %194, label %210
194: ; preds = %188
%195 = getelementptr inbounds i32, i32* %4, i64 %190
%196 = load i32, i32* %195
br i1 %15, label %197, label %202
197: ; preds = %194
switch i32 %196, label %202 [
i32 37, label %198
i32 91, label %204
]
198: ; preds = %197
%199 = call i32 @posn(i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.13, i64 0, i64 0), i8 signext 37)
%200 = mul nsw i32 %185, 45
%201 = add nsw i32 %199, %200
br label %210
202: ; preds = %194, %197
%203 = trunc i32 %196 to i8
br label %204
204: ; preds = %197, %202
%205 = phi i8 [ %203, %202 ], [ 37, %197 ]
%206 = call i32 @posn(i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.13, i64 0, i64 0), i8 signext %205)
%207 = add nsw i32 %138, 2
%208 = mul nsw i32 %185, 45
%209 = add nsw i32 %206, %208
br label %210
210: ; preds = %184, %188, %204, %198, %147, %172, %178, %162, %157
%211 = phi i32 [ 0, %147 ], [ 1, %172 ], [ 0, %178 ], [ 0, %162 ], [ 0, %157 ], [ 1, %198 ], [ 0, %204 ], [ 0, %188 ], [ 0, %184 ]
%212 = phi i32 [ 11, %147 ], [ 11, %172 ], [ 11, %178 ], [ 6, %162 ], [ 6, %157 ], [ 11, %198 ], [ 11, %204 ], [ 6, %188 ], [ 6, %184 ]
%213 = phi i32 [ %151, %147 ], [ %175, %172 ], [ %183, %178 ], [ %159, %162 ], [ %159, %157 ], [ %201, %198 ], [ %209, %204 ], [ %185, %188 ], [ %185, %184 ]
%214 = phi i32 [ %152, %147 ], [ %160, %172 ], [ %181, %178 ], [ %160, %162 ], [ %160, %157 ], [ %186, %198 ], [ %207, %204 ], [ %186, %188 ], [ %186, %184 ]
%215 = call i32 @bin_append(i32 %213, i32 %212, i8* %13)
br i1 %34, label %216, label %219
216: ; preds = %210
%217 = icmp sgt i32 %214, %66
br i1 %217, label %284, label %218
218: ; preds = %216, %219
br label %137
219: ; preds = %210
%220 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.7, i64 0, i64 0), i32 %213)
%221 = icmp sgt i32 %214, %66
br i1 %221, label %281, label %218
222: ; preds = %63
%223 = call i32 @strcat(i8* %13, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.14, i64 0, i64 0))
%224 = call i32 @tribus(i32 %1, i32 10, i32 12, i32 14)
%225 = call i32 @bin_append(i32 %65, i32 %224, i8* %13)
br i1 %34, label %228, label %226
226: ; preds = %222
%227 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([27 x i8], [27 x i8]* @.str.15, i64 0, i64 0), i32 %65)
br label %228
228: ; preds = %226, %222
br label %229
229: ; preds = %275, %228
%230 = phi i32 [ 0, %228 ], [ %276, %275 ]
%231 = add nuw nsw i32 %230, %50
%232 = zext i32 %231 to i64
%233 = getelementptr inbounds i32, i32* %4, i64 %232
%234 = load i32, i32* %233
%235 = trunc i32 %234 to i8
%236 = call i32 @posn(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.16, i64 0, i64 0), i8 signext %235)
%237 = icmp ult i32 %230, %66
br i1 %237, label %238, label %266
238: ; preds = %229
%239 = add nuw nsw i32 %231, 1
%240 = zext i32 %239 to i64
%241 = getelementptr inbounds i8, i8* %3, i64 %240
%242 = load i8, i8* %241
%243 = icmp eq i8 %242, 78
br i1 %243, label %244, label %266
244: ; preds = %238
%245 = getelementptr inbounds i32, i32* %4, i64 %240
%246 = load i32, i32* %245
%247 = trunc i32 %246 to i8
%248 = call i32 @posn(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.16, i64 0, i64 0), i8 signext %247)
%249 = mul nsw i32 %236, 10
%250 = add nsw i32 %248, %249
%251 = add nuw nsw i32 %230, 2
%252 = icmp ugt i32 %251, %66
br i1 %252, label %266, label %253
253: ; preds = %244
%254 = add nuw nsw i32 %231, 2
%255 = zext i32 %254 to i64
%256 = getelementptr inbounds i8, i8* %3, i64 %255
%257 = load i8, i8* %256
%258 = icmp eq i8 %257, 78
br i1 %258, label %259, label %266
259: ; preds = %253
%260 = getelementptr inbounds i32, i32* %4, i64 %255
%261 = load i32, i32* %260
%262 = trunc i32 %261 to i8
%263 = call i32 @posn(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.16, i64 0, i64 0), i8 signext %262)
%264 = mul nsw i32 %250, 10
%265 = add nsw i32 %263, %264
br label %266
266: ; preds = %244, %253, %259, %238, %229
%267 = phi i32 [ 1, %238 ], [ 1, %229 ], [ 3, %259 ], [ 2, %253 ], [ 2, %244 ]
%268 = phi i32 [ %236, %238 ], [ %236, %229 ], [ %265, %259 ], [ %250, %253 ], [ %250, %244 ]
%269 = mul nuw nsw i32 %267, 3
%270 = add nuw nsw i32 %269, 1
%271 = call i32 @bin_append(i32 %268, i32 %270, i8* %13)
br i1 %34, label %272, label %277
272: ; preds = %266
%273 = add nuw nsw i32 %267, %230
%274 = icmp ugt i32 %273, %66
br i1 %274, label %284, label %275
275: ; preds = %272, %277
%276 = phi i32 [ %273, %272 ], [ %279, %277 ]
br label %229
277: ; preds = %266
%278 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([11 x i8], [11 x i8]* @.str.17, i64 0, i64 0), i32 %268, i32 %268)
%279 = add nuw nsw i32 %267, %230
%280 = icmp ugt i32 %279, %66
br i1 %280, label %281, label %275
281: ; preds = %277, %219, %126, %99
%282 = phi i32 [ %49, %99 ], [ %49, %126 ], [ %211, %219 ], [ %49, %277 ]
%283 = call i32 @putchar(i32 10)
br label %284
284: ; preds = %272, %216, %121, %94, %281, %63
%285 = phi i32 [ %49, %63 ], [ %282, %281 ], [ %49, %94 ], [ %49, %121 ], [ %211, %216 ], [ %49, %272 ]
br i1 %58, label %48, label %286
286: ; preds = %284
%287 = call i32 @strcat(i8* %13, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.18, i64 0, i64 0))
%288 = call i64 @strlen(i8* %13)
%289 = trunc i64 %288 to i32
%290 = srem i32 %289, 8
%291 = trunc i32 %290 to i8
%292 = sub nsw i32 8, %290
%293 = icmp eq i8 %291, 0
%294 = select i1 %293, i32 0, i32 %292
%295 = add nsw i32 %294, %289
%296 = sdiv i32 %295, 8
%297 = icmp eq i32 %294, 0
br i1 %297, label %298, label %302
298: ; preds = %302, %286
%299 = icmp sgt i32 %295, 7
br i1 %299, label %300, label %307
300: ; preds = %298
%301 = zext i32 %296 to i64
br label %319
302: ; preds = %286, %302
%303 = phi i32 [ %305, %302 ], [ 0, %286 ]
%304 = call i32 @strcat(i8* %13, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.19, i64 0, i64 0))
%305 = add nuw i32 %303, 1
%306 = icmp eq i32 %305, %294
br i1 %306, label %298, label %302
307: ; preds = %382, %298
%308 = icmp slt i32 %296, %2
br i1 %308, label %309, label %412
309: ; preds = %307
%310 = sext i32 %296 to i64
%311 = sext i32 %2 to i64
%312 = sub nsw i64 %311, %310
%313 = xor i64 %310, -1
%314 = add nsw i64 %313, %311
%315 = and i64 %312, 3
%316 = icmp ult i64 %314, 3
br i1 %316, label %398, label %317
317: ; preds = %309
%318 = and i64 %312, -4
br label %385
319: ; preds = %300, %382
%320 = phi i64 [ 0, %300 ], [ %383, %382 ]
%321 = getelementptr inbounds i32, i32* %0, i64 %320
store i32 0, i32* %321
%322 = shl nsw i64 %320, 3
%323 = getelementptr inbounds i8, i8* %13, i64 %322
%324 = load i8, i8* %323
%325 = icmp eq i8 %324, 49
%326 = select i1 %325, i32 128, i32 0
store i32 %326, i32* %321
%327 = select i1 %325, i32 128, i32 0
%328 = or i64 %322, 1
%329 = getelementptr inbounds i8, i8* %13, i64 %328
%330 = load i8, i8* %329
%331 = icmp eq i8 %330, 49
br i1 %331, label %332, label %334
332: ; preds = %319
%333 = or i32 %327, 64
store i32 %333, i32* %321
br label %334
334: ; preds = %332, %319
%335 = phi i32 [ %333, %332 ], [ %327, %319 ]
%336 = or i64 %322, 2
%337 = getelementptr inbounds i8, i8* %13, i64 %336
%338 = load i8, i8* %337
%339 = icmp eq i8 %338, 49
br i1 %339, label %340, label %342
340: ; preds = %334
%341 = add nsw i32 %335, 32
store i32 %341, i32* %321
br label %342
342: ; preds = %340, %334
%343 = phi i32 [ %341, %340 ], [ %335, %334 ]
%344 = or i64 %322, 3
%345 = getelementptr inbounds i8, i8* %13, i64 %344
%346 = load i8, i8* %345
%347 = icmp eq i8 %346, 49
br i1 %347, label %348, label %350
348: ; preds = %342
%349 = add nsw i32 %343, 16
store i32 %349, i32* %321
br label %350
350: ; preds = %348, %342
%351 = phi i32 [ %349, %348 ], [ %343, %342 ]
%352 = or i64 %322, 4
%353 = getelementptr inbounds i8, i8* %13, i64 %352
%354 = load i8, i8* %353
%355 = icmp eq i8 %354, 49
br i1 %355, label %356, label %358
356: ; preds = %350
%357 = add nsw i32 %351, 8
store i32 %357, i32* %321
br label %358
358: ; preds = %356, %350
%359 = phi i32 [ %357, %356 ], [ %351, %350 ]
%360 = or i64 %322, 5
%361 = getelementptr inbounds i8, i8* %13, i64 %360
%362 = load i8, i8* %361
%363 = icmp eq i8 %362, 49
br i1 %363, label %364, label %366
364: ; preds = %358
%365 = add nsw i32 %359, 4
store i32 %365, i32* %321
br label %366
366: ; preds = %364, %358
%367 = phi i32 [ %365, %364 ], [ %359, %358 ]
%368 = or i64 %322, 6
%369 = getelementptr inbounds i8, i8* %13, i64 %368
%370 = load i8, i8* %369
%371 = icmp eq i8 %370, 49
br i1 %371, label %372, label %374
372: ; preds = %366
%373 = add nsw i32 %367, 2
store i32 %373, i32* %321
br label %374
374: ; preds = %372, %366
%375 = phi i32 [ %373, %372 ], [ %367, %366 ]
%376 = or i64 %322, 7
%377 = getelementptr inbounds i8, i8* %13, i64 %376
%378 = load i8, i8* %377
%379 = icmp eq i8 %378, 49
br i1 %379, label %380, label %382
380: ; preds = %374
%381 = add nsw i32 %375, 1
store i32 %381, i32* %321
br label %382
382: ; preds = %380, %374
%383 = add nuw nsw i64 %320, 1
%384 = icmp eq i64 %383, %301
br i1 %384, label %307, label %319
385: ; preds = %385, %317
%386 = phi i64 [ %310, %317 ], [ %395, %385 ]
%387 = phi i64 [ 0, %317 ], [ %396, %385 ]
%388 = getelementptr inbounds i32, i32* %0, i64 %386
store i32 236, i32* %388
%389 = add nsw i64 %386, 1
%390 = getelementptr inbounds i32, i32* %0, i64 %389
store i32 17, i32* %390
%391 = add nsw i64 %386, 2
%392 = getelementptr inbounds i32, i32* %0, i64 %391
store i32 236, i32* %392
%393 = add nsw i64 %386, 3
%394 = getelementptr inbounds i32, i32* %0, i64 %393
store i32 17, i32* %394
%395 = add nsw i64 %386, 4
%396 = add i64 %387, 4
%397 = icmp eq i64 %396, %318
br i1 %397, label %398, label %385
398: ; preds = %385, %309
%399 = phi i64 [ %310, %309 ], [ %395, %385 ]
%400 = icmp eq i64 %315, 0
br i1 %400, label %412, label %401
401: ; preds = %398, %401
%402 = phi i64 [ %409, %401 ], [ %399, %398 ]
%403 = phi i32 [ %407, %401 ], [ 0, %398 ]
%404 = phi i64 [ %410, %401 ], [ 0, %398 ]
%405 = icmp eq i32 %403, 0
%406 = select i1 %405, i32 236, i32 17
%407 = xor i32 %403, 1
%408 = getelementptr inbounds i32, i32* %0, i64 %402
store i32 %406, i32* %408
%409 = add nsw i64 %402, 1
%410 = add i64 %404, 1
%411 = icmp eq i64 %410, %315
br i1 %411, label %412, label %401
412: ; preds = %398, %401, %307
br i1 %34, label %427, label %413
413: ; preds = %412
%414 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([23 x i8], [23 x i8]* @.str.20, i64 0, i64 0))
%415 = icmp sgt i32 %2, 0
br i1 %415, label %416, label %425
416: ; preds = %413
%417 = zext i32 %2 to i64
br label %418
418: ; preds = %416, %418
%419 = phi i64 [ 0, %416 ], [ %423, %418 ]
%420 = getelementptr inbounds i32, i32* %0, i64 %419
%421 = load i32, i32* %420
%422 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.21, i64 0, i64 0), i32 %421)
%423 = add nuw nsw i64 %419, 1
%424 = icmp eq i64 %423, %417
br i1 %424, label %425, label %418
425: ; preds = %418, %413
%426 = call i32 @putchar(i32 10)
br label %427
427: ; preds = %425, %412
ret void
}