#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*/ printf(char *, char *);
int /*<<< orphan*/ sprintf(char *, char *, ...);
scalar_t__ strcmp(char *, char *);
int /*<<< orphan*/ strlen(char *);
int /*<<< orphan*/ strncmp(char *, char *, int);
scalar_t__ symchar(char);
void prx_def(char *buf) {
  char tb[256], tbn[256], tty[256];
  char *s, *t, *t1, *sa;
  int ind;
  s = buf;
  t = tb;
  t1 = tty;
  while (symchar(*s))
    *t1++ = *s++;
  *t1++ = 0;
  sprintf(t, "%s", tty);
  t += strlen(t);
  while (*s && (*s <= ' '))
    *t++ = *s++;
  ind = 0;
  while (*s == '*') {
    *t++ = *s++;
    ind++;
  }
  t1 = tbn;
  while (*s && symchar(*s))
    *t1++ = *s++;
  *t1++ = 0;
  sprintf(t, "(*_iproxy_%s)", tbn);
  t += strlen(t);
  sa = s;
  while (*s)
    *t++ = *s++;
  *t++ = 0;
  printf("%s;\n", tb);
  t = tb;
  sprintf(tb, "%s\n\t{ ", buf);
  t += strlen(t);
  if (strcmp(tty, "void") || ind) {
    sprintf(t, "return ");
    t += strlen(t);
  }
  sprintf(t, "_iproxy_%s(", tbn);
  t += strlen(t);
  s = sa;
  while (s && *s != ')') {
    while (*s && (*s != ')') && (*s != ','))
      s++;
    while (!symchar(*(s - 1)))
      s--;
    while (symchar(*(s - 1)))
      s--;
    if (!strncmp(s, "void)", 5))
      break;
    while (symchar(*s))
      *t++ = *s++;
    while (*s && (*s != ')') && (*s != ','))
      s++;
    if (*s == ',') {
      s++;
      *t++ = ',';
      *t++ = ' ';
    }
  }
  sprintf(t, "); }\n");
  t += strlen(t);
  printf("%s\n", tb);
}


x86 assembly (clang, -O0):
<prx_def>:
push   %rbp
mov    %rsp,%rbp
sub    $0x340,%rsp
mov    %rdi,-0x8(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x318(%rbp)
lea    -0x110(%rbp),%rax
mov    %rax,-0x320(%rbp)
lea    -0x310(%rbp),%rax
mov    %rax,-0x328(%rbp)
mov    -0x318(%rbp),%rax
movsbl (%rax),%edi
call   1040 <symchar@plt>
cmp    $0x0,%rax
je     11e2 <prx_def+0x82>
mov    -0x318(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x318(%rbp)
mov    (%rax),%cl
mov    -0x328(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x328(%rbp)
mov    %cl,(%rax)
jmp    1196 <prx_def+0x36>
mov    -0x328(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x328(%rbp)
movb   $0x0,(%rax)
mov    -0x320(%rbp),%rdi
lea    -0x310(%rbp),%rdx
lea    0xdf1(%rip),%rsi
mov    $0x0,%al
call   1080 <sprintf@plt>
mov    -0x320(%rbp),%rdi
call   1050 <strlen@plt>
mov    %eax,%ecx
mov    -0x320(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x320(%rbp)
mov    -0x318(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x335(%rbp)
je     1269 <prx_def+0x109>
mov    -0x318(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x20,%eax
setle  %al
mov    %al,-0x335(%rbp)
mov    -0x335(%rbp),%al
test   $0x1,%al
jne    127c <prx_def+0x11c>
jmp    12af <prx_def+0x14f>
mov    -0x318(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x318(%rbp)
mov    (%rax),%cl
mov    -0x320(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x320(%rbp)
mov    %cl,(%rax)
jmp    1238 <prx_def+0xd8>
movl   $0x0,-0x334(%rbp)
mov    -0x318(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x2a,%eax
jne    130e <prx_def+0x1ae>
mov    -0x318(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x318(%rbp)
mov    (%rax),%cl
mov    -0x320(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x320(%rbp)
mov    %cl,(%rax)
mov    -0x334(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x334(%rbp)
jmp    12b9 <prx_def+0x159>
lea    -0x210(%rbp),%rax
mov    %rax,-0x328(%rbp)
mov    -0x318(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x336(%rbp)
je     1353 <prx_def+0x1f3>
mov    -0x318(%rbp),%rax
movsbl (%rax),%edi
call   1040 <symchar@plt>
cmp    $0x0,%rax
setne  %al
mov    %al,-0x336(%rbp)
mov    -0x336(%rbp),%al
test   $0x1,%al
jne    1366 <prx_def+0x206>
jmp    1399 <prx_def+0x239>
mov    -0x318(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x318(%rbp)
mov    (%rax),%cl
mov    -0x328(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x328(%rbp)
mov    %cl,(%rax)
jmp    131c <prx_def+0x1bc>
mov    -0x328(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x328(%rbp)
movb   $0x0,(%rax)
mov    -0x320(%rbp),%rdi
lea    -0x210(%rbp),%rdx
lea    0xc3d(%rip),%rsi
mov    $0x0,%al
call   1080 <sprintf@plt>
mov    -0x320(%rbp),%rdi
call   1050 <strlen@plt>
mov    %eax,%ecx
mov    -0x320(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x320(%rbp)
mov    -0x318(%rbp),%rax
mov    %rax,-0x330(%rbp)
mov    -0x318(%rbp),%rax
cmpb   $0x0,(%rax)
je     1440 <prx_def+0x2e0>
mov    -0x318(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x318(%rbp)
mov    (%rax),%cl
mov    -0x320(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x320(%rbp)
mov    %cl,(%rax)
jmp    13fd <prx_def+0x29d>
mov    -0x320(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x320(%rbp)
movb   $0x0,(%rax)
lea    -0x110(%rbp),%rsi
lea    0xbab(%rip),%rdi
call   1060 <printf@plt>
lea    -0x110(%rbp),%rax
mov    %rax,-0x320(%rbp)
lea    -0x110(%rbp),%rdi
mov    -0x8(%rbp),%rdx
lea    0xb8b(%rip),%rsi
mov    $0x0,%al
call   1080 <sprintf@plt>
mov    -0x320(%rbp),%rdi
call   1050 <strlen@plt>
mov    %eax,%ecx
mov    -0x320(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x320(%rbp)
lea    -0x310(%rbp),%rdi
lea    0xb5b(%rip),%rsi
call   1070 <strcmp@plt>
cmp    $0x0,%rax
jne    14de <prx_def+0x37e>
cmpl   $0x0,-0x334(%rbp)
je     1515 <prx_def+0x3b5>
mov    -0x320(%rbp),%rdi
lea    0xb36(%rip),%rsi
mov    $0x0,%al
call   1080 <sprintf@plt>
mov    -0x320(%rbp),%rdi
call   1050 <strlen@plt>
mov    %eax,%ecx
mov    -0x320(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x320(%rbp)
mov    -0x320(%rbp),%rdi
lea    -0x210(%rbp),%rdx
lea    0xb00(%rip),%rsi
mov    $0x0,%al
call   1080 <sprintf@plt>
mov    -0x320(%rbp),%rdi
call   1050 <strlen@plt>
mov    %eax,%ecx
mov    -0x320(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x320(%rbp)
mov    -0x330(%rbp),%rax
mov    %rax,-0x318(%rbp)
xor    %eax,%eax
cmpq   $0x0,-0x318(%rbp)
mov    %al,-0x337(%rbp)
je     158d <prx_def+0x42d>
mov    -0x318(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x29,%eax
setne  %al
mov    %al,-0x337(%rbp)
mov    -0x337(%rbp),%al
test   $0x1,%al
jne    15a0 <prx_def+0x440>
jmp    17df <prx_def+0x67f>
jmp    15a5 <prx_def+0x445>
mov    -0x318(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x338(%rbp)
je     15f1 <prx_def+0x491>
mov    -0x318(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x29,%ecx
mov    %al,-0x338(%rbp)
je     15f1 <prx_def+0x491>
mov    -0x318(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x2c,%eax
setne  %al
mov    %al,-0x338(%rbp)
mov    -0x338(%rbp),%al
test   $0x1,%al
jne    1604 <prx_def+0x4a4>
jmp    161b <prx_def+0x4bb>
mov    -0x318(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x318(%rbp)
jmp    15a5 <prx_def+0x445>
jmp    1620 <prx_def+0x4c0>
mov    -0x318(%rbp),%rax
movsbl -0x1(%rax),%edi
call   1040 <symchar@plt>
cmp    $0x0,%rax
setne  %al
xor    $0xff,%al
test   $0x1,%al
jne    1646 <prx_def+0x4e6>
jmp    165d <prx_def+0x4fd>
mov    -0x318(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x318(%rbp)
jmp    1620 <prx_def+0x4c0>
jmp    1662 <prx_def+0x502>
mov    -0x318(%rbp),%rax
movsbl -0x1(%rax),%edi
call   1040 <symchar@plt>
cmp    $0x0,%rax
je     1693 <prx_def+0x533>
mov    -0x318(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x318(%rbp)
jmp    1662 <prx_def+0x502>
mov    -0x318(%rbp),%rdi
lea    0x995(%rip),%rsi
mov    $0x5,%edx
call   1030 <strncmp@plt>
cmp    $0x0,%eax
jne    16b9 <prx_def+0x559>
jmp    17df <prx_def+0x67f>
jmp    16be <prx_def+0x55e>
mov    -0x318(%rbp),%rax
movsbl (%rax),%edi
call   1040 <symchar@plt>
cmp    $0x0,%rax
je     170a <prx_def+0x5aa>
mov    -0x318(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x318(%rbp)
mov    (%rax),%cl
mov    -0x320(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x320(%rbp)
mov    %cl,(%rax)
jmp    16be <prx_def+0x55e>
jmp    170f <prx_def+0x5af>
mov    -0x318(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x339(%rbp)
je     175b <prx_def+0x5fb>
mov    -0x318(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x29,%ecx
mov    %al,-0x339(%rbp)
je     175b <prx_def+0x5fb>
mov    -0x318(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x2c,%eax
setne  %al
mov    %al,-0x339(%rbp)
mov    -0x339(%rbp),%al
test   $0x1,%al
jne    176e <prx_def+0x60e>
jmp    1785 <prx_def+0x625>
mov    -0x318(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x318(%rbp)
jmp    170f <prx_def+0x5af>
mov    -0x318(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x2c,%eax
jne    17da <prx_def+0x67a>
mov    -0x318(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x318(%rbp)
mov    -0x320(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x320(%rbp)
movb   $0x2c,(%rax)
mov    -0x320(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x320(%rbp)
movb   $0x20,(%rax)
jmp    1561 <prx_def+0x401>
mov    -0x320(%rbp),%rdi
lea    0x84f(%rip),%rsi
mov    $0x0,%al
call   1080 <sprintf@plt>
mov    -0x320(%rbp),%rdi
call   1050 <strlen@plt>
mov    %eax,%ecx
mov    -0x320(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x320(%rbp)
lea    -0x110(%rbp),%rsi
lea    0x81e(%rip),%rdi
call   1060 <printf@plt>
add    $0x340,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<prx_def>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x308,%rsp
mov    %rdi,%r14
movsbl (%rdi),%edi
call   1050 <symchar@plt>
lea    0x100(%rsp),%rbp
test   %rax,%rax
je     11c1 <prx_def+0x51>
mov    %r14,%rcx
nopl   0x0(%rax)
lea    0x1(%rcx),%rbx
movzbl (%rcx),%eax
mov    %al,0x0(%rbp)
add    $0x1,%rbp
movsbl 0x1(%rcx),%edi
call   1050 <symchar@plt>
mov    %rbx,%rcx
test   %rax,%rax
jne    11a0 <prx_def+0x30>
jmp    11c4 <prx_def+0x54>
mov    %r14,%rbx
movb   $0x0,0x0(%rbp)
mov    %rsp,%r15
lea    0x100(%rsp),%rsi
mov    %r15,%rdi
call   1040 <strcpy@plt>
mov    %r15,%rdi
call   1060 <strlen@plt>
cltq
lea    (%rsp,%rax,1),%r15
mov    (%rbx),%r12b
test   %r12b,%r12b
je     121b <prx_def+0xab>
cmp    $0x20,%r12b
jg     121b <prx_def+0xab>
nopw   0x0(%rax,%rax,1)
mov    %r12b,(%r15)
add    $0x1,%r15
movzbl 0x1(%rbx),%r12d
add    $0x1,%rbx
test   %r12b,%r12b
je     121b <prx_def+0xab>
cmp    $0x21,%r12b
jl     1200 <prx_def+0x90>
cmp    $0x2a,%r12b
jne    1246 <prx_def+0xd6>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movb   $0x2a,(%r15)
add    $0x1,%r15
movzbl 0x1(%rbx),%eax
add    $0x1,%rbx
cmp    $0x2a,%al
je     1230 <prx_def+0xc0>
jmp    1249 <prx_def+0xd9>
mov    %r12d,%eax
lea    0x200(%rsp),%r13
test   %al,%al
je     128d <prx_def+0x11d>
mov    %rbx,%rbp
nopl   0x0(%rax,%rax,1)
movsbl %al,%edi
call   1050 <symchar@plt>
test   %rax,%rax
je     128a <prx_def+0x11a>
lea    0x1(%rbp),%rbx
movzbl 0x0(%rbp),%eax
mov    %al,0x0(%r13)
add    $0x1,%r13
movzbl 0x1(%rbp),%eax
mov    %rbx,%rbp
test   %al,%al
jne    1260 <prx_def+0xf0>
jmp    128d <prx_def+0x11d>
mov    %rbp,%rbx
movb   $0x0,0x0(%r13)
lea    0xd67(%rip),%rsi
lea    0x200(%rsp),%rdx
mov    %r15,%rdi
xor    %eax,%eax
call   1090 <sprintf@plt>
mov    %r15,%rdi
call   1060 <strlen@plt>
cltq
add    %r15,%rax
mov    (%rbx),%cl
test   %cl,%cl
je     12e1 <prx_def+0x171>
lea    0x1(%rbx),%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %cl,(%rax)
add    $0x1,%rax
movzbl (%rdx),%ecx
add    $0x1,%rdx
test   %cl,%cl
jne    12d0 <prx_def+0x160>
movb   $0x0,(%rax)
lea    0xd23(%rip),%rdi
mov    %rsp,%r15
mov    %r15,%rsi
call   1070 <printf@plt>
lea    0xd16(%rip),%rsi
mov    %r15,%rdi
mov    %r14,%rdx
xor    %eax,%eax
call   1090 <sprintf@plt>
mov    %r15,%rdi
call   1060 <strlen@plt>
cltq
lea    (%rsp,%rax,1),%r15
lea    0xcfb(%rip),%rsi
lea    0x100(%rsp),%rdi
call   1080 <strcmp@plt>
test   %rax,%rax
jne    1337 <prx_def+0x1c7>
cmp    $0x2a,%r12b
jne    1351 <prx_def+0x1e1>
movabs $0x206e7275746572,%rax
mov    %rax,(%r15)
mov    %r15,%rdi
call   1060 <strlen@plt>
cltq
add    %rax,%r15
lea    0xcc7(%rip),%rsi
lea    0x200(%rsp),%rdx
mov    %r15,%rdi
xor    %eax,%eax
call   1090 <sprintf@plt>
mov    %r15,%rdi
call   1060 <strlen@plt>
movslq %eax,%r14
add    %r15,%r14
mov    (%rbx),%al
cmp    $0x29,%al
jne    13b5 <prx_def+0x245>
movw   $0xa,0x4(%r14)
movl   $0x7d203b29,(%r14)
mov    %r14,%rdi
call   1060 <strlen@plt>
lea    0xc9c(%rip),%rdi
mov    %rsp,%rsi
call   1070 <printf@plt>
add    $0x308,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
movabs $0x120000000001,%r12
lea    0xc65(%rip),%r15
jmp    13d8 <prx_def+0x268>
nopl   0x0(%rax,%rax,1)
add    $0xffffffffffffffff,%rbx
cmp    $0x29,%al
je     137e <prx_def+0x20e>
lea    0x1(%rbx),%rcx
jmp    13ec <prx_def+0x27c>
xchg   %ax,%ax
movzbl 0x1(%rbx),%eax
add    $0x1,%rbx
add    $0x1,%rcx
cmp    $0x2c,%al
ja     13e0 <prx_def+0x270>
movzbl %al,%eax
bt     %rax,%r12
jae    13e0 <prx_def+0x270>
nopl   0x0(%rax)
mov    %rcx,%rbx
movsbl -0x2(%rcx),%edi
call   1050 <symchar@plt>
lea    -0x1(%rbx),%rcx
test   %rax,%rax
je     1400 <prx_def+0x290>
cs nopw 0x0(%rax,%rax,1)
nop
movsbl -0x2(%rbx),%edi
call   1050 <symchar@plt>
add    $0xffffffffffffffff,%rbx
test   %rax,%rax
jne    1420 <prx_def+0x2b0>
mov    %rbx,%rdi
mov    %r15,%rsi
mov    $0x5,%edx
call   1030 <strncmp@plt>
test   %eax,%eax
je     137e <prx_def+0x20e>
movsbl (%rbx),%edi
call   1050 <symchar@plt>
test   %rax,%rax
je     1480 <prx_def+0x310>
nopw   0x0(%rax,%rax,1)
lea    0x1(%rbx),%rbp
movzbl (%rbx),%eax
mov    %al,(%r14)
add    $0x1,%r14
movsbl 0x1(%rbx),%edi
call   1050 <symchar@plt>
mov    %rbp,%rbx
test   %rax,%rax
jne    1460 <prx_def+0x2f0>
nop
add    $0x1,%rbx
movzbl -0x1(%rbx),%eax
test   %al,%al
je     13d0 <prx_def+0x260>
cmp    $0x29,%al
je     13d0 <prx_def+0x260>
cmp    $0x2c,%al
jne    1480 <prx_def+0x310>
movw   $0x202c,(%r14)
add    $0x2,%r14
mov    (%rbx),%al
cmp    $0x29,%al
jne    13d8 <prx_def+0x268>
jmp    137e <prx_def+0x20e>

LLVM IR (-O0):
@.str = [3 x i8] c"%s\00"
@.str.1 = [14 x i8] c"(*_iproxy_%s)\00"
@.str.2 = [5 x i8] c"%s;\0A\00"
@.str.3 = [7 x i8] c"%s\0A\09{ \00"
@.str.4 = [5 x i8] c"void\00"
@.str.5 = [8 x i8] c"return \00"
@.str.6 = [12 x i8] c"_iproxy_%s(\00"
@.str.7 = [6 x i8] c"void)\00"
@.str.8 = [6 x i8] c"); }\0A\00"
@.str.9 = [4 x i8] c"%s\0A\00"
define void @prx_def(i8* %0) {
%2 = alloca i8*
%3 = alloca [256 x i8]
%4 = alloca [256 x i8]
%5 = alloca [256 x i8]
%6 = alloca i8*
%7 = alloca i8*
%8 = alloca i8*
%9 = alloca i8*
%10 = alloca i32
store i8* %0, i8** %2
%11 = load i8*, i8** %2
store i8* %11, i8** %6
%12 = getelementptr inbounds [256 x i8], [256 x i8]* %3, i64 0, i64 0
store i8* %12, i8** %7
%13 = getelementptr inbounds [256 x i8], [256 x i8]* %5, i64 0, i64 0
store i8* %13, i8** %8
br label %14
14: ; preds = %19, %1
%15 = load i8*, i8** %6
%16 = load i8, i8* %15
%17 = call i64 @symchar(i8 signext %16)
%18 = icmp ne i64 %17, 0
br i1 %18, label %19, label %25
19: ; preds = %14
%20 = load i8*, i8** %6
%21 = getelementptr inbounds i8, i8* %20, i32 1
store i8* %21, i8** %6
%22 = load i8, i8* %20
%23 = load i8*, i8** %8
%24 = getelementptr inbounds i8, i8* %23, i32 1
store i8* %24, i8** %8
store i8 %22, i8* %23
br label %14
25: ; preds = %14
%26 = load i8*, i8** %8
%27 = getelementptr inbounds i8, i8* %26, i32 1
store i8* %27, i8** %8
store i8 0, i8* %26
%28 = load i8*, i8** %7
%29 = getelementptr inbounds [256 x i8], [256 x i8]* %5, i64 0, i64 0
%30 = call i32 (i8*, i8*, ...) @sprintf(i8* %28, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i8* %29)
%31 = load i8*, i8** %7
%32 = call i32 @strlen(i8* %31)
%33 = load i8*, i8** %7
%34 = sext i32 %32 to i64
%35 = getelementptr inbounds i8, i8* %33, i64 %34
store i8* %35, i8** %7
br label %36
36: ; preds = %48, %25
%37 = load i8*, i8** %6
%38 = load i8, i8* %37
%39 = sext i8 %38 to i32
%40 = icmp ne i32 %39, 0
br i1 %40, label %41, label %46
41: ; preds = %36
%42 = load i8*, i8** %6
%43 = load i8, i8* %42
%44 = sext i8 %43 to i32
%45 = icmp sle i32 %44, 32
br label %46
46: ; preds = %41, %36
%47 = phi i1 [ false, %36 ], [ %45, %41 ]
br i1 %47, label %48, label %54
48: ; preds = %46
%49 = load i8*, i8** %6
%50 = getelementptr inbounds i8, i8* %49, i32 1
store i8* %50, i8** %6
%51 = load i8, i8* %49
%52 = load i8*, i8** %7
%53 = getelementptr inbounds i8, i8* %52, i32 1
store i8* %53, i8** %7
store i8 %51, i8* %52
br label %36
54: ; preds = %46
store i32 0, i32* %10
br label %55
55: ; preds = %60, %54
%56 = load i8*, i8** %6
%57 = load i8, i8* %56
%58 = sext i8 %57 to i32
%59 = icmp eq i32 %58, 42
br i1 %59, label %60, label %68
60: ; preds = %55
%61 = load i8*, i8** %6
%62 = getelementptr inbounds i8, i8* %61, i32 1
store i8* %62, i8** %6
%63 = load i8, i8* %61
%64 = load i8*, i8** %7
%65 = getelementptr inbounds i8, i8* %64, i32 1
store i8* %65, i8** %7
store i8 %63, i8* %64
%66 = load i32, i32* %10
%67 = add nsw i32 %66, 1
store i32 %67, i32* %10
br label %55
68: ; preds = %55
%69 = getelementptr inbounds [256 x i8], [256 x i8]* %4, i64 0, i64 0
store i8* %69, i8** %8
br label %70
70: ; preds = %82, %68
%71 = load i8*, i8** %6
%72 = load i8, i8* %71
%73 = sext i8 %72 to i32
%74 = icmp ne i32 %73, 0
br i1 %74, label %75, label %80
75: ; preds = %70
%76 = load i8*, i8** %6
%77 = load i8, i8* %76
%78 = call i64 @symchar(i8 signext %77)
%79 = icmp ne i64 %78, 0
br label %80
80: ; preds = %75, %70
%81 = phi i1 [ false, %70 ], [ %79, %75 ]
br i1 %81, label %82, label %88
82: ; preds = %80
%83 = load i8*, i8** %6
%84 = getelementptr inbounds i8, i8* %83, i32 1
store i8* %84, i8** %6
%85 = load i8, i8* %83
%86 = load i8*, i8** %8
%87 = getelementptr inbounds i8, i8* %86, i32 1
store i8* %87, i8** %8
store i8 %85, i8* %86
br label %70
88: ; preds = %80
%89 = load i8*, i8** %8
%90 = getelementptr inbounds i8, i8* %89, i32 1
store i8* %90, i8** %8
store i8 0, i8* %89
%91 = load i8*, i8** %7
%92 = getelementptr inbounds [256 x i8], [256 x i8]* %4, i64 0, i64 0
%93 = call i32 (i8*, i8*, ...) @sprintf(i8* %91, i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.1, i64 0, i64 0), i8* %92)
%94 = load i8*, i8** %7
%95 = call i32 @strlen(i8* %94)
%96 = load i8*, i8** %7
%97 = sext i32 %95 to i64
%98 = getelementptr inbounds i8, i8* %96, i64 %97
store i8* %98, i8** %7
%99 = load i8*, i8** %6
store i8* %99, i8** %9
br label %100
100: ; preds = %104, %88
%101 = load i8*, i8** %6
%102 = load i8, i8* %101
%103 = icmp ne i8 %102, 0
br i1 %103, label %104, label %110
104: ; preds = %100
%105 = load i8*, i8** %6
%106 = getelementptr inbounds i8, i8* %105, i32 1
store i8* %106, i8** %6
%107 = load i8, i8* %105
%108 = load i8*, i8** %7
%109 = getelementptr inbounds i8, i8* %108, i32 1
store i8* %109, i8** %7
store i8 %107, i8* %108
br label %100
110: ; preds = %100
%111 = load i8*, i8** %7
%112 = getelementptr inbounds i8, i8* %111, i32 1
store i8* %112, i8** %7
store i8 0, i8* %111
%113 = getelementptr inbounds [256 x i8], [256 x i8]* %3, i64 0, i64 0
%114 = call i32 @printf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.2, i64 0, i64 0), i8* %113)
%115 = getelementptr inbounds [256 x i8], [256 x i8]* %3, i64 0, i64 0
store i8* %115, i8** %7
%116 = getelementptr inbounds [256 x i8], [256 x i8]* %3, i64 0, i64 0
%117 = load i8*, i8** %2
%118 = call i32 (i8*, i8*, ...) @sprintf(i8* %116, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.3, i64 0, i64 0), i8* %117)
%119 = load i8*, i8** %7
%120 = call i32 @strlen(i8* %119)
%121 = load i8*, i8** %7
%122 = sext i32 %120 to i64
%123 = getelementptr inbounds i8, i8* %121, i64 %122
store i8* %123, i8** %7
%124 = getelementptr inbounds [256 x i8], [256 x i8]* %5, i64 0, i64 0
%125 = call i64 @strcmp(i8* %124, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.4, i64 0, i64 0))
%126 = icmp ne i64 %125, 0
br i1 %126, label %130, label %127
127: ; preds = %110
%128 = load i32, i32* %10
%129 = icmp ne i32 %128, 0
br i1 %129, label %130, label %138
130: ; preds = %127, %110
%131 = load i8*, i8** %7
%132 = call i32 (i8*, i8*, ...) @sprintf(i8* %131, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.5, i64 0, i64 0))
%133 = load i8*, i8** %7
%134 = call i32 @strlen(i8* %133)
%135 = load i8*, i8** %7
%136 = sext i32 %134 to i64
%137 = getelementptr inbounds i8, i8* %135, i64 %136
store i8* %137, i8** %7
br label %138
138: ; preds = %130, %127
%139 = load i8*, i8** %7
%140 = getelementptr inbounds [256 x i8], [256 x i8]* %4, i64 0, i64 0
%141 = call i32 (i8*, i8*, ...) @sprintf(i8* %139, i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.6, i64 0, i64 0), i8* %140)
%142 = load i8*, i8** %7
%143 = call i32 @strlen(i8* %142)
%144 = load i8*, i8** %7
%145 = sext i32 %143 to i64
%146 = getelementptr inbounds i8, i8* %144, i64 %145
store i8* %146, i8** %7
%147 = load i8*, i8** %9
store i8* %147, i8** %6
br label %148
148: ; preds = %250, %138
%149 = load i8*, i8** %6
%150 = icmp ne i8* %149, null
br i1 %150, label %151, label %156
151: ; preds = %148
%152 = load i8*, i8** %6
%153 = load i8, i8* %152
%154 = sext i8 %153 to i32
%155 = icmp ne i32 %154, 41
br label %156
156: ; preds = %151, %148
%157 = phi i1 [ false, %148 ], [ %155, %151 ]
br i1 %157, label %158, label %251
158: ; preds = %156
br label %159
159: ; preds = %176, %158
%160 = load i8*, i8** %6
%161 = load i8, i8* %160
%162 = sext i8 %161 to i32
%163 = icmp ne i32 %162, 0
br i1 %163, label %164, label %174
164: ; preds = %159
%165 = load i8*, i8** %6
%166 = load i8, i8* %165
%167 = sext i8 %166 to i32
%168 = icmp ne i32 %167, 41
br i1 %168, label %169, label %174
169: ; preds = %164
%170 = load i8*, i8** %6
%171 = load i8, i8* %170
%172 = sext i8 %171 to i32
%173 = icmp ne i32 %172, 44
br label %174
174: ; preds = %169, %164, %159
%175 = phi i1 [ false, %164 ], [ false, %159 ], [ %173, %169 ]
br i1 %175, label %176, label %179
176: ; preds = %174
%177 = load i8*, i8** %6
%178 = getelementptr inbounds i8, i8* %177, i32 1
store i8* %178, i8** %6
br label %159
179: ; preds = %174
br label %180
180: ; preds = %187, %179
%181 = load i8*, i8** %6
%182 = getelementptr inbounds i8, i8* %181, i64 -1
%183 = load i8, i8* %182
%184 = call i64 @symchar(i8 signext %183)
%185 = icmp ne i64 %184, 0
%186 = xor i1 %185, true
br i1 %186, label %187, label %190
187: ; preds = %180
%188 = load i8*, i8** %6
%189 = getelementptr inbounds i8, i8* %188, i32 -1
store i8* %189, i8** %6
br label %180
190: ; preds = %180
br label %191
191: ; preds = %197, %190
%192 = load i8*, i8** %6
%193 = getelementptr inbounds i8, i8* %192, i64 -1
%194 = load i8, i8* %193
%195 = call i64 @symchar(i8 signext %194)
%196 = icmp ne i64 %195, 0
br i1 %196, label %197, label %200
197: ; preds = %191
%198 = load i8*, i8** %6
%199 = getelementptr inbounds i8, i8* %198, i32 -1
store i8* %199, i8** %6
br label %191
200: ; preds = %191
%201 = load i8*, i8** %6
%202 = call i32 @strncmp(i8* %201, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.7, i64 0, i64 0), i32 5)
%203 = icmp ne i32 %202, 0
br i1 %203, label %205, label %204
204: ; preds = %200
br label %251
205: ; preds = %200
br label %206
206: ; preds = %211, %205
%207 = load i8*, i8** %6
%208 = load i8, i8* %207
%209 = call i64 @symchar(i8 signext %208)
%210 = icmp ne i64 %209, 0
br i1 %210, label %211, label %217
211: ; preds = %206
%212 = load i8*, i8** %6
%213 = getelementptr inbounds i8, i8* %212, i32 1
store i8* %213, i8** %6
%214 = load i8, i8* %212
%215 = load i8*, i8** %7
%216 = getelementptr inbounds i8, i8* %215, i32 1
store i8* %216, i8** %7
store i8 %214, i8* %215
br label %206
217: ; preds = %206
br label %218
218: ; preds = %235, %217
%219 = load i8*, i8** %6
%220 = load i8, i8* %219
%221 = sext i8 %220 to i32
%222 = icmp ne i32 %221, 0
br i1 %222, label %223, label %233
223: ; preds = %218
%224 = load i8*, i8** %6
%225 = load i8, i8* %224
%226 = sext i8 %225 to i32
%227 = icmp ne i32 %226, 41
br i1 %227, label %228, label %233
228: ; preds = %223
%229 = load i8*, i8** %6
%230 = load i8, i8* %229
%231 = sext i8 %230 to i32
%232 = icmp ne i32 %231, 44
br label %233
233: ; preds = %228, %223, %218
%234 = phi i1 [ false, %223 ], [ false, %218 ], [ %232, %228 ]
br i1 %234, label %235, label %238
235: ; preds = %233
%236 = load i8*, i8** %6
%237 = getelementptr inbounds i8, i8* %236, i32 1
store i8* %237, i8** %6
br label %218
238: ; preds = %233
%239 = load i8*, i8** %6
%240 = load i8, i8* %239
%241 = sext i8 %240 to i32
%242 = icmp eq i32 %241, 44
br i1 %242, label %243, label %250
243: ; preds = %238
%244 = load i8*, i8** %6
%245 = getelementptr inbounds i8, i8* %244, i32 1
store i8* %245, i8** %6
%246 = load i8*, i8** %7
%247 = getelementptr inbounds i8, i8* %246, i32 1
store i8* %247, i8** %7
store i8 44, i8* %246
%248 = load i8*, i8** %7
%249 = getelementptr inbounds i8, i8* %248, i32 1
store i8* %249, i8** %7
store i8 32, i8* %248
br label %250
250: ; preds = %243, %238
br label %148
251: ; preds = %204, %156
%252 = load i8*, i8** %7
%253 = call i32 (i8*, i8*, ...) @sprintf(i8* %252, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.8, i64 0, i64 0))
%254 = load i8*, i8** %7
%255 = call i32 @strlen(i8* %254)
%256 = load i8*, i8** %7
%257 = sext i32 %255 to i64
%258 = getelementptr inbounds i8, i8* %256, i64 %257
store i8* %258, i8** %7
%259 = getelementptr inbounds [256 x i8], [256 x i8]* %3, i64 0, i64 0
%260 = call i32 @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.9, i64 0, i64 0), i8* %259)
ret void
}

LLVM IR (-O2):
@.str.1 = [14 x i8] c"(*_iproxy_%s)\00"
@.str.2 = [5 x i8] c"%s;\0A\00"
@.str.3 = [7 x i8] c"%s\0A\09{ \00"
@.str.4 = [5 x i8] c"void\00"
@.str.6 = [12 x i8] c"_iproxy_%s(\00"
@.str.7 = [6 x i8] c"void)\00"
@.str.8 = [6 x i8] c"); }\0A\00"
@.str.9 = [4 x i8] c"%s\0A\00"
define void @prx_def(i8* %0) {
%2 = alloca [256 x i8]
%3 = alloca [256 x i8]
%4 = alloca [256 x i8]
%5 = getelementptr inbounds [256 x i8], [256 x i8]* %2, i64 0, i64 0
%6 = getelementptr inbounds [256 x i8], [256 x i8]* %3, i64 0, i64 0
%7 = getelementptr inbounds [256 x i8], [256 x i8]* %4, i64 0, i64 0
%8 = load i8, i8* %0
%9 = tail call i64 @symchar(i8 signext %8)
%10 = icmp eq i64 %9, 0
br i1 %10, label %20, label %11
11: ; preds = %1, %11
%12 = phi i8* [ %14, %11 ], [ %0, %1 ]
%13 = phi i8* [ %16, %11 ], [ %7, %1 ]
%14 = getelementptr inbounds i8, i8* %12, i64 1
%15 = load i8, i8* %12
%16 = getelementptr inbounds i8, i8* %13, i64 1
store i8 %15, i8* %13
%17 = load i8, i8* %14
%18 = tail call i64 @symchar(i8 signext %17)
%19 = icmp eq i64 %18, 0
br i1 %19, label %20, label %11
20: ; preds = %11, %1
%21 = phi i8* [ %7, %1 ], [ %16, %11 ]
%22 = phi i8* [ %0, %1 ], [ %14, %11 ]
store i8 0, i8* %21
%23 = call i8* @strcpy(i8* %5, i8* %7)
%24 = call i32 @strlen(i8* %5)
%25 = sext i32 %24 to i64
%26 = getelementptr inbounds [256 x i8], [256 x i8]* %2, i64 0, i64 %25
%27 = load i8, i8* %22
%28 = icmp ne i8 %27, 0
%29 = icmp slt i8 %27, 33
%30 = and i1 %28, %29
br i1 %30, label %36, label %31
31: ; preds = %36, %20
%32 = phi i8* [ %26, %20 ], [ %41, %36 ]
%33 = phi i8* [ %22, %20 ], [ %40, %36 ]
%34 = phi i8 [ %27, %20 ], [ %42, %36 ]
%35 = icmp eq i8 %34, 42
br i1 %35, label %51, label %46
36: ; preds = %20, %36
%37 = phi i8 [ %42, %36 ], [ %27, %20 ]
%38 = phi i8* [ %40, %36 ], [ %22, %20 ]
%39 = phi i8* [ %41, %36 ], [ %26, %20 ]
%40 = getelementptr inbounds i8, i8* %38, i64 1
%41 = getelementptr inbounds i8, i8* %39, i64 1
store i8 %37, i8* %39
%42 = load i8, i8* %40
%43 = icmp ne i8 %42, 0
%44 = icmp slt i8 %42, 33
%45 = and i1 %43, %44
br i1 %45, label %36, label %31
46: ; preds = %51, %31
%47 = phi i8 [ %34, %31 ], [ %56, %51 ]
%48 = phi i8* [ %32, %31 ], [ %55, %51 ]
%49 = phi i8* [ %33, %31 ], [ %54, %51 ]
%50 = icmp eq i8 %47, 0
br i1 %50, label %70, label %58
51: ; preds = %31, %51
%52 = phi i8* [ %54, %51 ], [ %33, %31 ]
%53 = phi i8* [ %55, %51 ], [ %32, %31 ]
%54 = getelementptr inbounds i8, i8* %52, i64 1
%55 = getelementptr inbounds i8, i8* %53, i64 1
store i8 42, i8* %53
%56 = load i8, i8* %54
%57 = icmp eq i8 %56, 42
br i1 %57, label %51, label %46
58: ; preds = %46, %64
%59 = phi i8 [ %68, %64 ], [ %47, %46 ]
%60 = phi i8* [ %65, %64 ], [ %49, %46 ]
%61 = phi i8* [ %67, %64 ], [ %6, %46 ]
%62 = call i64 @symchar(i8 signext %59)
%63 = icmp eq i64 %62, 0
br i1 %63, label %70, label %64
64: ; preds = %58
%65 = getelementptr inbounds i8, i8* %60, i64 1
%66 = load i8, i8* %60
%67 = getelementptr inbounds i8, i8* %61, i64 1
store i8 %66, i8* %61
%68 = load i8, i8* %65
%69 = icmp eq i8 %68, 0
br i1 %69, label %70, label %58
70: ; preds = %58, %64, %46
%71 = phi i8* [ %6, %46 ], [ %67, %64 ], [ %61, %58 ]
%72 = phi i8* [ %49, %46 ], [ %65, %64 ], [ %60, %58 ]
store i8 0, i8* %71
%73 = call i32 (i8*, i8*, ...) @sprintf(i8* dereferenceable(1) %48, i8* dereferenceable(1) getelementptr inbounds ([14 x i8], [14 x i8]* @.str.1, i64 0, i64 0), i8* %6)
%74 = call i32 @strlen(i8* %48)
%75 = sext i32 %74 to i64
%76 = getelementptr inbounds i8, i8* %48, i64 %75
%77 = load i8, i8* %72
%78 = icmp eq i8 %77, 0
br i1 %78, label %87, label %79
79: ; preds = %70, %79
%80 = phi i8 [ %85, %79 ], [ %77, %70 ]
%81 = phi i8* [ %83, %79 ], [ %72, %70 ]
%82 = phi i8* [ %84, %79 ], [ %76, %70 ]
%83 = getelementptr inbounds i8, i8* %81, i64 1
%84 = getelementptr inbounds i8, i8* %82, i64 1
store i8 %80, i8* %82
%85 = load i8, i8* %83
%86 = icmp eq i8 %85, 0
br i1 %86, label %87, label %79
87: ; preds = %79, %70
%88 = phi i8* [ %76, %70 ], [ %84, %79 ]
store i8 0, i8* %88
%89 = call i32 @printf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.2, i64 0, i64 0), i8* %5)
%90 = call i32 (i8*, i8*, ...) @sprintf(i8* %5, i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.3, i64 0, i64 0), i8* %0)
%91 = call i32 @strlen(i8* %5)
%92 = sext i32 %91 to i64
%93 = getelementptr inbounds [256 x i8], [256 x i8]* %2, i64 0, i64 %92
%94 = call i64 @strcmp(i8* %7, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.4, i64 0, i64 0))
%95 = icmp ne i64 %94, 0
%96 = select i1 %95, i1 true, i1 %35
br i1 %96, label %97, label %102
97: ; preds = %87
%98 = bitcast i8* %93 to i64*
store i64 9128637130630514, i64* %98
%99 = call i32 @strlen(i8* %93)
%100 = sext i32 %99 to i64
%101 = getelementptr inbounds i8, i8* %93, i64 %100
br label %102
102: ; preds = %87, %97
%103 = phi i8* [ %101, %97 ], [ %93, %87 ]
%104 = call i32 (i8*, i8*, ...) @sprintf(i8* dereferenceable(1) %103, i8* dereferenceable(1) getelementptr inbounds ([12 x i8], [12 x i8]* @.str.6, i64 0, i64 0), i8* %6)
%105 = call i32 @strlen(i8* %103)
%106 = sext i32 %105 to i64
%107 = getelementptr inbounds i8, i8* %103, i64 %106
%108 = load i8, i8* %72
%109 = icmp eq i8 %108, 41
br i1 %109, label %167, label %110
110: ; preds = %102, %162
%111 = phi i8 [ %163, %162 ], [ %108, %102 ]
%112 = phi i8* [ %165, %162 ], [ %72, %102 ]
%113 = phi i8* [ %164, %162 ], [ %107, %102 ]
br label %114
114: ; preds = %110, %118
%115 = phi i8 [ %120, %118 ], [ %111, %110 ]
%116 = phi i8* [ %119, %118 ], [ %112, %110 ]
switch i8 %115, label %118 [
i8 0, label %117
i8 41, label %117
i8 44, label %117
]
117: ; preds = %114, %114, %114
br label %121
118: ; preds = %114
%119 = getelementptr inbounds i8, i8* %116, i64 1
%120 = load i8, i8* %119
br label %114
121: ; preds = %117, %121
%122 = phi i8* [ %123, %121 ], [ %116, %117 ]
%123 = getelementptr inbounds i8, i8* %122, i64 -1
%124 = load i8, i8* %123
%125 = call i64 @symchar(i8 signext %124)
%126 = icmp eq i64 %125, 0
br i1 %126, label %121, label %127
127: ; preds = %121, %127
%128 = phi i8* [ %129, %127 ], [ %122, %121 ]
%129 = getelementptr inbounds i8, i8* %128, i64 -1
%130 = load i8, i8* %129
%131 = call i64 @symchar(i8 signext %130)
%132 = icmp eq i64 %131, 0
br i1 %132, label %133, label %127
133: ; preds = %127
%134 = call i32 @strncmp(i8* %128, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.7, i64 0, i64 0), i32 5)
%135 = icmp eq i32 %134, 0
br i1 %135, label %167, label %136
136: ; preds = %133
%137 = load i8, i8* %128
%138 = call i64 @symchar(i8 signext %137)
%139 = icmp eq i64 %138, 0
br i1 %139, label %140, label %143
140: ; preds = %143, %136
%141 = phi i8* [ %113, %136 ], [ %148, %143 ]
%142 = phi i8* [ %128, %136 ], [ %146, %143 ]
br label %152
143: ; preds = %136, %143
%144 = phi i8* [ %146, %143 ], [ %128, %136 ]
%145 = phi i8* [ %148, %143 ], [ %113, %136 ]
%146 = getelementptr inbounds i8, i8* %144, i64 1
%147 = load i8, i8* %144
%148 = getelementptr inbounds i8, i8* %145, i64 1
store i8 %147, i8* %145
%149 = load i8, i8* %146
%150 = call i64 @symchar(i8 signext %149)
%151 = icmp eq i64 %150, 0
br i1 %151, label %140, label %143
152: ; preds = %140, %155
%153 = phi i8* [ %156, %155 ], [ %142, %140 ]
%154 = load i8, i8* %153
switch i8 %154, label %155 [
i8 44, label %157
i8 0, label %162
i8 41, label %162
]
155: ; preds = %152
%156 = getelementptr inbounds i8, i8* %153, i64 1
br label %152
157: ; preds = %152
%158 = getelementptr inbounds i8, i8* %153, i64 1
%159 = getelementptr inbounds i8, i8* %141, i64 1
store i8 44, i8* %141
%160 = getelementptr inbounds i8, i8* %141, i64 2
store i8 32, i8* %159
%161 = load i8, i8* %158
br label %162
162: ; preds = %152, %152, %157
%163 = phi i8 [ %161, %157 ], [ %154, %152 ], [ %154, %152 ]
%164 = phi i8* [ %160, %157 ], [ %141, %152 ], [ %141, %152 ]
%165 = phi i8* [ %158, %157 ], [ %153, %152 ], [ %153, %152 ]
%166 = icmp eq i8 %163, 41
br i1 %166, label %167, label %110
167: ; preds = %162, %133, %102
%168 = phi i8* [ %107, %102 ], [ %113, %133 ], [ %164, %162 ]
%169 = call i32 @strlen(i8* %168)
%170 = call i32 @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.9, i64 0, i64 0), i8* %5)
ret void
}