#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 atoi(char *);
scalar_t__ isdigit(char);
int /*<<< orphan*/ printf(char *, char *, int, int, ...);
int strlen(char *);
int main() {
  char TIPS_T[] = "EXPR: %s%cRESULT: %d%c";
  char TIPS_F[] = "EXPR: %s%cRESULT: error%c";
  char expr[] = "16/4+((8-5)*(4+3)+1)-10/2*9#";
  char post[1000];
  char ss[1000];
  char ch;
  int sum;
  int i;
  int t;
  int z;
  int error = 0;
  int top = 0;
  sum = strlen(expr);
  t = 1;
  i = 0;
  ch = expr[i];
  i += 1;
  while (ch != '#') {
    if (ch == '+' || ch == '-') {
      while (top != 0 && ss[top] != '(') {
        post[t] = ss[top];
        top -= 1;
        t += 1;
      }
      top += 1;
      ss[top] = ch;
    } else if (ch == '*' || ch == '/') {
      while (ss[top] == '*' || ss[top] == '/') {
        post[t] = ss[top];
        top -= 1;
        t += 1;
      }
      top += 1;
      ss[top] = ch;
    } else if (ch == '(') {
      top += 1;
      ss[top] = ch;
    } else if (ch == ')') {
      while (ss[top] != '(') {
        post[t] = ss[top];
        top -= 1;
        t += 1;
      }
      top -= 1;
    } else if (ch == ' ') {
      z = 1;
    } else {
      while (isdigit(ch) || ch == '.') {
        post[t] = ch;
        t += 1;
        ch = expr[i];
        i += 1;
      }
      i -= 1;
      post[t] = ' ';
      t += 1;
    }
    ch = expr[i];
    i += 1;
  }
  while (top != 0) {
    post[t] = ss[top];
    t += 1;
    top -= 1;
  }
  post[t] = ' ';
  int newstack[100];
  char newstr[100];
  t = 1;
  top = 0;
  ch = post[t];
  t = t + 1;
  char temp;
  while (ch != ' ' && error == 0) {
    if (ch == '+') {
      newstack[top - 1] = newstack[top - 1] + newstack[top];
      top -= 1;
    } else if (ch == '-') {
      newstack[top - 1] = newstack[top - 1] - newstack[top];
      top -= 1;
    } else if (ch == '*') {
      newstack[top - 1] = newstack[top - 1] * newstack[top];
      top -= 1;
    } else if (ch == '/') {
      if (newstack[top] != 0)
        newstack[top - 1] = newstack[top - 1] / newstack[top];
      else
        error = 1;
      top -= 1;
    } else {
      i = 0;
      while (isdigit(ch) || ch == '.') {
        newstr[i] = ch;
        i += 1;
        ch = post[t];
        t += 1;
      }
      temp = 0;
      newstr[i] = temp;
      top += 1;
      newstack[top] = atoi(newstr);
    }
    ch = post[t];
    t += 1;
  }
  if (error == 0)
    printf(TIPS_T, expr, 10, newstack[top], 10);
  else
    printf(TIPS_F, expr, 10, 10);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa70,%rsp
movl   $0x0,-0x4(%rbp)
mov    0xea7(%rip),%rax
mov    %rax,-0x20(%rbp)
mov    0xea4(%rip),%rax
mov    %rax,-0x18(%rbp)
mov    0xea2(%rip),%eax
mov    %eax,-0x10(%rbp)
mov    0xe9c(%rip),%ax
mov    %ax,-0xc(%rbp)
mov    0xe94(%rip),%al
mov    %al,-0xa(%rbp)
mov    0xe94(%rip),%rax
mov    %rax,-0x40(%rbp)
mov    0xe91(%rip),%rax
mov    %rax,-0x38(%rbp)
mov    0xe8e(%rip),%rax
mov    %rax,-0x30(%rbp)
mov    0xe8b(%rip),%ax
mov    %ax,-0x28(%rbp)
mov    0xe88(%rip),%rax
mov    %rax,-0x60(%rbp)
mov    0xe85(%rip),%rax
mov    %rax,-0x58(%rbp)
mov    0xe82(%rip),%rax
mov    %rax,-0x50(%rbp)
mov    0xe80(%rip),%eax
mov    %eax,-0x48(%rbp)
mov    0xe7b(%rip),%al
mov    %al,-0x44(%rbp)
movl   $0x0,-0x858(%rbp)
movl   $0x0,-0x85c(%rbp)
lea    -0x60(%rbp),%rdi
call   1040 <strlen@plt>
mov    %eax,-0x848(%rbp)
movl   $0x1,-0x850(%rbp)
movl   $0x0,-0x84c(%rbp)
movslq -0x84c(%rbp),%rax
mov    -0x60(%rbp,%rax,1),%al
mov    %al,-0x841(%rbp)
mov    -0x84c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84c(%rbp)
movsbl -0x841(%rbp),%eax
cmp    $0x23,%eax
je     15c5 <main+0x485>
movsbl -0x841(%rbp),%eax
cmp    $0x2b,%eax
je     126b <main+0x12b>
movsbl -0x841(%rbp),%eax
cmp    $0x2d,%eax
jne    131a <main+0x1da>
jmp    1270 <main+0x130>
xor    %eax,%eax
cmpl   $0x0,-0x85c(%rbp)
mov    %al,-0xa62(%rbp)
je     12a0 <main+0x160>
movslq -0x85c(%rbp),%rax
movsbl -0x840(%rbp,%rax,1),%eax
ff
cmp    $0x28,%eax
setne  %al
mov    %al,-0xa62(%rbp)
mov    -0xa62(%rbp),%al
test   $0x1,%al
jne    12b3 <main+0x173>
jmp    12f2 <main+0x1b2>
movslq -0x85c(%rbp),%rax
mov    -0x840(%rbp,%rax,1),%cl
movslq -0x850(%rbp),%rax
mov    %cl,-0x450(%rbp,%rax,1)
mov    -0x85c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x85c(%rbp)
mov    -0x850(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x850(%rbp)
jmp    1270 <main+0x130>
mov    -0x85c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x85c(%rbp)
mov    -0x841(%rbp),%cl
movslq -0x85c(%rbp),%rax
mov    %cl,-0x840(%rbp,%rax,1)
jmp    15a0 <main+0x460>
movsbl -0x841(%rbp),%eax
cmp    $0x2a,%eax
je     133a <main+0x1fa>
movsbl -0x841(%rbp),%eax
cmp    $0x2f,%eax
jne    13f4 <main+0x2b4>
jmp    133f <main+0x1ff>
movslq -0x85c(%rbp),%rax
movsbl -0x840(%rbp,%rax,1),%ecx
ff
mov    $0x1,%al
cmp    $0x2a,%ecx
mov    %al,-0xa63(%rbp)
je     137a <main+0x23a>
movslq -0x85c(%rbp),%rax
movsbl -0x840(%rbp,%rax,1),%eax
ff
cmp    $0x2f,%eax
sete   %al
mov    %al,-0xa63(%rbp)
mov    -0xa63(%rbp),%al
test   $0x1,%al
jne    138d <main+0x24d>
jmp    13cc <main+0x28c>
movslq -0x85c(%rbp),%rax
mov    -0x840(%rbp,%rax,1),%cl
movslq -0x850(%rbp),%rax
mov    %cl,-0x450(%rbp,%rax,1)
mov    -0x85c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x85c(%rbp)
mov    -0x850(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x850(%rbp)
jmp    133f <main+0x1ff>
mov    -0x85c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x85c(%rbp)
mov    -0x841(%rbp),%cl
movslq -0x85c(%rbp),%rax
mov    %cl,-0x840(%rbp,%rax,1)
jmp    159b <main+0x45b>
movsbl -0x841(%rbp),%eax
cmp    $0x28,%eax
jne    142c <main+0x2ec>
mov    -0x85c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x85c(%rbp)
mov    -0x841(%rbp),%cl
movslq -0x85c(%rbp),%rax
mov    %cl,-0x840(%rbp,%rax,1)
jmp    1596 <main+0x456>
movsbl -0x841(%rbp),%eax
cmp    $0x29,%eax
jne    14ac <main+0x36c>
jmp    1441 <main+0x301>
movslq -0x85c(%rbp),%rax
movsbl -0x840(%rbp,%rax,1),%eax
ff
cmp    $0x28,%eax
je     1498 <main+0x358>
movslq -0x85c(%rbp),%rax
mov    -0x840(%rbp,%rax,1),%cl
movslq -0x850(%rbp),%rax
mov    %cl,-0x450(%rbp,%rax,1)
mov    -0x85c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x85c(%rbp)
mov    -0x850(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x850(%rbp)
jmp    1441 <main+0x301>
mov    -0x85c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x85c(%rbp)
jmp    1591 <main+0x451>
movsbl -0x841(%rbp),%eax
cmp    $0x20,%eax
jne    14cb <main+0x38b>
movl   $0x1,-0x854(%rbp)
jmp    158c <main+0x44c>
jmp    14d0 <main+0x390>
movsbl -0x841(%rbp),%edi
call   1030 <isdigit@plt>
mov    %rax,%rcx
mov    $0x1,%al
cmp    $0x0,%rcx
mov    %al,-0xa64(%rbp)
jne    1504 <main+0x3c4>
movsbl -0x841(%rbp),%eax
cmp    $0x2e,%eax
sete   %al
mov    %al,-0xa64(%rbp)
mov    -0xa64(%rbp),%al
test   $0x1,%al
jne    1517 <main+0x3d7>
jmp    155f <main+0x41f>
mov    -0x841(%rbp),%cl
movslq -0x850(%rbp),%rax
mov    %cl,-0x450(%rbp,%rax,1)
mov    -0x850(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x850(%rbp)
movslq -0x84c(%rbp),%rax
mov    -0x60(%rbp,%rax,1),%al
mov    %al,-0x841(%rbp)
mov    -0x84c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84c(%rbp)
jmp    14d0 <main+0x390>
mov    -0x84c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x84c(%rbp)
movslq -0x850(%rbp),%rax
movb   $0x20,-0x450(%rbp,%rax,1)
20
mov    -0x850(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x850(%rbp)
jmp    1591 <main+0x451>
jmp    1596 <main+0x456>
jmp    159b <main+0x45b>
jmp    15a0 <main+0x460>
movslq -0x84c(%rbp),%rax
mov    -0x60(%rbp,%rax,1),%al
mov    %al,-0x841(%rbp)
mov    -0x84c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84c(%rbp)
jmp    123b <main+0xfb>
jmp    15ca <main+0x48a>
cmpl   $0x0,-0x85c(%rbp)
je     1616 <main+0x4d6>
movslq -0x85c(%rbp),%rax
mov    -0x840(%rbp,%rax,1),%cl
movslq -0x850(%rbp),%rax
mov    %cl,-0x450(%rbp,%rax,1)
mov    -0x850(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x850(%rbp)
mov    -0x85c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x85c(%rbp)
jmp    15ca <main+0x48a>
movslq -0x850(%rbp),%rax
movb   $0x20,-0x450(%rbp,%rax,1)
20
movl   $0x1,-0x850(%rbp)
movl   $0x0,-0x85c(%rbp)
movslq -0x850(%rbp),%rax
mov    -0x450(%rbp,%rax,1),%al
mov    %al,-0x841(%rbp)
mov    -0x850(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x850(%rbp)
movsbl -0x841(%rbp),%ecx
xor    %eax,%eax
cmp    $0x20,%ecx
mov    %al,-0xa65(%rbp)
je     1684 <main+0x544>
cmpl   $0x0,-0x858(%rbp)
sete   %al
mov    %al,-0xa65(%rbp)
mov    -0xa65(%rbp),%al
test   $0x1,%al
jne    1697 <main+0x557>
jmp    1930 <main+0x7f0>
movsbl -0x841(%rbp),%eax
cmp    $0x2b,%eax
jne    16ed <main+0x5ad>
mov    -0x85c(%rbp),%eax
sub    $0x1,%eax
cltq
mov    -0x9f0(%rbp,%rax,4),%ecx
movslq -0x85c(%rbp),%rax
add    -0x9f0(%rbp,%rax,4),%ecx
mov    -0x85c(%rbp),%eax
sub    $0x1,%eax
cltq
mov    %ecx,-0x9f0(%rbp,%rax,4)
mov    -0x85c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x85c(%rbp)
jmp    1908 <main+0x7c8>
movsbl -0x841(%rbp),%eax
cmp    $0x2d,%eax
jne    1743 <main+0x603>
mov    -0x85c(%rbp),%eax
sub    $0x1,%eax
cltq
mov    -0x9f0(%rbp,%rax,4),%ecx
movslq -0x85c(%rbp),%rax
sub    -0x9f0(%rbp,%rax,4),%ecx
mov    -0x85c(%rbp),%eax
sub    $0x1,%eax
cltq
mov    %ecx,-0x9f0(%rbp,%rax,4)
mov    -0x85c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x85c(%rbp)
jmp    1903 <main+0x7c3>
movsbl -0x841(%rbp),%eax
cmp    $0x2a,%eax
jne    179a <main+0x65a>
mov    -0x85c(%rbp),%eax
sub    $0x1,%eax
cltq
mov    -0x9f0(%rbp,%rax,4),%ecx
movslq -0x85c(%rbp),%rax
imul   -0x9f0(%rbp,%rax,4),%ecx
ff
mov    -0x85c(%rbp),%eax
sub    $0x1,%eax
cltq
mov    %ecx,-0x9f0(%rbp,%rax,4)
mov    -0x85c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x85c(%rbp)
jmp    18fe <main+0x7be>
movsbl -0x841(%rbp),%eax
cmp    $0x2f,%eax
jne    1817 <main+0x6d7>
movslq -0x85c(%rbp),%rax
cmpl   $0x0,-0x9f0(%rbp,%rax,4)
je     17f9 <main+0x6b9>
mov    -0x85c(%rbp),%eax
sub    $0x1,%eax
cltq
mov    -0x9f0(%rbp,%rax,4),%eax
movslq -0x85c(%rbp),%rcx
cltd
idivl  -0x9f0(%rbp,%rcx,4)
mov    %eax,%ecx
mov    -0x85c(%rbp),%eax
sub    $0x1,%eax
cltq
mov    %ecx,-0x9f0(%rbp,%rax,4)
jmp    1803 <main+0x6c3>
movl   $0x1,-0x858(%rbp)
mov    -0x85c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x85c(%rbp)
jmp    18f9 <main+0x7b9>
movl   $0x0,-0x84c(%rbp)
movsbl -0x841(%rbp),%edi
call   1030 <isdigit@plt>
mov    %rax,%rcx
mov    $0x1,%al
cmp    $0x0,%rcx
mov    %al,-0xa66(%rbp)
jne    1855 <main+0x715>
movsbl -0x841(%rbp),%eax
cmp    $0x2e,%eax
sete   %al
mov    %al,-0xa66(%rbp)
mov    -0xa66(%rbp),%al
test   $0x1,%al
jne    1868 <main+0x728>
jmp    18b3 <main+0x773>
mov    -0x841(%rbp),%cl
movslq -0x84c(%rbp),%rax
mov    %cl,-0xa60(%rbp,%rax,1)
mov    -0x84c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84c(%rbp)
movslq -0x850(%rbp),%rax
mov    -0x450(%rbp,%rax,1),%al
mov    %al,-0x841(%rbp)
mov    -0x850(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x850(%rbp)
jmp    1821 <main+0x6e1>
movb   $0x0,-0xa61(%rbp)
mov    -0xa61(%rbp),%cl
movslq -0x84c(%rbp),%rax
mov    %cl,-0xa60(%rbp,%rax,1)
mov    -0x85c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x85c(%rbp)
lea    -0xa60(%rbp),%rdi
call   1060 <atoi@plt>
mov    %eax,%ecx
movslq -0x85c(%rbp),%rax
mov    %ecx,-0x9f0(%rbp,%rax,4)
jmp    18fe <main+0x7be>
jmp    1903 <main+0x7c3>
jmp    1908 <main+0x7c8>
movslq -0x850(%rbp),%rax
mov    -0x450(%rbp,%rax,1),%al
mov    %al,-0x841(%rbp)
mov    -0x850(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x850(%rbp)
jmp    165c <main+0x51c>
cmpl   $0x0,-0x858(%rbp)
jne    1968 <main+0x828>
lea    -0x20(%rbp),%rdi
lea    -0x60(%rbp),%rsi
movslq -0x85c(%rbp),%rax
mov    -0x9f0(%rbp,%rax,4),%ecx
mov    $0xa,%r8d
mov    %r8d,%edx
mov    $0x0,%al
call   1050 <printf@plt>
jmp    197e <main+0x83e>
lea    -0x40(%rbp),%rdi
lea    -0x60(%rbp),%rsi
mov    $0xa,%ecx
mov    %ecx,%edx
mov    $0x0,%al
call   1050 <printf@plt>
xor    %eax,%eax
add    $0xa70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xa48,%rsp
movaps 0xf08(%rip),%xmm0
movaps %xmm0,0x30(%rsp)
movabs $0x63256425203a54,%rax
mov    %rax,0x3f(%rsp)
movups 0xf17(%rip),%xmm0
movups %xmm0,0x5a(%rsp)
movaps 0xf01(%rip),%xmm0
movaps %xmm0,0x50(%rsp)
movups 0xf22(%rip),%xmm0
movups %xmm0,0xd(%rsp)
movdqa 0xf08(%rip),%xmm0
movdqa %xmm0,(%rsp)
mov    %rsp,%rdi
call   1040 <strlen@plt>
mov    (%rsp),%r15b
xor    %r13d,%r13d
mov    $0x1,%r12d
lea    0xe47(%rip),%r8
mov    $0x1,%r14d
jmp    11e4 <main+0xa4>
sub    %esi,%r13d
add    %esi,%r14d
mov    %r13d,%eax
movslq %eax,%r13
mov    %r15b,0x661(%rsp,%r13,1)
add    $0x1,%r13
movslq %r12d,%r12
mov    (%rsp,%r12,1),%r15b
add    $0x1,%r12d
lea    -0x20(%r15),%eax
cmp    $0xf,%al
ja     12a3 <main+0x163>
movzbl %al,%eax
movslq (%r8,%rax,4),%rax
add    %r8,%rax
jmp    *%rax
movslq %r14d,%rax
movslq %r13d,%rcx
add    %rsp,%rcx
add    $0x660,%rcx
lea    (%rsp,%rax,1),%rdx
add    $0x270,%rdx
xor    %eax,%eax
jmp    122b <main+0xeb>
nopl   0x0(%rax,%rax,1)
mov    %bl,(%rdx,%rax,1)
add    $0x1,%rax
add    $0xffffffffffffffff,%rcx
movzbl (%rcx),%ebx
cmp    $0x2f,%bl
je     1220 <main+0xe0>
cmp    $0x2a,%bl
je     1220 <main+0xe0>
add    %eax,%r14d
add    $0x1,%r13d
sub    %rax,%r13
movslq %r13d,%rax
mov    %r15b,0x660(%rsp,%rax,1)
jmp    11d9 <main+0x99>
nop
xor    %eax,%eax
test   %r13d,%r13d
je     11ca <main+0x8a>
movslq %r13d,%rsi
movslq %r14d,%rdx
lea    (%r14,%r13,1),%ecx
add    %rsp,%rdx
add    $0x270,%rdx
lea    (%rsp,%rsi,1),%rdi
add    $0x660,%rdi
mov    %r13d,%ebp
xor    %esi,%esi
nop
movzbl (%rdi),%ebx
cmp    $0x28,%bl
je     11c1 <main+0x81>
mov    %bl,(%rdx,%rsi,1)
add    $0x1,%rsi
add    $0xffffffffffffffff,%rdi
cmp    %esi,%ebp
jne    1280 <main+0x140>
mov    %ecx,%r14d
jmp    11ca <main+0x8a>
mov    %r8,%rbx
movsbl %r15b,%edi
call   1030 <isdigit@plt>
cmp    $0x2e,%r15b
je     12ba <main+0x17a>
test   %rax,%rax
je     1311 <main+0x1d1>
mov    %r13,0x28(%rsp)
mov    %r14,0x20(%rsp)
movslq %r14d,%rax
movslq %r12d,%rcx
lea    (%rsp,%rcx,1),%rbp
lea    (%rsp,%rax,1),%r14
add    $0x270,%r14
xor    %r13d,%r13d
nopl   0x0(%rax)
mov    %r15b,(%r14,%r13,1)
movsbl 0x0(%rbp,%r13,1),%r15d
mov    %r15d,%edi
call   1030 <isdigit@plt>
add    $0x1,%r13
cmp    $0x2e,%r15d
je     12e0 <main+0x1a0>
test   %rax,%rax
jne    12e0 <main+0x1a0>
add    %r13d,%r12d
mov    0x20(%rsp),%r14
add    %r13d,%r14d
mov    0x28(%rsp),%r13
add    $0xffffffff,%r12d
movslq %r14d,%r14
movb   $0x20,0x270(%rsp,%r14,1)
add    $0x1,%r14d
mov    %rbx,%r8
jmp    11d9 <main+0x99>
movslq %r13d,%r13
movb   $0x28,0x661(%rsp,%r13,1)
jmp    11d5 <main+0x95>
movslq %r13d,%rax
mov    0x660(%rsp,%rax,1),%cl
cmp    $0x28,%cl
je     1389 <main+0x249>
movslq %r14d,%rdx
lea    (%rsp,%rdx,1),%rsi
add    $0x270,%rsi
lea    0x65f(%rsp),%rdx
add    %rdx,%rax
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
mov    %cl,(%rsi)
movzbl (%rax,%rdx,1),%ecx
add    $0x1,%rsi
add    $0xffffffffffffffff,%rdx
cmp    $0x28,%cl
jne    1370 <main+0x230>
sub    %edx,%r14d
add    %edx,%r13d
add    $0xffffffff,%r13d
jmp    11d9 <main+0x99>
test   %r13d,%r13d
je     149c <main+0x35c>
movslq %r13d,%rax
movslq %r14d,%rdi
add    $0xffffffff,%r13d
cmp    $0x1f,%r13d
jae    13b3 <main+0x273>
mov    %rdi,%r14
jmp    1480 <main+0x340>
add    $0x1,%r13
mov    %r13,%rcx
and    $0xffffffffffffffe0,%rcx
lea    (%rcx,%rdi,1),%r14
mov    %rcx,%rdx
neg    %rdx
lea    (%rsp,%rax,1),%rsi
add    $0x651,%rsi
sub    %rcx,%rax
add    %rsp,%rdi
add    $0x280,%rdi
xor    %ebp,%ebp
pxor   %xmm0,%xmm0
cs nopw 0x0(%rax,%rax,1)
movdqu -0x10(%rsi,%rbp,1),%xmm1
movdqu (%rsi,%rbp,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(%rdi)
movdqu %xmm1,(%rdi)
add    $0xffffffffffffffe0,%rbp
add    $0x20,%rdi
cmp    %rbp,%rdx
jne    13f0 <main+0x2b0>
cmp    %rcx,%r13
je     149c <main+0x35c>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movzbl 0x660(%rsp,%rax,1),%ecx
mov    %cl,0x270(%rsp,%r14,1)
add    $0x1,%r14
add    $0xffffffffffffffff,%rax
test   %eax,%eax
jne    1480 <main+0x340>
movslq %r14d,%rax
movb   $0x20,0x270(%rsp,%rax,1)
20
mov    0x271(%rsp),%bl
xor    %r12d,%r12d
cmp    $0x20,%bl
jne    14ee <main+0x3ae>
movslq %r12d,%rax
mov    0xe0(%rsp,%rax,4),%ecx
lea    0x30(%rsp),%rdi
mov    %rsp,%rsi
mov    $0xa,%edx
mov    $0xa,%r8d
xor    %eax,%eax
call   1050 <printf@plt>
xor    %eax,%eax
add    $0xa48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    $0x2,%r13d
xor    %r12d,%r12d
lea    0x70(%rsp),%r14
lea    0xb3d(%rip),%r15
jmp    1545 <main+0x405>
cs nopw 0x0(%rax,%rax,1)
nop
movslq %r12d,%rax
add    $0xffffffff,%r12d
mov    0xe0(%rsp,%rax,4),%ecx
imul   0xdc(%rsp,%rax,4),%ecx
mov    %ecx,0xdc(%rsp,%rax,4)
movslq %r13d,%r13
mov    0x270(%rsp,%r13,1),%bl
add    $0x1,%r13d
cmp    $0x20,%bl
je     14b6 <main+0x376>
lea    -0x2a(%rbx),%eax
cmp    $0x5,%al
ja     15bc <main+0x47c>
movzbl %al,%eax
movslq (%r15,%rax,4),%rax
add    %r15,%rax
jmp    *%rax
movslq %r12d,%rax
add    $0xffffffff,%r12d
mov    0xe0(%rsp,%rax,4),%ecx
add    %ecx,0xdc(%rsp,%rax,4)
jmp    152d <main+0x3ed>
nop
movslq %r12d,%rax
add    $0xffffffff,%r12d
mov    0xe0(%rsp,%rax,4),%ecx
sub    %ecx,0xdc(%rsp,%rax,4)
jmp    152d <main+0x3ed>
nopw   0x0(%rax,%rax,1)
movslq %r12d,%rcx
mov    0xe0(%rsp,%rcx,4),%esi
test   %esi,%esi
je     163c <main+0x4fc>
lea    -0x1(%rcx),%r12d
mov    0xdc(%rsp,%rcx,4),%eax
cltd
idiv   %esi
mov    %eax,0xdc(%rsp,%rcx,4)
jmp    152d <main+0x3ed>
movsbl %bl,%edi
call   1030 <isdigit@plt>
cmp    $0x2e,%bl
je     15d2 <main+0x492>
test   %rax,%rax
jne    15d2 <main+0x492>
xor    %ebp,%ebp
jmp    1616 <main+0x4d6>
movslq %r13d,%rax
lea    (%rsp,%rax,1),%r14
add    $0x270,%r14
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %bl,0x70(%rsp,%rbp,1)
movsbl (%r14,%rbp,1),%ebx
add    $0x1,%rbp
mov    %ebx,%edi
call   1030 <isdigit@plt>
cmp    $0x2e,%ebx
je     15f0 <main+0x4b0>
test   %rax,%rax
jne    15f0 <main+0x4b0>
add    %ebp,%r13d
lea    0x70(%rsp),%r14
mov    %ebp,%eax
movb   $0x0,0x70(%rsp,%rax,1)
lea    0x1(%r12),%ebx
mov    %r14,%rdi
call   1060 <atoi@plt>
movslq %r12d,%rcx
mov    %eax,0xe4(%rsp,%rcx,4)
mov    %ebx,%r12d
jmp    152d <main+0x3ed>
lea    0x50(%rsp),%rdi
mov    %rsp,%rsi
mov    $0xa,%edx
mov    $0xa,%ecx
xor    %eax,%eax
call   1050 <printf@plt>
jmp    14da <main+0x39a>

LLVM IR (-O0):
@__const.main.TIPS_T = [23 x i8] c"EXPR: %s%cRESULT: %d%c\00"
@__const.main.TIPS_F = [26 x i8] c"EXPR: %s%cRESULT: error%c\00"
@__const.main.expr = [29 x i8] c"16/4+((8-5)*(4+3)+1)-10/2*9#\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca [23 x i8]
%3 = alloca [26 x i8]
%4 = alloca [29 x i8]
%5 = alloca [1000 x i8]
%6 = alloca [1000 x i8]
%7 = alloca i8
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca [100 x i32]
%15 = alloca [100 x i8]
%16 = alloca i8
store i32 0, i32* %1
%17 = bitcast [23 x i8]* %2 to i8*
%18 = bitcast [26 x i8]* %3 to i8*
%19 = bitcast [29 x i8]* %4 to i8*
store i32 0, i32* %12
store i32 0, i32* %13
%20 = getelementptr inbounds [29 x i8], [29 x i8]* %4, i64 0, i64 0
%21 = call i32 @strlen(i8* %20)
store i32 %21, i32* %8
store i32 1, i32* %10
store i32 0, i32* %9
%22 = load i32, i32* %9
%23 = sext i32 %22 to i64
%24 = getelementptr inbounds [29 x i8], [29 x i8]* %4, i64 0, i64 %23
%25 = load i8, i8* %24
store i8 %25, i8* %7
%26 = load i32, i32* %9
%27 = add nsw i32 %26, 1
store i32 %27, i32* %9
br label %28
28: ; preds = %195, %0
%29 = load i8, i8* %7
%30 = sext i8 %29 to i32
%31 = icmp ne i32 %30, 35
br i1 %31, label %32, label %202
32: ; preds = %28
%33 = load i8, i8* %7
%34 = sext i8 %33 to i32
%35 = icmp eq i32 %34, 43
br i1 %35, label %40, label %36
36: ; preds = %32
%37 = load i8, i8* %7
%38 = sext i8 %37 to i32
%39 = icmp eq i32 %38, 45
br i1 %39, label %40, label %72
40: ; preds = %36, %32
br label %41
41: ; preds = %53, %40
%42 = load i32, i32* %13
%43 = icmp ne i32 %42, 0
br i1 %43, label %44, label %51
44: ; preds = %41
%45 = load i32, i32* %13
%46 = sext i32 %45 to i64
%47 = getelementptr inbounds [1000 x i8], [1000 x i8]* %6, i64 0, i64 %46
%48 = load i8, i8* %47
%49 = sext i8 %48 to i32
%50 = icmp ne i32 %49, 40
br label %51
51: ; preds = %44, %41
%52 = phi i1 [ false, %41 ], [ %50, %44 ]
br i1 %52, label %53, label %65
53: ; preds = %51
%54 = load i32, i32* %13
%55 = sext i32 %54 to i64
%56 = getelementptr inbounds [1000 x i8], [1000 x i8]* %6, i64 0, i64 %55
%57 = load i8, i8* %56
%58 = load i32, i32* %10
%59 = sext i32 %58 to i64
%60 = getelementptr inbounds [1000 x i8], [1000 x i8]* %5, i64 0, i64 %59
store i8 %57, i8* %60
%61 = load i32, i32* %13
%62 = sub nsw i32 %61, 1
store i32 %62, i32* %13
%63 = load i32, i32* %10
%64 = add nsw i32 %63, 1
store i32 %64, i32* %10
br label %41
65: ; preds = %51
%66 = load i32, i32* %13
%67 = add nsw i32 %66, 1
store i32 %67, i32* %13
%68 = load i8, i8* %7
%69 = load i32, i32* %13
%70 = sext i32 %69 to i64
%71 = getelementptr inbounds [1000 x i8], [1000 x i8]* %6, i64 0, i64 %70
store i8 %68, i8* %71
br label %195
72: ; preds = %36
%73 = load i8, i8* %7
%74 = sext i8 %73 to i32
%75 = icmp eq i32 %74, 42
br i1 %75, label %80, label %76
76: ; preds = %72
%77 = load i8, i8* %7
%78 = sext i8 %77 to i32
%79 = icmp eq i32 %78, 47
br i1 %79, label %80, label %116
80: ; preds = %76, %72
br label %81
81: ; preds = %97, %80
%82 = load i32, i32* %13
%83 = sext i32 %82 to i64
%84 = getelementptr inbounds [1000 x i8], [1000 x i8]* %6, i64 0, i64 %83
%85 = load i8, i8* %84
%86 = sext i8 %85 to i32
%87 = icmp eq i32 %86, 42
br i1 %87, label %95, label %88
88: ; preds = %81
%89 = load i32, i32* %13
%90 = sext i32 %89 to i64
%91 = getelementptr inbounds [1000 x i8], [1000 x i8]* %6, i64 0, i64 %90
%92 = load i8, i8* %91
%93 = sext i8 %92 to i32
%94 = icmp eq i32 %93, 47
br label %95
95: ; preds = %88, %81
%96 = phi i1 [ true, %81 ], [ %94, %88 ]
br i1 %96, label %97, label %109
97: ; preds = %95
%98 = load i32, i32* %13
%99 = sext i32 %98 to i64
%100 = getelementptr inbounds [1000 x i8], [1000 x i8]* %6, i64 0, i64 %99
%101 = load i8, i8* %100
%102 = load i32, i32* %10
%103 = sext i32 %102 to i64
%104 = getelementptr inbounds [1000 x i8], [1000 x i8]* %5, i64 0, i64 %103
store i8 %101, i8* %104
%105 = load i32, i32* %13
%106 = sub nsw i32 %105, 1
store i32 %106, i32* %13
%107 = load i32, i32* %10
%108 = add nsw i32 %107, 1
store i32 %108, i32* %10
br label %81
109: ; preds = %95
%110 = load i32, i32* %13
%111 = add nsw i32 %110, 1
store i32 %111, i32* %13
%112 = load i8, i8* %7
%113 = load i32, i32* %13
%114 = sext i32 %113 to i64
%115 = getelementptr inbounds [1000 x i8], [1000 x i8]* %6, i64 0, i64 %114
store i8 %112, i8* %115
br label %194
116: ; preds = %76
%117 = load i8, i8* %7
%118 = sext i8 %117 to i32
%119 = icmp eq i32 %118, 40
br i1 %119, label %120, label %127
120: ; preds = %116
%121 = load i32, i32* %13
%122 = add nsw i32 %121, 1
store i32 %122, i32* %13
%123 = load i8, i8* %7
%124 = load i32, i32* %13
%125 = sext i32 %124 to i64
%126 = getelementptr inbounds [1000 x i8], [1000 x i8]* %6, i64 0, i64 %125
store i8 %123, i8* %126
br label %193
127: ; preds = %116
%128 = load i8, i8* %7
%129 = sext i8 %128 to i32
%130 = icmp eq i32 %129, 41
br i1 %130, label %131, label %154
131: ; preds = %127
br label %132
132: ; preds = %139, %131
%133 = load i32, i32* %13
%134 = sext i32 %133 to i64
%135 = getelementptr inbounds [1000 x i8], [1000 x i8]* %6, i64 0, i64 %134
%136 = load i8, i8* %135
%137 = sext i8 %136 to i32
%138 = icmp ne i32 %137, 40
br i1 %138, label %139, label %151
139: ; preds = %132
%140 = load i32, i32* %13
%141 = sext i32 %140 to i64
%142 = getelementptr inbounds [1000 x i8], [1000 x i8]* %6, i64 0, i64 %141
%143 = load i8, i8* %142
%144 = load i32, i32* %10
%145 = sext i32 %144 to i64
%146 = getelementptr inbounds [1000 x i8], [1000 x i8]* %5, i64 0, i64 %145
store i8 %143, i8* %146
%147 = load i32, i32* %13
%148 = sub nsw i32 %147, 1
store i32 %148, i32* %13
%149 = load i32, i32* %10
%150 = add nsw i32 %149, 1
store i32 %150, i32* %10
br label %132
151: ; preds = %132
%152 = load i32, i32* %13
%153 = sub nsw i32 %152, 1
store i32 %153, i32* %13
br label %192
154: ; preds = %127
%155 = load i8, i8* %7
%156 = sext i8 %155 to i32
%157 = icmp eq i32 %156, 32
br i1 %157, label %158, label %159
158: ; preds = %154
store i32 1, i32* %11
br label %191
159: ; preds = %154
br label %160
160: ; preds = %170, %159
%161 = load i8, i8* %7
%162 = call i64 @isdigit(i8 signext %161)
%163 = icmp ne i64 %162, 0
br i1 %163, label %168, label %164
164: ; preds = %160
%165 = load i8, i8* %7
%166 = sext i8 %165 to i32
%167 = icmp eq i32 %166, 46
br label %168
168: ; preds = %164, %160
%169 = phi i1 [ true, %160 ], [ %167, %164 ]
br i1 %169, label %170, label %183
170: ; preds = %168
%171 = load i8, i8* %7
%172 = load i32, i32* %10
%173 = sext i32 %172 to i64
%174 = getelementptr inbounds [1000 x i8], [1000 x i8]* %5, i64 0, i64 %173
store i8 %171, i8* %174
%175 = load i32, i32* %10
%176 = add nsw i32 %175, 1
store i32 %176, i32* %10
%177 = load i32, i32* %9
%178 = sext i32 %177 to i64
%179 = getelementptr inbounds [29 x i8], [29 x i8]* %4, i64 0, i64 %178
%180 = load i8, i8* %179
store i8 %180, i8* %7
%181 = load i32, i32* %9
%182 = add nsw i32 %181, 1
store i32 %182, i32* %9
br label %160
183: ; preds = %168
%184 = load i32, i32* %9
%185 = sub nsw i32 %184, 1
store i32 %185, i32* %9
%186 = load i32, i32* %10
%187 = sext i32 %186 to i64
%188 = getelementptr inbounds [1000 x i8], [1000 x i8]* %5, i64 0, i64 %187
store i8 32, i8* %188
%189 = load i32, i32* %10
%190 = add nsw i32 %189, 1
store i32 %190, i32* %10
br label %191
191: ; preds = %183, %158
br label %192
192: ; preds = %191, %151
br label %193
193: ; preds = %192, %120
br label %194
194: ; preds = %193, %109
br label %195
195: ; preds = %194, %65
%196 = load i32, i32* %9
%197 = sext i32 %196 to i64
%198 = getelementptr inbounds [29 x i8], [29 x i8]* %4, i64 0, i64 %197
%199 = load i8, i8* %198
store i8 %199, i8* %7
%200 = load i32, i32* %9
%201 = add nsw i32 %200, 1
store i32 %201, i32* %9
br label %28
202: ; preds = %28
br label %203
203: ; preds = %206, %202
%204 = load i32, i32* %13
%205 = icmp ne i32 %204, 0
br i1 %205, label %206, label %218
206: ; preds = %203
%207 = load i32, i32* %13
%208 = sext i32 %207 to i64
%209 = getelementptr inbounds [1000 x i8], [1000 x i8]* %6, i64 0, i64 %208
%210 = load i8, i8* %209
%211 = load i32, i32* %10
%212 = sext i32 %211 to i64
%213 = getelementptr inbounds [1000 x i8], [1000 x i8]* %5, i64 0, i64 %212
store i8 %210, i8* %213
%214 = load i32, i32* %10
%215 = add nsw i32 %214, 1
store i32 %215, i32* %10
%216 = load i32, i32* %13
%217 = sub nsw i32 %216, 1
store i32 %217, i32* %13
br label %203
218: ; preds = %203
%219 = load i32, i32* %10
%220 = sext i32 %219 to i64
%221 = getelementptr inbounds [1000 x i8], [1000 x i8]* %5, i64 0, i64 %220
store i8 32, i8* %221
store i32 1, i32* %10
store i32 0, i32* %13
%222 = load i32, i32* %10
%223 = sext i32 %222 to i64
%224 = getelementptr inbounds [1000 x i8], [1000 x i8]* %5, i64 0, i64 %223
%225 = load i8, i8* %224
store i8 %225, i8* %7
%226 = load i32, i32* %10
%227 = add nsw i32 %226, 1
store i32 %227, i32* %10
br label %228
228: ; preds = %368, %218
%229 = load i8, i8* %7
%230 = sext i8 %229 to i32
%231 = icmp ne i32 %230, 32
br i1 %231, label %232, label %235
232: ; preds = %228
%233 = load i32, i32* %12
%234 = icmp eq i32 %233, 0
br label %235
235: ; preds = %232, %228
%236 = phi i1 [ false, %228 ], [ %234, %232 ]
br i1 %236, label %237, label %375
237: ; preds = %235
%238 = load i8, i8* %7
%239 = sext i8 %238 to i32
%240 = icmp eq i32 %239, 43
br i1 %240, label %241, label %258
241: ; preds = %237
%242 = load i32, i32* %13
%243 = sub nsw i32 %242, 1
%244 = sext i32 %243 to i64
%245 = getelementptr inbounds [100 x i32], [100 x i32]* %14, i64 0, i64 %244
%246 = load i32, i32* %245
%247 = load i32, i32* %13
%248 = sext i32 %247 to i64
%249 = getelementptr inbounds [100 x i32], [100 x i32]* %14, i64 0, i64 %248
%250 = load i32, i32* %249
%251 = add nsw i32 %246, %250
%252 = load i32, i32* %13
%253 = sub nsw i32 %252, 1
%254 = sext i32 %253 to i64
%255 = getelementptr inbounds [100 x i32], [100 x i32]* %14, i64 0, i64 %254
store i32 %251, i32* %255
%256 = load i32, i32* %13
%257 = sub nsw i32 %256, 1
store i32 %257, i32* %13
br label %368
258: ; preds = %237
%259 = load i8, i8* %7
%260 = sext i8 %259 to i32
%261 = icmp eq i32 %260, 45
br i1 %261, label %262, label %279
262: ; preds = %258
%263 = load i32, i32* %13
%264 = sub nsw i32 %263, 1
%265 = sext i32 %264 to i64
%266 = getelementptr inbounds [100 x i32], [100 x i32]* %14, i64 0, i64 %265
%267 = load i32, i32* %266
%268 = load i32, i32* %13
%269 = sext i32 %268 to i64
%270 = getelementptr inbounds [100 x i32], [100 x i32]* %14, i64 0, i64 %269
%271 = load i32, i32* %270
%272 = sub nsw i32 %267, %271
%273 = load i32, i32* %13
%274 = sub nsw i32 %273, 1
%275 = sext i32 %274 to i64
%276 = getelementptr inbounds [100 x i32], [100 x i32]* %14, i64 0, i64 %275
store i32 %272, i32* %276
%277 = load i32, i32* %13
%278 = sub nsw i32 %277, 1
store i32 %278, i32* %13
br label %367
279: ; preds = %258
%280 = load i8, i8* %7
%281 = sext i8 %280 to i32
%282 = icmp eq i32 %281, 42
br i1 %282, label %283, label %300
283: ; preds = %279
%284 = load i32, i32* %13
%285 = sub nsw i32 %284, 1
%286 = sext i32 %285 to i64
%287 = getelementptr inbounds [100 x i32], [100 x i32]* %14, i64 0, i64 %286
%288 = load i32, i32* %287
%289 = load i32, i32* %13
%290 = sext i32 %289 to i64
%291 = getelementptr inbounds [100 x i32], [100 x i32]* %14, i64 0, i64 %290
%292 = load i32, i32* %291
%293 = mul nsw i32 %288, %292
%294 = load i32, i32* %13
%295 = sub nsw i32 %294, 1
%296 = sext i32 %295 to i64
%297 = getelementptr inbounds [100 x i32], [100 x i32]* %14, i64 0, i64 %296
store i32 %293, i32* %297
%298 = load i32, i32* %13
%299 = sub nsw i32 %298, 1
store i32 %299, i32* %13
br label %366
300: ; preds = %279
%301 = load i8, i8* %7
%302 = sext i8 %301 to i32
%303 = icmp eq i32 %302, 47
br i1 %303, label %304, label %329
304: ; preds = %300
%305 = load i32, i32* %13
%306 = sext i32 %305 to i64
%307 = getelementptr inbounds [100 x i32], [100 x i32]* %14, i64 0, i64 %306
%308 = load i32, i32* %307
%309 = icmp ne i32 %308, 0
br i1 %309, label %310, label %325
310: ; preds = %304
%311 = load i32, i32* %13
%312 = sub nsw i32 %311, 1
%313 = sext i32 %312 to i64
%314 = getelementptr inbounds [100 x i32], [100 x i32]* %14, i64 0, i64 %313
%315 = load i32, i32* %314
%316 = load i32, i32* %13
%317 = sext i32 %316 to i64
%318 = getelementptr inbounds [100 x i32], [100 x i32]* %14, i64 0, i64 %317
%319 = load i32, i32* %318
%320 = sdiv i32 %315, %319
%321 = load i32, i32* %13
%322 = sub nsw i32 %321, 1
%323 = sext i32 %322 to i64
%324 = getelementptr inbounds [100 x i32], [100 x i32]* %14, i64 0, i64 %323
store i32 %320, i32* %324
br label %326
325: ; preds = %304
store i32 1, i32* %12
br label %326
326: ; preds = %325, %310
%327 = load i32, i32* %13
%328 = sub nsw i32 %327, 1
store i32 %328, i32* %13
br label %365
329: ; preds = %300
store i32 0, i32* %9
br label %330
330: ; preds = %340, %329
%331 = load i8, i8* %7
%332 = call i64 @isdigit(i8 signext %331)
%333 = icmp ne i64 %332, 0
br i1 %333, label %338, label %334
334: ; preds = %330
%335 = load i8, i8* %7
%336 = sext i8 %335 to i32
%337 = icmp eq i32 %336, 46
br label %338
338: ; preds = %334, %330
%339 = phi i1 [ true, %330 ], [ %337, %334 ]
br i1 %339, label %340, label %353
340: ; preds = %338
%341 = load i8, i8* %7
%342 = load i32, i32* %9
%343 = sext i32 %342 to i64
%344 = getelementptr inbounds [100 x i8], [100 x i8]* %15, i64 0, i64 %343
store i8 %341, i8* %344
%345 = load i32, i32* %9
%346 = add nsw i32 %345, 1
store i32 %346, i32* %9
%347 = load i32, i32* %10
%348 = sext i32 %347 to i64
%349 = getelementptr inbounds [1000 x i8], [1000 x i8]* %5, i64 0, i64 %348
%350 = load i8, i8* %349
store i8 %350, i8* %7
%351 = load i32, i32* %10
%352 = add nsw i32 %351, 1
store i32 %352, i32* %10
br label %330
353: ; preds = %338
store i8 0, i8* %16
%354 = load i8, i8* %16
%355 = load i32, i32* %9
%356 = sext i32 %355 to i64
%357 = getelementptr inbounds [100 x i8], [100 x i8]* %15, i64 0, i64 %356
store i8 %354, i8* %357
%358 = load i32, i32* %13
%359 = add nsw i32 %358, 1
store i32 %359, i32* %13
%360 = getelementptr inbounds [100 x i8], [100 x i8]* %15, i64 0, i64 0
%361 = call i32 @atoi(i8* %360)
%362 = load i32, i32* %13
%363 = sext i32 %362 to i64
%364 = getelementptr inbounds [100 x i32], [100 x i32]* %14, i64 0, i64 %363
store i32 %361, i32* %364
br label %365
365: ; preds = %353, %326
br label %366
366: ; preds = %365, %283
br label %367
367: ; preds = %366, %262
br label %368
368: ; preds = %367, %241
%369 = load i32, i32* %10
%370 = sext i32 %369 to i64
%371 = getelementptr inbounds [1000 x i8], [1000 x i8]* %5, i64 0, i64 %370
%372 = load i8, i8* %371
store i8 %372, i8* %7
%373 = load i32, i32* %10
%374 = add nsw i32 %373, 1
store i32 %374, i32* %10
br label %228
375: ; preds = %235
%376 = load i32, i32* %12
%377 = icmp eq i32 %376, 0
br i1 %377, label %378, label %386
378: ; preds = %375
%379 = getelementptr inbounds [23 x i8], [23 x i8]* %2, i64 0, i64 0
%380 = getelementptr inbounds [29 x i8], [29 x i8]* %4, i64 0, i64 0
%381 = load i32, i32* %13
%382 = sext i32 %381 to i64
%383 = getelementptr inbounds [100 x i32], [100 x i32]* %14, i64 0, i64 %382
%384 = load i32, i32* %383
%385 = call i32 (i8*, i8*, i32, i32, ...) @printf(i8* %379, i8* %380, i32 10, i32 %384, i32 10)
br label %390
386: ; preds = %375
%387 = getelementptr inbounds [26 x i8], [26 x i8]* %3, i64 0, i64 0
%388 = getelementptr inbounds [29 x i8], [29 x i8]* %4, i64 0, i64 0
%389 = call i32 (i8*, i8*, i32, i32, ...) @printf(i8* %387, i8* %388, i32 10, i32 10)
br label %390
390: ; preds = %386, %378
ret i32 0
}

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