#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 */
scalar_t__ is_operator(char);
scalar_t__ op_left_assoc(char);
scalar_t__ op_preced(char);
char *operand_end(char *);
int /*<<< orphan*/ printf(char *);
int postfix_convert(char *input, char *output) {
  char *inptr = input;
  char *outptr = output;
  char stack[128];
  int sl = 0;
  char sc;
  int so_i = 0;
  while (*inptr) {
    char c = *inptr;
    if (c != ' ') {
      if (!is_operator(c) && c != '(' && c != ')') {
        *outptr = 'x';
        ++outptr;
        char *end = operand_end(inptr);
        inptr = end - 1;
      } else if (is_operator(c)) {
        while (sl > 0) {
          sc = stack[sl - 1];
          if (is_operator(sc) &&
              ((op_left_assoc(c) && (op_preced(c) >= op_preced(sc))) ||
               (op_preced(c) > op_preced(sc)))) {
            *outptr = sc;
            ++outptr;
            sl--;
          } else {
            break;
          }
        }
        stack[sl] = c;
        ++sl;
      } else if (c == '(') {
        stack[sl] = c;
        ++sl;
      } else if (c == ')') {
        int pe = 0;
        while (sl > 0) {
          sc = stack[sl - 1];
          if (sc == '(') {
            pe = 1;
            break;
          } else {
            *outptr = sc;
            ++outptr;
            sl--;
          }
        }
        if (!pe) {
          printf("Error: parentheses mismatch\n");
          return 0;
        }
        sl--;
        if (sl > 0) {
          sc = stack[sl - 1];
        }
      }
    }
    ++inptr;
  }
  while (sl > 0) {
    sc = stack[sl - 1];
    if (sc == '(' || sc == ')') {
      printf("Error: parentheses mismatched\n");
      return 0;
    }
    *outptr = sc;
    ++outptr;
    --sl;
  }
  *outptr = 0;
  return 1;
}


x86 assembly (clang, -O0):
<postfix_convert>:
push   %rbp
mov    %rsp,%rbp
sub    $0xe0,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x28(%rbp)
movl   $0x0,-0xb4(%rbp)
movl   $0x0,-0xbc(%rbp)
mov    -0x20(%rbp),%rax
cmpb   $0x0,(%rax)
je     1490 <postfix_convert+0x340>
mov    -0x20(%rbp),%rax
mov    (%rax),%al
mov    %al,-0xbd(%rbp)
movsbl -0xbd(%rbp),%eax
cmp    $0x20,%eax
je     147f <postfix_convert+0x32f>
movsbl -0xbd(%rbp),%edi
call   1060 <is_operator@plt>
cmp    $0x0,%rax
jne    121d <postfix_convert+0xcd>
movsbl -0xbd(%rbp),%eax
cmp    $0x28,%eax
je     121d <postfix_convert+0xcd>
movsbl -0xbd(%rbp),%eax
cmp    $0x29,%eax
je     121d <postfix_convert+0xcd>
mov    -0x28(%rbp),%rax
movb   $0x78,(%rax)
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
mov    -0x20(%rbp),%rdi
call   1070 <operand_end@plt>
mov    %rax,-0xc8(%rbp)
mov    -0xc8(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x20(%rbp)
jmp    147a <postfix_convert+0x32a>
movsbl -0xbd(%rbp),%edi
call   1060 <is_operator@plt>
cmp    $0x0,%rax
je     134b <postfix_convert+0x1fb>
jmp    1238 <postfix_convert+0xe8>
cmpl   $0x0,-0xb4(%rbp)
jle    1323 <postfix_convert+0x1d3>
mov    -0xb4(%rbp),%eax
sub    $0x1,%eax
cltq
mov    -0xb0(%rbp,%rax,1),%al
mov    %al,-0xb5(%rbp)
movsbl -0xb5(%rbp),%edi
call   1060 <is_operator@plt>
cmp    $0x0,%rax
je     1319 <postfix_convert+0x1c9>
movsbl -0xbd(%rbp),%edi
call   1050 <op_left_assoc@plt>
cmp    $0x0,%rax
je     12bb <postfix_convert+0x16b>
movsbl -0xbd(%rbp),%edi
call   1030 <op_preced@plt>
mov    %rax,-0xd8(%rbp)
movsbl -0xb5(%rbp),%edi
call   1030 <op_preced@plt>
mov    %rax,%rcx
mov    -0xd8(%rbp),%rax
cmp    %rcx,%rax
jge    12ed <postfix_convert+0x19d>
movsbl -0xbd(%rbp),%edi
call   1030 <op_preced@plt>
mov    %rax,-0xe0(%rbp)
movsbl -0xb5(%rbp),%edi
call   1030 <op_preced@plt>
mov    %rax,%rcx
mov    -0xe0(%rbp),%rax
cmp    %rcx,%rax
jle    1319 <postfix_convert+0x1c9>
mov    -0xb5(%rbp),%cl
mov    -0x28(%rbp),%rax
mov    %cl,(%rax)
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
mov    -0xb4(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xb4(%rbp)
jmp    131e <postfix_convert+0x1ce>
jmp    1323 <postfix_convert+0x1d3>
jmp    1238 <postfix_convert+0xe8>
mov    -0xbd(%rbp),%cl
movslq -0xb4(%rbp),%rax
mov    %cl,-0xb0(%rbp,%rax,1)
mov    -0xb4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb4(%rbp)
jmp    1475 <postfix_convert+0x325>
movsbl -0xbd(%rbp),%eax
cmp    $0x28,%eax
jne    1383 <postfix_convert+0x233>
mov    -0xbd(%rbp),%cl
movslq -0xb4(%rbp),%rax
mov    %cl,-0xb0(%rbp,%rax,1)
mov    -0xb4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb4(%rbp)
jmp    1470 <postfix_convert+0x320>
movsbl -0xbd(%rbp),%eax
cmp    $0x29,%eax
jne    146b <postfix_convert+0x31b>
movl   $0x0,-0xcc(%rbp)
cmpl   $0x0,-0xb4(%rbp)
jle    140d <postfix_convert+0x2bd>
mov    -0xb4(%rbp),%eax
sub    $0x1,%eax
cltq
mov    -0xb0(%rbp,%rax,1),%al
mov    %al,-0xb5(%rbp)
movsbl -0xb5(%rbp),%eax
cmp    $0x28,%eax
jne    13e1 <postfix_convert+0x291>
movl   $0x1,-0xcc(%rbp)
jmp    140d <postfix_convert+0x2bd>
mov    -0xb5(%rbp),%cl
mov    -0x28(%rbp),%rax
mov    %cl,(%rax)
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
mov    -0xb4(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xb4(%rbp)
jmp    139d <postfix_convert+0x24d>
cmpl   $0x0,-0xcc(%rbp)
jne    1432 <postfix_convert+0x2e2>
lea    0xbdf(%rip),%rdi
call   1040 <printf@plt>
movl   $0x0,-0x4(%rbp)
jmp    152c <postfix_convert+0x3dc>
mov    -0xb4(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xb4(%rbp)
cmpl   $0x0,-0xb4(%rbp)
jle    1466 <postfix_convert+0x316>
mov    -0xb4(%rbp),%eax
sub    $0x1,%eax
cltq
mov    -0xb0(%rbp,%rax,1),%al
mov    %al,-0xb5(%rbp)
jmp    146b <postfix_convert+0x31b>
jmp    1470 <postfix_convert+0x320>
jmp    1475 <postfix_convert+0x325>
jmp    147a <postfix_convert+0x32a>
jmp    147f <postfix_convert+0x32f>
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
jmp    1187 <postfix_convert+0x37>
jmp    1495 <postfix_convert+0x345>
cmpl   $0x0,-0xb4(%rbp)
jle    151e <postfix_convert+0x3ce>
mov    -0xb4(%rbp),%eax
sub    $0x1,%eax
cltq
mov    -0xb0(%rbp,%rax,1),%al
mov    %al,-0xb5(%rbp)
movsbl -0xb5(%rbp),%eax
cmp    $0x28,%eax
je     14da <postfix_convert+0x38a>
movsbl -0xb5(%rbp),%eax
cmp    $0x29,%eax
jne    14f2 <postfix_convert+0x3a2>
lea    0xb3c(%rip),%rdi
call   1040 <printf@plt>
movl   $0x0,-0x4(%rbp)
jmp    152c <postfix_convert+0x3dc>
mov    -0xb5(%rbp),%cl
mov    -0x28(%rbp),%rax
mov    %cl,(%rax)
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
mov    -0xb4(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xb4(%rbp)
jmp    1495 <postfix_convert+0x345>
mov    -0x28(%rbp),%rax
movb   $0x0,(%rax)
movl   $0x1,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0xe0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<postfix_convert>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x98,%rsp
mov    %rsi,%r12
mov    %rdi,%rbp
xor    %r13d,%r13d
jmp    1174 <postfix_convert+0x24>
add    $0xffffffff,%r13d
add    $0x1,%rbp
mov    0x0(%rbp),%bl
cmp    $0x20,%bl
je     1170 <postfix_convert+0x20>
test   %bl,%bl
je     12fe <postfix_convert+0x1ae>
movsbl %bl,%edi
mov    %edi,0x4(%rsp)
call   1060 <is_operator@plt>
test   %rax,%rax
jne    11c0 <postfix_convert+0x70>
mov    %ebx,%eax
and    $0xfe,%al
cmp    $0x28,%al
je     11c0 <postfix_convert+0x70>
movb   $0x78,(%r12)
add    $0x1,%r12
mov    %rbp,%rdi
call   1070 <operand_end@plt>
mov    %rax,%rbp
add    $0xffffffffffffffff,%rbp
add    $0x1,%rbp
jmp    1174 <postfix_convert+0x24>
nopl   0x0(%rax,%rax,1)
mov    0x4(%rsp),%edi
call   1060 <is_operator@plt>
test   %rax,%rax
je     126c <postfix_convert+0x11c>
test   %r13d,%r13d
jle    12d4 <postfix_convert+0x184>
mov    %bl,0x3(%rsp)
mov    %rbp,0x8(%rsp)
mov    %r13d,%r13d
mov    0x4(%rsp),%ebx
jmp    1224 <postfix_convert+0xd4>
nopl   (%rax)
mov    %ebx,%edi
call   1030 <op_preced@plt>
mov    %rax,%rbx
mov    %ebp,%edi
call   1030 <op_preced@plt>
cmp    %rax,%rbx
mov    0x4(%rsp),%ebx
jle    12be <postfix_convert+0x16e>
mov    %r14b,(%r12)
add    $0x1,%r12
lea    0x1(%r13),%rax
cmp    $0x1,%rax
jbe    12c8 <postfix_convert+0x178>
mov    %r13,%r15
add    $0xffffffffffffffff,%r13
mov    %r13d,%eax
movzbl 0x10(%rsp,%rax,1),%r14d
movsbl %r14b,%ebp
mov    %ebp,%edi
call   1060 <is_operator@plt>
test   %rax,%rax
je     12be <postfix_convert+0x16e>
mov    %ebx,%edi
call   1050 <op_left_assoc@plt>
test   %rax,%rax
je     11f0 <postfix_convert+0xa0>
mov    %ebx,%edi
call   1030 <op_preced@plt>
mov    %rax,%rbx
mov    %ebp,%edi
call   1030 <op_preced@plt>
cmp    %rax,%rbx
mov    0x4(%rsp),%ebx
jl     11f0 <postfix_convert+0xa0>
jmp    120e <postfix_convert+0xbe>
cmp    $0x28,%bl
je     12e9 <postfix_convert+0x199>
cmp    $0x29,%bl
jne    1170 <postfix_convert+0x20>
test   %r13d,%r13d
jle    1340 <postfix_convert+0x1f0>
mov    %r13d,%r13d
cs nopw 0x0(%rax,%rax,1)
lea    -0x1(%r13),%rax
mov    %eax,%ecx
movzbl 0x10(%rsp,%rcx,1),%ecx
cmp    $0x28,%cl
je     116c <postfix_convert+0x1c>
mov    %cl,(%r12)
add    $0x1,%r12
lea    0x1(%rax),%rcx
mov    %rax,%r13
cmp    $0x1,%rcx
ja     1290 <postfix_convert+0x140>
jmp    1340 <postfix_convert+0x1f0>
mov    0x8(%rsp),%rbp
mov    %r15,%r13
jmp    12d0 <postfix_convert+0x180>
xor    %r13d,%r13d
mov    0x8(%rsp),%rbp
mov    0x3(%rsp),%bl
movslq %r13d,%r13
mov    %bl,0x10(%rsp,%r13,1)
add    $0x1,%r13d
add    $0x1,%rbp
jmp    1174 <postfix_convert+0x24>
movslq %r13d,%rax
movb   $0x28,0x10(%rsp,%rax,1)
add    $0x1,%r13d
add    $0x1,%rbp
jmp    1174 <postfix_convert+0x24>
test   %r13d,%r13d
jle    1334 <postfix_convert+0x1e4>
mov    %r13d,%eax
add    $0x1,%rax
nopw   0x0(%rax,%rax,1)
lea    -0x2(%rax),%ecx
movzbl 0x10(%rsp,%rcx,1),%ecx
mov    %ecx,%edx
and    $0xfe,%dl
cmp    $0x28,%dl
je     1349 <postfix_convert+0x1f9>
mov    %cl,(%r12)
add    $0x1,%r12
add    $0xffffffffffffffff,%rax
cmp    $0x1,%rax
ja     1310 <postfix_convert+0x1c0>
movb   $0x0,(%r12)
mov    $0x1,%eax
jmp    1357 <postfix_convert+0x207>
lea    0xcd7(%rip),%rdi
jmp    1350 <postfix_convert+0x200>
lea    0xcb0(%rip),%rdi
call   1040 <puts@plt>
xor    %eax,%eax
add    $0x98,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
@str = [30 x i8] c"Error: parentheses mismatched\00"
@str.2 = [28 x i8] c"Error: parentheses mismatch\00"
define i32 @postfix_convert(i8* %0, i8* nocapture writeonly %1) {
%3 = alloca [128 x i8]
%4 = getelementptr inbounds [128 x i8], [128 x i8]* %3, i64 0, i64 0
br label %5
5: ; preds = %89, %2
%6 = phi i32 [ 0, %2 ], [ %90, %89 ]
%7 = phi i8* [ %1, %2 ], [ %91, %89 ]
%8 = phi i8* [ %0, %2 ], [ %93, %89 ]
%9 = load i8, i8* %8
switch i8 %9, label %14 [
i8 0, label %10
i8 32, label %89
]
10: ; preds = %5
%11 = icmp sgt i32 %6, 0
br i1 %11, label %12, label %108
12: ; preds = %10
%13 = zext i32 %6 to i64
br label %94
14: ; preds = %5
%15 = tail call i64 @is_operator(i8 signext %9)
%16 = freeze i64 %15
%17 = icmp ne i64 %16, 0
%18 = and i8 %9, -2
%19 = icmp eq i8 %18, 40
%20 = select i1 %17, i1 true, i1 %19
br i1 %20, label %25, label %21
21: ; preds = %14
store i8 120, i8* %7
%22 = getelementptr inbounds i8, i8* %7, i64 1
%23 = tail call i8* @operand_end(i8* %8)
%24 = getelementptr inbounds i8, i8* %23, i64 -1
br label %89
25: ; preds = %14
%26 = tail call i64 @is_operator(i8 signext %9)
%27 = icmp eq i64 %26, 0
br i1 %27, label %65, label %28
28: ; preds = %25
%29 = icmp sgt i32 %6, 0
br i1 %29, label %30, label %59
30: ; preds = %28
%31 = zext i32 %6 to i64
br label %32
32: ; preds = %30, %52
%33 = phi i64 [ %31, %30 ], [ %35, %52 ]
%34 = phi i8* [ %7, %30 ], [ %53, %52 ]
%35 = add nsw i64 %33, -1
%36 = and i64 %35, 4294967295
%37 = getelementptr inbounds [128 x i8], [128 x i8]* %3, i64 0, i64 %36
%38 = load i8, i8* %37
%39 = tail call i64 @is_operator(i8 signext %38)
%40 = icmp eq i64 %39, 0
br i1 %40, label %55, label %41
41: ; preds = %32
%42 = tail call i64 @op_left_assoc(i8 signext %9)
%43 = icmp eq i64 %42, 0
br i1 %43, label %48, label %44
44: ; preds = %41
%45 = tail call i64 @op_preced(i8 signext %9)
%46 = tail call i64 @op_preced(i8 signext %38)
%47 = icmp slt i64 %45, %46
br i1 %47, label %48, label %52
48: ; preds = %44, %41
%49 = tail call i64 @op_preced(i8 signext %9)
%50 = tail call i64 @op_preced(i8 signext %38)
%51 = icmp sgt i64 %49, %50
br i1 %51, label %52, label %57
52: ; preds = %48, %44
store i8 %38, i8* %34
%53 = getelementptr inbounds i8, i8* %34, i64 1
%54 = icmp ugt i64 %33, 1
br i1 %54, label %32, label %59
55: ; preds = %32
%56 = trunc i64 %33 to i32
br label %59
57: ; preds = %48
%58 = trunc i64 %33 to i32
br label %59
59: ; preds = %52, %55, %57, %28
%60 = phi i32 [ %6, %28 ], [ %56, %55 ], [ %58, %57 ], [ 0, %52 ]
%61 = phi i8* [ %7, %28 ], [ %34, %55 ], [ %34, %57 ], [ %53, %52 ]
%62 = sext i32 %60 to i64
%63 = getelementptr inbounds [128 x i8], [128 x i8]* %3, i64 0, i64 %62
store i8 %9, i8* %63
%64 = add nsw i32 %60, 1
br label %89
65: ; preds = %25
switch i8 %9, label %89 [
i8 40, label %70
i8 41, label %66
]
66: ; preds = %65
%67 = icmp sgt i32 %6, 0
br i1 %67, label %68, label %85
68: ; preds = %66
%69 = zext i32 %6 to i64
br label %74
70: ; preds = %65
%71 = sext i32 %6 to i64
%72 = getelementptr inbounds [128 x i8], [128 x i8]* %3, i64 0, i64 %71
store i8 40, i8* %72
%73 = add nsw i32 %6, 1
br label %89
74: ; preds = %68, %82
%75 = phi i64 [ %69, %68 ], [ %77, %82 ]
%76 = phi i8* [ %7, %68 ], [ %83, %82 ]
%77 = add nsw i64 %75, -1
%78 = and i64 %77, 4294967295
%79 = getelementptr inbounds [128 x i8], [128 x i8]* %3, i64 0, i64 %78
%80 = load i8, i8* %79
%81 = icmp eq i8 %80, 40
br i1 %81, label %87, label %82
82: ; preds = %74
store i8 %80, i8* %76
%83 = getelementptr inbounds i8, i8* %76, i64 1
%84 = icmp ugt i64 %75, 1
br i1 %84, label %74, label %85
85: ; preds = %66, %82
%86 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([28 x i8], [28 x i8]* @str.2, i64 0, i64 0))
br label %110
87: ; preds = %74
%88 = trunc i64 %77 to i32
br label %89
89: ; preds = %87, %59, %70, %21, %5, %65
%90 = phi i32 [ %6, %21 ], [ %64, %59 ], [ %73, %70 ], [ %6, %5 ], [ %6, %65 ], [ %88, %87 ]
%91 = phi i8* [ %22, %21 ], [ %61, %59 ], [ %7, %70 ], [ %7, %5 ], [ %7, %65 ], [ %76, %87 ]
%92 = phi i8* [ %24, %21 ], [ %8, %59 ], [ %8, %70 ], [ %8, %5 ], [ %8, %65 ], [ %8, %87 ]
%93 = getelementptr inbounds i8, i8* %92, i64 1
br label %5
94: ; preds = %12, %105
%95 = phi i64 [ %13, %12 ], [ %97, %105 ]
%96 = phi i8* [ %7, %12 ], [ %106, %105 ]
%97 = add nsw i64 %95, -1
%98 = and i64 %97, 4294967295
%99 = getelementptr inbounds [128 x i8], [128 x i8]* %3, i64 0, i64 %98
%100 = load i8, i8* %99
%101 = and i8 %100, -2
%102 = icmp eq i8 %101, 40
br i1 %102, label %103, label %105
103: ; preds = %94
%104 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([30 x i8], [30 x i8]* @str, i64 0, i64 0))
br label %110
105: ; preds = %94
store i8 %100, i8* %96
%106 = getelementptr inbounds i8, i8* %96, i64 1
%107 = icmp ugt i64 %95, 1
br i1 %107, label %94, label %108
108: ; preds = %105, %10
%109 = phi i8* [ %7, %10 ], [ %106, %105 ]
store i8 0, i8* %109
br label %110
110: ; preds = %85, %108, %103
%111 = phi i32 [ 0, %103 ], [ 1, %108 ], [ 0, %85 ]
ret i32 %111
}