char *backslash_eliminate(str, type, who)
char *str;
int type;
int who;
{
  char *new_str;
  int extra = 100;
  int seenlb = 0;
  register int i = 0;
  register int seenbs = 0;
  int first_half = 0;
  if (type == 1) {
    if (!(new_str = mem(who, strlen(str) + 1 + extra))) {
      return 0;
    }
  } else {
    new_str = str;
  }
  while (*str) {
    if (seenbs) {
      seenbs = 0;
      switch (*str) {
      case '\\': {
        new_str[i++] = '\\';
        str++;
        break;
      }
      case '-': {
        if (seenlb) {
          new_str[i++] = '\\';
        }
        new_str[i++] = '-';
        str++;
        break;
      }
      case '}': {
        if (seenlb) {
          new_str[i++] = '\\';
        }
        new_str[i++] = '}';
        str++;
        break;
      }
      case 'n': {
        new_str[i++] = '\n';
        str++;
        break;
      }
      case 't': {
        new_str[i++] = '\t';
        str++;
        break;
      }
      case 's': {
        new_str[i++] = ' ';
        str++;
        break;
      }
      case 'r': {
        new_str[i++] = '\r';
        str++;
        break;
      }
      case 'f': {
        new_str[i++] = '\f';
        str++;
        break;
      }
      case 'b': {
        new_str[i++] = '\b';
        str++;
        break;
      }
      case 'v': {
        new_str[i++] = '\13';
        str++;
        break;
      }
      case 'z': {
        str++;
        break;
      }
      case '0':
      case '1':
      case '2':
      case '3':
      case '4':
      case '5':
      case '6':
      case '7':
      case '8':
      case '9': {
        char val;
        if (*str >= '0' && *str <= '3' && *(str + 1) >= '0' &&
            *(str + 1) <= '7' && *(str + 2) >= '0' && *(str + 2) <= '7') {
          val = ((isdigit(*str)   ? (*str) - '0'
                  : islower(*str) ? (*str) + 10 - 'a'
                                  : (*str) + 10 - 'A')
                 << 6) +
                ((isdigit(*(str + 1))   ? (*(str + 1)) - '0'
                  : islower(*(str + 1)) ? (*(str + 1)) + 10 - 'a'
                                        : (*(str + 1)) + 10 - 'A')
                 << 3) +
                (isdigit(*(str + 2))   ? (*(str + 2)) - '0'
                 : islower(*(str + 2)) ? (*(str + 2)) + 10 - 'a'
                                       : (*(str + 2)) + 10 - 'A');
          if (!val) {
            return 0;
          }
          new_str[i++] = val;
          str += 3;
          break;
        }
        if (*str == '0' && (*(str + 1) == 'x' || *(str + 1) == 'X') &&
            isxdigit(*(str + 2))) {
          val = (isdigit(*(str + 2))   ? (*(str + 2)) - '0'
                 : islower(*(str + 2)) ? (*(str + 2)) + 10 - 'a'
                                       : (*(str + 2)) + 10 - 'A');
          if (isxdigit(*(str + 3))) {
            val =
                (val << 4) + (isdigit(*(str + 3))   ? (*(str + 3)) - '0'
                              : islower(*(str + 3)) ? (*(str + 3)) + 10 - 'a'
                                                    : (*(str + 3)) + 10 - 'A');
            str += 4;
          } else {
            str += 3;
          }
          if (!val) {
            return 0;
          }
          new_str[i++] = val;
          break;
        }
        if (isdigit(*(str + 1))) {
          val = (isdigit(*str)   ? (*str) - '0'
                 : islower(*str) ? (*str) + 10 - 'a'
                                 : (*str) + 10 - 'A') *
                    10 +
                (isdigit(*(str + 1))   ? (*(str + 1)) - '0'
                 : islower(*(str + 1)) ? (*(str + 1)) + 10 - 'a'
                                       : (*(str + 1)) + 10 - 'A');
          if (isdigit(*(str + 2))) {
            val = 10 * val + (isdigit(*(str + 2))   ? (*(str + 2)) - '0'
                              : islower(*(str + 2)) ? (*(str + 2)) + 10 - 'a'
                                                    : (*(str + 2)) + 10 - 'A');
            str += 3;
          } else {
            str += 2;
          }
          if (!val) {
            return 0;
          }
          new_str[i++] = val;
          break;
        }
        if (*str == '0' && type == 0) {
          return 0;
        }
        if (type == 2) {
          if (!(val = (isdigit(*str)   ? (*str) - '0'
                       : islower(*str) ? (*str) + 10 - 'a'
                                       : (*str) + 10 - 'A'))) {
            return 0;
          }
          new_str[i++] = val;
          str++;
        } else {
          new_str[i++] = '\\';
          new_str[i++] = *str++;
        }
        break;
      }
      default: {
        if (type == 0) {
          new_str[i++] = '\\';
        }
        new_str[i++] = *str++;
        break;
      }
      }
    } else {
      if (*str == '\\') {
        seenbs = 1;
        str++;
      } else if (type == 1 && *str == '}') {
        if (*(str + 1) == '{' && first_half) {
          new_str[i++] = *str++;
          new_str[i++] = *str++;
          first_half = 0;
        } else {
          seenlb = 0;
          new_str[i++] = *str++;
        }
      } else if (type == 1 && !seenlb && *str == '{') {
        seenlb = 1;
        first_half = 1;
        if (i < 2 || new_str[i - 2] != '\\' ||
            !(new_str[i - 1] >= '0' && new_str[i - 1] <= '9')) {
          if ((extra -= 2) < 0) {
            return 0;
          }
          new_str[i++] = '\\';
          new_str[i++] = '0';
        }
        new_str[i++] = *str++;
      } else {
        new_str[i++] = *str++;
      }
    }
  }
  if (seenbs) {
    new_str[i++] = '\\';
  }
  new_str[i] = '\0';
  return new_str;
}


x86 assembly (clang, -O0):
<backslash_eliminate>:
push   %rbp
mov    %rsp,%rbp
sub    $0xb0,%rsp
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    %edx,-0x18(%rbp)
movl   $0x64,-0x24(%rbp)
movl   $0x0,-0x28(%rbp)
movl   $0x0,-0x2c(%rbp)
movl   $0x0,-0x30(%rbp)
movl   $0x0,-0x34(%rbp)
cmpl   $0x1,-0x14(%rbp)
jne    11db <backslash_eliminate+0x8b>
mov    -0x18(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x10(%rbp),%rdi
call   1050 <strlen@plt>
mov    -0x3c(%rbp),%edi
mov    %rax,%rsi
add    $0x1,%rsi
movslq -0x24(%rbp),%rax
add    %rax,%rsi
mov    $0x0,%al
call   1060 <mem@plt>
cltq
mov    %rax,-0x20(%rbp)
cmp    $0x0,%rax
jne    11d6 <backslash_eliminate+0x86>
movq   $0x0,-0x8(%rbp)
jmp    1d9e <backslash_eliminate+0xc4e>
jmp    11e3 <backslash_eliminate+0x93>
mov    -0x10(%rbp),%rax
mov    %rax,-0x20(%rbp)
jmp    11e8 <backslash_eliminate+0x98>
mov    -0x10(%rbp),%rax
cmpb   $0x0,(%rax)
je     1d6a <backslash_eliminate+0xc1a>
cmpl   $0x0,-0x30(%rbp)
je     1b49 <backslash_eliminate+0x9f9>
movl   $0x0,-0x30(%rbp)
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
add    $0xffffffd3,%eax
mov    %eax,%ecx
mov    %rcx,-0x48(%rbp)
sub    $0x50,%eax
ja     1afe <backslash_eliminate+0x9ae>
mov    -0x48(%rbp),%rax
lea    0xdd6(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x2c(%rbp)
movslq %ecx,%rcx
movb   $0x5c,(%rax,%rcx,1)
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    1b44 <backslash_eliminate+0x9f4>
cmpl   $0x0,-0x28(%rbp)
je     127a <backslash_eliminate+0x12a>
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x2c(%rbp)
movslq %ecx,%rcx
movb   $0x5c,(%rax,%rcx,1)
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x2c(%rbp)
movslq %ecx,%rcx
movb   $0x2d,(%rax,%rcx,1)
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    1b44 <backslash_eliminate+0x9f4>
cmpl   $0x0,-0x28(%rbp)
je     12c1 <backslash_eliminate+0x171>
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x2c(%rbp)
movslq %ecx,%rcx
movb   $0x5c,(%rax,%rcx,1)
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x2c(%rbp)
movslq %ecx,%rcx
movb   $0x7d,(%rax,%rcx,1)
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    1b44 <backslash_eliminate+0x9f4>
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x2c(%rbp)
movslq %ecx,%rcx
movb   $0xa,(%rax,%rcx,1)
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    1b44 <backslash_eliminate+0x9f4>
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x2c(%rbp)
movslq %ecx,%rcx
movb   $0x9,(%rax,%rcx,1)
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    1b44 <backslash_eliminate+0x9f4>
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x2c(%rbp)
movslq %ecx,%rcx
movb   $0x20,(%rax,%rcx,1)
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    1b44 <backslash_eliminate+0x9f4>
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x2c(%rbp)
movslq %ecx,%rcx
movb   $0xd,(%rax,%rcx,1)
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    1b44 <backslash_eliminate+0x9f4>
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x2c(%rbp)
movslq %ecx,%rcx
movb   $0xc,(%rax,%rcx,1)
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    1b44 <backslash_eliminate+0x9f4>
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x2c(%rbp)
movslq %ecx,%rcx
movb   $0x8,(%rax,%rcx,1)
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    1b44 <backslash_eliminate+0x9f4>
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x2c(%rbp)
movslq %ecx,%rcx
movb   $0xb,(%rax,%rcx,1)
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    1b44 <backslash_eliminate+0x9f4>
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    1b44 <backslash_eliminate+0x9f4>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x30,%eax
jl     160f <backslash_eliminate+0x4bf>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x33,%eax
jg     160f <backslash_eliminate+0x4bf>
mov    -0x10(%rbp),%rax
movsbl 0x1(%rax),%eax
cmp    $0x30,%eax
jl     160f <backslash_eliminate+0x4bf>
mov    -0x10(%rbp),%rax
movsbl 0x1(%rax),%eax
cmp    $0x37,%eax
jg     160f <backslash_eliminate+0x4bf>
mov    -0x10(%rbp),%rax
movsbl 0x2(%rax),%eax
cmp    $0x30,%eax
jl     160f <backslash_eliminate+0x4bf>
mov    -0x10(%rbp),%rax
movsbl 0x2(%rax),%eax
cmp    $0x37,%eax
jg     160f <backslash_eliminate+0x4bf>
mov    -0x10(%rbp),%rax
movsbl (%rax),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%eax
je     1495 <backslash_eliminate+0x345>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
sub    $0x30,%eax
mov    %eax,-0x4c(%rbp)
jmp    14d5 <backslash_eliminate+0x385>
mov    -0x10(%rbp),%rax
movsbl (%rax),%edi
call   1040 <islower@plt>
cmp    $0x0,%eax
je     14bf <backslash_eliminate+0x36f>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
add    $0xa,%eax
sub    $0x61,%eax
mov    %eax,-0x50(%rbp)
jmp    14cf <backslash_eliminate+0x37f>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
add    $0xa,%eax
sub    $0x41,%eax
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
shl    $0x6,%eax
mov    %eax,-0x54(%rbp)
mov    -0x10(%rbp),%rax
movsbl 0x1(%rax),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%eax
je     1507 <backslash_eliminate+0x3b7>
mov    -0x10(%rbp),%rax
movsbl 0x1(%rax),%eax
sub    $0x30,%eax
mov    %eax,-0x58(%rbp)
jmp    154a <backslash_eliminate+0x3fa>
mov    -0x10(%rbp),%rax
movsbl 0x1(%rax),%edi
call   1040 <islower@plt>
cmp    $0x0,%eax
je     1533 <backslash_eliminate+0x3e3>
mov    -0x10(%rbp),%rax
movsbl 0x1(%rax),%eax
add    $0xa,%eax
sub    $0x61,%eax
mov    %eax,-0x5c(%rbp)
jmp    1544 <backslash_eliminate+0x3f4>
mov    -0x10(%rbp),%rax
movsbl 0x1(%rax),%eax
add    $0xa,%eax
sub    $0x41,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x54(%rbp),%eax
mov    -0x58(%rbp),%ecx
shl    $0x3,%ecx
add    %ecx,%eax
mov    %eax,-0x60(%rbp)
mov    -0x10(%rbp),%rax
movsbl 0x2(%rax),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%eax
je     1581 <backslash_eliminate+0x431>
mov    -0x10(%rbp),%rax
movsbl 0x2(%rax),%eax
sub    $0x30,%eax
mov    %eax,-0x64(%rbp)
jmp    15c4 <backslash_eliminate+0x474>
mov    -0x10(%rbp),%rax
movsbl 0x2(%rax),%edi
call   1040 <islower@plt>
cmp    $0x0,%eax
je     15ad <backslash_eliminate+0x45d>
mov    -0x10(%rbp),%rax
movsbl 0x2(%rax),%eax
add    $0xa,%eax
sub    $0x61,%eax
mov    %eax,-0x68(%rbp)
jmp    15be <backslash_eliminate+0x46e>
mov    -0x10(%rbp),%rax
movsbl 0x2(%rax),%eax
add    $0xa,%eax
sub    $0x41,%eax
mov    %eax,-0x68(%rbp)
mov    -0x68(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x60(%rbp),%eax
mov    -0x64(%rbp),%ecx
add    %ecx,%eax
mov    %al,-0x35(%rbp)
cmpb   $0x0,-0x35(%rbp)
jne    15e6 <backslash_eliminate+0x496>
movq   $0x0,-0x8(%rbp)
jmp    1d9e <backslash_eliminate+0xc4e>
mov    -0x35(%rbp),%dl
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x2c(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x10(%rbp),%rax
add    $0x3,%rax
mov    %rax,-0x10(%rbp)
jmp    1b44 <backslash_eliminate+0x9f4>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x30,%eax
jne    17b1 <backslash_eliminate+0x661>
mov    -0x10(%rbp),%rax
movsbl 0x1(%rax),%eax
cmp    $0x78,%eax
je     1641 <backslash_eliminate+0x4f1>
mov    -0x10(%rbp),%rax
movsbl 0x1(%rax),%eax
cmp    $0x58,%eax
jne    17b1 <backslash_eliminate+0x661>
mov    -0x10(%rbp),%rax
movsbl 0x2(%rax),%edi
call   1070 <isxdigit@plt>
cmp    $0x0,%eax
je     17b1 <backslash_eliminate+0x661>
mov    -0x10(%rbp),%rax
movsbl 0x2(%rax),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%eax
je     1680 <backslash_eliminate+0x530>
mov    -0x10(%rbp),%rax
movsbl 0x2(%rax),%eax
sub    $0x30,%eax
mov    %eax,-0x6c(%rbp)
jmp    16c3 <backslash_eliminate+0x573>
mov    -0x10(%rbp),%rax
movsbl 0x2(%rax),%edi
call   1040 <islower@plt>
cmp    $0x0,%eax
je     16ac <backslash_eliminate+0x55c>
mov    -0x10(%rbp),%rax
movsbl 0x2(%rax),%eax
add    $0xa,%eax
sub    $0x61,%eax
mov    %eax,-0x70(%rbp)
jmp    16bd <backslash_eliminate+0x56d>
mov    -0x10(%rbp),%rax
movsbl 0x2(%rax),%eax
add    $0xa,%eax
sub    $0x41,%eax
mov    %eax,-0x70(%rbp)
mov    -0x70(%rbp),%eax
mov    %eax,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
mov    %al,-0x35(%rbp)
mov    -0x10(%rbp),%rax
movsbl 0x3(%rax),%edi
call   1070 <isxdigit@plt>
cmp    $0x0,%eax
je     1771 <backslash_eliminate+0x621>
movsbl -0x35(%rbp),%eax
shl    $0x4,%eax
mov    %eax,-0x74(%rbp)
mov    -0x10(%rbp),%rax
movsbl 0x3(%rax),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%eax
je     1712 <backslash_eliminate+0x5c2>
mov    -0x10(%rbp),%rax
movsbl 0x3(%rax),%eax
sub    $0x30,%eax
mov    %eax,-0x78(%rbp)
jmp    1755 <backslash_eliminate+0x605>
mov    -0x10(%rbp),%rax
movsbl 0x3(%rax),%edi
call   1040 <islower@plt>
cmp    $0x0,%eax
je     173e <backslash_eliminate+0x5ee>
mov    -0x10(%rbp),%rax
movsbl 0x3(%rax),%eax
add    $0xa,%eax
sub    $0x61,%eax
mov    %eax,-0x7c(%rbp)
jmp    174f <backslash_eliminate+0x5ff>
mov    -0x10(%rbp),%rax
movsbl 0x3(%rax),%eax
add    $0xa,%eax
sub    $0x41,%eax
mov    %eax,-0x7c(%rbp)
mov    -0x7c(%rbp),%eax
mov    %eax,-0x78(%rbp)
mov    -0x74(%rbp),%eax
mov    -0x78(%rbp),%ecx
add    %ecx,%eax
mov    %al,-0x35(%rbp)
mov    -0x10(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x10(%rbp)
jmp    177d <backslash_eliminate+0x62d>
mov    -0x10(%rbp),%rax
add    $0x3,%rax
mov    %rax,-0x10(%rbp)
cmpb   $0x0,-0x35(%rbp)
jne    1794 <backslash_eliminate+0x644>
movq   $0x0,-0x8(%rbp)
jmp    1d9e <backslash_eliminate+0xc4e>
mov    -0x35(%rbp),%dl
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x2c(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
jmp    1b44 <backslash_eliminate+0x9f4>
mov    -0x10(%rbp),%rax
movsbl 0x1(%rax),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%eax
je     19cf <backslash_eliminate+0x87f>
mov    -0x10(%rbp),%rax
movsbl (%rax),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%eax
je     17ee <backslash_eliminate+0x69e>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
sub    $0x30,%eax
mov    %eax,-0x80(%rbp)
jmp    1837 <backslash_eliminate+0x6e7>
mov    -0x10(%rbp),%rax
movsbl (%rax),%edi
call   1040 <islower@plt>
cmp    $0x0,%eax
je     181b <backslash_eliminate+0x6cb>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
add    $0xa,%eax
sub    $0x61,%eax
mov    %eax,-0x84(%rbp)
jmp    182e <backslash_eliminate+0x6de>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
add    $0xa,%eax
sub    $0x41,%eax
mov    %eax,-0x84(%rbp)
mov    -0x84(%rbp),%eax
mov    %eax,-0x80(%rbp)
mov    -0x80(%rbp),%eax
imul   $0xa,%eax,%eax
mov    %eax,-0x88(%rbp)
mov    -0x10(%rbp),%rax
movsbl 0x1(%rax),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%eax
je     186f <backslash_eliminate+0x71f>
mov    -0x10(%rbp),%rax
movsbl 0x1(%rax),%eax
sub    $0x30,%eax
mov    %eax,-0x8c(%rbp)
jmp    18be <backslash_eliminate+0x76e>
mov    -0x10(%rbp),%rax
movsbl 0x1(%rax),%edi
call   1040 <islower@plt>
cmp    $0x0,%eax
je     189e <backslash_eliminate+0x74e>
mov    -0x10(%rbp),%rax
movsbl 0x1(%rax),%eax
add    $0xa,%eax
sub    $0x61,%eax
mov    %eax,-0x90(%rbp)
jmp    18b2 <backslash_eliminate+0x762>
mov    -0x10(%rbp),%rax
movsbl 0x1(%rax),%eax
add    $0xa,%eax
sub    $0x41,%eax
mov    %eax,-0x90(%rbp)
mov    -0x90(%rbp),%eax
mov    %eax,-0x8c(%rbp)
mov    -0x88(%rbp),%eax
mov    -0x8c(%rbp),%ecx
add    %ecx,%eax
mov    %al,-0x35(%rbp)
mov    -0x10(%rbp),%rax
movsbl 0x2(%rax),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%eax
je     198f <backslash_eliminate+0x83f>
movsbl -0x35(%rbp),%eax
imul   $0xa,%eax,%eax
mov    %eax,-0x94(%rbp)
mov    -0x10(%rbp),%rax
movsbl 0x2(%rax),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%eax
je     191e <backslash_eliminate+0x7ce>
mov    -0x10(%rbp),%rax
movsbl 0x2(%rax),%eax
sub    $0x30,%eax
mov    %eax,-0x98(%rbp)
jmp    196d <backslash_eliminate+0x81d>
mov    -0x10(%rbp),%rax
movsbl 0x2(%rax),%edi
call   1040 <islower@plt>
cmp    $0x0,%eax
je     194d <backslash_eliminate+0x7fd>
mov    -0x10(%rbp),%rax
movsbl 0x2(%rax),%eax
add    $0xa,%eax
sub    $0x61,%eax
mov    %eax,-0x9c(%rbp)
jmp    1961 <backslash_eliminate+0x811>
mov    -0x10(%rbp),%rax
movsbl 0x2(%rax),%eax
add    $0xa,%eax
sub    $0x41,%eax
mov    %eax,-0x9c(%rbp)
mov    -0x9c(%rbp),%eax
mov    %eax,-0x98(%rbp)
mov    -0x94(%rbp),%eax
mov    -0x98(%rbp),%ecx
add    %ecx,%eax
mov    %al,-0x35(%rbp)
mov    -0x10(%rbp),%rax
add    $0x3,%rax
mov    %rax,-0x10(%rbp)
jmp    199b <backslash_eliminate+0x84b>
mov    -0x10(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x10(%rbp)
cmpb   $0x0,-0x35(%rbp)
jne    19b2 <backslash_eliminate+0x862>
movq   $0x0,-0x8(%rbp)
jmp    1d9e <backslash_eliminate+0xc4e>
mov    -0x35(%rbp),%dl
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x2c(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
jmp    1b44 <backslash_eliminate+0x9f4>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x30,%eax
jne    19f6 <backslash_eliminate+0x8a6>
cmpl   $0x0,-0x14(%rbp)
jne    19f6 <backslash_eliminate+0x8a6>
movq   $0x0,-0x8(%rbp)
jmp    1d9e <backslash_eliminate+0xc4e>
cmpl   $0x2,-0x14(%rbp)
jne    1abd <backslash_eliminate+0x96d>
mov    -0x10(%rbp),%rax
movsbl (%rax),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%eax
je     1a2a <backslash_eliminate+0x8da>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
sub    $0x30,%eax
mov    %eax,-0xa0(%rbp)
jmp    1a76 <backslash_eliminate+0x926>
mov    -0x10(%rbp),%rax
movsbl (%rax),%edi
call   1040 <islower@plt>
cmp    $0x0,%eax
je     1a57 <backslash_eliminate+0x907>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
add    $0xa,%eax
sub    $0x61,%eax
mov    %eax,-0xa4(%rbp)
jmp    1a6a <backslash_eliminate+0x91a>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
add    $0xa,%eax
sub    $0x41,%eax
mov    %eax,-0xa4(%rbp)
mov    -0xa4(%rbp),%eax
mov    %eax,-0xa0(%rbp)
mov    -0xa0(%rbp),%eax
mov    %al,-0x35(%rbp)
cmp    $0x0,%al
jne    1a94 <backslash_eliminate+0x944>
movq   $0x0,-0x8(%rbp)
jmp    1d9e <backslash_eliminate+0xc4e>
mov    -0x35(%rbp),%dl
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x2c(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    1af9 <backslash_eliminate+0x9a9>
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x2c(%rbp)
movslq %ecx,%rcx
movb   $0x5c,(%rax,%rcx,1)
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
mov    (%rax),%dl
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x2c(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
jmp    1b44 <backslash_eliminate+0x9f4>
cmpl   $0x0,-0x14(%rbp)
jne    1b1e <backslash_eliminate+0x9ce>
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x2c(%rbp)
movslq %ecx,%rcx
movb   $0x5c,(%rax,%rcx,1)
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
mov    (%rax),%dl
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x2c(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
jmp    1d65 <backslash_eliminate+0xc15>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x5c,%eax
jne    1b71 <backslash_eliminate+0xa21>
movl   $0x1,-0x30(%rbp)
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    1d60 <backslash_eliminate+0xc10>
cmpl   $0x1,-0x14(%rbp)
jne    1c30 <backslash_eliminate+0xae0>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x7d,%eax
jne    1c30 <backslash_eliminate+0xae0>
mov    -0x10(%rbp),%rax
movsbl 0x1(%rax),%eax
cmp    $0x7b,%eax
jne    1bfe <backslash_eliminate+0xaae>
cmpl   $0x0,-0x34(%rbp)
je     1bfe <backslash_eliminate+0xaae>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
mov    (%rax),%dl
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x2c(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
mov    (%rax),%dl
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x2c(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
movl   $0x0,-0x34(%rbp)
jmp    1c2b <backslash_eliminate+0xadb>
movl   $0x0,-0x28(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
mov    (%rax),%dl
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x2c(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
jmp    1d5b <backslash_eliminate+0xc0b>
cmpl   $0x1,-0x14(%rbp)
jne    1d30 <backslash_eliminate+0xbe0>
cmpl   $0x0,-0x28(%rbp)
jne    1d30 <backslash_eliminate+0xbe0>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x7b,%eax
jne    1d30 <backslash_eliminate+0xbe0>
movl   $0x1,-0x28(%rbp)
movl   $0x1,-0x34(%rbp)
cmpl   $0x2,-0x2c(%rbp)
jl     1cba <backslash_eliminate+0xb6a>
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x5c,%eax
jne    1cba <backslash_eliminate+0xb6a>
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x30,%eax
jl     1cba <backslash_eliminate+0xb6a>
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x39,%eax
jle    1d05 <backslash_eliminate+0xbb5>
mov    -0x24(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x24(%rbp)
cmp    $0x0,%eax
jge    1cd9 <backslash_eliminate+0xb89>
movq   $0x0,-0x8(%rbp)
jmp    1d9e <backslash_eliminate+0xc4e>
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x2c(%rbp)
movslq %ecx,%rcx
movb   $0x5c,(%rax,%rcx,1)
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x2c(%rbp)
movslq %ecx,%rcx
movb   $0x30,(%rax,%rcx,1)
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
mov    (%rax),%dl
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x2c(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
jmp    1d56 <backslash_eliminate+0xc06>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
mov    (%rax),%dl
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x2c(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
jmp    1d5b <backslash_eliminate+0xc0b>
jmp    1d60 <backslash_eliminate+0xc10>
jmp    1d65 <backslash_eliminate+0xc15>
jmp    11e8 <backslash_eliminate+0x98>
cmpl   $0x0,-0x30(%rbp)
je     1d8a <backslash_eliminate+0xc3a>
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x2c(%rbp)
movslq %ecx,%rcx
movb   $0x5c,(%rax,%rcx,1)
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x20(%rbp),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0xb0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<backslash_eliminate>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    %rdi,%r15
mov    %rdi,%r9
cmp    $0x1,%esi
jne    117f <backslash_eliminate+0x3f>
mov    %edx,%ebp
mov    %esi,%ebx
mov    %r15,%rdi
call   1040 <strlen@plt>
lea    0x65(%rax),%rsi
mov    %ebp,%edi
xor    %eax,%eax
call   1050 <mem@plt>
test   %eax,%eax
je     162b <backslash_eliminate+0x4eb>
movslq %eax,%r9
mov    %ebx,%esi
mov    (%r15),%bl
test   %bl,%bl
je     1630 <backslash_eliminate+0x4f0>
mov    $0x64,%r8d
lea    0xe69(%rip),%rdi
xor    %r11d,%r11d
xor    %eax,%eax
xor    %r14d,%r14d
xor    %r10d,%r10d
jmp    11d5 <backslash_eliminate+0x95>
test   %esi,%esi
je     15c1 <backslash_eliminate+0x481>
add    $0x1,%r15
movslq %r14d,%rax
add    $0x1,%r14d
mov    %bl,(%r9,%rax,1)
nopl   0x0(%rax,%rax,1)
xor    %eax,%eax
mov    $0x1,%dl
mov    %r15,%rcx
movzbl (%rcx),%ebx
mov    %rcx,%r15
test   %bl,%bl
je     1619 <backslash_eliminate+0x4d9>
test   %eax,%eax
je     1250 <backslash_eliminate+0x110>
movsbl %bl,%eax
add    $0xffffffd3,%eax
cmp    $0x50,%eax
ja     11a4 <backslash_eliminate+0x64>
movslq (%rdi,%rax,4),%rax
add    %rdi,%rax
jmp    *%rax
mov    %ebx,%eax
and    $0xfc,%al
movsbl 0x1(%r15),%ebp
cmp    $0x30,%al
jne    1387 <backslash_eliminate+0x247>
mov    %ebp,%eax
and    $0xf8,%al
cmp    $0x30,%al
jne    12bd <backslash_eliminate+0x17d>
movzbl 0x2(%r15),%eax
mov    %eax,%ecx
and    $0xf8,%cl
cmp    $0x30,%cl
jne    12bd <backslash_eliminate+0x17d>
shl    $0x6,%bl
shl    $0x3,%bpl
xor    $0x80,%bpl
add    %bl,%bpl
add    %al,%bpl
add    $0xd0,%bpl
je     162b <backslash_eliminate+0x4eb>
movslq %r14d,%rax
add    $0x1,%r14d
mov    %bpl,(%r9,%rax,1)
add    $0x3,%r15
jmp    11c0 <backslash_eliminate+0x80>
nopl   0x0(%rax)
cmp    $0x5c,%bl
jne    1265 <backslash_eliminate+0x125>
add    $0x1,%r15
mov    $0x1,%eax
xor    %edx,%edx
jmp    11c4 <backslash_eliminate+0x84>
cmp    $0x1,%esi
jne    140b <backslash_eliminate+0x2cb>
cmp    $0x7d,%bl
jne    140b <backslash_eliminate+0x2cb>
lea    0x1(%r15),%rcx
movslq %r14d,%rdx
lea    0x1(%rdx),%rbp
xor    %eax,%eax
cmpb   $0x7b,0x1(%r15)
movb   $0x7d,(%r9,%rdx,1)
mov    $0x1,%dl
jne    14c2 <backslash_eliminate+0x382>
test   %r11d,%r11d
je     14c2 <backslash_eliminate+0x382>
movzbl 0x1(%r15),%eax
add    $0x2,%r15
add    $0x2,%r14d
mov    %al,(%r9,%rbp,1)
xor    %eax,%eax
mov    %r15,%rcx
xor    %r11d,%r11d
jmp    11c7 <backslash_eliminate+0x87>
cmp    $0x30,%bl
jne    1387 <backslash_eliminate+0x247>
mov    $0x1,%r12b
mov    %ebp,%eax
or     $0x20,%al
cmp    $0x78,%al
jne    138a <backslash_eliminate+0x24a>
movsbl 0x2(%r15),%r13d
mov    %r9,0x10(%rsp)
mov    %r13d,%edi
mov    %esi,0xc(%rsp)
mov    %r8d,0x8(%rsp)
mov    %r10d,0x4(%rsp)
mov    %r11d,(%rsp)
call   1060 <isxdigit@plt>
mov    (%rsp),%r11d
mov    0x4(%rsp),%r10d
lea    0xcf7(%rip),%rdi
mov    0x8(%rsp),%r8d
mov    0xc(%rsp),%esi
mov    0x10(%rsp),%r9
test   %eax,%eax
je     138a <backslash_eliminate+0x24a>
lea    -0x30(%r13),%ecx
mov    $0xd0,%al
cmp    $0xa,%ecx
jb     1338 <backslash_eliminate+0x1f8>
mov    %r13d,%edi
call   1030 <islower@plt>
test   %eax,%eax
sete   %al
shl    $0x5,%al
add    $0xa9,%al
add    %al,%r13b
movsbl 0x3(%r15),%r12d
mov    %r12d,%edi
call   1060 <isxdigit@plt>
test   %eax,%eax
je     15d6 <backslash_eliminate+0x496>
shl    $0x4,%r13b
lea    -0x30(%r12),%ecx
mov    $0xd0,%al
cmp    $0xa,%ecx
jb     1372 <backslash_eliminate+0x232>
mov    %r12d,%edi
call   1030 <islower@plt>
test   %eax,%eax
sete   %al
shl    $0x5,%al
add    $0xa9,%al
add    %al,%r12b
add    %r13b,%r12b
add    $0x4,%r15
mov    %r15,%rcx
mov    %r12d,%r13d
jmp    15dd <backslash_eliminate+0x49d>
xor    %r12d,%r12d
lea    -0x30(%rbp),%eax
cmp    $0x9,%eax
ja     13d7 <backslash_eliminate+0x297>
movzbl %bl,%eax
add    %eax,%eax
lea    (%rax,%rax,4),%eax
add    %bpl,%al
add    $0xf0,%al
movsbl 0x2(%r15),%ecx
movzbl %al,%edx
lea    (%rdx,%rdx,1),%eax
lea    (%rax,%rax,4),%eax
add    %cl,%al
add    $0xffffffd0,%ecx
add    $0xd0,%al
cmp    $0xa,%ecx
movzbl %al,%eax
cmovae %edx,%eax
test   %al,%al
je     162b <backslash_eliminate+0x4eb>
cmp    $0xa,%ecx
jb     1491 <backslash_eliminate+0x351>
add    $0x2,%r15
jmp    1495 <backslash_eliminate+0x355>
test   %esi,%esi
sete   %al
test   %r12b,%al
jne    162b <backslash_eliminate+0x4eb>
lea    0x1(%r15),%rcx
cmp    $0x2,%esi
jne    14a8 <backslash_eliminate+0x368>
add    $0xd0,%bl
je     162b <backslash_eliminate+0x4eb>
movslq %r14d,%rax
add    $0x1,%r14d
mov    %bl,(%r9,%rax,1)
jmp    1610 <backslash_eliminate+0x4d0>
cmp    $0x1,%esi
jne    11ac <backslash_eliminate+0x6c>
test   %r10d,%r10d
jne    11ac <backslash_eliminate+0x6c>
cmp    $0x7b,%bl
jne    11ac <backslash_eliminate+0x6c>
cmp    $0x2,%r14d
jl     144a <backslash_eliminate+0x30a>
lea    -0x2(%r14),%eax
cmpb   $0x5c,(%r9,%rax,1)
jne    144a <backslash_eliminate+0x30a>
lea    -0x1(%r14),%eax
movzbl (%r9,%rax,1),%ecx
add    $0xd0,%cl
mov    $0x7b,%al
cmp    $0xa,%cl
jb     146a <backslash_eliminate+0x32a>
cmp    $0x2,%r8d
jl     162b <backslash_eliminate+0x4eb>
add    $0xfffffffe,%r8d
movslq %r14d,%rax
movw   $0x305c,(%r9,%rax,1)
add    $0x2,%r14d
movzbl (%r15),%eax
add    $0x1,%r15
movslq %r14d,%rcx
add    $0x1,%r14d
mov    %al,(%r9,%rcx,1)
xor    %eax,%eax
mov    $0x1,%dl
mov    $0x1,%r10d
mov    %r15,%rcx
mov    $0x1,%r11d
jmp    11c7 <backslash_eliminate+0x87>
add    $0x3,%r15
mov    %r15,%rcx
movslq %r14d,%rdx
add    $0x1,%r14d
mov    %al,(%r9,%rdx,1)
jmp    1610 <backslash_eliminate+0x4d0>
movslq %r14d,%rax
movb   $0x5c,(%r9,%rax,1)
movzbl (%r15),%edx
add    $0x2,%r14d
mov    %dl,0x1(%r9,%rax,1)
jmp    1610 <backslash_eliminate+0x4d0>
xor    %r10d,%r10d
mov    %ebp,%r14d
jmp    11c7 <backslash_eliminate+0x87>
test   %r10d,%r10d
je     14de <backslash_eliminate+0x39e>
movslq %r14d,%rax
add    $0x1,%r14d
movb   $0x5c,(%r9,%rax,1)
movslq %r14d,%rax
add    $0x1,%r14d
movb   $0x2d,(%r9,%rax,1)
add    $0x1,%r15
jmp    11c0 <backslash_eliminate+0x80>
movslq %r14d,%rax
add    $0x1,%r14d
movb   $0x5c,(%r9,%rax,1)
add    $0x1,%r15
jmp    11c0 <backslash_eliminate+0x80>
movslq %r14d,%rax
add    $0x1,%r14d
movb   $0x8,(%r9,%rax,1)
add    $0x1,%r15
jmp    11c0 <backslash_eliminate+0x80>
movslq %r14d,%rax
add    $0x1,%r14d
movb   $0xc,(%r9,%rax,1)
add    $0x1,%r15
jmp    11c0 <backslash_eliminate+0x80>
movslq %r14d,%rax
add    $0x1,%r14d
movb   $0xa,(%r9,%rax,1)
add    $0x1,%r15
jmp    11c0 <backslash_eliminate+0x80>
movslq %r14d,%rax
add    $0x1,%r14d
movb   $0xd,(%r9,%rax,1)
add    $0x1,%r15
jmp    11c0 <backslash_eliminate+0x80>
movslq %r14d,%rax
add    $0x1,%r14d
movb   $0x20,(%r9,%rax,1)
add    $0x1,%r15
jmp    11c0 <backslash_eliminate+0x80>
movslq %r14d,%rax
add    $0x1,%r14d
movb   $0x9,(%r9,%rax,1)
add    $0x1,%r15
jmp    11c0 <backslash_eliminate+0x80>
movslq %r14d,%rax
add    $0x1,%r14d
movb   $0xb,(%r9,%rax,1)
add    $0x1,%r15
jmp    11c0 <backslash_eliminate+0x80>
test   %r10d,%r10d
je     15ac <backslash_eliminate+0x46c>
movslq %r14d,%rax
add    $0x1,%r14d
movb   $0x5c,(%r9,%rax,1)
movslq %r14d,%rax
add    $0x1,%r14d
movb   $0x7d,(%r9,%rax,1)
add    $0x1,%r15
jmp    11c0 <backslash_eliminate+0x80>
movslq %r14d,%rax
add    $0x1,%r14d
movb   $0x5c,(%r9,%rax,1)
movzbl (%r15),%ebx
jmp    11ac <backslash_eliminate+0x6c>
add    $0x3,%r15
mov    %r15,%rcx
mov    0x10(%rsp),%r9
mov    0xc(%rsp),%esi
mov    0x8(%rsp),%r8d
lea    0xa0e(%rip),%rdi
mov    0x4(%rsp),%r10d
mov    (%rsp),%r11d
test   %r13b,%r13b
je     162b <backslash_eliminate+0x4eb>
movslq %r14d,%rax
add    $0x1,%r14d
mov    %r13b,(%r9,%rax,1)
nopl   0x0(%rax,%rax,1)
xor    %eax,%eax
mov    $0x1,%dl
jmp    11c7 <backslash_eliminate+0x87>
test   %dl,%dl
jne    1633 <backslash_eliminate+0x4f3>
movslq %r14d,%rax
add    $0x1,%r14d
movb   $0x5c,(%r9,%rax,1)
jmp    1633 <backslash_eliminate+0x4f3>
xor    %r9d,%r9d
jmp    163b <backslash_eliminate+0x4fb>
xor    %r14d,%r14d
movslq %r14d,%rax
movb   $0x0,(%r9,%rax,1)
mov    %r9,%rax
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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