#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 *, ...);
char *strrev(char *);
int main() {
  char inf[100], stack[100], out[100], rev[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++;
  }
  i = n - 1;
  int j = 0;
  for (i = n - 1; i >= 0; i--) {
    rev[j] = inf[i];
    j++;
  }
  printf("\n the reversed string is expression is:");
  for (i = 0; i <= n; i++) {
    printf("%c", rev[i]);
  }
  printf("\n\n\n");
  char scan;
  for (i = 0; i < n; i++) {
    scan = rev[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", strrev(out));
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x1f0,%rsp
movl   $0x0,-0x4(%rbp)
movl   $0xffffffff,-0x1c4(%rbp)
ff ff ff
movl   $0xffffffff,-0x1c8(%rbp)
ff ff ff
lea    0xe93(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xea6(%rip),%rdi
lea    -0x1cc(%rbp),%rsi
mov    $0x0,%al
call   1050 <scanf@plt>
lea    0xe94(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x1d0(%rbp)
mov    -0x1d0(%rbp),%eax
cmp    -0x1cc(%rbp),%eax
jge    11e3 <main+0xa3>
movslq -0x1d0(%rbp),%rax
lea    -0x70(%rbp),%rsi
add    %rax,%rsi
lea    0xe7b(%rip),%rdi
mov    $0x0,%al
call   1050 <scanf@plt>
mov    -0x1d0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1d0(%rbp)
jmp    11a1 <main+0x61>
mov    -0x1cc(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x1d0(%rbp)
movl   $0x0,-0x1d4(%rbp)
mov    -0x1cc(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x1d0(%rbp)
cmpl   $0x0,-0x1d0(%rbp)
jl     1254 <main+0x114>
movslq -0x1d0(%rbp),%rax
mov    -0x70(%rbp,%rax,1),%cl
movslq -0x1d4(%rbp),%rax
mov    %cl,-0x1c0(%rbp,%rax,1)
mov    -0x1d4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1d4(%rbp)
mov    -0x1d0(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1d0(%rbp)
jmp    120b <main+0xcb>
lea    0xdeb(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x1d0(%rbp)
mov    -0x1d0(%rbp),%eax
cmp    -0x1cc(%rbp),%eax
jg     12af <main+0x16f>
movslq -0x1d0(%rbp),%rax
movsbl -0x1c0(%rbp,%rax,1),%esi
ff
lea    0xdda(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x1d0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1d0(%rbp)
jmp    126c <main+0x12c>
lea    0xdbb(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x1d0(%rbp)
mov    -0x1d0(%rbp),%eax
cmp    -0x1cc(%rbp),%eax
jge    15a4 <main+0x464>
movslq -0x1d0(%rbp),%rax
mov    -0x1c0(%rbp,%rax,1),%al
mov    %al,-0x1d5(%rbp)
movsbl -0x1d5(%rbp),%eax
cmp    $0x29,%eax
jne    1325 <main+0x1e5>
mov    -0x1c4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c4(%rbp)
mov    -0x1d5(%rbp),%cl
movslq -0x1c4(%rbp),%rax
mov    %cl,-0xe0(%rbp,%rax,1)
jmp    158b <main+0x44b>
movsbl -0x1d5(%rbp),%eax
cmp    $0x28,%eax
jne    13a5 <main+0x265>
jmp    133a <main+0x1fa>
movslq -0x1c4(%rbp),%rax
movsbl -0xe0(%rbp,%rax,1),%eax
ff
cmp    $0x29,%eax
je     1391 <main+0x251>
mov    -0x1c8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c8(%rbp)
movslq -0x1c4(%rbp),%rax
mov    -0xe0(%rbp,%rax,1),%cl
movslq -0x1c8(%rbp),%rax
mov    %cl,-0x150(%rbp,%rax,1)
mov    -0x1c4(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1c4(%rbp)
jmp    133a <main+0x1fa>
mov    -0x1c4(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1c4(%rbp)
jmp    1586 <main+0x446>
movsbl -0x1d5(%rbp),%edi
call   1040 <ispref@plt>
movsbl %al,%eax
cmp    $0x0,%eax
jne    13e5 <main+0x2a5>
mov    -0x1c8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c8(%rbp)
mov    -0x1d5(%rbp),%cl
movslq -0x1c8(%rbp),%rax
mov    %cl,-0x150(%rbp,%rax,1)
jmp    1581 <main+0x441>
cmpl   $0xffffffff,-0x1c4(%rbp)
je     1559 <main+0x419>
movsbl -0x1d5(%rbp),%edi
call   1040 <ispref@plt>
movsbl %al,%eax
mov    %eax,-0x1dc(%rbp)
movslq -0x1c4(%rbp),%rax
movsbl -0xe0(%rbp,%rax,1),%edi
ff
call   1040 <ispref@plt>
mov    %al,%cl
mov    -0x1dc(%rbp),%eax
movsbl %cl,%ecx
cmp    %ecx,%eax
jl     1456 <main+0x316>
mov    -0x1c4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c4(%rbp)
mov    -0x1d5(%rbp),%cl
movslq -0x1c4(%rbp),%rax
mov    %cl,-0xe0(%rbp,%rax,1)
jmp    1554 <main+0x414>
movsbl -0x1d5(%rbp),%edi
call   1040 <ispref@plt>
movsbl %al,%eax
mov    %eax,-0x1e0(%rbp)
movslq -0x1c4(%rbp),%rax
movsbl -0xe0(%rbp,%rax,1),%edi
ff
call   1040 <ispref@plt>
mov    %al,%cl
mov    -0x1e0(%rbp),%eax
movsbl %cl,%ecx
cmp    %ecx,%eax
jge    154f <main+0x40f>
jmp    1497 <main+0x357>
movslq -0x1c4(%rbp),%rax
movsbl -0xe0(%rbp,%rax,1),%edi
ff
call   1040 <ispref@plt>
movsbl %al,%eax
mov    %eax,-0x1e4(%rbp)
movsbl -0x1d5(%rbp),%edi
call   1040 <ispref@plt>
movsbl %al,%edi
call   1040 <ispref@plt>
mov    %al,%cl
mov    -0x1e4(%rbp),%eax
movsbl %cl,%ecx
cmp    %ecx,%eax
jle    152c <main+0x3ec>
mov    -0x1c8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c8(%rbp)
movslq -0x1c4(%rbp),%rax
mov    -0xe0(%rbp,%rax,1),%cl
movslq -0x1c8(%rbp),%rax
mov    %cl,-0x150(%rbp,%rax,1)
mov    -0x1c4(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1c4(%rbp)
cmpl   $0xffffffff,-0x1c4(%rbp)
jne    1527 <main+0x3e7>
jmp    152c <main+0x3ec>
jmp    1497 <main+0x357>
mov    -0x1c4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c4(%rbp)
mov    -0x1d5(%rbp),%cl
movslq -0x1c4(%rbp),%rax
mov    %cl,-0xe0(%rbp,%rax,1)
jmp    1554 <main+0x414>
jmp    157c <main+0x43c>
mov    -0x1c4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c4(%rbp)
mov    -0x1d5(%rbp),%cl
movslq -0x1c4(%rbp),%rax
mov    %cl,-0xe0(%rbp,%rax,1)
jmp    1581 <main+0x441>
jmp    1586 <main+0x446>
jmp    158b <main+0x44b>
jmp    1590 <main+0x450>
mov    -0x1d0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1d0(%rbp)
jmp    12c7 <main+0x187>
lea    0xac7(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
cmpl   $0xffffffff,-0x1c4(%rbp)
je     15fe <main+0x4be>
mov    -0x1c8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c8(%rbp)
movslq -0x1c4(%rbp),%rax
mov    -0xe0(%rbp,%rax,1),%cl
movslq -0x1c8(%rbp),%rax
mov    %cl,-0x150(%rbp,%rax,1)
mov    -0x1c4(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1c4(%rbp)
jmp    15b2 <main+0x472>
lea    -0x150(%rbp),%rdi
call   1060 <strrev@plt>
mov    %rax,%rsi
lea    0xa2f(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x4(%rbp),%eax
add    $0x1f0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x1d8,%rsp
lea    0xe88(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
lea    0xe9b(%rip),%rdi
lea    0x8(%rsp),%rsi
xor    %eax,%eax
call   1070 <scanf@plt>
lea    0xe8b(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
cmpl   $0x0,0x8(%rsp)
jle    1297 <main+0x137>
lea    0xe91(%rip),%rbx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
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     11c0 <main+0x60>
mov    %eax,%eax
test   %eax,%eax
jle    1297 <main+0x137>
cmp    $0x8,%eax
jae    1513 <main+0x3b3>
xor    %ecx,%ecx
mov    %rax,%rdx
mov    %rcx,%rsi
not    %rsi
add    %rax,%rsi
mov    %rax,%rdi
and    $0x3,%rdi
je     122f <main+0xcf>
nopl   (%rax)
add    $0xffffffffffffffff,%rdx
mov    %edx,%ebp
movzbl 0x100(%rsp,%rbp,1),%ebx
mov    %bl,0x90(%rsp,%rcx,1)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rdi
jne    1210 <main+0xb0>
cmp    $0x3,%rsi
jb     1297 <main+0x137>
mov    $0xfffffffe,%esi
nopw   0x0(%rax,%rax,1)
lea    (%rdx,%rsi,1),%rdi
lea    0x1(%rdi),%ebp
movzbl 0x100(%rsp,%rbp,1),%ebx
mov    %bl,0x90(%rsp,%rcx,1)
mov    %edi,%ebp
movzbl 0x100(%rsp,%rbp,1),%ebx
mov    %bl,0x91(%rsp,%rcx,1)
add    $0xffffffff,%edi
movzbl 0x100(%rsp,%rdi,1),%ebx
mov    %bl,0x92(%rsp,%rcx,1)
add    $0xfffffffffffffffc,%rdx
mov    %edx,%edi
movzbl 0x100(%rsp,%rdi,1),%ebx
mov    %bl,0x93(%rsp,%rcx,1)
add    $0x4,%rcx
cmp    %rcx,%rax
jne    1240 <main+0xe0>
lea    0xda8(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
cmpl   $0x0,0x8(%rsp)
js     12db <main+0x17b>
mov    $0xffffffffffffffff,%rbx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsbl 0x91(%rsp,%rbx,1),%edi
call   1030 <putchar@plt>
movslq 0x8(%rsp),%rax
add    $0x1,%rbx
cmp    %rax,%rbx
jl     12c0 <main+0x160>
lea    0xd8c(%rip),%rdi
call   1040 <puts@plt>
cmpl   $0x0,0x8(%rsp)
jle    1502 <main+0x3a2>
mov    $0xffffffff,%r12d
xor    %ebp,%ebp
mov    $0xffffffff,%r13d
jmp    1326 <main+0x1c6>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0xffffffff,%r12d
add    $0x1,%rbp
movslq 0x8(%rsp),%rax
cmp    %rax,%rbp
jge    14d4 <main+0x374>
mov    0x90(%rsp,%rbp,1),%r15b
cmp    $0x29,%r15b
je     1380 <main+0x220>
cmp    $0x28,%r15b
jne    1390 <main+0x230>
movslq %r12d,%rax
mov    0x20(%rsp,%rax,1),%cl
cmp    $0x29,%cl
je     1310 <main+0x1b0>
movslq %r13d,%rdx
lea    0x171(%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    $0x29,%cl
jne    1360 <main+0x200>
add    %esi,%r13d
sub    %esi,%r12d
jmp    1310 <main+0x1b0>
nopl   0x0(%rax,%rax,1)
movslq %r12d,%r12
movb   $0x29,0x21(%rsp,%r12,1)
add    $0x1,%r12
jmp    1314 <main+0x1b4>
nop
movsbl %r15b,%ebx
mov    %ebx,%edi
call   1060 <ispref@plt>
test   %al,%al
je     147f <main+0x31f>
cmp    $0xffffffff,%r12d
je     1493 <main+0x333>
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)
jge    14a0 <main+0x340>
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
jge    14ac <main+0x34c>
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
jle    14b6 <main+0x356>
mov    0x10(%rsp),%rax
add    %r12d,%eax
add    $0x1,%eax
mov    %rax,0x10(%rsp)
mov    0x18(%rsp),%rcx
mov    %rcx,%rbx
xchg   %ax,%ax
mov    %r14b,0x171(%rsp,%r13,1)
sub    $0x1,%rbx
jb     14bd <main+0x35d>
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
jg     1440 <main+0x2e0>
jmp    14bb <main+0x35b>
movslq %r13d,%r13
mov    %r15b,0x171(%rsp,%r13,1)
add    $0x1,%r13
jmp    1314 <main+0x1b4>
mov    %r15b,0x20(%rsp)
xor    %r12d,%r12d
jmp    1314 <main+0x1b4>
movslq %r12d,%r12
mov    %r15b,0x21(%rsp,%r12,1)
add    $0x1,%r12
mov    0x10(%rsp),%r13
jmp    1314 <main+0x1b4>
mov    0x18(%rsp),%rbx
jmp    14c7 <main+0x367>
mov    $0xffffffff,%ebx
mov    0x10(%rsp),%r13
movslq %ebx,%r12
mov    %r15b,0x21(%rsp,%r12,1)
jmp    1389 <main+0x229>
lea    0xb94(%rip),%rdi
call   1040 <puts@plt>
cmp    $0xffffffff,%r12d
je     16b1 <main+0x551>
movslq %r12d,%rax
movslq %r13d,%r9
lea    0x1(%rax),%rdx
cmp    $0x8,%rdx
jae    1544 <main+0x3e4>
mov    %r9,%r10
jmp    1682 <main+0x522>
lea    0xb66(%rip),%rdi
call   1040 <puts@plt>
jmp    16b1 <main+0x551>
lea    -0x1(%rax),%rsi
lea    -0x1(%rax),%edx
xor    %ecx,%ecx
cmp    %esi,%edx
jb     11f8 <main+0x98>
mov    %rsi,%rdx
shr    $0x20,%rdx
mov    %rax,%rdx
jne    11fb <main+0x9b>
cmp    $0x20,%eax
jae    16e3 <main+0x583>
xor    %ecx,%ecx
jmp    1790 <main+0x630>
cmp    $0x20,%rdx
jae    1552 <main+0x3f2>
xor    %r8d,%r8d
jmp    1610 <main+0x4b0>
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    $0x181,%rbx
xor    %esi,%esi
pxor   %xmm0,%xmm0
nopl   0x0(%rax,%rax,1)
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    1580 <main+0x420>
cmp    %r8,%rdx
je     16b1 <main+0x551>
test   $0x18,%dl
je     17f6 <main+0x696>
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    0x170(%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    1650 <main+0x4f0>
cmp    %rcx,%rdx
je     16b1 <main+0x551>
lea    0x170(%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     16a0 <main+0x540>
lea    0x170(%rsp),%rdi
call   1080 <strrev@plt>
lea    0x97e(%rip),%rdi
mov    %rax,%rsi
xor    %eax,%eax
call   1050 <printf@plt>
xor    %eax,%eax
add    $0x1d8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %eax,%ecx
and    $0xffffffe0,%ecx
xor    %edx,%edx
pxor   %xmm0,%xmm0
xchg   %ax,%ax
mov    %esi,%edi
movdqu 0xe1(%rsp,%rdi,1),%xmm1
movdqu 0xf1(%rsp,%rdi,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
movdqa %xmm2,0x90(%rsp,%rdx,1)
movdqa %xmm1,0xa0(%rsp,%rdx,1)
add    $0x20,%rdx
add    $0xffffffffffffffe0,%rsi
cmp    %rdx,%rcx
jne    16f0 <main+0x590>
cmp    %rax,%rcx
je     1297 <main+0x137>
test   $0x18,%al
je     1801 <main+0x6a1>
mov    %rcx,%rsi
mov    %eax,%ecx
and    $0xfffffff8,%ecx
mov    %eax,%edx
and    $0x7,%edx
mov    %rsi,%rdi
not    %rdi
add    %rax,%rdi
pxor   %xmm0,%xmm0
nopw   0x0(%rax,%rax,1)
mov    %edi,%ebp
movq   0xf9(%rsp,%rbp,1),%xmm1
punpcklbw %xmm0,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm1,%xmm1
movq   %xmm1,0x90(%rsp,%rsi,1)
add    $0x8,%rsi
add    $0xfffffffffffffff8,%rdi
cmp    %rsi,%rcx
jne    17b0 <main+0x650>
cmp    %rax,%rcx
jne    11fb <main+0x9b>
jmp    1297 <main+0x137>
sub    %r8,%rax
add    %r8,%r9
jmp    14fa <main+0x39a>
mov    %eax,%edx
and    $0x1f,%edx
jmp    11fb <main+0x9b>

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

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 = [40 x i8] c"\0A the reversed string is 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 [100 x i8]
%5 = alloca i32
%6 = getelementptr inbounds [100 x i8], [100 x i8]* %1, i64 0, i64 0
%7 = getelementptr inbounds [100 x i8], [100 x i8]* %2, i64 0, i64 0
%8 = getelementptr inbounds [100 x i8], [100 x i8]* %3, i64 0, i64 0
%9 = getelementptr inbounds [100 x i8], [100 x i8]* %4, i64 0, i64 0
%10 = bitcast i32* %5 to i8*
%11 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([33 x i8], [33 x i8]* @.str, i64 0, i64 0))
%12 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32* %5)
%13 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([31 x i8], [31 x i8]* @.str.2, i64 0, i64 0))
%14 = load i32, i32* %5
%15 = icmp sgt i32 %14, 0
br i1 %15, label %101, label %137
16: ; preds = %101
%17 = icmp sgt i32 %106, 0
br i1 %17, label %18, label %137
18: ; preds = %16
%19 = zext i32 %106 to i64
%20 = icmp ult i32 %106, 8
br i1 %20, label %78, label %21
21: ; preds = %18
%22 = add nsw i64 %19, -1
%23 = add i32 %106, -1
%24 = trunc i64 %22 to i32
%25 = icmp ult i32 %23, %24
%26 = icmp ugt i64 %22, 4294967295
%27 = or i1 %25, %26
br i1 %27, label %78, label %28
28: ; preds = %21
%29 = icmp ult i32 %106, 32
br i1 %29, label %58, label %30
30: ; preds = %28
%31 = and i64 %19, 4294967264
br label %32
32: ; preds = %32, %30
%33 = phi i64 [ 0, %30 ], [ %50, %32 ]
%34 = xor i64 %33, -1
%35 = add i64 %34, %19
%36 = and i64 %35, 4294967295
%37 = getelementptr inbounds [100 x i8], [100 x i8]* %1, i64 0, i64 %36
%38 = getelementptr inbounds i8, i8* %37, i64 -15
%39 = bitcast i8* %38 to <16 x i8>*
%40 = load <16 x i8>, <16 x i8>* %39
%41 = shufflevector <16 x i8> %40, <16 x i8> poison, <16 x i32> <i32 15, i32 14, i32 13, i32 12, i32 11, i32 10, i32 9, i32 8, i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0>
%42 = getelementptr inbounds i8, i8* %37, i64 -31
%43 = bitcast i8* %42 to <16 x i8>*
%44 = load <16 x i8>, <16 x i8>* %43
%45 = shufflevector <16 x i8> %44, <16 x i8> poison, <16 x i32> <i32 15, i32 14, i32 13, i32 12, i32 11, i32 10, i32 9, i32 8, i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0>
%46 = getelementptr inbounds [100 x i8], [100 x i8]* %4, i64 0, i64 %33
%47 = bitcast i8* %46 to <16 x i8>*
store <16 x i8> %41, <16 x i8>* %47
%48 = getelementptr inbounds i8, i8* %46, i64 16
%49 = bitcast i8* %48 to <16 x i8>*
store <16 x i8> %45, <16 x i8>* %49
%50 = add nuw i64 %33, 32
%51 = icmp eq i64 %50, %31
br i1 %51, label %52, label %32
52: ; preds = %32
%53 = icmp eq i64 %31, %19
br i1 %53, label %137, label %54
54: ; preds = %52
%55 = and i64 %19, 31
%56 = and i64 %19, 24
%57 = icmp eq i64 %56, 0
br i1 %57, label %78, label %58
58: ; preds = %28, %54
%59 = phi i64 [ %31, %54 ], [ 0, %28 ]
%60 = and i64 %19, 4294967288
%61 = and i64 %19, 7
br label %62
62: ; preds = %62, %58
%63 = phi i64 [ %59, %58 ], [ %74, %62 ]
%64 = xor i64 %63, -1
%65 = add i64 %64, %19
%66 = and i64 %65, 4294967295
%67 = getelementptr inbounds [100 x i8], [100 x i8]* %1, i64 0, i64 %66
%68 = getelementptr inbounds i8, i8* %67, i64 -7
%69 = bitcast i8* %68 to <8 x i8>*
%70 = load <8 x i8>, <8 x i8>* %69
%71 = shufflevector <8 x i8> %70, <8 x i8> poison, <8 x i32> <i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0>
%72 = getelementptr inbounds [100 x i8], [100 x i8]* %4, i64 0, i64 %63
%73 = bitcast i8* %72 to <8 x i8>*
store <8 x i8> %71, <8 x i8>* %73
%74 = add nuw i64 %63, 8
%75 = icmp eq i64 %74, %60
br i1 %75, label %76, label %62
76: ; preds = %62
%77 = icmp eq i64 %60, %19
br i1 %77, label %137, label %78
78: ; preds = %21, %18, %54, %76
%79 = phi i64 [ 0, %18 ], [ 0, %21 ], [ %31, %54 ], [ %60, %76 ]
%80 = phi i64 [ %19, %18 ], [ %19, %21 ], [ %55, %54 ], [ %61, %76 ]
%81 = xor i64 %79, -1
%82 = add nsw i64 %81, %19
%83 = and i64 %19, 3
%84 = icmp eq i64 %83, 0
br i1 %84, label %97, label %85
85: ; preds = %78, %85
%86 = phi i64 [ %94, %85 ], [ %79, %78 ]
%87 = phi i64 [ %89, %85 ], [ %80, %78 ]
%88 = phi i64 [ %95, %85 ], [ 0, %78 ]
%89 = add nsw i64 %87, -1
%90 = and i64 %89, 4294967295
%91 = getelementptr inbounds [100 x i8], [100 x i8]* %1, i64 0, i64 %90
%92 = load i8, i8* %91
%93 = getelementptr inbounds [100 x i8], [100 x i8]* %4, i64 0, i64 %86
store i8 %92, i8* %93
%94 = add nuw nsw i64 %86, 1
%95 = add i64 %88, 1
%96 = icmp eq i64 %95, %83
br i1 %96, label %97, label %85
97: ; preds = %85, %78
%98 = phi i64 [ %79, %78 ], [ %94, %85 ]
%99 = phi i64 [ %80, %78 ], [ %89, %85 ]
%100 = icmp ult i64 %82, 3
br i1 %100, label %137, label %109
101: ; preds = %0, %101
%102 = phi i64 [ %105, %101 ], [ 0, %0 ]
%103 = getelementptr inbounds [100 x i8], [100 x i8]* %1, i64 0, i64 %102
%104 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), i8* %103)
%105 = add nuw nsw i64 %102, 1
%106 = load i32, i32* %5
%107 = sext i32 %106 to i64
%108 = icmp slt i64 %105, %107
br i1 %108, label %101, label %16
109: ; preds = %97, %109
%110 = phi i64 [ %135, %109 ], [ %98, %97 ]
%111 = phi i64 [ %130, %109 ], [ %99, %97 ]
%112 = add i64 %111, 4294967295
%113 = and i64 %112, 4294967295
%114 = getelementptr inbounds [100 x i8], [100 x i8]* %1, i64 0, i64 %113
%115 = load i8, i8* %114
%116 = getelementptr inbounds [100 x i8], [100 x i8]* %4, i64 0, i64 %110
store i8 %115, i8* %116
%117 = add nuw nsw i64 %110, 1
%118 = add i64 %111, 4294967294
%119 = and i64 %118, 4294967295
%120 = getelementptr inbounds [100 x i8], [100 x i8]* %1, i64 0, i64 %119
%121 = load i8, i8* %120
%122 = getelementptr inbounds [100 x i8], [100 x i8]* %4, i64 0, i64 %117
store i8 %121, i8* %122
%123 = add nuw nsw i64 %110, 2
%124 = add i64 %111, 4294967293
%125 = and i64 %124, 4294967295
%126 = getelementptr inbounds [100 x i8], [100 x i8]* %1, i64 0, i64 %125
%127 = load i8, i8* %126
%128 = getelementptr inbounds [100 x i8], [100 x i8]* %4, i64 0, i64 %123
store i8 %127, i8* %128
%129 = add nuw nsw i64 %110, 3
%130 = add nsw i64 %111, -4
%131 = and i64 %130, 4294967295
%132 = getelementptr inbounds [100 x i8], [100 x i8]* %1, i64 0, i64 %131
%133 = load i8, i8* %132
%134 = getelementptr inbounds [100 x i8], [100 x i8]* %4, i64 0, i64 %129
store i8 %133, i8* %134
%135 = add nuw nsw i64 %110, 4
%136 = icmp eq i64 %135, %19
br i1 %136, label %137, label %109
137: ; preds = %97, %109, %52, %76, %0, %16
%138 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([40 x i8], [40 x i8]* @.str.4, i64 0, i64 0))
%139 = load i32, i32* %5
%140 = icmp slt i32 %139, 0
br i1 %140, label %151, label %141
141: ; preds = %137, %141
%142 = phi i64 [ %147, %141 ], [ 0, %137 ]
%143 = getelementptr inbounds [100 x i8], [100 x i8]* %4, i64 0, i64 %142
%144 = load i8, i8* %143
%145 = sext i8 %144 to i32
%146 = call i32 @putchar(i32 %145)
%147 = add nuw nsw i64 %142, 1
%148 = load i32, i32* %5
%149 = sext i32 %148 to i64
%150 = icmp slt i64 %142, %149
br i1 %150, label %141, label %151
151: ; preds = %141, %137
%152 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([3 x i8], [3 x i8]* @str, i64 0, i64 0))
%153 = load i32, i32* %5
%154 = icmp sgt i32 %153, 0
br i1 %154, label %157, label %155
155: ; preds = %151
%156 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([2 x i8], [2 x i8]* @str.8, i64 0, i64 0))
br label %330
157: ; preds = %151, %250
%158 = phi i64 [ %253, %250 ], [ 0, %151 ]
%159 = phi i32 [ %252, %250 ], [ -1, %151 ]
%160 = phi i32 [ %251, %250 ], [ -1, %151 ]
%161 = getelementptr inbounds [100 x i8], [100 x i8]* %4, i64 0, i64 %158
%162 = load i8, i8* %161
switch i8 %162, label %191 [
i8 41, label %170
i8 40, label %163
]
163: ; preds = %157
%164 = sext i32 %159 to i64
%165 = getelementptr inbounds [100 x i8], [100 x i8]* %2, i64 0, i64 %164
%166 = load i8, i8* %165
%167 = icmp eq i8 %166, 41
br i1 %167, label %187, label %168
168: ; preds = %163
%169 = sext i32 %160 to i64
br label %174
170: ; preds = %157
%171 = add nsw i32 %159, 1
%172 = sext i32 %171 to i64
%173 = getelementptr inbounds [100 x i8], [100 x i8]* %2, i64 0, i64 %172
store i8 41, i8* %173
br label %250
174: ; preds = %168, %174
%175 = phi i64 [ %169, %168 ], [ %178, %174 ]
%176 = phi i64 [ %164, %168 ], [ %180, %174 ]
%177 = phi i8 [ %166, %168 ], [ %182, %174 ]
%178 = add i64 %175, 1
%179 = getelementptr inbounds [100 x i8], [100 x i8]* %3, i64 0, i64 %178
store i8 %177, i8* %179
%180 = add i64 %176, -1
%181 = getelementptr inbounds [100 x i8], [100 x i8]* %2, i64 0, i64 %180
%182 = load i8, i8* %181
%183 = icmp eq i8 %182, 41
br i1 %183, label %184, label %174
184: ; preds = %174
%185 = trunc i64 %178 to i32
%186 = trunc i64 %180 to i32
br label %187
187: ; preds = %184, %163
%188 = phi i32 [ %160, %163 ], [ %185, %184 ]
%189 = phi i32 [ %159, %163 ], [ %186, %184 ]
%190 = add nsw i32 %189, -1
br label %250
191: ; preds = %157
%192 = call signext i8 @ispref(i8 signext %162)
%193 = icmp eq i8 %192, 0
br i1 %193, label %194, label %198
194: ; preds = %191
%195 = add nsw i32 %160, 1
%196 = sext i32 %195 to i64
%197 = getelementptr inbounds [100 x i8], [100 x i8]* %3, i64 0, i64 %196
store i8 %162, i8* %197
br label %250
198: ; preds = %191
%199 = icmp eq i32 %159, -1
br i1 %199, label %249, label %200
200: ; preds = %198
%201 = call signext i8 @ispref(i8 signext %162)
%202 = sext i32 %159 to i64
%203 = getelementptr inbounds [100 x i8], [100 x i8]* %2, i64 0, i64 %202
%204 = load i8, i8* %203
%205 = call signext i8 @ispref(i8 signext %204)
%206 = icmp slt i8 %201, %205
br i1 %206, label %211, label %207
207: ; preds = %200
%208 = add nuw nsw i32 %159, 1
%209 = sext i32 %208 to i64
%210 = getelementptr inbounds [100 x i8], [100 x i8]* %2, i64 0, i64 %209
store i8 %162, i8* %210
br label %250
211: ; preds = %200
%212 = call signext i8 @ispref(i8 signext %162)
%213 = call signext i8 @ispref(i8 signext %204)
%214 = icmp slt i8 %212, %213
br i1 %214, label %215, label %250
215: ; preds = %211
%216 = sext i32 %160 to i64
%217 = add i32 %160, 1
%218 = add i32 %217, %159
%219 = call signext i8 @ispref(i8 signext %204)
%220 = call signext i8 @ispref(i8 signext %162)
%221 = call signext i8 @ispref(i8 signext %220)
%222 = icmp sgt i8 %219, %221
br i1 %222, label %223, label %238
223: ; preds = %215, %231
%224 = phi i64 [ %227, %231 ], [ %216, %215 ]
%225 = phi i64 [ %229, %231 ], [ %202, %215 ]
%226 = phi i8 [ %233, %231 ], [ %204, %215 ]
%227 = add nsw i64 %224, 1
%228 = getelementptr inbounds [100 x i8], [100 x i8]* %3, i64 0, i64 %227
store i8 %226, i8* %228
%229 = add nsw i64 %225, -1
%230 = icmp eq i64 %225, 0
br i1 %230, label %243, label %231
231: ; preds = %223
%232 = getelementptr inbounds [100 x i8], [100 x i8]* %2, i64 0, i64 %229
%233 = load i8, i8* %232
%234 = call signext i8 @ispref(i8 signext %233)
%235 = call signext i8 @ispref(i8 signext %162)
%236 = call signext i8 @ispref(i8 signext %235)
%237 = icmp sgt i8 %234, %236
br i1 %237, label %223, label %238
238: ; preds = %231, %215
%239 = phi i64 [ %202, %215 ], [ %229, %231 ]
%240 = phi i64 [ %216, %215 ], [ %227, %231 ]
%241 = trunc i64 %240 to i32
%242 = trunc i64 %239 to i32
br label %243
243: ; preds = %223, %238
%244 = phi i32 [ %241, %238 ], [ %218, %223 ]
%245 = phi i32 [ %242, %238 ], [ -1, %223 ]
%246 = add nsw i32 %245, 1
%247 = sext i32 %246 to i64
%248 = getelementptr inbounds [100 x i8], [100 x i8]* %2, i64 0, i64 %247
store i8 %162, i8* %248
br label %250
249: ; preds = %198
store i8 %162, i8* %7
br label %250
250: ; preds = %170, %194, %207, %243, %211, %249, %187
%251 = phi i32 [ %160, %170 ], [ %188, %187 ], [ %195, %194 ], [ %160, %207 ], [ %244, %243 ], [ %160, %211 ], [ %160, %249 ]
%252 = phi i32 [ %171, %170 ], [ %190, %187 ], [ %159, %194 ], [ %208, %207 ], [ %246, %243 ], [ %159, %211 ], [ 0, %249 ]
%253 = add nuw nsw i64 %158, 1
%254 = load i32, i32* %5
%255 = sext i32 %254 to i64
%256 = icmp slt i64 %253, %255
br i1 %256, label %157, label %257
257: ; preds = %250
%258 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([2 x i8], [2 x i8]* @str.8, i64 0, i64 0))
%259 = icmp eq i32 %252, -1
br i1 %259, label %330, label %260
260: ; preds = %257
%261 = sext i32 %252 to i64
%262 = sext i32 %251 to i64
%263 = add nsw i64 %261, 1
%264 = icmp ult i64 %263, 8
br i1 %264, label %318, label %265
265: ; preds = %260
%266 = icmp ult i64 %263, 32
br i1 %266, label %296, label %267
267: ; preds = %265
%268 = and i64 %263, -32
br label %269
269: ; preds = %269, %267
%270 = phi i64 [ 0, %267 ], [ %287, %269 ]
%271 = add i64 %270, %262
%272 = sub i64 %261, %270
%273 = add nsw i64 %271, 1
%274 = getelementptr inbounds [100 x i8], [100 x i8]* %2, i64 0, i64 %272
%275 = getelementptr inbounds i8, i8* %274, i64 -15
%276 = bitcast i8* %275 to <16 x i8>*
%277 = load <16 x i8>, <16 x i8>* %276
%278 = shufflevector <16 x i8> %277, <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>
%279 = getelementptr inbounds i8, i8* %274, i64 -31
%280 = bitcast i8* %279 to <16 x i8>*
%281 = load <16 x i8>, <16 x i8>* %280
%282 = shufflevector <16 x i8> %281, <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>
%283 = getelementptr inbounds [100 x i8], [100 x i8]* %3, i64 0, i64 %273
%284 = bitcast i8* %283 to <16 x i8>*
store <16 x i8> %278, <16 x i8>* %284
%285 = getelementptr inbounds i8, i8* %283, i64 16
%286 = bitcast i8* %285 to <16 x i8>*
store <16 x i8> %282, <16 x i8>* %286
%287 = add nuw i64 %270, 32
%288 = icmp eq i64 %287, %268
br i1 %288, label %289, label %269
289: ; preds = %269
%290 = icmp eq i64 %263, %268
br i1 %290, label %330, label %291
291: ; preds = %289
%292 = sub nsw i64 %261, %268
%293 = add nsw i64 %268, %262
%294 = and i64 %263, 24
%295 = icmp eq i64 %294, 0
br i1 %295, label %318, label %296
296: ; preds = %265, %291
%297 = phi i64 [ %268, %291 ], [ 0, %265 ]
%298 = add nsw i64 %261, 1
%299 = and i64 %298, -8
%300 = add nsw i64 %299, %262
%301 = sub nsw i64 %261, %299
br label %302
302: ; preds = %302, %296
%303 = phi i64 [ %297, %296 ], [ %314, %302 ]
%304 = add i64 %303, %262
%305 = sub i64 %261, %303
%306 = add nsw i64 %304, 1
%307 = getelementptr inbounds [100 x i8], [100 x i8]* %2, i64 0, i64 %305
%308 = getelementptr inbounds i8, i8* %307, i64 -7
%309 = bitcast i8* %308 to <8 x i8>*
%310 = load <8 x i8>, <8 x i8>* %309
%311 = shufflevector <8 x i8> %310, <8 x i8> poison, <8 x i32> <i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0>
%312 = getelementptr inbounds [100 x i8], [100 x i8]* %3, i64 0, i64 %306
%313 = bitcast i8* %312 to <8 x i8>*
store <8 x i8> %311, <8 x i8>* %313
%314 = add nuw i64 %303, 8
%315 = icmp eq i64 %314, %299
br i1 %315, label %316, label %302
316: ; preds = %302
%317 = icmp eq i64 %298, %299
br i1 %317, label %330, label %318
318: ; preds = %260, %291, %316
%319 = phi i64 [ %262, %260 ], [ %293, %291 ], [ %300, %316 ]
%320 = phi i64 [ %261, %260 ], [ %292, %291 ], [ %301, %316 ]
br label %321
321: ; preds = %318, %321
%322 = phi i64 [ %324, %321 ], [ %319, %318 ]
%323 = phi i64 [ %328, %321 ], [ %320, %318 ]
%324 = add nsw i64 %322, 1
%325 = getelementptr inbounds [100 x i8], [100 x i8]* %2, i64 0, i64 %323
%326 = load i8, i8* %325
%327 = getelementptr inbounds [100 x i8], [100 x i8]* %3, i64 0, i64 %324
store i8 %326, i8* %327
%328 = add nsw i64 %323, -1
%329 = icmp eq i64 %323, 0
br i1 %329, label %330, label %321
330: ; preds = %321, %289, %316, %155, %257
%331 = call i8* @strrev(i8* %8)
%332 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), i8* %331)
ret i32 0
}