#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 getchar();
int /*<<< orphan*/ printf(char *, ...);
int main() {
  char stack[1000];
  char fin[10000];
  int final = 0;
  char A[1000];
  int head = -1;
  int a, b, c, i, j, k, n, m, count = 0;
  while ((c = getchar()) != '\n') {
    A[count] = c;
    count++;
  }
  for (i = 0; i < count; i++) {
    if (A[i] == '(') {
      head++;
      stack[head] = '(';
    } else if (A[i] == ')') {
      while (head != -1 && stack[head] != '(') {
        fin[final] = stack[head];
        final++;
        head--;
      }
      if (head != -1)
        head--;
    } else if (A[i] == '*' || A[i] == '/') {
      while (head != -1 && stack[head] != '(' &&
             (stack[head] == '*' || stack[head] == '/')) {
        fin[final] = stack[head];
        final++;
        head--;
      }
      head++;
      stack[head] = A[i];
    } else if (A[i] == '+' || A[i] == '-') {
      while (head != -1 && stack[head] != '(') {
        fin[final] = stack[head];
        final++;
        head--;
      }
      head++;
      stack[head] = A[i];
    } else {
      fin[final] = A[i];
      final++;
    }
  }
  while (head != -1) {
    fin[final] = stack[head];
    final++;
    head--;
  }
  for (i = 0; i < final; i++)
    printf("%c", fin[i]);
  printf("\n");
  final = 0;
  for (i = count - 1; i >= 0; i--) {
    if (A[i] == ')') {
      head++;
      stack[head] = ')';
    } else if (A[i] == '(') {
      while (head != -1 && stack[head] != ')') {
        fin[final] = stack[head];
        final++;
        head--;
      }
      if (head != -1)
        head--;
    } else if (A[i] == '*' || A[i] == '/') {
      while (head != -1 && stack[head] != ')' &&
             (stack[head] == '*' || stack[head] == '/')) {
        fin[final] = stack[head];
        final++;
        head--;
      }
      head++;
      stack[head] = A[i];
    } else if (A[i] == '+' || A[i] == '-') {
      while (head != -1 && stack[head] != ')') {
        fin[final] = stack[head];
        final++;
        head--;
      }
      head++;
      stack[head] = A[i];
    } else {
      fin[final] = A[i];
      final++;
    }
  }
  while (head != -1) {
    fin[final] = stack[head];
    final++;
    head--;
  }
  for (i = final - 1; i >= 0; i--)
    printf("%c", fin[i]);
  printf("\n");
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x2f20,%rsp
movl   $0x0,-0x4(%rbp)
movl   $0x0,-0x2b04(%rbp)
movl   $0xffffffff,-0x2ef4(%rbp)
ff ff ff
movl   $0x0,-0x2f18(%rbp)
mov    $0x0,%al
call   1040 <getchar@plt>
mov    %eax,-0x2f00(%rbp)
cmp    $0xa,%eax
je     1190 <main+0x70>
mov    -0x2f00(%rbp),%eax
mov    %al,%cl
movslq -0x2f18(%rbp),%rax
mov    %cl,-0x2ef0(%rbp,%rax,1)
mov    -0x2f18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2f18(%rbp)
jmp    1150 <main+0x30>
movl   $0x0,-0x2f04(%rbp)
mov    -0x2f04(%rbp),%eax
cmp    -0x2f18(%rbp),%eax
jge    1514 <main+0x3f4>
movslq -0x2f04(%rbp),%rax
movsbl -0x2ef0(%rbp,%rax,1),%eax
ff
cmp    $0x28,%eax
jne    11e7 <main+0xc7>
mov    -0x2ef4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2ef4(%rbp)
movslq -0x2ef4(%rbp),%rax
movb   $0x28,-0x3f0(%rbp,%rax,1)
28
jmp    14fb <main+0x3db>
movslq -0x2f04(%rbp),%rax
movsbl -0x2ef0(%rbp,%rax,1),%eax
ff
cmp    $0x29,%eax
jne    12a7 <main+0x187>
jmp    1204 <main+0xe4>
xor    %eax,%eax
cmpl   $0xffffffff,-0x2ef4(%rbp)
mov    %al,-0x2f19(%rbp)
je     1234 <main+0x114>
movslq -0x2ef4(%rbp),%rax
movsbl -0x3f0(%rbp,%rax,1),%eax
ff
cmp    $0x28,%eax
setne  %al
mov    %al,-0x2f19(%rbp)
mov    -0x2f19(%rbp),%al
test   $0x1,%al
jne    1247 <main+0x127>
jmp    1286 <main+0x166>
movslq -0x2ef4(%rbp),%rax
mov    -0x3f0(%rbp,%rax,1),%cl
movslq -0x2b04(%rbp),%rax
mov    %cl,-0x2b00(%rbp,%rax,1)
mov    -0x2b04(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2b04(%rbp)
mov    -0x2ef4(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2ef4(%rbp)
jmp    1204 <main+0xe4>
cmpl   $0xffffffff,-0x2ef4(%rbp)
je     12a2 <main+0x182>
mov    -0x2ef4(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2ef4(%rbp)
jmp    14f6 <main+0x3d6>
movslq -0x2f04(%rbp),%rax
movsbl -0x2ef0(%rbp,%rax,1),%eax
ff
cmp    $0x2a,%eax
je     12d7 <main+0x1b7>
movslq -0x2f04(%rbp),%rax
movsbl -0x2ef0(%rbp,%rax,1),%eax
ff
cmp    $0x2f,%eax
jne    13da <main+0x2ba>
jmp    12dc <main+0x1bc>
xor    %eax,%eax
cmpl   $0xffffffff,-0x2ef4(%rbp)
mov    %al,-0x2f1a(%rbp)
je     1358 <main+0x238>
movslq -0x2ef4(%rbp),%rax
movsbl -0x3f0(%rbp,%rax,1),%ecx
ff
xor    %eax,%eax
cmp    $0x28,%ecx
mov    %al,-0x2f1a(%rbp)
je     1358 <main+0x238>
movslq -0x2ef4(%rbp),%rax
movsbl -0x3f0(%rbp,%rax,1),%ecx
ff
mov    $0x1,%al
cmp    $0x2a,%ecx
mov    %al,-0x2f1b(%rbp)
je     134c <main+0x22c>
movslq -0x2ef4(%rbp),%rax
movsbl -0x3f0(%rbp,%rax,1),%eax
ff
cmp    $0x2f,%eax
sete   %al
mov    %al,-0x2f1b(%rbp)
mov    -0x2f1b(%rbp),%al
mov    %al,-0x2f1a(%rbp)
mov    -0x2f1a(%rbp),%al
test   $0x1,%al
jne    136b <main+0x24b>
jmp    13aa <main+0x28a>
movslq -0x2ef4(%rbp),%rax
mov    -0x3f0(%rbp,%rax,1),%cl
movslq -0x2b04(%rbp),%rax
mov    %cl,-0x2b00(%rbp,%rax,1)
mov    -0x2b04(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2b04(%rbp)
mov    -0x2ef4(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2ef4(%rbp)
jmp    12dc <main+0x1bc>
mov    -0x2ef4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2ef4(%rbp)
movslq -0x2f04(%rbp),%rax
mov    -0x2ef0(%rbp,%rax,1),%cl
movslq -0x2ef4(%rbp),%rax
mov    %cl,-0x3f0(%rbp,%rax,1)
jmp    14f1 <main+0x3d1>
movslq -0x2f04(%rbp),%rax
movsbl -0x2ef0(%rbp,%rax,1),%eax
ff
cmp    $0x2b,%eax
je     140a <main+0x2ea>
movslq -0x2f04(%rbp),%rax
movsbl -0x2ef0(%rbp,%rax,1),%eax
cmp    $0x2d,%eax
jne    14c1 <main+0x3a1>
jmp    140f <main+0x2ef>
xor    %eax,%eax
cmpl   $0xffffffff,-0x2ef4(%rbp)
mov    %al,-0x2f1c(%rbp)
je     143f <main+0x31f>
movslq -0x2ef4(%rbp),%rax
movsbl -0x3f0(%rbp,%rax,1),%eax
ff
cmp    $0x28,%eax
setne  %al
mov    %al,-0x2f1c(%rbp)
mov    -0x2f1c(%rbp),%al
test   $0x1,%al
jne    1452 <main+0x332>
jmp    1491 <main+0x371>
movslq -0x2ef4(%rbp),%rax
mov    -0x3f0(%rbp,%rax,1),%cl
movslq -0x2b04(%rbp),%rax
mov    %cl,-0x2b00(%rbp,%rax,1)
mov    -0x2b04(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2b04(%rbp)
mov    -0x2ef4(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2ef4(%rbp)
jmp    140f <main+0x2ef>
mov    -0x2ef4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2ef4(%rbp)
movslq -0x2f04(%rbp),%rax
mov    -0x2ef0(%rbp,%rax,1),%cl
movslq -0x2ef4(%rbp),%rax
mov    %cl,-0x3f0(%rbp,%rax,1)
jmp    14ec <main+0x3cc>
movslq -0x2f04(%rbp),%rax
mov    -0x2ef0(%rbp,%rax,1),%cl
movslq -0x2b04(%rbp),%rax
mov    %cl,-0x2b00(%rbp,%rax,1)
mov    -0x2b04(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2b04(%rbp)
jmp    14f1 <main+0x3d1>
jmp    14f6 <main+0x3d6>
jmp    14fb <main+0x3db>
jmp    1500 <main+0x3e0>
mov    -0x2f04(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2f04(%rbp)
jmp    119a <main+0x7a>
jmp    1519 <main+0x3f9>
cmpl   $0xffffffff,-0x2ef4(%rbp)
je     1565 <main+0x445>
movslq -0x2ef4(%rbp),%rax
mov    -0x3f0(%rbp,%rax,1),%cl
movslq -0x2b04(%rbp),%rax
mov    %cl,-0x2b00(%rbp,%rax,1)
mov    -0x2b04(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2b04(%rbp)
mov    -0x2ef4(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2ef4(%rbp)
jmp    1519 <main+0x3f9>
movl   $0x0,-0x2f04(%rbp)
mov    -0x2f04(%rbp),%eax
cmp    -0x2b04(%rbp),%eax
jge    15b2 <main+0x492>
movslq -0x2f04(%rbp),%rax
movsbl -0x2b00(%rbp,%rax,1),%esi
ff
lea    0xa69(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x2f04(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2f04(%rbp)
jmp    156f <main+0x44f>
lea    0xa4a(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x2b04(%rbp)
mov    -0x2f18(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x2f04(%rbp)
cmpl   $0x0,-0x2f04(%rbp)
jl     194e <main+0x82e>
movslq -0x2f04(%rbp),%rax
movsbl -0x2ef0(%rbp,%rax,1),%eax
ff
cmp    $0x29,%eax
jne    1621 <main+0x501>
mov    -0x2ef4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2ef4(%rbp)
movslq -0x2ef4(%rbp),%rax
movb   $0x29,-0x3f0(%rbp,%rax,1)
29
jmp    1935 <main+0x815>
movslq -0x2f04(%rbp),%rax
movsbl -0x2ef0(%rbp,%rax,1),%eax
ff
cmp    $0x28,%eax
jne    16e1 <main+0x5c1>
jmp    163e <main+0x51e>
xor    %eax,%eax
cmpl   $0xffffffff,-0x2ef4(%rbp)
mov    %al,-0x2f1d(%rbp)
je     166e <main+0x54e>
movslq -0x2ef4(%rbp),%rax
movsbl -0x3f0(%rbp,%rax,1),%eax
ff
cmp    $0x29,%eax
setne  %al
mov    %al,-0x2f1d(%rbp)
mov    -0x2f1d(%rbp),%al
test   $0x1,%al
jne    1681 <main+0x561>
jmp    16c0 <main+0x5a0>
movslq -0x2ef4(%rbp),%rax
mov    -0x3f0(%rbp,%rax,1),%cl
movslq -0x2b04(%rbp),%rax
mov    %cl,-0x2b00(%rbp,%rax,1)
mov    -0x2b04(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2b04(%rbp)
mov    -0x2ef4(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2ef4(%rbp)
jmp    163e <main+0x51e>
cmpl   $0xffffffff,-0x2ef4(%rbp)
je     16dc <main+0x5bc>
mov    -0x2ef4(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2ef4(%rbp)
jmp    1930 <main+0x810>
movslq -0x2f04(%rbp),%rax
movsbl -0x2ef0(%rbp,%rax,1),%eax
ff
cmp    $0x2a,%eax
je     1711 <main+0x5f1>
movslq -0x2f04(%rbp),%rax
movsbl -0x2ef0(%rbp,%rax,1),%eax
ff
cmp    $0x2f,%eax
jne    1814 <main+0x6f4>
jmp    1716 <main+0x5f6>
xor    %eax,%eax
cmpl   $0xffffffff,-0x2ef4(%rbp)
mov    %al,-0x2f1e(%rbp)
je     1792 <main+0x672>
movslq -0x2ef4(%rbp),%rax
movsbl -0x3f0(%rbp,%rax,1),%ecx
ff
xor    %eax,%eax
cmp    $0x29,%ecx
mov    %al,-0x2f1e(%rbp)
je     1792 <main+0x672>
movslq -0x2ef4(%rbp),%rax
movsbl -0x3f0(%rbp,%rax,1),%ecx
ff
mov    $0x1,%al
cmp    $0x2a,%ecx
mov    %al,-0x2f1f(%rbp)
je     1786 <main+0x666>
movslq -0x2ef4(%rbp),%rax
movsbl -0x3f0(%rbp,%rax,1),%eax
ff
cmp    $0x2f,%eax
sete   %al
mov    %al,-0x2f1f(%rbp)
mov    -0x2f1f(%rbp),%al
mov    %al,-0x2f1e(%rbp)
mov    -0x2f1e(%rbp),%al
test   $0x1,%al
jne    17a5 <main+0x685>
jmp    17e4 <main+0x6c4>
movslq -0x2ef4(%rbp),%rax
mov    -0x3f0(%rbp,%rax,1),%cl
movslq -0x2b04(%rbp),%rax
mov    %cl,-0x2b00(%rbp,%rax,1)
mov    -0x2b04(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2b04(%rbp)
mov    -0x2ef4(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2ef4(%rbp)
jmp    1716 <main+0x5f6>
mov    -0x2ef4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2ef4(%rbp)
movslq -0x2f04(%rbp),%rax
mov    -0x2ef0(%rbp,%rax,1),%cl
movslq -0x2ef4(%rbp),%rax
mov    %cl,-0x3f0(%rbp,%rax,1)
jmp    192b <main+0x80b>
movslq -0x2f04(%rbp),%rax
movsbl -0x2ef0(%rbp,%rax,1),%eax
ff
cmp    $0x2b,%eax
je     1844 <main+0x724>
movslq -0x2f04(%rbp),%rax
movsbl -0x2ef0(%rbp,%rax,1),%eax
ff
cmp    $0x2d,%eax
jne    18fb <main+0x7db>
jmp    1849 <main+0x729>
xor    %eax,%eax
cmpl   $0xffffffff,-0x2ef4(%rbp)
mov    %al,-0x2f20(%rbp)
je     1879 <main+0x759>
movslq -0x2ef4(%rbp),%rax
movsbl -0x3f0(%rbp,%rax,1),%eax
ff
cmp    $0x29,%eax
setne  %al
mov    %al,-0x2f20(%rbp)
mov    -0x2f20(%rbp),%al
test   $0x1,%al
jne    188c <main+0x76c>
jmp    18cb <main+0x7ab>
movslq -0x2ef4(%rbp),%rax
mov    -0x3f0(%rbp,%rax,1),%cl
movslq -0x2b04(%rbp),%rax
mov    %cl,-0x2b00(%rbp,%rax,1)
mov    -0x2b04(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2b04(%rbp)
mov    -0x2ef4(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2ef4(%rbp)
jmp    1849 <main+0x729>
mov    -0x2ef4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2ef4(%rbp)
movslq -0x2f04(%rbp),%rax
mov    -0x2ef0(%rbp,%rax,1),%cl
movslq -0x2ef4(%rbp),%rax
mov    %cl,-0x3f0(%rbp,%rax,1)
jmp    1926 <main+0x806>
movslq -0x2f04(%rbp),%rax
mov    -0x2ef0(%rbp,%rax,1),%cl
movslq -0x2b04(%rbp),%rax
mov    %cl,-0x2b00(%rbp,%rax,1)
mov    -0x2b04(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2b04(%rbp)
jmp    192b <main+0x80b>
jmp    1930 <main+0x810>
jmp    1935 <main+0x815>
jmp    193a <main+0x81a>
mov    -0x2f04(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2f04(%rbp)
jmp    15d9 <main+0x4b9>
jmp    1953 <main+0x833>
cmpl   $0xffffffff,-0x2ef4(%rbp)
je     199f <main+0x87f>
movslq -0x2ef4(%rbp),%rax
mov    -0x3f0(%rbp,%rax,1),%cl
movslq -0x2b04(%rbp),%rax
mov    %cl,-0x2b00(%rbp,%rax,1)
mov    -0x2b04(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2b04(%rbp)
mov    -0x2ef4(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2ef4(%rbp)
jmp    1953 <main+0x833>
mov    -0x2b04(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x2f04(%rbp)
cmpl   $0x0,-0x2f04(%rbp)
jl     19ec <main+0x8cc>
movslq -0x2f04(%rbp),%rax
movsbl -0x2b00(%rbp,%rax,1),%esi
ff
lea    0x62f(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x2f04(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2f04(%rbp)
jmp    19ae <main+0x88e>
lea    0x610(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
xor    %eax,%eax
add    $0x2f20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x2ef0,%rsp
xor    %eax,%eax
call   1040 <getchar@plt>
cmp    $0xa,%eax
je     1322 <main+0x202>
xor    %r13d,%r13d
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %al,0x3f0(%rsp,%r13,1)
add    $0x1,%r13
xor    %eax,%eax
call   1040 <getchar@plt>
cmp    $0xa,%eax
jne    1150 <main+0x30>
test   %r13d,%r13d
je     1322 <main+0x202>
mov    %r13d,%r9d
mov    $0xffffffff,%r12d
xor    %edx,%edx
lea    0xe7d(%rip),%r8
xor    %r14d,%r14d
jmp    11ac <main+0x8c>
nopl   0x0(%rax,%rax,1)
mov    %r11d,%r14d
movslq %r10d,%r12
mov    %r15b,0x1(%rsp,%r12,1)
add    $0x1,%r12
add    $0x1,%rdx
cmp    %r9,%rdx
je     1349 <main+0x229>
mov    0x3f0(%rsp,%rdx,1),%r15b
lea    -0x28(%r15),%eax
cmp    $0x7,%al
ja     12e6 <main+0x1c6>
movzbl %al,%eax
movslq (%r8,%rax,4),%rax
add    %r8,%rax
jmp    *%rax
mov    $0xffffffff,%r10d
cmp    $0xffffffff,%r12d
je     1193 <main+0x73>
movslq %r14d,%rsi
movslq %r12d,%rcx
lea    (%r14,%r12,1),%r11d
add    $0x1,%r11d
lea    (%rsp,%rcx,1),%rax
not    %rcx
lea    (%rsp,%rsi,1),%rdi
add    $0x7e0,%rdi
xor    %esi,%esi
jmp    120f <main+0xef>
nopl   0x0(%rax)
mov    %bl,(%rdi)
add    $0xffffffffffffffff,%rsi
add    $0x1,%rdi
cmp    %rsi,%rcx
je     1190 <main+0x70>
movzbl (%rax,%rsi,1),%ebx
cmp    $0x2f,%bl
je     1200 <main+0xe0>
cmp    $0x2a,%bl
je     1200 <main+0xe0>
sub    %esi,%r14d
add    %esi,%r12d
jmp    1300 <main+0x1e0>
nopl   0x0(%rax,%rax,1)
mov    $0xffffffff,%r10d
cmp    $0xffffffff,%r12d
je     1193 <main+0x73>
movslq %r14d,%rax
movslq %r12d,%rcx
lea    (%rax,%r12,1),%r11d
add    $0x1,%r11d
lea    (%rsp,%rcx,1),%rsi
not    %rcx
add    %rsp,%rax
add    $0x7e0,%rax
xor    %edi,%edi
movzbl (%rsi,%rdi,1),%ebx
cmp    $0x28,%bl
je     12fa <main+0x1da>
mov    %bl,(%rax)
add    $0xffffffffffffffff,%rdi
add    $0x1,%rax
cmp    %rdi,%rcx
jne    1260 <main+0x140>
jmp    1190 <main+0x70>
movslq %r12d,%r12
movb   $0x28,0x1(%rsp,%r12,1)
jmp    119b <main+0x7b>
cmp    $0xffffffff,%r12d
je     1308 <main+0x1e8>
movslq %r14d,%rax
movslq %r12d,%rcx
lea    (%r14,%r12,1),%r10d
add    $0x1,%r10d
lea    (%rsp,%rcx,1),%rsi
not    %rcx
lea    (%rsp,%rax,1),%rdi
add    $0x7e0,%rdi
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
movzbl (%rsi,%rax,1),%ebx
cmp    $0x28,%bl
je     1313 <main+0x1f3>
mov    %bl,(%rdi)
add    $0xffffffffffffffff,%rax
add    $0x1,%rdi
cmp    %rax,%rcx
jne    12c0 <main+0x1a0>
mov    $0xffffffff,%r12d
mov    %r10d,%r14d
jmp    119f <main+0x7f>
movslq %r14d,%rax
mov    %r15b,0x7e0(%rsp,%rax,1)
add    $0x1,%r14d
jmp    119f <main+0x7f>
sub    %edi,%r14d
add    %edi,%r12d
mov    %r12d,%r10d
jmp    1193 <main+0x73>
mov    $0xffffffff,%r12d
jmp    119f <main+0x7f>
sub    %eax,%r14d
add    %eax,%r12d
add    $0xffffffff,%r12d
jmp    119f <main+0x7f>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
xor    %eax,%eax
add    $0x2ef0,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
ret
cmp    $0xffffffff,%r12d
je     1446 <main+0x326>
movslq %r14d,%rax
movslq %r12d,%rcx
lea    0x1(%rcx),%r8
cmp    $0x20,%r8
jae    136b <main+0x24b>
mov    %rax,%r14
jmp    1430 <main+0x310>
mov    %r8,%r9
and    $0xffffffffffffffe0,%r9
lea    (%r9,%rax,1),%r14
mov    %r9,%r10
neg    %r10
lea    (%rsp,%rax,1),%rdx
add    $0x7f0,%rdx
lea    (%rsp,%rcx,1),%rsi
add    $0xfffffffffffffff1,%rsi
sub    %r9,%rcx
xor    %edi,%edi
pxor   %xmm0,%xmm0
nopl   0x0(%rax,%rax,1)
movdqu -0x10(%rsi,%rdi,1),%xmm1
movdqu (%rsi,%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
movdqu %xmm2,-0x10(%rdx)
movdqu %xmm1,(%rdx)
add    $0xffffffffffffffe0,%rdi
add    $0x20,%rdx
cmp    %rdi,%r10
jne    13a0 <main+0x280>
cmp    %r9,%r8
je     1446 <main+0x326>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movzbl (%rsp,%rcx,1),%eax
mov    %al,0x7e0(%rsp,%r14,1)
add    $0x1,%r14
add    $0xffffffffffffffff,%rcx
jb     1430 <main+0x310>
test   %r14d,%r14d
jle    1466 <main+0x346>
mov    %r14d,%r14d
xor    %ebx,%ebx
movsbl 0x7e0(%rsp,%rbx,1),%edi
call   1030 <putchar@plt>
add    $0x1,%rbx
cmp    %rbx,%r14
jne    1450 <main+0x330>
mov    $0xa,%edi
call   1030 <putchar@plt>
test   %r13d,%r13d
jle    132c <main+0x20c>
mov    %r13d,%r11d
mov    $0xffffffff,%edi
xor    %r15d,%r15d
lea    0xb95(%rip),%r8
jmp    14a9 <main+0x389>
nopl   (%rax)
mov    %r10d,%r15d
movslq %r9d,%rdi
mov    %r12b,0x1(%rsp,%rdi,1)
add    $0x1,%rdi
cmp    $0x1,%r14
jle    161d <main+0x4fd>
mov    %r11,%r14
add    $0xffffffffffffffff,%r11
mov    %r11d,%eax
mov    0x3f0(%rsp,%rax,1),%r12b
lea    -0x28(%r12),%eax
cmp    $0x7,%al
ja     15f2 <main+0x4d2>
movzbl %al,%eax
movslq (%r8,%rax,4),%rax
add    %r8,%rax
jmp    *%rax
mov    $0xffffffff,%r9d
cmp    $0xffffffff,%edi
je     1493 <main+0x373>
movslq %r15d,%rax
movslq %edi,%rdx
lea    (%r15,%rdi,1),%r10d
add    $0x1,%r10d
lea    (%rsp,%rdx,1),%rcx
not    %rdx
add    %rsp,%rax
add    $0x7e0,%rax
xor    %esi,%esi
jmp    1523 <main+0x403>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %bl,(%rax)
add    $0xffffffffffffffff,%rsi
add    $0x1,%rax
cmp    %rsi,%rdx
je     1490 <main+0x370>
movzbl (%rcx,%rsi,1),%ebx
cmp    $0x2f,%bl
je     1510 <main+0x3f0>
cmp    $0x2a,%bl
je     1510 <main+0x3f0>
sub    %esi,%r15d
add    %esi,%edi
mov    %edi,%r9d
jmp    1493 <main+0x373>
xchg   %ax,%ax
mov    $0xffffffff,%r9d
cmp    $0xffffffff,%edi
je     1493 <main+0x373>
movslq %r15d,%rcx
movslq %edi,%rdx
lea    (%rcx,%rdi,1),%r10d
add    $0x1,%r10d
lea    (%rsp,%rdx,1),%rax
not    %rdx
add    %rsp,%rcx
add    $0x7e0,%rcx
xor    %esi,%esi
movzbl (%rax,%rsi,1),%ebx
cmp    $0x29,%bl
je     1531 <main+0x411>
mov    %bl,(%rcx)
add    $0xffffffffffffffff,%rsi
add    $0x1,%rcx
cmp    %rsi,%rdx
jne    1570 <main+0x450>
jmp    1490 <main+0x370>
cmp    $0xffffffff,%edi
je     1606 <main+0x4e6>
movslq %r15d,%rax
movslq %edi,%rdx
lea    (%r15,%rdi,1),%r9d
add    $0x1,%r9d
lea    (%rsp,%rdx,1),%rsi
not    %rdx
add    %rsp,%rax
add    $0x7e0,%rax
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movzbl (%rsi,%rcx,1),%ebx
cmp    $0x29,%bl
je     1610 <main+0x4f0>
mov    %bl,(%rax)
add    $0xffffffffffffffff,%rcx
add    $0x1,%rax
cmp    %rcx,%rdx
jne    15c0 <main+0x4a0>
mov    $0xffffffff,%edi
mov    %r9d,%r15d
jmp    149f <main+0x37f>
movslq %edi,%rdi
movb   $0x29,0x1(%rsp,%rdi,1)
jmp    149b <main+0x37b>
movslq %r15d,%rax
mov    %r12b,0x7e0(%rsp,%rax,1)
add    $0x1,%r15d
jmp    149f <main+0x37f>
mov    $0xffffffff,%edi
jmp    149f <main+0x37f>
sub    %ecx,%r15d
add    %ecx,%edi
add    $0xffffffff,%edi
jmp    149f <main+0x37f>
cmp    $0xffffffff,%edi
je     1716 <main+0x5f6>
movslq %r15d,%rax
movslq %edi,%rcx
lea    0x1(%rcx),%r8
cmp    $0x20,%r8
jae    163e <main+0x51e>
mov    %rax,%r15
jmp    1700 <main+0x5e0>
mov    %r8,%r9
and    $0xffffffffffffffe0,%r9
lea    (%r9,%rax,1),%r15
mov    %r9,%rdi
neg    %rdi
lea    (%rsp,%rax,1),%rbx
add    $0x7f0,%rbx
lea    (%rsp,%rcx,1),%rdx
add    $0xfffffffffffffff1,%rdx
sub    %r9,%rcx
xor    %esi,%esi
pxor   %xmm0,%xmm0
nopl   0x0(%rax,%rax,1)
movdqu -0x10(%rdx,%rsi,1),%xmm1
movdqu (%rdx,%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    1670 <main+0x550>
cmp    %r9,%r8
je     1716 <main+0x5f6>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movzbl (%rsp,%rcx,1),%eax
mov    %al,0x7e0(%rsp,%r15,1)
add    $0x1,%r15
add    $0xffffffffffffffff,%rcx
jb     1700 <main+0x5e0>
test   %r15d,%r15d
jle    132c <main+0x20c>
mov    %r15d,%ebx
add    $0x1,%rbx
cs nopw 0x0(%rax,%rax,1)
lea    -0x2(%rbx),%eax
movsbl 0x7e0(%rsp,%rax,1),%edi
call   1030 <putchar@plt>
add    $0xffffffffffffffff,%rbx
cmp    $0x1,%rbx
ja     1730 <main+0x610>
jmp    132c <main+0x20c>

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

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