#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ esOperador(char);
unsigned int evaluar_prioridad(char);
int /*<<< orphan*/ isdigit(char);
int strlen(char *);
scalar_t__ strncmp(char *, char *, int);
int /*<<< orphan*/ strncpy(char *, char *, int);
void traducir_a_postfijo(char *infijo, char *postfijo) {
  int i = 0, k = -1, n = -1;
  unsigned int prioridad;
  char pila[65535];
  while (infijo[i] != '\0') {
    if (strncmp(&infijo[i], "resComp", strlen("resComp")) == 0) {
      ++k;
      strncpy(&postfijo[k], "resComp", strlen("resComp"));
      k += strlen("resComp") - 1;
      i += strlen("resComp") - 1;
    } else if (strncmp(&infijo[i], "res", strlen("res")) == 0) {
      ++k;
      strncpy(&postfijo[k], "res", strlen("res"));
      k += strlen("res") - 1;
      i += strlen("res") - 1;
    } else {
      prioridad = evaluar_prioridad(infijo[i]);
      switch (prioridad) {
      case 6:
        k++;
        postfijo[k] = infijo[i];
        if (isdigit(infijo[i]) &&
            (esOperador(infijo[i + 1]) || (infijo[i + 1] == ')') ||
             (infijo[i + 1] == '\0') || (infijo[i + 1] == ',') ||
             (infijo[i + 1] == '!'))) {
          k++;
          postfijo[k] = ',';
          if (infijo[i + 1] == ',')
            i++;
        }
        break;
      case 1:
        pila[++n] = infijo[i];
        break;
      case 4:
        pila[++n] = infijo[i];
        break;
      case 0:
        while (pila[n] != '(')
          postfijo[++k] = pila[n--];
        n--;
        break;
      default:
        while (n != -1) {
          if (evaluar_prioridad(infijo[i]) <= evaluar_prioridad(pila[n]))
            postfijo[++k] = pila[n--];
          else
            break;
        }
        pila[++n] = infijo[i];
      }
    }
    i++;
  }
  while (n != -1) {
    k++;
    postfijo[k] = pila[n];
    n--;
  }
  k++;
  postfijo[k] = '\0';
  return;
}


x86 assembly (clang, -O0):
<traducir_a_postfijo>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10050,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movl   $0x0,-0x14(%rbp)
movl   $0xffffffff,-0x18(%rbp)
movl   $0xffffffff,-0x1c(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
je     1578 <traducir_a_postfijo+0x418>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x10028(%rbp)
lea    0xe66(%rip),%rdi
call   1060 <strlen@plt>
mov    -0x10028(%rbp),%rdi
mov    %eax,%edx
lea    0xe51(%rip),%rsi
call   1040 <strncmp@plt>
cmp    $0x0,%rax
jne    1245 <traducir_a_postfijo+0xe5>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x10030(%rbp)
lea    0xe20(%rip),%rdi
call   1060 <strlen@plt>
mov    -0x10030(%rbp),%rdi
mov    %eax,%edx
lea    0xe0b(%rip),%rsi
call   1030 <strncpy@plt>
lea    0xdff(%rip),%rdi
call   1060 <strlen@plt>
sub    $0x1,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
lea    0xdea(%rip),%rdi
call   1060 <strlen@plt>
sub    $0x1,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
jmp    156a <traducir_a_postfijo+0x40a>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x10038(%rbp)
lea    0xdc6(%rip),%rdi
call   1060 <strlen@plt>
mov    -0x10038(%rbp),%rdi
mov    %eax,%edx
lea    0xdb1(%rip),%rsi
call   1040 <strncmp@plt>
cmp    $0x0,%rax
jne    12ed <traducir_a_postfijo+0x18d>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x10040(%rbp)
lea    0xd80(%rip),%rdi
call   1060 <strlen@plt>
mov    -0x10040(%rbp),%rdi
mov    %eax,%edx
lea    0xd6b(%rip),%rsi
call   1030 <strncpy@plt>
lea    0xd5f(%rip),%rdi
call   1060 <strlen@plt>
sub    $0x1,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
lea    0xd4a(%rip),%rdi
call   1060 <strlen@plt>
sub    $0x1,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
jmp    1565 <traducir_a_postfijo+0x405>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1070 <evaluar_prioridad@plt>
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
mov    %rax,-0x10048(%rbp)
sub    $0x6,%rax
ja     14c6 <traducir_a_postfijo+0x366>
mov    -0x10048(%rbp),%rax
lea    0xcdd(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1050 <isdigit@plt>
cmp    $0x0,%eax
je     1429 <traducir_a_postfijo+0x2c9>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%edi
call   1080 <esOperador@plt>
cmp    $0x0,%eax
jne    13ec <traducir_a_postfijo+0x28c>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x29,%eax
je     13ec <traducir_a_postfijo+0x28c>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
je     13ec <traducir_a_postfijo+0x28c>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x2c,%eax
je     13ec <traducir_a_postfijo+0x28c>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x21,%eax
jne    1429 <traducir_a_postfijo+0x2c9>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
movb   $0x2c,(%rax,%rcx,1)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x2c,%eax
jne    1424 <traducir_a_postfijo+0x2c4>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1429 <traducir_a_postfijo+0x2c9>
jmp    1560 <traducir_a_postfijo+0x400>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
cltq
mov    %cl,-0x10020(%rbp,%rax,1)
jmp    1560 <traducir_a_postfijo+0x400>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
cltq
mov    %cl,-0x10020(%rbp,%rax,1)
jmp    1560 <traducir_a_postfijo+0x400>
jmp    1477 <traducir_a_postfijo+0x317>
movslq -0x1c(%rbp),%rax
movsbl -0x10020(%rbp,%rax,1),%eax
ff
cmp    $0x28,%eax
je     14b8 <traducir_a_postfijo+0x358>
mov    -0x1c(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x1c(%rbp)
cltq
mov    -0x10020(%rbp,%rax,1),%dl
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,-0x18(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
jmp    1477 <traducir_a_postfijo+0x317>
mov    -0x1c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
jmp    1560 <traducir_a_postfijo+0x400>
jmp    14cb <traducir_a_postfijo+0x36b>
cmpl   $0xffffffff,-0x1c(%rbp)
je     1543 <traducir_a_postfijo+0x3e3>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1070 <evaluar_prioridad@plt>
mov    %eax,-0x1004c(%rbp)
movslq -0x1c(%rbp),%rax
movsbl -0x10020(%rbp,%rax,1),%edi
ff
call   1070 <evaluar_prioridad@plt>
mov    %eax,%ecx
mov    -0x1004c(%rbp),%eax
cmp    %ecx,%eax
ja     1539 <traducir_a_postfijo+0x3d9>
mov    -0x1c(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x1c(%rbp)
cltq
mov    -0x10020(%rbp,%rax,1),%dl
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,-0x18(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
jmp    153e <traducir_a_postfijo+0x3de>
jmp    1543 <traducir_a_postfijo+0x3e3>
jmp    14cb <traducir_a_postfijo+0x36b>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
cltq
mov    %cl,-0x10020(%rbp,%rax,1)
jmp    1565 <traducir_a_postfijo+0x405>
jmp    156a <traducir_a_postfijo+0x40a>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1188 <traducir_a_postfijo+0x28>
jmp    157d <traducir_a_postfijo+0x41d>
cmpl   $0xffffffff,-0x1c(%rbp)
je     15b4 <traducir_a_postfijo+0x454>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
movslq -0x1c(%rbp),%rax
mov    -0x10020(%rbp,%rax,1),%dl
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x1c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
jmp    157d <traducir_a_postfijo+0x41d>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
add    $0x10050,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<traducir_a_postfijo>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x10048,%rsp
cmpb   $0x0,(%rdi)
je     149a <traducir_a_postfijo+0x33a>
mov    %rdi,%r13
mov    %rsi,0x10(%rsp)
lea    0x1(%rsi),%rax
mov    %rax,0x28(%rsp)
mov    $0xffffffff,%eax
mov    %rax,(%rsp)
xor    %r15d,%r15d
lea    0xe7e(%rip),%r14
mov    %rdi,%rbx
mov    $0xffffffff,%r12d
mov    %rdi,0x20(%rsp)
jmp    120f <traducir_a_postfijo+0xaf>
xchg   %ax,%ax
movslq %r12d,%rax
mov    0x10(%rsp),%rcx
lea    (%rax,%rcx,1),%rbx
add    $0x1,%rbx
mov    %r14,%rdi
call   1060 <strlen@plt>
mov    %rbx,%rdi
mov    %r14,%rsi
mov    %eax,%edx
call   1030 <strncpy@plt>
mov    %r14,%rdi
call   1060 <strlen@plt>
mov    %eax,%ebx
add    %r12d,%ebx
mov    %r14,%rdi
call   1060 <strlen@plt>
add    %eax,%r15d
add    $0xffffffff,%r15d
mov    %ebx,%r12d
movslq %r15d,%rax
lea    0x1(%rax),%r15
lea    (%rax,%r13,1),%rbx
add    $0x1,%rbx
cmpb   $0x0,0x1(%r13,%rax,1)
je     1475 <traducir_a_postfijo+0x315>
mov    %r14,%rdi
call   1060 <strlen@plt>
mov    %rbx,%rdi
mov    %r14,%rsi
mov    %eax,%edx
call   1040 <strncmp@plt>
test   %rax,%rax
je     11b0 <traducir_a_postfijo+0x50>
lea    0xdf4(%rip),%rbp
mov    %rbp,%rdi
call   1060 <strlen@plt>
mov    %rbx,%rdi
mov    %rbp,%rsi
mov    %eax,%edx
call   1040 <strncmp@plt>
test   %rax,%rax
je     1280 <traducir_a_postfijo+0x120>
movsbl (%rbx),%edi
call   1070 <evaluar_prioridad@plt>
cmp    $0x6,%eax
ja     1304 <traducir_a_postfijo+0x1a4>
mov    %eax,%eax
lea    0xd9c(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    (%rbx),%al
mov    (%rsp),%rcx
movslq %ecx,%rcx
jmp    145c <traducir_a_postfijo+0x2fc>
nopl   0x0(%rax,%rax,1)
movslq %r12d,%rax
mov    0x10(%rsp),%rcx
lea    (%rax,%rcx,1),%rbx
add    $0x1,%rbx
mov    %rbp,%rdi
call   1060 <strlen@plt>
mov    %rbx,%rdi
mov    %rbp,%rsi
mov    %eax,%edx
call   1030 <strncpy@plt>
mov    %rbp,%rdi
call   1060 <strlen@plt>
mov    %eax,%ebx
add    %r12d,%ebx
mov    %rbp,%rdi
jmp    11e5 <traducir_a_postfijo+0x85>
mov    (%rsp),%rdi
movslq %edi,%rax
mov    0x40(%rsp,%rax,1),%cl
cmp    $0x28,%cl
je     12f8 <traducir_a_postfijo+0x198>
movslq %r12d,%rdx
add    0x28(%rsp),%rdx
lea    0x3f(%rsp),%rsi
add    %rsi,%rax
xor    %esi,%esi
nopl   0x0(%rax)
mov    %cl,(%rdx,%rsi,1)
movzbl (%rax),%ecx
add    $0x1,%rsi
add    $0xffffffffffffffff,%rax
cmp    $0x28,%cl
jne    12e0 <traducir_a_postfijo+0x180>
add    %esi,%r12d
sub    %esi,%edi
add    $0xffffffff,%edi
mov    %rdi,(%rsp)
jmp    11f4 <traducir_a_postfijo+0x94>
mov    $0xffffffff,%ecx
mov    (%rsp),%rax
cmp    $0xffffffff,%eax
je     1457 <traducir_a_postfijo+0x2f7>
mov    %r15,0x8(%rsp)
movslq %eax,%r15
movslq %r12d,%r13
mov    %r12,0x30(%rsp)
add    %r12d,%eax
add    $0x1,%eax
mov    %eax,0x1c(%rsp)
add    0x28(%rsp),%r13
lea    (%rsp,%r15,1),%rax
add    $0x40,%rax
mov    %rax,0x38(%rsp)
not    %r15
xor    %r14d,%r14d
nopl   0x0(%rax,%rax,1)
movsbl (%rbx),%edi
call   1070 <evaluar_prioridad@plt>
mov    %eax,%ebp
mov    0x38(%rsp),%rax
movzbl (%rax,%r14,1),%r12d
movsbl %r12b,%edi
call   1070 <evaluar_prioridad@plt>
cmp    %eax,%ebp
ja     1435 <traducir_a_postfijo+0x2d5>
mov    %r12b,0x0(%r13)
add    $0xffffffffffffffff,%r14
add    $0x1,%r13
cmp    %r14,%r15
jne    1350 <traducir_a_postfijo+0x1f0>
mov    0x1c(%rsp),%eax
mov    %eax,%r12d
mov    0x20(%rsp),%r13
lea    0xc83(%rip),%r14
mov    0x8(%rsp),%r15
mov    $0xffffffff,%ecx
jmp    1457 <traducir_a_postfijo+0x2f7>
mov    %r15,0x8(%rsp)
movslq %r12d,%r15
lea    0x1(%r15),%r12
mov    (%rbx),%al
mov    0x10(%rsp),%rcx
mov    %al,0x1(%rcx,%r15,1)
movsbl (%rbx),%edi
call   1050 <isdigit@plt>
test   %eax,%eax
je     142b <traducir_a_postfijo+0x2cb>
mov    0x8(%rsp),%rbp
movslq %ebp,%rbx
movsbl 0x1(%r13,%rbx,1),%edi
add    $0x1,%rbx
call   1080 <esOperador@plt>
test   %eax,%eax
jne    1408 <traducir_a_postfijo+0x2a8>
movzbl 0x0(%r13,%rbx,1),%eax
cmp    $0x2c,%rax
ja     142b <traducir_a_postfijo+0x2cb>
movabs $0x120200000001,%rcx
bt     %rax,%rcx
mov    0x8(%rsp),%rbp
jae    146d <traducir_a_postfijo+0x30d>
mov    0x10(%rsp),%rax
movb   $0x2c,0x2(%rax,%r15,1)
add    $0x2,%r15
cmpb   $0x2c,0x0(%r13,%rbx,1)
cmove  %ebx,%ebp
mov    %r15d,%r12d
mov    %rbp,%r15
jmp    11f4 <traducir_a_postfijo+0x94>
mov    0x8(%rsp),%r15
jmp    11f4 <traducir_a_postfijo+0x94>
mov    (%rsp),%rax
add    %r14d,%eax
mov    0x30(%rsp),%r12
sub    %r14d,%r12d
mov    %eax,%ecx
mov    0x20(%rsp),%r13
lea    0xbca(%rip),%r14
mov    0x8(%rsp),%r15
mov    (%rbx),%al
movslq %ecx,%rcx
mov    %al,0x41(%rsp,%rcx,1)
add    $0x1,%rcx
mov    %rcx,(%rsp)
jmp    11f4 <traducir_a_postfijo+0x94>
mov    %rbp,%r15
jmp    11f4 <traducir_a_postfijo+0x94>
mov    (%rsp),%rax
cmp    $0xffffffff,%eax
je     14a5 <traducir_a_postfijo+0x345>
cltq
movslq %r12d,%rbp
lea    0x1(%rax),%r8
cmp    $0x20,%r8
mov    0x10(%rsp),%rsi
jae    14af <traducir_a_postfijo+0x34f>
mov    %rbp,%r12
jmp    1570 <traducir_a_postfijo+0x410>
mov    $0xffffffff,%r12d
jmp    1584 <traducir_a_postfijo+0x424>
mov    0x10(%rsp),%rsi
jmp    1584 <traducir_a_postfijo+0x424>
mov    %r8,%rcx
and    $0xffffffffffffffe0,%rcx
lea    (%rcx,%rbp,1),%r12
mov    %rcx,%rdx
neg    %rdx
lea    (%rsp,%rax,1),%rdi
add    $0x31,%rdi
sub    %rcx,%rax
add    %rsi,%rbp
add    $0x11,%rbp
xor    %ebx,%ebx
pxor   %xmm0,%xmm0
nopl   0x0(%rax,%rax,1)
movdqu -0x10(%rdi,%rbx,1),%xmm1
movdqu (%rdi,%rbx,1),%xmm2
movdqa %xmm2,%xmm3
punpcklbw %xmm0,%xmm3
pshufd $0x4e,%xmm3,%xmm3
pshuflw $0x1b,%xmm3,%xmm3
pshufhw $0x1b,%xmm3,%xmm3
punpckhbw %xmm0,%xmm2
pshufd $0x4e,%xmm2,%xmm2
pshuflw $0x1b,%xmm2,%xmm2
pshufhw $0x1b,%xmm2,%xmm2
packuswb %xmm3,%xmm2
movdqa %xmm1,%xmm3
punpcklbw %xmm0,%xmm3
pshufd $0x4e,%xmm3,%xmm3
pshuflw $0x1b,%xmm3,%xmm3
pshufhw $0x1b,%xmm3,%xmm3
punpckhbw %xmm0,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm3,%xmm1
movdqu %xmm2,-0x10(%rbp)
movdqu %xmm1,0x0(%rbp)
add    $0xffffffffffffffe0,%rbx
add    $0x20,%rbp
cmp    %rbx,%rdx
jne    14e0 <traducir_a_postfijo+0x380>
cmp    %rcx,%r8
je     1584 <traducir_a_postfijo+0x424>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movzbl 0x40(%rsp,%rax,1),%ecx
mov    %cl,0x1(%rsi,%r12,1)
add    $0x1,%r12
add    $0xffffffffffffffff,%rax
jb     1570 <traducir_a_postfijo+0x410>
movslq %r12d,%rax
movb   $0x0,0x1(%rax,%rsi,1)
add    $0x10048,%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"
define void @traducir_a_postfijo(i8* %0, i8* %1) {
%3 = alloca i8*
%4 = alloca i8*
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca [65535 x i8]
store i8* %0, i8** %3
store i8* %1, i8** %4
store i32 0, i32* %5
store i32 -1, i32* %6
store i32 -1, i32* %7
br label %10
10: ; preds = %244, %2
%11 = load i8*, i8** %3
%12 = load i32, i32* %5
%13 = sext i32 %12 to i64
%14 = getelementptr inbounds i8, i8* %11, i64 %13
%15 = load i8, i8* %14
%16 = sext i8 %15 to i32
%17 = icmp ne i32 %16, 0
br i1 %17, label %18, label %247
18: ; preds = %10
%19 = load i8*, i8** %3
%20 = load i32, i32* %5
%21 = sext i32 %20 to i64
%22 = getelementptr inbounds i8, i8* %19, i64 %21
%23 = call i32 @strlen(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str, i64 0, i64 0))
%24 = call i64 @strncmp(i8* %22, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str, i64 0, i64 0), i32 %23)
%25 = icmp eq i64 %24, 0
br i1 %25, label %26, label %43
26: ; preds = %18
%27 = load i32, i32* %6
%28 = add nsw i32 %27, 1
store i32 %28, i32* %6
%29 = load i8*, i8** %4
%30 = load i32, i32* %6
%31 = sext i32 %30 to i64
%32 = getelementptr inbounds i8, i8* %29, i64 %31
%33 = call i32 @strlen(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str, i64 0, i64 0))
%34 = call i32 @strncpy(i8* %32, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str, i64 0, i64 0), i32 %33)
%35 = call i32 @strlen(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str, i64 0, i64 0))
%36 = sub nsw i32 %35, 1
%37 = load i32, i32* %6
%38 = add nsw i32 %37, %36
store i32 %38, i32* %6
%39 = call i32 @strlen(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str, i64 0, i64 0))
%40 = sub nsw i32 %39, 1
%41 = load i32, i32* %5
%42 = add nsw i32 %41, %40
store i32 %42, i32* %5
br label %244
43: ; preds = %18
%44 = load i8*, i8** %3
%45 = load i32, i32* %5
%46 = sext i32 %45 to i64
%47 = getelementptr inbounds i8, i8* %44, i64 %46
%48 = call i32 @strlen(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0))
%49 = call i64 @strncmp(i8* %47, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), i32 %48)
%50 = icmp eq i64 %49, 0
br i1 %50, label %51, label %68
51: ; preds = %43
%52 = load i32, i32* %6
%53 = add nsw i32 %52, 1
store i32 %53, i32* %6
%54 = load i8*, i8** %4
%55 = load i32, i32* %6
%56 = sext i32 %55 to i64
%57 = getelementptr inbounds i8, i8* %54, i64 %56
%58 = call i32 @strlen(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0))
%59 = call i32 @strncpy(i8* %57, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), i32 %58)
%60 = call i32 @strlen(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0))
%61 = sub nsw i32 %60, 1
%62 = load i32, i32* %6
%63 = add nsw i32 %62, %61
store i32 %63, i32* %6
%64 = call i32 @strlen(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0))
%65 = sub nsw i32 %64, 1
%66 = load i32, i32* %5
%67 = add nsw i32 %66, %65
store i32 %67, i32* %5
br label %243
68: ; preds = %43
%69 = load i8*, i8** %3
%70 = load i32, i32* %5
%71 = sext i32 %70 to i64
%72 = getelementptr inbounds i8, i8* %69, i64 %71
%73 = load i8, i8* %72
%74 = call i32 @evaluar_prioridad(i8 signext %73)
store i32 %74, i32* %8
%75 = load i32, i32* %8
switch i32 %75, label %202 [
i32 6, label %76
i32 1, label %160
i32 4, label %170
i32 0, label %180
]
76: ; preds = %68
%77 = load i32, i32* %6
%78 = add nsw i32 %77, 1
store i32 %78, i32* %6
%79 = load i8*, i8** %3
%80 = load i32, i32* %5
%81 = sext i32 %80 to i64
%82 = getelementptr inbounds i8, i8* %79, i64 %81
%83 = load i8, i8* %82
%84 = load i8*, i8** %4
%85 = load i32, i32* %6
%86 = sext i32 %85 to i64
%87 = getelementptr inbounds i8, i8* %84, i64 %86
store i8 %83, i8* %87
%88 = load i8*, i8** %3
%89 = load i32, i32* %5
%90 = sext i32 %89 to i64
%91 = getelementptr inbounds i8, i8* %88, i64 %90
%92 = load i8, i8* %91
%93 = call i32 @isdigit(i8 signext %92)
%94 = icmp ne i32 %93, 0
br i1 %94, label %95, label %159
95: ; preds = %76
%96 = load i8*, i8** %3
%97 = load i32, i32* %5
%98 = add nsw i32 %97, 1
%99 = sext i32 %98 to i64
%100 = getelementptr inbounds i8, i8* %96, i64 %99
%101 = load i8, i8* %100
%102 = call i32 @esOperador(i8 signext %101)
%103 = icmp ne i32 %102, 0
br i1 %103, label %140, label %104
104: ; preds = %95
%105 = load i8*, i8** %3
%106 = load i32, i32* %5
%107 = add nsw i32 %106, 1
%108 = sext i32 %107 to i64
%109 = getelementptr inbounds i8, i8* %105, i64 %108
%110 = load i8, i8* %109
%111 = sext i8 %110 to i32
%112 = icmp eq i32 %111, 41
br i1 %112, label %140, label %113
113: ; preds = %104
%114 = load i8*, i8** %3
%115 = load i32, i32* %5
%116 = add nsw i32 %115, 1
%117 = sext i32 %116 to i64
%118 = getelementptr inbounds i8, i8* %114, i64 %117
%119 = load i8, i8* %118
%120 = sext i8 %119 to i32
%121 = icmp eq i32 %120, 0
br i1 %121, label %140, label %122
122: ; preds = %113
%123 = load i8*, i8** %3
%124 = load i32, i32* %5
%125 = add nsw i32 %124, 1
%126 = sext i32 %125 to i64
%127 = getelementptr inbounds i8, i8* %123, i64 %126
%128 = load i8, i8* %127
%129 = sext i8 %128 to i32
%130 = icmp eq i32 %129, 44
br i1 %130, label %140, label %131
131: ; preds = %122
%132 = load i8*, i8** %3
%133 = load i32, i32* %5
%134 = add nsw i32 %133, 1
%135 = sext i32 %134 to i64
%136 = getelementptr inbounds i8, i8* %132, i64 %135
%137 = load i8, i8* %136
%138 = sext i8 %137 to i32
%139 = icmp eq i32 %138, 33
br i1 %139, label %140, label %159
140: ; preds = %131, %122, %113, %104, %95
%141 = load i32, i32* %6
%142 = add nsw i32 %141, 1
store i32 %142, i32* %6
%143 = load i8*, i8** %4
%144 = load i32, i32* %6
%145 = sext i32 %144 to i64
%146 = getelementptr inbounds i8, i8* %143, i64 %145
store i8 44, i8* %146
%147 = load i8*, i8** %3
%148 = load i32, i32* %5
%149 = add nsw i32 %148, 1
%150 = sext i32 %149 to i64
%151 = getelementptr inbounds i8, i8* %147, i64 %150
%152 = load i8, i8* %151
%153 = sext i8 %152 to i32
%154 = icmp eq i32 %153, 44
br i1 %154, label %155, label %158
155: ; preds = %140
%156 = load i32, i32* %5
%157 = add nsw i32 %156, 1
store i32 %157, i32* %5
br label %158
158: ; preds = %155, %140
br label %159
159: ; preds = %158, %131, %76
br label %242
160: ; preds = %68
%161 = load i8*, i8** %3
%162 = load i32, i32* %5
%163 = sext i32 %162 to i64
%164 = getelementptr inbounds i8, i8* %161, i64 %163
%165 = load i8, i8* %164
%166 = load i32, i32* %7
%167 = add nsw i32 %166, 1
store i32 %167, i32* %7
%168 = sext i32 %167 to i64
%169 = getelementptr inbounds [65535 x i8], [65535 x i8]* %9, i64 0, i64 %168
store i8 %165, i8* %169
br label %242
170: ; preds = %68
%171 = load i8*, i8** %3
%172 = load i32, i32* %5
%173 = sext i32 %172 to i64
%174 = getelementptr inbounds i8, i8* %171, i64 %173
%175 = load i8, i8* %174
%176 = load i32, i32* %7
%177 = add nsw i32 %176, 1
store i32 %177, i32* %7
%178 = sext i32 %177 to i64
%179 = getelementptr inbounds [65535 x i8], [65535 x i8]* %9, i64 0, i64 %178
store i8 %175, i8* %179
br label %242
180: ; preds = %68
br label %181
181: ; preds = %188, %180
%182 = load i32, i32* %7
%183 = sext i32 %182 to i64
%184 = getelementptr inbounds [65535 x i8], [65535 x i8]* %9, i64 0, i64 %183
%185 = load i8, i8* %184
%186 = sext i8 %185 to i32
%187 = icmp ne i32 %186, 40
br i1 %187, label %188, label %199
188: ; preds = %181
%189 = load i32, i32* %7
%190 = add nsw i32 %189, -1
store i32 %190, i32* %7
%191 = sext i32 %189 to i64
%192 = getelementptr inbounds [65535 x i8], [65535 x i8]* %9, i64 0, i64 %191
%193 = load i8, i8* %192
%194 = load i8*, i8** %4
%195 = load i32, i32* %6
%196 = add nsw i32 %195, 1
store i32 %196, i32* %6
%197 = sext i32 %196 to i64
%198 = getelementptr inbounds i8, i8* %194, i64 %197
store i8 %193, i8* %198
br label %181
199: ; preds = %181
%200 = load i32, i32* %7
%201 = add nsw i32 %200, -1
store i32 %201, i32* %7
br label %242
202: ; preds = %68
br label %203
203: ; preds = %231, %202
%204 = load i32, i32* %7
%205 = icmp ne i32 %204, -1
br i1 %205, label %206, label %232
206: ; preds = %203
%207 = load i8*, i8** %3
%208 = load i32, i32* %5
%209 = sext i32 %208 to i64
%210 = getelementptr inbounds i8, i8* %207, i64 %209
%211 = load i8, i8* %210
%212 = call i32 @evaluar_prioridad(i8 signext %211)
%213 = load i32, i32* %7
%214 = sext i32 %213 to i64
%215 = getelementptr inbounds [65535 x i8], [65535 x i8]* %9, i64 0, i64 %214
%216 = load i8, i8* %215
%217 = call i32 @evaluar_prioridad(i8 signext %216)
%218 = icmp ule i32 %212, %217
br i1 %218, label %219, label %230
219: ; preds = %206
%220 = load i32, i32* %7
%221 = add nsw i32 %220, -1
store i32 %221, i32* %7
%222 = sext i32 %220 to i64
%223 = getelementptr inbounds [65535 x i8], [65535 x i8]* %9, i64 0, i64 %222
%224 = load i8, i8* %223
%225 = load i8*, i8** %4
%226 = load i32, i32* %6
%227 = add nsw i32 %226, 1
store i32 %227, i32* %6
%228 = sext i32 %227 to i64
%229 = getelementptr inbounds i8, i8* %225, i64 %228
store i8 %224, i8* %229
br label %231
230: ; preds = %206
br label %232
231: ; preds = %219
br label %203
232: ; preds = %230, %203
%233 = load i8*, i8** %3
%234 = load i32, i32* %5
%235 = sext i32 %234 to i64
%236 = getelementptr inbounds i8, i8* %233, i64 %235
%237 = load i8, i8* %236
%238 = load i32, i32* %7
%239 = add nsw i32 %238, 1
store i32 %239, i32* %7
%240 = sext i32 %239 to i64
%241 = getelementptr inbounds [65535 x i8], [65535 x i8]* %9, i64 0, i64 %240
store i8 %237, i8* %241
br label %242
242: ; preds = %232, %199, %170, %160, %159
br label %243
243: ; preds = %242, %51
br label %244
244: ; preds = %243, %26
%245 = load i32, i32* %5
%246 = add nsw i32 %245, 1
store i32 %246, i32* %5
br label %10
247: ; preds = %10
br label %248
248: ; preds = %251, %247
%249 = load i32, i32* %7
%250 = icmp ne i32 %249, -1
br i1 %250, label %251, label %264
251: ; preds = %248
%252 = load i32, i32* %6
%253 = add nsw i32 %252, 1
store i32 %253, i32* %6
%254 = load i32, i32* %7
%255 = sext i32 %254 to i64
%256 = getelementptr inbounds [65535 x i8], [65535 x i8]* %9, i64 0, i64 %255
%257 = load i8, i8* %256
%258 = load i8*, i8** %4
%259 = load i32, i32* %6
%260 = sext i32 %259 to i64
%261 = getelementptr inbounds i8, i8* %258, i64 %260
store i8 %257, i8* %261
%262 = load i32, i32* %7
%263 = add nsw i32 %262, -1
store i32 %263, i32* %7
br label %248
264: ; preds = %248
%265 = load i32, i32* %6
%266 = add nsw i32 %265, 1
store i32 %266, i32* %6
%267 = load i8*, i8** %4
%268 = load i32, i32* %6
%269 = sext i32 %268 to i64
%270 = getelementptr inbounds i8, i8* %267, i64 %269
store i8 0, i8* %270
ret void
}

LLVM IR (-O2):
@.str = [8 x i8] c"resComp\00"
@.str.1 = [4 x i8] c"res\00"
define void @traducir_a_postfijo(i8* %0, i8* %1) {
%3 = alloca [65535 x i8]
%4 = getelementptr inbounds [65535 x i8], [65535 x i8]* %3, i64 0, i64 0
%5 = load i8, i8* %0
%6 = icmp eq i8 %5, 0
br i1 %6, label %190, label %43
7: ; preds = %169
%8 = icmp eq i32 %171, -1
br i1 %8, label %190, label %9
9: ; preds = %7
%10 = sext i32 %171 to i64
%11 = sext i32 %170 to i64
%12 = add nsw i64 %10, 1
%13 = icmp ult i64 %12, 32
br i1 %13, label %40, label %14
14: ; preds = %9
%15 = and i64 %12, -32
%16 = add nsw i64 %15, %11
%17 = sub nsw i64 %10, %15
br label %18
18: ; preds = %18, %14
%19 = phi i64 [ 0, %14 ], [ %36, %18 ]
%20 = add i64 %19, %11
%21 = sub i64 %10, %19
%22 = add nsw i64 %20, 1
%23 = getelementptr inbounds [65535 x i8], [65535 x i8]* %3, i64 0, i64 %21
%24 = getelementptr inbounds i8, i8* %23, i64 -15
%25 = bitcast i8* %24 to <16 x i8>*
%26 = load <16 x i8>, <16 x i8>* %25
%27 = shufflevector <16 x i8> %26, <16 x i8> poison, <16 x i32> <i32 15, i32 14, i32 13, i32 12, i32 11, i32 10, i32 9, i32 8, i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0>
%28 = getelementptr inbounds i8, i8* %23, i64 -31
%29 = bitcast i8* %28 to <16 x i8>*
%30 = load <16 x i8>, <16 x i8>* %29
%31 = shufflevector <16 x i8> %30, <16 x i8> poison, <16 x i32> <i32 15, i32 14, i32 13, i32 12, i32 11, i32 10, i32 9, i32 8, i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0>
%32 = getelementptr inbounds i8, i8* %1, i64 %22
%33 = bitcast i8* %32 to <16 x i8>*
store <16 x i8> %27, <16 x i8>* %33
%34 = getelementptr inbounds i8, i8* %32, i64 16
%35 = bitcast i8* %34 to <16 x i8>*
store <16 x i8> %31, <16 x i8>* %35
%36 = add nuw i64 %19, 32
%37 = icmp eq i64 %36, %15
br i1 %37, label %38, label %18
38: ; preds = %18
%39 = icmp eq i64 %12, %15
br i1 %39, label %187, label %40
40: ; preds = %9, %38
%41 = phi i64 [ %11, %9 ], [ %16, %38 ]
%42 = phi i64 [ %10, %9 ], [ %17, %38 ]
br label %178
43: ; preds = %2, %169
%44 = phi i8* [ %175, %169 ], [ %0, %2 ]
%45 = phi i32 [ %173, %169 ], [ 0, %2 ]
%46 = phi i32 [ %171, %169 ], [ -1, %2 ]
%47 = phi i32 [ %170, %169 ], [ -1, %2 ]
%48 = tail call i32 @strlen(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str, i64 0, i64 0))
%49 = tail call i64 @strncmp(i8* %44, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str, i64 0, i64 0), i32 %48)
%50 = icmp eq i64 %49, 0
br i1 %50, label %51, label %62
51: ; preds = %43
%52 = add nsw i32 %47, 1
%53 = sext i32 %52 to i64
%54 = getelementptr inbounds i8, i8* %1, i64 %53
%55 = tail call i32 @strlen(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str, i64 0, i64 0))
%56 = tail call i32 @strncpy(i8* %54, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str, i64 0, i64 0), i32 %55)
%57 = tail call i32 @strlen(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str, i64 0, i64 0))
%58 = add i32 %57, %47
%59 = tail call i32 @strlen(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str, i64 0, i64 0))
%60 = add nsw i32 %45, -1
%61 = add i32 %60, %59
br label %169
62: ; preds = %43
%63 = tail call i32 @strlen(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0))
%64 = tail call i64 @strncmp(i8* %44, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), i32 %63)
%65 = icmp eq i64 %64, 0
br i1 %65, label %66, label %77
66: ; preds = %62
%67 = add nsw i32 %47, 1
%68 = sext i32 %67 to i64
%69 = getelementptr inbounds i8, i8* %1, i64 %68
%70 = tail call i32 @strlen(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0))
%71 = tail call i32 @strncpy(i8* %69, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), i32 %70)
%72 = tail call i32 @strlen(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0))
%73 = add i32 %72, %47
%74 = tail call i32 @strlen(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0))
%75 = add nsw i32 %45, -1
%76 = add i32 %75, %74
br label %169
77: ; preds = %62
%78 = load i8, i8* %44
%79 = tail call i32 @evaluar_prioridad(i8 signext %78)
switch i32 %79, label %87 [
i32 6, label %94
i32 1, label %118
i32 4, label %123
i32 0, label %80
]
80: ; preds = %77
%81 = sext i32 %46 to i64
%82 = getelementptr inbounds [65535 x i8], [65535 x i8]* %3, i64 0, i64 %81
%83 = load i8, i8* %82
%84 = icmp eq i8 %83, 40
br i1 %84, label %141, label %85
85: ; preds = %80
%86 = sext i32 %47 to i64
br label %128
87: ; preds = %77
%88 = icmp eq i32 %46, -1
br i1 %88, label %162, label %89
89: ; preds = %87
%90 = sext i32 %46 to i64
%91 = sext i32 %47 to i64
%92 = add i32 %47, 1
%93 = add i32 %92, %46
br label %145
94: ; preds = %77
%95 = add nsw i32 %47, 1
%96 = load i8, i8* %44
%97 = sext i32 %95 to i64
%98 = getelementptr inbounds i8, i8* %1, i64 %97
store i8 %96, i8* %98
%99 = load i8, i8* %44
%100 = tail call i32 @isdigit(i8 signext %99)
%101 = icmp eq i32 %100, 0
br i1 %101, label %169, label %102
102: ; preds = %94
%103 = add nsw i32 %45, 1
%104 = sext i32 %103 to i64
%105 = getelementptr inbounds i8, i8* %0, i64 %104
%106 = load i8, i8* %105
%107 = tail call i32 @esOperador(i8 signext %106)
%108 = icmp eq i32 %107, 0
br i1 %108, label %109, label %111
109: ; preds = %102
%110 = load i8, i8* %105
switch i8 %110, label %169 [
i8 41, label %111
i8 0, label %111
i8 44, label %111
i8 33, label %111
]
111: ; preds = %109, %109, %109, %109, %102
%112 = add nsw i32 %47, 2
%113 = sext i32 %112 to i64
%114 = getelementptr inbounds i8, i8* %1, i64 %113
store i8 44, i8* %114
%115 = load i8, i8* %105
%116 = icmp eq i8 %115, 44
%117 = select i1 %116, i32 %103, i32 %45
br label %169
118: ; preds = %77
%119 = load i8, i8* %44
%120 = add nsw i32 %46, 1
%121 = sext i32 %120 to i64
%122 = getelementptr inbounds [65535 x i8], [65535 x i8]* %3, i64 0, i64 %121
store i8 %119, i8* %122
br label %169
123: ; preds = %77
%124 = load i8, i8* %44
%125 = add nsw i32 %46, 1
%126 = sext i32 %125 to i64
%127 = getelementptr inbounds [65535 x i8], [65535 x i8]* %3, i64 0, i64 %126
store i8 %124, i8* %127
br label %169
128: ; preds = %85, %128
%129 = phi i64 [ %86, %85 ], [ %133, %128 ]
%130 = phi i64 [ %81, %85 ], [ %132, %128 ]
%131 = phi i8 [ %83, %85 ], [ %136, %128 ]
%132 = add i64 %130, -1
%133 = add i64 %129, 1
%134 = getelementptr inbounds i8, i8* %1, i64 %133
store i8 %131, i8* %134
%135 = getelementptr inbounds [65535 x i8], [65535 x i8]* %3, i64 0, i64 %132
%136 = load i8, i8* %135
%137 = icmp eq i8 %136, 40
br i1 %137, label %138, label %128
138: ; preds = %128
%139 = trunc i64 %133 to i32
%140 = trunc i64 %132 to i32
br label %141
141: ; preds = %138, %80
%142 = phi i32 [ %47, %80 ], [ %139, %138 ]
%143 = phi i32 [ %46, %80 ], [ %140, %138 ]
%144 = add nsw i32 %143, -1
br label %169
145: ; preds = %89, %154
%146 = phi i64 [ %91, %89 ], [ %156, %154 ]
%147 = phi i64 [ %90, %89 ], [ %155, %154 ]
%148 = load i8, i8* %44
%149 = tail call i32 @evaluar_prioridad(i8 signext %148)
%150 = getelementptr inbounds [65535 x i8], [65535 x i8]* %3, i64 0, i64 %147
%151 = load i8, i8* %150
%152 = tail call i32 @evaluar_prioridad(i8 signext %151)
%153 = icmp ugt i32 %149, %152
br i1 %153, label %159, label %154
154: ; preds = %145
%155 = add nsw i64 %147, -1
%156 = add nsw i64 %146, 1
%157 = getelementptr inbounds i8, i8* %1, i64 %156
store i8 %151, i8* %157
%158 = icmp eq i64 %147, 0
br i1 %158, label %162, label %145
159: ; preds = %145
%160 = trunc i64 %147 to i32
%161 = trunc i64 %146 to i32
br label %162
162: ; preds = %154, %159, %87
%163 = phi i32 [ %47, %87 ], [ %161, %159 ], [ %93, %154 ]
%164 = phi i32 [ -1, %87 ], [ %160, %159 ], [ -1, %154 ]
%165 = load i8, i8* %44
%166 = add nsw i32 %164, 1
%167 = sext i32 %166 to i64
%168 = getelementptr inbounds [65535 x i8], [65535 x i8]* %3, i64 0, i64 %167
store i8 %165, i8* %168
br label %169
169: ; preds = %111, %109, %66, %94, %162, %141, %123, %118, %51
%170 = phi i32 [ %58, %51 ], [ %73, %66 ], [ %163, %162 ], [ %142, %141 ], [ %47, %123 ], [ %47, %118 ], [ %95, %94 ], [ %95, %109 ], [ %112, %111 ]
%171 = phi i32 [ %46, %51 ], [ %46, %66 ], [ %166, %162 ], [ %144, %141 ], [ %125, %123 ], [ %120, %118 ], [ %46, %94 ], [ %46, %109 ], [ %46, %111 ]
%172 = phi i32 [ %61, %51 ], [ %76, %66 ], [ %45, %162 ], [ %45, %141 ], [ %45, %123 ], [ %45, %118 ], [ %45, %94 ], [ %45, %109 ], [ %117, %111 ]
%173 = add nsw i32 %172, 1
%174 = sext i32 %173 to i64
%175 = getelementptr inbounds i8, i8* %0, i64 %174
%176 = load i8, i8* %175
%177 = icmp eq i8 %176, 0
br i1 %177, label %7, label %43
178: ; preds = %40, %178
%179 = phi i64 [ %181, %178 ], [ %41, %40 ]
%180 = phi i64 [ %185, %178 ], [ %42, %40 ]
%181 = add nsw i64 %179, 1
%182 = getelementptr inbounds [65535 x i8], [65535 x i8]* %3, i64 0, i64 %180
%183 = load i8, i8* %182
%184 = getelementptr inbounds i8, i8* %1, i64 %181
store i8 %183, i8* %184
%185 = add nsw i64 %180, -1
%186 = icmp eq i64 %180, 0
br i1 %186, label %187, label %178
187: ; preds = %178, %38
%188 = phi i64 [ %16, %38 ], [ %181, %178 ]
%189 = trunc i64 %188 to i32
br label %190
190: ; preds = %2, %187, %7
%191 = phi i32 [ %170, %7 ], [ %189, %187 ], [ -1, %2 ]
%192 = add nsw i32 %191, 1
%193 = sext i32 %192 to i64
%194 = getelementptr inbounds i8, i8* %1, i64 %193
store i8 0, i8* %194
ret void
}