void pretraducir(char *origS, char *newS) {
  unsigned int i = 0, j = 0;
  while (origS[i] != '\0') {
    if (origS[i] == 'i') {
      if (!esOperador(origS[i + 1]) && origS[i + 1] != '\0' &&
          origS[i + 1] != ')' && origS[i + 1] != '!') {
        newS[j++] = origS[i++];
        newS[j++] = '*';
      } else
        newS[j++] = origS[i++];
    } else if (strncmp(&origS[i], "resComp", strlen("resComp")) == 0) {
      strncpy(&newS[j], "resComp", strlen("resComp"));
      j += strlen("resComp");
      i += strlen("resComp");
    } else if (strncmp(&origS[i], "res", strlen("res")) == 0 ||
               strncmp(&origS[i], "ans", strlen("ans")) == 0) {
      strncpy(&newS[j], "res", strlen("res"));
      j += strlen("res");
      i += strlen("res");
    } else if (strncmp(&origS[i], "sqrt", strlen("sqrt")) == 0) {
      newS[j++] = 'a';
      i += strlen("sqrt");
    } else if (strncmp(&origS[i], "sin", strlen("sin")) == 0 ||
               strncmp(&origS[i], "sen", strlen("sen")) == 0) {
      newS[j++] = 'b';
      i += strlen("sin");
    } else if (strncmp(&origS[i], "cos", strlen("cos")) == 0) {
      newS[j++] = 'c';
      i += strlen("cos");
    } else if (strncmp(&origS[i], "tan", strlen("tan")) == 0) {
      newS[j++] = 'd';
      i += strlen("tan");
    } else if (strncmp(&origS[i], "asin", strlen("asin")) == 0 ||
               strncmp(&origS[i], "asen", strlen("asen")) == 0) {
      newS[j++] = 'e';
      i += strlen("asin");
    } else if (strncmp(&origS[i], "acos", strlen("acos")) == 0) {
      newS[j++] = 'f';
      i += strlen("acos");
    } else if (strncmp(&origS[i], "atan", strlen("atan")) == 0) {
      newS[j++] = 'g';
      i += strlen("atan");
    } else if (strncmp(&origS[i], "exp", strlen("exp")) == 0) {
      newS[j++] = 'h';
      i += strlen("exp");
    } else if (strncmp(&origS[i], "ln", strlen("ln")) == 0) {
      newS[j++] = 'z';
      i += strlen("ln");
    } else if (strncmp(&origS[i], "log", strlen("log")) == 0) {
      newS[j++] = 'k';
      i += strlen("log");
    } else if (strncmp(&origS[i], "sh", strlen("sh")) == 0) {
      newS[j++] = 'l';
      i += strlen("sh");
    } else if (strncmp(&origS[i], "ch", strlen("ch")) == 0) {
      newS[j++] = 'm';
      i += strlen("ch");
    } else if (strncmp(&origS[i], "th", strlen("th")) == 0) {
      newS[j++] = 'n';
      i += strlen("th");
    } else if (strncmp(&origS[i], "ash", strlen("ash")) == 0) {
      newS[j++] = 'o';
      i += strlen("ash");
    } else if (strncmp(&origS[i], "ach", strlen("ach")) == 0) {
      newS[j++] = 'p';
      i += strlen("ach");
    } else if (strncmp(&origS[i], "ath", strlen("ath")) == 0) {
      newS[j++] = 'q';
      i += strlen("ath");
    } else if (strncmp(&origS[i], "pow", strlen("pow")) == 0) {
      newS[j++] = 'r';
      i += strlen("pow");
    } else if (strncmp(&origS[i], "gamma'", strlen("gamma'")) == 0) {
      newS[j++] = 'w';
      i += strlen("gamma'");
    } else if (strncmp(&origS[i], "factorial", strlen("factorial")) == 0) {
      newS[j++] = 't';
      i += strlen("factorial");
    } else if (strncmp(&origS[i], "betha", strlen("betha")) == 0) {
      newS[j++] = 'u';
      i += strlen("betha");
    } else if (strncmp(&origS[i], "prim", strlen("prim")) == 0) {
      newS[j++] = 'v';
      i += strlen("prim");
    } else if (strncmp(&origS[i], "gamma", strlen("gamma")) == 0) {
      newS[j++] = 's';
      i += strlen("gamma");
    } else if (strncmp(&origS[i], "pi", strlen("pi")) == 0) {
      newS[j] = 'U';
      j++;
      i += strlen("pi");
    } else if (strncmp(&origS[i], "e", strlen("e")) == 0) {
      newS[j] = 'V';
      j++;
      i += strlen("e");
    } else if (strncmp(&origS[i], "r2", strlen("r2")) == 0) {
      newS[j] = 'W';
      j++;
      i += strlen("r2");
    } else if (i == 0 && origS[i] == '-') {
      newS[j++] = '0';
      newS[j++] = origS[i++];
    } else if (origS[i] == '(' && origS[i + 1] == '-') {
      newS[j++] = origS[i++];
      newS[j++] = '0';
      newS[j++] = origS[i++];
    } else if ((origS[i] == ')') && (origS[i + 1] == '(')) {
      newS[j++] = origS[i++];
      newS[j++] = '*';
    } else if (isalpha(origS[i]) && isalpha(origS[i + 1])) {
      newS[j++] = toupper(origS[i++]);
      newS[j++] = '*';
    } else if (isalpha(origS[i]) && origS[i + 1] == '(') {
      newS[j++] = toupper(origS[i++]);
      newS[j++] = '*';
    } else if (origS[i] == ')' && isalpha(origS[i + 1])) {
      newS[j++] = origS[i++];
      newS[j++] = '*';
    } else if (isdigit(origS[i]) && origS[i + 1] == '(') {
      newS[j++] = origS[i++];
      newS[j++] = '*';
    } else if (isdigit(origS[i]) && isalpha(origS[i + 1])) {
      newS[j++] = origS[i++];
      newS[j++] = '*';
    } else if (isalpha(origS[i]) && isdigit(origS[i + 1])) {
      newS[j++] = origS[i++];
      newS[j++] = '*';
    } else if (isalpha(origS[i])) {
      newS[j++] = toupper(origS[i++]);
    } else
      newS[j++] = origS[i++];
  }
  newS[j] = '\0';
  return;
}


x86 assembly (clang, -O0):
<pretraducir>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movl   $0x0,-0x14(%rbp)
movl   $0x0,-0x18(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
movsbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
je     2012 <pretraducir+0xeb2>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
movsbl (%rax,%rcx,1),%eax
cmp    $0x69,%eax
jne    1280 <pretraducir+0x120>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
movsbl (%rax,%rcx,1),%edi
mov    $0x0,%al
call   1080 <esOperador@plt>
cmp    $0x0,%eax
jne    1253 <pretraducir+0xf3>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
movsbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
je     1253 <pretraducir+0xf3>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
movsbl (%rax,%rcx,1),%eax
cmp    $0x29,%eax
je     1253 <pretraducir+0xf3>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
movsbl (%rax,%rcx,1),%eax
cmp    $0x21,%eax
je     1253 <pretraducir+0xf3>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x14(%rbp)
mov    %ecx,%ecx
mov    (%rax,%rcx,1),%dl
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x18(%rbp)
mov    %ecx,%ecx
mov    %dl,(%rax,%rcx,1)
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x18(%rbp)
mov    %ecx,%ecx
movb   $0x2a,(%rax,%rcx,1)
jmp    127b <pretraducir+0x11b>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x14(%rbp)
mov    %ecx,%ecx
mov    (%rax,%rcx,1),%dl
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x18(%rbp)
mov    %ecx,%ecx
mov    %dl,(%rax,%rcx,1)
jmp    200d <pretraducir+0xead>
mov    -0x8(%rbp),%rdi
mov    -0x14(%rbp),%eax
add    %rax,%rdi
lea    0x1d6f(%rip),%rsi
mov    $0x7,%edx
call   1040 <strncmp@plt>
cmp    $0x0,%eax
jne    12d8 <pretraducir+0x178>
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%eax
add    %rax,%rdi
lea    0x1d4b(%rip),%rsi
mov    $0x7,%edx
call   1030 <strncpy@plt>
mov    -0x18(%rbp),%eax
add    $0x7,%rax
mov    %eax,-0x18(%rbp)
mov    -0x14(%rbp),%eax
add    $0x7,%rax
mov    %eax,-0x14(%rbp)
jmp    2008 <pretraducir+0xea8>
mov    -0x8(%rbp),%rdi
mov    -0x14(%rbp),%eax
add    %rax,%rdi
lea    0x1d1f(%rip),%rsi
mov    $0x3,%edx
call   1040 <strncmp@plt>
cmp    $0x0,%eax
je     1320 <pretraducir+0x1c0>
mov    -0x8(%rbp),%rdi
mov    -0x14(%rbp),%eax
add    %rax,%rdi
lea    0x1cff(%rip),%rsi
mov    $0x3,%edx
call   1040 <strncmp@plt>
cmp    $0x0,%eax
jne    1354 <pretraducir+0x1f4>
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%eax
add    %rax,%rdi
lea    0x1cd7(%rip),%rsi
mov    $0x3,%edx
call   1030 <strncpy@plt>
mov    -0x18(%rbp),%eax
add    $0x3,%rax
mov    %eax,-0x18(%rbp)
mov    -0x14(%rbp),%eax
add    $0x3,%rax
mov    %eax,-0x14(%rbp)
jmp    2003 <pretraducir+0xea3>
mov    -0x8(%rbp),%rdi
mov    -0x14(%rbp),%eax
add    %rax,%rdi
lea    0x1cab(%rip),%rsi
mov    $0x4,%edx
call   1040 <strncmp@plt>
cmp    $0x0,%eax
jne    139c <pretraducir+0x23c>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x18(%rbp)
mov    %ecx,%ecx
movb   $0x61,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0x4,%rax
mov    %eax,-0x14(%rbp)
jmp    1ffe <pretraducir+0xe9e>
mov    -0x8(%rbp),%rdi
mov    -0x14(%rbp),%eax
add    %rax,%rdi
lea    0x1c69(%rip),%rsi
mov    $0x3,%edx
call   1040 <strncmp@plt>
cmp    $0x0,%eax
je     13e4 <pretraducir+0x284>
mov    -0x8(%rbp),%rdi
mov    -0x14(%rbp),%eax
add    %rax,%rdi
lea    0x1c4a(%rip),%rsi
mov    $0x3,%edx
call   1040 <strncmp@plt>
cmp    $0x0,%eax
jne    1408 <pretraducir+0x2a8>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x18(%rbp)
mov    %ecx,%ecx
movb   $0x62,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0x3,%rax
mov    %eax,-0x14(%rbp)
jmp    1ff9 <pretraducir+0xe99>
mov    -0x8(%rbp),%rdi
mov    -0x14(%rbp),%eax
add    %rax,%rdi
lea    0x1c07(%rip),%rsi
mov    $0x3,%edx
call   1040 <strncmp@plt>
cmp    $0x0,%eax
jne    1450 <pretraducir+0x2f0>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x18(%rbp)
mov    %ecx,%ecx
movb   $0x63,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0x3,%rax
mov    %eax,-0x14(%rbp)
jmp    1ff4 <pretraducir+0xe94>
mov    -0x8(%rbp),%rdi
mov    -0x14(%rbp),%eax
add    %rax,%rdi
lea    0x1bc4(%rip),%rsi
mov    $0x3,%edx
call   1040 <strncmp@plt>
cmp    $0x0,%eax
jne    1498 <pretraducir+0x338>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x18(%rbp)
mov    %ecx,%ecx
movb   $0x64,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0x3,%rax
mov    %eax,-0x14(%rbp)
jmp    1fef <pretraducir+0xe8f>
mov    -0x8(%rbp),%rdi
mov    -0x14(%rbp),%eax
add    %rax,%rdi
lea    0x1b6c(%rip),%rsi
mov    $0x4,%edx
call   1040 <strncmp@plt>
cmp    $0x0,%eax
je     14e0 <pretraducir+0x380>
mov    -0x8(%rbp),%rdi
mov    -0x14(%rbp),%eax
add    %rax,%rdi
lea    0x1b4d(%rip),%rsi
mov    $0x4,%edx
call   1040 <strncmp@plt>
cmp    $0x0,%eax
jne    1504 <pretraducir+0x3a4>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x18(%rbp)
mov    %ecx,%ecx
movb   $0x65,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0x4,%rax
mov    %eax,-0x14(%rbp)
jmp    1fea <pretraducir+0xe8a>
mov    -0x8(%rbp),%rdi
mov    -0x14(%rbp),%eax
add    %rax,%rdi
lea    0x1b0a(%rip),%rsi
mov    $0x4,%edx
call   1040 <strncmp@plt>
cmp    $0x0,%eax
jne    154c <pretraducir+0x3ec>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x18(%rbp)
mov    %ecx,%ecx
movb   $0x66,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0x4,%rax
mov    %eax,-0x14(%rbp)
jmp    1fe5 <pretraducir+0xe85>
mov    -0x8(%rbp),%rdi
mov    -0x14(%rbp),%eax
add    %rax,%rdi
lea    0x1ac7(%rip),%rsi
mov    $0x4,%edx
call   1040 <strncmp@plt>
cmp    $0x0,%eax
jne    1594 <pretraducir+0x434>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x18(%rbp)
mov    %ecx,%ecx
movb   $0x67,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0x4,%rax
mov    %eax,-0x14(%rbp)
jmp    1fe0 <pretraducir+0xe80>
mov    -0x8(%rbp),%rdi
mov    -0x14(%rbp),%eax
add    %rax,%rdi
lea    0x1a84(%rip),%rsi
mov    $0x3,%edx
call   1040 <strncmp@plt>
cmp    $0x0,%eax
jne    15dc <pretraducir+0x47c>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x18(%rbp)
mov    %ecx,%ecx
movb   $0x68,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0x3,%rax
mov    %eax,-0x14(%rbp)
jmp    1fdb <pretraducir+0xe7b>
mov    -0x8(%rbp),%rdi
mov    -0x14(%rbp),%eax
add    %rax,%rdi
lea    0x1a40(%rip),%rsi
mov    $0x2,%edx
call   1040 <strncmp@plt>
cmp    $0x0,%eax
jne    1624 <pretraducir+0x4c4>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x18(%rbp)
mov    %ecx,%ecx
movb   $0x7a,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0x2,%rax
mov    %eax,-0x14(%rbp)
jmp    1fd6 <pretraducir+0xe76>
mov    -0x8(%rbp),%rdi
mov    -0x14(%rbp),%eax
add    %rax,%rdi
lea    0x19fb(%rip),%rsi
mov    $0x3,%edx
call   1040 <strncmp@plt>
cmp    $0x0,%eax
jne    166c <pretraducir+0x50c>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x18(%rbp)
mov    %ecx,%ecx
movb   $0x6b,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0x3,%rax
mov    %eax,-0x14(%rbp)
jmp    1fd1 <pretraducir+0xe71>
mov    -0x8(%rbp),%rdi
mov    -0x14(%rbp),%eax
add    %rax,%rdi
lea    0x19b8(%rip),%rsi
mov    $0x2,%edx
call   1040 <strncmp@plt>
cmp    $0x0,%eax
jne    16b4 <pretraducir+0x554>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x18(%rbp)
mov    %ecx,%ecx
movb   $0x6c,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0x2,%rax
mov    %eax,-0x14(%rbp)
jmp    1fcc <pretraducir+0xe6c>
mov    -0x8(%rbp),%rdi
mov    -0x14(%rbp),%eax
add    %rax,%rdi
lea    0x1974(%rip),%rsi
mov    $0x2,%edx
call   1040 <strncmp@plt>
cmp    $0x0,%eax
jne    16fc <pretraducir+0x59c>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x18(%rbp)
mov    %ecx,%ecx
movb   $0x6d,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0x2,%rax
mov    %eax,-0x14(%rbp)
jmp    1fc7 <pretraducir+0xe67>
mov    -0x8(%rbp),%rdi
mov    -0x14(%rbp),%eax
add    %rax,%rdi
lea    0x1930(%rip),%rsi
mov    $0x2,%edx
call   1040 <strncmp@plt>
cmp    $0x0,%eax
jne    1744 <pretraducir+0x5e4>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x18(%rbp)
mov    %ecx,%ecx
movb   $0x6e,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0x2,%rax
mov    %eax,-0x14(%rbp)
jmp    1fc2 <pretraducir+0xe62>
mov    -0x8(%rbp),%rdi
mov    -0x14(%rbp),%eax
add    %rax,%rdi
lea    0x18df(%rip),%rsi
mov    $0x3,%edx
call   1040 <strncmp@plt>
cmp    $0x0,%eax
jne    178c <pretraducir+0x62c>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x18(%rbp)
mov    %ecx,%ecx
movb   $0x6f,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0x3,%rax
mov    %eax,-0x14(%rbp)
jmp    1fbd <pretraducir+0xe5d>
mov    -0x8(%rbp),%rdi
mov    -0x14(%rbp),%eax
add    %rax,%rdi
lea    0x189b(%rip),%rsi
mov    $0x3,%edx
call   1040 <strncmp@plt>
cmp    $0x0,%eax
jne    17d4 <pretraducir+0x674>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x18(%rbp)
mov    %ecx,%ecx
movb   $0x70,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0x3,%rax
mov    %eax,-0x14(%rbp)
jmp    1fb8 <pretraducir+0xe58>
mov    -0x8(%rbp),%rdi
mov    -0x14(%rbp),%eax
add    %rax,%rdi
lea    0x1857(%rip),%rsi
mov    $0x3,%edx
call   1040 <strncmp@plt>
cmp    $0x0,%eax
jne    181c <pretraducir+0x6bc>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x18(%rbp)
mov    %ecx,%ecx
movb   $0x71,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0x3,%rax
mov    %eax,-0x14(%rbp)
jmp    1fb3 <pretraducir+0xe53>
mov    -0x8(%rbp),%rdi
mov    -0x14(%rbp),%eax
add    %rax,%rdi
lea    0x1813(%rip),%rsi
mov    $0x3,%edx
call   1040 <strncmp@plt>
cmp    $0x0,%eax
jne    1864 <pretraducir+0x704>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x18(%rbp)
mov    %ecx,%ecx
movb   $0x72,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0x3,%rax
mov    %eax,-0x14(%rbp)
jmp    1fae <pretraducir+0xe4e>
mov    -0x8(%rbp),%rdi
mov    -0x14(%rbp),%eax
add    %rax,%rdi
lea    0x17cf(%rip),%rsi
mov    $0x6,%edx
call   1040 <strncmp@plt>
cmp    $0x0,%eax
jne    18ac <pretraducir+0x74c>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x18(%rbp)
mov    %ecx,%ecx
movb   $0x77,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0x6,%rax
mov    %eax,-0x14(%rbp)
jmp    1fa9 <pretraducir+0xe49>
mov    -0x8(%rbp),%rdi
mov    -0x14(%rbp),%eax
add    %rax,%rdi
lea    0x178e(%rip),%rsi
mov    $0x9,%edx
call   1040 <strncmp@plt>
cmp    $0x0,%eax
jne    18f4 <pretraducir+0x794>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x18(%rbp)
mov    %ecx,%ecx
movb   $0x74,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0x9,%rax
mov    %eax,-0x14(%rbp)
jmp    1fa4 <pretraducir+0xe44>
mov    -0x8(%rbp),%rdi
mov    -0x14(%rbp),%eax
add    %rax,%rdi
lea    0x1750(%rip),%rsi
mov    $0x5,%edx
call   1040 <strncmp@plt>
cmp    $0x0,%eax
jne    193c <pretraducir+0x7dc>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x18(%rbp)
mov    %ecx,%ecx
movb   $0x75,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0x5,%rax
mov    %eax,-0x14(%rbp)
jmp    1f9f <pretraducir+0xe3f>
mov    -0x8(%rbp),%rdi
mov    -0x14(%rbp),%eax
add    %rax,%rdi
lea    0x170e(%rip),%rsi
mov    $0x4,%edx
call   1040 <strncmp@plt>
cmp    $0x0,%eax
jne    1984 <pretraducir+0x824>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x18(%rbp)
mov    %ecx,%ecx
movb   $0x76,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0x4,%rax
mov    %eax,-0x14(%rbp)
jmp    1f9a <pretraducir+0xe3a>
mov    -0x8(%rbp),%rdi
mov    -0x14(%rbp),%eax
add    %rax,%rdi
lea    0x16cb(%rip),%rsi
mov    $0x5,%edx
call   1040 <strncmp@plt>
cmp    $0x0,%eax
jne    19cc <pretraducir+0x86c>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x18(%rbp)
mov    %ecx,%ecx
movb   $0x73,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0x5,%rax
mov    %eax,-0x14(%rbp)
jmp    1f95 <pretraducir+0xe35>
mov    -0x8(%rbp),%rdi
mov    -0x14(%rbp),%eax
add    %rax,%rdi
lea    0x1689(%rip),%rsi
mov    $0x2,%edx
call   1040 <strncmp@plt>
cmp    $0x0,%eax
jne    1a13 <pretraducir+0x8b3>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
movb   $0x55,(%rax,%rcx,1)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
mov    -0x14(%rbp),%eax
add    $0x2,%rax
mov    %eax,-0x14(%rbp)
jmp    1f90 <pretraducir+0xe30>
mov    -0x8(%rbp),%rdi
mov    -0x14(%rbp),%eax
add    %rax,%rdi
lea    0x1645(%rip),%rsi
mov    $0x1,%edx
call   1040 <strncmp@plt>
cmp    $0x0,%eax
jne    1a5a <pretraducir+0x8fa>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
movb   $0x56,(%rax,%rcx,1)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%rax
mov    %eax,-0x14(%rbp)
jmp    1f8b <pretraducir+0xe2b>
mov    -0x8(%rbp),%rdi
mov    -0x14(%rbp),%eax
add    %rax,%rdi
lea    0x1600(%rip),%rsi
mov    $0x2,%edx
call   1040 <strncmp@plt>
cmp    $0x0,%eax
jne    1aa1 <pretraducir+0x941>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
movb   $0x57,(%rax,%rcx,1)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
mov    -0x14(%rbp),%eax
add    $0x2,%rax
mov    %eax,-0x14(%rbp)
jmp    1f86 <pretraducir+0xe26>
cmpl   $0x0,-0x14(%rbp)
jne    1b01 <pretraducir+0x9a1>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
movsbl (%rax,%rcx,1),%eax
cmp    $0x2d,%eax
jne    1b01 <pretraducir+0x9a1>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x18(%rbp)
mov    %ecx,%ecx
movb   $0x30,(%rax,%rcx,1)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x14(%rbp)
mov    %ecx,%ecx
mov    (%rax,%rcx,1),%dl
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x18(%rbp)
mov    %ecx,%ecx
mov    %dl,(%rax,%rcx,1)
jmp    1f81 <pretraducir+0xe21>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
movsbl (%rax,%rcx,1),%eax
cmp    $0x28,%eax
jne    1b98 <pretraducir+0xa38>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
movsbl (%rax,%rcx,1),%eax
cmp    $0x2d,%eax
jne    1b98 <pretraducir+0xa38>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x14(%rbp)
mov    %ecx,%ecx
mov    (%rax,%rcx,1),%dl
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x18(%rbp)
mov    %ecx,%ecx
mov    %dl,(%rax,%rcx,1)
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x18(%rbp)
mov    %ecx,%ecx
movb   $0x30,(%rax,%rcx,1)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x14(%rbp)
mov    %ecx,%ecx
mov    (%rax,%rcx,1),%dl
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x18(%rbp)
mov    %ecx,%ecx
mov    %dl,(%rax,%rcx,1)
jmp    1f7c <pretraducir+0xe1c>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
movsbl (%rax,%rcx,1),%eax
cmp    $0x29,%eax
jne    1c07 <pretraducir+0xaa7>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
movsbl (%rax,%rcx,1),%eax
cmp    $0x28,%eax
jne    1c07 <pretraducir+0xaa7>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x14(%rbp)
mov    %ecx,%ecx
mov    (%rax,%rcx,1),%dl
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x18(%rbp)
mov    %ecx,%ecx
mov    %dl,(%rax,%rcx,1)
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x18(%rbp)
mov    %ecx,%ecx
movb   $0x2a,(%rax,%rcx,1)
jmp    1f77 <pretraducir+0xe17>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
movsbl (%rax,%rcx,1),%edi
call   1070 <isalpha@plt>
cmp    $0x0,%eax
je     1c88 <pretraducir+0xb28>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
movsbl (%rax,%rcx,1),%edi
call   1070 <isalpha@plt>
cmp    $0x0,%eax
je     1c88 <pretraducir+0xb28>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x14(%rbp)
mov    %ecx,%ecx
movsbl (%rax,%rcx,1),%edi
call   1060 <toupper@plt>
mov    %al,%dl
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x18(%rbp)
mov    %ecx,%ecx
mov    %dl,(%rax,%rcx,1)
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x18(%rbp)
mov    %ecx,%ecx
movb   $0x2a,(%rax,%rcx,1)
jmp    1f72 <pretraducir+0xe12>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
movsbl (%rax,%rcx,1),%edi
call   1070 <isalpha@plt>
cmp    $0x0,%eax
je     1d04 <pretraducir+0xba4>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
movsbl (%rax,%rcx,1),%eax
cmp    $0x28,%eax
jne    1d04 <pretraducir+0xba4>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x14(%rbp)
mov    %ecx,%ecx
movsbl (%rax,%rcx,1),%edi
call   1060 <toupper@plt>
mov    %al,%dl
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x18(%rbp)
mov    %ecx,%ecx
mov    %dl,(%rax,%rcx,1)
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x18(%rbp)
mov    %ecx,%ecx
movb   $0x2a,(%rax,%rcx,1)
jmp    1f6d <pretraducir+0xe0d>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
movsbl (%rax,%rcx,1),%eax
cmp    $0x29,%eax
jne    1d78 <pretraducir+0xc18>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
movsbl (%rax,%rcx,1),%edi
call   1070 <isalpha@plt>
cmp    $0x0,%eax
je     1d78 <pretraducir+0xc18>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x14(%rbp)
mov    %ecx,%ecx
mov    (%rax,%rcx,1),%dl
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x18(%rbp)
mov    %ecx,%ecx
mov    %dl,(%rax,%rcx,1)
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x18(%rbp)
mov    %ecx,%ecx
movb   $0x2a,(%rax,%rcx,1)
jmp    1f68 <pretraducir+0xe08>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
movsbl (%rax,%rcx,1),%edi
call   1050 <isdigit@plt>
cmp    $0x0,%eax
je     1dec <pretraducir+0xc8c>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
movsbl (%rax,%rcx,1),%eax
cmp    $0x28,%eax
jne    1dec <pretraducir+0xc8c>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x14(%rbp)
mov    %ecx,%ecx
mov    (%rax,%rcx,1),%dl
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x18(%rbp)
mov    %ecx,%ecx
mov    %dl,(%rax,%rcx,1)
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x18(%rbp)
mov    %ecx,%ecx
movb   $0x2a,(%rax,%rcx,1)
jmp    1f63 <pretraducir+0xe03>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
movsbl (%rax,%rcx,1),%edi
call   1050 <isdigit@plt>
cmp    $0x0,%eax
je     1e65 <pretraducir+0xd05>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
movsbl (%rax,%rcx,1),%edi
call   1070 <isalpha@plt>
cmp    $0x0,%eax
je     1e65 <pretraducir+0xd05>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x14(%rbp)
mov    %ecx,%ecx
mov    (%rax,%rcx,1),%dl
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x18(%rbp)
mov    %ecx,%ecx
mov    %dl,(%rax,%rcx,1)
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x18(%rbp)
mov    %ecx,%ecx
movb   $0x2a,(%rax,%rcx,1)
jmp    1f5e <pretraducir+0xdfe>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
movsbl (%rax,%rcx,1),%edi
call   1070 <isalpha@plt>
cmp    $0x0,%eax
je     1ede <pretraducir+0xd7e>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
movsbl (%rax,%rcx,1),%edi
call   1050 <isdigit@plt>
cmp    $0x0,%eax
je     1ede <pretraducir+0xd7e>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x14(%rbp)
mov    %ecx,%ecx
mov    (%rax,%rcx,1),%dl
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x18(%rbp)
mov    %ecx,%ecx
mov    %dl,(%rax,%rcx,1)
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x18(%rbp)
mov    %ecx,%ecx
movb   $0x2a,(%rax,%rcx,1)
jmp    1f59 <pretraducir+0xdf9>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
movsbl (%rax,%rcx,1),%edi
call   1070 <isalpha@plt>
cmp    $0x0,%eax
je     1f2c <pretraducir+0xdcc>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x14(%rbp)
mov    %ecx,%ecx
movsbl (%rax,%rcx,1),%edi
call   1060 <toupper@plt>
mov    %al,%dl
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x18(%rbp)
mov    %ecx,%ecx
mov    %dl,(%rax,%rcx,1)
jmp    1f54 <pretraducir+0xdf4>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x14(%rbp)
mov    %ecx,%ecx
mov    (%rax,%rcx,1),%dl
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x18(%rbp)
mov    %ecx,%ecx
mov    %dl,(%rax,%rcx,1)
jmp    1f59 <pretraducir+0xdf9>
jmp    1f5e <pretraducir+0xdfe>
jmp    1f63 <pretraducir+0xe03>
jmp    1f68 <pretraducir+0xe08>
jmp    1f6d <pretraducir+0xe0d>
jmp    1f72 <pretraducir+0xe12>
jmp    1f77 <pretraducir+0xe17>
jmp    1f7c <pretraducir+0xe1c>
jmp    1f81 <pretraducir+0xe21>
jmp    1f86 <pretraducir+0xe26>
jmp    1f8b <pretraducir+0xe2b>
jmp    1f90 <pretraducir+0xe30>
jmp    1f95 <pretraducir+0xe35>
jmp    1f9a <pretraducir+0xe3a>
jmp    1f9f <pretraducir+0xe3f>
jmp    1fa4 <pretraducir+0xe44>
jmp    1fa9 <pretraducir+0xe49>
jmp    1fae <pretraducir+0xe4e>
jmp    1fb3 <pretraducir+0xe53>
jmp    1fb8 <pretraducir+0xe58>
jmp    1fbd <pretraducir+0xe5d>
jmp    1fc2 <pretraducir+0xe62>
jmp    1fc7 <pretraducir+0xe67>
jmp    1fcc <pretraducir+0xe6c>
jmp    1fd1 <pretraducir+0xe71>
jmp    1fd6 <pretraducir+0xe76>
jmp    1fdb <pretraducir+0xe7b>
jmp    1fe0 <pretraducir+0xe80>
jmp    1fe5 <pretraducir+0xe85>
jmp    1fea <pretraducir+0xe8a>
jmp    1fef <pretraducir+0xe8f>
jmp    1ff4 <pretraducir+0xe94>
jmp    1ff9 <pretraducir+0xe99>
jmp    1ffe <pretraducir+0xe9e>
jmp    2003 <pretraducir+0xea3>
jmp    2008 <pretraducir+0xea8>
jmp    200d <pretraducir+0xead>
jmp    117e <pretraducir+0x1e>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
movb   $0x0,(%rax,%rcx,1)
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<pretraducir>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    %rsi,%r14
mov    %rdi,%rbx
xor    %r15d,%r15d
xor    %r12d,%r12d
jmp    1188 <pretraducir+0x48>
nopl   0x0(%rax)
add    $0x1,%r15d
movsbl (%rbx,%r15,1),%edi
xor    %eax,%eax
call   1060 <esOperador@plt>
test   %eax,%eax
je     14ed <pretraducir+0x3ad>
movzbl 0x0(%r13),%eax
mov    %r12d,%ecx
add    $0x1,%r12d
mov    %al,(%r14,%rcx,1)
mov    %r15d,%eax
lea    (%rbx,%rax,1),%r13
movsbl (%rbx,%rax,1),%ebp
cmp    $0x69,%ebp
je     1160 <pretraducir+0x20>
test   %bpl,%bpl
je     1901 <pretraducir+0x7c1>
mov    $0x7,%edx
mov    %r13,%rdi
lea    0xe50(%rip),%rsi
call   1030 <strncmp@plt>
test   %eax,%eax
je     152b <pretraducir+0x3eb>
mov    $0x3,%edx
mov    %r13,%rdi
lea    0xe3c(%rip),%rsi
call   1030 <strncmp@plt>
test   %eax,%eax
je     14d0 <pretraducir+0x390>
mov    $0x3,%edx
mov    %r13,%rdi
lea    0xe24(%rip),%rsi
call   1030 <strncmp@plt>
test   %eax,%eax
je     14d0 <pretraducir+0x390>
mov    $0x4,%edx
mov    %r13,%rdi
lea    0xe0c(%rip),%rsi
call   1030 <strncmp@plt>
test   %eax,%eax
je     1561 <pretraducir+0x421>
mov    $0x3,%edx
mov    %r13,%rdi
lea    0xdf6(%rip),%rsi
call   1030 <strncmp@plt>
test   %eax,%eax
je     154c <pretraducir+0x40c>
mov    $0x3,%edx
mov    %r13,%rdi
lea    0xddf(%rip),%rsi
call   1030 <strncmp@plt>
test   %eax,%eax
je     154c <pretraducir+0x40c>
mov    $0x3,%edx
mov    %r13,%rdi
lea    0xdc8(%rip),%rsi
call   1030 <strncmp@plt>
test   %eax,%eax
je     1576 <pretraducir+0x436>
mov    $0x3,%edx
mov    %r13,%rdi
lea    0xdb1(%rip),%rsi
call   1030 <strncmp@plt>
test   %eax,%eax
je     15a0 <pretraducir+0x460>
mov    $0x4,%edx
mov    %r13,%rdi
lea    0xd85(%rip),%rsi
call   1030 <strncmp@plt>
test   %eax,%eax
je     158b <pretraducir+0x44b>
mov    $0x4,%edx
mov    %r13,%rdi
lea    0xd6e(%rip),%rsi
call   1030 <strncmp@plt>
test   %eax,%eax
je     158b <pretraducir+0x44b>
mov    $0x4,%edx
mov    %r13,%rdi
lea    0xd57(%rip),%rsi
call   1030 <strncmp@plt>
test   %eax,%eax
je     15b5 <pretraducir+0x475>
mov    $0x4,%edx
mov    %r13,%rdi
lea    0xd40(%rip),%rsi
call   1030 <strncmp@plt>
test   %eax,%eax
je     15ca <pretraducir+0x48a>
mov    $0x3,%edx
mov    %r13,%rdi
lea    0xd29(%rip),%rsi
call   1030 <strncmp@plt>
test   %eax,%eax
je     15df <pretraducir+0x49f>
mov    $0x2,%edx
mov    %r13,%rdi
lea    0xd11(%rip),%rsi
call   1030 <strncmp@plt>
test   %eax,%eax
je     15f4 <pretraducir+0x4b4>
mov    $0x3,%edx
mov    %r13,%rdi
lea    0xcf8(%rip),%rsi
call   1030 <strncmp@plt>
test   %eax,%eax
je     1609 <pretraducir+0x4c9>
mov    $0x2,%edx
mov    %r13,%rdi
lea    0xce1(%rip),%rsi
call   1030 <strncmp@plt>
test   %eax,%eax
je     161e <pretraducir+0x4de>
mov    $0x2,%edx
mov    %r13,%rdi
lea    0xcc9(%rip),%rsi
call   1030 <strncmp@plt>
test   %eax,%eax
je     1633 <pretraducir+0x4f3>
mov    $0x2,%edx
mov    %r13,%rdi
lea    0xcb1(%rip),%rsi
call   1030 <strncmp@plt>
test   %eax,%eax
je     1648 <pretraducir+0x508>
mov    $0x3,%edx
mov    %r13,%rdi
lea    0xc8c(%rip),%rsi
call   1030 <strncmp@plt>
test   %eax,%eax
je     165d <pretraducir+0x51d>
mov    $0x3,%edx
mov    %r13,%rdi
lea    0xc74(%rip),%rsi
call   1030 <strncmp@plt>
test   %eax,%eax
je     1672 <pretraducir+0x532>
mov    $0x3,%edx
mov    %r13,%rdi
lea    0xc5c(%rip),%rsi
call   1030 <strncmp@plt>
test   %eax,%eax
je     1687 <pretraducir+0x547>
mov    $0x3,%edx
mov    %r13,%rdi
lea    0xc44(%rip),%rsi
call   1030 <strncmp@plt>
test   %eax,%eax
je     169c <pretraducir+0x55c>
mov    $0x6,%edx
mov    %r13,%rdi
lea    0xc2c(%rip),%rsi
call   1030 <strncmp@plt>
test   %eax,%eax
je     16b1 <pretraducir+0x571>
mov    $0x9,%edx
mov    %r13,%rdi
lea    0xc17(%rip),%rsi
call   1030 <strncmp@plt>
test   %eax,%eax
je     16c6 <pretraducir+0x586>
mov    $0x5,%edx
mov    %r13,%rdi
lea    0xc05(%rip),%rsi
call   1030 <strncmp@plt>
test   %eax,%eax
je     16db <pretraducir+0x59b>
mov    $0x4,%edx
mov    %r13,%rdi
lea    0xbef(%rip),%rsi
call   1030 <strncmp@plt>
test   %eax,%eax
je     16f0 <pretraducir+0x5b0>
mov    $0x5,%edx
mov    %r13,%rdi
lea    0xbd8(%rip),%rsi
call   1030 <strncmp@plt>
test   %eax,%eax
je     1705 <pretraducir+0x5c5>
mov    $0x2,%edx
mov    %r13,%rdi
lea    0xbc2(%rip),%rsi
call   1030 <strncmp@plt>
test   %eax,%eax
je     171a <pretraducir+0x5da>
cmp    $0x65,%bpl
jne    1724 <pretraducir+0x5e4>
mov    %r12d,%eax
movb   $0x56,(%r14,%rax,1)
add    $0x1,%r12d
add    $0x1,%r15d
jmp    1188 <pretraducir+0x48>
mov    %r12d,%eax
movb   $0x73,0x2(%r14,%rax,1)
movw   $0x6572,(%r14,%rax,1)
add    $0x3,%r12d
add    $0x3,%r15d
jmp    1188 <pretraducir+0x48>
movzbl (%rbx,%r15,1),%eax
cmp    $0x29,%rax
ja     150c <pretraducir+0x3cc>
movabs $0x20200000001,%rcx
bt     %rax,%rcx
jb     1178 <pretraducir+0x38>
movzbl 0x0(%r13),%eax
lea    0x1(%r12),%ecx
mov    %r12d,%edx
mov    %al,(%r14,%rdx,1)
add    $0x2,%r12d
movb   $0x2a,(%r14,%rcx,1)
jmp    1188 <pretraducir+0x48>
mov    %r12d,%eax
movl   $0x706d6f43,0x3(%r14,%rax,1)
6d 70
movl   $0x43736572,(%r14,%rax,1)
43
add    $0x7,%r12d
add    $0x7,%r15d
jmp    1188 <pretraducir+0x48>
mov    %r12d,%eax
add    $0x1,%r12d
movb   $0x62,(%r14,%rax,1)
add    $0x3,%r15d
jmp    1188 <pretraducir+0x48>
mov    %r12d,%eax
add    $0x1,%r12d
movb   $0x61,(%r14,%rax,1)
add    $0x4,%r15d
jmp    1188 <pretraducir+0x48>
mov    %r12d,%eax
add    $0x1,%r12d
movb   $0x63,(%r14,%rax,1)
add    $0x3,%r15d
jmp    1188 <pretraducir+0x48>
mov    %r12d,%eax
add    $0x1,%r12d
movb   $0x65,(%r14,%rax,1)
add    $0x4,%r15d
jmp    1188 <pretraducir+0x48>
mov    %r12d,%eax
add    $0x1,%r12d
movb   $0x64,(%r14,%rax,1)
add    $0x3,%r15d
jmp    1188 <pretraducir+0x48>
mov    %r12d,%eax
add    $0x1,%r12d
movb   $0x66,(%r14,%rax,1)
add    $0x4,%r15d
jmp    1188 <pretraducir+0x48>
mov    %r12d,%eax
add    $0x1,%r12d
movb   $0x67,(%r14,%rax,1)
add    $0x4,%r15d
jmp    1188 <pretraducir+0x48>
mov    %r12d,%eax
add    $0x1,%r12d
movb   $0x68,(%r14,%rax,1)
add    $0x3,%r15d
jmp    1188 <pretraducir+0x48>
mov    %r12d,%eax
add    $0x1,%r12d
movb   $0x7a,(%r14,%rax,1)
add    $0x2,%r15d
jmp    1188 <pretraducir+0x48>
mov    %r12d,%eax
add    $0x1,%r12d
movb   $0x6b,(%r14,%rax,1)
add    $0x3,%r15d
jmp    1188 <pretraducir+0x48>
mov    %r12d,%eax
add    $0x1,%r12d
movb   $0x6c,(%r14,%rax,1)
add    $0x2,%r15d
jmp    1188 <pretraducir+0x48>
mov    %r12d,%eax
add    $0x1,%r12d
movb   $0x6d,(%r14,%rax,1)
add    $0x2,%r15d
jmp    1188 <pretraducir+0x48>
mov    %r12d,%eax
add    $0x1,%r12d
movb   $0x6e,(%r14,%rax,1)
add    $0x2,%r15d
jmp    1188 <pretraducir+0x48>
mov    %r12d,%eax
add    $0x1,%r12d
movb   $0x6f,(%r14,%rax,1)
add    $0x3,%r15d
jmp    1188 <pretraducir+0x48>
mov    %r12d,%eax
add    $0x1,%r12d
movb   $0x70,(%r14,%rax,1)
add    $0x3,%r15d
jmp    1188 <pretraducir+0x48>
mov    %r12d,%eax
add    $0x1,%r12d
movb   $0x71,(%r14,%rax,1)
add    $0x3,%r15d
jmp    1188 <pretraducir+0x48>
mov    %r12d,%eax
add    $0x1,%r12d
movb   $0x72,(%r14,%rax,1)
add    $0x3,%r15d
jmp    1188 <pretraducir+0x48>
mov    %r12d,%eax
add    $0x1,%r12d
movb   $0x77,(%r14,%rax,1)
add    $0x6,%r15d
jmp    1188 <pretraducir+0x48>
mov    %r12d,%eax
add    $0x1,%r12d
movb   $0x74,(%r14,%rax,1)
add    $0x9,%r15d
jmp    1188 <pretraducir+0x48>
mov    %r12d,%eax
add    $0x1,%r12d
movb   $0x75,(%r14,%rax,1)
add    $0x5,%r15d
jmp    1188 <pretraducir+0x48>
mov    %r12d,%eax
add    $0x1,%r12d
movb   $0x76,(%r14,%rax,1)
add    $0x4,%r15d
jmp    1188 <pretraducir+0x48>
mov    %r12d,%eax
add    $0x1,%r12d
movb   $0x73,(%r14,%rax,1)
add    $0x5,%r15d
jmp    1188 <pretraducir+0x48>
mov    %r12d,%eax
movb   $0x55,(%r14,%rax,1)
jmp    1774 <pretraducir+0x634>
mov    $0x2,%edx
mov    %r13,%rdi
lea    0x936(%rip),%rsi
call   1030 <strncmp@plt>
test   %eax,%eax
je     176c <pretraducir+0x62c>
test   %r15d,%r15d
jne    1781 <pretraducir+0x641>
cmp    $0x2d,%bpl
jne    1781 <pretraducir+0x641>
lea    0x1(%r12),%eax
mov    %r12d,%ecx
movb   $0x30,(%r14,%rcx,1)
movzbl 0x0(%r13),%ecx
add    $0x2,%r12d
mov    %cl,(%r14,%rax,1)
mov    $0x1,%r15d
jmp    1188 <pretraducir+0x48>
mov    %r12d,%eax
movb   $0x57,(%r14,%rax,1)
add    $0x1,%r12d
add    $0x2,%r15d
jmp    1188 <pretraducir+0x48>
cmp    $0x29,%bpl
je     17cd <pretraducir+0x68d>
cmp    $0x28,%bpl
jne    17c3 <pretraducir+0x683>
lea    0x1(%r15),%eax
cmpb   $0x2d,(%rbx,%rax,1)
jne    17c3 <pretraducir+0x683>
lea    0x1(%r12),%ecx
mov    %r12d,%edx
movb   $0x28,(%r14,%rdx,1)
lea    0x2(%r12),%edx
movb   $0x30,(%r14,%rcx,1)
add    $0x2,%r15d
movzbl (%rbx,%rax,1),%eax
add    $0x3,%r12d
mov    %al,(%r14,%rdx,1)
jmp    1188 <pretraducir+0x48>
movl   $0x0,0x8(%rsp)
jmp    17fb <pretraducir+0x6bb>
lea    0x1(%r15),%eax
mov    $0x1,%cl
mov    %ecx,0x8(%rsp)
cmpb   $0x28,(%rbx,%rax,1)
jne    17fb <pretraducir+0x6bb>
lea    0x1(%r12),%ecx
mov    %r12d,%edx
movb   $0x29,(%r14,%rdx,1)
add    $0x2,%r12d
movb   $0x2a,(%r14,%rcx,1)
mov    %eax,%r15d
jmp    1188 <pretraducir+0x48>
mov    %ebp,%edi
call   1050 <isalpha@plt>
mov    %eax,0xc(%rsp)
test   %eax,%eax
je     1851 <pretraducir+0x711>
lea    0x1(%r15),%eax
mov    %rax,0x10(%rsp)
movzbl (%rbx,%rax,1),%r13d
movsbl %r13b,%edi
call   1050 <isalpha@plt>
test   %eax,%eax
jne    182b <pretraducir+0x6eb>
cmp    $0x28,%r13b
jne    1851 <pretraducir+0x711>
mov    %ebp,%edi
call   1040 <toupper@plt>
lea    0x1(%r12),%ecx
mov    %r12d,%edx
mov    %al,(%r14,%rdx,1)
add    $0x2,%r12d
movb   $0x2a,(%r14,%rcx,1)
mov    0x10(%rsp),%r15
jmp    1188 <pretraducir+0x48>
cmpb   $0x0,0x8(%rsp)
je     186a <pretraducir+0x72a>
lea    0x1(%r15),%r13d
movsbl (%rbx,%r13,1),%edi
call   1050 <isalpha@plt>
test   %eax,%eax
jne    1889 <pretraducir+0x749>
lea    -0x30(%rbp),%eax
cmp    $0x9,%eax
ja     18a6 <pretraducir+0x766>
lea    0x1(%r15),%r13d
movsbl (%rbx,%r13,1),%edi
cmp    $0x28,%edi
je     1889 <pretraducir+0x749>
call   1050 <isalpha@plt>
test   %eax,%eax
je     18a6 <pretraducir+0x766>
lea    0x1(%r12),%eax
mov    %r12d,%ecx
mov    %bpl,(%r14,%rcx,1)
add    $0x2,%r12d
movb   $0x2a,(%r14,%rax,1)
mov    %r13d,%r15d
jmp    1188 <pretraducir+0x48>
add    $0x1,%r15d
cmpl   $0x0,0xc(%rsp)
je     18da <pretraducir+0x79a>
mov    %r15d,%eax
movsbl (%rbx,%rax,1),%eax
add    $0xffffffd0,%eax
cmp    $0x9,%eax
ja     18ea <pretraducir+0x7aa>
lea    0x1(%r12),%eax
mov    %r12d,%ecx
mov    %bpl,(%r14,%rcx,1)
add    $0x2,%r12d
movb   $0x2a,(%r14,%rax,1)
jmp    1188 <pretraducir+0x48>
mov    %r12d,%eax
add    $0x1,%r12d
mov    %bpl,(%r14,%rax,1)
jmp    1188 <pretraducir+0x48>
mov    %ebp,%edi
call   1040 <toupper@plt>
mov    %r12d,%ecx
add    $0x1,%r12d
mov    %al,(%r14,%rcx,1)
jmp    1188 <pretraducir+0x48>
mov    %r12d,%eax
movb   $0x0,(%r14,%rax,1)
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [8 x i8] c"resComp\00"
@.str.1 = [4 x i8] c"res\00"
@.str.2 = [4 x i8] c"ans\00"
@.str.3 = [5 x i8] c"sqrt\00"
@.str.4 = [4 x i8] c"sin\00"
@.str.5 = [4 x i8] c"sen\00"
@.str.6 = [4 x i8] c"cos\00"
@.str.7 = [4 x i8] c"tan\00"
@.str.8 = [5 x i8] c"asin\00"
@.str.9 = [5 x i8] c"asen\00"
@.str.10 = [5 x i8] c"acos\00"
@.str.11 = [5 x i8] c"atan\00"
@.str.12 = [4 x i8] c"exp\00"
@.str.13 = [3 x i8] c"ln\00"
@.str.14 = [4 x i8] c"log\00"
@.str.15 = [3 x i8] c"sh\00"
@.str.16 = [3 x i8] c"ch\00"
@.str.17 = [3 x i8] c"th\00"
@.str.18 = [4 x i8] c"ash\00"
@.str.19 = [4 x i8] c"ach\00"
@.str.20 = [4 x i8] c"ath\00"
@.str.21 = [4 x i8] c"pow\00"
@.str.22 = [7 x i8] c"gamma'\00"
@.str.23 = [10 x i8] c"factorial\00"
@.str.24 = [6 x i8] c"betha\00"
@.str.25 = [5 x i8] c"prim\00"
@.str.26 = [6 x i8] c"gamma\00"
@.str.27 = [3 x i8] c"pi\00"
@.str.28 = [2 x i8] c"e\00"
@.str.29 = [3 x i8] c"r2\00"
define void @pretraducir(i8* %0, i8* %1) {
%3 = alloca i8*
%4 = alloca i8*
%5 = alloca i32
%6 = alloca i32
store i8* %0, i8** %3
store i8* %1, i8** %4
store i32 0, i32* %5
store i32 0, i32* %6
br label %7
7: ; preds = %980, %2
%8 = load i8*, i8** %3
%9 = load i32, i32* %5
%10 = zext i32 %9 to i64
%11 = getelementptr inbounds i8, i8* %8, i64 %10
%12 = load i8, i8* %11
%13 = sext i8 %12 to i32
%14 = icmp ne i32 %13, 0
br i1 %14, label %15, label %981
15: ; preds = %7
%16 = load i8*, i8** %3
%17 = load i32, i32* %5
%18 = zext i32 %17 to i64
%19 = getelementptr inbounds i8, i8* %16, i64 %18
%20 = load i8, i8* %19
%21 = sext i8 %20 to i32
%22 = icmp eq i32 %21, 105
br i1 %22, label %23, label %90
23: ; preds = %15
%24 = load i8*, i8** %3
%25 = load i32, i32* %5
%26 = add i32 %25, 1
%27 = zext i32 %26 to i64
%28 = getelementptr inbounds i8, i8* %24, i64 %27
%29 = load i8, i8* %28
%30 = sext i8 %29 to i32
%31 = call i32 (i32, ...) bitcast (i32 (...)* @esOperador to i32 (i32, ...)*)(i32 %30)
%32 = icmp ne i32 %31, 0
br i1 %32, label %77, label %33
33: ; preds = %23
%34 = load i8*, i8** %3
%35 = load i32, i32* %5
%36 = add i32 %35, 1
%37 = zext i32 %36 to i64
%38 = getelementptr inbounds i8, i8* %34, i64 %37
%39 = load i8, i8* %38
%40 = sext i8 %39 to i32
%41 = icmp ne i32 %40, 0
br i1 %41, label %42, label %77
42: ; preds = %33
%43 = load i8*, i8** %3
%44 = load i32, i32* %5
%45 = add i32 %44, 1
%46 = zext i32 %45 to i64
%47 = getelementptr inbounds i8, i8* %43, i64 %46
%48 = load i8, i8* %47
%49 = sext i8 %48 to i32
%50 = icmp ne i32 %49, 41
br i1 %50, label %51, label %77
51: ; preds = %42
%52 = load i8*, i8** %3
%53 = load i32, i32* %5
%54 = add i32 %53, 1
%55 = zext i32 %54 to i64
%56 = getelementptr inbounds i8, i8* %52, i64 %55
%57 = load i8, i8* %56
%58 = sext i8 %57 to i32
%59 = icmp ne i32 %58, 33
br i1 %59, label %60, label %77
60: ; preds = %51
%61 = load i8*, i8** %3
%62 = load i32, i32* %5
%63 = add i32 %62, 1
store i32 %63, i32* %5
%64 = zext i32 %62 to i64
%65 = getelementptr inbounds i8, i8* %61, i64 %64
%66 = load i8, i8* %65
%67 = load i8*, i8** %4
%68 = load i32, i32* %6
%69 = add i32 %68, 1
store i32 %69, i32* %6
%70 = zext i32 %68 to i64
%71 = getelementptr inbounds i8, i8* %67, i64 %70
store i8 %66, i8* %71
%72 = load i8*, i8** %4
%73 = load i32, i32* %6
%74 = add i32 %73, 1
store i32 %74, i32* %6
%75 = zext i32 %73 to i64
%76 = getelementptr inbounds i8, i8* %72, i64 %75
store i8 42, i8* %76
br label %89
77: ; preds = %51, %42, %33, %23
%78 = load i8*, i8** %3
%79 = load i32, i32* %5
%80 = add i32 %79, 1
store i32 %80, i32* %5
%81 = zext i32 %79 to i64
%82 = getelementptr inbounds i8, i8* %78, i64 %81
%83 = load i8, i8* %82
%84 = load i8*, i8** %4
%85 = load i32, i32* %6
%86 = add i32 %85, 1
store i32 %86, i32* %6
%87 = zext i32 %85 to i64
%88 = getelementptr inbounds i8, i8* %84, i64 %87
store i8 %83, i8* %88
br label %89
89: ; preds = %77, %60
br label %980
90: ; preds = %15
%91 = load i8*, i8** %3
%92 = load i32, i32* %5
%93 = zext i32 %92 to i64
%94 = getelementptr inbounds i8, i8* %91, i64 %93
%95 = call i32 @strncmp(i8* %94, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str, i64 0, i64 0), i64 7)
%96 = icmp eq i32 %95, 0
br i1 %96, label %97, label %111
97: ; preds = %90
%98 = load i8*, i8** %4
%99 = load i32, i32* %6
%100 = zext i32 %99 to i64
%101 = getelementptr inbounds i8, i8* %98, i64 %100
%102 = call i8* @strncpy(i8* %101, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str, i64 0, i64 0), i64 7)
%103 = load i32, i32* %6
%104 = zext i32 %103 to i64
%105 = add i64 %104, 7
%106 = trunc i64 %105 to i32
store i32 %106, i32* %6
%107 = load i32, i32* %5
%108 = zext i32 %107 to i64
%109 = add i64 %108, 7
%110 = trunc i64 %109 to i32
store i32 %110, i32* %5
br label %979
111: ; preds = %90
%112 = load i8*, i8** %3
%113 = load i32, i32* %5
%114 = zext i32 %113 to i64
%115 = getelementptr inbounds i8, i8* %112, i64 %114
%116 = call i32 @strncmp(i8* %115, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), i64 3)
%117 = icmp eq i32 %116, 0
br i1 %117, label %125, label %118
118: ; preds = %111
%119 = load i8*, i8** %3
%120 = load i32, i32* %5
%121 = zext i32 %120 to i64
%122 = getelementptr inbounds i8, i8* %119, i64 %121
%123 = call i32 @strncmp(i8* %122, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0), i64 3)
%124 = icmp eq i32 %123, 0
br i1 %124, label %125, label %139
125: ; preds = %118, %111
%126 = load i8*, i8** %4
%127 = load i32, i32* %6
%128 = zext i32 %127 to i64
%129 = getelementptr inbounds i8, i8* %126, i64 %128
%130 = call i8* @strncpy(i8* %129, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), i64 3)
%131 = load i32, i32* %6
%132 = zext i32 %131 to i64
%133 = add i64 %132, 3
%134 = trunc i64 %133 to i32
store i32 %134, i32* %6
%135 = load i32, i32* %5
%136 = zext i32 %135 to i64
%137 = add i64 %136, 3
%138 = trunc i64 %137 to i32
store i32 %138, i32* %5
br label %978
139: ; preds = %118
%140 = load i8*, i8** %3
%141 = load i32, i32* %5
%142 = zext i32 %141 to i64
%143 = getelementptr inbounds i8, i8* %140, i64 %142
%144 = call i32 @strncmp(i8* %143, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.3, i64 0, i64 0), i64 4)
%145 = icmp eq i32 %144, 0
br i1 %145, label %146, label %156
146: ; preds = %139
%147 = load i8*, i8** %4
%148 = load i32, i32* %6
%149 = add i32 %148, 1
store i32 %149, i32* %6
%150 = zext i32 %148 to i64
%151 = getelementptr inbounds i8, i8* %147, i64 %150
store i8 97, i8* %151
%152 = load i32, i32* %5
%153 = zext i32 %152 to i64
%154 = add i64 %153, 4
%155 = trunc i64 %154 to i32
store i32 %155, i32* %5
br label %977
156: ; preds = %139
%157 = load i8*, i8** %3
%158 = load i32, i32* %5
%159 = zext i32 %158 to i64
%160 = getelementptr inbounds i8, i8* %157, i64 %159
%161 = call i32 @strncmp(i8* %160, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.4, i64 0, i64 0), i64 3)
%162 = icmp eq i32 %161, 0
br i1 %162, label %170, label %163
163: ; preds = %156
%164 = load i8*, i8** %3
%165 = load i32, i32* %5
%166 = zext i32 %165 to i64
%167 = getelementptr inbounds i8, i8* %164, i64 %166
%168 = call i32 @strncmp(i8* %167, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.5, i64 0, i64 0), i64 3)
%169 = icmp eq i32 %168, 0
br i1 %169, label %170, label %180
170: ; preds = %163, %156
%171 = load i8*, i8** %4
%172 = load i32, i32* %6
%173 = add i32 %172, 1
store i32 %173, i32* %6
%174 = zext i32 %172 to i64
%175 = getelementptr inbounds i8, i8* %171, i64 %174
store i8 98, i8* %175
%176 = load i32, i32* %5
%177 = zext i32 %176 to i64
%178 = add i64 %177, 3
%179 = trunc i64 %178 to i32
store i32 %179, i32* %5
br label %976
180: ; preds = %163
%181 = load i8*, i8** %3
%182 = load i32, i32* %5
%183 = zext i32 %182 to i64
%184 = getelementptr inbounds i8, i8* %181, i64 %183
%185 = call i32 @strncmp(i8* %184, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.6, i64 0, i64 0), i64 3)
%186 = icmp eq i32 %185, 0
br i1 %186, label %187, label %197
187: ; preds = %180
%188 = load i8*, i8** %4
%189 = load i32, i32* %6
%190 = add i32 %189, 1
store i32 %190, i32* %6
%191 = zext i32 %189 to i64
%192 = getelementptr inbounds i8, i8* %188, i64 %191
store i8 99, i8* %192
%193 = load i32, i32* %5
%194 = zext i32 %193 to i64
%195 = add i64 %194, 3
%196 = trunc i64 %195 to i32
store i32 %196, i32* %5
br label %975
197: ; preds = %180
%198 = load i8*, i8** %3
%199 = load i32, i32* %5
%200 = zext i32 %199 to i64
%201 = getelementptr inbounds i8, i8* %198, i64 %200
%202 = call i32 @strncmp(i8* %201, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.7, i64 0, i64 0), i64 3)
%203 = icmp eq i32 %202, 0
br i1 %203, label %204, label %214
204: ; preds = %197
%205 = load i8*, i8** %4
%206 = load i32, i32* %6
%207 = add i32 %206, 1
store i32 %207, i32* %6
%208 = zext i32 %206 to i64
%209 = getelementptr inbounds i8, i8* %205, i64 %208
store i8 100, i8* %209
%210 = load i32, i32* %5
%211 = zext i32 %210 to i64
%212 = add i64 %211, 3
%213 = trunc i64 %212 to i32
store i32 %213, i32* %5
br label %974
214: ; preds = %197
%215 = load i8*, i8** %3
%216 = load i32, i32* %5
%217 = zext i32 %216 to i64
%218 = getelementptr inbounds i8, i8* %215, i64 %217
%219 = call i32 @strncmp(i8* %218, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.8, i64 0, i64 0), i64 4)
%220 = icmp eq i32 %219, 0
br i1 %220, label %228, label %221
221: ; preds = %214
%222 = load i8*, i8** %3
%223 = load i32, i32* %5
%224 = zext i32 %223 to i64
%225 = getelementptr inbounds i8, i8* %222, i64 %224
%226 = call i32 @strncmp(i8* %225, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.9, i64 0, i64 0), i64 4)
%227 = icmp eq i32 %226, 0
br i1 %227, label %228, label %238
228: ; preds = %221, %214
%229 = load i8*, i8** %4
%230 = load i32, i32* %6
%231 = add i32 %230, 1
store i32 %231, i32* %6
%232 = zext i32 %230 to i64
%233 = getelementptr inbounds i8, i8* %229, i64 %232
store i8 101, i8* %233
%234 = load i32, i32* %5
%235 = zext i32 %234 to i64
%236 = add i64 %235, 4
%237 = trunc i64 %236 to i32
store i32 %237, i32* %5
br label %973
238: ; preds = %221
%239 = load i8*, i8** %3
%240 = load i32, i32* %5
%241 = zext i32 %240 to i64
%242 = getelementptr inbounds i8, i8* %239, i64 %241
%243 = call i32 @strncmp(i8* %242, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.10, i64 0, i64 0), i64 4)
%244 = icmp eq i32 %243, 0
br i1 %244, label %245, label %255
245: ; preds = %238
%246 = load i8*, i8** %4
%247 = load i32, i32* %6
%248 = add i32 %247, 1
store i32 %248, i32* %6
%249 = zext i32 %247 to i64
%250 = getelementptr inbounds i8, i8* %246, i64 %249
store i8 102, i8* %250
%251 = load i32, i32* %5
%252 = zext i32 %251 to i64
%253 = add i64 %252, 4
%254 = trunc i64 %253 to i32
store i32 %254, i32* %5
br label %972
255: ; preds = %238
%256 = load i8*, i8** %3
%257 = load i32, i32* %5
%258 = zext i32 %257 to i64
%259 = getelementptr inbounds i8, i8* %256, i64 %258
%260 = call i32 @strncmp(i8* %259, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.11, i64 0, i64 0), i64 4)
%261 = icmp eq i32 %260, 0
br i1 %261, label %262, label %272
262: ; preds = %255
%263 = load i8*, i8** %4
%264 = load i32, i32* %6
%265 = add i32 %264, 1
store i32 %265, i32* %6
%266 = zext i32 %264 to i64
%267 = getelementptr inbounds i8, i8* %263, i64 %266
store i8 103, i8* %267
%268 = load i32, i32* %5
%269 = zext i32 %268 to i64
%270 = add i64 %269, 4
%271 = trunc i64 %270 to i32
store i32 %271, i32* %5
br label %971
272: ; preds = %255
%273 = load i8*, i8** %3
%274 = load i32, i32* %5
%275 = zext i32 %274 to i64
%276 = getelementptr inbounds i8, i8* %273, i64 %275
%277 = call i32 @strncmp(i8* %276, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.12, i64 0, i64 0), i64 3)
%278 = icmp eq i32 %277, 0
br i1 %278, label %279, label %289
279: ; preds = %272
%280 = load i8*, i8** %4
%281 = load i32, i32* %6
%282 = add i32 %281, 1
store i32 %282, i32* %6
%283 = zext i32 %281 to i64
%284 = getelementptr inbounds i8, i8* %280, i64 %283
store i8 104, i8* %284
%285 = load i32, i32* %5
%286 = zext i32 %285 to i64
%287 = add i64 %286, 3
%288 = trunc i64 %287 to i32
store i32 %288, i32* %5
br label %970
289: ; preds = %272
%290 = load i8*, i8** %3
%291 = load i32, i32* %5
%292 = zext i32 %291 to i64
%293 = getelementptr inbounds i8, i8* %290, i64 %292
%294 = call i32 @strncmp(i8* %293, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.13, i64 0, i64 0), i64 2)
%295 = icmp eq i32 %294, 0
br i1 %295, label %296, label %306
296: ; preds = %289
%297 = load i8*, i8** %4
%298 = load i32, i32* %6
%299 = add i32 %298, 1
store i32 %299, i32* %6
%300 = zext i32 %298 to i64
%301 = getelementptr inbounds i8, i8* %297, i64 %300
store i8 122, i8* %301
%302 = load i32, i32* %5
%303 = zext i32 %302 to i64
%304 = add i64 %303, 2
%305 = trunc i64 %304 to i32
store i32 %305, i32* %5
br label %969
306: ; preds = %289
%307 = load i8*, i8** %3
%308 = load i32, i32* %5
%309 = zext i32 %308 to i64
%310 = getelementptr inbounds i8, i8* %307, i64 %309
%311 = call i32 @strncmp(i8* %310, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.14, i64 0, i64 0), i64 3)
%312 = icmp eq i32 %311, 0
br i1 %312, label %313, label %323
313: ; preds = %306
%314 = load i8*, i8** %4
%315 = load i32, i32* %6
%316 = add i32 %315, 1
store i32 %316, i32* %6
%317 = zext i32 %315 to i64
%318 = getelementptr inbounds i8, i8* %314, i64 %317
store i8 107, i8* %318
%319 = load i32, i32* %5
%320 = zext i32 %319 to i64
%321 = add i64 %320, 3
%322 = trunc i64 %321 to i32
store i32 %322, i32* %5
br label %968
323: ; preds = %306
%324 = load i8*, i8** %3
%325 = load i32, i32* %5
%326 = zext i32 %325 to i64
%327 = getelementptr inbounds i8, i8* %324, i64 %326
%328 = call i32 @strncmp(i8* %327, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.15, i64 0, i64 0), i64 2)
%329 = icmp eq i32 %328, 0
br i1 %329, label %330, label %340
330: ; preds = %323
%331 = load i8*, i8** %4
%332 = load i32, i32* %6
%333 = add i32 %332, 1
store i32 %333, i32* %6
%334 = zext i32 %332 to i64
%335 = getelementptr inbounds i8, i8* %331, i64 %334
store i8 108, i8* %335
%336 = load i32, i32* %5
%337 = zext i32 %336 to i64
%338 = add i64 %337, 2
%339 = trunc i64 %338 to i32
store i32 %339, i32* %5
br label %967
340: ; preds = %323
%341 = load i8*, i8** %3
%342 = load i32, i32* %5
%343 = zext i32 %342 to i64
%344 = getelementptr inbounds i8, i8* %341, i64 %343
%345 = call i32 @strncmp(i8* %344, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.16, i64 0, i64 0), i64 2)
%346 = icmp eq i32 %345, 0
br i1 %346, label %347, label %357
347: ; preds = %340
%348 = load i8*, i8** %4
%349 = load i32, i32* %6
%350 = add i32 %349, 1
store i32 %350, i32* %6
%351 = zext i32 %349 to i64
%352 = getelementptr inbounds i8, i8* %348, i64 %351
store i8 109, i8* %352
%353 = load i32, i32* %5
%354 = zext i32 %353 to i64
%355 = add i64 %354, 2
%356 = trunc i64 %355 to i32
store i32 %356, i32* %5
br label %966
357: ; preds = %340
%358 = load i8*, i8** %3
%359 = load i32, i32* %5
%360 = zext i32 %359 to i64
%361 = getelementptr inbounds i8, i8* %358, i64 %360
%362 = call i32 @strncmp(i8* %361, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.17, i64 0, i64 0), i64 2)
%363 = icmp eq i32 %362, 0
br i1 %363, label %364, label %374
364: ; preds = %357
%365 = load i8*, i8** %4
%366 = load i32, i32* %6
%367 = add i32 %366, 1
store i32 %367, i32* %6
%368 = zext i32 %366 to i64
%369 = getelementptr inbounds i8, i8* %365, i64 %368
store i8 110, i8* %369
%370 = load i32, i32* %5
%371 = zext i32 %370 to i64
%372 = add i64 %371, 2
%373 = trunc i64 %372 to i32
store i32 %373, i32* %5
br label %965
374: ; preds = %357
%375 = load i8*, i8** %3
%376 = load i32, i32* %5
%377 = zext i32 %376 to i64
%378 = getelementptr inbounds i8, i8* %375, i64 %377
%379 = call i32 @strncmp(i8* %378, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.18, i64 0, i64 0), i64 3)
%380 = icmp eq i32 %379, 0
br i1 %380, label %381, label %391
381: ; preds = %374
%382 = load i8*, i8** %4
%383 = load i32, i32* %6
%384 = add i32 %383, 1
store i32 %384, i32* %6
%385 = zext i32 %383 to i64
%386 = getelementptr inbounds i8, i8* %382, i64 %385
store i8 111, i8* %386
%387 = load i32, i32* %5
%388 = zext i32 %387 to i64
%389 = add i64 %388, 3
%390 = trunc i64 %389 to i32
store i32 %390, i32* %5
br label %964
391: ; preds = %374
%392 = load i8*, i8** %3
%393 = load i32, i32* %5
%394 = zext i32 %393 to i64
%395 = getelementptr inbounds i8, i8* %392, i64 %394
%396 = call i32 @strncmp(i8* %395, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.19, i64 0, i64 0), i64 3)
%397 = icmp eq i32 %396, 0
br i1 %397, label %398, label %408
398: ; preds = %391
%399 = load i8*, i8** %4
%400 = load i32, i32* %6
%401 = add i32 %400, 1
store i32 %401, i32* %6
%402 = zext i32 %400 to i64
%403 = getelementptr inbounds i8, i8* %399, i64 %402
store i8 112, i8* %403
%404 = load i32, i32* %5
%405 = zext i32 %404 to i64
%406 = add i64 %405, 3
%407 = trunc i64 %406 to i32
store i32 %407, i32* %5
br label %963
408: ; preds = %391
%409 = load i8*, i8** %3
%410 = load i32, i32* %5
%411 = zext i32 %410 to i64
%412 = getelementptr inbounds i8, i8* %409, i64 %411
%413 = call i32 @strncmp(i8* %412, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.20, i64 0, i64 0), i64 3)
%414 = icmp eq i32 %413, 0
br i1 %414, label %415, label %425
415: ; preds = %408
%416 = load i8*, i8** %4
%417 = load i32, i32* %6
%418 = add i32 %417, 1
store i32 %418, i32* %6
%419 = zext i32 %417 to i64
%420 = getelementptr inbounds i8, i8* %416, i64 %419
store i8 113, i8* %420
%421 = load i32, i32* %5
%422 = zext i32 %421 to i64
%423 = add i64 %422, 3
%424 = trunc i64 %423 to i32
store i32 %424, i32* %5
br label %962
425: ; preds = %408
%426 = load i8*, i8** %3
%427 = load i32, i32* %5
%428 = zext i32 %427 to i64
%429 = getelementptr inbounds i8, i8* %426, i64 %428
%430 = call i32 @strncmp(i8* %429, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.21, i64 0, i64 0), i64 3)
%431 = icmp eq i32 %430, 0
br i1 %431, label %432, label %442
432: ; preds = %425
%433 = load i8*, i8** %4
%434 = load i32, i32* %6
%435 = add i32 %434, 1
store i32 %435, i32* %6
%436 = zext i32 %434 to i64
%437 = getelementptr inbounds i8, i8* %433, i64 %436
store i8 114, i8* %437
%438 = load i32, i32* %5
%439 = zext i32 %438 to i64
%440 = add i64 %439, 3
%441 = trunc i64 %440 to i32
store i32 %441, i32* %5
br label %961
442: ; preds = %425
%443 = load i8*, i8** %3
%444 = load i32, i32* %5
%445 = zext i32 %444 to i64
%446 = getelementptr inbounds i8, i8* %443, i64 %445
%447 = call i32 @strncmp(i8* %446, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.22, i64 0, i64 0), i64 6)
%448 = icmp eq i32 %447, 0
br i1 %448, label %449, label %459
449: ; preds = %442
%450 = load i8*, i8** %4
%451 = load i32, i32* %6
%452 = add i32 %451, 1
store i32 %452, i32* %6
%453 = zext i32 %451 to i64
%454 = getelementptr inbounds i8, i8* %450, i64 %453
store i8 119, i8* %454
%455 = load i32, i32* %5
%456 = zext i32 %455 to i64
%457 = add i64 %456, 6
%458 = trunc i64 %457 to i32
store i32 %458, i32* %5
br label %960
459: ; preds = %442
%460 = load i8*, i8** %3
%461 = load i32, i32* %5
%462 = zext i32 %461 to i64
%463 = getelementptr inbounds i8, i8* %460, i64 %462
%464 = call i32 @strncmp(i8* %463, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.23, i64 0, i64 0), i64 9)
%465 = icmp eq i32 %464, 0
br i1 %465, label %466, label %476
466: ; preds = %459
%467 = load i8*, i8** %4
%468 = load i32, i32* %6
%469 = add i32 %468, 1
store i32 %469, i32* %6
%470 = zext i32 %468 to i64
%471 = getelementptr inbounds i8, i8* %467, i64 %470
store i8 116, i8* %471
%472 = load i32, i32* %5
%473 = zext i32 %472 to i64
%474 = add i64 %473, 9
%475 = trunc i64 %474 to i32
store i32 %475, i32* %5
br label %959
476: ; preds = %459
%477 = load i8*, i8** %3
%478 = load i32, i32* %5
%479 = zext i32 %478 to i64
%480 = getelementptr inbounds i8, i8* %477, i64 %479
%481 = call i32 @strncmp(i8* %480, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.24, i64 0, i64 0), i64 5)
%482 = icmp eq i32 %481, 0
br i1 %482, label %483, label %493
483: ; preds = %476
%484 = load i8*, i8** %4
%485 = load i32, i32* %6
%486 = add i32 %485, 1
store i32 %486, i32* %6
%487 = zext i32 %485 to i64
%488 = getelementptr inbounds i8, i8* %484, i64 %487
store i8 117, i8* %488
%489 = load i32, i32* %5
%490 = zext i32 %489 to i64
%491 = add i64 %490, 5
%492 = trunc i64 %491 to i32
store i32 %492, i32* %5
br label %958
493: ; preds = %476
%494 = load i8*, i8** %3
%495 = load i32, i32* %5
%496 = zext i32 %495 to i64
%497 = getelementptr inbounds i8, i8* %494, i64 %496
%498 = call i32 @strncmp(i8* %497, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.25, i64 0, i64 0), i64 4)
%499 = icmp eq i32 %498, 0
br i1 %499, label %500, label %510
500: ; preds = %493
%501 = load i8*, i8** %4
%502 = load i32, i32* %6
%503 = add i32 %502, 1
store i32 %503, i32* %6
%504 = zext i32 %502 to i64
%505 = getelementptr inbounds i8, i8* %501, i64 %504
store i8 118, i8* %505
%506 = load i32, i32* %5
%507 = zext i32 %506 to i64
%508 = add i64 %507, 4
%509 = trunc i64 %508 to i32
store i32 %509, i32* %5
br label %957
510: ; preds = %493
%511 = load i8*, i8** %3
%512 = load i32, i32* %5
%513 = zext i32 %512 to i64
%514 = getelementptr inbounds i8, i8* %511, i64 %513
%515 = call i32 @strncmp(i8* %514, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.26, i64 0, i64 0), i64 5)
%516 = icmp eq i32 %515, 0
br i1 %516, label %517, label %527
517: ; preds = %510
%518 = load i8*, i8** %4
%519 = load i32, i32* %6
%520 = add i32 %519, 1
store i32 %520, i32* %6
%521 = zext i32 %519 to i64
%522 = getelementptr inbounds i8, i8* %518, i64 %521
store i8 115, i8* %522
%523 = load i32, i32* %5
%524 = zext i32 %523 to i64
%525 = add i64 %524, 5
%526 = trunc i64 %525 to i32
store i32 %526, i32* %5
br label %956
527: ; preds = %510
%528 = load i8*, i8** %3
%529 = load i32, i32* %5
%530 = zext i32 %529 to i64
%531 = getelementptr inbounds i8, i8* %528, i64 %530
%532 = call i32 @strncmp(i8* %531, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.27, i64 0, i64 0), i64 2)
%533 = icmp eq i32 %532, 0
br i1 %533, label %534, label %545
534: ; preds = %527
%535 = load i8*, i8** %4
%536 = load i32, i32* %6
%537 = zext i32 %536 to i64
%538 = getelementptr inbounds i8, i8* %535, i64 %537
store i8 85, i8* %538
%539 = load i32, i32* %6
%540 = add i32 %539, 1
store i32 %540, i32* %6
%541 = load i32, i32* %5
%542 = zext i32 %541 to i64
%543 = add i64 %542, 2
%544 = trunc i64 %543 to i32
store i32 %544, i32* %5
br label %955
545: ; preds = %527
%546 = load i8*, i8** %3
%547 = load i32, i32* %5
%548 = zext i32 %547 to i64
%549 = getelementptr inbounds i8, i8* %546, i64 %548
%550 = call i32 @strncmp(i8* %549, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.28, i64 0, i64 0), i64 1)
%551 = icmp eq i32 %550, 0
br i1 %551, label %552, label %563
552: ; preds = %545
%553 = load i8*, i8** %4
%554 = load i32, i32* %6
%555 = zext i32 %554 to i64
%556 = getelementptr inbounds i8, i8* %553, i64 %555
store i8 86, i8* %556
%557 = load i32, i32* %6
%558 = add i32 %557, 1
store i32 %558, i32* %6
%559 = load i32, i32* %5
%560 = zext i32 %559 to i64
%561 = add i64 %560, 1
%562 = trunc i64 %561 to i32
store i32 %562, i32* %5
br label %954
563: ; preds = %545
%564 = load i8*, i8** %3
%565 = load i32, i32* %5
%566 = zext i32 %565 to i64
%567 = getelementptr inbounds i8, i8* %564, i64 %566
%568 = call i32 @strncmp(i8* %567, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.29, i64 0, i64 0), i64 2)
%569 = icmp eq i32 %568, 0
br i1 %569, label %570, label %581
570: ; preds = %563
%571 = load i8*, i8** %4
%572 = load i32, i32* %6
%573 = zext i32 %572 to i64
%574 = getelementptr inbounds i8, i8* %571, i64 %573
store i8 87, i8* %574
%575 = load i32, i32* %6
%576 = add i32 %575, 1
store i32 %576, i32* %6
%577 = load i32, i32* %5
%578 = zext i32 %577 to i64
%579 = add i64 %578, 2
%580 = trunc i64 %579 to i32
store i32 %580, i32* %5
br label %953
581: ; preds = %563
%582 = load i32, i32* %5
%583 = icmp eq i32 %582, 0
br i1 %583, label %584, label %609
584: ; preds = %581
%585 = load i8*, i8** %3
%586 = load i32, i32* %5
%587 = zext i32 %586 to i64
%588 = getelementptr inbounds i8, i8* %585, i64 %587
%589 = load i8, i8* %588
%590 = sext i8 %589 to i32
%591 = icmp eq i32 %590, 45
br i1 %591, label %592, label %609
592: ; preds = %584
%593 = load i8*, i8** %4
%594 = load i32, i32* %6
%595 = add i32 %594, 1
store i32 %595, i32* %6
%596 = zext i32 %594 to i64
%597 = getelementptr inbounds i8, i8* %593, i64 %596
store i8 48, i8* %597
%598 = load i8*, i8** %3
%599 = load i32, i32* %5
%600 = add i32 %599, 1
store i32 %600, i32* %5
%601 = zext i32 %599 to i64
%602 = getelementptr inbounds i8, i8* %598, i64 %601
%603 = load i8, i8* %602
%604 = load i8*, i8** %4
%605 = load i32, i32* %6
%606 = add i32 %605, 1
store i32 %606, i32* %6
%607 = zext i32 %605 to i64
%608 = getelementptr inbounds i8, i8* %604, i64 %607
store i8 %603, i8* %608
br label %952
609: ; preds = %584, %581
%610 = load i8*, i8** %3
%611 = load i32, i32* %5
%612 = zext i32 %611 to i64
%613 = getelementptr inbounds i8, i8* %610, i64 %612
%614 = load i8, i8* %613
%615 = sext i8 %614 to i32
%616 = icmp eq i32 %615, 40
br i1 %616, label %617, label %654
617: ; preds = %609
%618 = load i8*, i8** %3
%619 = load i32, i32* %5
%620 = add i32 %619, 1
%621 = zext i32 %620 to i64
%622 = getelementptr inbounds i8, i8* %618, i64 %621
%623 = load i8, i8* %622
%624 = sext i8 %623 to i32
%625 = icmp eq i32 %624, 45
br i1 %625, label %626, label %654
626: ; preds = %617
%627 = load i8*, i8** %3
%628 = load i32, i32* %5
%629 = add i32 %628, 1
store i32 %629, i32* %5
%630 = zext i32 %628 to i64
%631 = getelementptr inbounds i8, i8* %627, i64 %630
%632 = load i8, i8* %631
%633 = load i8*, i8** %4
%634 = load i32, i32* %6
%635 = add i32 %634, 1
store i32 %635, i32* %6
%636 = zext i32 %634 to i64
%637 = getelementptr inbounds i8, i8* %633, i64 %636
store i8 %632, i8* %637
%638 = load i8*, i8** %4
%639 = load i32, i32* %6
%640 = add i32 %639, 1
store i32 %640, i32* %6
%641 = zext i32 %639 to i64
%642 = getelementptr inbounds i8, i8* %638, i64 %641
store i8 48, i8* %642
%643 = load i8*, i8** %3
%644 = load i32, i32* %5
%645 = add i32 %644, 1
store i32 %645, i32* %5
%646 = zext i32 %644 to i64
%647 = getelementptr inbounds i8, i8* %643, i64 %646
%648 = load i8, i8* %647
%649 = load i8*, i8** %4
%650 = load i32, i32* %6
%651 = add i32 %650, 1
store i32 %651, i32* %6
%652 = zext i32 %650 to i64
%653 = getelementptr inbounds i8, i8* %649, i64 %652
store i8 %648, i8* %653
br label %951
654: ; preds = %617, %609
%655 = load i8*, i8** %3
%656 = load i32, i32* %5
%657 = zext i32 %656 to i64
%658 = getelementptr inbounds i8, i8* %655, i64 %657
%659 = load i8, i8* %658
%660 = sext i8 %659 to i32
%661 = icmp eq i32 %660, 41
br i1 %661, label %662, label %688
662: ; preds = %654
%663 = load i8*, i8** %3
%664 = load i32, i32* %5
%665 = add i32 %664, 1
%666 = zext i32 %665 to i64
%667 = getelementptr inbounds i8, i8* %663, i64 %666
%668 = load i8, i8* %667
%669 = sext i8 %668 to i32
%670 = icmp eq i32 %669, 40
br i1 %670, label %671, label %688
671: ; preds = %662
%672 = load i8*, i8** %3
%673 = load i32, i32* %5
%674 = add i32 %673, 1
store i32 %674, i32* %5
%675 = zext i32 %673 to i64
%676 = getelementptr inbounds i8, i8* %672, i64 %675
%677 = load i8, i8* %676
%678 = load i8*, i8** %4
%679 = load i32, i32* %6
%680 = add i32 %679, 1
store i32 %680, i32* %6
%681 = zext i32 %679 to i64
%682 = getelementptr inbounds i8, i8* %678, i64 %681
store i8 %677, i8* %682
%683 = load i8*, i8** %4
%684 = load i32, i32* %6
%685 = add i32 %684, 1
store i32 %685, i32* %6
%686 = zext i32 %684 to i64
%687 = getelementptr inbounds i8, i8* %683, i64 %686
store i8 42, i8* %687
br label %950
688: ; preds = %662, %654
%689 = load i8*, i8** %3
%690 = load i32, i32* %5
%691 = zext i32 %690 to i64
%692 = getelementptr inbounds i8, i8* %689, i64 %691
%693 = load i8, i8* %692
%694 = sext i8 %693 to i32
%695 = call i32 @isalpha(i32 %694)
%696 = icmp ne i32 %695, 0
br i1 %696, label %697, label %727
697: ; preds = %688
%698 = load i8*, i8** %3
%699 = load i32, i32* %5
%700 = add i32 %699, 1
%701 = zext i32 %700 to i64
%702 = getelementptr inbounds i8, i8* %698, i64 %701
%703 = load i8, i8* %702
%704 = sext i8 %703 to i32
%705 = call i32 @isalpha(i32 %704)
%706 = icmp ne i32 %705, 0
br i1 %706, label %707, label %727
707: ; preds = %697
%708 = load i8*, i8** %3
%709 = load i32, i32* %5
%710 = add i32 %709, 1
store i32 %710, i32* %5
%711 = zext i32 %709 to i64
%712 = getelementptr inbounds i8, i8* %708, i64 %711
%713 = load i8, i8* %712
%714 = sext i8 %713 to i32
%715 = call i32 @toupper(i32 %714)
%716 = trunc i32 %715 to i8
%717 = load i8*, i8** %4
%718 = load i32, i32* %6
%719 = add i32 %718, 1
store i32 %719, i32* %6
%720 = zext i32 %718 to i64
%721 = getelementptr inbounds i8, i8* %717, i64 %720
store i8 %716, i8* %721
%722 = load i8*, i8** %4
%723 = load i32, i32* %6
%724 = add i32 %723, 1
store i32 %724, i32* %6
%725 = zext i32 %723 to i64
%726 = getelementptr inbounds i8, i8* %722, i64 %725
store i8 42, i8* %726
br label %949
727: ; preds = %697, %688
%728 = load i8*, i8** %3
%729 = load i32, i32* %5
%730 = zext i32 %729 to i64
%731 = getelementptr inbounds i8, i8* %728, i64 %730
%732 = load i8, i8* %731
%733 = sext i8 %732 to i32
%734 = call i32 @isalpha(i32 %733)
%735 = icmp ne i32 %734, 0
br i1 %735, label %736, label %765
736: ; preds = %727
%737 = load i8*, i8** %3
%738 = load i32, i32* %5
%739 = add i32 %738, 1
%740 = zext i32 %739 to i64
%741 = getelementptr inbounds i8, i8* %737, i64 %740
%742 = load i8, i8* %741
%743 = sext i8 %742 to i32
%744 = icmp eq i32 %743, 40
br i1 %744, label %745, label %765
745: ; preds = %736
%746 = load i8*, i8** %3
%747 = load i32, i32* %5
%748 = add i32 %747, 1
store i32 %748, i32* %5
%749 = zext i32 %747 to i64
%750 = getelementptr inbounds i8, i8* %746, i64 %749
%751 = load i8, i8* %750
%752 = sext i8 %751 to i32
%753 = call i32 @toupper(i32 %752)
%754 = trunc i32 %753 to i8
%755 = load i8*, i8** %4
%756 = load i32, i32* %6
%757 = add i32 %756, 1
store i32 %757, i32* %6
%758 = zext i32 %756 to i64
%759 = getelementptr inbounds i8, i8* %755, i64 %758
store i8 %754, i8* %759
%760 = load i8*, i8** %4
%761 = load i32, i32* %6
%762 = add i32 %761, 1
store i32 %762, i32* %6
%763 = zext i32 %761 to i64
%764 = getelementptr inbounds i8, i8* %760, i64 %763
store i8 42, i8* %764
br label %948
765: ; preds = %736, %727
%766 = load i8*, i8** %3
%767 = load i32, i32* %5
%768 = zext i32 %767 to i64
%769 = getelementptr inbounds i8, i8* %766, i64 %768
%770 = load i8, i8* %769
%771 = sext i8 %770 to i32
%772 = icmp eq i32 %771, 41
br i1 %772, label %773, label %800
773: ; preds = %765
%774 = load i8*, i8** %3
%775 = load i32, i32* %5
%776 = add i32 %775, 1
%777 = zext i32 %776 to i64
%778 = getelementptr inbounds i8, i8* %774, i64 %777
%779 = load i8, i8* %778
%780 = sext i8 %779 to i32
%781 = call i32 @isalpha(i32 %780)
%782 = icmp ne i32 %781, 0
br i1 %782, label %783, label %800
783: ; preds = %773
%784 = load i8*, i8** %3
%785 = load i32, i32* %5
%786 = add i32 %785, 1
store i32 %786, i32* %5
%787 = zext i32 %785 to i64
%788 = getelementptr inbounds i8, i8* %784, i64 %787
%789 = load i8, i8* %788
%790 = load i8*, i8** %4
%791 = load i32, i32* %6
%792 = add i32 %791, 1
store i32 %792, i32* %6
%793 = zext i32 %791 to i64
%794 = getelementptr inbounds i8, i8* %790, i64 %793
store i8 %789, i8* %794
%795 = load i8*, i8** %4
%796 = load i32, i32* %6
%797 = add i32 %796, 1
store i32 %797, i32* %6
%798 = zext i32 %796 to i64
%799 = getelementptr inbounds i8, i8* %795, i64 %798
store i8 42, i8* %799
br label %947
800: ; preds = %773, %765
%801 = load i8*, i8** %3
%802 = load i32, i32* %5
%803 = zext i32 %802 to i64
%804 = getelementptr inbounds i8, i8* %801, i64 %803
%805 = load i8, i8* %804
%806 = sext i8 %805 to i32
%807 = call i32 @isdigit(i32 %806)
%808 = icmp ne i32 %807, 0
br i1 %808, label %809, label %835
809: ; preds = %800
%810 = load i8*, i8** %3
%811 = load i32, i32* %5
%812 = add i32 %811, 1
%813 = zext i32 %812 to i64
%814 = getelementptr inbounds i8, i8* %810, i64 %813
%815 = load i8, i8* %814
%816 = sext i8 %815 to i32
%817 = icmp eq i32 %816, 40
br i1 %817, label %818, label %835
818: ; preds = %809
%819 = load i8*, i8** %3
%820 = load i32, i32* %5
%821 = add i32 %820, 1
store i32 %821, i32* %5
%822 = zext i32 %820 to i64
%823 = getelementptr inbounds i8, i8* %819, i64 %822
%824 = load i8, i8* %823
%825 = load i8*, i8** %4
%826 = load i32, i32* %6
%827 = add i32 %826, 1
store i32 %827, i32* %6
%828 = zext i32 %826 to i64
%829 = getelementptr inbounds i8, i8* %825, i64 %828
store i8 %824, i8* %829
%830 = load i8*, i8** %4
%831 = load i32, i32* %6
%832 = add i32 %831, 1
store i32 %832, i32* %6
%833 = zext i32 %831 to i64
%834 = getelementptr inbounds i8, i8* %830, i64 %833
store i8 42, i8* %834
br label %946
835: ; preds = %809, %800
%836 = load i8*, i8** %3
%837 = load i32, i32* %5
%838 = zext i32 %837 to i64
%839 = getelementptr inbounds i8, i8* %836, i64 %838
%840 = load i8, i8* %839
%841 = sext i8 %840 to i32
%842 = call i32 @isdigit(i32 %841)
%843 = icmp ne i32 %842, 0
br i1 %843, label %844, label %871
844: ; preds = %835
%845 = load i8*, i8** %3
%846 = load i32, i32* %5
%847 = add i32 %846, 1
%848 = zext i32 %847 to i64
%849 = getelementptr inbounds i8, i8* %845, i64 %848
%850 = load i8, i8* %849
%851 = sext i8 %850 to i32
%852 = call i32 @isalpha(i32 %851)
%853 = icmp ne i32 %852, 0
br i1 %853, label %854, label %871
854: ; preds = %844
%855 = load i8*, i8** %3
%856 = load i32, i32* %5
%857 = add i32 %856, 1
store i32 %857, i32* %5
%858 = zext i32 %856 to i64
%859 = getelementptr inbounds i8, i8* %855, i64 %858
%860 = load i8, i8* %859
%861 = load i8*, i8** %4
%862 = load i32, i32* %6
%863 = add i32 %862, 1
store i32 %863, i32* %6
%864 = zext i32 %862 to i64
%865 = getelementptr inbounds i8, i8* %861, i64 %864
store i8 %860, i8* %865
%866 = load i8*, i8** %4
%867 = load i32, i32* %6
%868 = add i32 %867, 1
store i32 %868, i32* %6
%869 = zext i32 %867 to i64
%870 = getelementptr inbounds i8, i8* %866, i64 %869
store i8 42, i8* %870
br label %945
871: ; preds = %844, %835
%872 = load i8*, i8** %3
%873 = load i32, i32* %5
%874 = zext i32 %873 to i64
%875 = getelementptr inbounds i8, i8* %872, i64 %874
%876 = load i8, i8* %875
%877 = sext i8 %876 to i32
%878 = call i32 @isalpha(i32 %877)
%879 = icmp ne i32 %878, 0
br i1 %879, label %880, label %907
880: ; preds = %871
%881 = load i8*, i8** %3
%882 = load i32, i32* %5
%883 = add i32 %882, 1
%884 = zext i32 %883 to i64
%885 = getelementptr inbounds i8, i8* %881, i64 %884
%886 = load i8, i8* %885
%887 = sext i8 %886 to i32
%888 = call i32 @isdigit(i32 %887)
%889 = icmp ne i32 %888, 0
br i1 %889, label %890, label %907
890: ; preds = %880
%891 = load i8*, i8** %3
%892 = load i32, i32* %5
%893 = add i32 %892, 1
store i32 %893, i32* %5
%894 = zext i32 %892 to i64
%895 = getelementptr inbounds i8, i8* %891, i64 %894
%896 = load i8, i8* %895
%897 = load i8*, i8** %4
%898 = load i32, i32* %6
%899 = add i32 %898, 1
store i32 %899, i32* %6
%900 = zext i32 %898 to i64
%901 = getelementptr inbounds i8, i8* %897, i64 %900
store i8 %896, i8* %901
%902 = load i8*, i8** %4
%903 = load i32, i32* %6
%904 = add i32 %903, 1
store i32 %904, i32* %6
%905 = zext i32 %903 to i64
%906 = getelementptr inbounds i8, i8* %902, i64 %905
store i8 42, i8* %906
br label %944
907: ; preds = %880, %871
%908 = load i8*, i8** %3
%909 = load i32, i32* %5
%910 = zext i32 %909 to i64
%911 = getelementptr inbounds i8, i8* %908, i64 %910
%912 = load i8, i8* %911
%913 = sext i8 %912 to i32
%914 = call i32 @isalpha(i32 %913)
%915 = icmp ne i32 %914, 0
br i1 %915, label %916, label %931
916: ; preds = %907
%917 = load i8*, i8** %3
%918 = load i32, i32* %5
%919 = add i32 %918, 1
store i32 %919, i32* %5
%920 = zext i32 %918 to i64
%921 = getelementptr inbounds i8, i8* %917, i64 %920
%922 = load i8, i8* %921
%923 = sext i8 %922 to i32
%924 = call i32 @toupper(i32 %923)
%925 = trunc i32 %924 to i8
%926 = load i8*, i8** %4
%927 = load i32, i32* %6
%928 = add i32 %927, 1
store i32 %928, i32* %6
%929 = zext i32 %927 to i64
%930 = getelementptr inbounds i8, i8* %926, i64 %929
store i8 %925, i8* %930
br label %943
931: ; preds = %907
%932 = load i8*, i8** %3
%933 = load i32, i32* %5
%934 = add i32 %933, 1
store i32 %934, i32* %5
%935 = zext i32 %933 to i64
%936 = getelementptr inbounds i8, i8* %932, i64 %935
%937 = load i8, i8* %936
%938 = load i8*, i8** %4
%939 = load i32, i32* %6
%940 = add i32 %939, 1
store i32 %940, i32* %6
%941 = zext i32 %939 to i64
%942 = getelementptr inbounds i8, i8* %938, i64 %941
store i8 %937, i8* %942
br label %943
943: ; preds = %931, %916
br label %944
944: ; preds = %943, %890
br label %945
945: ; preds = %944, %854
br label %946
946: ; preds = %945, %818
br label %947
947: ; preds = %946, %783
br label %948
948: ; preds = %947, %745
br label %949
949: ; preds = %948, %707
br label %950
950: ; preds = %949, %671
br label %951
951: ; preds = %950, %626
br label %952
952: ; preds = %951, %592
br label %953
953: ; preds = %952, %570
br label %954
954: ; preds = %953, %552
br label %955
955: ; preds = %954, %534
br label %956
956: ; preds = %955, %517
br label %957
957: ; preds = %956, %500
br label %958
958: ; preds = %957, %483
br label %959
959: ; preds = %958, %466
br label %960
960: ; preds = %959, %449
br label %961
961: ; preds = %960, %432
br label %962
962: ; preds = %961, %415
br label %963
963: ; preds = %962, %398
br label %964
964: ; preds = %963, %381
br label %965
965: ; preds = %964, %364
br label %966
966: ; preds = %965, %347
br label %967
967: ; preds = %966, %330
br label %968
968: ; preds = %967, %313
br label %969
969: ; preds = %968, %296
br label %970
970: ; preds = %969, %279
br label %971
971: ; preds = %970, %262
br label %972
972: ; preds = %971, %245
br label %973
973: ; preds = %972, %228
br label %974
974: ; preds = %973, %204
br label %975
975: ; preds = %974, %187
br label %976
976: ; preds = %975, %170
br label %977
977: ; preds = %976, %146
br label %978
978: ; preds = %977, %125
br label %979
979: ; preds = %978, %97
br label %980
980: ; preds = %979, %89
br label %7
981: ; preds = %7
%982 = load i8*, i8** %4
%983 = load i32, i32* %6
%984 = zext i32 %983 to i64
%985 = getelementptr inbounds i8, i8* %982, i64 %984
store i8 0, i8* %985
ret void
}

LLVM IR (-O2):
@.str = [8 x i8] c"resComp\00"
@.str.1 = [4 x i8] c"res\00"
@.str.2 = [4 x i8] c"ans\00"
@.str.3 = [5 x i8] c"sqrt\00"
@.str.4 = [4 x i8] c"sin\00"
@.str.5 = [4 x i8] c"sen\00"
@.str.6 = [4 x i8] c"cos\00"
@.str.7 = [4 x i8] c"tan\00"
@.str.8 = [5 x i8] c"asin\00"
@.str.9 = [5 x i8] c"asen\00"
@.str.10 = [5 x i8] c"acos\00"
@.str.11 = [5 x i8] c"atan\00"
@.str.12 = [4 x i8] c"exp\00"
@.str.13 = [3 x i8] c"ln\00"
@.str.14 = [4 x i8] c"log\00"
@.str.15 = [3 x i8] c"sh\00"
@.str.16 = [3 x i8] c"ch\00"
@.str.17 = [3 x i8] c"th\00"
@.str.18 = [4 x i8] c"ash\00"
@.str.19 = [4 x i8] c"ach\00"
@.str.20 = [4 x i8] c"ath\00"
@.str.21 = [4 x i8] c"pow\00"
@.str.22 = [7 x i8] c"gamma'\00"
@.str.23 = [10 x i8] c"factorial\00"
@.str.24 = [6 x i8] c"betha\00"
@.str.25 = [5 x i8] c"prim\00"
@.str.26 = [6 x i8] c"gamma\00"
@.str.27 = [3 x i8] c"pi\00"
@.str.29 = [3 x i8] c"r2\00"
define void @pretraducir(i8* %0, i8* writeonly %1) {
br label %3
3: ; preds = %40, %2
%4 = phi i32 [ 0, %2 ], [ %41, %40 ]
%5 = phi i32 [ 0, %2 ], [ %42, %40 ]
%6 = zext i32 %4 to i64
%7 = getelementptr inbounds i8, i8* %0, i64 %6
%8 = load i8, i8* %7
switch i8 %8, label %32 [
i8 0, label %405
i8 105, label %9
]
9: ; preds = %3
%10 = add i32 %4, 1
%11 = zext i32 %10 to i64
%12 = getelementptr inbounds i8, i8* %0, i64 %11
%13 = load i8, i8* %12
%14 = sext i8 %13 to i32
%15 = tail call i32 (i32, ...) bitcast (i32 (...)* @esOperador to i32 (i32, ...)*)(i32 %14)
%16 = icmp eq i32 %15, 0
br i1 %16, label %17, label %27
17: ; preds = %9
%18 = load i8, i8* %12
switch i8 %18, label %19 [
i8 0, label %27
i8 41, label %27
i8 33, label %27
]
19: ; preds = %17
%20 = load i8, i8* %7
%21 = add i32 %5, 1
%22 = zext i32 %5 to i64
%23 = getelementptr inbounds i8, i8* %1, i64 %22
store i8 %20, i8* %23
%24 = add i32 %5, 2
%25 = zext i32 %21 to i64
%26 = getelementptr inbounds i8, i8* %1, i64 %25
store i8 42, i8* %26
br label %40
27: ; preds = %17, %17, %17, %9
%28 = load i8, i8* %7
%29 = add i32 %5, 1
%30 = zext i32 %5 to i64
%31 = getelementptr inbounds i8, i8* %1, i64 %30
store i8 %28, i8* %31
br label %40
32: ; preds = %3
%33 = tail call i32 @strncmp(i8* dereferenceable(1) %7, i8* dereferenceable(8) getelementptr inbounds ([8 x i8], [8 x i8]* @.str, i64 0, i64 0), i64 7)
%34 = icmp eq i32 %33, 0
br i1 %34, label %35, label %43
35: ; preds = %32
%36 = zext i32 %5 to i64
%37 = getelementptr inbounds i8, i8* %1, i64 %36
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(7) %37, i8* align 1 dereferenceable(8) getelementptr inbounds ([8 x i8], [8 x i8]* @.str, i64 0, i64 0), i64 7, i1 false)
%38 = add i32 %5, 7
%39 = add i32 %4, 7
br label %40
40: ; preds = %35, %57, %76, %95, %111, %127, %143, %159, %175, %191, %207, %223, %239, %254, %278, %316, %345, %372, %395, %401, %388, %361, %327, %296, %263, %246, %231, %215, %199, %183, %167, %151, %135, %119, %103, %84, %68, %49, %19, %27
%41 = phi i32 [ %10, %27 ], [ %10, %19 ], [ %39, %35 ], [ %53, %49 ], [ %61, %57 ], [ %72, %68 ], [ %80, %76 ], [ %88, %84 ], [ %99, %95 ], [ %107, %103 ], [ %115, %111 ], [ %123, %119 ], [ %131, %127 ], [ %139, %135 ], [ %147, %143 ], [ %155, %151 ], [ %163, %159 ], [ %171, %167 ], [ %179, %175 ], [ %187, %183 ], [ %195, %191 ], [ %203, %199 ], [ %211, %207 ], [ %219, %215 ], [ %227, %223 ], [ %235, %231 ], [ %243, %239 ], [ %250, %246 ], [ %258, %254 ], [ 1, %263 ], [ %285, %278 ], [ %291, %296 ], [ %309, %316 ], [ %309, %327 ], [ %338, %345 ], [ %356, %361 ], [ %356, %372 ], [ %380, %388 ], [ %380, %395 ], [ %380, %401 ]
%42 = phi i32 [ %29, %27 ], [ %24, %19 ], [ %38, %35 ], [ %52, %49 ], [ %58, %57 ], [ %69, %68 ], [ %77, %76 ], [ %85, %84 ], [ %96, %95 ], [ %104, %103 ], [ %112, %111 ], [ %120, %119 ], [ %128, %127 ], [ %136, %135 ], [ %144, %143 ], [ %152, %151 ], [ %160, %159 ], [ %168, %167 ], [ %176, %175 ], [ %184, %183 ], [ %192, %191 ], [ %200, %199 ], [ %208, %207 ], [ %216, %215 ], [ %224, %223 ], [ %232, %231 ], [ %242, %239 ], [ %249, %246 ], [ %257, %254 ], [ %268, %263 ], [ %287, %278 ], [ %300, %296 ], [ %322, %316 ], [ %333, %327 ], [ %349, %345 ], [ %365, %361 ], [ %376, %372 ], [ %392, %388 ], [ %398, %395 ], [ %402, %401 ]
br label %3
43: ; preds = %32
%44 = tail call i32 @strncmp(i8* dereferenceable(1) %7, i8* dereferenceable(4) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), i64 3)
%45 = icmp eq i32 %44, 0
br i1 %45, label %49, label %46
46: ; preds = %43
%47 = tail call i32 @strncmp(i8* dereferenceable(1) %7, i8* dereferenceable(4) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0), i64 3)
%48 = icmp eq i32 %47, 0
br i1 %48, label %49, label %54
49: ; preds = %46, %43
%50 = zext i32 %5 to i64
%51 = getelementptr inbounds i8, i8* %1, i64 %50
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(3) %51, i8* align 1 dereferenceable(4) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), i64 3, i1 false)
%52 = add i32 %5, 3
%53 = add i32 %4, 3
br label %40
54: ; preds = %46
%55 = tail call i32 @strncmp(i8* dereferenceable(1) %7, i8* dereferenceable(5) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.3, i64 0, i64 0), i64 4)
%56 = icmp eq i32 %55, 0
br i1 %56, label %57, label %62
57: ; preds = %54
%58 = add i32 %5, 1
%59 = zext i32 %5 to i64
%60 = getelementptr inbounds i8, i8* %1, i64 %59
store i8 97, i8* %60
%61 = add i32 %4, 4
br label %40
62: ; preds = %54
%63 = tail call i32 @strncmp(i8* dereferenceable(1) %7, i8* dereferenceable(4) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.4, i64 0, i64 0), i64 3)
%64 = icmp eq i32 %63, 0
br i1 %64, label %68, label %65
65: ; preds = %62
%66 = tail call i32 @strncmp(i8* dereferenceable(1) %7, i8* dereferenceable(4) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.5, i64 0, i64 0), i64 3)
%67 = icmp eq i32 %66, 0
br i1 %67, label %68, label %73
68: ; preds = %65, %62
%69 = add i32 %5, 1
%70 = zext i32 %5 to i64
%71 = getelementptr inbounds i8, i8* %1, i64 %70
store i8 98, i8* %71
%72 = add i32 %4, 3
br label %40
73: ; preds = %65
%74 = tail call i32 @strncmp(i8* dereferenceable(1) %7, i8* dereferenceable(4) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.6, i64 0, i64 0), i64 3)
%75 = icmp eq i32 %74, 0
br i1 %75, label %76, label %81
76: ; preds = %73
%77 = add i32 %5, 1
%78 = zext i32 %5 to i64
%79 = getelementptr inbounds i8, i8* %1, i64 %78
store i8 99, i8* %79
%80 = add i32 %4, 3
br label %40
81: ; preds = %73
%82 = tail call i32 @strncmp(i8* dereferenceable(1) %7, i8* dereferenceable(4) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.7, i64 0, i64 0), i64 3)
%83 = icmp eq i32 %82, 0
br i1 %83, label %84, label %89
84: ; preds = %81
%85 = add i32 %5, 1
%86 = zext i32 %5 to i64
%87 = getelementptr inbounds i8, i8* %1, i64 %86
store i8 100, i8* %87
%88 = add i32 %4, 3
br label %40
89: ; preds = %81
%90 = tail call i32 @strncmp(i8* dereferenceable(1) %7, i8* dereferenceable(5) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.8, i64 0, i64 0), i64 4)
%91 = icmp eq i32 %90, 0
br i1 %91, label %95, label %92
92: ; preds = %89
%93 = tail call i32 @strncmp(i8* dereferenceable(1) %7, i8* dereferenceable(5) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.9, i64 0, i64 0), i64 4)
%94 = icmp eq i32 %93, 0
br i1 %94, label %95, label %100
95: ; preds = %92, %89
%96 = add i32 %5, 1
%97 = zext i32 %5 to i64
%98 = getelementptr inbounds i8, i8* %1, i64 %97
store i8 101, i8* %98
%99 = add i32 %4, 4
br label %40
100: ; preds = %92
%101 = tail call i32 @strncmp(i8* dereferenceable(1) %7, i8* dereferenceable(5) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.10, i64 0, i64 0), i64 4)
%102 = icmp eq i32 %101, 0
br i1 %102, label %103, label %108
103: ; preds = %100
%104 = add i32 %5, 1
%105 = zext i32 %5 to i64
%106 = getelementptr inbounds i8, i8* %1, i64 %105
store i8 102, i8* %106
%107 = add i32 %4, 4
br label %40
108: ; preds = %100
%109 = tail call i32 @strncmp(i8* dereferenceable(1) %7, i8* dereferenceable(5) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.11, i64 0, i64 0), i64 4)
%110 = icmp eq i32 %109, 0
br i1 %110, label %111, label %116
111: ; preds = %108
%112 = add i32 %5, 1
%113 = zext i32 %5 to i64
%114 = getelementptr inbounds i8, i8* %1, i64 %113
store i8 103, i8* %114
%115 = add i32 %4, 4
br label %40
116: ; preds = %108
%117 = tail call i32 @strncmp(i8* dereferenceable(1) %7, i8* dereferenceable(4) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.12, i64 0, i64 0), i64 3)
%118 = icmp eq i32 %117, 0
br i1 %118, label %119, label %124
119: ; preds = %116
%120 = add i32 %5, 1
%121 = zext i32 %5 to i64
%122 = getelementptr inbounds i8, i8* %1, i64 %121
store i8 104, i8* %122
%123 = add i32 %4, 3
br label %40
124: ; preds = %116
%125 = tail call i32 @strncmp(i8* dereferenceable(1) %7, i8* dereferenceable(3) getelementptr inbounds ([3 x i8], [3 x i8]* @.str.13, i64 0, i64 0), i64 2)
%126 = icmp eq i32 %125, 0
br i1 %126, label %127, label %132
127: ; preds = %124
%128 = add i32 %5, 1
%129 = zext i32 %5 to i64
%130 = getelementptr inbounds i8, i8* %1, i64 %129
store i8 122, i8* %130
%131 = add i32 %4, 2
br label %40
132: ; preds = %124
%133 = tail call i32 @strncmp(i8* dereferenceable(1) %7, i8* dereferenceable(4) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.14, i64 0, i64 0), i64 3)
%134 = icmp eq i32 %133, 0
br i1 %134, label %135, label %140
135: ; preds = %132
%136 = add i32 %5, 1
%137 = zext i32 %5 to i64
%138 = getelementptr inbounds i8, i8* %1, i64 %137
store i8 107, i8* %138
%139 = add i32 %4, 3
br label %40
140: ; preds = %132
%141 = tail call i32 @strncmp(i8* dereferenceable(1) %7, i8* dereferenceable(3) getelementptr inbounds ([3 x i8], [3 x i8]* @.str.15, i64 0, i64 0), i64 2)
%142 = icmp eq i32 %141, 0
br i1 %142, label %143, label %148
143: ; preds = %140
%144 = add i32 %5, 1
%145 = zext i32 %5 to i64
%146 = getelementptr inbounds i8, i8* %1, i64 %145
store i8 108, i8* %146
%147 = add i32 %4, 2
br label %40
148: ; preds = %140
%149 = tail call i32 @strncmp(i8* dereferenceable(1) %7, i8* dereferenceable(3) getelementptr inbounds ([3 x i8], [3 x i8]* @.str.16, i64 0, i64 0), i64 2)
%150 = icmp eq i32 %149, 0
br i1 %150, label %151, label %156
151: ; preds = %148
%152 = add i32 %5, 1
%153 = zext i32 %5 to i64
%154 = getelementptr inbounds i8, i8* %1, i64 %153
store i8 109, i8* %154
%155 = add i32 %4, 2
br label %40
156: ; preds = %148
%157 = tail call i32 @strncmp(i8* dereferenceable(1) %7, i8* dereferenceable(3) getelementptr inbounds ([3 x i8], [3 x i8]* @.str.17, i64 0, i64 0), i64 2)
%158 = icmp eq i32 %157, 0
br i1 %158, label %159, label %164
159: ; preds = %156
%160 = add i32 %5, 1
%161 = zext i32 %5 to i64
%162 = getelementptr inbounds i8, i8* %1, i64 %161
store i8 110, i8* %162
%163 = add i32 %4, 2
br label %40
164: ; preds = %156
%165 = tail call i32 @strncmp(i8* dereferenceable(1) %7, i8* dereferenceable(4) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.18, i64 0, i64 0), i64 3)
%166 = icmp eq i32 %165, 0
br i1 %166, label %167, label %172
167: ; preds = %164
%168 = add i32 %5, 1
%169 = zext i32 %5 to i64
%170 = getelementptr inbounds i8, i8* %1, i64 %169
store i8 111, i8* %170
%171 = add i32 %4, 3
br label %40
172: ; preds = %164
%173 = tail call i32 @strncmp(i8* dereferenceable(1) %7, i8* dereferenceable(4) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.19, i64 0, i64 0), i64 3)
%174 = icmp eq i32 %173, 0
br i1 %174, label %175, label %180
175: ; preds = %172
%176 = add i32 %5, 1
%177 = zext i32 %5 to i64
%178 = getelementptr inbounds i8, i8* %1, i64 %177
store i8 112, i8* %178
%179 = add i32 %4, 3
br label %40
180: ; preds = %172
%181 = tail call i32 @strncmp(i8* dereferenceable(1) %7, i8* dereferenceable(4) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.20, i64 0, i64 0), i64 3)
%182 = icmp eq i32 %181, 0
br i1 %182, label %183, label %188
183: ; preds = %180
%184 = add i32 %5, 1
%185 = zext i32 %5 to i64
%186 = getelementptr inbounds i8, i8* %1, i64 %185
store i8 113, i8* %186
%187 = add i32 %4, 3
br label %40
188: ; preds = %180
%189 = tail call i32 @strncmp(i8* dereferenceable(1) %7, i8* dereferenceable(4) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.21, i64 0, i64 0), i64 3)
%190 = icmp eq i32 %189, 0
br i1 %190, label %191, label %196
191: ; preds = %188
%192 = add i32 %5, 1
%193 = zext i32 %5 to i64
%194 = getelementptr inbounds i8, i8* %1, i64 %193
store i8 114, i8* %194
%195 = add i32 %4, 3
br label %40
196: ; preds = %188
%197 = tail call i32 @strncmp(i8* dereferenceable(1) %7, i8* dereferenceable(7) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.22, i64 0, i64 0), i64 6)
%198 = icmp eq i32 %197, 0
br i1 %198, label %199, label %204
199: ; preds = %196
%200 = add i32 %5, 1
%201 = zext i32 %5 to i64
%202 = getelementptr inbounds i8, i8* %1, i64 %201
store i8 119, i8* %202
%203 = add i32 %4, 6
br label %40
204: ; preds = %196
%205 = tail call i32 @strncmp(i8* dereferenceable(1) %7, i8* dereferenceable(10) getelementptr inbounds ([10 x i8], [10 x i8]* @.str.23, i64 0, i64 0), i64 9)
%206 = icmp eq i32 %205, 0
br i1 %206, label %207, label %212
207: ; preds = %204
%208 = add i32 %5, 1
%209 = zext i32 %5 to i64
%210 = getelementptr inbounds i8, i8* %1, i64 %209
store i8 116, i8* %210
%211 = add i32 %4, 9
br label %40
212: ; preds = %204
%213 = tail call i32 @strncmp(i8* dereferenceable(1) %7, i8* dereferenceable(6) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.24, i64 0, i64 0), i64 5)
%214 = icmp eq i32 %213, 0
br i1 %214, label %215, label %220
215: ; preds = %212
%216 = add i32 %5, 1
%217 = zext i32 %5 to i64
%218 = getelementptr inbounds i8, i8* %1, i64 %217
store i8 117, i8* %218
%219 = add i32 %4, 5
br label %40
220: ; preds = %212
%221 = tail call i32 @strncmp(i8* dereferenceable(1) %7, i8* dereferenceable(5) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.25, i64 0, i64 0), i64 4)
%222 = icmp eq i32 %221, 0
br i1 %222, label %223, label %228
223: ; preds = %220
%224 = add i32 %5, 1
%225 = zext i32 %5 to i64
%226 = getelementptr inbounds i8, i8* %1, i64 %225
store i8 118, i8* %226
%227 = add i32 %4, 4
br label %40
228: ; preds = %220
%229 = tail call i32 @strncmp(i8* dereferenceable(1) %7, i8* dereferenceable(6) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.26, i64 0, i64 0), i64 5)
%230 = icmp eq i32 %229, 0
br i1 %230, label %231, label %236
231: ; preds = %228
%232 = add i32 %5, 1
%233 = zext i32 %5 to i64
%234 = getelementptr inbounds i8, i8* %1, i64 %233
store i8 115, i8* %234
%235 = add i32 %4, 5
br label %40
236: ; preds = %228
%237 = tail call i32 @strncmp(i8* dereferenceable(1) %7, i8* dereferenceable(3) getelementptr inbounds ([3 x i8], [3 x i8]* @.str.27, i64 0, i64 0), i64 2)
%238 = icmp eq i32 %237, 0
br i1 %238, label %239, label %244
239: ; preds = %236
%240 = zext i32 %5 to i64
%241 = getelementptr inbounds i8, i8* %1, i64 %240
store i8 85, i8* %241
%242 = add i32 %5, 1
%243 = add i32 %4, 2
br label %40
244: ; preds = %236
%245 = icmp eq i8 %8, 101
br i1 %245, label %246, label %251
246: ; preds = %244
%247 = zext i32 %5 to i64
%248 = getelementptr inbounds i8, i8* %1, i64 %247
store i8 86, i8* %248
%249 = add i32 %5, 1
%250 = add i32 %4, 1
br label %40
251: ; preds = %244
%252 = tail call i32 @strncmp(i8* %7, i8* dereferenceable(3) getelementptr inbounds ([3 x i8], [3 x i8]* @.str.29, i64 0, i64 0), i64 2)
%253 = icmp eq i32 %252, 0
br i1 %253, label %254, label %259
254: ; preds = %251
%255 = zext i32 %5 to i64
%256 = getelementptr inbounds i8, i8* %1, i64 %255
store i8 87, i8* %256
%257 = add i32 %5, 1
%258 = add i32 %4, 2
br label %40
259: ; preds = %251
%260 = icmp eq i32 %4, 0
%261 = icmp eq i8 %8, 45
%262 = select i1 %260, i1 %261, i1 false
br i1 %262, label %263, label %271
263: ; preds = %259
%264 = add i32 %5, 1
%265 = zext i32 %5 to i64
%266 = getelementptr inbounds i8, i8* %1, i64 %265
store i8 48, i8* %266
%267 = load i8, i8* %7
%268 = add i32 %5, 2
%269 = zext i32 %264 to i64
%270 = getelementptr inbounds i8, i8* %1, i64 %269
store i8 %267, i8* %270
br label %40
271: ; preds = %259
switch i8 %8, label %303 [
i8 40, label %272
i8 41, label %290
]
272: ; preds = %271
%273 = add i32 %4, 1
%274 = zext i32 %273 to i64
%275 = getelementptr inbounds i8, i8* %0, i64 %274
%276 = load i8, i8* %275
%277 = icmp eq i8 %276, 45
br i1 %277, label %278, label %303
278: ; preds = %272
%279 = add i32 %5, 1
%280 = zext i32 %5 to i64
%281 = getelementptr inbounds i8, i8* %1, i64 %280
store i8 40, i8* %281
%282 = add i32 %5, 2
%283 = zext i32 %279 to i64
%284 = getelementptr inbounds i8, i8* %1, i64 %283
store i8 48, i8* %284
%285 = add i32 %4, 2
%286 = load i8, i8* %275
%287 = add i32 %5, 3
%288 = zext i32 %282 to i64
%289 = getelementptr inbounds i8, i8* %1, i64 %288
store i8 %286, i8* %289
br label %40
290: ; preds = %271
%291 = add i32 %4, 1
%292 = zext i32 %291 to i64
%293 = getelementptr inbounds i8, i8* %0, i64 %292
%294 = load i8, i8* %293
%295 = icmp eq i8 %294, 40
br i1 %295, label %296, label %303
296: ; preds = %290
%297 = add i32 %5, 1
%298 = zext i32 %5 to i64
%299 = getelementptr inbounds i8, i8* %1, i64 %298
store i8 41, i8* %299
%300 = add i32 %5, 2
%301 = zext i32 %297 to i64
%302 = getelementptr inbounds i8, i8* %1, i64 %301
store i8 42, i8* %302
br label %40
303: ; preds = %271, %272, %290
%304 = phi i1 [ true, %290 ], [ false, %272 ], [ false, %271 ]
%305 = sext i8 %8 to i32
%306 = tail call i32 @isalpha(i32 %305)
%307 = icmp eq i32 %306, 0
br i1 %307, label %336, label %308
308: ; preds = %303
%309 = add i32 %4, 1
%310 = zext i32 %309 to i64
%311 = getelementptr inbounds i8, i8* %0, i64 %310
%312 = load i8, i8* %311
%313 = sext i8 %312 to i32
%314 = tail call i32 @isalpha(i32 %313)
%315 = icmp eq i32 %314, 0
br i1 %315, label %325, label %316
316: ; preds = %308
%317 = tail call i32 @toupper(i32 %305)
%318 = trunc i32 %317 to i8
%319 = add i32 %5, 1
%320 = zext i32 %5 to i64
%321 = getelementptr inbounds i8, i8* %1, i64 %320
store i8 %318, i8* %321
%322 = add i32 %5, 2
%323 = zext i32 %319 to i64
%324 = getelementptr inbounds i8, i8* %1, i64 %323
store i8 42, i8* %324
br label %40
325: ; preds = %308
%326 = icmp eq i8 %312, 40
br i1 %326, label %327, label %336
327: ; preds = %325
%328 = tail call i32 @toupper(i32 %305)
%329 = trunc i32 %328 to i8
%330 = add i32 %5, 1
%331 = zext i32 %5 to i64
%332 = getelementptr inbounds i8, i8* %1, i64 %331
store i8 %329, i8* %332
%333 = add i32 %5, 2
%334 = zext i32 %330 to i64
%335 = getelementptr inbounds i8, i8* %1, i64 %334
store i8 42, i8* %335
br label %40
336: ; preds = %303, %325
br i1 %304, label %337, label %352
337: ; preds = %336
%338 = add i32 %4, 1
%339 = zext i32 %338 to i64
%340 = getelementptr inbounds i8, i8* %0, i64 %339
%341 = load i8, i8* %340
%342 = sext i8 %341 to i32
%343 = tail call i32 @isalpha(i32 %342)
%344 = icmp eq i32 %343, 0
br i1 %344, label %352, label %345
345: ; preds = %337
%346 = add i32 %5, 1
%347 = zext i32 %5 to i64
%348 = getelementptr inbounds i8, i8* %1, i64 %347
store i8 %8, i8* %348
%349 = add i32 %5, 2
%350 = zext i32 %346 to i64
%351 = getelementptr inbounds i8, i8* %1, i64 %350
store i8 42, i8* %351
br label %40
352: ; preds = %337, %336
%353 = add nsw i32 %305, -48
%354 = icmp ult i32 %353, 10
br i1 %354, label %355, label %379
355: ; preds = %352
%356 = add i32 %4, 1
%357 = zext i32 %356 to i64
%358 = getelementptr inbounds i8, i8* %0, i64 %357
%359 = load i8, i8* %358
%360 = icmp eq i8 %359, 40
br i1 %360, label %361, label %368
361: ; preds = %355
%362 = add i32 %5, 1
%363 = zext i32 %5 to i64
%364 = getelementptr inbounds i8, i8* %1, i64 %363
store i8 %8, i8* %364
%365 = add i32 %5, 2
%366 = zext i32 %362 to i64
%367 = getelementptr inbounds i8, i8* %1, i64 %366
store i8 42, i8* %367
br label %40
368: ; preds = %355
%369 = sext i8 %359 to i32
%370 = tail call i32 @isalpha(i32 %369)
%371 = icmp eq i32 %370, 0
br i1 %371, label %379, label %372
372: ; preds = %368
%373 = add i32 %5, 1
%374 = zext i32 %5 to i64
%375 = getelementptr inbounds i8, i8* %1, i64 %374
store i8 %8, i8* %375
%376 = add i32 %5, 2
%377 = zext i32 %373 to i64
%378 = getelementptr inbounds i8, i8* %1, i64 %377
store i8 42, i8* %378
br label %40
379: ; preds = %352, %368
%380 = add i32 %4, 1
br i1 %307, label %401, label %381
381: ; preds = %379
%382 = zext i32 %380 to i64
%383 = getelementptr inbounds i8, i8* %0, i64 %382
%384 = load i8, i8* %383
%385 = sext i8 %384 to i32
%386 = add nsw i32 %385, -48
%387 = icmp ult i32 %386, 10
br i1 %387, label %388, label %395
388: ; preds = %381
%389 = add i32 %5, 1
%390 = zext i32 %5 to i64
%391 = getelementptr inbounds i8, i8* %1, i64 %390
store i8 %8, i8* %391
%392 = add i32 %5, 2
%393 = zext i32 %389 to i64
%394 = getelementptr inbounds i8, i8* %1, i64 %393
store i8 42, i8* %394
br label %40
395: ; preds = %381
%396 = tail call i32 @toupper(i32 %305)
%397 = trunc i32 %396 to i8
%398 = add i32 %5, 1
%399 = zext i32 %5 to i64
%400 = getelementptr inbounds i8, i8* %1, i64 %399
store i8 %397, i8* %400
br label %40
401: ; preds = %379
%402 = add i32 %5, 1
%403 = zext i32 %5 to i64
%404 = getelementptr inbounds i8, i8* %1, i64 %403
store i8 %8, i8* %404
br label %40
405: ; preds = %3
%406 = zext i32 %5 to i64
%407 = getelementptr inbounds i8, i8* %1, i64 %406
store i8 0, i8* %407
ret void
}