#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 topostfix(char s[100]) {
  printf("\n the infix expression entered is  :%s", s);
  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';
  printf("\n The postfix rxpression is :%s", res);
  values(res);
  printf("\n The postfix rxpression after valuing is :%s", res);
  evapo(res);
}


x86 assembly (clang, -O0):
<topostfix>:
push   %rbp
mov    %rsp,%rbp
sub    $0x100,%rsp
mov    %rdi,-0x8(%rbp)
mov    -0x8(%rbp),%rsi
lea    0xea6(%rip),%rdi
call   1050 <printf@plt>
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     1525 <topostfix+0x3e5>
mov    -0x8(%rbp),%rax
movslq -0xec(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x28,%eax
jne    11e9 <topostfix+0xa9>
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    1520 <topostfix+0x3e0>
mov    -0x8(%rbp),%rax
movslq -0xec(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x29,%eax
jne    12a8 <topostfix+0x168>
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,-0xf1(%rbp)
je     1245 <topostfix+0x105>
movslq -0xe8(%rbp),%rax
movsbl -0x70(%rbp,%rax,1),%eax
cmp    $0x29,%eax
setne  %al
mov    %al,-0xf1(%rbp)
mov    -0xf1(%rbp),%al
test   $0x1,%al
jne    1258 <topostfix+0x118>
jmp    1294 <topostfix+0x154>
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    1210 <topostfix+0xd0>
mov    -0xe8(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xe8(%rbp)
jmp    151b <topostfix+0x3db>
mov    -0x8(%rbp),%rax
movslq -0xec(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1060 <prec@plt>
movsbl %al,%eax
cmp    $0x0,%eax
jne    1307 <topostfix+0x1c7>
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    1516 <topostfix+0x3d6>
cmpl   $0xffffffff,-0xe8(%rbp)
je     14da <topostfix+0x39a>
mov    -0x8(%rbp),%rax
movslq -0xec(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1060 <prec@plt>
movsbl %al,%eax
mov    %eax,-0xf8(%rbp)
movslq -0xe8(%rbp),%rax
movsbl -0x70(%rbp,%rax,1),%edi
call   1060 <prec@plt>
mov    %al,%cl
mov    -0xf8(%rbp),%eax
movsbl %cl,%ecx
cmp    %ecx,%eax
jle    1391 <topostfix+0x251>
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    14d5 <topostfix+0x395>
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
jg     14d0 <topostfix+0x390>
movslq -0xe8(%rbp),%rax
movsbl -0x70(%rbp,%rax,1),%eax
cmp    $0x28,%eax
je     14d0 <topostfix+0x390>
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,-0xf9(%rbp)
jg     143b <topostfix+0x2fb>
xor    %eax,%eax
cmpl   $0xffffffff,-0xe8(%rbp)
mov    %al,-0xf9(%rbp)
je     143b <topostfix+0x2fb>
movslq -0xe8(%rbp),%rax
movsbl -0x70(%rbp,%rax,1),%eax
cmp    $0x28,%eax
setne  %al
mov    %al,-0xf9(%rbp)
mov    -0xf9(%rbp),%al
test   $0x1,%al
jne    144e <topostfix+0x30e>
jmp    1499 <topostfix+0x359>
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    13db <topostfix+0x29b>
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    14d5 <topostfix+0x395>
jmp    1511 <topostfix+0x3d1>
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    1516 <topostfix+0x3d6>
jmp    151b <topostfix+0x3db>
jmp    1520 <topostfix+0x3e0>
jmp    117d <topostfix+0x3d>
jmp    152a <topostfix+0x3ea>
cmpl   $0x0,-0xe8(%rbp)
jl     1573 <topostfix+0x433>
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    152a <topostfix+0x3ea>
mov    -0xe4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xe4(%rbp)
movslq -0xe4(%rbp),%rax
movb   $0x0,-0xe0(%rbp,%rax,1)
lea    -0xe0(%rbp),%rsi
lea    0xa88(%rip),%rdi
call   1050 <printf@plt>
lea    -0xe0(%rbp),%rdi
call   1030 <values@plt>
lea    -0xe0(%rbp),%rsi
lea    0xa89(%rip),%rdi
call   1050 <printf@plt>
lea    -0xe0(%rbp),%rdi
call   1040 <evapo@plt>
add    $0x100,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<topostfix>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xf8,%rsp
mov    %rdi,%rsi
lea    0xea5(%rip),%rdi
mov    %rsi,(%rsp)
call   1050 <printf@plt>
xor    %eax,%eax
mov    $0xffffffff,%r15d
mov    $0xffffffff,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %rax,0x8(%rsp)
movslq %eax,%rbp
movslq %ebx,%r12
nopl   0x0(%rax,%rax,1)
mov    (%rsp),%rax
movzbl (%rax,%rbp,1),%eax
cmp    $0x29,%al
je     12b1 <topostfix+0x171>
cmp    $0x28,%al
je     12d0 <topostfix+0x190>
test   %al,%al
je     1370 <topostfix+0x230>
movsbl %al,%edi
call   1060 <prec@plt>
test   %al,%al
je     12d8 <topostfix+0x198>
mov    (%rsp),%rax
movzbl (%rax,%rbp,1),%eax
cmp    $0xffffffff,%ebx
je     12fb <topostfix+0x1bb>
mov    %rbx,%r14
movsbl %al,%edi
call   1060 <prec@plt>
mov    %eax,%ebx
movzbl 0x20(%rsp,%r12,1),%r13d
movsbl %r13b,%edi
call   1060 <prec@plt>
cmp    %al,%bl
jg     1303 <topostfix+0x1c3>
mov    (%rsp),%rax
movsbl (%rax,%rbp,1),%edi
call   1060 <prec@plt>
cmp    $0x28,%r13b
mov    %r14,%rbx
je     1190 <topostfix+0x50>
cmp    %r13b,%al
jg     1190 <topostfix+0x50>
mov    (%rsp),%rax
movsbl (%rax,%rbp,1),%edi
call   1060 <prec@plt>
cmp    %r13b,%al
jg     1292 <topostfix+0x152>
mov    %r15,0x10(%rsp)
movslq %r15d,%rbx
lea    0x91(%rsp),%rax
add    %rax,%rbx
lea    0x1f(%rsp),%rax
add    %r12,%rax
mov    %rax,0x18(%rsp)
neg    %r12
xor    %r15d,%r15d
nopl   0x0(%rax,%rax,1)
mov    %r13b,(%rbx)
mov    (%rsp),%rax
movsbl (%rax,%rbp,1),%edi
call   1060 <prec@plt>
mov    0x18(%rsp),%rcx
movzbl (%rcx,%r15,1),%r13d
lea    -0x1(%r15),%rcx
cmp    $0x28,%r13b
je     1285 <topostfix+0x145>
cmp    %r13b,%al
jg     1285 <topostfix+0x145>
add    $0x1,%rbx
cmp    %r15,%r12
mov    %rcx,%r15
jne    1250 <topostfix+0x110>
mov    0x10(%rsp),%r15
sub    %ecx,%r15d
mov    %r14,%rbx
add    %ecx,%ebx
movslq %ebx,%rbx
mov    (%rsp),%rax
mov    (%rax,%rbp,1),%al
mov    %al,0x21(%rsp,%rbx,1)
add    $0x1,%rbx
mov    0x8(%rsp),%rax
add    $0x1,%eax
jmp    1180 <topostfix+0x40>
mov    %rbx,%rsi
mov    0x20(%rsp,%r12,1),%bl
mov    %ebx,%ecx
and    $0xfe,%cl
cmp    $0x28,%cl
jne    1323 <topostfix+0x1e3>
mov    0x8(%rsp),%rax
mov    %rsi,%rbx
jmp    1365 <topostfix+0x225>
movb   $0x28,0x21(%rsp,%r12,1)
jmp    130f <topostfix+0x1cf>
movslq %r15d,%r15
mov    (%rsp),%rax
mov    (%rax,%rbp,1),%al
mov    %al,0x91(%rsp,%r15,1)
add    $0x1,%r15
mov    0x8(%rsp),%rax
add    $0x1,%eax
jmp    1180 <topostfix+0x40>
mov    %al,0x20(%rsp)
xor    %ebx,%ebx
jmp    1316 <topostfix+0x1d6>
mov    (%rsp),%rax
mov    (%rax,%rbp,1),%al
mov    %al,0x21(%rsp,%r12,1)
add    $0x1,%r12
mov    %r12d,%ebx
mov    0x8(%rsp),%rax
add    $0x1,%eax
jmp    1180 <topostfix+0x40>
movslq %r15d,%rcx
lea    0x91(%rsp),%rax
add    %rax,%rcx
lea    0x1f(%rsp),%rax
add    %rax,%r12
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
mov    %bl,(%rcx,%rdx,1)
movzbl (%r12),%ebx
mov    %ebx,%eax
and    $0xfe,%al
add    $0x1,%rdx
add    $0xffffffffffffffff,%r12
cmp    $0x28,%al
jne    1340 <topostfix+0x200>
add    %edx,%r15d
mov    %rsi,%rbx
sub    %edx,%ebx
mov    0x8(%rsp),%rax
add    $0xffffffff,%ebx
add    $0x1,%eax
jmp    1180 <topostfix+0x40>
test   %ebx,%ebx
js     1467 <topostfix+0x327>
mov    %ebx,%eax
movslq %r15d,%rbp
cmp    $0x1f,%ebx
jae    138a <topostfix+0x24a>
mov    %rbp,%r15
jmp    1450 <topostfix+0x310>
lea    0x1(%rax),%rcx
mov    %rcx,%rdx
and    $0xffffffffffffffe0,%rdx
lea    (%rdx,%rbp,1),%r15
mov    %rdx,%rsi
neg    %rsi
lea    (%rsp,%rax,1),%rdi
add    $0x11,%rdi
sub    %rdx,%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    13c0 <topostfix+0x280>
cmp    %rdx,%rcx
je     1467 <topostfix+0x327>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movzbl 0x20(%rsp,%rax,1),%ecx
mov    %cl,0x91(%rsp,%r15,1)
add    $0x1,%r15
add    $0xffffffffffffffff,%rax
jb     1450 <topostfix+0x310>
movslq %r15d,%rax
lea    0x90(%rsp),%rbx
movb   $0x0,0x1(%rax,%rbx,1)
lea    0xba9(%rip),%rdi
mov    %rbx,%rsi
call   1050 <printf@plt>
mov    %rbx,%rdi
call   1030 <values@plt>
lea    0xbb2(%rip),%rdi
mov    %rbx,%rsi
call   1050 <printf@plt>
mov    %rbx,%rdi
call   1040 <evapo@plt>
add    $0xf8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
@.str = [39 x i8] c"\0A the infix expression entered is :%s\00"
@.str.1 = [32 x i8] c"\0A The postfix rxpression is :%s\00"
@.str.2 = [46 x i8] c"\0A The postfix rxpression after valuing is :%s\00"
define void @topostfix(i8* %0) {
%2 = alloca [100 x i8]
%3 = alloca [100 x i8]
%4 = tail call i32 @printf(i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str, i64 0, i64 0), i8* %0)
%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 40, label %57
i8 41, 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 40, 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 sgt i8 %105, %107
br i1 %108, label %109, label %114
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 sgt i8 %116, %106
%118 = icmp eq i8 %106, 40
%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, 40
%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 = call i32 @printf(i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.1, i64 0, i64 0), i8* %6)
%171 = call i32 @values(i8* %6)
%172 = call i32 @printf(i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.2, i64 0, i64 0), i8* %6)
%173 = call i32 @evapo(i8* %6)
ret void
}