#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 */
char ispref(char);
int /*<<< orphan*/ printf(char *, ...);
int /*<<< orphan*/ scanf(char *, ...);
int main() {
  char inf[100], stack[100], out[100];
  int stop = -1;
  int otop = -1;
  int n, i;
  printf("\n Enter the number of elements :");
  scanf("%d", &n);
  printf("\n Enter the infix expression :");
  i = 0;
  while (i < n) {
    scanf("%s", &inf[i]);
    i++;
  }
  printf("\n the infix expression is:");
  for (i = 0; i <= n; i++) {
    printf("%c", inf[i]);
  }
  printf("\n\n\n");
  char scan;
  for (i = 0; i < n; i++) {
    scan = inf[i];
    if (scan == '(') {
      stop++;
      stack[stop] = scan;
    } else if (scan == ')') {
      while (stack[stop] != '(') {
        otop++;
        out[otop] = stack[stop];
        stop--;
      }
      stop--;
    } else {
      if (ispref(scan) == 0) {
        otop++;
        out[otop] = scan;
      } else if (stop != -1) {
        if ((ispref(scan) > ispref(stack[stop]))) {
          stop++;
          stack[stop] = scan;
        } else if (ispref(scan) <= ispref(stack[stop])) {
          while (ispref(stack[stop]) >= ispref(ispref(scan))) {
            otop++;
            out[otop] = stack[stop];
            stop--;
            if (stop == -1) {
              break;
            }
          }
          stop++;
          stack[stop] = scan;
        }
      } else {
        stop++;
        stack[stop] = scan;
      }
    }
  }
  printf("\n\n");
  while (stop != -1) {
    otop++;
    out[otop] = stack[stop];
    stop--;
  }
  printf("%s", out);
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x170,%rsp
movl   $0x0,-0x4(%rbp)
movl   $0xffffffff,-0x154(%rbp)
ff ff ff
movl   $0xffffffff,-0x158(%rbp)
ff ff ff
lea    0xea3(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xeb6(%rip),%rdi
lea    -0x15c(%rbp),%rsi
mov    $0x0,%al
call   1050 <scanf@plt>
lea    0xea4(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x160(%rbp)
mov    -0x160(%rbp),%eax
cmp    -0x15c(%rbp),%eax
jge    11d3 <main+0xa3>
movslq -0x160(%rbp),%rax
lea    -0x70(%rbp),%rsi
add    %rax,%rsi
lea    0xe8b(%rip),%rdi
mov    $0x0,%al
call   1050 <scanf@plt>
mov    -0x160(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x160(%rbp)
jmp    1191 <main+0x61>
lea    0xe6c(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x160(%rbp)
mov    -0x160(%rbp),%eax
cmp    -0x15c(%rbp),%eax
jg     122b <main+0xfb>
movslq -0x160(%rbp),%rax
movsbl -0x70(%rbp,%rax,1),%esi
lea    0xe51(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x160(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x160(%rbp)
jmp    11eb <main+0xbb>
lea    0xe32(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x160(%rbp)
mov    -0x160(%rbp),%eax
cmp    -0x15c(%rbp),%eax
jge    151d <main+0x3ed>
movslq -0x160(%rbp),%rax
mov    -0x70(%rbp,%rax,1),%al
mov    %al,-0x161(%rbp)
movsbl -0x161(%rbp),%eax
cmp    $0x28,%eax
jne    129e <main+0x16e>
mov    -0x154(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x154(%rbp)
mov    -0x161(%rbp),%cl
movslq -0x154(%rbp),%rax
mov    %cl,-0xe0(%rbp,%rax,1)
jmp    1504 <main+0x3d4>
movsbl -0x161(%rbp),%eax
cmp    $0x29,%eax
jne    131e <main+0x1ee>
jmp    12b3 <main+0x183>
movslq -0x154(%rbp),%rax
movsbl -0xe0(%rbp,%rax,1),%eax
ff
cmp    $0x28,%eax
je     130a <main+0x1da>
mov    -0x158(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x158(%rbp)
movslq -0x154(%rbp),%rax
mov    -0xe0(%rbp,%rax,1),%cl
movslq -0x158(%rbp),%rax
mov    %cl,-0x150(%rbp,%rax,1)
mov    -0x154(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x154(%rbp)
jmp    12b3 <main+0x183>
mov    -0x154(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x154(%rbp)
jmp    14ff <main+0x3cf>
movsbl -0x161(%rbp),%edi
call   1040 <ispref@plt>
movsbl %al,%eax
cmp    $0x0,%eax
jne    135e <main+0x22e>
mov    -0x158(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x158(%rbp)
mov    -0x161(%rbp),%cl
movslq -0x158(%rbp),%rax
mov    %cl,-0x150(%rbp,%rax,1)
jmp    14fa <main+0x3ca>
cmpl   $0xffffffff,-0x154(%rbp)
je     14d2 <main+0x3a2>
movsbl -0x161(%rbp),%edi
call   1040 <ispref@plt>
movsbl %al,%eax
mov    %eax,-0x168(%rbp)
movslq -0x154(%rbp),%rax
movsbl -0xe0(%rbp,%rax,1),%edi
ff
call   1040 <ispref@plt>
mov    %al,%cl
mov    -0x168(%rbp),%eax
movsbl %cl,%ecx
cmp    %ecx,%eax
jle    13cf <main+0x29f>
mov    -0x154(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x154(%rbp)
mov    -0x161(%rbp),%cl
movslq -0x154(%rbp),%rax
mov    %cl,-0xe0(%rbp,%rax,1)
jmp    14cd <main+0x39d>
movsbl -0x161(%rbp),%edi
call   1040 <ispref@plt>
movsbl %al,%eax
mov    %eax,-0x16c(%rbp)
movslq -0x154(%rbp),%rax
movsbl -0xe0(%rbp,%rax,1),%edi
ff
call   1040 <ispref@plt>
mov    %al,%cl
mov    -0x16c(%rbp),%eax
movsbl %cl,%ecx
cmp    %ecx,%eax
jg     14c8 <main+0x398>
jmp    1410 <main+0x2e0>
movslq -0x154(%rbp),%rax
movsbl -0xe0(%rbp,%rax,1),%edi
ff
call   1040 <ispref@plt>
movsbl %al,%eax
mov    %eax,-0x170(%rbp)
movsbl -0x161(%rbp),%edi
call   1040 <ispref@plt>
movsbl %al,%edi
call   1040 <ispref@plt>
mov    %al,%cl
mov    -0x170(%rbp),%eax
movsbl %cl,%ecx
cmp    %ecx,%eax
jl     14a5 <main+0x375>
mov    -0x158(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x158(%rbp)
movslq -0x154(%rbp),%rax
mov    -0xe0(%rbp,%rax,1),%cl
movslq -0x158(%rbp),%rax
mov    %cl,-0x150(%rbp,%rax,1)
mov    -0x154(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x154(%rbp)
cmpl   $0xffffffff,-0x154(%rbp)
jne    14a0 <main+0x370>
jmp    14a5 <main+0x375>
jmp    1410 <main+0x2e0>
mov    -0x154(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x154(%rbp)
mov    -0x161(%rbp),%cl
movslq -0x154(%rbp),%rax
mov    %cl,-0xe0(%rbp,%rax,1)
jmp    14cd <main+0x39d>
jmp    14f5 <main+0x3c5>
mov    -0x154(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x154(%rbp)
mov    -0x161(%rbp),%cl
movslq -0x154(%rbp),%rax
mov    %cl,-0xe0(%rbp,%rax,1)
jmp    14fa <main+0x3ca>
jmp    14ff <main+0x3cf>
jmp    1504 <main+0x3d4>
jmp    1509 <main+0x3d9>
mov    -0x160(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x160(%rbp)
jmp    1243 <main+0x113>
lea    0xb41(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
cmpl   $0xffffffff,-0x154(%rbp)
je     1577 <main+0x447>
mov    -0x158(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x158(%rbp)
movslq -0x154(%rbp),%rax
mov    -0xe0(%rbp,%rax,1),%cl
movslq -0x158(%rbp),%rax
mov    %cl,-0x150(%rbp,%rax,1)
mov    -0x154(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x154(%rbp)
jmp    152b <main+0x3fb>
lea    -0x150(%rbp),%rsi
lea    0xabe(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x4(%rbp),%eax
add    $0x170,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x168,%rsp
lea    0xe98(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
lea    0xeab(%rip),%rdi
lea    0x8(%rsp),%rsi
xor    %eax,%eax
call   1070 <scanf@plt>
lea    0xe9b(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
cmpl   $0x0,0x8(%rsp)
jle    11c3 <main+0x73>
lea    0xea5(%rip),%rbx
xor    %ebp,%ebp
lea    (%rsp,%rbp,1),%rsi
add    $0x100,%rsi
mov    %rbx,%rdi
xor    %eax,%eax
call   1070 <scanf@plt>
add    $0x1,%rbp
movslq 0x8(%rsp),%rax
cmp    %rax,%rbp
jl     11a0 <main+0x50>
lea    0xe7c(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
cmpl   $0x0,0x8(%rsp)
js     11fb <main+0xab>
mov    $0xffffffffffffffff,%rbx
nop
movsbl 0x101(%rsp,%rbx,1),%edi
call   1030 <putchar@plt>
movslq 0x8(%rsp),%rax
add    $0x1,%rbx
cmp    %rax,%rbx
jl     11e0 <main+0x90>
lea    0xe5f(%rip),%rdi
call   1040 <puts@plt>
cmpl   $0x0,0x8(%rsp)
jle    1424 <main+0x2d4>
mov    $0xffffffff,%r12d
xor    %ebp,%ebp
mov    $0xffffffff,%r13d
jmp    1246 <main+0xf6>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0xffffffff,%r12d
add    $0x1,%rbp
movslq 0x8(%rsp),%rax
cmp    %rax,%rbp
jge    13f6 <main+0x2a6>
mov    0x100(%rsp,%rbp,1),%r15b
cmp    $0x28,%r15b
je     12a0 <main+0x150>
cmp    $0x29,%r15b
jne    12b0 <main+0x160>
movslq %r12d,%rax
mov    0x20(%rsp,%rax,1),%cl
cmp    $0x28,%cl
je     1230 <main+0xe0>
movslq %r13d,%rdx
lea    0x91(%rsp),%rsi
add    %rsi,%rdx
lea    0x1f(%rsp),%rsi
add    %rsi,%rax
xor    %esi,%esi
xchg   %ax,%ax
mov    %cl,(%rdx,%rsi,1)
movzbl (%rax),%ecx
add    $0x1,%rsi
add    $0xffffffffffffffff,%rax
cmp    $0x28,%cl
jne    1280 <main+0x130>
add    %esi,%r13d
sub    %esi,%r12d
jmp    1230 <main+0xe0>
nopl   0x0(%rax,%rax,1)
movslq %r12d,%r12
movb   $0x28,0x21(%rsp,%r12,1)
add    $0x1,%r12
jmp    1234 <main+0xe4>
nop
movsbl %r15b,%ebx
mov    %ebx,%edi
call   1060 <ispref@plt>
test   %al,%al
je     1308 <main+0x1b8>
cmp    $0xffffffff,%r12d
je     131c <main+0x1cc>
mov    %r13,0x10(%rsp)
mov    %ebx,%edi
call   1060 <ispref@plt>
mov    %al,0x18(%rsp)
movslq %r12d,%r13
mov    %ebx,0xc(%rsp)
mov    0x20(%rsp,%r13,1),%r14b
movsbl %r14b,%edi
mov    %edi,%ebx
call   1060 <ispref@plt>
cmp    %al,0x18(%rsp)
jle    1329 <main+0x1d9>
movslq %r12d,%r12
mov    %r15b,0x21(%rsp,%r12,1)
add    $0x1,%r12
mov    0x10(%rsp),%r13
jmp    1234 <main+0xe4>
movslq %r13d,%r13
mov    %r15b,0x91(%rsp,%r13,1)
add    $0x1,%r13
jmp    1234 <main+0xe4>
mov    %r15b,0x20(%rsp)
xor    %r12d,%r12d
jmp    1234 <main+0xe4>
mov    %r13,0x18(%rsp)
mov    0xc(%rsp),%edi
call   1060 <ispref@plt>
mov    %eax,%r13d
mov    %ebx,%edi
call   1060 <ispref@plt>
cmp    %al,%r13b
jle    1350 <main+0x200>
mov    0x10(%rsp),%r13
jmp    1234 <main+0xe4>
movslq 0x10(%rsp),%r13
mov    %ebx,%edi
call   1060 <ispref@plt>
mov    %eax,%ebx
mov    0xc(%rsp),%edi
call   1060 <ispref@plt>
movsbl %al,%edi
call   1060 <ispref@plt>
cmp    %al,%bl
jge    137a <main+0x22a>
mov    0x18(%rsp),%rbx
jmp    13dd <main+0x28d>
mov    0x10(%rsp),%rax
add    %r12d,%eax
add    $0x1,%eax
mov    %rax,0x10(%rsp)
mov    0x18(%rsp),%rcx
mov    %rcx,%rbx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %r14b,0x91(%rsp,%r13,1)
sub    $0x1,%rbx
jb     13df <main+0x28f>
movzbl 0x1f(%rsp,%rcx,1),%r14d
movsbl %r14b,%edi
call   1060 <ispref@plt>
mov    %eax,%r12d
mov    0xc(%rsp),%edi
call   1060 <ispref@plt>
movsbl %al,%edi
call   1060 <ispref@plt>
add    $0x1,%r13
mov    %rbx,%rcx
cmp    %al,%r12b
jge    13a0 <main+0x250>
jmp    13e9 <main+0x299>
mov    $0xffffffff,%ebx
mov    0x10(%rsp),%r13
movslq %ebx,%r12
mov    %r15b,0x21(%rsp,%r12,1)
jmp    12a9 <main+0x159>
lea    0xc65(%rip),%rdi
call   1040 <puts@plt>
cmp    $0xffffffff,%r12d
je     15a1 <main+0x451>
movslq %r12d,%rax
movslq %r13d,%r9
lea    0x1(%rax),%rdx
cmp    $0x8,%rdx
jae    1435 <main+0x2e5>
mov    %r9,%r10
jmp    1572 <main+0x422>
lea    0xc37(%rip),%rdi
call   1040 <puts@plt>
jmp    15a1 <main+0x451>
cmp    $0x20,%rdx
jae    1443 <main+0x2f3>
xor    %r8d,%r8d
jmp    1500 <main+0x3b0>
mov    %rdx,%r8
and    $0xffffffffffffffe0,%r8
mov    %r8,%rdi
neg    %rdi
lea    (%rsp,%rax,1),%rbp
add    $0x11,%rbp
lea    (%rsp,%r9,1),%rbx
add    $0xa1,%rbx
xor    %esi,%esi
pxor   %xmm0,%xmm0
nopl   0x0(%rax)
movdqu -0x10(%rbp,%rsi,1),%xmm1
movdqu 0x0(%rbp,%rsi,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(%rbx)
movdqu %xmm1,(%rbx)
add    $0xffffffffffffffe0,%rsi
add    $0x20,%rbx
cmp    %rsi,%rdi
jne    1470 <main+0x320>
cmp    %r8,%rdx
je     15a1 <main+0x451>
test   $0x18,%dl
je     15cb <main+0x47b>
mov    %rdx,%rcx
and    $0xfffffffffffffff8,%rcx
lea    (%rcx,%r9,1),%r10
mov    %rcx,%rsi
neg    %rsi
mov    %r8,%rbp
neg    %rbp
lea    (%rsp,%rax,1),%rbx
add    $0x19,%rbx
sub    %rcx,%rax
lea    0x90(%rsp),%rdi
add    %r8,%rdi
add    %r9,%rdi
add    $0x1,%rdi
pxor   %xmm0,%xmm0
nopl   0x0(%rax,%rax,1)
movq   (%rbx,%rbp,1),%xmm1
punpcklbw %xmm0,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm1,%xmm1
movq   %xmm1,(%rdi)
add    $0xfffffffffffffff8,%rbp
add    $0x8,%rdi
cmp    %rbp,%rsi
jne    1540 <main+0x3f0>
cmp    %rcx,%rdx
je     15a1 <main+0x451>
lea    0x90(%rsp),%rcx
add    %r10,%rcx
add    $0x1,%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movzbl 0x20(%rsp,%rax,1),%edx
mov    %dl,(%rcx)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rax
jb     1590 <main+0x440>
lea    0xa9b(%rip),%rdi
lea    0x90(%rsp),%rsi
xor    %eax,%eax
call   1050 <printf@plt>
xor    %eax,%eax
add    $0x168,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
sub    %r8,%rax
add    %r8,%r9
jmp    141c <main+0x2cc>

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

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