#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*/ evapo(char *);
char prec(char);
int /*<<< orphan*/ printf(char *, char *);
int /*<<< orphan*/ values(char *);
void toprefix(char s[100]) {
  char stack[100];
  char res[100];
  int rtop = -1;
  int stop = -1;
  int i = 0;
  while (s[i] != '\0') {
    if (s[i] == ')') {
      stop++;
      stack[stop] = s[i];
      i++;
    } else if (s[i] == '(') {
      i++;
      while ((stack[stop] != '(') && (stack[stop] != ')')) {
        rtop++;
        res[rtop] = stack[stop];
        stop--;
      }
      stop--;
    } else if (prec(s[i]) == 0) {
      rtop++;
      res[rtop] = s[i];
      i++;
    } else if (stop != -1) {
      if (prec(s[i]) >= prec(stack[stop])) {
        stop++;
        stack[stop] = s[i];
        i++;
      } else if ((prec(s[i]) < stack[stop]) && (stack[stop] != ')')) {
        int eror = 0;
        while (prec(s[i]) <= stack[stop] && stop != -1 &&
               (stack[stop] != ')')) {
          rtop++;
          eror++;
          res[rtop] = stack[stop];
          stop--;
        }
        stop++;
        stack[stop] = s[i];
        i++;
      }
    } else {
      stop++;
      stack[stop] = s[i];
      i++;
    }
  }
  while (stop >= 0) {
    rtop++;
    res[rtop] = stack[stop];
    stop--;
  }
  rtop++;
  res[rtop] = '\0';
  int p = 0;
  int ptop = 0;
  while (res[p] != '\0') {
    ptop++;
    p++;
  }
  char fin[100];
  fin[ptop] = '\0';
  ptop--;
  p = 0;
  while (res[p] != '\0') {
    fin[ptop] = res[p];
    p++;
    ptop--;
  }
  printf("\n The prefix rxpression is :%s", fin);
  values(res);
  evapo(res);
}


x86 assembly (clang, -O0):
<toprefix>:
push   %rbp
mov    %rsp,%rbp
sub    $0x170,%rsp
mov    %rdi,-0x8(%rbp)
movl   $0xffffffff,-0xe4(%rbp)
ff ff ff
movl   $0xffffffff,-0xe8(%rbp)
ff ff ff
movl   $0x0,-0xec(%rbp)
mov    -0x8(%rbp),%rax
movslq -0xec(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
je     1515 <toprefix+0x3d5>
mov    -0x8(%rbp),%rax
movslq -0xec(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x29,%eax
jne    11d9 <toprefix+0x99>
mov    -0xe8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xe8(%rbp)
mov    -0x8(%rbp),%rax
movslq -0xec(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
movslq -0xe8(%rbp),%rax
mov    %cl,-0x70(%rbp,%rax,1)
mov    -0xec(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xec(%rbp)
jmp    1510 <toprefix+0x3d0>
mov    -0x8(%rbp),%rax
movslq -0xec(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x28,%eax
jne    1298 <toprefix+0x158>
mov    -0xec(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xec(%rbp)
movslq -0xe8(%rbp),%rax
movsbl -0x70(%rbp,%rax,1),%ecx
xor    %eax,%eax
cmp    $0x28,%ecx
mov    %al,-0x161(%rbp)
je     1235 <toprefix+0xf5>
movslq -0xe8(%rbp),%rax
movsbl -0x70(%rbp,%rax,1),%eax
cmp    $0x29,%eax
setne  %al
mov    %al,-0x161(%rbp)
mov    -0x161(%rbp),%al
test   $0x1,%al
jne    1248 <toprefix+0x108>
jmp    1284 <toprefix+0x144>
mov    -0xe4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xe4(%rbp)
movslq -0xe8(%rbp),%rax
mov    -0x70(%rbp,%rax,1),%cl
movslq -0xe4(%rbp),%rax
mov    %cl,-0xe0(%rbp,%rax,1)
mov    -0xe8(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xe8(%rbp)
jmp    1200 <toprefix+0xc0>
mov    -0xe8(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xe8(%rbp)
jmp    150b <toprefix+0x3cb>
mov    -0x8(%rbp),%rax
movslq -0xec(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1060 <prec@plt>
movsbl %al,%eax
cmp    $0x0,%eax
jne    12f7 <toprefix+0x1b7>
mov    -0xe4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xe4(%rbp)
mov    -0x8(%rbp),%rax
movslq -0xec(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
movslq -0xe4(%rbp),%rax
mov    %cl,-0xe0(%rbp,%rax,1)
mov    -0xec(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xec(%rbp)
jmp    1506 <toprefix+0x3c6>
cmpl   $0xffffffff,-0xe8(%rbp)
je     14ca <toprefix+0x38a>
mov    -0x8(%rbp),%rax
movslq -0xec(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1060 <prec@plt>
movsbl %al,%eax
mov    %eax,-0x168(%rbp)
movslq -0xe8(%rbp),%rax
movsbl -0x70(%rbp,%rax,1),%edi
call   1060 <prec@plt>
mov    %al,%cl
mov    -0x168(%rbp),%eax
movsbl %cl,%ecx
cmp    %ecx,%eax
jl     1381 <toprefix+0x241>
mov    -0xe8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xe8(%rbp)
mov    -0x8(%rbp),%rax
movslq -0xec(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
movslq -0xe8(%rbp),%rax
mov    %cl,-0x70(%rbp,%rax,1)
mov    -0xec(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xec(%rbp)
jmp    14c5 <toprefix+0x385>
mov    -0x8(%rbp),%rax
movslq -0xec(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1060 <prec@plt>
movsbl %al,%eax
movslq -0xe8(%rbp),%rcx
movsbl -0x70(%rbp,%rcx,1),%ecx
cmp    %ecx,%eax
jge    14c0 <toprefix+0x380>
movslq -0xe8(%rbp),%rax
movsbl -0x70(%rbp,%rax,1),%eax
cmp    $0x29,%eax
je     14c0 <toprefix+0x380>
movl   $0x0,-0xf0(%rbp)
mov    -0x8(%rbp),%rax
movslq -0xec(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1060 <prec@plt>
movsbl %al,%ecx
movslq -0xe8(%rbp),%rax
movsbl -0x70(%rbp,%rax,1),%edx
xor    %eax,%eax
cmp    %edx,%ecx
mov    %al,-0x169(%rbp)
jg     142b <toprefix+0x2eb>
xor    %eax,%eax
cmpl   $0xffffffff,-0xe8(%rbp)
mov    %al,-0x169(%rbp)
je     142b <toprefix+0x2eb>
movslq -0xe8(%rbp),%rax
movsbl -0x70(%rbp,%rax,1),%eax
cmp    $0x29,%eax
setne  %al
mov    %al,-0x169(%rbp)
mov    -0x169(%rbp),%al
test   $0x1,%al
jne    143e <toprefix+0x2fe>
jmp    1489 <toprefix+0x349>
mov    -0xe4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xe4(%rbp)
mov    -0xf0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xf0(%rbp)
movslq -0xe8(%rbp),%rax
mov    -0x70(%rbp,%rax,1),%cl
movslq -0xe4(%rbp),%rax
mov    %cl,-0xe0(%rbp,%rax,1)
mov    -0xe8(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xe8(%rbp)
jmp    13cb <toprefix+0x28b>
mov    -0xe8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xe8(%rbp)
mov    -0x8(%rbp),%rax
movslq -0xec(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
movslq -0xe8(%rbp),%rax
mov    %cl,-0x70(%rbp,%rax,1)
mov    -0xec(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xec(%rbp)
jmp    14c5 <toprefix+0x385>
jmp    1501 <toprefix+0x3c1>
mov    -0xe8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xe8(%rbp)
mov    -0x8(%rbp),%rax
movslq -0xec(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
movslq -0xe8(%rbp),%rax
mov    %cl,-0x70(%rbp,%rax,1)
mov    -0xec(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xec(%rbp)
jmp    1506 <toprefix+0x3c6>
jmp    150b <toprefix+0x3cb>
jmp    1510 <toprefix+0x3d0>
jmp    116d <toprefix+0x2d>
jmp    151a <toprefix+0x3da>
cmpl   $0x0,-0xe8(%rbp)
jl     1563 <toprefix+0x423>
mov    -0xe4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xe4(%rbp)
movslq -0xe8(%rbp),%rax
mov    -0x70(%rbp,%rax,1),%cl
movslq -0xe4(%rbp),%rax
mov    %cl,-0xe0(%rbp,%rax,1)
mov    -0xe8(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xe8(%rbp)
jmp    151a <toprefix+0x3da>
mov    -0xe4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xe4(%rbp)
movslq -0xe4(%rbp),%rax
movb   $0x0,-0xe0(%rbp,%rax,1)
movl   $0x0,-0xf4(%rbp)
movl   $0x0,-0xf8(%rbp)
movslq -0xf4(%rbp),%rax
movsbl -0xe0(%rbp,%rax,1),%eax
ff
cmp    $0x0,%eax
je     15d0 <toprefix+0x490>
mov    -0xf8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xf8(%rbp)
mov    -0xf4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xf4(%rbp)
jmp    1595 <toprefix+0x455>
movslq -0xf8(%rbp),%rax
movb   $0x0,-0x160(%rbp,%rax,1)
mov    -0xf8(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xf8(%rbp)
movl   $0x0,-0xf4(%rbp)
movslq -0xf4(%rbp),%rax
movsbl -0xe0(%rbp,%rax,1),%eax
ff
cmp    $0x0,%eax
je     164f <toprefix+0x50f>
movslq -0xf4(%rbp),%rax
mov    -0xe0(%rbp,%rax,1),%cl
movslq -0xf8(%rbp),%rax
mov    %cl,-0x160(%rbp,%rax,1)
mov    -0xf4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xf4(%rbp)
mov    -0xf8(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xf8(%rbp)
jmp    15f8 <toprefix+0x4b8>
lea    -0x160(%rbp),%rsi
lea    0x9a3(%rip),%rdi
call   1050 <printf@plt>
lea    -0xe0(%rbp),%rdi
call   1030 <values@plt>
lea    -0xe0(%rbp),%rdi
call   1040 <evapo@plt>
add    $0x170,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<toprefix>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x168,%rsp
mov    %rdi,0x8(%rsp)
lea    0x91(%rsp),%r12
xor    %ecx,%ecx
mov    $0xffffffff,%eax
mov    %rax,(%rsp)
mov    $0xffffffff,%ebx
xchg   %ax,%ax
mov    %rcx,0x10(%rsp)
movslq %ecx,%rbp
movslq %ebx,%r13
nopl   0x0(%rax,%rax,1)
mov    0x8(%rsp),%rax
movzbl (%rax,%rbp,1),%eax
cmp    $0x29,%al
je     12ae <toprefix+0x16e>
cmp    $0x28,%al
je     12b6 <toprefix+0x176>
test   %al,%al
je     1377 <toprefix+0x237>
movsbl %al,%edi
call   1060 <prec@plt>
test   %al,%al
je     12d5 <toprefix+0x195>
mov    0x8(%rsp),%rax
movzbl (%rax,%rbp,1),%eax
cmp    $0xffffffff,%ebx
je     1300 <toprefix+0x1c0>
mov    %rbx,%r14
movsbl %al,%edi
call   1060 <prec@plt>
mov    %eax,%ebx
movzbl 0x20(%rsp,%r13,1),%r15d
movsbl %r15b,%edi
call   1060 <prec@plt>
cmp    %al,%bl
jge    1308 <toprefix+0x1c8>
mov    0x8(%rsp),%rax
movsbl (%rax,%rbp,1),%edi
call   1060 <prec@plt>
cmp    $0x29,%r15b
mov    %r14,%rbx
je     1180 <toprefix+0x40>
cmp    %r15b,%al
jge    1180 <toprefix+0x40>
mov    0x8(%rsp),%rax
movsbl (%rax,%rbp,1),%edi
call   1060 <prec@plt>
cmp    %r15b,%al
jg     128e <toprefix+0x14e>
movslq (%rsp),%rbx
add    %r12,%rbx
lea    0x1f(%rsp),%rax
add    %r13,%rax
mov    %rax,0x18(%rsp)
neg    %r13
xor    %r12d,%r12d
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %r15b,(%rbx)
mov    0x8(%rsp),%rax
movsbl (%rax,%rbp,1),%edi
call   1060 <prec@plt>
mov    0x18(%rsp),%rcx
movzbl (%rcx,%r12,1),%r15d
lea    -0x1(%r12),%rcx
cmp    $0x29,%r15b
je     1277 <toprefix+0x137>
cmp    %r15b,%al
jg     1277 <toprefix+0x137>
add    $0x1,%rbx
cmp    %r12,%r13
mov    %rcx,%r12
jne    1240 <toprefix+0x100>
mov    (%rsp),%rax
sub    %ecx,%eax
mov    %rax,(%rsp)
mov    %r14,%rbx
add    %ecx,%ebx
lea    0x91(%rsp),%r12
movslq %ebx,%rbx
mov    0x8(%rsp),%rax
mov    (%rax,%rbp,1),%al
mov    %al,0x21(%rsp,%rbx,1)
add    $0x1,%rbx
mov    0x10(%rsp),%rcx
add    $0x1,%ecx
jmp    1170 <toprefix+0x30>
movb   $0x29,0x21(%rsp,%r13,1)
jmp    1315 <toprefix+0x1d5>
mov    %rbx,%rsi
mov    0x20(%rsp,%r13,1),%bl
mov    %ebx,%ecx
and    $0xfe,%cl
cmp    $0x28,%cl
jne    1329 <toprefix+0x1e9>
mov    0x10(%rsp),%rcx
mov    %rsi,%rbx
jmp    136c <toprefix+0x22c>
mov    (%rsp),%rcx
movslq %ecx,%rcx
mov    0x8(%rsp),%rax
mov    (%rax,%rbp,1),%al
mov    %al,0x91(%rsp,%rcx,1)
add    $0x1,%rcx
mov    %rcx,(%rsp)
mov    0x10(%rsp),%rcx
add    $0x1,%ecx
jmp    1170 <toprefix+0x30>
mov    %al,0x20(%rsp)
xor    %ebx,%ebx
jmp    131c <toprefix+0x1dc>
mov    0x8(%rsp),%rax
mov    (%rax,%rbp,1),%al
mov    %al,0x21(%rsp,%r13,1)
add    $0x1,%r13
mov    %r13d,%ebx
mov    0x10(%rsp),%rcx
add    $0x1,%ecx
jmp    1170 <toprefix+0x30>
movslq (%rsp),%rcx
add    %r12,%rcx
lea    0x1f(%rsp),%rax
add    %rax,%r13
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
mov    %bl,(%rcx,%rdx,1)
movzbl 0x0(%r13),%ebx
mov    %ebx,%eax
and    $0xfe,%al
add    $0x1,%rdx
add    $0xffffffffffffffff,%r13
cmp    $0x28,%al
jne    1340 <toprefix+0x200>
mov    (%rsp),%rax
add    %edx,%eax
mov    %rax,(%rsp)
mov    %rsi,%rbx
sub    %edx,%ebx
mov    0x10(%rsp),%rcx
add    $0xffffffff,%ebx
add    $0x1,%ecx
jmp    1170 <toprefix+0x30>
test   %ebx,%ebx
js     138e <toprefix+0x24e>
mov    %ebx,%eax
movslq (%rsp),%rbp
cmp    $0x1f,%ebx
jae    1397 <toprefix+0x257>
mov    %rbp,%rdx
jmp    1460 <toprefix+0x320>
mov    (%rsp),%rdx
jmp    1476 <toprefix+0x336>
lea    0x1(%rax),%r8
mov    %r8,%rcx
and    $0xffffffffffffffe0,%rcx
lea    (%rcx,%rbp,1),%rdx
mov    %rcx,%rsi
neg    %rsi
lea    (%rsp,%rax,1),%rdi
add    $0x11,%rdi
sub    %rcx,%rax
add    %rsp,%rbp
add    $0xa1,%rbp
xor    %ebx,%ebx
pxor   %xmm0,%xmm0
nopw   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,%rsi
jne    13d0 <toprefix+0x290>
cmp    %rcx,%r8
je     1476 <toprefix+0x336>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movzbl 0x20(%rsp,%rax,1),%ecx
mov    %cl,0x91(%rsp,%rdx,1)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rax
jb     1460 <toprefix+0x320>
movslq %edx,%rax
lea    0x90(%rsp),%rcx
movb   $0x0,0x1(%rax,%rcx,1)
mov    0x90(%rsp),%al
test   %al,%al
je     14e5 <toprefix+0x3a5>
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
cmpb   $0x0,0x91(%rsp,%rcx,1)
lea    0x1(%rcx),%rcx
jne    14a0 <toprefix+0x360>
mov    %ecx,%edx
movb   $0x0,0x100(%rsp,%rdx,1)
test   %al,%al
je     14ed <toprefix+0x3ad>
mov    %ecx,%ecx
add    %rsp,%rcx
add    $0xff,%rcx
nopl   0x0(%rax,%rax,1)
mov    %al,(%rcx)
movzbl (%r12),%eax
add    $0x1,%r12
add    $0xffffffffffffffff,%rcx
test   %al,%al
jne    14d0 <toprefix+0x390>
jmp    14ed <toprefix+0x3ad>
movb   $0x0,0x100(%rsp)
lea    0xb0c(%rip),%rdi
lea    0x100(%rsp),%rsi
call   1050 <printf@plt>
lea    0x90(%rsp),%rbx
mov    %rbx,%rdi
call   1030 <values@plt>
mov    %rbx,%rdi
call   1040 <evapo@plt>
add    $0x168,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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