#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*/ add_byte_count(char *, size_t, int);
int /*<<< orphan*/ add_shift_char(char *, int);
int posn(char *, int);
int /*<<< orphan*/ printf(char *, ...);
int seek_forward(int *, int, int, int);
int /*<<< orphan*/ strcat(char *, char *);
int /*<<< orphan*/ strcpy(char *, char *);
int strlen(char *);
int gm_encode(int gbdata[], int length, char binary[], int reader, int eci) {
  int sp, current_mode, next_mode, last_mode, glyph = 0, q;
  int c1, c2, done;
  int p = 0, ppos;
  int numbuf[3], punt = 0;
  size_t number_pad_posn, byte_count_posn = 0;
  int byte_count = 0, debug = 0;
  int shift, i;
  strcpy(binary, "");
  sp = 0;
  current_mode = 0;
  last_mode = 0;
  number_pad_posn = 0;
  if (reader) {
    strcat(binary, "1010");
  }
  if (eci != 3) {
    strcat(binary, "11000");
    for (q = 0; q < 10; q++) {
      if (eci & (0x100 >> q)) {
        strcat(binary, "1");
      } else {
        strcat(binary, "0");
      }
    }
  }
  do {
    next_mode = seek_forward(gbdata, length, sp, current_mode);
    if (next_mode != current_mode) {
      switch (current_mode) {
      case 0:
        switch (next_mode) {
        case 7:
          strcat(binary, "0001");
          break;
        case 1:
          strcat(binary, "0010");
          break;
        case 2:
          strcat(binary, "0011");
          break;
        case 3:
          strcat(binary, "0100");
          break;
        case 4:
          strcat(binary, "0101");
          break;
        case 6:
          strcat(binary, "0111");
          break;
        }
        break;
      case 7:
        switch (next_mode) {
        case 1:
          strcat(binary, "1111111100001");
          break;
        case 2:
          strcat(binary, "1111111100010");
          break;
        case 3:
          strcat(binary, "1111111100011");
          break;
        case 4:
          strcat(binary, "1111111100100");
          break;
        case 6:
          strcat(binary, "1111111100101");
          break;
        }
        break;
      case 1:
        switch (p) {
        case 1:
          binary[number_pad_posn] = '1';
          binary[number_pad_posn + 1] = '0';
          break;
        case 2:
          binary[number_pad_posn] = '0';
          binary[number_pad_posn + 1] = '1';
          break;
        case 3:
          binary[number_pad_posn] = '0';
          binary[number_pad_posn + 1] = '0';
          break;
        }
        switch (next_mode) {
        case 7:
          strcat(binary, "1111111011");
          break;
        case 2:
          strcat(binary, "1111111100");
          break;
        case 3:
          strcat(binary, "1111111101");
          break;
        case 4:
          strcat(binary, "1111111110");
          break;
        case 6:
          strcat(binary, "1111111111");
          break;
        }
        break;
      case 2:
      case 3:
        switch (next_mode) {
        case 7:
          strcat(binary, "11100");
          break;
        case 1:
          strcat(binary, "11101");
          break;
        case 2:
        case 3:
          strcat(binary, "11110");
          break;
        case 4:
          strcat(binary, "1111100");
          break;
        case 6:
          strcat(binary, "1111110");
          break;
        }
        break;
      case 4:
        switch (next_mode) {
        case 7:
          strcat(binary, "1111110001");
          break;
        case 1:
          strcat(binary, "1111110010");
          break;
        case 2:
          strcat(binary, "1111110011");
          break;
        case 3:
          strcat(binary, "1111110100");
          break;
        case 6:
          strcat(binary, "1111110111");
          break;
        }
        break;
      case 6:
        add_byte_count(binary, byte_count_posn, byte_count);
        byte_count = 0;
        switch (next_mode) {
        case 7:
          strcat(binary, "0001");
          break;
        case 1:
          strcat(binary, "0010");
          break;
        case 2:
          strcat(binary, "0011");
          break;
        case 3:
          strcat(binary, "0100");
          break;
        case 4:
          strcat(binary, "0101");
          break;
        }
        break;
      }
      if (debug) {
        switch (next_mode) {
        case 7:
          printf("CHIN ");
          break;
        case 1:
          printf("NUMB ");
          break;
        case 2:
          printf("LOWR ");
          break;
        case 3:
          printf("UPPR ");
          break;
        case 4:
          printf("MIXD ");
          break;
        case 6:
          printf("BYTE ");
          break;
        }
      }
    }
    last_mode = current_mode;
    current_mode = next_mode;
    switch (current_mode) {
    case 7:
      done = 0;
      if (gbdata[sp] > 0xff) {
        c1 = (gbdata[sp] & 0xff00) >> 8;
        c2 = gbdata[sp] & 0xff;
        if ((c1 >= 0xa0) && (c1 <= 0xa9)) {
          glyph = (0x60 * (c1 - 0xa1)) + (c2 - 0xa0);
        }
        if ((c1 >= 0xb0) && (c1 <= 0xf7)) {
          glyph = (0x60 * (c1 - 0xb0 + 9)) + (c2 - 0xa0);
        }
        done = 1;
      }
      if (!(done)) {
        if (sp != (length - 1)) {
          if ((gbdata[sp] == 0x13) && (gbdata[sp + 1] == 0x10)) {
            glyph = 7776;
            sp++;
          }
          done = 1;
        }
      }
      if (!(done)) {
        if (sp != (length - 1)) {
          if (((gbdata[sp] >= '0') && (gbdata[sp] <= '9')) &&
              ((gbdata[sp + 1] >= '0') && (gbdata[sp + 1] <= '9'))) {
            glyph = 8033 + (10 * (gbdata[sp] - '0')) + (gbdata[sp + 1] - '0');
            sp++;
          }
        }
      }
      if (!(done)) {
        glyph = 7777 + gbdata[sp];
      }
      if (debug) {
        printf("[%d] ", glyph);
      }
      for (q = 0; q < 13; q++) {
        if (glyph & (0x1000 >> q)) {
          strcat(binary, "1");
        } else {
          strcat(binary, "0");
        }
      }
      sp++;
      break;
    case 1:
      if (last_mode != current_mode) {
        number_pad_posn = strlen(binary);
        strcat(binary, "XX");
      }
      p = 0;
      ppos = -1;
      numbuf[0] = '0';
      numbuf[1] = '0';
      numbuf[2] = '0';
      do {
        if ((gbdata[sp] >= '0') && (gbdata[sp] <= '9')) {
          numbuf[p] = gbdata[sp];
          sp++;
          p++;
        }
        switch (gbdata[sp]) {
        case ' ':
        case '+':
        case '-':
        case '.':
        case ',':
          punt = gbdata[sp];
          sp++;
          ppos = p;
          break;
        }
        if (sp < (length - 1)) {
          if ((gbdata[sp] == 0x13) && (gbdata[sp + 1] == 0x10)) {
            punt = gbdata[sp];
            sp += 2;
            ppos = p;
          }
        }
      } while ((p < 3) && (sp < length));
      if (ppos != -1) {
        switch (punt) {
        case ' ':
          glyph = 0;
          break;
        case '+':
          glyph = 3;
          break;
        case '-':
          glyph = 6;
          break;
        case '.':
          glyph = 9;
          break;
        case ',':
          glyph = 12;
          break;
        case 0x13:
          glyph = 15;
          break;
        }
        glyph += ppos;
        glyph += 1000;
        if (debug) {
          printf("[%d] ", glyph);
        }
        for (q = 0; q < 10; q++) {
          if (glyph & (0x200 >> q)) {
            strcat(binary, "1");
          } else {
            strcat(binary, "0");
          }
        }
      }
      glyph = (100 * (numbuf[0] - '0')) + (10 * (numbuf[1] - '0')) +
              (numbuf[2] - '0');
      if (debug) {
        printf("[%d] ", glyph);
      }
      for (q = 0; q < 10; q++) {
        if (glyph & (0x200 >> q)) {
          strcat(binary, "1");
        } else {
          strcat(binary, "0");
        }
      }
      break;
    case 6:
      if (last_mode != current_mode) {
        byte_count_posn = strlen(binary);
        strcat(binary, "LLLLLLLLL");
      }
      if (byte_count == 512) {
        add_byte_count(binary, byte_count_posn, byte_count);
        strcat(binary, "0111");
        byte_count_posn = strlen(binary);
        strcat(binary, "LLLLLLLLL");
        byte_count = 0;
      }
      glyph = gbdata[sp];
      if (debug) {
        printf("[%d] ", glyph);
      }
      for (q = 0; q < 8; q++) {
        if (glyph & (0x80 >> q)) {
          strcat(binary, "1");
        } else {
          strcat(binary, "0");
        }
      }
      sp++;
      byte_count++;
      break;
    case 4:
      shift = 1;
      if ((gbdata[sp] >= '0') && (gbdata[sp] <= '9')) {
        shift = 0;
      }
      if ((gbdata[sp] >= 'A') && (gbdata[sp] <= 'Z')) {
        shift = 0;
      }
      if ((gbdata[sp] >= 'a') && (gbdata[sp] <= 'z')) {
        shift = 0;
      }
      if (gbdata[sp] == ' ') {
        shift = 0;
      }
      if (shift == 0) {
        glyph = posn(
            "0123456789ABCDEFGHIJKLMOPRSTUVWXYZabcdefghijklmnopqrstuvwxyz ",
            gbdata[sp]);
        if (debug) {
          printf("[%d] ", glyph);
        }
        for (q = 0; q < 6; q++) {
          if (glyph & (0x20 >> q)) {
            strcat(binary, "1");
          } else {
            strcat(binary, "0");
          }
        }
      } else {
        strcat(binary, "1111110110");
        add_shift_char(binary, gbdata[sp]);
      }
      sp++;
      break;
    case 3:
      shift = 1;
      if ((gbdata[sp] >= 'A') && (gbdata[sp] <= 'Z')) {
        shift = 0;
      }
      if (gbdata[sp] == ' ') {
        shift = 0;
      }
      if (shift == 0) {
        glyph = posn("ABCDEFGHIJKLMNOPQRSTUVWXYZ ", gbdata[sp]);
        if (debug) {
          printf("[%d] ", glyph);
        }
        for (q = 0; q < 5; q++) {
          if (glyph & (0x10 >> q)) {
            strcat(binary, "1");
          } else {
            strcat(binary, "0");
          }
        }
      } else {
        strcat(binary, "1111101");
        add_shift_char(binary, gbdata[sp]);
      }
      sp++;
      break;
    case 2:
      shift = 1;
      if ((gbdata[sp] >= 'a') && (gbdata[sp] <= 'z')) {
        shift = 0;
      }
      if (gbdata[sp] == ' ') {
        shift = 0;
      }
      if (shift == 0) {
        glyph = posn("abcdefghijklmnopqrstuvwxyz ", gbdata[sp]);
        if (debug) {
          printf("[%d] ", glyph);
        }
        for (q = 0; q < 5; q++) {
          if (glyph & (0x10 >> q)) {
            strcat(binary, "1");
          } else {
            strcat(binary, "0");
          }
        }
      } else {
        strcat(binary, "1111101");
        add_shift_char(binary, gbdata[sp]);
      }
      sp++;
      break;
    }
    if (strlen(binary) > 9191) {
      return 5;
    }
  } while (sp < length);
  if (current_mode == 1) {
    switch (p) {
    case 1:
      binary[number_pad_posn] = '1';
      binary[number_pad_posn + 1] = '0';
      break;
    case 2:
      binary[number_pad_posn] = '0';
      binary[number_pad_posn + 1] = '1';
      break;
    case 3:
      binary[number_pad_posn] = '0';
      binary[number_pad_posn + 1] = '0';
      break;
    }
  }
  if (current_mode == 6) {
    add_byte_count(binary, byte_count_posn, byte_count);
  }
  switch (current_mode) {
  case 7:
    strcat(binary, "1111111100000");
    break;
  case 1:
    strcat(binary, "1111111010");
    break;
  case 2:
  case 3:
    strcat(binary, "11011");
    break;
  case 4:
    strcat(binary, "1111110000");
    break;
  case 6:
    strcat(binary, "0000");
    break;
  }
  p = 7 - (strlen(binary) % 7);
  if (p == 7) {
    p = 0;
  }
  for (i = 0; i < p; i++) {
    strcat(binary, "0");
  }
  if (strlen(binary) > 9191) {
    return 5;
  }
  return 0;
}


x86 assembly (clang, -O0):
<gm_encode>:
push   %rbp
mov    %rsp,%rbp
sub    $0x100,%rsp
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %ecx,-0x24(%rbp)
mov    %r8d,-0x28(%rbp)
movl   $0x0,-0x3c(%rbp)
movl   $0x0,-0x50(%rbp)
movl   $0x0,-0x64(%rbp)
movq   $0x0,-0x78(%rbp)
movl   $0x0,-0x7c(%rbp)
movl   $0x0,-0x80(%rbp)
mov    -0x20(%rbp),%rdi
lea    0x2076(%rip),%rsi
call   1030 <strcpy@plt>
movl   $0x0,-0x2c(%rbp)
movl   $0x0,-0x30(%rbp)
movl   $0x0,-0x38(%rbp)
movq   $0x0,-0x70(%rbp)
cmpl   $0x0,-0x24(%rbp)
je     120f <gm_encode+0x8f>
mov    -0x20(%rbp),%rdi
lea    0x20e4(%rip),%rsi
call   1080 <strcat@plt>
cmpl   $0x3,-0x28(%rbp)
je     1291 <gm_encode+0x111>
mov    -0x20(%rbp),%rdi
lea    0x1f60(%rip),%rsi
call   1080 <strcat@plt>
movl   $0x0,-0x40(%rbp)
cmpl   $0xa,-0x40(%rbp)
jge    128c <gm_encode+0x10c>
mov    -0x28(%rbp),%eax
mov    -0x40(%rbp),%ecx
mov    $0x100,%edx
sar    %cl,%edx
mov    %edx,%ecx
and    %ecx,%eax
cmp    $0x0,%eax
je     1269 <gm_encode+0xe9>
mov    -0x20(%rbp),%rdi
lea    0x1f37(%rip),%rsi
call   1080 <strcat@plt>
jmp    1279 <gm_encode+0xf9>
mov    -0x20(%rbp),%rdi
lea    0x2072(%rip),%rsi
call   1080 <strcat@plt>
jmp    127e <gm_encode+0xfe>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1230 <gm_encode+0xb0>
jmp    1291 <gm_encode+0x111>
jmp    1296 <gm_encode+0x116>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x2c(%rbp),%edx
mov    -0x30(%rbp),%ecx
call   1060 <seek_forward@plt>
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x30(%rbp),%eax
je     17e2 <gm_encode+0x662>
mov    -0x30(%rbp),%eax
mov    %rax,-0x90(%rbp)
sub    $0x7,%rax
ja     1732 <gm_encode+0x5b2>
mov    -0x90(%rbp),%rax
lea    0x1d27(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x34(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,%ecx
mov    %rcx,-0x98(%rbp)
sub    $0x6,%eax
ja     138a <gm_encode+0x20a>
mov    -0x98(%rbp),%rax
lea    0x1d9c(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x20(%rbp),%rdi
lea    0x1e77(%rip),%rsi
call   1080 <strcat@plt>
jmp    138a <gm_encode+0x20a>
mov    -0x20(%rbp),%rdi
lea    0x1e70(%rip),%rsi
call   1080 <strcat@plt>
jmp    138a <gm_encode+0x20a>
mov    -0x20(%rbp),%rdi
lea    0x1e69(%rip),%rsi
call   1080 <strcat@plt>
jmp    138a <gm_encode+0x20a>
mov    -0x20(%rbp),%rdi
lea    0x1e62(%rip),%rsi
call   1080 <strcat@plt>
jmp    138a <gm_encode+0x20a>
mov    -0x20(%rbp),%rdi
lea    0x1e5b(%rip),%rsi
call   1080 <strcat@plt>
jmp    138a <gm_encode+0x20a>
mov    -0x20(%rbp),%rdi
lea    0x1eb4(%rip),%rsi
call   1080 <strcat@plt>
jmp    1732 <gm_encode+0x5b2>
mov    -0x34(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,%ecx
mov    %rcx,-0xa0(%rbp)
sub    $0x5,%eax
ja     1422 <gm_encode+0x2a2>
mov    -0xa0(%rbp),%rax
lea    0x1cd7(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x20(%rbp),%rdi
lea    0x1dc1(%rip),%rsi
call   1080 <strcat@plt>
jmp    1422 <gm_encode+0x2a2>
mov    -0x20(%rbp),%rdi
lea    0x1dba(%rip),%rsi
call   1080 <strcat@plt>
jmp    1422 <gm_encode+0x2a2>
mov    -0x20(%rbp),%rdi
lea    0x1db3(%rip),%rsi
call   1080 <strcat@plt>
jmp    1422 <gm_encode+0x2a2>
mov    -0x20(%rbp),%rdi
lea    0x1dac(%rip),%rsi
call   1080 <strcat@plt>
jmp    1422 <gm_encode+0x2a2>
mov    -0x20(%rbp),%rdi
lea    0x1da5(%rip),%rsi
call   1080 <strcat@plt>
jmp    1732 <gm_encode+0x5b2>
mov    -0x50(%rbp),%eax
mov    %eax,-0xa4(%rbp)
sub    $0x1,%eax
je     1466 <gm_encode+0x2e6>
jmp    143e <gm_encode+0x2be>
mov    -0xa4(%rbp),%eax
sub    $0x2,%eax
je     1484 <gm_encode+0x304>
jmp    1452 <gm_encode+0x2d2>
mov    -0xa4(%rbp),%eax
sub    $0x3,%eax
je     14a2 <gm_encode+0x322>
jmp    14bb <gm_encode+0x33b>
mov    -0x20(%rbp),%rax
mov    -0x70(%rbp),%rcx
movb   $0x31,(%rax,%rcx,1)
mov    -0x20(%rbp),%rax
mov    -0x70(%rbp),%rcx
movb   $0x30,0x1(%rax,%rcx,1)
jmp    14bb <gm_encode+0x33b>
mov    -0x20(%rbp),%rax
mov    -0x70(%rbp),%rcx
movb   $0x30,(%rax,%rcx,1)
mov    -0x20(%rbp),%rax
mov    -0x70(%rbp),%rcx
movb   $0x31,0x1(%rax,%rcx,1)
jmp    14bb <gm_encode+0x33b>
mov    -0x20(%rbp),%rax
mov    -0x70(%rbp),%rcx
movb   $0x30,(%rax,%rcx,1)
mov    -0x20(%rbp),%rax
mov    -0x70(%rbp),%rcx
movb   $0x30,0x1(%rax,%rcx,1)
mov    -0x34(%rbp),%eax
add    $0xfffffffe,%eax
mov    %eax,%ecx
mov    %rcx,-0xb0(%rbp)
sub    $0x5,%eax
ja     154e <gm_encode+0x3ce>
mov    -0xb0(%rbp),%rax
lea    0x1b93(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x20(%rbp),%rdi
lea    0x1cdb(%rip),%rsi
call   1080 <strcat@plt>
jmp    154e <gm_encode+0x3ce>
mov    -0x20(%rbp),%rdi
lea    0x1cd1(%rip),%rsi
call   1080 <strcat@plt>
jmp    154e <gm_encode+0x3ce>
mov    -0x20(%rbp),%rdi
lea    0x1cc7(%rip),%rsi
call   1080 <strcat@plt>
jmp    154e <gm_encode+0x3ce>
mov    -0x20(%rbp),%rdi
lea    0x1cbd(%rip),%rsi
call   1080 <strcat@plt>
jmp    154e <gm_encode+0x3ce>
mov    -0x20(%rbp),%rdi
lea    0x1cb3(%rip),%rsi
call   1080 <strcat@plt>
jmp    1732 <gm_encode+0x5b2>
mov    -0x34(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,%ecx
mov    %rcx,-0xb8(%rbp)
sub    $0x6,%eax
ja     15e6 <gm_encode+0x466>
mov    -0xb8(%rbp),%rax
lea    0x1adf(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x20(%rbp),%rdi
lea    0x1c53(%rip),%rsi
call   1080 <strcat@plt>
jmp    15e6 <gm_encode+0x466>
mov    -0x20(%rbp),%rdi
lea    0x1c49(%rip),%rsi
call   1080 <strcat@plt>
jmp    15e6 <gm_encode+0x466>
mov    -0x20(%rbp),%rdi
lea    0x1c3f(%rip),%rsi
call   1080 <strcat@plt>
jmp    15e6 <gm_encode+0x466>
mov    -0x20(%rbp),%rdi
lea    0x1c12(%rip),%rsi
call   1080 <strcat@plt>
jmp    15e6 <gm_encode+0x466>
mov    -0x20(%rbp),%rdi
lea    0x1c13(%rip),%rsi
call   1080 <strcat@plt>
jmp    1732 <gm_encode+0x5b2>
mov    -0x34(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,%ecx
mov    %rcx,-0xc0(%rbp)
sub    $0x6,%eax
ja     167e <gm_encode+0x4fe>
mov    -0xc0(%rbp),%rax
lea    0x1a2b(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x20(%rbp),%rdi
lea    0x1be2(%rip),%rsi
call   1080 <strcat@plt>
jmp    167e <gm_encode+0x4fe>
mov    -0x20(%rbp),%rdi
lea    0x1bd8(%rip),%rsi
call   1080 <strcat@plt>
jmp    167e <gm_encode+0x4fe>
mov    -0x20(%rbp),%rdi
lea    0x1bce(%rip),%rsi
call   1080 <strcat@plt>
jmp    167e <gm_encode+0x4fe>
mov    -0x20(%rbp),%rdi
lea    0x1bc4(%rip),%rsi
call   1080 <strcat@plt>
jmp    167e <gm_encode+0x4fe>
mov    -0x20(%rbp),%rdi
lea    0x1bba(%rip),%rsi
call   1080 <strcat@plt>
jmp    1732 <gm_encode+0x5b2>
mov    -0x20(%rbp),%rdi
mov    -0x78(%rbp),%rsi
mov    -0x7c(%rbp),%edx
call   1090 <add_byte_count@plt>
movl   $0x0,-0x7c(%rbp)
mov    -0x34(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,%ecx
mov    %rcx,-0xc8(%rbp)
sub    $0x6,%eax
ja     172d <gm_encode+0x5ad>
mov    -0xc8(%rbp),%rax
lea    0x1960(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x20(%rbp),%rdi
lea    0x1abf(%rip),%rsi
call   1080 <strcat@plt>
jmp    172d <gm_encode+0x5ad>
mov    -0x20(%rbp),%rdi
lea    0x1ab8(%rip),%rsi
call   1080 <strcat@plt>
jmp    172d <gm_encode+0x5ad>
mov    -0x20(%rbp),%rdi
lea    0x1ab1(%rip),%rsi
call   1080 <strcat@plt>
jmp    172d <gm_encode+0x5ad>
mov    -0x20(%rbp),%rdi
lea    0x1aaa(%rip),%rsi
call   1080 <strcat@plt>
jmp    172d <gm_encode+0x5ad>
mov    -0x20(%rbp),%rdi
lea    0x1aa3(%rip),%rsi
call   1080 <strcat@plt>
jmp    1732 <gm_encode+0x5b2>
cmpl   $0x0,-0x80(%rbp)
je     17dd <gm_encode+0x65d>
mov    -0x34(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,%ecx
mov    %rcx,-0xd0(%rbp)
sub    $0x6,%eax
ja     17d8 <gm_encode+0x658>
mov    -0xd0(%rbp),%rax
lea    0x195e(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
lea    0x1acc(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    17d8 <gm_encode+0x658>
lea    0x1abf(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    17d8 <gm_encode+0x658>
lea    0x1ab2(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    17d8 <gm_encode+0x658>
lea    0x1aa5(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    17d8 <gm_encode+0x658>
lea    0x1a98(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    17d8 <gm_encode+0x658>
lea    0x1a8b(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    17dd <gm_encode+0x65d>
jmp    17e2 <gm_encode+0x662>
mov    -0x30(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x34(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,%ecx
mov    %rcx,-0xd8(%rbp)
sub    $0x6,%eax
ja     22c0 <gm_encode+0x1140>
mov    -0xd8(%rbp),%rax
lea    0x18c8(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
movl   $0x0,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
cmpl   $0xff,(%rax,%rcx,4)
jle    18d2 <gm_encode+0x752>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
and    $0xff00,%eax
sar    $0x8,%eax
mov    %eax,-0x44(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
and    $0xff,%eax
mov    %eax,-0x48(%rbp)
cmpl   $0xa0,-0x44(%rbp)
jl     1895 <gm_encode+0x715>
cmpl   $0xa9,-0x44(%rbp)
jg     1895 <gm_encode+0x715>
mov    -0x44(%rbp),%eax
sub    $0xa1,%eax
imul   $0x60,%eax,%eax
mov    -0x48(%rbp),%ecx
sub    $0xa0,%ecx
add    %ecx,%eax
mov    %eax,-0x3c(%rbp)
cmpl   $0xb0,-0x44(%rbp)
jl     18cb <gm_encode+0x74b>
cmpl   $0xf7,-0x44(%rbp)
jg     18cb <gm_encode+0x74b>
mov    -0x44(%rbp),%eax
sub    $0xb0,%eax
add    $0x9,%eax
imul   $0x60,%eax,%eax
mov    -0x48(%rbp),%ecx
sub    $0xa0,%ecx
add    %ecx,%eax
mov    %eax,-0x3c(%rbp)
movl   $0x1,-0x4c(%rbp)
cmpl   $0x0,-0x4c(%rbp)
jne    1932 <gm_encode+0x7b2>
mov    -0x2c(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
je     192d <gm_encode+0x7ad>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
cmpl   $0x13,(%rax,%rcx,4)
jne    1926 <gm_encode+0x7a6>
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
cmpl   $0x10,(%rax,%rcx,4)
jne    1926 <gm_encode+0x7a6>
movl   $0x1e60,-0x3c(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
movl   $0x1,-0x4c(%rbp)
jmp    1932 <gm_encode+0x7b2>
cmpl   $0x0,-0x4c(%rbp)
jne    19e0 <gm_encode+0x860>
mov    -0x2c(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
je     19db <gm_encode+0x85b>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
cmpl   $0x30,(%rax,%rcx,4)
jl     19d6 <gm_encode+0x856>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
cmpl   $0x39,(%rax,%rcx,4)
jg     19d6 <gm_encode+0x856>
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
cmpl   $0x30,(%rax,%rcx,4)
jl     19d6 <gm_encode+0x856>
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
cmpl   $0x39,(%rax,%rcx,4)
jg     19d6 <gm_encode+0x856>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
sub    $0x30,%eax
imul   $0xa,%eax,%eax
add    $0x1f61,%eax
mov    -0x10(%rbp),%rcx
mov    -0x2c(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,4),%ecx
sub    $0x30,%ecx
add    %ecx,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    19db <gm_encode+0x85b>
jmp    19e0 <gm_encode+0x860>
cmpl   $0x0,-0x4c(%rbp)
jne    19fd <gm_encode+0x87d>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
add    $0x1e61,%eax
mov    %eax,-0x3c(%rbp)
cmpl   $0x0,-0x80(%rbp)
je     1a18 <gm_encode+0x898>
mov    -0x3c(%rbp),%esi
lea    0x1851(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movl   $0x0,-0x40(%rbp)
cmpl   $0xd,-0x40(%rbp)
jge    1a7b <gm_encode+0x8fb>
mov    -0x3c(%rbp),%eax
mov    -0x40(%rbp),%ecx
mov    $0x1000,%edx
sar    %cl,%edx
mov    %edx,%ecx
and    %ecx,%eax
cmp    $0x0,%eax
je     1a58 <gm_encode+0x8d8>
mov    -0x20(%rbp),%rdi
lea    0x1748(%rip),%rsi
call   1080 <strcat@plt>
jmp    1a68 <gm_encode+0x8e8>
mov    -0x20(%rbp),%rdi
lea    0x1883(%rip),%rsi
call   1080 <strcat@plt>
jmp    1a6d <gm_encode+0x8ed>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1a1f <gm_encode+0x89f>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    22c0 <gm_encode+0x1140>
mov    -0x38(%rbp),%eax
cmp    -0x30(%rbp),%eax
je     1ab4 <gm_encode+0x934>
mov    -0x20(%rbp),%rdi
call   1040 <strlen@plt>
cltq
mov    %rax,-0x70(%rbp)
mov    -0x20(%rbp),%rdi
lea    0x17b9(%rip),%rsi
call   1080 <strcat@plt>
movl   $0x0,-0x50(%rbp)
movl   $0xffffffff,-0x54(%rbp)
movl   $0x30,-0x60(%rbp)
movl   $0x30,-0x5c(%rbp)
movl   $0x30,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
cmpl   $0x30,(%rax,%rcx,4)
jl     1b20 <gm_encode+0x9a0>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
cmpl   $0x39,(%rax,%rcx,4)
jg     1b20 <gm_encode+0x9a0>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%ecx
movslq -0x50(%rbp),%rax
mov    %ecx,-0x60(%rbp,%rax,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xdc(%rbp)
sub    $0x20,%eax
je     1b56 <gm_encode+0x9d6>
jmp    1b3f <gm_encode+0x9bf>
mov    -0xdc(%rbp),%eax
add    $0xffffffd5,%eax
sub    $0x3,%eax
ja     1b73 <gm_encode+0x9f3>
jmp    1b56 <gm_encode+0x9d6>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x64(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x50(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1bcf <gm_encode+0xa4f>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
cmpl   $0x13,(%rax,%rcx,4)
jne    1bca <gm_encode+0xa4a>
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
cmpl   $0x10,(%rax,%rcx,4)
jne    1bca <gm_encode+0xa4a>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x64(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x50(%rbp),%eax
mov    %eax,-0x54(%rbp)
jmp    1bcf <gm_encode+0xa4f>
jmp    1bd4 <gm_encode+0xa54>
xor    %eax,%eax
cmpl   $0x3,-0x50(%rbp)
mov    %al,-0xdd(%rbp)
jge    1bf5 <gm_encode+0xa75>
mov    -0x2c(%rbp),%eax
cmp    -0x14(%rbp),%eax
setl   %al
mov    %al,-0xdd(%rbp)
mov    -0xdd(%rbp),%al
test   $0x1,%al
jne    1ad7 <gm_encode+0x957>
cmpl   $0xffffffff,-0x54(%rbp)
je     1d16 <gm_encode+0xb96>
mov    -0x64(%rbp),%eax
add    $0xffffffed,%eax
mov    %eax,%ecx
mov    %rcx,-0xe8(%rbp)
sub    $0x1b,%eax
ja     1c7f <gm_encode+0xaff>
mov    -0xe8(%rbp),%rax
lea    0x14c5(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
movl   $0x0,-0x3c(%rbp)
jmp    1c7f <gm_encode+0xaff>
movl   $0x3,-0x3c(%rbp)
jmp    1c7f <gm_encode+0xaff>
movl   $0x6,-0x3c(%rbp)
jmp    1c7f <gm_encode+0xaff>
movl   $0x9,-0x3c(%rbp)
jmp    1c7f <gm_encode+0xaff>
movl   $0xc,-0x3c(%rbp)
jmp    1c7f <gm_encode+0xaff>
movl   $0xf,-0x3c(%rbp)
mov    -0x54(%rbp),%eax
add    -0x3c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x3e8,%eax
mov    %eax,-0x3c(%rbp)
cmpl   $0x0,-0x80(%rbp)
je     1cae <gm_encode+0xb2e>
mov    -0x3c(%rbp),%esi
lea    0x15bb(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movl   $0x0,-0x40(%rbp)
cmpl   $0xa,-0x40(%rbp)
jge    1d11 <gm_encode+0xb91>
mov    -0x3c(%rbp),%eax
mov    -0x40(%rbp),%ecx
mov    $0x200,%edx
sar    %cl,%edx
mov    %edx,%ecx
and    %ecx,%eax
cmp    $0x0,%eax
je     1cee <gm_encode+0xb6e>
mov    -0x20(%rbp),%rdi
lea    0x14b2(%rip),%rsi
call   1080 <strcat@plt>
jmp    1cfe <gm_encode+0xb7e>
mov    -0x20(%rbp),%rdi
lea    0x15ed(%rip),%rsi
call   1080 <strcat@plt>
jmp    1d03 <gm_encode+0xb83>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1cb5 <gm_encode+0xb35>
jmp    1d16 <gm_encode+0xb96>
mov    -0x60(%rbp),%eax
sub    $0x30,%eax
imul   $0x64,%eax,%eax
mov    -0x5c(%rbp),%ecx
sub    $0x30,%ecx
imul   $0xa,%ecx,%ecx
add    %ecx,%eax
mov    -0x58(%rbp),%ecx
sub    $0x30,%ecx
add    %ecx,%eax
mov    %eax,-0x3c(%rbp)
cmpl   $0x0,-0x80(%rbp)
je     1d50 <gm_encode+0xbd0>
mov    -0x3c(%rbp),%esi
lea    0x1519(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movl   $0x0,-0x40(%rbp)
cmpl   $0xa,-0x40(%rbp)
jge    1db3 <gm_encode+0xc33>
mov    -0x3c(%rbp),%eax
mov    -0x40(%rbp),%ecx
mov    $0x200,%edx
sar    %cl,%edx
mov    %edx,%ecx
and    %ecx,%eax
cmp    $0x0,%eax
je     1d90 <gm_encode+0xc10>
mov    -0x20(%rbp),%rdi
lea    0x1410(%rip),%rsi
call   1080 <strcat@plt>
jmp    1da0 <gm_encode+0xc20>
mov    -0x20(%rbp),%rdi
lea    0x154b(%rip),%rsi
call   1080 <strcat@plt>
jmp    1da5 <gm_encode+0xc25>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1d57 <gm_encode+0xbd7>
jmp    22c0 <gm_encode+0x1140>
mov    -0x38(%rbp),%eax
cmp    -0x30(%rbp),%eax
je     1de3 <gm_encode+0xc63>
mov    -0x20(%rbp),%rdi
call   1040 <strlen@plt>
cltq
mov    %rax,-0x78(%rbp)
mov    -0x20(%rbp),%rdi
lea    0x148d(%rip),%rsi
call   1080 <strcat@plt>
cmpl   $0x200,-0x7c(%rbp)
jne    1e36 <gm_encode+0xcb6>
mov    -0x20(%rbp),%rdi
mov    -0x78(%rbp),%rsi
mov    -0x7c(%rbp),%edx
call   1090 <add_byte_count@plt>
mov    -0x20(%rbp),%rdi
lea    0x142e(%rip),%rsi
call   1080 <strcat@plt>
mov    -0x20(%rbp),%rdi
call   1040 <strlen@plt>
cltq
mov    %rax,-0x78(%rbp)
mov    -0x20(%rbp),%rdi
lea    0x1441(%rip),%rsi
call   1080 <strcat@plt>
movl   $0x0,-0x7c(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x3c(%rbp)
cmpl   $0x0,-0x80(%rbp)
je     1e5f <gm_encode+0xcdf>
mov    -0x3c(%rbp),%esi
lea    0x140a(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movl   $0x0,-0x40(%rbp)
cmpl   $0x8,-0x40(%rbp)
jge    1ec2 <gm_encode+0xd42>
mov    -0x3c(%rbp),%eax
mov    -0x40(%rbp),%ecx
mov    $0x80,%edx
sar    %cl,%edx
mov    %edx,%ecx
and    %ecx,%eax
cmp    $0x0,%eax
je     1e9f <gm_encode+0xd1f>
mov    -0x20(%rbp),%rdi
lea    0x1301(%rip),%rsi
call   1080 <strcat@plt>
jmp    1eaf <gm_encode+0xd2f>
mov    -0x20(%rbp),%rdi
lea    0x143c(%rip),%rsi
call   1080 <strcat@plt>
jmp    1eb4 <gm_encode+0xd34>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1e66 <gm_encode+0xce6>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
jmp    22c0 <gm_encode+0x1140>
movl   $0x1,-0x84(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
cmpl   $0x30,(%rax,%rcx,4)
jl     1f11 <gm_encode+0xd91>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
cmpl   $0x39,(%rax,%rcx,4)
jg     1f11 <gm_encode+0xd91>
movl   $0x0,-0x84(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
cmpl   $0x41,(%rax,%rcx,4)
jl     1f3f <gm_encode+0xdbf>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
cmpl   $0x5a,(%rax,%rcx,4)
jg     1f3f <gm_encode+0xdbf>
movl   $0x0,-0x84(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
cmpl   $0x61,(%rax,%rcx,4)
jl     1f6d <gm_encode+0xded>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
cmpl   $0x7a,(%rax,%rcx,4)
jg     1f6d <gm_encode+0xded>
movl   $0x0,-0x84(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
cmpl   $0x20,(%rax,%rcx,4)
jne    1f89 <gm_encode+0xe09>
movl   $0x0,-0x84(%rbp)
cmpl   $0x0,-0x84(%rbp)
jne    2033 <gm_encode+0xeb3>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
lea    0x12cd(%rip),%rdi
call   1070 <posn@plt>
mov    %eax,-0x3c(%rbp)
cmpl   $0x0,-0x80(%rbp)
je     1fcb <gm_encode+0xe4b>
mov    -0x3c(%rbp),%esi
lea    0x129e(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movl   $0x0,-0x40(%rbp)
cmpl   $0x6,-0x40(%rbp)
jge    202e <gm_encode+0xeae>
mov    -0x3c(%rbp),%eax
mov    -0x40(%rbp),%ecx
mov    $0x20,%edx
sar    %cl,%edx
mov    %edx,%ecx
and    %ecx,%eax
cmp    $0x0,%eax
je     200b <gm_encode+0xe8b>
mov    -0x20(%rbp),%rdi
lea    0x1195(%rip),%rsi
call   1080 <strcat@plt>
jmp    201b <gm_encode+0xe9b>
mov    -0x20(%rbp),%rdi
lea    0x12d0(%rip),%rsi
call   1080 <strcat@plt>
jmp    2020 <gm_encode+0xea0>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1fd2 <gm_encode+0xe52>
jmp    2057 <gm_encode+0xed7>
mov    -0x20(%rbp),%rdi
lea    0x1275(%rip),%rsi
call   1080 <strcat@plt>
mov    -0x20(%rbp),%rdi
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
call   10a0 <add_shift_char@plt>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    22c0 <gm_encode+0x1140>
movl   $0x1,-0x84(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
cmpl   $0x41,(%rax,%rcx,4)
jl     209d <gm_encode+0xf1d>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
cmpl   $0x5a,(%rax,%rcx,4)
jg     209d <gm_encode+0xf1d>
movl   $0x0,-0x84(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
cmpl   $0x20,(%rax,%rcx,4)
jne    20b9 <gm_encode+0xf39>
movl   $0x0,-0x84(%rbp)
cmpl   $0x0,-0x84(%rbp)
jne    2163 <gm_encode+0xfe3>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
lea    0x11e6(%rip),%rdi
call   1070 <posn@plt>
mov    %eax,-0x3c(%rbp)
cmpl   $0x0,-0x80(%rbp)
je     20fb <gm_encode+0xf7b>
mov    -0x3c(%rbp),%esi
lea    0x116e(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movl   $0x0,-0x40(%rbp)
cmpl   $0x5,-0x40(%rbp)
jge    215e <gm_encode+0xfde>
mov    -0x3c(%rbp),%eax
mov    -0x40(%rbp),%ecx
mov    $0x10,%edx
sar    %cl,%edx
mov    %edx,%ecx
and    %ecx,%eax
cmp    $0x0,%eax
je     213b <gm_encode+0xfbb>
mov    -0x20(%rbp),%rdi
lea    0x1065(%rip),%rsi
call   1080 <strcat@plt>
jmp    214b <gm_encode+0xfcb>
mov    -0x20(%rbp),%rdi
lea    0x11a0(%rip),%rsi
call   1080 <strcat@plt>
jmp    2150 <gm_encode+0xfd0>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    2102 <gm_encode+0xf82>
jmp    2187 <gm_encode+0x1007>
mov    -0x20(%rbp),%rdi
lea    0x107b(%rip),%rsi
call   1080 <strcat@plt>
mov    -0x20(%rbp),%rdi
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
call   10a0 <add_shift_char@plt>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    22c0 <gm_encode+0x1140>
movl   $0x1,-0x84(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
cmpl   $0x61,(%rax,%rcx,4)
jl     21cd <gm_encode+0x104d>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
cmpl   $0x7a,(%rax,%rcx,4)
jg     21cd <gm_encode+0x104d>
movl   $0x0,-0x84(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
cmpl   $0x20,(%rax,%rcx,4)
jne    21e9 <gm_encode+0x1069>
movl   $0x0,-0x84(%rbp)
cmpl   $0x0,-0x84(%rbp)
jne    2293 <gm_encode+0x1113>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
lea    0x108f(%rip),%rdi
call   1070 <posn@plt>
mov    %eax,-0x3c(%rbp)
cmpl   $0x0,-0x80(%rbp)
je     222b <gm_encode+0x10ab>
mov    -0x3c(%rbp),%esi
lea    0x103e(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movl   $0x0,-0x40(%rbp)
cmpl   $0x5,-0x40(%rbp)
jge    228e <gm_encode+0x110e>
mov    -0x3c(%rbp),%eax
mov    -0x40(%rbp),%ecx
mov    $0x10,%edx
sar    %cl,%edx
mov    %edx,%ecx
and    %ecx,%eax
cmp    $0x0,%eax
je     226b <gm_encode+0x10eb>
mov    -0x20(%rbp),%rdi
lea    0xf35(%rip),%rsi
call   1080 <strcat@plt>
jmp    227b <gm_encode+0x10fb>
mov    -0x20(%rbp),%rdi
lea    0x1070(%rip),%rsi
call   1080 <strcat@plt>
jmp    2280 <gm_encode+0x1100>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    2232 <gm_encode+0x10b2>
jmp    22b7 <gm_encode+0x1137>
mov    -0x20(%rbp),%rdi
lea    0xf4b(%rip),%rsi
call   1080 <strcat@plt>
mov    -0x20(%rbp),%rdi
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
call   10a0 <add_shift_char@plt>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x20(%rbp),%rdi
call   1040 <strlen@plt>
cmp    $0x23e7,%eax
jle    22e0 <gm_encode+0x1160>
movl   $0x5,-0x4(%rbp)
jmp    24d1 <gm_encode+0x1351>
jmp    22e5 <gm_encode+0x1165>
mov    -0x2c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jl     1296 <gm_encode+0x116>
cmpl   $0x1,-0x30(%rbp)
jne    2394 <gm_encode+0x1214>
mov    -0x50(%rbp),%eax
mov    %eax,-0xec(%rbp)
sub    $0x1,%eax
je     233a <gm_encode+0x11ba>
jmp    2312 <gm_encode+0x1192>
mov    -0xec(%rbp),%eax
sub    $0x2,%eax
je     2358 <gm_encode+0x11d8>
jmp    2326 <gm_encode+0x11a6>
mov    -0xec(%rbp),%eax
sub    $0x3,%eax
je     2376 <gm_encode+0x11f6>
jmp    238f <gm_encode+0x120f>
mov    -0x20(%rbp),%rax
mov    -0x70(%rbp),%rcx
movb   $0x31,(%rax,%rcx,1)
mov    -0x20(%rbp),%rax
mov    -0x70(%rbp),%rcx
movb   $0x30,0x1(%rax,%rcx,1)
jmp    238f <gm_encode+0x120f>
mov    -0x20(%rbp),%rax
mov    -0x70(%rbp),%rcx
movb   $0x30,(%rax,%rcx,1)
mov    -0x20(%rbp),%rax
mov    -0x70(%rbp),%rcx
movb   $0x31,0x1(%rax,%rcx,1)
jmp    238f <gm_encode+0x120f>
mov    -0x20(%rbp),%rax
mov    -0x70(%rbp),%rcx
movb   $0x30,(%rax,%rcx,1)
mov    -0x20(%rbp),%rax
mov    -0x70(%rbp),%rcx
movb   $0x30,0x1(%rax,%rcx,1)
jmp    2394 <gm_encode+0x1214>
cmpl   $0x6,-0x30(%rbp)
jne    23ae <gm_encode+0x122e>
mov    -0x20(%rbp),%rdi
mov    -0x78(%rbp),%rsi
mov    -0x7c(%rbp),%edx
call   1090 <add_byte_count@plt>
mov    -0x30(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,%ecx
mov    %rcx,-0xf8(%rbp)
sub    $0x6,%eax
ja     2441 <gm_encode+0x12c1>
mov    -0xf8(%rbp),%rax
lea    0xd94(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x20(%rbp),%rdi
lea    0xef2(%rip),%rsi
call   1080 <strcat@plt>
jmp    2441 <gm_encode+0x12c1>
mov    -0x20(%rbp),%rdi
lea    0xeeb(%rip),%rsi
call   1080 <strcat@plt>
jmp    2441 <gm_encode+0x12c1>
mov    -0x20(%rbp),%rdi
lea    0xdc3(%rip),%rsi
call   1080 <strcat@plt>
jmp    2441 <gm_encode+0x12c1>
mov    -0x20(%rbp),%rdi
lea    0xecc(%rip),%rsi
call   1080 <strcat@plt>
jmp    2441 <gm_encode+0x12c1>
mov    -0x20(%rbp),%rdi
lea    0xea7(%rip),%rsi
call   1080 <strcat@plt>
mov    -0x20(%rbp),%rdi
call   1040 <strlen@plt>
mov    $0x7,%ecx
cltd
idiv   %ecx
mov    $0x7,%eax
sub    %edx,%eax
mov    %eax,-0x50(%rbp)
cmpl   $0x7,-0x50(%rbp)
jne    246d <gm_encode+0x12ed>
movl   $0x0,-0x50(%rbp)
movl   $0x0,-0x88(%rbp)
mov    -0x88(%rbp),%eax
cmp    -0x50(%rbp),%eax
jge    24aa <gm_encode+0x132a>
mov    -0x20(%rbp),%rdi
lea    0xe55(%rip),%rsi
call   1080 <strcat@plt>
mov    -0x88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x88(%rbp)
jmp    2477 <gm_encode+0x12f7>
mov    -0x20(%rbp),%rdi
call   1040 <strlen@plt>
cmp    $0x23e7,%eax
jle    24ca <gm_encode+0x134a>
movl   $0x5,-0x4(%rbp)
jmp    24d1 <gm_encode+0x1351>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x100,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<gm_encode>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x68,%rsp
mov    %r8d,%r13d
mov    %ecx,%ebp
mov    %rdx,%rbx
mov    %esi,%r14d
mov    %rdi,0x10(%rsp)
lea    0x211e(%rip),%rsi
mov    %rdx,%rdi
call   1030 <strcpy@plt>
test   %ebp,%ebp
mov    %rbx,%rbp
je     11b3 <gm_encode+0x43>
lea    0x211d(%rip),%rsi
mov    %rbp,%rdi
call   1070 <strcat@plt>
cmp    $0x3,%r13d
mov    0x10(%rsp),%r15
je     12df <gm_encode+0x16f>
lea    0x1fbf(%rip),%rsi
mov    %rbp,%rdi
call   1070 <strcat@plt>
test   $0x100,%r13d
lea    0x20e1(%rip),%r15
lea    0x1fb4(%rip),%r12
mov    %r12,%rsi
cmove  %r15,%rsi
mov    %rbp,%rdi
call   1070 <strcat@plt>
movd   %r13d,%xmm0
pshufd $0x0,%xmm0,%xmm0
movdqa 0x1df9(%rip),%xmm1
pand   %xmm0,%xmm1
pand   0x1dfd(%rip),%xmm0
pxor   %xmm2,%xmm2
pcmpeqd %xmm2,%xmm0
pcmpeqd %xmm2,%xmm1
packssdw %xmm0,%xmm1
packsswb %xmm1,%xmm1
mov    %rbp,%rbx
pmovmskb %xmm1,%ebp
test   $0x80,%bpl
mov    %r12,%rsi
mov    %r15,%r13
cmovne %r15,%rsi
mov    %rbx,%rdi
call   1070 <strcat@plt>
test   $0x40,%bpl
mov    %r12,%rsi
cmovne %r15,%rsi
mov    %rbx,%rdi
call   1070 <strcat@plt>
test   $0x20,%bpl
mov    %r12,%rsi
cmovne %r15,%rsi
mov    %rbx,%rdi
call   1070 <strcat@plt>
test   $0x10,%bpl
mov    %r12,%rsi
cmovne %r15,%rsi
mov    %rbx,%rdi
call   1070 <strcat@plt>
test   $0x8,%bpl
mov    %r12,%rsi
cmovne %r15,%rsi
mov    %rbx,%rdi
call   1070 <strcat@plt>
test   $0x4,%bpl
mov    %r12,%rsi
cmovne %r15,%rsi
mov    %rbx,%rdi
call   1070 <strcat@plt>
test   $0x2,%bpl
mov    %r12,%rsi
cmovne %r15,%rsi
mov    %rbx,%rdi
call   1070 <strcat@plt>
test   $0x1,%bpl
mov    %rbx,%rbp
mov    0x10(%rsp),%r15
cmovne %r13,%r12
mov    %r13,%rbx
mov    %rbp,%rdi
mov    %r12,%rsi
call   1070 <strcat@plt>
mov    %rbp,%rdi
mov    %r13,%rsi
call   1070 <strcat@plt>
mov    %r14,%rsi
lea    -0x1(%r14),%eax
mov    %eax,0x2c(%rsp)
cltq
mov    %rax,0x60(%rsp)
xor    %eax,%eax
mov    %rax,0x18(%rsp)
xor    %r13d,%r13d
xor    %r12d,%r12d
xor    %r14d,%r14d
xor    %eax,%eax
mov    %rax,0x38(%rsp)
xor    %eax,%eax
mov    %rax,0x40(%rsp)
xor    %eax,%eax
mov    %rax,0x30(%rsp)
movl   $0x0,0xc(%rsp)
mov    %rsi,0x58(%rsp)
mov    %rbp,0x20(%rsp)
nopl   0x0(%rax,%rax,1)
mov    %r15,%rdi
mov    %r12d,%edx
mov    %r13d,%ecx
call   1050 <seek_forward@plt>
mov    %eax,%ebx
cmp    %r13d,%eax
jne    1380 <gm_encode+0x210>
lea    -0x1(%rbx),%eax
cmp    $0x6,%eax
ja     1f4b <gm_encode+0xddb>
lea    0x1d88(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    %rbx,(%rsp)
cmp    %r13d,%ebx
mov    0x2c(%rsp),%ebx
mov    0x38(%rsp),%rbp
jne    1615 <gm_encode+0x4a5>
jmp    163d <gm_encode+0x4cd>
nopl   0x0(%rax)
cmp    $0x7,%r13d
ja     1345 <gm_encode+0x1d5>
mov    %r13d,%eax
lea    0x1c90(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
lea    -0x1(%rbx),%eax
cmp    $0x6,%eax
ja     1345 <gm_encode+0x1d5>
lea    0x1cd0(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
lea    0x1e2e(%rip),%rsi
lea    0x1e32(%rip),%r8
lea    0x1e34(%rip),%rcx
lea    0x1e17(%rip),%rdx
jmp    *%rax
mov    %rbp,%rdi
lea    0x1e23(%rip),%rsi
call   1070 <strcat@plt>
jmp    1345 <gm_encode+0x1d5>
cmp    %r13d,%ebx
lea    0x1ed5(%rip),%r15
jne    17f8 <gm_encode+0x688>
jmp    1816 <gm_encode+0x6a6>
lea    -0x1(%rbx),%eax
cmp    $0x6,%eax
ja     1345 <gm_encode+0x1d5>
lea    0x1cbb(%rip),%rcx
movslq (%rcx,%rax,4),%rdi
add    %rcx,%rdi
lea    0x1d80(%rip),%rsi
lea    0x1d87(%rip),%r8
lea    0x1e18(%rip),%rcx
lea    0x1da3(%rip),%rdx
lea    0x1d8e(%rip),%r9
lea    0x1d79(%rip),%rax
jmp    *%rdi
lea    -0x1(%r14),%ecx
cmp    $0x2,%ecx
ja     1463 <gm_encode+0x2f3>
shl    $0x3,%ecx
mov    $0x303031,%eax
shr    %cl,%eax
mov    $0x303130,%edx
shr    %cl,%edx
mov    0x40(%rsp),%rcx
mov    %al,0x0(%rbp,%rcx,1)
mov    %dl,0x1(%rbp,%rcx,1)
lea    -0x2(%rbx),%eax
cmp    $0x5,%eax
ja     1345 <gm_encode+0x1d5>
lea    0x1c1e(%rip),%rcx
movslq (%rcx,%rax,4),%rdi
add    %rcx,%rdi
lea    0x1d50(%rip),%rsi
lea    0x1d75(%rip),%rcx
lea    0x1d63(%rip),%rdx
lea    0x1d51(%rip),%r9
lea    0x1d3f(%rip),%rax
jmp    *%rdi
lea    -0x1(%rbx),%eax
cmp    $0x6,%eax
ja     1345 <gm_encode+0x1d5>
lea    0x1ba7(%rip),%rcx
movslq (%rcx,%rax,4),%rdx
add    %rcx,%rdx
lea    0x1d48(%rip),%rsi
lea    0x1d4c(%rip),%r8
lea    0x1d66(%rip),%rcx
lea    0x1d54(%rip),%r9
lea    0x1d42(%rip),%rax
jmp    *%rdx
mov    %rbp,%rdi
mov    0x30(%rsp),%rsi
mov    0xc(%rsp),%edx
call   1080 <add_byte_count@plt>
lea    -0x1(%rbx),%eax
cmp    $0x6,%eax
ja     1f6d <gm_encode+0xdfd>
movl   $0x0,0xc(%rsp)
lea    0x1b33(%rip),%rdx
movslq (%rdx,%rax,4),%rcx
add    %rdx,%rcx
lea    0x1c7c(%rip),%rsi
lea    0x1c83(%rip),%r8
lea    0x1ca6(%rip),%rdx
lea    0x1c91(%rip),%r9
lea    0x1c7c(%rip),%rax
jmp    *%rcx
mov    %rbp,%rdi
call   1070 <strcat@plt>
movslq %r12d,%rax
mov    (%r15,%rax,4),%ecx
cmp    $0x100,%ecx
mov    %rbx,(%rsp)
jl     1595 <gm_encode+0x425>
mov    %rbp,%r8
movzbl %ch,%eax
movzbl %cl,%ecx
lea    -0xa0(%rax),%edx
lea    (%rax,%rax,2),%esi
shl    $0x5,%esi
cmp    $0xa,%edx
lea    -0x3d00(%rsi,%rcx,1),%edx
mov    0x18(%rsp),%rdi
cmovb  %edx,%edi
add    $0xffffff50,%eax
cmp    $0x48,%eax
lea    -0x3f40(%rsi,%rcx,1),%eax
cmovae %edi,%eax
mov    %eax,%r13d
jmp    1b6a <gm_encode+0x9fa>
mov    0x2c(%rsp),%edx
mov    %rbp,%r8
cmp    %edx,%r12d
jne    1b41 <gm_encode+0x9d1>
mov    0x60(%rsp),%rax
mov    (%r15,%rax,4),%r13d
mov    $0x1e61,%eax
add    %eax,%r13d
mov    %edx,%r12d
jmp    1b6a <gm_encode+0x9fa>
lea    -0x1(%rbx),%eax
cmp    $0x5,%eax
ja     1345 <gm_encode+0x1d5>
lea    0x1adb(%rip),%rcx
movslq (%rcx,%rax,4),%rsi
add    %rcx,%rsi
lea    0x1baf(%rip),%r8
lea    0x1be0(%rip),%rcx
lea    0x1bcb(%rip),%rdx
lea    0x1bb6(%rip),%r9
lea    0x1ba1(%rip),%rax
jmp    *%rsi
mov    %rbx,(%rsp)
mov    %rbp,%rdi
mov    %r8,%rsi
call   1070 <strcat@plt>
mov    0x2c(%rsp),%ebx
mov    0x38(%rsp),%rbp
mov    0x20(%rsp),%r14
mov    %r14,%rdi
call   1040 <strlen@plt>
cltq
mov    %rax,0x40(%rsp)
mov    %r14,%rdi
mov    0x10(%rsp),%r15
lea    0x1c0a(%rip),%rsi
call   1070 <strcat@plt>
movabs $0x3000000030,%rax
mov    %rax,0x4c(%rsp)
movl   $0x30,0x54(%rsp)
mov    $0xffffffff,%eax
xor    %r14d,%r14d
mov    0x58(%rsp),%rdi
jmp    167d <gm_encode+0x50d>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %ecx,%ebp
cmp    $0x2,%r14d
jg     16eb <gm_encode+0x57b>
cmp    %edi,%r12d
jge    16eb <gm_encode+0x57b>
movslq %r12d,%rdx
mov    (%r15,%rdx,4),%ecx
lea    -0x30(%rcx),%esi
cmp    $0x9,%esi
ja     16a1 <gm_encode+0x531>
movslq %r14d,%r14
mov    %ecx,0x4c(%rsp,%r14,4)
lea    0x1(%rdx),%r12d
add    $0x1,%r14d
mov    0x4(%r15,%rdx,4),%ecx
lea    -0x2b(%rcx),%edx
cmp    $0x4,%edx
jb     16b0 <gm_encode+0x540>
cmp    $0x20,%ecx
jne    16e2 <gm_encode+0x572>
xchg   %ax,%ax
add    $0x1,%r12d
mov    %r14d,%eax
cmp    %ebx,%r12d
jge    1670 <gm_encode+0x500>
movslq %r12d,%rdx
cmpl   $0x13,(%r15,%rdx,4)
jne    1670 <gm_encode+0x500>
cmpl   $0x10,0x4(%r15,%rdx,4)
jne    1670 <gm_encode+0x500>
add    $0x2,%r12d
mov    $0x13,%ebp
mov    %r14d,%eax
cmp    $0x2,%r14d
jle    1678 <gm_encode+0x508>
jmp    16eb <gm_encode+0x57b>
mov    %ebp,%ecx
cmp    %ebx,%r12d
jl     16bc <gm_encode+0x54c>
jmp    1670 <gm_encode+0x500>
mov    %rbp,0x38(%rsp)
cmp    $0xffffffff,%eax
mov    0x20(%rsp),%r13
lea    0x1bc1(%rip),%r15
je     1e25 <gm_encode+0xcb5>
mov    0x38(%rsp),%rcx
add    $0xffffffed,%ecx
cmp    $0x1b,%ecx
ja     1cdd <gm_encode+0xb6d>
lea    0x19df(%rip),%rdx
movslq (%rdx,%rcx,4),%rcx
add    %rdx,%rcx
lea    0x1a6f(%rip),%rbp
mov    0x18(%rsp),%rdx
jmp    *%rcx
mov    $0xf,%edx
jmp    1ce9 <gm_encode+0xb79>
mov    %rbp,%rdi
mov    %rdx,%rsi
call   1070 <strcat@plt>
mov    %r15,%rax
movslq %r12d,%r15
mov    (%rax,%r15,4),%esi
cmp    $0x20,%esi
je     179e <gm_encode+0x62e>
lea    -0x7b(%rsi),%eax
cmp    $0xffffffe5,%eax
ja     179e <gm_encode+0x62e>
lea    -0x5b(%rsi),%eax
cmp    $0xffffffe5,%eax
ja     179e <gm_encode+0x62e>
lea    -0x3a(%rsi),%eax
cmp    $0xfffffff6,%eax
jae    179e <gm_encode+0x62e>
mov    %rbx,%r13
mov    0x20(%rsp),%rbp
mov    %rbp,%rdi
lea    0x1b0d(%rip),%rsi
call   1070 <strcat@plt>
mov    0x10(%rsp),%rax
mov    (%rax,%r15,4),%esi
mov    %rax,%r15
mov    %rbp,%rdi
call   1090 <add_shift_char@plt>
jmp    1ca3 <gm_encode+0xb33>
mov    %rbx,(%rsp)
lea    0x1aa6(%rip),%rdi
call   1060 <posn@plt>
mov    %eax,%ebp
test   $0x20,%bpl
lea    0x19df(%rip),%rbx
mov    %rbx,%rsi
lea    0x1afb(%rip),%r15
cmove  %r15,%rsi
mov    0x20(%rsp),%r13
mov    %r13,%rdi
call   1070 <strcat@plt>
test   $0x10,%bpl
mov    %rbx,%rsi
cmove  %r15,%rsi
jmp    1ad0 <gm_encode+0x960>
mov    %rbp,%rdi
mov    %rcx,%rsi
call   1070 <strcat@plt>
lea    0x1ac8(%rip),%r15
mov    %rbp,%rdi
call   1040 <strlen@plt>
cltq
mov    %rax,0x30(%rsp)
mov    %rbp,%rdi
lea    0x1a34(%rip),%rsi
call   1070 <strcat@plt>
mov    0xc(%rsp),%eax
cmp    $0x200,%eax
mov    %rbx,(%rsp)
jne    1871 <gm_encode+0x701>
mov    %rbp,%rdi
mov    0x30(%rsp),%rsi
mov    $0x200,%edx
call   1080 <add_byte_count@plt>
mov    %rbp,%rdi
lea    0x19fc(%rip),%rsi
call   1070 <strcat@plt>
mov    %rbp,%rdi
call   1040 <strlen@plt>
cltq
mov    %rax,0x30(%rsp)
mov    %rbp,%rdi
lea    0x19e6(%rip),%rsi
call   1070 <strcat@plt>
movl   $0x0,0xc(%rsp)
mov    %rbp,%r13
jmp    1878 <gm_encode+0x708>
mov    %rbp,%r13
mov    %eax,0xc(%rsp)
movslq %r12d,%rax
mov    0x10(%rsp),%rcx
mov    (%rcx,%rax,4),%eax
mov    %rax,0x18(%rsp)
movd   %eax,%xmm0
pshufd $0x0,%xmm0,%xmm0
movdqa %xmm0,%xmm1
pand   0x1763(%rip),%xmm1
pand   0x176b(%rip),%xmm0
pxor   %xmm2,%xmm2
pcmpeqd %xmm2,%xmm0
pcmpeqd %xmm2,%xmm1
packssdw %xmm0,%xmm1
packsswb %xmm1,%xmm1
pmovmskb %xmm1,%ebx
test   $0x80,%bl
lea    0x18d3(%rip),%rbp
mov    %rbp,%rsi
cmovne %r15,%rsi
mov    %r13,%rdi
call   1070 <strcat@plt>
test   $0x40,%bl
mov    %rbp,%rsi
cmovne %r15,%rsi
mov    %r13,%rdi
call   1070 <strcat@plt>
test   $0x20,%bl
mov    %rbp,%rsi
cmovne %r15,%rsi
mov    %r13,%rdi
call   1070 <strcat@plt>
test   $0x10,%bl
mov    %rbp,%rsi
cmovne %r15,%rsi
mov    %r13,%rdi
call   1070 <strcat@plt>
test   $0x8,%bl
mov    %rbp,%rsi
cmovne %r15,%rsi
mov    %r13,%rdi
call   1070 <strcat@plt>
test   $0x4,%bl
mov    %rbp,%rsi
cmovne %r15,%rsi
mov    %r13,%rdi
call   1070 <strcat@plt>
test   $0x2,%bl
mov    %rbp,%rsi
cmovne %r15,%rsi
mov    %r13,%rdi
call   1070 <strcat@plt>
test   $0x1,%bl
mov    %rbp,%rsi
mov    0x10(%rsp),%rax
cmovne %r15,%rsi
mov    %rax,%r15
mov    %r13,%rdi
call   1070 <strcat@plt>
add    $0x1,%r12d
addl   $0x1,0xc(%rsp)
mov    %r13,%rbp
jmp    1f47 <gm_encode+0xdd7>
mov    %rbp,%rdi
mov    %rax,%rsi
call   1070 <strcat@plt>
mov    %rbx,(%rsp)
movslq %r12d,%rbx
mov    (%r15,%rbx,4),%esi
cmp    $0x20,%esi
je     19c5 <gm_encode+0x855>
lea    -0x61(%rsi),%eax
cmp    $0x19,%eax
jbe    19c5 <gm_encode+0x855>
mov    %r15,%rbp
mov    0x20(%rsp),%r15
mov    %r15,%rdi
lea    0x184b(%rip),%rsi
call   1070 <strcat@plt>
mov    0x0(%rbp,%rbx,4),%esi
mov    %r15,%rax
mov    %rbp,%r15
mov    %rax,%rbp
mov    %rax,%rdi
call   1090 <add_shift_char@plt>
mov    (%rsp),%rbx
jmp    1ca3 <gm_encode+0xb33>
lea    0x18a5(%rip),%rdi
call   1060 <posn@plt>
mov    %eax,%ebp
test   $0x10,%bpl
lea    0x17bc(%rip),%rbx
mov    %rbx,%rsi
lea    0x18d8(%rip),%r15
cmove  %r15,%rsi
mov    0x20(%rsp),%r13
mov    %r13,%rdi
call   1070 <strcat@plt>
test   $0x8,%bpl
mov    %rbx,%rsi
cmove  %r15,%rsi
mov    %r13,%rdi
call   1070 <strcat@plt>
test   $0x4,%bpl
mov    %rbx,%rsi
cmove  %r15,%rsi
mov    %r13,%rdi
call   1070 <strcat@plt>
test   $0x2,%bpl
mov    %rbx,%rsi
cmove  %r15,%rsi
mov    %r13,%rdi
call   1070 <strcat@plt>
mov    %rbp,0x18(%rsp)
mov    %r13,%rdi
test   $0x1,%bpl
jne    1c8f <gm_encode+0xb1f>
mov    %r15,%rsi
jmp    1c92 <gm_encode+0xb22>
mov    %rbp,%rdi
mov    %r9,%rsi
call   1070 <strcat@plt>
mov    %rbx,(%rsp)
movslq %r12d,%rbx
mov    (%r15,%rbx,4),%esi
cmp    $0x20,%esi
je     1aa4 <gm_encode+0x934>
lea    -0x41(%rsi),%eax
cmp    $0x19,%eax
jbe    1aa4 <gm_encode+0x934>
mov    %r15,%rbp
mov    0x20(%rsp),%r15
mov    %r15,%rdi
lea    0x176c(%rip),%rsi
call   1070 <strcat@plt>
mov    0x0(%rbp,%rbx,4),%esi
mov    %r15,%rax
mov    %rbp,%r15
mov    %rax,%rbp
mov    %rax,%rdi
call   1090 <add_shift_char@plt>
add    $0x1,%r12d
jmp    1f47 <gm_encode+0xdd7>
lea    0x17ed(%rip),%rdi
call   1060 <posn@plt>
mov    %eax,%ebp
test   $0x10,%bpl
lea    0x16dd(%rip),%rbx
mov    %rbx,%rsi
lea    0x17f9(%rip),%r15
cmove  %r15,%rsi
mov    0x20(%rsp),%r13
mov    %r13,%rdi
call   1070 <strcat@plt>
test   $0x8,%bpl
mov    %rbx,%rsi
cmove  %r15,%rsi
mov    %r13,%rdi
call   1070 <strcat@plt>
test   $0x4,%bpl
mov    %rbx,%rsi
cmove  %r15,%rsi
mov    %r13,%rdi
call   1070 <strcat@plt>
test   $0x2,%bpl
mov    %rbx,%rsi
cmove  %r15,%rsi
mov    %r13,%rdi
call   1070 <strcat@plt>
mov    %rbp,0x18(%rsp)
mov    %r13,%rdi
test   $0x1,%bpl
jne    1b24 <gm_encode+0x9b4>
mov    %r15,%rsi
jmp    1b27 <gm_encode+0x9b7>
mov    %rbx,%rsi
call   1070 <strcat@plt>
add    $0x1,%r12d
mov    (%rsp),%rbx
mov    %r13,%rbp
mov    0x10(%rsp),%r15
jmp    1f4b <gm_encode+0xddb>
cmp    $0x13,%ecx
jne    1cac <gm_encode+0xb3c>
lea    0x1(%r12),%ecx
cmpl   $0x10,0x4(%r15,%rax,4)
mov    $0x1e60,%eax
mov    0x18(%rsp),%r13
cmove  %eax,%r13d
cmovne %r12d,%ecx
mov    %ecx,%r12d
lea    0x1629(%rip),%r15
test   $0x1000,%r13d
mov    %r15,%rsi
lea    0x173e(%rip),%rbx
cmove  %rbx,%rsi
mov    %r8,%rbp
mov    %r8,%rdi
call   1070 <strcat@plt>
test   $0x800,%r13d
mov    %r15,%rsi
cmove  %rbx,%rsi
mov    %rbp,%rdi
call   1070 <strcat@plt>
test   $0x400,%r13d
mov    %r15,%rsi
cmove  %rbx,%rsi
mov    %rbp,%rdi
call   1070 <strcat@plt>
test   $0x200,%r13d
mov    %r15,%rsi
cmove  %rbx,%rsi
mov    %rbp,%rdi
call   1070 <strcat@plt>
test   $0x100,%r13d
mov    %r15,%rsi
cmove  %rbx,%rsi
mov    %rbp,%rdi
call   1070 <strcat@plt>
test   $0x80,%r13b
mov    %r15,%rsi
cmove  %rbx,%rsi
mov    %rbp,%rdi
call   1070 <strcat@plt>
test   $0x40,%r13b
mov    %r15,%rsi
cmove  %rbx,%rsi
mov    %rbp,%rdi
call   1070 <strcat@plt>
test   $0x20,%r13b
mov    %r15,%rsi
cmove  %rbx,%rsi
mov    %rbp,%rdi
call   1070 <strcat@plt>
test   $0x10,%r13b
mov    %r15,%rsi
cmove  %rbx,%rsi
mov    %rbp,%rdi
call   1070 <strcat@plt>
test   $0x8,%r13b
mov    %r15,%rsi
cmove  %rbx,%rsi
mov    %rbp,%rdi
call   1070 <strcat@plt>
test   $0x4,%r13b
mov    %r15,%rsi
cmove  %rbx,%rsi
mov    %rbp,%rdi
call   1070 <strcat@plt>
test   $0x2,%r13b
mov    %r15,%rsi
cmove  %rbx,%rsi
mov    %rbp,%rdi
call   1070 <strcat@plt>
mov    %r13,0x18(%rsp)
test   $0x1,%r13b
cmove  %rbx,%r15
mov    %rbp,%rdi
mov    %r15,%rsi
call   1070 <strcat@plt>
add    $0x1,%r12d
jmp    1f42 <gm_encode+0xdd2>
mov    %rbx,%rsi
call   1070 <strcat@plt>
mov    (%rsp),%rbx
mov    %r13,%rbp
mov    0x10(%rsp),%r15
add    $0x1,%r12d
jmp    1f4b <gm_encode+0xddb>
lea    0x14e7(%rip),%r15
mov    0x18(%rsp),%r13
jmp    1b71 <gm_encode+0xa01>
xor    %edx,%edx
jmp    1ce9 <gm_encode+0xb79>
mov    $0x3,%edx
jmp    1ce9 <gm_encode+0xb79>
mov    $0xc,%edx
jmp    1ce9 <gm_encode+0xb79>
mov    $0x6,%edx
jmp    1ce9 <gm_encode+0xb79>
mov    $0x9,%edx
jmp    1ce9 <gm_encode+0xb79>
lea    0x14b6(%rip),%rbp
mov    0x18(%rsp),%rdx
lea    (%rax,%rdx,1),%ebx
add    $0x3e8,%ebx
test   $0x200,%ebx
mov    %rbp,%rsi
cmove  %r15,%rsi
mov    0x20(%rsp),%r13
mov    %r13,%rdi
call   1070 <strcat@plt>
test   $0x100,%ebx
mov    %rbp,%rsi
lea    0x15a4(%rip),%rax
cmove  %rax,%rsi
mov    %r13,%rdi
call   1070 <strcat@plt>
movd   %ebx,%xmm0
pshufd $0x0,%xmm0,%xmm0
movdqa %xmm0,%xmm1
pand   0x12c3(%rip),%xmm1
pand   0x12cb(%rip),%xmm0
pxor   %xmm2,%xmm2
pcmpeqd %xmm2,%xmm0
pcmpeqd %xmm2,%xmm1
packssdw %xmm0,%xmm1
packsswb %xmm1,%xmm1
pmovmskb %xmm1,%ebx
test   $0x80,%bl
mov    %rbp,%rsi
lea    0x1556(%rip),%rax
cmovne %rax,%rsi
mov    %r13,%rdi
call   1070 <strcat@plt>
test   $0x40,%bl
mov    %rbp,%rsi
lea    0x153d(%rip),%rax
cmovne %rax,%rsi
mov    %r13,%rdi
call   1070 <strcat@plt>
test   $0x20,%bl
mov    %rbp,%rsi
lea    0x1524(%rip),%rax
cmovne %rax,%rsi
mov    %r13,%rdi
call   1070 <strcat@plt>
test   $0x10,%bl
mov    %rbp,%rsi
lea    0x150b(%rip),%rax
cmovne %rax,%rsi
mov    %r13,%rdi
call   1070 <strcat@plt>
test   $0x8,%bl
mov    %rbp,%rsi
lea    0x14f2(%rip),%rax
cmovne %rax,%rsi
mov    %r13,%rdi
call   1070 <strcat@plt>
test   $0x4,%bl
mov    %rbp,%rsi
lea    0x14d9(%rip),%rax
cmovne %rax,%rsi
mov    %r13,%rdi
call   1070 <strcat@plt>
test   $0x2,%bl
mov    %rbp,%rsi
lea    0x14c0(%rip),%rax
cmovne %rax,%rsi
mov    %r13,%rdi
call   1070 <strcat@plt>
test   $0x1,%bl
mov    %rbp,%rsi
lea    0x14a7(%rip),%r15
cmovne %r15,%rsi
mov    %r13,%rdi
call   1070 <strcat@plt>
imul   $0x64,0x4c(%rsp),%eax
mov    0x50(%rsp),%ecx
mov    0x54(%rsp),%edx
lea    (%rcx,%rcx,4),%ecx
lea    (%rax,%rcx,2),%eax
lea    (%rdx,%rax,1),%ebx
add    $0xffffeb30,%ebx
test   $0x200,%ebx
lea    0x134c(%rip),%rbp
mov    %rbp,%rsi
cmove  %r15,%rsi
mov    %r13,%rdi
call   1070 <strcat@plt>
test   $0x100,%ebx
mov    %rbp,%rsi
cmove  %r15,%rsi
mov    %r13,%rdi
call   1070 <strcat@plt>
mov    %rbx,0x18(%rsp)
movd   %ebx,%xmm0
pshufd $0x0,%xmm0,%xmm0
movdqa %xmm0,%xmm1
pand   0x1174(%rip),%xmm1
pand   0x117c(%rip),%xmm0
pxor   %xmm2,%xmm2
pcmpeqd %xmm2,%xmm0
pcmpeqd %xmm2,%xmm1
packssdw %xmm0,%xmm1
packsswb %xmm1,%xmm1
pmovmskb %xmm1,%ebx
test   $0x80,%bl
mov    %rbp,%rsi
cmovne %r15,%rsi
mov    %r13,%rdi
call   1070 <strcat@plt>
test   $0x40,%bl
mov    %rbp,%rsi
cmovne %r15,%rsi
mov    %r13,%rdi
call   1070 <strcat@plt>
test   $0x20,%bl
mov    %rbp,%rsi
cmovne %r15,%rsi
mov    %r13,%rdi
call   1070 <strcat@plt>
test   $0x10,%bl
mov    %rbp,%rsi
cmovne %r15,%rsi
mov    %r13,%rdi
call   1070 <strcat@plt>
test   $0x8,%bl
mov    %rbp,%rsi
cmovne %r15,%rsi
mov    %r13,%rdi
call   1070 <strcat@plt>
test   $0x4,%bl
mov    %rbp,%rsi
cmovne %r15,%rsi
mov    %r13,%rdi
call   1070 <strcat@plt>
test   $0x2,%bl
mov    %rbp,%rsi
cmovne %r15,%rsi
mov    %r13,%rdi
call   1070 <strcat@plt>
mov    %r13,%rdi
test   $0x1,%bl
je     1f37 <gm_encode+0xdc7>
mov    %r15,%rsi
jmp    1f3a <gm_encode+0xdca>
mov    %rbp,%rsi
call   1070 <strcat@plt>
mov    %r13,%rbp
mov    0x10(%rsp),%r15
mov    (%rsp),%rbx
mov    %rbp,%rdi
call   1040 <strlen@plt>
cmp    $0x23e7,%eax
jg     1f7a <gm_encode+0xe0a>
mov    %ebx,%r13d
mov    0x58(%rsp),%rsi
cmp    %esi,%r12d
jl     1330 <gm_encode+0x1c0>
jmp    1f84 <gm_encode+0xe14>
movl   $0x0,0xc(%rsp)
jmp    1345 <gm_encode+0x1d5>
mov    $0x5,%eax
jmp    2074 <gm_encode+0xf04>
add    $0xffffffff,%ebx
cmp    $0x6,%ebx
ja     200a <gm_encode+0xe9a>
lea    0x1321(%rip),%rsi
lea    0x11d2(%rip),%rax
movslq (%rax,%rbx,4),%rcx
add    %rax,%rcx
jmp    *%rcx
lea    0x122f(%rip),%rsi
jmp    2002 <gm_encode+0xe92>
mov    %rbp,%rdi
mov    0x30(%rsp),%rsi
mov    0xc(%rsp),%edx
call   1080 <add_byte_count@plt>
lea    0x12f9(%rip),%rsi
jmp    2002 <gm_encode+0xe92>
add    $0xffffffff,%r14d
lea    0x12f1(%rip),%rsi
cmp    $0x2,%r14d
ja     2002 <gm_encode+0xe92>
shl    $0x3,%r14d
mov    $0x303031,%eax
mov    %r14d,%ecx
shr    %cl,%eax
mov    $0x303130,%edx
shr    %cl,%edx
mov    0x40(%rsp),%rcx
mov    %al,0x0(%rbp,%rcx,1)
mov    %dl,0x1(%rbp,%rcx,1)
jmp    2002 <gm_encode+0xe92>
lea    0x12cb(%rip),%rsi
mov    %rbp,%rdi
call   1070 <strcat@plt>
mov    %rbp,%rdi
call   1040 <strlen@plt>
cltq
mov    %rbp,%rbx
imul   $0xffffffff92492493,%rax,%rbp
shr    $0x20,%rbp
add    %eax,%ebp
mov    %ebp,%ecx
shr    $0x1f,%ecx
sar    $0x2,%ebp
add    %ecx,%ebp
lea    0x0(,%rbp,8),%ecx
sub    %ecx,%ebp
add    %eax,%ebp
je     205f <gm_encode+0xeef>
add    $0xfffffff9,%ebp
lea    0x127b(%rip),%r14
cs nopw 0x0(%rax,%rax,1)
nop
mov    %rbx,%rdi
mov    %r14,%rsi
call   1070 <strcat@plt>
inc    %ebp
jne    2050 <gm_encode+0xee0>
mov    %rbx,%rdi
call   1040 <strlen@plt>
xor    %ecx,%ecx
cmp    $0x23e8,%eax
setge  %cl
lea    (%rcx,%rcx,4),%eax
add    $0x68,%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"1010\00"
@.str.2 = [6 x i8] c"11000\00"
@.str.3 = [2 x i8] c"1\00"
@.str.4 = [2 x i8] c"0\00"
@.str.5 = [5 x i8] c"0001\00"
@.str.6 = [5 x i8] c"0010\00"
@.str.7 = [5 x i8] c"0011\00"
@.str.8 = [5 x i8] c"0100\00"
@.str.9 = [5 x i8] c"0101\00"
@.str.10 = [5 x i8] c"0111\00"
@.str.11 = [14 x i8] c"1111111100001\00"
@.str.12 = [14 x i8] c"1111111100010\00"
@.str.13 = [14 x i8] c"1111111100011\00"
@.str.14 = [14 x i8] c"1111111100100\00"
@.str.15 = [14 x i8] c"1111111100101\00"
@.str.16 = [11 x i8] c"1111111011\00"
@.str.17 = [11 x i8] c"1111111100\00"
@.str.18 = [11 x i8] c"1111111101\00"
@.str.19 = [11 x i8] c"1111111110\00"
@.str.20 = [11 x i8] c"1111111111\00"
@.str.21 = [6 x i8] c"11100\00"
@.str.22 = [6 x i8] c"11101\00"
@.str.23 = [6 x i8] c"11110\00"
@.str.24 = [8 x i8] c"1111100\00"
@.str.25 = [8 x i8] c"1111110\00"
@.str.26 = [11 x i8] c"1111110001\00"
@.str.27 = [11 x i8] c"1111110010\00"
@.str.28 = [11 x i8] c"1111110011\00"
@.str.29 = [11 x i8] c"1111110100\00"
@.str.30 = [11 x i8] c"1111110111\00"
@.str.31 = [6 x i8] c"CHIN \00"
@.str.32 = [6 x i8] c"NUMB \00"
@.str.33 = [6 x i8] c"LOWR \00"
@.str.34 = [6 x i8] c"UPPR \00"
@.str.35 = [6 x i8] c"MIXD \00"
@.str.36 = [6 x i8] c"BYTE \00"
@.str.37 = [6 x i8] c"[%d] \00"
@.str.38 = [3 x i8] c"XX\00"
@.str.39 = [10 x i8] c"LLLLLLLLL\00"
@.str.40 = [62 x i8] c"0123456789ABCDEFGHIJKLMOPRSTUVWXYZabcdefghijklmnopqrstuvwxyz \00"
@.str.41 = [11 x i8] c"1111110110\00"
@.str.42 = [28 x i8] c"ABCDEFGHIJKLMNOPQRSTUVWXYZ \00"
@.str.43 = [8 x i8] c"1111101\00"
@.str.44 = [28 x i8] c"abcdefghijklmnopqrstuvwxyz \00"
@.str.45 = [14 x i8] c"1111111100000\00"
@.str.46 = [11 x i8] c"1111111010\00"
@.str.47 = [6 x i8] c"11011\00"
@.str.48 = [11 x i8] c"1111110000\00"
@.str.49 = [5 x i8] c"0000\00"
define i32 @gm_encode(i32* %0, i32 %1, i8* %2, i32 %3, i32 %4) {
%6 = alloca i32
%7 = alloca i32*
%8 = alloca i32
%9 = alloca i8*
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
%20 = alloca i32
%21 = alloca i32
%22 = alloca i32
%23 = alloca [3 x i32]
%24 = alloca i32
%25 = alloca i64
%26 = alloca i64
%27 = alloca i32
%28 = alloca i32
%29 = alloca i32
%30 = alloca i32
store i32* %0, i32** %7
store i32 %1, i32* %8
store i8* %2, i8** %9
store i32 %3, i32* %10
store i32 %4, i32* %11
store i32 0, i32* %16
store i32 0, i32* %21
store i32 0, i32* %24
store i64 0, i64* %26
store i32 0, i32* %27
store i32 0, i32* %28
%31 = load i8*, i8** %9
%32 = call i32 @strcpy(i8* %31, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str, i64 0, i64 0))
store i32 0, i32* %12
store i32 0, i32* %13
store i32 0, i32* %15
store i64 0, i64* %25
%33 = load i32, i32* %10
%34 = icmp ne i32 %33, 0
br i1 %34, label %35, label %38
35: ; preds = %5
%36 = load i8*, i8** %9
%37 = call i32 @strcat(i8* %36, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0))
br label %38
38: ; preds = %35, %5
%39 = load i32, i32* %11
%40 = icmp ne i32 %39, 3
br i1 %40, label %41, label %64
41: ; preds = %38
%42 = load i8*, i8** %9
%43 = call i32 @strcat(i8* %42, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.2, i64 0, i64 0))
store i32 0, i32* %17
br label %44
44: ; preds = %60, %41
%45 = load i32, i32* %17
%46 = icmp slt i32 %45, 10
br i1 %46, label %47, label %63
47: ; preds = %44
%48 = load i32, i32* %11
%49 = load i32, i32* %17
%50 = ashr i32 256, %49
%51 = and i32 %48, %50
%52 = icmp ne i32 %51, 0
br i1 %52, label %53, label %56
53: ; preds = %47
%54 = load i8*, i8** %9
%55 = call i32 @strcat(i8* %54, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.3, i64 0, i64 0))
br label %59
56: ; preds = %47
%57 = load i8*, i8** %9
%58 = call i32 @strcat(i8* %57, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0))
br label %59
59: ; preds = %56, %53
br label %60
60: ; preds = %59
%61 = load i32, i32* %17
%62 = add nsw i32 %61, 1
store i32 %62, i32* %17
br label %44
63: ; preds = %44
br label %64
64: ; preds = %63, %38
br label %65
65: ; preds = %906, %64
%66 = load i32*, i32** %7
%67 = load i32, i32* %8
%68 = load i32, i32* %12
%69 = load i32, i32* %13
%70 = call i32 @seek_forward(i32* %66, i32 %67, i32 %68, i32 %69)
store i32 %70, i32* %14
%71 = load i32, i32* %14
%72 = load i32, i32* %13
%73 = icmp ne i32 %71, %72
br i1 %73, label %74, label %236
74: ; preds = %65
%75 = load i32, i32* %13
switch i32 %75, label %217 [
i32 0, label %76
i32 7, label %97
i32 1, label %115
i32 2, label %159
i32 3, label %159
i32 4, label %177
i32 6, label %195
]
76: ; preds = %74
%77 = load i32, i32* %14
switch i32 %77, label %96 [
i32 7, label %78
i32 1, label %81
i32 2, label %84
i32 3, label %87
i32 4, label %90
i32 6, label %93
]
78: ; preds = %76
%79 = load i8*, i8** %9
%80 = call i32 @strcat(i8* %79, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.5, i64 0, i64 0))
br label %96
81: ; preds = %76
%82 = load i8*, i8** %9
%83 = call i32 @strcat(i8* %82, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.6, i64 0, i64 0))
br label %96
84: ; preds = %76
%85 = load i8*, i8** %9
%86 = call i32 @strcat(i8* %85, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.7, i64 0, i64 0))
br label %96
87: ; preds = %76
%88 = load i8*, i8** %9
%89 = call i32 @strcat(i8* %88, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.8, i64 0, i64 0))
br label %96
90: ; preds = %76
%91 = load i8*, i8** %9
%92 = call i32 @strcat(i8* %91, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.9, i64 0, i64 0))
br label %96
93: ; preds = %76
%94 = load i8*, i8** %9
%95 = call i32 @strcat(i8* %94, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.10, i64 0, i64 0))
br label %96
96: ; preds = %76, %93, %90, %87, %84, %81, %78
br label %217
97: ; preds = %74
%98 = load i32, i32* %14
switch i32 %98, label %114 [
i32 1, label %99
i32 2, label %102
i32 3, label %105
i32 4, label %108
i32 6, label %111
]
99: ; preds = %97
%100 = load i8*, i8** %9
%101 = call i32 @strcat(i8* %100, i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.11, i64 0, i64 0))
br label %114
102: ; preds = %97
%103 = load i8*, i8** %9
%104 = call i32 @strcat(i8* %103, i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.12, i64 0, i64 0))
br label %114
105: ; preds = %97
%106 = load i8*, i8** %9
%107 = call i32 @strcat(i8* %106, i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.13, i64 0, i64 0))
br label %114
108: ; preds = %97
%109 = load i8*, i8** %9
%110 = call i32 @strcat(i8* %109, i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.14, i64 0, i64 0))
br label %114
111: ; preds = %97
%112 = load i8*, i8** %9
%113 = call i32 @strcat(i8* %112, i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.15, i64 0, i64 0))
br label %114
114: ; preds = %97, %111, %108, %105, %102, %99
br label %217
115: ; preds = %74
%116 = load i32, i32* %21
switch i32 %116, label %141 [
i32 1, label %117
i32 2, label %125
i32 3, label %133
]
117: ; preds = %115
%118 = load i8*, i8** %9
%119 = load i64, i64* %25
%120 = getelementptr inbounds i8, i8* %118, i64 %119
store i8 49, i8* %120
%121 = load i8*, i8** %9
%122 = load i64, i64* %25
%123 = add i64 %122, 1
%124 = getelementptr inbounds i8, i8* %121, i64 %123
store i8 48, i8* %124
br label %141
125: ; preds = %115
%126 = load i8*, i8** %9
%127 = load i64, i64* %25
%128 = getelementptr inbounds i8, i8* %126, i64 %127
store i8 48, i8* %128
%129 = load i8*, i8** %9
%130 = load i64, i64* %25
%131 = add i64 %130, 1
%132 = getelementptr inbounds i8, i8* %129, i64 %131
store i8 49, i8* %132
br label %141
133: ; preds = %115
%134 = load i8*, i8** %9
%135 = load i64, i64* %25
%136 = getelementptr inbounds i8, i8* %134, i64 %135
store i8 48, i8* %136
%137 = load i8*, i8** %9
%138 = load i64, i64* %25
%139 = add i64 %138, 1
%140 = getelementptr inbounds i8, i8* %137, i64 %139
store i8 48, i8* %140
br label %141
141: ; preds = %115, %133, %125, %117
%142 = load i32, i32* %14
switch i32 %142, label %158 [
i32 7, label %143
i32 2, label %146
i32 3, label %149
i32 4, label %152
i32 6, label %155
]
143: ; preds = %141
%144 = load i8*, i8** %9
%145 = call i32 @strcat(i8* %144, i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.16, i64 0, i64 0))
br label %158
146: ; preds = %141
%147 = load i8*, i8** %9
%148 = call i32 @strcat(i8* %147, i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.17, i64 0, i64 0))
br label %158
149: ; preds = %141
%150 = load i8*, i8** %9
%151 = call i32 @strcat(i8* %150, i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.18, i64 0, i64 0))
br label %158
152: ; preds = %141
%153 = load i8*, i8** %9
%154 = call i32 @strcat(i8* %153, i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.19, i64 0, i64 0))
br label %158
155: ; preds = %141
%156 = load i8*, i8** %9
%157 = call i32 @strcat(i8* %156, i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.20, i64 0, i64 0))
br label %158
158: ; preds = %141, %155, %152, %149, %146, %143
br label %217
159: ; preds = %74, %74
%160 = load i32, i32* %14
switch i32 %160, label %176 [
i32 7, label %161
i32 1, label %164
i32 2, label %167
i32 3, label %167
i32 4, label %170
i32 6, label %173
]
161: ; preds = %159
%162 = load i8*, i8** %9
%163 = call i32 @strcat(i8* %162, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.21, i64 0, i64 0))
br label %176
164: ; preds = %159
%165 = load i8*, i8** %9
%166 = call i32 @strcat(i8* %165, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.22, i64 0, i64 0))
br label %176
167: ; preds = %159, %159
%168 = load i8*, i8** %9
%169 = call i32 @strcat(i8* %168, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.23, i64 0, i64 0))
br label %176
170: ; preds = %159
%171 = load i8*, i8** %9
%172 = call i32 @strcat(i8* %171, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.24, i64 0, i64 0))
br label %176
173: ; preds = %159
%174 = load i8*, i8** %9
%175 = call i32 @strcat(i8* %174, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.25, i64 0, i64 0))
br label %176
176: ; preds = %159, %173, %170, %167, %164, %161
br label %217
177: ; preds = %74
%178 = load i32, i32* %14
switch i32 %178, label %194 [
i32 7, label %179
i32 1, label %182
i32 2, label %185
i32 3, label %188
i32 6, label %191
]
179: ; preds = %177
%180 = load i8*, i8** %9
%181 = call i32 @strcat(i8* %180, i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.26, i64 0, i64 0))
br label %194
182: ; preds = %177
%183 = load i8*, i8** %9
%184 = call i32 @strcat(i8* %183, i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.27, i64 0, i64 0))
br label %194
185: ; preds = %177
%186 = load i8*, i8** %9
%187 = call i32 @strcat(i8* %186, i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.28, i64 0, i64 0))
br label %194
188: ; preds = %177
%189 = load i8*, i8** %9
%190 = call i32 @strcat(i8* %189, i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.29, i64 0, i64 0))
br label %194
191: ; preds = %177
%192 = load i8*, i8** %9
%193 = call i32 @strcat(i8* %192, i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.30, i64 0, i64 0))
br label %194
194: ; preds = %177, %191, %188, %185, %182, %179
br label %217
195: ; preds = %74
%196 = load i8*, i8** %9
%197 = load i64, i64* %26
%198 = load i32, i32* %27
%199 = call i32 @add_byte_count(i8* %196, i64 %197, i32 %198)
store i32 0, i32* %27
%200 = load i32, i32* %14
switch i32 %200, label %216 [
i32 7, label %201
i32 1, label %204
i32 2, label %207
i32 3, label %210
i32 4, label %213
]
201: ; preds = %195
%202 = load i8*, i8** %9
%203 = call i32 @strcat(i8* %202, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.5, i64 0, i64 0))
br label %216
204: ; preds = %195
%205 = load i8*, i8** %9
%206 = call i32 @strcat(i8* %205, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.6, i64 0, i64 0))
br label %216
207: ; preds = %195
%208 = load i8*, i8** %9
%209 = call i32 @strcat(i8* %208, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.7, i64 0, i64 0))
br label %216
210: ; preds = %195
%211 = load i8*, i8** %9
%212 = call i32 @strcat(i8* %211, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.8, i64 0, i64 0))
br label %216
213: ; preds = %195
%214 = load i8*, i8** %9
%215 = call i32 @strcat(i8* %214, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.9, i64 0, i64 0))
br label %216
216: ; preds = %195, %213, %210, %207, %204, %201
br label %217
217: ; preds = %74, %216, %194, %176, %158, %114, %96
%218 = load i32, i32* %28
%219 = icmp ne i32 %218, 0
br i1 %219, label %220, label %235
220: ; preds = %217
%221 = load i32, i32* %14
switch i32 %221, label %234 [
i32 7, label %222
i32 1, label %224
i32 2, label %226
i32 3, label %228
i32 4, label %230
i32 6, label %232
]
222: ; preds = %220
%223 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.31, i64 0, i64 0))
br label %234
224: ; preds = %220
%225 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.32, i64 0, i64 0))
br label %234
226: ; preds = %220
%227 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.33, i64 0, i64 0))
br label %234
228: ; preds = %220
%229 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.34, i64 0, i64 0))
br label %234
230: ; preds = %220
%231 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.35, i64 0, i64 0))
br label %234
232: ; preds = %220
%233 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.36, i64 0, i64 0))
br label %234
234: ; preds = %220, %232, %230, %228, %226, %224, %222
br label %235
235: ; preds = %234, %217
br label %236
236: ; preds = %235, %65
%237 = load i32, i32* %13
store i32 %237, i32* %15
%238 = load i32, i32* %14
store i32 %238, i32* %13
%239 = load i32, i32* %13
switch i32 %239, label %900 [
i32 7, label %240
i32 1, label %414
i32 6, label %593
i32 4, label %654
i32 3, label %756
i32 2, label %828
]
240: ; preds = %236
store i32 0, i32* %20
%241 = load i32*, i32** %7
%242 = load i32, i32* %12
%243 = sext i32 %242 to i64
%244 = getelementptr inbounds i32, i32* %241, i64 %243
%245 = load i32, i32* %244
%246 = icmp sgt i32 %245, 255
br i1 %246, label %247, label %288
247: ; preds = %240
%248 = load i32*, i32** %7
%249 = load i32, i32* %12
%250 = sext i32 %249 to i64
%251 = getelementptr inbounds i32, i32* %248, i64 %250
%252 = load i32, i32* %251
%253 = and i32 %252, 65280
%254 = ashr i32 %253, 8
store i32 %254, i32* %18
%255 = load i32*, i32** %7
%256 = load i32, i32* %12
%257 = sext i32 %256 to i64
%258 = getelementptr inbounds i32, i32* %255, i64 %257
%259 = load i32, i32* %258
%260 = and i32 %259, 255
store i32 %260, i32* %19
%261 = load i32, i32* %18
%262 = icmp sge i32 %261, 160
br i1 %262, label %263, label %273
263: ; preds = %247
%264 = load i32, i32* %18
%265 = icmp sle i32 %264, 169
br i1 %265, label %266, label %273
266: ; preds = %263
%267 = load i32, i32* %18
%268 = sub nsw i32 %267, 161
%269 = mul nsw i32 96, %268
%270 = load i32, i32* %19
%271 = sub nsw i32 %270, 160
%272 = add nsw i32 %269, %271
store i32 %272, i32* %16
br label %273
273: ; preds = %266, %263, %247
%274 = load i32, i32* %18
%275 = icmp sge i32 %274, 176
br i1 %275, label %276, label %287
276: ; preds = %273
%277 = load i32, i32* %18
%278 = icmp sle i32 %277, 247
br i1 %278, label %279, label %287
279: ; preds = %276
%280 = load i32, i32* %18
%281 = sub nsw i32 %280, 176
%282 = add nsw i32 %281, 9
%283 = mul nsw i32 96, %282
%284 = load i32, i32* %19
%285 = sub nsw i32 %284, 160
%286 = add nsw i32 %283, %285
store i32 %286, i32* %16
br label %287
287: ; preds = %279, %276, %273
store i32 1, i32* %20
br label %288
288: ; preds = %287, %240
%289 = load i32, i32* %20
%290 = icmp ne i32 %289, 0
br i1 %290, label %316, label %291
291: ; preds = %288
%292 = load i32, i32* %12
%293 = load i32, i32* %8
%294 = sub nsw i32 %293, 1
%295 = icmp ne i32 %292, %294
br i1 %295, label %296, label %315
296: ; preds = %291
%297 = load i32*, i32** %7
%298 = load i32, i32* %12
%299 = sext i32 %298 to i64
%300 = getelementptr inbounds i32, i32* %297, i64 %299
%301 = load i32, i32* %300
%302 = icmp eq i32 %301, 19
br i1 %302, label %303, label %314
303: ; preds = %296
%304 = load i32*, i32** %7
%305 = load i32, i32* %12
%306 = add nsw i32 %305, 1
%307 = sext i32 %306 to i64
%308 = getelementptr inbounds i32, i32* %304, i64 %307
%309 = load i32, i32* %308
%310 = icmp eq i32 %309, 16
br i1 %310, label %311, label %314
311: ; preds = %303
store i32 7776, i32* %16
%312 = load i32, i32* %12
%313 = add nsw i32 %312, 1
store i32 %313, i32* %12
br label %314
314: ; preds = %311, %303, %296
store i32 1, i32* %20
br label %315
315: ; preds = %314, %291
br label %316
316: ; preds = %315, %288
%317 = load i32, i32* %20
%318 = icmp ne i32 %317, 0
br i1 %318, label %375, label %319
319: ; preds = %316
%320 = load i32, i32* %12
%321 = load i32, i32* %8
%322 = sub nsw i32 %321, 1
%323 = icmp ne i32 %320, %322
br i1 %323, label %324, label %374
324: ; preds = %319
%325 = load i32*, i32** %7
%326 = load i32, i32* %12
%327 = sext i32 %326 to i64
%328 = getelementptr inbounds i32, i32* %325, i64 %327
%329 = load i32, i32* %328
%330 = icmp sge i32 %329, 48
br i1 %330, label %331, label %373
331: ; preds = %324
%332 = load i32*, i32** %7
%333 = load i32, i32* %12
%334 = sext i32 %333 to i64
%335 = getelementptr inbounds i32, i32* %332, i64 %334
%336 = load i32, i32* %335
%337 = icmp sle i32 %336, 57
br i1 %337, label %338, label %373
338: ; preds = %331
%339 = load i32*, i32** %7
%340 = load i32, i32* %12
%341 = add nsw i32 %340, 1
%342 = sext i32 %341 to i64
%343 = getelementptr inbounds i32, i32* %339, i64 %342
%344 = load i32, i32* %343
%345 = icmp sge i32 %344, 48
br i1 %345, label %346, label %373
346: ; preds = %338
%347 = load i32*, i32** %7
%348 = load i32, i32* %12
%349 = add nsw i32 %348, 1
%350 = sext i32 %349 to i64
%351 = getelementptr inbounds i32, i32* %347, i64 %350
%352 = load i32, i32* %351
%353 = icmp sle i32 %352, 57
br i1 %353, label %354, label %373
354: ; preds = %346
%355 = load i32*, i32** %7
%356 = load i32, i32* %12
%357 = sext i32 %356 to i64
%358 = getelementptr inbounds i32, i32* %355, i64 %357
%359 = load i32, i32* %358
%360 = sub nsw i32 %359, 48
%361 = mul nsw i32 10, %360
%362 = add nsw i32 8033, %361
%363 = load i32*, i32** %7
%364 = load i32, i32* %12
%365 = add nsw i32 %364, 1
%366 = sext i32 %365 to i64
%367 = getelementptr inbounds i32, i32* %363, i64 %366
%368 = load i32, i32* %367
%369 = sub nsw i32 %368, 48
%370 = add nsw i32 %362, %369
store i32 %370, i32* %16
%371 = load i32, i32* %12
%372 = add nsw i32 %371, 1
store i32 %372, i32* %12
br label %373
373: ; preds = %354, %346, %338, %331, %324
br label %374
374: ; preds = %373, %319
br label %375
375: ; preds = %374, %316
%376 = load i32, i32* %20
%377 = icmp ne i32 %376, 0
br i1 %377, label %385, label %378
378: ; preds = %375
%379 = load i32*, i32** %7
%380 = load i32, i32* %12
%381 = sext i32 %380 to i64
%382 = getelementptr inbounds i32, i32* %379, i64 %381
%383 = load i32, i32* %382
%384 = add nsw i32 7777, %383
store i32 %384, i32* %16
br label %385
385: ; preds = %378, %375
%386 = load i32, i32* %28
%387 = icmp ne i32 %386, 0
br i1 %387, label %388, label %391
388: ; preds = %385
%389 = load i32, i32* %16
%390 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.37, i64 0, i64 0), i32 %389)
br label %391
391: ; preds = %388, %385
store i32 0, i32* %17
br label %392
392: ; preds = %408, %391
%393 = load i32, i32* %17
%394 = icmp slt i32 %393, 13
br i1 %394, label %395, label %411
395: ; preds = %392
%396 = load i32, i32* %16
%397 = load i32, i32* %17
%398 = ashr i32 4096, %397
%399 = and i32 %396, %398
%400 = icmp ne i32 %399, 0
br i1 %400, label %401, label %404
401: ; preds = %395
%402 = load i8*, i8** %9
%403 = call i32 @strcat(i8* %402, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.3, i64 0, i64 0))
br label %407
404: ; preds = %395
%405 = load i8*, i8** %9
%406 = call i32 @strcat(i8* %405, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0))
br label %407
407: ; preds = %404, %401
br label %408
408: ; preds = %407
%409 = load i32, i32* %17
%410 = add nsw i32 %409, 1
store i32 %410, i32* %17
br label %392
411: ; preds = %392
%412 = load i32, i32* %12
%413 = add nsw i32 %412, 1
store i32 %413, i32* %12
br label %900
414: ; preds = %236
%415 = load i32, i32* %15
%416 = load i32, i32* %13
%417 = icmp ne i32 %415, %416
br i1 %417, label %418, label %424
418: ; preds = %414
%419 = load i8*, i8** %9
%420 = call i32 @strlen(i8* %419)
%421 = sext i32 %420 to i64
store i64 %421, i64* %25
%422 = load i8*, i8** %9
%423 = call i32 @strcat(i8* %422, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.38, i64 0, i64 0))
br label %424
424: ; preds = %418, %414
store i32 0, i32* %21
store i32 -1, i32* %22
%425 = getelementptr inbounds [3 x i32], [3 x i32]* %23, i64 0, i64 0
store i32 48, i32* %425
%426 = getelementptr inbounds [3 x i32], [3 x i32]* %23, i64 0, i64 1
store i32 48, i32* %426
%427 = getelementptr inbounds [3 x i32], [3 x i32]* %23, i64 0, i64 2
store i32 48, i32* %427
br label %428
428: ; preds = %508, %424
%429 = load i32*, i32** %7
%430 = load i32, i32* %12
%431 = sext i32 %430 to i64
%432 = getelementptr inbounds i32, i32* %429, i64 %431
%433 = load i32, i32* %432
%434 = icmp sge i32 %433, 48
br i1 %434, label %435, label %455
435: ; preds = %428
%436 = load i32*, i32** %7
%437 = load i32, i32* %12
%438 = sext i32 %437 to i64
%439 = getelementptr inbounds i32, i32* %436, i64 %438
%440 = load i32, i32* %439
%441 = icmp sle i32 %440, 57
br i1 %441, label %442, label %455
442: ; preds = %435
%443 = load i32*, i32** %7
%444 = load i32, i32* %12
%445 = sext i32 %444 to i64
%446 = getelementptr inbounds i32, i32* %443, i64 %445
%447 = load i32, i32* %446
%448 = load i32, i32* %21
%449 = sext i32 %448 to i64
%450 = getelementptr inbounds [3 x i32], [3 x i32]* %23, i64 0, i64 %449
store i32 %447, i32* %450
%451 = load i32, i32* %12
%452 = add nsw i32 %451, 1
store i32 %452, i32* %12
%453 = load i32, i32* %21
%454 = add nsw i32 %453, 1
store i32 %454, i32* %21
br label %455
455: ; preds = %442, %435, %428
%456 = load i32*, i32** %7
%457 = load i32, i32* %12
%458 = sext i32 %457 to i64
%459 = getelementptr inbounds i32, i32* %456, i64 %458
%460 = load i32, i32* %459
switch i32 %460, label %470 [
i32 32, label %461
i32 43, label %461
i32 45, label %461
i32 46, label %461
i32 44, label %461
]
461: ; preds = %455, %455, %455, %455, %455
%462 = load i32*, i32** %7
%463 = load i32, i32* %12
%464 = sext i32 %463 to i64
%465 = getelementptr inbounds i32, i32* %462, i64 %464
%466 = load i32, i32* %465
store i32 %466, i32* %24
%467 = load i32, i32* %12
%468 = add nsw i32 %467, 1
store i32 %468, i32* %12
%469 = load i32, i32* %21
store i32 %469, i32* %22
br label %470
470: ; preds = %455, %461
%471 = load i32, i32* %12
%472 = load i32, i32* %8
%473 = sub nsw i32 %472, 1
%474 = icmp slt i32 %471, %473
br i1 %474, label %475, label %500
475: ; preds = %470
%476 = load i32*, i32** %7
%477 = load i32, i32* %12
%478 = sext i32 %477 to i64
%479 = getelementptr inbounds i32, i32* %476, i64 %478
%480 = load i32, i32* %479
%481 = icmp eq i32 %480, 19
br i1 %481, label %482, label %499
482: ; preds = %475
%483 = load i32*, i32** %7
%484 = load i32, i32* %12
%485 = add nsw i32 %484, 1
%486 = sext i32 %485 to i64
%487 = getelementptr inbounds i32, i32* %483, i64 %486
%488 = load i32, i32* %487
%489 = icmp eq i32 %488, 16
br i1 %489, label %490, label %499
490: ; preds = %482
%491 = load i32*, i32** %7
%492 = load i32, i32* %12
%493 = sext i32 %492 to i64
%494 = getelementptr inbounds i32, i32* %491, i64 %493
%495 = load i32, i32* %494
store i32 %495, i32* %24
%496 = load i32, i32* %12
%497 = add nsw i32 %496, 2
store i32 %497, i32* %12
%498 = load i32, i32* %21
store i32 %498, i32* %22
br label %499
499: ; preds = %490, %482, %475
br label %500
500: ; preds = %499, %470
br label %501
501: ; preds = %500
%502 = load i32, i32* %21
%503 = icmp slt i32 %502, 3
br i1 %503, label %504, label %508
504: ; preds = %501
%505 = load i32, i32* %12
%506 = load i32, i32* %8
%507 = icmp slt i32 %505, %506
br label %508
508: ; preds = %504, %501
%509 = phi i1 [ false, %501 ], [ %507, %504 ]
br i1 %509, label %428, label %510
510: ; preds = %508
%511 = load i32, i32* %22
%512 = icmp ne i32 %511, -1
br i1 %512, label %513, label %553
513: ; preds = %510
%514 = load i32, i32* %24
switch i32 %514, label %521 [
i32 32, label %515
i32 43, label %516
i32 45, label %517
i32 46, label %518
i32 44, label %519
i32 19, label %520
]
515: ; preds = %513
store i32 0, i32* %16
br label %521
516: ; preds = %513
store i32 3, i32* %16
br label %521
517: ; preds = %513
store i32 6, i32* %16
br label %521
518: ; preds = %513
store i32 9, i32* %16
br label %521
519: ; preds = %513
store i32 12, i32* %16
br label %521
520: ; preds = %513
store i32 15, i32* %16
br label %521
521: ; preds = %513, %520, %519, %518, %517, %516, %515
%522 = load i32, i32* %22
%523 = load i32, i32* %16
%524 = add nsw i32 %523, %522
store i32 %524, i32* %16
%525 = load i32, i32* %16
%526 = add nsw i32 %525, 1000
store i32 %526, i32* %16
%527 = load i32, i32* %28
%528 = icmp ne i32 %527, 0
br i1 %528, label %529, label %532
529: ; preds = %521
%530 = load i32, i32* %16
%531 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.37, i64 0, i64 0), i32 %530)
br label %532
532: ; preds = %529, %521
store i32 0, i32* %17
br label %533
533: ; preds = %549, %532
%534 = load i32, i32* %17
%535 = icmp slt i32 %534, 10
br i1 %535, label %536, label %552
536: ; preds = %533
%537 = load i32, i32* %16
%538 = load i32, i32* %17
%539 = ashr i32 512, %538
%540 = and i32 %537, %539
%541 = icmp ne i32 %540, 0
br i1 %541, label %542, label %545
542: ; preds = %536
%543 = load i8*, i8** %9
%544 = call i32 @strcat(i8* %543, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.3, i64 0, i64 0))
br label %548
545: ; preds = %536
%546 = load i8*, i8** %9
%547 = call i32 @strcat(i8* %546, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0))
br label %548
548: ; preds = %545, %542
br label %549
549: ; preds = %548
%550 = load i32, i32* %17
%551 = add nsw i32 %550, 1
store i32 %551, i32* %17
br label %533
552: ; preds = %533
br label %553
553: ; preds = %552, %510
%554 = getelementptr inbounds [3 x i32], [3 x i32]* %23, i64 0, i64 0
%555 = load i32, i32* %554
%556 = sub nsw i32 %555, 48
%557 = mul nsw i32 100, %556
%558 = getelementptr inbounds [3 x i32], [3 x i32]* %23, i64 0, i64 1
%559 = load i32, i32* %558
%560 = sub nsw i32 %559, 48
%561 = mul nsw i32 10, %560
%562 = add nsw i32 %557, %561
%563 = getelementptr inbounds [3 x i32], [3 x i32]* %23, i64 0, i64 2
%564 = load i32, i32* %563
%565 = sub nsw i32 %564, 48
%566 = add nsw i32 %562, %565
store i32 %566, i32* %16
%567 = load i32, i32* %28
%568 = icmp ne i32 %567, 0
br i1 %568, label %569, label %572
569: ; preds = %553
%570 = load i32, i32* %16
%571 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.37, i64 0, i64 0), i32 %570)
br label %572
572: ; preds = %569, %553
store i32 0, i32* %17
br label %573
573: ; preds = %589, %572
%574 = load i32, i32* %17
%575 = icmp slt i32 %574, 10
br i1 %575, label %576, label %592
576: ; preds = %573
%577 = load i32, i32* %16
%578 = load i32, i32* %17
%579 = ashr i32 512, %578
%580 = and i32 %577, %579
%581 = icmp ne i32 %580, 0
br i1 %581, label %582, label %585
582: ; preds = %576
%583 = load i8*, i8** %9
%584 = call i32 @strcat(i8* %583, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.3, i64 0, i64 0))
br label %588
585: ; preds = %576
%586 = load i8*, i8** %9
%587 = call i32 @strcat(i8* %586, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0))
br label %588
588: ; preds = %585, %582
br label %589
589: ; preds = %588
%590 = load i32, i32* %17
%591 = add nsw i32 %590, 1
store i32 %591, i32* %17
br label %573
592: ; preds = %573
br label %900
593: ; preds = %236
%594 = load i32, i32* %15
%595 = load i32, i32* %13
%596 = icmp ne i32 %594, %595
br i1 %596, label %597, label %603
597: ; preds = %593
%598 = load i8*, i8** %9
%599 = call i32 @strlen(i8* %598)
%600 = sext i32 %599 to i64
store i64 %600, i64* %26
%601 = load i8*, i8** %9
%602 = call i32 @strcat(i8* %601, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.39, i64 0, i64 0))
br label %603
603: ; preds = %597, %593
%604 = load i32, i32* %27
%605 = icmp eq i32 %604, 512
br i1 %605, label %606, label %618
606: ; preds = %603
%607 = load i8*, i8** %9
%608 = load i64, i64* %26
%609 = load i32, i32* %27
%610 = call i32 @add_byte_count(i8* %607, i64 %608, i32 %609)
%611 = load i8*, i8** %9
%612 = call i32 @strcat(i8* %611, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.10, i64 0, i64 0))
%613 = load i8*, i8** %9
%614 = call i32 @strlen(i8* %613)
%615 = sext i32 %614 to i64
store i64 %615, i64* %26
%616 = load i8*, i8** %9
%617 = call i32 @strcat(i8* %616, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.39, i64 0, i64 0))
store i32 0, i32* %27
br label %618
618: ; preds = %606, %603
%619 = load i32*, i32** %7
%620 = load i32, i32* %12
%621 = sext i32 %620 to i64
%622 = getelementptr inbounds i32, i32* %619, i64 %621
%623 = load i32, i32* %622
store i32 %623, i32* %16
%624 = load i32, i32* %28
%625 = icmp ne i32 %624, 0
br i1 %625, label %626, label %629
626: ; preds = %618
%627 = load i32, i32* %16
%628 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.37, i64 0, i64 0), i32 %627)
br label %629
629: ; preds = %626, %618
store i32 0, i32* %17
br label %630
630: ; preds = %646, %629
%631 = load i32, i32* %17
%632 = icmp slt i32 %631, 8
br i1 %632, label %633, label %649
633: ; preds = %630
%634 = load i32, i32* %16
%635 = load i32, i32* %17
%636 = ashr i32 128, %635
%637 = and i32 %634, %636
%638 = icmp ne i32 %637, 0
br i1 %638, label %639, label %642
639: ; preds = %633
%640 = load i8*, i8** %9
%641 = call i32 @strcat(i8* %640, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.3, i64 0, i64 0))
br label %645
642: ; preds = %633
%643 = load i8*, i8** %9
%644 = call i32 @strcat(i8* %643, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0))
br label %645
645: ; preds = %642, %639
br label %646
646: ; preds = %645
%647 = load i32, i32* %17
%648 = add nsw i32 %647, 1
store i32 %648, i32* %17
br label %630
649: ; preds = %630
%650 = load i32, i32* %12
%651 = add nsw i32 %650, 1
store i32 %651, i32* %12
%652 = load i32, i32* %27
%653 = add nsw i32 %652, 1
store i32 %653, i32* %27
br label %900
654: ; preds = %236
store i32 1, i32* %29
%655 = load i32*, i32** %7
%656 = load i32, i32* %12
%657 = sext i32 %656 to i64
%658 = getelementptr inbounds i32, i32* %655, i64 %657
%659 = load i32, i32* %658
%660 = icmp sge i32 %659, 48
br i1 %660, label %661, label %669
661: ; preds = %654
%662 = load i32*, i32** %7
%663 = load i32, i32* %12
%664 = sext i32 %663 to i64
%665 = getelementptr inbounds i32, i32* %662, i64 %664
%666 = load i32, i32* %665
%667 = icmp sle i32 %666, 57
br i1 %667, label %668, label %669
668: ; preds = %661
store i32 0, i32* %29
br label %669
669: ; preds = %668, %661, %654
%670 = load i32*, i32** %7
%671 = load i32, i32* %12
%672 = sext i32 %671 to i64
%673 = getelementptr inbounds i32, i32* %670, i64 %672
%674 = load i32, i32* %673
%675 = icmp sge i32 %674, 65
br i1 %675, label %676, label %684
676: ; preds = %669
%677 = load i32*, i32** %7
%678 = load i32, i32* %12
%679 = sext i32 %678 to i64
%680 = getelementptr inbounds i32, i32* %677, i64 %679
%681 = load i32, i32* %680
%682 = icmp sle i32 %681, 90
br i1 %682, label %683, label %684
683: ; preds = %676
store i32 0, i32* %29
br label %684
684: ; preds = %683, %676, %669
%685 = load i32*, i32** %7
%686 = load i32, i32* %12
%687 = sext i32 %686 to i64
%688 = getelementptr inbounds i32, i32* %685, i64 %687
%689 = load i32, i32* %688
%690 = icmp sge i32 %689, 97
br i1 %690, label %691, label %699
691: ; preds = %684
%692 = load i32*, i32** %7
%693 = load i32, i32* %12
%694 = sext i32 %693 to i64
%695 = getelementptr inbounds i32, i32* %692, i64 %694
%696 = load i32, i32* %695
%697 = icmp sle i32 %696, 122
br i1 %697, label %698, label %699
698: ; preds = %691
store i32 0, i32* %29
br label %699
699: ; preds = %698, %691, %684
%700 = load i32*, i32** %7
%701 = load i32, i32* %12
%702 = sext i32 %701 to i64
%703 = getelementptr inbounds i32, i32* %700, i64 %702
%704 = load i32, i32* %703
%705 = icmp eq i32 %704, 32
br i1 %705, label %706, label %707
706: ; preds = %699
store i32 0, i32* %29
br label %707
707: ; preds = %706, %699
%708 = load i32, i32* %29
%709 = icmp eq i32 %708, 0
br i1 %709, label %710, label %743
710: ; preds = %707
%711 = load i32*, i32** %7
%712 = load i32, i32* %12
%713 = sext i32 %712 to i64
%714 = getelementptr inbounds i32, i32* %711, i64 %713
%715 = load i32, i32* %714
%716 = call i32 @posn(i8* getelementptr inbounds ([62 x i8], [62 x i8]* @.str.40, i64 0, i64 0), i32 %715)
store i32 %716, i32* %16
%717 = load i32, i32* %28
%718 = icmp ne i32 %717, 0
br i1 %718, label %719, label %722
719: ; preds = %710
%720 = load i32, i32* %16
%721 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.37, i64 0, i64 0), i32 %720)
br label %722
722: ; preds = %719, %710
store i32 0, i32* %17
br label %723
723: ; preds = %739, %722
%724 = load i32, i32* %17
%725 = icmp slt i32 %724, 6
br i1 %725, label %726, label %742
726: ; preds = %723
%727 = load i32, i32* %16
%728 = load i32, i32* %17
%729 = ashr i32 32, %728
%730 = and i32 %727, %729
%731 = icmp ne i32 %730, 0
br i1 %731, label %732, label %735
732: ; preds = %726
%733 = load i8*, i8** %9
%734 = call i32 @strcat(i8* %733, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.3, i64 0, i64 0))
br label %738
735: ; preds = %726
%736 = load i8*, i8** %9
%737 = call i32 @strcat(i8* %736, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0))
br label %738
738: ; preds = %735, %732
br label %739
739: ; preds = %738
%740 = load i32, i32* %17
%741 = add nsw i32 %740, 1
store i32 %741, i32* %17
br label %723
742: ; preds = %723
br label %753
743: ; preds = %707
%744 = load i8*, i8** %9
%745 = call i32 @strcat(i8* %744, i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.41, i64 0, i64 0))
%746 = load i8*, i8** %9
%747 = load i32*, i32** %7
%748 = load i32, i32* %12
%749 = sext i32 %748 to i64
%750 = getelementptr inbounds i32, i32* %747, i64 %749
%751 = load i32, i32* %750
%752 = call i32 @add_shift_char(i8* %746, i32 %751)
br label %753
753: ; preds = %743, %742
%754 = load i32, i32* %12
%755 = add nsw i32 %754, 1
store i32 %755, i32* %12
br label %900
756: ; preds = %236
store i32 1, i32* %29
%757 = load i32*, i32** %7
%758 = load i32, i32* %12
%759 = sext i32 %758 to i64
%760 = getelementptr inbounds i32, i32* %757, i64 %759
%761 = load i32, i32* %760
%762 = icmp sge i32 %761, 65
br i1 %762, label %763, label %771
763: ; preds = %756
%764 = load i32*, i32** %7
%765 = load i32, i32* %12
%766 = sext i32 %765 to i64
%767 = getelementptr inbounds i32, i32* %764, i64 %766
%768 = load i32, i32* %767
%769 = icmp sle i32 %768, 90
br i1 %769, label %770, label %771
770: ; preds = %763
store i32 0, i32* %29
br label %771
771: ; preds = %770, %763, %756
%772 = load i32*, i32** %7
%773 = load i32, i32* %12
%774 = sext i32 %773 to i64
%775 = getelementptr inbounds i32, i32* %772, i64 %774
%776 = load i32, i32* %775
%777 = icmp eq i32 %776, 32
br i1 %777, label %778, label %779
778: ; preds = %771
store i32 0, i32* %29
br label %779
779: ; preds = %778, %771
%780 = load i32, i32* %29
%781 = icmp eq i32 %780, 0
br i1 %781, label %782, label %815
782: ; preds = %779
%783 = load i32*, i32** %7
%784 = load i32, i32* %12
%785 = sext i32 %784 to i64
%786 = getelementptr inbounds i32, i32* %783, i64 %785
%787 = load i32, i32* %786
%788 = call i32 @posn(i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str.42, i64 0, i64 0), i32 %787)
store i32 %788, i32* %16
%789 = load i32, i32* %28
%790 = icmp ne i32 %789, 0
br i1 %790, label %791, label %794
791: ; preds = %782
%792 = load i32, i32* %16
%793 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.37, i64 0, i64 0), i32 %792)
br label %794
794: ; preds = %791, %782
store i32 0, i32* %17
br label %795
795: ; preds = %811, %794
%796 = load i32, i32* %17
%797 = icmp slt i32 %796, 5
br i1 %797, label %798, label %814
798: ; preds = %795
%799 = load i32, i32* %16
%800 = load i32, i32* %17
%801 = ashr i32 16, %800
%802 = and i32 %799, %801
%803 = icmp ne i32 %802, 0
br i1 %803, label %804, label %807
804: ; preds = %798
%805 = load i8*, i8** %9
%806 = call i32 @strcat(i8* %805, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.3, i64 0, i64 0))
br label %810
807: ; preds = %798
%808 = load i8*, i8** %9
%809 = call i32 @strcat(i8* %808, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0))
br label %810
810: ; preds = %807, %804
br label %811
811: ; preds = %810
%812 = load i32, i32* %17
%813 = add nsw i32 %812, 1
store i32 %813, i32* %17
br label %795
814: ; preds = %795
br label %825
815: ; preds = %779
%816 = load i8*, i8** %9
%817 = call i32 @strcat(i8* %816, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.43, i64 0, i64 0))
%818 = load i8*, i8** %9
%819 = load i32*, i32** %7
%820 = load i32, i32* %12
%821 = sext i32 %820 to i64
%822 = getelementptr inbounds i32, i32* %819, i64 %821
%823 = load i32, i32* %822
%824 = call i32 @add_shift_char(i8* %818, i32 %823)
br label %825
825: ; preds = %815, %814
%826 = load i32, i32* %12
%827 = add nsw i32 %826, 1
store i32 %827, i32* %12
br label %900
828: ; preds = %236
store i32 1, i32* %29
%829 = load i32*, i32** %7
%830 = load i32, i32* %12
%831 = sext i32 %830 to i64
%832 = getelementptr inbounds i32, i32* %829, i64 %831
%833 = load i32, i32* %832
%834 = icmp sge i32 %833, 97
br i1 %834, label %835, label %843
835: ; preds = %828
%836 = load i32*, i32** %7
%837 = load i32, i32* %12
%838 = sext i32 %837 to i64
%839 = getelementptr inbounds i32, i32* %836, i64 %838
%840 = load i32, i32* %839
%841 = icmp sle i32 %840, 122
br i1 %841, label %842, label %843
842: ; preds = %835
store i32 0, i32* %29
br label %843
843: ; preds = %842, %835, %828
%844 = load i32*, i32** %7
%845 = load i32, i32* %12
%846 = sext i32 %845 to i64
%847 = getelementptr inbounds i32, i32* %844, i64 %846
%848 = load i32, i32* %847
%849 = icmp eq i32 %848, 32
br i1 %849, label %850, label %851
850: ; preds = %843
store i32 0, i32* %29
br label %851
851: ; preds = %850, %843
%852 = load i32, i32* %29
%853 = icmp eq i32 %852, 0
br i1 %853, label %854, label %887
854: ; preds = %851
%855 = load i32*, i32** %7
%856 = load i32, i32* %12
%857 = sext i32 %856 to i64
%858 = getelementptr inbounds i32, i32* %855, i64 %857
%859 = load i32, i32* %858
%860 = call i32 @posn(i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str.44, i64 0, i64 0), i32 %859)
store i32 %860, i32* %16
%861 = load i32, i32* %28
%862 = icmp ne i32 %861, 0
br i1 %862, label %863, label %866
863: ; preds = %854
%864 = load i32, i32* %16
%865 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.37, i64 0, i64 0), i32 %864)
br label %866
866: ; preds = %863, %854
store i32 0, i32* %17
br label %867
867: ; preds = %883, %866
%868 = load i32, i32* %17
%869 = icmp slt i32 %868, 5
br i1 %869, label %870, label %886
870: ; preds = %867
%871 = load i32, i32* %16
%872 = load i32, i32* %17
%873 = ashr i32 16, %872
%874 = and i32 %871, %873
%875 = icmp ne i32 %874, 0
br i1 %875, label %876, label %879
876: ; preds = %870
%877 = load i8*, i8** %9
%878 = call i32 @strcat(i8* %877, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.3, i64 0, i64 0))
br label %882
879: ; preds = %870
%880 = load i8*, i8** %9
%881 = call i32 @strcat(i8* %880, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0))
br label %882
882: ; preds = %879, %876
br label %883
883: ; preds = %882
%884 = load i32, i32* %17
%885 = add nsw i32 %884, 1
store i32 %885, i32* %17
br label %867
886: ; preds = %867
br label %897
887: ; preds = %851
%888 = load i8*, i8** %9
%889 = call i32 @strcat(i8* %888, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.43, i64 0, i64 0))
%890 = load i8*, i8** %9
%891 = load i32*, i32** %7
%892 = load i32, i32* %12
%893 = sext i32 %892 to i64
%894 = getelementptr inbounds i32, i32* %891, i64 %893
%895 = load i32, i32* %894
%896 = call i32 @add_shift_char(i8* %890, i32 %895)
br label %897
897: ; preds = %887, %886
%898 = load i32, i32* %12
%899 = add nsw i32 %898, 1
store i32 %899, i32* %12
br label %900
900: ; preds = %236, %897, %825, %753, %649, %592, %411
%901 = load i8*, i8** %9
%902 = call i32 @strlen(i8* %901)
%903 = icmp sgt i32 %902, 9191
br i1 %903, label %904, label %905
904: ; preds = %900
store i32 5, i32* %6
br label %990
905: ; preds = %900
br label %906
906: ; preds = %905
%907 = load i32, i32* %12
%908 = load i32, i32* %8
%909 = icmp slt i32 %907, %908
br i1 %909, label %65, label %910
910: ; preds = %906
%911 = load i32, i32* %13
%912 = icmp eq i32 %911, 1
br i1 %912, label %913, label %940
913: ; preds = %910
%914 = load i32, i32* %21
switch i32 %914, label %939 [
i32 1, label %915
i32 2, label %923
i32 3, label %931
]
915: ; preds = %913
%916 = load i8*, i8** %9
%917 = load i64, i64* %25
%918 = getelementptr inbounds i8, i8* %916, i64 %917
store i8 49, i8* %918
%919 = load i8*, i8** %9
%920 = load i64, i64* %25
%921 = add i64 %920, 1
%922 = getelementptr inbounds i8, i8* %919, i64 %921
store i8 48, i8* %922
br label %939
923: ; preds = %913
%924 = load i8*, i8** %9
%925 = load i64, i64* %25
%926 = getelementptr inbounds i8, i8* %924, i64 %925
store i8 48, i8* %926
%927 = load i8*, i8** %9
%928 = load i64, i64* %25
%929 = add i64 %928, 1
%930 = getelementptr inbounds i8, i8* %927, i64 %929
store i8 49, i8* %930
br label %939
931: ; preds = %913
%932 = load i8*, i8** %9
%933 = load i64, i64* %25
%934 = getelementptr inbounds i8, i8* %932, i64 %933
store i8 48, i8* %934
%935 = load i8*, i8** %9
%936 = load i64, i64* %25
%937 = add i64 %936, 1
%938 = getelementptr inbounds i8, i8* %935, i64 %937
store i8 48, i8* %938
br label %939
939: ; preds = %913, %931, %923, %915
br label %940
940: ; preds = %939, %910
%941 = load i32, i32* %13
%942 = icmp eq i32 %941, 6
br i1 %942, label %943, label %948
943: ; preds = %940
%944 = load i8*, i8** %9
%945 = load i64, i64* %26
%946 = load i32, i32* %27
%947 = call i32 @add_byte_count(i8* %944, i64 %945, i32 %946)
br label %948
948: ; preds = %943, %940
%949 = load i32, i32* %13
switch i32 %949, label %965 [
i32 7, label %950
i32 1, label %953
i32 2, label %956
i32 3, label %956
i32 4, label %959
i32 6, label %962
]
950: ; preds = %948
%951 = load i8*, i8** %9
%952 = call i32 @strcat(i8* %951, i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.45, i64 0, i64 0))
br label %965
953: ; preds = %948
%954 = load i8*, i8** %9
%955 = call i32 @strcat(i8* %954, i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.46, i64 0, i64 0))
br label %965
956: ; preds = %948, %948
%957 = load i8*, i8** %9
%958 = call i32 @strcat(i8* %957, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.47, i64 0, i64 0))
br label %965
959: ; preds = %948
%960 = load i8*, i8** %9
%961 = call i32 @strcat(i8* %960, i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.48, i64 0, i64 0))
br label %965
962: ; preds = %948
%963 = load i8*, i8** %9
%964 = call i32 @strcat(i8* %963, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.49, i64 0, i64 0))
br label %965
965: ; preds = %948, %962, %959, %956, %953, %950
%966 = load i8*, i8** %9
%967 = call i32 @strlen(i8* %966)
%968 = srem i32 %967, 7
%969 = sub nsw i32 7, %968
store i32 %969, i32* %21
%970 = load i32, i32* %21
%971 = icmp eq i32 %970, 7
br i1 %971, label %972, label %973
972: ; preds = %965
store i32 0, i32* %21
br label %973
973: ; preds = %972, %965
store i32 0, i32* %30
br label %974
974: ; preds = %981, %973
%975 = load i32, i32* %30
%976 = load i32, i32* %21
%977 = icmp slt i32 %975, %976
br i1 %977, label %978, label %984
978: ; preds = %974
%979 = load i8*, i8** %9
%980 = call i32 @strcat(i8* %979, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0))
br label %981
981: ; preds = %978
%982 = load i32, i32* %30
%983 = add nsw i32 %982, 1
store i32 %983, i32* %30
br label %974
984: ; preds = %974
%985 = load i8*, i8** %9
%986 = call i32 @strlen(i8* %985)
%987 = icmp sgt i32 %986, 9191
br i1 %987, label %988, label %989
988: ; preds = %984
store i32 5, i32* %6
br label %990
989: ; preds = %984
store i32 0, i32* %6
br label %990
990: ; preds = %989, %988, %904
%991 = load i32, i32* %6
ret i32 %991
}

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