#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 */
char *Capitalise(char *);
int Char2Int(char);
int /*<<< orphan*/ Debug(int, char *, ...);
char *Lowercase(char *);
int /*<<< orphan*/ MatchClass(char, char);
char *Pluralise(char *);
char *PolyPurge(char *, char);
int /*<<< orphan*/ PolyStrchr(char *, char);
char *PolySubst(char *, char, char);
char *Purge(char *, char);
char *Reverse(char *);
char *Substitute(char *, char, char);
char *Uppercase(char *);
int /*<<< orphan*/ strcat(char *, char *);
int /*<<< orphan*/ strchr(char *, char);
int /*<<< orphan*/ strcpy(char *, char *);
scalar_t__ strlen(char *);
char *Mangle(char *input, char *control) {
  int limit;
  register char *ptr;
  static char area[1024];
  char area2[1024];
  area[0] = '\0';
  strcpy(area, input);
  for (ptr = control; *ptr; ptr++) {
    switch (*ptr) {
    case ':':
      break;
    case 'r':
      strcpy(area, Reverse(area));
      break;
    case 'u':
      strcpy(area, Uppercase(area));
      break;
    case 'l':
      strcpy(area, Lowercase(area));
      break;
    case 'c':
      strcpy(area, Capitalise(area));
      break;
    case 'p':
      strcpy(area, Pluralise(area));
      break;
    case 'f':
      strcat(area, Reverse(area));
      break;
    case 'd':
      strcpy(area2, area);
      strcat(area, area2);
      break;
    case '>':
      if (!ptr[1]) {
        Debug(1, "Mangle: '>' missing argument in '%s'\n", control);
        return ((char *)0);
      } else {
        limit = Char2Int(*(++ptr));
        if (limit < 0) {
          Debug(1, "Mangle: '>' weird argument in '%s'\n", control);
          return ((char *)0);
        }
        if ((int)strlen(area) <= limit) {
          return ((char *)0);
        }
      }
      break;
    case '<':
      if (!ptr[1]) {
        Debug(1, "Mangle: '<' missing argument in '%s'\n", control);
        return ((char *)0);
      } else {
        limit = Char2Int(*(++ptr));
        if (limit < 0) {
          Debug(1, "Mangle: '<' weird argument in '%s'\n", control);
          return ((char *)0);
        }
        if ((int)strlen(area) >= limit) {
          return ((char *)0);
        }
      }
      break;
    case '^':
      if (!ptr[1]) {
        Debug(1, "Mangle: prepend missing argument in '%s'\n", control);
        return ((char *)0);
      } else {
        area2[0] = *(++ptr);
        strcpy(area2 + 1, area);
        strcpy(area, area2);
      }
      break;
    case '$':
      if (!ptr[1]) {
        Debug(1, "Mangle: append missing argument in '%s'\n", control);
        return ((char *)0);
      } else {
        register char *string;
        string = area;
        while (*(string++))
          ;
        string[-1] = *(++ptr);
        *string = '\0';
      }
      break;
    case 'x':
      if (!ptr[1] || !ptr[2]) {
        Debug(1, "Mangle: extract missing argument in '%s'\n", control);
        return ((char *)0);
      } else {
        register int i;
        int start;
        int length;
        start = Char2Int(*(++ptr));
        length = Char2Int(*(++ptr));
        if (start < 0 || length < 0) {
          Debug(1, "Mangle: extract: weird argument in '%s'\n", control);
          return ((char *)0);
        }
        strcpy(area2, area);
        for (i = 0; length-- && area2[start + i]; i++) {
          area[i] = area2[start + i];
        }
        area[i] = '\0';
      }
      break;
    case 'o':
      if (!ptr[1] || !ptr[2]) {
        Debug(1, "Mangle: overstrike missing argument in '%s'\n", control);
        return ((char *)0);
      } else {
        register int i;
        i = Char2Int(*(++ptr));
        if (i < 0) {
          Debug(1, "Mangle: overstrike weird argument in '%s'\n", control);
          return ((char *)0);
        } else {
          ++ptr;
          if (area[i]) {
            area[i] = *ptr;
          }
        }
      }
      break;
    case 'i':
      if (!ptr[1] || !ptr[2]) {
        Debug(1, "Mangle: insert missing argument in '%s'\n", control);
        return ((char *)0);
      } else {
        register int i;
        register char *p1;
        register char *p2;
        i = Char2Int(*(++ptr));
        if (i < 0) {
          Debug(1, "Mangle: insert weird argument in '%s'\n", control);
          return ((char *)0);
        }
        p1 = area;
        p2 = area2;
        while (i && *p1) {
          i--;
          *(p2++) = *(p1++);
        }
        *(p2++) = *(++ptr);
        strcpy(p2, p1);
        strcpy(area, area2);
      }
      break;
    case '@':
      if (!ptr[1] || (ptr[1] == '?' && !ptr[2])) {
        Debug(1, "Mangle: delete missing arguments in '%s'\n", control);
        return ((char *)0);
      } else if (ptr[1] != '?') {
        strcpy(area, Purge(area, *(++ptr)));
      } else {
        strcpy(area, PolyPurge(area, ptr[2]));
        ptr += 2;
      }
      break;
    case 's':
      if (!ptr[1] || !ptr[2] || (ptr[1] == '?' && !ptr[3])) {
        Debug(1, "Mangle: subst missing argument in '%s'\n", control);
        return ((char *)0);
      } else if (ptr[1] != '?') {
        strcpy(area, Substitute(area, ptr[1], ptr[2]));
        ptr += 2;
      } else {
        strcpy(area, PolySubst(area, ptr[2], ptr[3]));
        ptr += 3;
      }
      break;
    case '/':
      if (!ptr[1] || (ptr[1] == '?' && !ptr[2])) {
        Debug(1, "Mangle: '/' missing argument in '%s'\n", control);
        return ((char *)0);
      } else if (ptr[1] != '?') {
        if (!strchr(area, *(++ptr))) {
          return ((char *)0);
        }
      } else {
        if (!PolyStrchr(area, ptr[2])) {
          return ((char *)0);
        }
        ptr += 2;
      }
      break;
    case '!':
      if (!ptr[1] || (ptr[1] == '?' && !ptr[2])) {
        Debug(1, "Mangle: '!' missing argument in '%s'\n", control);
        return ((char *)0);
      } else if (ptr[1] != '?') {
        if (strchr(area, *(++ptr))) {
          return ((char *)0);
        }
      } else {
        if (PolyStrchr(area, ptr[2])) {
          return ((char *)0);
        }
        ptr += 2;
      }
      break;
    case '=':
      if (!ptr[1] || !ptr[2] || (ptr[2] == '?' && !ptr[3])) {
        Debug(1, "Mangle: '=' missing argument in '%s'\n", control);
        return ((char *)0);
      } else {
        register int i;
        if ((i = Char2Int(ptr[1])) < 0) {
          Debug(1, "Mangle: '=' weird argument in '%s'\n", control);
          return ((char *)0);
        }
        if (ptr[2] != '?') {
          ptr += 2;
          if (area[i] != *ptr) {
            return ((char *)0);
          }
        } else {
          ptr += 3;
          if (!MatchClass(*ptr, area[i])) {
            return ((char *)0);
          }
        }
      }
      break;
    case '[':
      if (area[0]) {
        register int i;
        for (i = 1; area[i]; i++) {
          area[i - 1] = area[i];
        }
        area[i - 1] = '\0';
      }
      break;
    case ']':
      if (area[0]) {
        register int i;
        for (i = 1; area[i]; i++)
          ;
        area[i - 1] = '\0';
      }
      break;
    case '(':
      if (!ptr[1] || (ptr[1] == '?' && !ptr[2])) {
        Debug(1, "Mangle: '(' missing argument in '%s'\n", control);
        return ((char *)0);
      } else {
        if (ptr[1] != '?') {
          ptr++;
          if (area[0] != *ptr) {
            return ((char *)0);
          }
        } else {
          ptr += 2;
          if (!MatchClass(*ptr, area[0])) {
            return ((char *)0);
          }
        }
      }
    case ')':
      if (!ptr[1] || (ptr[1] == '?' && !ptr[2])) {
        Debug(1, "Mangle: ')' missing argument in '%s'\n", control);
        return ((char *)0);
      } else {
        register int i;
        for (i = 0; area[i]; i++)
          ;
        if (i > 0) {
          i--;
        } else {
          return ((char *)0);
        }
        if (ptr[1] != '?') {
          ptr++;
          if (area[i] != *ptr) {
            return ((char *)0);
          }
        } else {
          ptr += 2;
          if (!MatchClass(*ptr, area[i])) {
            return ((char *)0);
          }
        }
      }
    default:
      Debug(1, "Mangle: unknown command %c in %s\n", *ptr, control);
      return ((char *)0);
      break;
    }
  }
  if (!area[0]) {
    return ((char *)0);
  }
  return (area);
}


x86 assembly (clang, -O0):
<Mangle>:
push   %rbp
mov    %rsp,%rbp
sub    $0x480,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
movb   $0x0,0x3e96(%rip)
mov    -0x10(%rbp),%rsi
lea    0x3e8b(%rip),%rdi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rax
cmpb   $0x0,(%rax)
je     21b7 <Mangle+0xfa7>
mov    -0x28(%rbp),%rax
movsbl (%rax),%eax
add    $0xffffffdf,%eax
mov    %eax,%ecx
mov    %rcx,-0x478(%rbp)
sub    $0x57,%eax
ja     2176 <Mangle+0xf66>
mov    -0x478(%rbp),%rax
lea    0x1d87(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
jmp    21a1 <Mangle+0xf91>
lea    0x3e32(%rip),%rdi
call   10e0 <Reverse@plt>
mov    %rax,%rsi
lea    0x3e23(%rip),%rdi
call   1030 <strcpy@plt>
jmp    21a1 <Mangle+0xf91>
lea    0x3e12(%rip),%rdi
call   1040 <Uppercase@plt>
mov    %rax,%rsi
lea    0x3e03(%rip),%rdi
call   1030 <strcpy@plt>
jmp    21a1 <Mangle+0xf91>
lea    0x3df2(%rip),%rdi
call   10b0 <Lowercase@plt>
mov    %rax,%rsi
lea    0x3de3(%rip),%rdi
call   1030 <strcpy@plt>
jmp    21a1 <Mangle+0xf91>
lea    0x3dd2(%rip),%rdi
call   1120 <Capitalise@plt>
mov    %rax,%rsi
lea    0x3dc3(%rip),%rdi
call   1030 <strcpy@plt>
jmp    21a1 <Mangle+0xf91>
lea    0x3db2(%rip),%rdi
call   10f0 <Pluralise@plt>
mov    %rax,%rsi
lea    0x3da3(%rip),%rdi
call   1030 <strcpy@plt>
jmp    21a1 <Mangle+0xf91>
lea    0x3d92(%rip),%rdi
call   10e0 <Reverse@plt>
mov    %rax,%rsi
lea    0x3d83(%rip),%rdi
call   1100 <strcat@plt>
jmp    21a1 <Mangle+0xf91>
lea    -0x430(%rbp),%rdi
lea    0x3d6b(%rip),%rsi
call   1030 <strcpy@plt>
lea    -0x430(%rbp),%rsi
lea    0x3d58(%rip),%rdi
call   1100 <strcat@plt>
jmp    21a1 <Mangle+0xf91>
mov    -0x28(%rbp),%rax
cmpb   $0x0,0x1(%rax)
jne    13a4 <Mangle+0x194>
mov    -0x18(%rbp),%rdx
mov    $0x1,%edi
lea    0x1dd0(%rip),%rsi
mov    $0x0,%al
call   10a0 <Debug@plt>
movq   $0x0,-0x8(%rbp)
jmp    21dc <Mangle+0xfcc>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
movsbl 0x1(%rax),%edi
call   1090 <Char2Int@plt>
mov    %eax,-0x1c(%rbp)
cmpl   $0x0,-0x1c(%rbp)
jge    13ed <Mangle+0x1dd>
mov    -0x18(%rbp),%rdx
mov    $0x1,%edi
lea    0x1dad(%rip),%rsi
mov    $0x0,%al
call   10a0 <Debug@plt>
movq   $0x0,-0x8(%rbp)
jmp    21dc <Mangle+0xfcc>
lea    0x3ccc(%rip),%rdi
call   1050 <strlen@plt>
cmp    -0x1c(%rbp),%eax
jg     140f <Mangle+0x1ff>
movq   $0x0,-0x8(%rbp)
jmp    21dc <Mangle+0xfcc>
jmp    1414 <Mangle+0x204>
jmp    21a1 <Mangle+0xf91>
mov    -0x28(%rbp),%rax
cmpb   $0x0,0x1(%rax)
jne    144b <Mangle+0x23b>
mov    -0x18(%rbp),%rdx
mov    $0x1,%edi
lea    0x1d73(%rip),%rsi
mov    $0x0,%al
call   10a0 <Debug@plt>
movq   $0x0,-0x8(%rbp)
jmp    21dc <Mangle+0xfcc>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
movsbl 0x1(%rax),%edi
call   1090 <Char2Int@plt>
mov    %eax,-0x1c(%rbp)
cmpl   $0x0,-0x1c(%rbp)
jge    1494 <Mangle+0x284>
mov    -0x18(%rbp),%rdx
mov    $0x1,%edi
lea    0x1d50(%rip),%rsi
mov    $0x0,%al
call   10a0 <Debug@plt>
movq   $0x0,-0x8(%rbp)
jmp    21dc <Mangle+0xfcc>
lea    0x3c25(%rip),%rdi
call   1050 <strlen@plt>
cmp    -0x1c(%rbp),%eax
jl     14b6 <Mangle+0x2a6>
movq   $0x0,-0x8(%rbp)
jmp    21dc <Mangle+0xfcc>
jmp    14bb <Mangle+0x2ab>
jmp    21a1 <Mangle+0xf91>
mov    -0x28(%rbp),%rax
cmpb   $0x0,0x1(%rax)
jne    14f2 <Mangle+0x2e2>
mov    -0x18(%rbp),%rdx
mov    $0x1,%edi
lea    0x1d16(%rip),%rsi
mov    $0x0,%al
call   10a0 <Debug@plt>
movq   $0x0,-0x8(%rbp)
jmp    21dc <Mangle+0xfcc>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
mov    0x1(%rax),%al
mov    %al,-0x430(%rbp)
lea    -0x430(%rbp),%rdi
add    $0x1,%rdi
lea    0x3ba4(%rip),%rsi
call   1030 <strcpy@plt>
lea    -0x430(%rbp),%rsi
lea    0x3b91(%rip),%rdi
call   1030 <strcpy@plt>
jmp    21a1 <Mangle+0xf91>
mov    -0x28(%rbp),%rax
cmpb   $0x0,0x1(%rax)
jne    156b <Mangle+0x35b>
mov    -0x18(%rbp),%rdx
mov    $0x1,%edi
lea    0x1cc7(%rip),%rsi
mov    $0x0,%al
call   10a0 <Debug@plt>
movq   $0x0,-0x8(%rbp)
jmp    21dc <Mangle+0xfcc>
lea    0x3b4e(%rip),%rax
mov    %rax,-0x438(%rbp)
mov    -0x438(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x438(%rbp)
cmpb   $0x0,(%rax)
je     159c <Mangle+0x38c>
jmp    1579 <Mangle+0x369>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
mov    0x1(%rax),%cl
mov    -0x438(%rbp),%rax
mov    %cl,-0x1(%rax)
mov    -0x438(%rbp),%rax
movb   $0x0,(%rax)
jmp    21a1 <Mangle+0xf91>
mov    -0x28(%rbp),%rax
cmpb   $0x0,0x1(%rax)
je     15e3 <Mangle+0x3d3>
mov    -0x28(%rbp),%rax
cmpb   $0x0,0x2(%rax)
jne    1607 <Mangle+0x3f7>
mov    -0x18(%rbp),%rdx
mov    $0x1,%edi
lea    0x1c54(%rip),%rsi
mov    $0x0,%al
call   10a0 <Debug@plt>
movq   $0x0,-0x8(%rbp)
jmp    21dc <Mangle+0xfcc>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
movsbl 0x1(%rax),%edi
call   1090 <Char2Int@plt>
mov    %eax,-0x440(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
movsbl 0x1(%rax),%edi
call   1090 <Char2Int@plt>
mov    %eax,-0x444(%rbp)
cmpl   $0x0,-0x440(%rbp)
jl     165d <Mangle+0x44d>
cmpl   $0x0,-0x444(%rbp)
jge    1681 <Mangle+0x471>
mov    -0x18(%rbp),%rdx
mov    $0x1,%edi
lea    0x1c04(%rip),%rsi
mov    $0x0,%al
call   10a0 <Debug@plt>
movq   $0x0,-0x8(%rbp)
jmp    21dc <Mangle+0xfcc>
lea    -0x430(%rbp),%rdi
lea    0x3a31(%rip),%rsi
call   1030 <strcpy@plt>
movl   $0x0,-0x43c(%rbp)
mov    -0x444(%rbp),%ecx
mov    %ecx,%eax
add    $0xffffffff,%eax
mov    %eax,-0x444(%rbp)
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x479(%rbp)
je     16e2 <Mangle+0x4d2>
mov    -0x440(%rbp),%eax
add    -0x43c(%rbp),%eax
cltq
movsbl -0x430(%rbp,%rax,1),%eax
ff
cmp    $0x0,%eax
setne  %al
mov    %al,-0x479(%rbp)
mov    -0x479(%rbp),%al
test   $0x1,%al
jne    16f5 <Mangle+0x4e5>
jmp    172f <Mangle+0x51f>
mov    -0x440(%rbp),%eax
add    -0x43c(%rbp),%eax
cltq
mov    -0x430(%rbp,%rax,1),%dl
movslq -0x43c(%rbp),%rcx
lea    0x39a8(%rip),%rax
mov    %dl,(%rax,%rcx,1)
mov    -0x43c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x43c(%rbp)
jmp    169e <Mangle+0x48e>
movslq -0x43c(%rbp),%rcx
lea    0x3983(%rip),%rax
movb   $0x0,(%rax,%rcx,1)
jmp    21a1 <Mangle+0xf91>
mov    -0x28(%rbp),%rax
cmpb   $0x0,0x1(%rax)
je     1762 <Mangle+0x552>
mov    -0x28(%rbp),%rax
cmpb   $0x0,0x2(%rax)
jne    1786 <Mangle+0x576>
mov    -0x18(%rbp),%rdx
mov    $0x1,%edi
lea    0x1b28(%rip),%rsi
mov    $0x0,%al
call   10a0 <Debug@plt>
movq   $0x0,-0x8(%rbp)
jmp    21dc <Mangle+0xfcc>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
movsbl 0x1(%rax),%edi
call   1090 <Char2Int@plt>
mov    %eax,-0x448(%rbp)
cmpl   $0x0,-0x448(%rbp)
jge    17d5 <Mangle+0x5c5>
mov    -0x18(%rbp),%rdx
mov    $0x1,%edi
lea    0x1b06(%rip),%rsi
mov    $0x0,%al
call   10a0 <Debug@plt>
movq   $0x0,-0x8(%rbp)
jmp    21dc <Mangle+0xfcc>
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
movslq -0x448(%rbp),%rcx
lea    0x38d1(%rip),%rax
cmpb   $0x0,(%rax,%rcx,1)
je     1810 <Mangle+0x600>
mov    -0x28(%rbp),%rax
mov    (%rax),%dl
movslq -0x448(%rbp),%rcx
lea    0x38b3(%rip),%rax
mov    %dl,(%rax,%rcx,1)
jmp    1815 <Mangle+0x605>
jmp    181a <Mangle+0x60a>
jmp    21a1 <Mangle+0xf91>
mov    -0x28(%rbp),%rax
cmpb   $0x0,0x1(%rax)
je     183b <Mangle+0x62b>
mov    -0x28(%rbp),%rax
cmpb   $0x0,0x2(%rax)
jne    185f <Mangle+0x64f>
mov    -0x18(%rbp),%rdx
mov    $0x1,%edi
lea    0x1aa7(%rip),%rsi
mov    $0x0,%al
call   10a0 <Debug@plt>
movq   $0x0,-0x8(%rbp)
jmp    21dc <Mangle+0xfcc>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
movsbl 0x1(%rax),%edi
call   1090 <Char2Int@plt>
mov    %eax,-0x44c(%rbp)
cmpl   $0x0,-0x44c(%rbp)
jge    18ae <Mangle+0x69e>
mov    -0x18(%rbp),%rdx
mov    $0x1,%edi
lea    0x1a81(%rip),%rsi
mov    $0x0,%al
call   10a0 <Debug@plt>
movq   $0x0,-0x8(%rbp)
jmp    21dc <Mangle+0xfcc>
lea    0x380b(%rip),%rax
mov    %rax,-0x458(%rbp)
lea    -0x430(%rbp),%rax
mov    %rax,-0x460(%rbp)
xor    %eax,%eax
cmpl   $0x0,-0x44c(%rbp)
mov    %al,-0x47a(%rbp)
je     18f5 <Mangle+0x6e5>
mov    -0x458(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x0,%eax
setne  %al
mov    %al,-0x47a(%rbp)
mov    -0x47a(%rbp),%al
test   $0x1,%al
jne    1908 <Mangle+0x6f8>
jmp    194a <Mangle+0x73a>
mov    -0x44c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x44c(%rbp)
mov    -0x458(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x458(%rbp)
mov    (%rax),%cl
mov    -0x460(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x460(%rbp)
mov    %cl,(%rax)
jmp    18ca <Mangle+0x6ba>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
mov    0x1(%rax),%cl
mov    -0x460(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x460(%rbp)
mov    %cl,(%rax)
mov    -0x460(%rbp),%rdi
mov    -0x458(%rbp),%rsi
call   1030 <strcpy@plt>
lea    -0x430(%rbp),%rsi
lea    0x372c(%rip),%rdi
call   1030 <strcpy@plt>
jmp    21a1 <Mangle+0xf91>
mov    -0x28(%rbp),%rax
cmpb   $0x0,0x1(%rax)
je     19cb <Mangle+0x7bb>
mov    -0x28(%rbp),%rax
movsbl 0x1(%rax),%eax
cmp    $0x3f,%eax
jne    19ef <Mangle+0x7df>
mov    -0x28(%rbp),%rax
cmpb   $0x0,0x2(%rax)
jne    19ef <Mangle+0x7df>
mov    -0x18(%rbp),%rdx
mov    $0x1,%edi
lea    0x1967(%rip),%rsi
mov    $0x0,%al
call   10a0 <Debug@plt>
movq   $0x0,-0x8(%rbp)
jmp    21dc <Mangle+0xfcc>
mov    -0x28(%rbp),%rax
movsbl 0x1(%rax),%eax
cmp    $0x3f,%eax
je     1a33 <Mangle+0x823>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
lea    0x36aa(%rip),%rdi
movsbl 0x1(%rax),%esi
call   1080 <Purge@plt>
mov    %rax,%rsi
lea    0x3697(%rip),%rdi
call   1030 <strcpy@plt>
jmp    1a62 <Mangle+0x852>
mov    -0x28(%rbp),%rax
lea    0x3682(%rip),%rdi
movsbl 0x2(%rax),%esi
call   10c0 <PolyPurge@plt>
mov    %rax,%rsi
lea    0x366f(%rip),%rdi
call   1030 <strcpy@plt>
mov    -0x28(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x28(%rbp)
jmp    1a67 <Mangle+0x857>
jmp    21a1 <Mangle+0xf91>
mov    -0x28(%rbp),%rax
cmpb   $0x0,0x1(%rax)
je     1aa7 <Mangle+0x897>
mov    -0x28(%rbp),%rax
cmpb   $0x0,0x2(%rax)
je     1aa7 <Mangle+0x897>
mov    -0x28(%rbp),%rax
movsbl 0x1(%rax),%eax
cmp    $0x3f,%eax
jne    1acb <Mangle+0x8bb>
mov    -0x28(%rbp),%rax
cmpb   $0x0,0x3(%rax)
jne    1acb <Mangle+0x8bb>
mov    -0x18(%rbp),%rdx
mov    $0x1,%edi
lea    0x18b5(%rip),%rsi
mov    $0x0,%al
call   10a0 <Debug@plt>
movq   $0x0,-0x8(%rbp)
jmp    21dc <Mangle+0xfcc>
mov    -0x28(%rbp),%rax
movsbl 0x1(%rax),%eax
cmp    $0x3f,%eax
je     1b1a <Mangle+0x90a>
mov    -0x28(%rbp),%rax
mov    0x1(%rax),%cl
mov    -0x28(%rbp),%rax
lea    0x35d2(%rip),%rdi
movsbl %cl,%esi
movsbl 0x2(%rax),%edx
call   1130 <Substitute@plt>
mov    %rax,%rsi
lea    0x35bc(%rip),%rdi
call   1030 <strcpy@plt>
mov    -0x28(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x28(%rbp)
jmp    1b53 <Mangle+0x943>
mov    -0x28(%rbp),%rax
mov    0x2(%rax),%cl
mov    -0x28(%rbp),%rax
lea    0x3594(%rip),%rdi
movsbl %cl,%esi
movsbl 0x3(%rax),%edx
call   10d0 <PolySubst@plt>
mov    %rax,%rsi
lea    0x357e(%rip),%rdi
call   1030 <strcpy@plt>
mov    -0x28(%rbp),%rax
add    $0x3,%rax
mov    %rax,-0x28(%rbp)
jmp    1b58 <Mangle+0x948>
jmp    21a1 <Mangle+0xf91>
mov    -0x28(%rbp),%rax
cmpb   $0x0,0x1(%rax)
je     1b8a <Mangle+0x97a>
mov    -0x28(%rbp),%rax
movsbl 0x1(%rax),%eax
cmp    $0x3f,%eax
jne    1bae <Mangle+0x99e>
mov    -0x28(%rbp),%rax
cmpb   $0x0,0x2(%rax)
jne    1bae <Mangle+0x99e>
mov    -0x18(%rbp),%rdx
mov    $0x1,%edi
lea    0x17fa(%rip),%rsi
mov    $0x0,%al
call   10a0 <Debug@plt>
movq   $0x0,-0x8(%rbp)
jmp    21dc <Mangle+0xfcc>
mov    -0x28(%rbp),%rax
movsbl 0x1(%rax),%eax
cmp    $0x3f,%eax
je     1bf9 <Mangle+0x9e9>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
lea    0x34eb(%rip),%rdi
movsbl 0x1(%rax),%esi
call   1070 <strchr@plt>
cmp    $0x0,%eax
jne    1bf4 <Mangle+0x9e4>
movq   $0x0,-0x8(%rbp)
jmp    21dc <Mangle+0xfcc>
jmp    1c2f <Mangle+0xa1f>
mov    -0x28(%rbp),%rax
lea    0x34bc(%rip),%rdi
movsbl 0x2(%rax),%esi
call   1110 <PolyStrchr@plt>
cmp    $0x0,%eax
jne    1c23 <Mangle+0xa13>
movq   $0x0,-0x8(%rbp)
jmp    21dc <Mangle+0xfcc>
mov    -0x28(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x28(%rbp)
jmp    1c34 <Mangle+0xa24>
jmp    21a1 <Mangle+0xf91>
mov    -0x28(%rbp),%rax
cmpb   $0x0,0x1(%rax)
je     1c66 <Mangle+0xa56>
mov    -0x28(%rbp),%rax
movsbl 0x1(%rax),%eax
cmp    $0x3f,%eax
jne    1c8a <Mangle+0xa7a>
mov    -0x28(%rbp),%rax
cmpb   $0x0,0x2(%rax)
jne    1c8a <Mangle+0xa7a>
mov    -0x18(%rbp),%rdx
mov    $0x1,%edi
lea    0x1744(%rip),%rsi
mov    $0x0,%al
call   10a0 <Debug@plt>
movq   $0x0,-0x8(%rbp)
jmp    21dc <Mangle+0xfcc>
mov    -0x28(%rbp),%rax
movsbl 0x1(%rax),%eax
cmp    $0x3f,%eax
je     1cd5 <Mangle+0xac5>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
lea    0x340f(%rip),%rdi
movsbl 0x1(%rax),%esi
call   1070 <strchr@plt>
cmp    $0x0,%eax
je     1cd0 <Mangle+0xac0>
movq   $0x0,-0x8(%rbp)
jmp    21dc <Mangle+0xfcc>
jmp    1d0b <Mangle+0xafb>
mov    -0x28(%rbp),%rax
lea    0x33e0(%rip),%rdi
movsbl 0x2(%rax),%esi
call   1110 <PolyStrchr@plt>
cmp    $0x0,%eax
je     1cff <Mangle+0xaef>
movq   $0x0,-0x8(%rbp)
jmp    21dc <Mangle+0xfcc>
mov    -0x28(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x28(%rbp)
jmp    1d10 <Mangle+0xb00>
jmp    21a1 <Mangle+0xf91>
mov    -0x28(%rbp),%rax
cmpb   $0x0,0x1(%rax)
je     1d50 <Mangle+0xb40>
mov    -0x28(%rbp),%rax
cmpb   $0x0,0x2(%rax)
je     1d50 <Mangle+0xb40>
mov    -0x28(%rbp),%rax
movsbl 0x2(%rax),%eax
cmp    $0x3f,%eax
jne    1d74 <Mangle+0xb64>
mov    -0x28(%rbp),%rax
cmpb   $0x0,0x3(%rax)
jne    1d74 <Mangle+0xb64>
mov    -0x18(%rbp),%rdx
mov    $0x1,%edi
lea    0x1680(%rip),%rsi
mov    $0x0,%al
call   10a0 <Debug@plt>
movq   $0x0,-0x8(%rbp)
jmp    21dc <Mangle+0xfcc>
mov    -0x28(%rbp),%rax
movsbl 0x1(%rax),%edi
call   1090 <Char2Int@plt>
mov    %eax,-0x464(%rbp)
cmp    $0x0,%eax
jge    1db4 <Mangle+0xba4>
mov    -0x18(%rbp),%rdx
mov    $0x1,%edi
lea    0x1666(%rip),%rsi
mov    $0x0,%al
call   10a0 <Debug@plt>
movq   $0x0,-0x8(%rbp)
jmp    21dc <Mangle+0xfcc>
mov    -0x28(%rbp),%rax
movsbl 0x2(%rax),%eax
cmp    $0x3f,%eax
je     1e04 <Mangle+0xbf4>
mov    -0x28(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x28(%rbp)
movslq -0x464(%rbp),%rcx
lea    0x32e1(%rip),%rax
movsbl (%rax,%rcx,1),%eax
mov    -0x28(%rbp),%rcx
movsbl (%rcx),%ecx
cmp    %ecx,%eax
je     1dff <Mangle+0xbef>
movq   $0x0,-0x8(%rbp)
jmp    21dc <Mangle+0xfcc>
jmp    1e4b <Mangle+0xc3b>
mov    -0x28(%rbp),%rax
add    $0x3,%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rax
mov    (%rax),%dl
movslq -0x464(%rbp),%rcx
lea    0x329c(%rip),%rax
movsbl %dl,%edi
movsbl (%rax,%rcx,1),%esi
call   1060 <MatchClass@plt>
cmp    $0x0,%eax
jne    1e46 <Mangle+0xc36>
movq   $0x0,-0x8(%rbp)
jmp    21dc <Mangle+0xfcc>
jmp    1e4b <Mangle+0xc3b>
jmp    1e50 <Mangle+0xc40>
jmp    21a1 <Mangle+0xf91>
cmpb   $0x0,0x3264(%rip)
je     1ed6 <Mangle+0xcc6>
movl   $0x1,-0x468(%rbp)
movslq -0x468(%rbp),%rcx
lea    0x3246(%rip),%rax
cmpb   $0x0,(%rax,%rcx,1)
je     1ebf <Mangle+0xcaf>
movslq -0x468(%rbp),%rcx
lea    0x322e(%rip),%rax
mov    (%rax,%rcx,1),%dl
mov    -0x468(%rbp),%eax
sub    $0x1,%eax
movslq %eax,%rcx
lea    0x3218(%rip),%rax
mov    %dl,(%rax,%rcx,1)
mov    -0x468(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x468(%rbp)
jmp    1e6c <Mangle+0xc5c>
mov    -0x468(%rbp),%eax
sub    $0x1,%eax
movslq %eax,%rcx
lea    0x31ee(%rip),%rax
movb   $0x0,(%rax,%rcx,1)
jmp    21a1 <Mangle+0xf91>
cmpb   $0x0,0x31de(%rip)
je     1f3a <Mangle+0xd2a>
movl   $0x1,-0x46c(%rbp)
movslq -0x46c(%rbp),%rcx
lea    0x31c0(%rip),%rax
cmpb   $0x0,(%rax,%rcx,1)
je     1f23 <Mangle+0xd13>
jmp    1f0f <Mangle+0xcff>
mov    -0x46c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x46c(%rbp)
jmp    1ef2 <Mangle+0xce2>
mov    -0x46c(%rbp),%eax
sub    $0x1,%eax
movslq %eax,%rcx
lea    0x318a(%rip),%rax
movb   $0x0,(%rax,%rcx,1)
jmp    21a1 <Mangle+0xf91>
mov    -0x28(%rbp),%rax
cmpb   $0x0,0x1(%rax)
je     1f6c <Mangle+0xd5c>
mov    -0x28(%rbp),%rax
movsbl 0x1(%rax),%eax
cmp    $0x3f,%eax
jne    1f90 <Mangle+0xd80>
mov    -0x28(%rbp),%rax
cmpb   $0x0,0x2(%rax)
jne    1f90 <Mangle+0xd80>
mov    -0x18(%rbp),%rdx
mov    $0x1,%edi
lea    0x14ae(%rip),%rsi
mov    $0x0,%al
call   10a0 <Debug@plt>
movq   $0x0,-0x8(%rbp)
jmp    21dc <Mangle+0xfcc>
mov    -0x28(%rbp),%rax
movsbl 0x1(%rax),%eax
cmp    $0x3f,%eax
je     1fd5 <Mangle+0xdc5>
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
movsbl 0x310c(%rip),%eax
mov    -0x28(%rbp),%rcx
movsbl (%rcx),%ecx
cmp    %ecx,%eax
je     1fd0 <Mangle+0xdc0>
movq   $0x0,-0x8(%rbp)
jmp    21dc <Mangle+0xfcc>
jmp    2011 <Mangle+0xe01>
mov    -0x28(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rax
mov    (%rax),%al
movsbl %al,%edi
movsbl 0x30cf(%rip),%esi
call   1060 <MatchClass@plt>
cmp    $0x0,%eax
jne    200c <Mangle+0xdfc>
movq   $0x0,-0x8(%rbp)
jmp    21dc <Mangle+0xfcc>
jmp    2011 <Mangle+0xe01>
jmp    2016 <Mangle+0xe06>
jmp    201b <Mangle+0xe0b>
mov    -0x28(%rbp),%rax
cmpb   $0x0,0x1(%rax)
je     2048 <Mangle+0xe38>
mov    -0x28(%rbp),%rax
movsbl 0x1(%rax),%eax
cmp    $0x3f,%eax
jne    206c <Mangle+0xe5c>
mov    -0x28(%rbp),%rax
cmpb   $0x0,0x2(%rax)
jne    206c <Mangle+0xe5c>
mov    -0x18(%rbp),%rdx
mov    $0x1,%edi
lea    0x13f8(%rip),%rsi
mov    $0x0,%al
call   10a0 <Debug@plt>
movq   $0x0,-0x8(%rbp)
jmp    21dc <Mangle+0xfcc>
movl   $0x0,-0x470(%rbp)
movslq -0x470(%rbp),%rcx
lea    0x303c(%rip),%rax
cmpb   $0x0,(%rax,%rcx,1)
je     20a7 <Mangle+0xe97>
jmp    2093 <Mangle+0xe83>
mov    -0x470(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x470(%rbp)
jmp    2076 <Mangle+0xe66>
cmpl   $0x0,-0x470(%rbp)
jle    20c8 <Mangle+0xeb8>
mov    -0x470(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x470(%rbp)
jmp    20d5 <Mangle+0xec5>
movq   $0x0,-0x8(%rbp)
jmp    21dc <Mangle+0xfcc>
mov    -0x28(%rbp),%rax
movsbl 0x1(%rax),%eax
cmp    $0x3f,%eax
je     2125 <Mangle+0xf15>
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
movslq -0x470(%rbp),%rcx
lea    0x2fc0(%rip),%rax
movsbl (%rax,%rcx,1),%eax
mov    -0x28(%rbp),%rcx
movsbl (%rcx),%ecx
cmp    %ecx,%eax
je     2120 <Mangle+0xf10>
movq   $0x0,-0x8(%rbp)
jmp    21dc <Mangle+0xfcc>
jmp    216c <Mangle+0xf5c>
mov    -0x28(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rax
mov    (%rax),%dl
movslq -0x470(%rbp),%rcx
lea    0x2f7b(%rip),%rax
movsbl %dl,%edi
movsbl (%rax,%rcx,1),%esi
call   1060 <MatchClass@plt>
cmp    $0x0,%eax
jne    2167 <Mangle+0xf57>
movq   $0x0,-0x8(%rbp)
jmp    21dc <Mangle+0xfcc>
jmp    216c <Mangle+0xf5c>
jmp    2171 <Mangle+0xf61>
jmp    2176 <Mangle+0xf66>
mov    -0x28(%rbp),%rax
movsbl (%rax),%edx
mov    -0x18(%rbp),%rcx
mov    $0x1,%edi
lea    0x12e9(%rip),%rsi
mov    $0x0,%al
call   10a0 <Debug@plt>
movq   $0x0,-0x8(%rbp)
jmp    21dc <Mangle+0xfcc>
jmp    21a6 <Mangle+0xf96>
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    1242 <Mangle+0x32>
cmpb   $0x0,0x2f02(%rip)
jne    21d1 <Mangle+0xfc1>
movq   $0x0,-0x8(%rbp)
jmp    21dc <Mangle+0xfcc>
lea    0x2ee8(%rip),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0x480,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<Mangle>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x418,%rsp
mov    %rsi,%r12
mov    %rdi,%rsi
movb   $0x0,0x2e92(%rip)
lea    0x2e8b(%rip),%r14
mov    %r14,%rdi
call   1030 <strcpy@plt>
mov    (%r12),%al
test   %al,%al
je     17f9 <Mangle+0x5e9>
lea    0xdb0(%rip),%r15
mov    %r12,%rbp
jmp    128a <Mangle+0x7a>
lea    0x2e64(%rip),%rbx
mov    %rbx,%rdi
call   10e0 <Reverse@plt>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %rbx,%rdi
mov    %rax,%rsi
call   1030 <strcpy@plt>
mov    0x1(%rbp),%al
add    $0x1,%rbp
test   %al,%al
je     17f9 <Mangle+0x5e9>
movsbl %al,%ecx
add    $0xffffffdf,%ecx
cmp    $0x57,%ecx
ja     19b7 <Mangle+0x7a7>
movslq (%r15,%rcx,4),%rcx
add    %r15,%rcx
jmp    *%rcx
mov    0x1(%rbp),%al
cmp    $0x3f,%al
je     16c1 <Mangle+0x4b1>
test   %al,%al
je     18bc <Mangle+0x6ac>
movsbl %al,%esi
lea    0x2e01(%rip),%rdi
call   1070 <strchr@plt>
test   %eax,%eax
je     13ba <Mangle+0x1aa>
jmp    195f <Mangle+0x74f>
mov    0x1(%rbp),%al
test   %al,%al
je     188c <Mangle+0x67c>
add    $0x1,%rbp
lea    0x2dd9(%rip),%rcx
nopw   0x0(%rax,%rax,1)
cmpb   $0x0,(%rcx)
lea    0x1(%rcx),%rcx
jne    12f0 <Mangle+0xe0>
mov    %al,-0x1(%rcx)
movb   $0x0,(%rcx)
jmp    127b <Mangle+0x6b>
mov    0x1(%rbp),%al
cmp    $0x3f,%al
je     16e4 <Mangle+0x4d4>
test   %al,%al
je     18c8 <Mangle+0x6b8>
movsbl %al,%esi
lea    0x2d9f(%rip),%rdi
call   1070 <strchr@plt>
test   %eax,%eax
jne    13ba <Mangle+0x1aa>
jmp    195f <Mangle+0x74f>
mov    0x1(%rbp),%al
test   %al,%al
je     1898 <Mangle+0x688>
movsbl %al,%edi
call   1090 <Char2Int@plt>
test   %eax,%eax
js     18e0 <Mangle+0x6d0>
mov    %eax,%ebx
lea    0x2d69(%rip),%rdi
call   1050 <strlen@plt>
cmp    %eax,%ebx
jg     13ba <Mangle+0x1aa>
jmp    195f <Mangle+0x74f>
mov    0x1(%rbp),%al
test   %al,%al
je     1842 <Mangle+0x632>
mov    0x2(%rbp),%cl
cmp    $0x3f,%cl
je     1735 <Mangle+0x525>
test   %cl,%cl
jne    173f <Mangle+0x52f>
jmp    1842 <Mangle+0x632>
mov    0x1(%rbp),%al
test   %al,%al
je     18a4 <Mangle+0x694>
movsbl %al,%edi
call   1090 <Char2Int@plt>
test   %eax,%eax
js     18ec <Mangle+0x6dc>
mov    %eax,%ebx
lea    0x2d13(%rip),%rdi
call   1050 <strlen@plt>
cmp    %eax,%ebx
jge    195f <Mangle+0x74f>
add    $0x1,%rbp
jmp    127b <Mangle+0x6b>
mov    0x1(%rbp),%al
cmp    $0x3f,%al
je     170f <Mangle+0x4ff>
test   %al,%al
je     18d4 <Mangle+0x6c4>
add    $0x1,%rbp
movsbl %al,%esi
lea    0x2cdc(%rip),%rbx
mov    %rbx,%rdi
call   1080 <Purge@plt>
jmp    1270 <Mangle+0x60>
cmpb   $0x0,0x2cc8(%rip)
je     127b <Mangle+0x6b>
mov    0x2cbd(%rip),%cl
mov    $0x1,%eax
test   %cl,%cl
je     1428 <Mangle+0x218>
nopl   (%rax)
lea    0x2ca9(%rip),%rdx
mov    %cl,-0x1(%rax,%rdx,1)
movzbl 0x1(%rax,%rdx,1),%ecx
add    $0x1,%rax
test   %cl,%cl
jne    1410 <Mangle+0x200>
add    $0xffffffff,%eax
cltq
jmp    146a <Mangle+0x25a>
cmpb   $0x0,0x2c8a(%rip)
je     127b <Mangle+0x6b>
lea    0x2c7e(%rip),%rcx
movabs $0xffffffff00000000,%rax
ff ff ff
nopl   (%rax)
movabs $0x100000000,%rdx
add    %rdx,%rax
cmpb   $0x0,(%rcx)
lea    0x1(%rcx),%rcx
jne    1450 <Mangle+0x240>
sar    $0x20,%rax
lea    0x2c4f(%rip),%rcx
movb   $0x0,(%rax,%rcx,1)
jmp    127b <Mangle+0x6b>
mov    0x1(%rbp),%al
test   %al,%al
je     18b0 <Mangle+0x6a0>
add    $0x1,%rbp
mov    %al,0x10(%rsp)
lea    0x2c2c(%rip),%rbx
lea    0x11(%rsp),%rdi
mov    %rbx,%rsi
call   1030 <strcpy@plt>
lea    0x10(%rsp),%rsi
mov    %rbx,%rdi
jmp    1276 <Mangle+0x66>
lea    0x2c0b(%rip),%rbx
mov    %rbx,%rdi
call   1120 <Capitalise@plt>
jmp    1270 <Mangle+0x60>
lea    0x2bf7(%rip),%rbx
lea    0x10(%rsp),%r13
mov    %r13,%rdi
mov    %rbx,%rsi
call   1030 <strcpy@plt>
mov    %rbx,%rdi
mov    %r13,%rsi
jmp    14f6 <Mangle+0x2e6>
lea    0x2bd8(%rip),%rbx
mov    %rbx,%rdi
call   10e0 <Reverse@plt>
mov    %rbx,%rdi
mov    %rax,%rsi
call   1100 <strcat@plt>
jmp    127b <Mangle+0x6b>
mov    0x1(%rbp),%al
test   %al,%al
je     181e <Mangle+0x60e>
cmpb   $0x0,0x2(%rbp)
je     181e <Mangle+0x60e>
add    $0x2,%rbp
movsbl %al,%edi
call   1090 <Char2Int@plt>
test   %eax,%eax
js     18f5 <Mangle+0x6e5>
je     17b7 <Mangle+0x5a7>
lea    0x2b8a(%rip),%rsi
lea    0x10(%rsp),%rcx
nopl   0x0(%rax,%rax,1)
movzbl (%rsi),%edx
test   %dl,%dl
je     17d7 <Mangle+0x5c7>
add    $0x1,%rsi
lea    0x1(%rcx),%rdi
mov    %dl,(%rcx)
mov    %rdi,%rcx
add    $0xffffffff,%eax
jne    1540 <Mangle+0x330>
jmp    17da <Mangle+0x5ca>
lea    0x2b57(%rip),%rbx
mov    %rbx,%rdi
call   10b0 <Lowercase@plt>
jmp    1270 <Mangle+0x60>
mov    0x1(%rbp),%al
test   %al,%al
je     182a <Mangle+0x61a>
cmpb   $0x0,0x2(%rbp)
je     182a <Mangle+0x61a>
movsbl %al,%edi
call   1090 <Char2Int@plt>
test   %eax,%eax
js     18fe <Mangle+0x6ee>
add    $0x2,%rbp
mov    %eax,%eax
cmpb   $0x0,(%rax,%r14,1)
je     127b <Mangle+0x6b>
mov    0x0(%rbp),%cl
mov    %cl,(%rax,%r14,1)
jmp    127b <Mangle+0x6b>
lea    0x2b01(%rip),%rbx
mov    %rbx,%rdi
call   10f0 <Pluralise@plt>
jmp    1270 <Mangle+0x60>
mov    0x1(%rbp),%cl
test   %cl,%cl
je     1812 <Mangle+0x602>
mov    0x2(%rbp),%al
test   %al,%al
je     1812 <Mangle+0x602>
cmp    $0x3f,%cl
jne    1781 <Mangle+0x571>
mov    0x3(%rbp),%cl
test   %cl,%cl
je     1812 <Mangle+0x602>
add    $0x3,%rbp
movsbl %al,%esi
movsbl %cl,%edx
lea    0x2ab9(%rip),%rbx
mov    %rbx,%rdi
call   10d0 <PolySubst@plt>
jmp    1270 <Mangle+0x60>
lea    0x2aa5(%rip),%rbx
mov    %rbx,%rdi
call   1040 <Uppercase@plt>
jmp    1270 <Mangle+0x60>
mov    0x1(%rbp),%al
test   %al,%al
je     1836 <Mangle+0x626>
cmpb   $0x0,0x2(%rbp)
je     1836 <Mangle+0x626>
add    $0x2,%rbp
movsbl %al,%edi
call   1090 <Char2Int@plt>
mov    %eax,%ebx
movsbl 0x0(%rbp),%edi
call   1090 <Char2Int@plt>
test   %ebx,%ebx
js     1907 <Mangle+0x6f7>
test   %eax,%eax
js     1907 <Mangle+0x6f7>
mov    %r12,0x8(%rsp)
mov    %r14,%r12
mov    %eax,%r14d
lea    0x2a4a(%rip),%r13
lea    0x10(%rsp),%rdi
mov    %r13,%rsi
call   1030 <strcpy@plt>
test   %r14,%r14
je     17c1 <Mangle+0x5b1>
mov    %ebx,%eax
lea    (%rsp,%rax,1),%rcx
add    $0x10,%rcx
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
movzbl (%rcx,%rax,1),%edx
test   %dl,%dl
je     17c3 <Mangle+0x5b3>
mov    %dl,(%rax,%r13,1)
add    $0x1,%rax
cmp    %eax,%r14d
jne    16a0 <Mangle+0x490>
mov    %r14d,%eax
jmp    17c3 <Mangle+0x5b3>
mov    0x2(%rbp),%al
test   %al,%al
je     18bc <Mangle+0x6ac>
movsbl %al,%esi
lea    0x29ea(%rip),%rdi
call   1110 <PolyStrchr@plt>
test   %eax,%eax
je     1706 <Mangle+0x4f6>
jmp    195f <Mangle+0x74f>
mov    0x2(%rbp),%al
test   %al,%al
je     18c8 <Mangle+0x6b8>
movsbl %al,%esi
lea    0x29c7(%rip),%rdi
call   1110 <PolyStrchr@plt>
test   %eax,%eax
je     195f <Mangle+0x74f>
add    $0x2,%rbp
jmp    127b <Mangle+0x6b>
mov    0x2(%rbp),%al
test   %al,%al
je     18d4 <Mangle+0x6c4>
add    $0x2,%rbp
movsbl %al,%esi
lea    0x2998(%rip),%rbx
mov    %rbx,%rdi
call   10c0 <PolyPurge@plt>
jmp    1270 <Mangle+0x60>
cmpb   $0x0,0x3(%rbp)
je     1842 <Mangle+0x632>
movsbl %al,%edi
call   1090 <Char2Int@plt>
test   %eax,%eax
js     1910 <Mangle+0x700>
lea    0x2(%rbp),%rcx
mov    (%rcx),%dl
mov    %eax,%eax
cmp    $0x3f,%dl
jne    179f <Mangle+0x58f>
movsbl 0x3(%rbp),%edi
lea    0x2959(%rip),%rcx
movsbl (%rax,%rcx,1),%esi
call   1060 <MatchClass@plt>
test   %eax,%eax
je     195f <Mangle+0x74f>
add    $0x3,%rbp
jmp    127b <Mangle+0x6b>
add    $0x2,%rbp
movsbl %cl,%esi
movsbl %al,%edx
lea    0x292e(%rip),%rbx
mov    %rbx,%rdi
call   1130 <Substitute@plt>
jmp    1270 <Mangle+0x60>
lea    0x291a(%rip),%rsi
mov    %rcx,%rbp
cmp    %dl,(%rax,%rsi,1)
je     127b <Mangle+0x6b>
jmp    195f <Mangle+0x74f>
lea    0x10(%rsp),%rdi
mov    %r14,%rsi
jmp    17da <Mangle+0x5ca>
xor    %eax,%eax
mov    %r12,%r14
mov    0x8(%rsp),%r12
mov    %eax,%eax
movb   $0x0,(%rax,%r13,1)
jmp    127b <Mangle+0x6b>
mov    %rcx,%rdi
mov    0x0(%rbp),%al
mov    %al,(%rdi)
add    $0x1,%rdi
call   1030 <strcpy@plt>
lea    0x28d1(%rip),%rdi
lea    0x10(%rsp),%rsi
jmp    1276 <Mangle+0x66>
lea    0x28c0(%rip),%rax
xor    %ebx,%ebx
cmpb   $0x0,0x28b7(%rip)
cmovne %rax,%rbx
jmp    197b <Mangle+0x76b>
lea    0xb53(%rip),%rsi
jmp    196a <Mangle+0x75a>
lea    0xacd(%rip),%rsi
jmp    196a <Mangle+0x75a>
lea    0xa69(%rip),%rsi
jmp    196a <Mangle+0x75a>
lea    0xa0a(%rip),%rsi
jmp    196a <Mangle+0x75a>
lea    0xb97(%rip),%rsi
jmp    196a <Mangle+0x75a>
mov    0x1(%rbp),%al
test   %al,%al
je     1919 <Mangle+0x709>
cmp    $0x3f,%al
jne    1922 <Mangle+0x712>
mov    0x2(%rbp),%al
test   %al,%al
je     1919 <Mangle+0x709>
movsbl 0x284d(%rip),%esi
movsbl %al,%edi
call   1060 <MatchClass@plt>
test   %eax,%eax
je     195f <Mangle+0x74f>
add    $0x2,%rbp
jmp    192e <Mangle+0x71e>
lea    0x98b(%rip),%rsi
jmp    196a <Mangle+0x75a>
lea    0x90b(%rip),%rsi
jmp    196a <Mangle+0x75a>
lea    0x8b5(%rip),%rsi
jmp    196a <Mangle+0x75a>
lea    0x93d(%rip),%rsi
jmp    196a <Mangle+0x75a>
lea    0xaf7(%rip),%rsi
jmp    196a <Mangle+0x75a>
lea    0xac5(%rip),%rsi
jmp    196a <Mangle+0x75a>
lea    0xa67(%rip),%rsi
jmp    196a <Mangle+0x75a>
lea    0x8e9(%rip),%rsi
jmp    196a <Mangle+0x75a>
lea    0x893(%rip),%rsi
jmp    196a <Mangle+0x75a>
lea    0xa1f(%rip),%rsi
jmp    196a <Mangle+0x75a>
lea    0x9c2(%rip),%rsi
jmp    196a <Mangle+0x75a>
lea    0x963(%rip),%rsi
jmp    196a <Mangle+0x75a>
lea    0xaef(%rip),%rsi
jmp    196a <Mangle+0x75a>
lea    0xb0a(%rip),%rsi
jmp    196a <Mangle+0x75a>
cmp    %al,0x2798(%rip)
jne    195f <Mangle+0x74f>
add    $0x1,%rbp
mov    0x1(%rbp),%al
test   %al,%al
je     1963 <Mangle+0x753>
cmp    $0x3f,%al
jne    193f <Mangle+0x72f>
cmpb   $0x0,0x2(%rbp)
je     1963 <Mangle+0x753>
xor    %edx,%edx
lea    0x2778(%rip),%rcx
nopl   0x0(%rax,%rax,1)
cmpb   $0x0,(%rdx,%rcx,1)
lea    0x1(%rdx),%rdx
jne    1950 <Mangle+0x740>
cmp    $0x1,%edx
jne    1990 <Mangle+0x780>
xor    %ebx,%ebx
jmp    197b <Mangle+0x76b>
lea    0xae6(%rip),%rsi
xor    %ebx,%ebx
mov    $0x1,%edi
mov    %r12,%rdx
xor    %eax,%eax
call   10a0 <Debug@plt>
mov    %rbx,%rax
add    $0x418,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
add    $0xfffffffffffffffe,%rdx
cmp    $0x3f,%al
jne    19b0 <Mangle+0x7a0>
movsbl 0x2(%rbp),%edi
mov    %edx,%eax
movsbl (%rax,%rcx,1),%esi
call   1060 <MatchClass@plt>
test   %eax,%eax
je     195f <Mangle+0x74f>
mov    0x2(%rbp),%al
jmp    19b7 <Mangle+0x7a7>
mov    %edx,%edx
cmp    %al,(%rdx,%rcx,1)
jne    195f <Mangle+0x74f>
movsbl %al,%edx
lea    0xab5(%rip),%rsi
xor    %ebx,%ebx
mov    $0x1,%edi
mov    %r12,%rcx
xor    %eax,%eax
call   10a0 <Debug@plt>
jmp    197b <Mangle+0x76b>

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

LLVM IR (-O2):
@Mangle.area = internal global [1024 x i8] zeroinitializer
@.str = [38 x i8] c"Mangle: '>' missing argument in '%s'\0A\00"
@.str.1 = [36 x i8] c"Mangle: '>' weird argument in '%s'\0A\00"
@.str.2 = [38 x i8] c"Mangle: '<' missing argument in '%s'\0A\00"
@.str.3 = [36 x i8] c"Mangle: '<' weird argument in '%s'\0A\00"
@.str.4 = [42 x i8] c"Mangle: prepend missing argument in '%s'\0A\00"
@.str.5 = [41 x i8] c"Mangle: append missing argument in '%s'\0A\00"
@.str.6 = [42 x i8] c"Mangle: extract missing argument in '%s'\0A\00"
@.str.7 = [41 x i8] c"Mangle: extract: weird argument in '%s'\0A\00"
@.str.8 = [45 x i8] c"Mangle: overstrike missing argument in '%s'\0A\00"
@.str.9 = [43 x i8] c"Mangle: overstrike weird argument in '%s'\0A\00"
@.str.10 = [41 x i8] c"Mangle: insert missing argument in '%s'\0A\00"
@.str.11 = [39 x i8] c"Mangle: insert weird argument in '%s'\0A\00"
@.str.12 = [42 x i8] c"Mangle: delete missing arguments in '%s'\0A\00"
@.str.13 = [40 x i8] c"Mangle: subst missing argument in '%s'\0A\00"
@.str.14 = [38 x i8] c"Mangle: '/' missing argument in '%s'\0A\00"
@.str.15 = [38 x i8] c"Mangle: '!' missing argument in '%s'\0A\00"
@.str.16 = [38 x i8] c"Mangle: '=' missing argument in '%s'\0A\00"
@.str.17 = [36 x i8] c"Mangle: '=' weird argument in '%s'\0A\00"
@.str.18 = [38 x i8] c"Mangle: '(' missing argument in '%s'\0A\00"
@.str.19 = [38 x i8] c"Mangle: ')' missing argument in '%s'\0A\00"
@.str.20 = [34 x i8] c"Mangle: unknown command %c in %s\0A\00"
define i8* @Mangle(i8* %0, i8* %1) {
%3 = alloca [1024 x i8]
%4 = getelementptr inbounds [1024 x i8], [1024 x i8]* %3, i64 0, i64 0
store i8 0, i8* getelementptr inbounds ([1024 x i8], [1024 x i8]* @Mangle.area, i64 0, i64 0)
%5 = tail call i32 @strcpy(i8* getelementptr inbounds ([1024 x i8], [1024 x i8]* @Mangle.area, i64 0, i64 0), i8* %0)
%6 = load i8, i8* %1
%7 = icmp eq i8 %6, 0
br i1 %7, label %384, label %8
8: ; preds = %2
%9 = getelementptr inbounds [1024 x i8], [1024 x i8]* %3, i64 0, i64 1
br label %10
10: ; preds = %8, %379
%11 = phi i8 [ %6, %8 ], [ %382, %379 ]
%12 = phi i8* [ %1, %8 ], [ %381, %379 ]
%13 = sext i8 %11 to i32
switch i32 %13, label %375 [
i32 58, label %379
i32 114, label %14
i32 117, label %17
i32 108, label %20
i32 99, label %23
i32 112, label %26
i32 102, label %29
i32 100, label %32
i32 62, label %35
i32 60, label %50
i32 94, label %65
i32 36, label %74
i32 120, label %86
i32 111, label %128
i32 105, label %150
i32 64, label %185
i32 115, label %200
i32 47, label %222
i32 33, label %237
i32 61, label %252
i32 91, label %286
i32 93, label %307
i32 40, label %321
i32 41, label %337
]
14: ; preds = %10
%15 = call i8* @Reverse(i8* getelementptr inbounds ([1024 x i8], [1024 x i8]* @Mangle.area, i64 0, i64 0))
%16 = call i32 @strcpy(i8* getelementptr inbounds ([1024 x i8], [1024 x i8]* @Mangle.area, i64 0, i64 0), i8* %15)
br label %379
17: ; preds = %10
%18 = call i8* @Uppercase(i8* getelementptr inbounds ([1024 x i8], [1024 x i8]* @Mangle.area, i64 0, i64 0))
%19 = call i32 @strcpy(i8* getelementptr inbounds ([1024 x i8], [1024 x i8]* @Mangle.area, i64 0, i64 0), i8* %18)
br label %379
20: ; preds = %10
%21 = call i8* @Lowercase(i8* getelementptr inbounds ([1024 x i8], [1024 x i8]* @Mangle.area, i64 0, i64 0))
%22 = call i32 @strcpy(i8* getelementptr inbounds ([1024 x i8], [1024 x i8]* @Mangle.area, i64 0, i64 0), i8* %21)
br label %379
23: ; preds = %10
%24 = call i8* @Capitalise(i8* getelementptr inbounds ([1024 x i8], [1024 x i8]* @Mangle.area, i64 0, i64 0))
%25 = call i32 @strcpy(i8* getelementptr inbounds ([1024 x i8], [1024 x i8]* @Mangle.area, i64 0, i64 0), i8* %24)
br label %379
26: ; preds = %10
%27 = call i8* @Pluralise(i8* getelementptr inbounds ([1024 x i8], [1024 x i8]* @Mangle.area, i64 0, i64 0))
%28 = call i32 @strcpy(i8* getelementptr inbounds ([1024 x i8], [1024 x i8]* @Mangle.area, i64 0, i64 0), i8* %27)
br label %379
29: ; preds = %10
%30 = call i8* @Reverse(i8* getelementptr inbounds ([1024 x i8], [1024 x i8]* @Mangle.area, i64 0, i64 0))
%31 = call i32 @strcat(i8* getelementptr inbounds ([1024 x i8], [1024 x i8]* @Mangle.area, i64 0, i64 0), i8* %30)
br label %379
32: ; preds = %10
%33 = call i32 @strcpy(i8* %4, i8* getelementptr inbounds ([1024 x i8], [1024 x i8]* @Mangle.area, i64 0, i64 0))
%34 = call i32 @strcat(i8* getelementptr inbounds ([1024 x i8], [1024 x i8]* @Mangle.area, i64 0, i64 0), i8* %4)
br label %379
35: ; preds = %10
%36 = getelementptr inbounds i8, i8* %12, i64 1
%37 = load i8, i8* %36
%38 = icmp eq i8 %37, 0
br i1 %38, label %39, label %41
39: ; preds = %35
%40 = call i32 (i32, i8*, ...) @Debug(i32 1, i8* getelementptr inbounds ([38 x i8], [38 x i8]* @.str, i64 0, i64 0), i8* %1)
br label %388
41: ; preds = %35
%42 = call i32 @Char2Int(i8 signext %37)
%43 = icmp slt i32 %42, 0
br i1 %43, label %44, label %46
44: ; preds = %41
%45 = call i32 (i32, i8*, ...) @Debug(i32 1, i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str.1, i64 0, i64 0), i8* %1)
br label %388
46: ; preds = %41
%47 = call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([1024 x i8], [1024 x i8]* @Mangle.area, i64 0, i64 0))
%48 = trunc i64 %47 to i32
%49 = icmp slt i32 %42, %48
br i1 %49, label %379, label %388
50: ; preds = %10
%51 = getelementptr inbounds i8, i8* %12, i64 1
%52 = load i8, i8* %51
%53 = icmp eq i8 %52, 0
br i1 %53, label %54, label %56
54: ; preds = %50
%55 = call i32 (i32, i8*, ...) @Debug(i32 1, i8* getelementptr inbounds ([38 x i8], [38 x i8]* @.str.2, i64 0, i64 0), i8* %1)
br label %388
56: ; preds = %50
%57 = call i32 @Char2Int(i8 signext %52)
%58 = icmp slt i32 %57, 0
br i1 %58, label %59, label %61
59: ; preds = %56
%60 = call i32 (i32, i8*, ...) @Debug(i32 1, i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str.3, i64 0, i64 0), i8* %1)
br label %388
61: ; preds = %56
%62 = call i64 @strlen(i8* dereferenceable(1) getelementptr inbounds ([1024 x i8], [1024 x i8]* @Mangle.area, i64 0, i64 0))
%63 = trunc i64 %62 to i32
%64 = icmp sgt i32 %57, %63
br i1 %64, label %379, label %388
65: ; preds = %10
%66 = getelementptr inbounds i8, i8* %12, i64 1
%67 = load i8, i8* %66
%68 = icmp eq i8 %67, 0
br i1 %68, label %69, label %71
69: ; preds = %65
%70 = call i32 (i32, i8*, ...) @Debug(i32 1, i8* getelementptr inbounds ([42 x i8], [42 x i8]* @.str.4, i64 0, i64 0), i8* %1)
br label %388
71: ; preds = %65
store i8 %67, i8* %4
%72 = call i32 @strcpy(i8* %9, i8* getelementptr inbounds ([1024 x i8], [1024 x i8]* @Mangle.area, i64 0, i64 0))
%73 = call i32 @strcpy(i8* getelementptr inbounds ([1024 x i8], [1024 x i8]* @Mangle.area, i64 0, i64 0), i8* %4)
br label %379
74: ; preds = %10
%75 = getelementptr inbounds i8, i8* %12, i64 1
%76 = load i8, i8* %75
%77 = icmp eq i8 %76, 0
br i1 %77, label %78, label %80
78: ; preds = %74
%79 = call i32 (i32, i8*, ...) @Debug(i32 1, i8* getelementptr inbounds ([41 x i8], [41 x i8]* @.str.5, i64 0, i64 0), i8* %1)
br label %388
80: ; preds = %74, %80
%81 = phi i8* [ %82, %80 ], [ getelementptr inbounds ([1024 x i8], [1024 x i8]* @Mangle.area, i64 0, i64 0), %74 ]
%82 = getelementptr inbounds i8, i8* %81, i64 1
%83 = load i8, i8* %81
%84 = icmp eq i8 %83, 0
br i1 %84, label %85, label %80
85: ; preds = %80
store i8 %76, i8* %81
store i8 0, i8* %82
br label %379
86: ; preds = %10
%87 = getelementptr inbounds i8, i8* %12, i64 1
%88 = load i8, i8* %87
%89 = icmp eq i8 %88, 0
br i1 %89, label %94, label %90
90: ; preds = %86
%91 = getelementptr inbounds i8, i8* %12, i64 2
%92 = load i8, i8* %91
%93 = icmp eq i8 %92, 0
br i1 %93, label %94, label %96
94: ; preds = %90, %86
%95 = call i32 (i32, i8*, ...) @Debug(i32 1, i8* getelementptr inbounds ([42 x i8], [42 x i8]* @.str.6, i64 0, i64 0), i8* %1)
br label %388
96: ; preds = %90
%97 = call i32 @Char2Int(i8 signext %88)
%98 = load i8, i8* %91
%99 = call i32 @Char2Int(i8 signext %98)
%100 = icmp slt i32 %97, 0
%101 = icmp slt i32 %99, 0
%102 = select i1 %100, i1 true, i1 %101
br i1 %102, label %103, label %105
103: ; preds = %96
%104 = call i32 (i32, i8*, ...) @Debug(i32 1, i8* getelementptr inbounds ([41 x i8], [41 x i8]* @.str.7, i64 0, i64 0), i8* %1)
br label %388
105: ; preds = %96
%106 = call i32 @strcpy(i8* %4, i8* getelementptr inbounds ([1024 x i8], [1024 x i8]* @Mangle.area, i64 0, i64 0))
%107 = icmp eq i32 %99, 0
br i1 %107, label %124, label %108
108: ; preds = %105
%109 = zext i32 %97 to i64
br label %110
110: ; preds = %108, %118
%111 = phi i64 [ 0, %108 ], [ %120, %118 ]
%112 = phi i32 [ %99, %108 ], [ %113, %118 ]
%113 = add nsw i32 %112, -1
%114 = add nuw nsw i64 %111, %109
%115 = getelementptr inbounds [1024 x i8], [1024 x i8]* %3, i64 0, i64 %114
%116 = load i8, i8* %115
%117 = icmp eq i8 %116, 0
br i1 %117, label %122, label %118
118: ; preds = %110
%119 = getelementptr inbounds [1024 x i8], [1024 x i8]* @Mangle.area, i64 0, i64 %111
store i8 %116, i8* %119
%120 = add nuw nsw i64 %111, 1
%121 = icmp eq i32 %113, 0
br i1 %121, label %124, label %110
122: ; preds = %110
%123 = trunc i64 %111 to i32
br label %124
124: ; preds = %118, %122, %105
%125 = phi i32 [ 0, %105 ], [ %123, %122 ], [ %99, %118 ]
%126 = zext i32 %125 to i64
%127 = getelementptr inbounds [1024 x i8], [1024 x i8]* @Mangle.area, i64 0, i64 %126
store i8 0, i8* %127
br label %379
128: ; preds = %10
%129 = getelementptr inbounds i8, i8* %12, i64 1
%130 = load i8, i8* %129
%131 = icmp eq i8 %130, 0
br i1 %131, label %136, label %132
132: ; preds = %128
%133 = getelementptr inbounds i8, i8* %12, i64 2
%134 = load i8, i8* %133
%135 = icmp eq i8 %134, 0
br i1 %135, label %136, label %138
136: ; preds = %132, %128
%137 = call i32 (i32, i8*, ...) @Debug(i32 1, i8* getelementptr inbounds ([45 x i8], [45 x i8]* @.str.8, i64 0, i64 0), i8* %1)
br label %388
138: ; preds = %132
%139 = call i32 @Char2Int(i8 signext %130)
%140 = icmp slt i32 %139, 0
br i1 %140, label %148, label %141
141: ; preds = %138
%142 = zext i32 %139 to i64
%143 = getelementptr inbounds [1024 x i8], [1024 x i8]* @Mangle.area, i64 0, i64 %142
%144 = load i8, i8* %143
%145 = icmp eq i8 %144, 0
br i1 %145, label %379, label %146
146: ; preds = %141
%147 = load i8, i8* %133
store i8 %147, i8* %143
br label %379
148: ; preds = %138
%149 = call i32 (i32, i8*, ...) @Debug(i32 1, i8* getelementptr inbounds ([43 x i8], [43 x i8]* @.str.9, i64 0, i64 0), i8* %1)
br label %388
150: ; preds = %10
%151 = getelementptr inbounds i8, i8* %12, i64 1
%152 = load i8, i8* %151
%153 = icmp eq i8 %152, 0
br i1 %153, label %158, label %154
154: ; preds = %150
%155 = getelementptr inbounds i8, i8* %12, i64 2
%156 = load i8, i8* %155
%157 = icmp eq i8 %156, 0
br i1 %157, label %158, label %160
158: ; preds = %154, %150
%159 = call i32 (i32, i8*, ...) @Debug(i32 1, i8* getelementptr inbounds ([41 x i8], [41 x i8]* @.str.10, i64 0, i64 0), i8* %1)
br label %388
160: ; preds = %154
%161 = call i32 @Char2Int(i8 signext %152)
%162 = icmp slt i32 %161, 0
br i1 %162, label %165, label %163
163: ; preds = %160
%164 = icmp eq i32 %161, 0
br i1 %164, label %178, label %167
165: ; preds = %160
%166 = call i32 (i32, i8*, ...) @Debug(i32 1, i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str.11, i64 0, i64 0), i8* %1)
br label %388
167: ; preds = %163, %173
%168 = phi i8* [ %176, %173 ], [ %4, %163 ]
%169 = phi i8* [ %175, %173 ], [ getelementptr inbounds ([1024 x i8], [1024 x i8]* @Mangle.area, i64 0, i64 0), %163 ]
%170 = phi i32 [ %174, %173 ], [ %161, %163 ]
%171 = load i8, i8* %169
%172 = icmp eq i8 %171, 0
br i1 %172, label %178, label %173
173: ; preds = %167
%174 = add nsw i32 %170, -1
%175 = getelementptr inbounds i8, i8* %169, i64 1
%176 = getelementptr inbounds i8, i8* %168, i64 1
store i8 %171, i8* %168
%177 = icmp eq i32 %174, 0
br i1 %177, label %178, label %167
178: ; preds = %173, %167, %163
%179 = phi i8* [ getelementptr inbounds ([1024 x i8], [1024 x i8]* @Mangle.area, i64 0, i64 0), %163 ], [ %169, %167 ], [ %175, %173 ]
%180 = phi i8* [ %4, %163 ], [ %168, %167 ], [ %176, %173 ]
%181 = load i8, i8* %155
%182 = getelementptr inbounds i8, i8* %180, i64 1
store i8 %181, i8* %180
%183 = call i32 @strcpy(i8* %182, i8* %179)
%184 = call i32 @strcpy(i8* getelementptr inbounds ([1024 x i8], [1024 x i8]* @Mangle.area, i64 0, i64 0), i8* %4)
br label %379
185: ; preds = %10
%186 = getelementptr inbounds i8, i8* %12, i64 1
%187 = load i8, i8* %186
switch i8 %187, label %194 [
i8 0, label %192
i8 63, label %188
]
188: ; preds = %185
%189 = getelementptr inbounds i8, i8* %12, i64 2
%190 = load i8, i8* %189
%191 = icmp eq i8 %190, 0
br i1 %191, label %192, label %197
192: ; preds = %185, %188
%193 = call i32 (i32, i8*, ...) @Debug(i32 1, i8* getelementptr inbounds ([42 x i8], [42 x i8]* @.str.12, i64 0, i64 0), i8* %1)
br label %388
194: ; preds = %185
%195 = call i8* @Purge(i8* getelementptr inbounds ([1024 x i8], [1024 x i8]* @Mangle.area, i64 0, i64 0), i8 signext %187)
%196 = call i32 @strcpy(i8* getelementptr inbounds ([1024 x i8], [1024 x i8]* @Mangle.area, i64 0, i64 0), i8* %195)
br label %379
197: ; preds = %188
%198 = call i8* @PolyPurge(i8* getelementptr inbounds ([1024 x i8], [1024 x i8]* @Mangle.area, i64 0, i64 0), i8 signext %190)
%199 = call i32 @strcpy(i8* getelementptr inbounds ([1024 x i8], [1024 x i8]* @Mangle.area, i64 0, i64 0), i8* %198)
br label %379
200: ; preds = %10
%201 = getelementptr inbounds i8, i8* %12, i64 1
%202 = load i8, i8* %201
%203 = icmp eq i8 %202, 0
br i1 %203, label %214, label %204
204: ; preds = %200
%205 = getelementptr inbounds i8, i8* %12, i64 2
%206 = load i8, i8* %205
%207 = icmp eq i8 %206, 0
br i1 %207, label %214, label %208
208: ; preds = %204
%209 = icmp eq i8 %202, 63
br i1 %209, label %210, label %216
210: ; preds = %208
%211 = getelementptr inbounds i8, i8* %12, i64 3
%212 = load i8, i8* %211
%213 = icmp eq i8 %212, 0
br i1 %213, label %214, label %219
214: ; preds = %210, %204, %200
%215 = call i32 (i32, i8*, ...) @Debug(i32 1, i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str.13, i64 0, i64 0), i8* %1)
br label %388
216: ; preds = %208
%217 = call i8* @Substitute(i8* getelementptr inbounds ([1024 x i8], [1024 x i8]* @Mangle.area, i64 0, i64 0), i8 signext %202, i8 signext %206)
%218 = call i32 @strcpy(i8* getelementptr inbounds ([1024 x i8], [1024 x i8]* @Mangle.area, i64 0, i64 0), i8* %217)
br label %379
219: ; preds = %210
%220 = call i8* @PolySubst(i8* getelementptr inbounds ([1024 x i8], [1024 x i8]* @Mangle.area, i64 0, i64 0), i8 signext %206, i8 signext %212)
%221 = call i32 @strcpy(i8* getelementptr inbounds ([1024 x i8], [1024 x i8]* @Mangle.area, i64 0, i64 0), i8* %220)
br label %379
222: ; preds = %10
%223 = getelementptr inbounds i8, i8* %12, i64 1
%224 = load i8, i8* %223
switch i8 %224, label %231 [
i8 0, label %229
i8 63, label %225
]
225: ; preds = %222
%226 = getelementptr inbounds i8, i8* %12, i64 2
%227 = load i8, i8* %226
%228 = icmp eq i8 %227, 0
br i1 %228, label %229, label %234
229: ; preds = %222, %225
%230 = call i32 (i32, i8*, ...) @Debug(i32 1, i8* getelementptr inbounds ([38 x i8], [38 x i8]* @.str.14, i64 0, i64 0), i8* %1)
br label %388
231: ; preds = %222
%232 = call i32 @strchr(i8* getelementptr inbounds ([1024 x i8], [1024 x i8]* @Mangle.area, i64 0, i64 0), i8 signext %224)
%233 = icmp eq i32 %232, 0
br i1 %233, label %388, label %379
234: ; preds = %225
%235 = call i32 @PolyStrchr(i8* getelementptr inbounds ([1024 x i8], [1024 x i8]* @Mangle.area, i64 0, i64 0), i8 signext %227)
%236 = icmp eq i32 %235, 0
br i1 %236, label %388, label %379
237: ; preds = %10
%238 = getelementptr inbounds i8, i8* %12, i64 1
%239 = load i8, i8* %238
switch i8 %239, label %246 [
i8 0, label %244
i8 63, label %240
]
240: ; preds = %237
%241 = getelementptr inbounds i8, i8* %12, i64 2
%242 = load i8, i8* %241
%243 = icmp eq i8 %242, 0
br i1 %243, label %244, label %249
244: ; preds = %237, %240
%245 = call i32 (i32, i8*, ...) @Debug(i32 1, i8* getelementptr inbounds ([38 x i8], [38 x i8]* @.str.15, i64 0, i64 0), i8* %1)
br label %388
246: ; preds = %237
%247 = call i32 @strchr(i8* getelementptr inbounds ([1024 x i8], [1024 x i8]* @Mangle.area, i64 0, i64 0), i8 signext %239)
%248 = icmp eq i32 %247, 0
br i1 %248, label %379, label %388
249: ; preds = %240
%250 = call i32 @PolyStrchr(i8* getelementptr inbounds ([1024 x i8], [1024 x i8]* @Mangle.area, i64 0, i64 0), i8 signext %242)
%251 = icmp eq i32 %250, 0
br i1 %251, label %379, label %388
252: ; preds = %10
%253 = getelementptr inbounds i8, i8* %12, i64 1
%254 = load i8, i8* %253
%255 = icmp eq i8 %254, 0
br i1 %255, label %263, label %256
256: ; preds = %252
%257 = getelementptr inbounds i8, i8* %12, i64 2
%258 = load i8, i8* %257
switch i8 %258, label %265 [
i8 0, label %263
i8 63, label %259
]
259: ; preds = %256
%260 = getelementptr inbounds i8, i8* %12, i64 3
%261 = load i8, i8* %260
%262 = icmp eq i8 %261, 0
br i1 %262, label %263, label %265
263: ; preds = %256, %259, %252
%264 = call i32 (i32, i8*, ...) @Debug(i32 1, i8* getelementptr inbounds ([38 x i8], [38 x i8]* @.str.16, i64 0, i64 0), i8* %1)
br label %388
265: ; preds = %256, %259
%266 = call i32 @Char2Int(i8 signext %254)
%267 = icmp slt i32 %266, 0
br i1 %267, label %268, label %270
268: ; preds = %265
%269 = call i32 (i32, i8*, ...) @Debug(i32 1, i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str.17, i64 0, i64 0), i8* %1)
br label %388
270: ; preds = %265
%271 = load i8, i8* %257
%272 = icmp eq i8 %271, 63
br i1 %272, label %278, label %273
273: ; preds = %270
%274 = zext i32 %266 to i64
%275 = getelementptr inbounds [1024 x i8], [1024 x i8]* @Mangle.area, i64 0, i64 %274
%276 = load i8, i8* %275
%277 = icmp eq i8 %276, %271
br i1 %277, label %379, label %388
278: ; preds = %270
%279 = getelementptr inbounds i8, i8* %12, i64 3
%280 = load i8, i8* %279
%281 = zext i32 %266 to i64
%282 = getelementptr inbounds [1024 x i8], [1024 x i8]* @Mangle.area, i64 0, i64 %281
%283 = load i8, i8* %282
%284 = call i32 @MatchClass(i8 signext %280, i8 signext %283)
%285 = icmp eq i32 %284, 0
br i1 %285, label %388, label %379
286: ; preds = %10
%287 = load i8, i8* getelementptr inbounds ([1024 x i8], [1024 x i8]* @Mangle.area, i64 0, i64 0)
%288 = icmp eq i8 %287, 0
br i1 %288, label %379, label %289
289: ; preds = %286
%290 = load i8, i8* getelementptr inbounds ([1024 x i8], [1024 x i8]* @Mangle.area, i64 0, i64 1)
%291 = icmp eq i8 %290, 0
br i1 %291, label %301, label %292
292: ; preds = %289, %292
%293 = phi i64 [ %297, %292 ], [ 1, %289 ]
%294 = phi i8 [ %299, %292 ], [ %290, %289 ]
%295 = add nsw i64 %293, -1
%296 = getelementptr inbounds [1024 x i8], [1024 x i8]* @Mangle.area, i64 0, i64 %295
store i8 %294, i8* %296
%297 = add nuw nsw i64 %293, 1
%298 = getelementptr inbounds [1024 x i8], [1024 x i8]* @Mangle.area, i64 0, i64 %297
%299 = load i8, i8* %298
%300 = icmp eq i8 %299, 0
br i1 %300, label %301, label %292
301: ; preds = %292, %289
%302 = phi i64 [ 1, %289 ], [ %297, %292 ]
%303 = shl i64 %302, 32
%304 = add i64 %303, -4294967296
%305 = ashr exact i64 %304, 32
%306 = getelementptr inbounds [1024 x i8], [1024 x i8]* @Mangle.area, i64 0, i64 %305
store i8 0, i8* %306
br label %379
307: ; preds = %10
%308 = load i8, i8* getelementptr inbounds ([1024 x i8], [1024 x i8]* @Mangle.area, i64 0, i64 0)
%309 = icmp eq i8 %308, 0
br i1 %309, label %379, label %310
310: ; preds = %307, %310
%311 = phi i64 [ %315, %310 ], [ 1, %307 ]
%312 = getelementptr inbounds [1024 x i8], [1024 x i8]* @Mangle.area, i64 0, i64 %311
%313 = load i8, i8* %312
%314 = icmp eq i8 %313, 0
%315 = add nuw i64 %311, 1
br i1 %314, label %316, label %310
316: ; preds = %310
%317 = shl i64 %311, 32
%318 = add i64 %317, -4294967296
%319 = ashr exact i64 %318, 32
%320 = getelementptr inbounds [1024 x i8], [1024 x i8]* @Mangle.area, i64 0, i64 %319
store i8 0, i8* %320
br label %379
321: ; preds = %10
%322 = getelementptr inbounds i8, i8* %12, i64 1
%323 = load i8, i8* %322
switch i8 %323, label %330 [
i8 0, label %328
i8 63, label %324
]
324: ; preds = %321
%325 = getelementptr inbounds i8, i8* %12, i64 2
%326 = load i8, i8* %325
%327 = icmp eq i8 %326, 0
br i1 %327, label %328, label %333
328: ; preds = %321, %324
%329 = call i32 (i32, i8*, ...) @Debug(i32 1, i8* getelementptr inbounds ([38 x i8], [38 x i8]* @.str.18, i64 0, i64 0), i8* %1)
br label %388
330: ; preds = %321
%331 = load i8, i8* getelementptr inbounds ([1024 x i8], [1024 x i8]* @Mangle.area, i64 0, i64 0)
%332 = icmp eq i8 %331, %323
br i1 %332, label %337, label %388
333: ; preds = %324
%334 = load i8, i8* getelementptr inbounds ([1024 x i8], [1024 x i8]* @Mangle.area, i64 0, i64 0)
%335 = call i32 @MatchClass(i8 signext %326, i8 signext %334)
%336 = icmp eq i32 %335, 0
br i1 %336, label %388, label %337
337: ; preds = %10, %333, %330
%338 = phi i8* [ %322, %330 ], [ %325, %333 ], [ %12, %10 ]
%339 = getelementptr inbounds i8, i8* %338, i64 1
%340 = load i8, i8* %339
switch i8 %340, label %345 [
i8 0, label %346
i8 63, label %341
]
341: ; preds = %337
%342 = getelementptr inbounds i8, i8* %338, i64 2
%343 = load i8, i8* %342
%344 = icmp eq i8 %343, 0
br i1 %344, label %346, label %345
345: ; preds = %337, %341
br label %348
346: ; preds = %337, %341
%347 = call i32 (i32, i8*, ...) @Debug(i32 1, i8* getelementptr inbounds ([38 x i8], [38 x i8]* @.str.19, i64 0, i64 0), i8* %1)
br label %388
348: ; preds = %345, %348
%349 = phi i64 [ %353, %348 ], [ 0, %345 ]
%350 = getelementptr inbounds [1024 x i8], [1024 x i8]* @Mangle.area, i64 0, i64 %349
%351 = load i8, i8* %350
%352 = icmp eq i8 %351, 0
%353 = add nuw i64 %349, 1
br i1 %352, label %354, label %348
354: ; preds = %348
%355 = trunc i64 %349 to i32
%356 = icmp eq i32 %355, 0
br i1 %356, label %388, label %357
357: ; preds = %354
%358 = add nsw i32 %355, -1
%359 = icmp eq i8 %340, 63
br i1 %359, label %365, label %360
360: ; preds = %357
%361 = zext i32 %358 to i64
%362 = getelementptr inbounds [1024 x i8], [1024 x i8]* @Mangle.area, i64 0, i64 %361
%363 = load i8, i8* %362
%364 = icmp eq i8 %363, %340
br i1 %364, label %375, label %388
365: ; preds = %357
%366 = getelementptr inbounds i8, i8* %338, i64 2
%367 = load i8, i8* %366
%368 = zext i32 %358 to i64
%369 = getelementptr inbounds [1024 x i8], [1024 x i8]* @Mangle.area, i64 0, i64 %368
%370 = load i8, i8* %369
%371 = call i32 @MatchClass(i8 signext %367, i8 signext %370)
%372 = icmp eq i32 %371, 0
br i1 %372, label %388, label %373
373: ; preds = %365
%374 = load i8, i8* %366
br label %375
375: ; preds = %10, %373, %360
%376 = phi i8 [ %340, %360 ], [ %374, %373 ], [ %11, %10 ]
%377 = sext i8 %376 to i32
%378 = call i32 (i32, i8*, ...) @Debug(i32 1, i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.20, i64 0, i64 0), i32 %377, i8* %1)
br label %388
379: ; preds = %178, %124, %141, %146, %278, %273, %249, %234, %14, %17, %20, %23, %26, %29, %32, %10, %71, %85, %46, %61, %194, %197, %216, %219, %231, %246, %301, %286, %316, %307
%380 = phi i8* [ %12, %316 ], [ %12, %307 ], [ %12, %301 ], [ %12, %286 ], [ %238, %246 ], [ %223, %231 ], [ %205, %216 ], [ %211, %219 ], [ %186, %194 ], [ %189, %197 ], [ %155, %178 ], [ %91, %124 ], [ %75, %85 ], [ %66, %71 ], [ %51, %61 ], [ %36, %46 ], [ %12, %32 ], [ %12, %29 ], [ %12, %26 ], [ %12, %23 ], [ %12, %20 ], [ %12, %17 ], [ %12, %14 ], [ %12, %10 ], [ %226, %234 ], [ %241, %249 ], [ %257, %273 ], [ %279, %278 ], [ %133, %146 ], [ %133, %141 ]
%381 = getelementptr inbounds i8, i8* %380, i64 1
%382 = load i8, i8* %381
%383 = icmp eq i8 %382, 0
br i1 %383, label %384, label %10
384: ; preds = %379, %2
%385 = load i8, i8* getelementptr inbounds ([1024 x i8], [1024 x i8]* @Mangle.area, i64 0, i64 0)
%386 = icmp eq i8 %385, 0
%387 = select i1 %386, i8* null, i8* getelementptr inbounds ([1024 x i8], [1024 x i8]* @Mangle.area, i64 0, i64 0)
br label %388
388: ; preds = %278, %273, %249, %246, %234, %231, %61, %46, %365, %360, %354, %268, %165, %148, %103, %384, %333, %330, %375, %346, %328, %263, %244, %229, %214, %192, %158, %136, %94, %78, %69, %59, %54, %44, %39
%389 = phi i8* [ null, %375 ], [ null, %346 ], [ null, %328 ], [ null, %263 ], [ null, %244 ], [ null, %229 ], [ null, %214 ], [ null, %192 ], [ null, %158 ], [ null, %148 ], [ null, %136 ], [ null, %94 ], [ null, %78 ], [ null, %69 ], [ null, %59 ], [ null, %54 ], [ null, %44 ], [ null, %39 ], [ null, %330 ], [ null, %333 ], [ %387, %384 ], [ null, %103 ], [ null, %165 ], [ null, %268 ], [ null, %354 ], [ null, %360 ], [ null, %365 ], [ null, %46 ], [ null, %61 ], [ null, %231 ], [ null, %234 ], [ null, %246 ], [ null, %249 ], [ null, %273 ], [ null, %278 ]
ret i8* %389
}