#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 /*<<< orphan*/ putchar(char);
int main() {
  char array[30000] = {0};
  char *ptr = array;
  ++*ptr;
  ++*ptr;
  ++*ptr;
  ++*ptr;
  ++*ptr;
  ++*ptr;
  ++*ptr;
  ++*ptr;
  while (*ptr) {
    ++ptr;
    ++*ptr;
    ++*ptr;
    ++*ptr;
    ++*ptr;
    while (*ptr) {
      ++ptr;
      ++*ptr;
      ++*ptr;
      ++ptr;
      ++*ptr;
      ++*ptr;
      ++*ptr;
      ++ptr;
      ++*ptr;
      ++*ptr;
      ++*ptr;
      ++ptr;
      ++*ptr;
      --ptr;
      --ptr;
      --ptr;
      --ptr;
      --*ptr;
    }
    ++ptr;
    ++*ptr;
    ++ptr;
    ++*ptr;
    ++ptr;
    --*ptr;
    ++ptr;
    ++ptr;
    ++*ptr;
    while (*ptr) {
      --ptr;
    }
    --ptr;
    --*ptr;
  }
  ++ptr;
  ++ptr;
  putchar(*ptr);
  ++ptr;
  --*ptr;
  --*ptr;
  --*ptr;
  putchar(*ptr);
  ++*ptr;
  ++*ptr;
  ++*ptr;
  ++*ptr;
  ++*ptr;
  ++*ptr;
  ++*ptr;
  putchar(*ptr);
  putchar(*ptr);
  ++*ptr;
  ++*ptr;
  ++*ptr;
  putchar(*ptr);
  ++ptr;
  ++ptr;
  putchar(*ptr);
  --ptr;
  --*ptr;
  putchar(*ptr);
  --ptr;
  putchar(*ptr);
  ++*ptr;
  ++*ptr;
  ++*ptr;
  putchar(*ptr);
  --*ptr;
  --*ptr;
  --*ptr;
  --*ptr;
  --*ptr;
  --*ptr;
  putchar(*ptr);
  --*ptr;
  --*ptr;
  --*ptr;
  --*ptr;
  --*ptr;
  --*ptr;
  --*ptr;
  --*ptr;
  putchar(*ptr);
  ++ptr;
  ++ptr;
  ++*ptr;
  putchar(*ptr);
  ++ptr;
  ++*ptr;
  ++*ptr;
  putchar(*ptr);
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x7550,%rsp
movl   $0x0,-0x4(%rbp)
lea    -0x7540(%rbp),%rdi
xor    %esi,%esi
mov    $0x7530,%edx
call   1040 <memset@plt>
lea    -0x7540(%rbp),%rax
mov    %rax,-0x7548(%rbp)
mov    -0x7548(%rbp),%rax
mov    (%rax),%cl
add    $0x1,%cl
mov    %cl,(%rax)
mov    -0x7548(%rbp),%rax
mov    (%rax),%cl
add    $0x1,%cl
mov    %cl,(%rax)
mov    -0x7548(%rbp),%rax
mov    (%rax),%cl
add    $0x1,%cl
mov    %cl,(%rax)
mov    -0x7548(%rbp),%rax
mov    (%rax),%cl
add    $0x1,%cl
mov    %cl,(%rax)
mov    -0x7548(%rbp),%rax
mov    (%rax),%cl
add    $0x1,%cl
mov    %cl,(%rax)
mov    -0x7548(%rbp),%rax
mov    (%rax),%cl
add    $0x1,%cl
mov    %cl,(%rax)
mov    -0x7548(%rbp),%rax
mov    (%rax),%cl
add    $0x1,%cl
mov    %cl,(%rax)
mov    -0x7548(%rbp),%rax
mov    (%rax),%cl
add    $0x1,%cl
mov    %cl,(%rax)
mov    -0x7548(%rbp),%rax
cmpb   $0x0,(%rax)
je     142c <main+0x30c>
mov    -0x7548(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x7548(%rbp)
mov    -0x7548(%rbp),%rax
mov    (%rax),%cl
add    $0x1,%cl
mov    %cl,(%rax)
mov    -0x7548(%rbp),%rax
mov    (%rax),%cl
add    $0x1,%cl
mov    %cl,(%rax)
mov    -0x7548(%rbp),%rax
mov    (%rax),%cl
add    $0x1,%cl
mov    %cl,(%rax)
mov    -0x7548(%rbp),%rax
mov    (%rax),%cl
add    $0x1,%cl
mov    %cl,(%rax)
mov    -0x7548(%rbp),%rax
cmpb   $0x0,(%rax)
je     134e <main+0x22e>
mov    -0x7548(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x7548(%rbp)
mov    -0x7548(%rbp),%rax
mov    (%rax),%cl
add    $0x1,%cl
mov    %cl,(%rax)
mov    -0x7548(%rbp),%rax
mov    (%rax),%cl
add    $0x1,%cl
mov    %cl,(%rax)
mov    -0x7548(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x7548(%rbp)
mov    -0x7548(%rbp),%rax
mov    (%rax),%cl
add    $0x1,%cl
mov    %cl,(%rax)
mov    -0x7548(%rbp),%rax
mov    (%rax),%cl
add    $0x1,%cl
mov    %cl,(%rax)
mov    -0x7548(%rbp),%rax
mov    (%rax),%cl
add    $0x1,%cl
mov    %cl,(%rax)
mov    -0x7548(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x7548(%rbp)
mov    -0x7548(%rbp),%rax
mov    (%rax),%cl
add    $0x1,%cl
mov    %cl,(%rax)
mov    -0x7548(%rbp),%rax
mov    (%rax),%cl
add    $0x1,%cl
mov    %cl,(%rax)
mov    -0x7548(%rbp),%rax
mov    (%rax),%cl
add    $0x1,%cl
mov    %cl,(%rax)
mov    -0x7548(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x7548(%rbp)
mov    -0x7548(%rbp),%rax
mov    (%rax),%cl
add    $0x1,%cl
mov    %cl,(%rax)
mov    -0x7548(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x7548(%rbp)
mov    -0x7548(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x7548(%rbp)
mov    -0x7548(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x7548(%rbp)
mov    -0x7548(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x7548(%rbp)
mov    -0x7548(%rbp),%rax
mov    (%rax),%cl
add    $0xff,%cl
mov    %cl,(%rax)
jmp    121d <main+0xfd>
mov    -0x7548(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x7548(%rbp)
mov    -0x7548(%rbp),%rax
mov    (%rax),%cl
add    $0x1,%cl
mov    %cl,(%rax)
mov    -0x7548(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x7548(%rbp)
mov    -0x7548(%rbp),%rax
mov    (%rax),%cl
add    $0x1,%cl
mov    %cl,(%rax)
mov    -0x7548(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x7548(%rbp)
mov    -0x7548(%rbp),%rax
mov    (%rax),%cl
add    $0xff,%cl
mov    %cl,(%rax)
mov    -0x7548(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x7548(%rbp)
mov    -0x7548(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x7548(%rbp)
mov    -0x7548(%rbp),%rax
mov    (%rax),%cl
add    $0x1,%cl
mov    %cl,(%rax)
mov    -0x7548(%rbp),%rax
cmpb   $0x0,(%rax)
je     1407 <main+0x2e7>
mov    -0x7548(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x7548(%rbp)
jmp    13e0 <main+0x2c0>
mov    -0x7548(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x7548(%rbp)
mov    -0x7548(%rbp),%rax
mov    (%rax),%cl
add    $0xff,%cl
mov    %cl,(%rax)
jmp    11c3 <main+0xa3>
mov    -0x7548(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x7548(%rbp)
mov    -0x7548(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x7548(%rbp)
mov    -0x7548(%rbp),%rax
movsbl (%rax),%edi
call   1030 <putchar@plt>
mov    -0x7548(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x7548(%rbp)
mov    -0x7548(%rbp),%rax
mov    (%rax),%cl
add    $0xff,%cl
mov    %cl,(%rax)
mov    -0x7548(%rbp),%rax
mov    (%rax),%cl
add    $0xff,%cl
mov    %cl,(%rax)
mov    -0x7548(%rbp),%rax
mov    (%rax),%cl
add    $0xff,%cl
mov    %cl,(%rax)
mov    -0x7548(%rbp),%rax
movsbl (%rax),%edi
call   1030 <putchar@plt>
mov    -0x7548(%rbp),%rax
mov    (%rax),%cl
add    $0x1,%cl
mov    %cl,(%rax)
mov    -0x7548(%rbp),%rax
mov    (%rax),%cl
add    $0x1,%cl
mov    %cl,(%rax)
mov    -0x7548(%rbp),%rax
mov    (%rax),%cl
add    $0x1,%cl
mov    %cl,(%rax)
mov    -0x7548(%rbp),%rax
mov    (%rax),%cl
add    $0x1,%cl
mov    %cl,(%rax)
mov    -0x7548(%rbp),%rax
mov    (%rax),%cl
add    $0x1,%cl
mov    %cl,(%rax)
mov    -0x7548(%rbp),%rax
mov    (%rax),%cl
add    $0x1,%cl
mov    %cl,(%rax)
mov    -0x7548(%rbp),%rax
mov    (%rax),%cl
add    $0x1,%cl
mov    %cl,(%rax)
mov    -0x7548(%rbp),%rax
movsbl (%rax),%edi
call   1030 <putchar@plt>
mov    -0x7548(%rbp),%rax
movsbl (%rax),%edi
call   1030 <putchar@plt>
mov    -0x7548(%rbp),%rax
mov    (%rax),%cl
add    $0x1,%cl
mov    %cl,(%rax)
mov    -0x7548(%rbp),%rax
mov    (%rax),%cl
add    $0x1,%cl
mov    %cl,(%rax)
mov    -0x7548(%rbp),%rax
mov    (%rax),%cl
add    $0x1,%cl
mov    %cl,(%rax)
mov    -0x7548(%rbp),%rax
movsbl (%rax),%edi
call   1030 <putchar@plt>
mov    -0x7548(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x7548(%rbp)
mov    -0x7548(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x7548(%rbp)
mov    -0x7548(%rbp),%rax
movsbl (%rax),%edi
call   1030 <putchar@plt>
mov    -0x7548(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x7548(%rbp)
mov    -0x7548(%rbp),%rax
mov    (%rax),%cl
add    $0xff,%cl
mov    %cl,(%rax)
mov    -0x7548(%rbp),%rax
movsbl (%rax),%edi
call   1030 <putchar@plt>
mov    -0x7548(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x7548(%rbp)
mov    -0x7548(%rbp),%rax
movsbl (%rax),%edi
call   1030 <putchar@plt>
mov    -0x7548(%rbp),%rax
mov    (%rax),%cl
add    $0x1,%cl
mov    %cl,(%rax)
mov    -0x7548(%rbp),%rax
mov    (%rax),%cl
add    $0x1,%cl
mov    %cl,(%rax)
mov    -0x7548(%rbp),%rax
mov    (%rax),%cl
add    $0x1,%cl
mov    %cl,(%rax)
mov    -0x7548(%rbp),%rax
movsbl (%rax),%edi
call   1030 <putchar@plt>
mov    -0x7548(%rbp),%rax
mov    (%rax),%cl
add    $0xff,%cl
mov    %cl,(%rax)
mov    -0x7548(%rbp),%rax
mov    (%rax),%cl
add    $0xff,%cl
mov    %cl,(%rax)
mov    -0x7548(%rbp),%rax
mov    (%rax),%cl
add    $0xff,%cl
mov    %cl,(%rax)
mov    -0x7548(%rbp),%rax
mov    (%rax),%cl
add    $0xff,%cl
mov    %cl,(%rax)
mov    -0x7548(%rbp),%rax
mov    (%rax),%cl
add    $0xff,%cl
mov    %cl,(%rax)
mov    -0x7548(%rbp),%rax
mov    (%rax),%cl
add    $0xff,%cl
mov    %cl,(%rax)
mov    -0x7548(%rbp),%rax
movsbl (%rax),%edi
call   1030 <putchar@plt>
mov    -0x7548(%rbp),%rax
mov    (%rax),%cl
add    $0xff,%cl
mov    %cl,(%rax)
mov    -0x7548(%rbp),%rax
mov    (%rax),%cl
add    $0xff,%cl
mov    %cl,(%rax)
mov    -0x7548(%rbp),%rax
mov    (%rax),%cl
add    $0xff,%cl
mov    %cl,(%rax)
mov    -0x7548(%rbp),%rax
mov    (%rax),%cl
add    $0xff,%cl
mov    %cl,(%rax)
mov    -0x7548(%rbp),%rax
mov    (%rax),%cl
add    $0xff,%cl
mov    %cl,(%rax)
mov    -0x7548(%rbp),%rax
mov    (%rax),%cl
add    $0xff,%cl
mov    %cl,(%rax)
mov    -0x7548(%rbp),%rax
mov    (%rax),%cl
add    $0xff,%cl
mov    %cl,(%rax)
mov    -0x7548(%rbp),%rax
mov    (%rax),%cl
add    $0xff,%cl
mov    %cl,(%rax)
mov    -0x7548(%rbp),%rax
movsbl (%rax),%edi
call   1030 <putchar@plt>
mov    -0x7548(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x7548(%rbp)
mov    -0x7548(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x7548(%rbp)
mov    -0x7548(%rbp),%rax
mov    (%rax),%cl
add    $0x1,%cl
mov    %cl,(%rax)
mov    -0x7548(%rbp),%rax
movsbl (%rax),%edi
call   1030 <putchar@plt>
mov    -0x7548(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x7548(%rbp)
mov    -0x7548(%rbp),%rax
mov    (%rax),%cl
add    $0x1,%cl
mov    %cl,(%rax)
mov    -0x7548(%rbp),%rax
mov    (%rax),%cl
add    $0x1,%cl
mov    %cl,(%rax)
mov    -0x7548(%rbp),%rax
movsbl (%rax),%edi
call   1030 <putchar@plt>
mov    -0x4(%rbp),%eax
add    $0x7550,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %r14
push   %rbx
sub    $0x7538,%rsp
mov    %rsp,%r14
mov    $0x7530,%edx
mov    %r14,%rdi
xor    %esi,%esi
call   1040 <memset@plt>
movb   $0x8,(%rsp)
jmp    115d <main+0x3d>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %rax,%rbx
lea    -0x1(%rbx),%r14
addb   $0xff,-0x1(%rbx)
je     11cf <main+0xaf>
mov    0x1(%r14),%cl
mov    %ecx,%ebx
add    $0x4,%bl
je     1190 <main+0x70>
lea    (%rcx,%rcx,1),%eax
add    0x2(%r14),%al
movzbl %cl,%ecx
add    $0x8,%al
lea    (%rcx,%rcx,2),%ecx
mov    0x4(%r14),%dl
add    %cl,%dl
add    0x3(%r14),%cl
add    $0xc,%cl
add    $0xc,%dl
add    %bl,0x5(%r14)
jmp    119c <main+0x7c>
nopl   (%rax)
mov    0x2(%r14),%al
mov    0x3(%r14),%cl
mov    0x4(%r14),%dl
movb   $0x0,0x1(%r14)
add    $0x1,%al
mov    %al,0x2(%r14)
add    $0x1,%cl
mov    %cl,0x3(%r14)
add    $0xff,%dl
mov    %dl,0x4(%r14)
lea    0x6(%r14),%rax
addb   $0x1,0x6(%r14)
je     1150 <main+0x30>
lea    -0x1(%rax),%rbx
cmpb   $0x0,-0x1(%rax)
mov    %rbx,%rax
jne    11c0 <main+0xa0>
jmp    1153 <main+0x33>
movsbl 0x1(%rbx),%edi
call   1030 <putchar@plt>
mov    0x2(%rbx),%al
add    $0xfd,%al
mov    %al,0x2(%rbx)
movsbl %al,%edi
call   1030 <putchar@plt>
mov    0x2(%rbx),%al
add    $0x7,%al
mov    %al,0x2(%rbx)
movsbl %al,%edi
call   1030 <putchar@plt>
movsbl 0x2(%rbx),%edi
call   1030 <putchar@plt>
mov    0x2(%rbx),%al
add    $0x3,%al
mov    %al,0x2(%rbx)
movsbl %al,%edi
call   1030 <putchar@plt>
movsbl 0x4(%rbx),%edi
call   1030 <putchar@plt>
mov    0x3(%rbx),%al
add    $0xff,%al
mov    %al,0x3(%rbx)
movsbl %al,%edi
call   1030 <putchar@plt>
movsbl 0x2(%rbx),%edi
call   1030 <putchar@plt>
mov    0x2(%rbx),%al
add    $0x3,%al
mov    %al,0x2(%rbx)
movsbl %al,%edi
call   1030 <putchar@plt>
mov    0x2(%rbx),%al
add    $0xfa,%al
mov    %al,0x2(%rbx)
movsbl %al,%edi
call   1030 <putchar@plt>
mov    0x2(%rbx),%al
add    $0xf8,%al
mov    %al,0x2(%rbx)
movsbl %al,%edi
call   1030 <putchar@plt>
mov    0x4(%rbx),%al
add    $0x1,%al
mov    %al,0x4(%rbx)
movsbl %al,%edi
call   1030 <putchar@plt>
mov    0x5(%rbx),%al
add    $0x2,%al
mov    %al,0x5(%rbx)
movsbl %al,%edi
call   1030 <putchar@plt>
xor    %eax,%eax
add    $0x7538,%rsp
pop    %rbx
pop    %r14
ret

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

LLVM IR (-O2):
define i32 @main() {
%1 = alloca [30000 x i8]
%2 = getelementptr inbounds [30000 x i8], [30000 x i8]* %1, i64 0, i64 0
store i8 8, i8* %2
br label %3
3: ; preds = %0, %52
%4 = phi i8* [ %54, %52 ], [ %2, %0 ]
%5 = getelementptr inbounds i8, i8* %4, i64 1
%6 = load i8, i8* %5
%7 = add i8 %6, 4
%8 = icmp eq i8 %7, 0
%9 = getelementptr inbounds i8, i8* %4, i64 2
br i1 %8, label %10, label %16
10: ; preds = %3
%11 = load i8, i8* %9
%12 = getelementptr inbounds i8, i8* %4, i64 3
%13 = load i8, i8* %12
%14 = getelementptr inbounds i8, i8* %4, i64 4
%15 = load i8, i8* %14
br label %33
16: ; preds = %3
%17 = getelementptr inbounds i8, i8* %4, i64 3
%18 = getelementptr inbounds i8, i8* %4, i64 4
%19 = getelementptr inbounds i8, i8* %4, i64 5
%20 = load i8, i8* %9
%21 = load i8, i8* %17
%22 = load i8, i8* %18
%23 = load i8, i8* %19
%24 = add i8 %20, 8
%25 = shl i8 %6, 1
%26 = add i8 %24, %25
%27 = mul i8 %6, 3
%28 = add i8 %22, 12
%29 = add i8 %21, 12
%30 = add i8 %29, %27
%31 = add i8 %28, %27
%32 = add i8 %7, %23
store i8 %32, i8* %19
br label %33
33: ; preds = %10, %16
%34 = phi i8 [ %15, %10 ], [ %31, %16 ]
%35 = phi i8 [ %13, %10 ], [ %30, %16 ]
%36 = phi i8 [ %11, %10 ], [ %26, %16 ]
store i8 0, i8* %5
%37 = getelementptr inbounds i8, i8* %4, i64 2
%38 = add i8 %36, 1
store i8 %38, i8* %37
%39 = getelementptr inbounds i8, i8* %4, i64 3
%40 = add i8 %35, 1
store i8 %40, i8* %39
%41 = getelementptr inbounds i8, i8* %4, i64 4
%42 = add i8 %34, -1
store i8 %42, i8* %41
%43 = getelementptr inbounds i8, i8* %4, i64 6
%44 = load i8, i8* %43
%45 = add i8 %44, 1
store i8 %45, i8* %43
%46 = icmp eq i8 %45, 0
br i1 %46, label %52, label %47
47: ; preds = %33, %47
%48 = phi i8* [ %49, %47 ], [ %43, %33 ]
%49 = getelementptr inbounds i8, i8* %48, i64 -1
%50 = load i8, i8* %49
%51 = icmp eq i8 %50, 0
br i1 %51, label %52, label %47
52: ; preds = %47, %33
%53 = phi i8* [ %43, %33 ], [ %49, %47 ]
%54 = getelementptr inbounds i8, i8* %53, i64 -1
%55 = load i8, i8* %54
%56 = add i8 %55, -1
store i8 %56, i8* %54
%57 = icmp eq i8 %56, 0
br i1 %57, label %58, label %3
58: ; preds = %52
%59 = getelementptr inbounds i8, i8* %53, i64 1
%60 = load i8, i8* %59
%61 = tail call i32 @putchar(i8 signext %60)
%62 = getelementptr inbounds i8, i8* %53, i64 2
%63 = load i8, i8* %62
%64 = add i8 %63, -3
store i8 %64, i8* %62
%65 = tail call i32 @putchar(i8 signext %64)
%66 = load i8, i8* %62
%67 = add i8 %66, 7
store i8 %67, i8* %62
%68 = tail call i32 @putchar(i8 signext %67)
%69 = load i8, i8* %62
%70 = tail call i32 @putchar(i8 signext %69)
%71 = load i8, i8* %62
%72 = add i8 %71, 3
store i8 %72, i8* %62
%73 = tail call i32 @putchar(i8 signext %72)
%74 = getelementptr inbounds i8, i8* %53, i64 4
%75 = load i8, i8* %74
%76 = tail call i32 @putchar(i8 signext %75)
%77 = getelementptr inbounds i8, i8* %53, i64 3
%78 = load i8, i8* %77
%79 = add i8 %78, -1
store i8 %79, i8* %77
%80 = tail call i32 @putchar(i8 signext %79)
%81 = load i8, i8* %62
%82 = tail call i32 @putchar(i8 signext %81)
%83 = load i8, i8* %62
%84 = add i8 %83, 3
store i8 %84, i8* %62
%85 = tail call i32 @putchar(i8 signext %84)
%86 = load i8, i8* %62
%87 = add i8 %86, -6
store i8 %87, i8* %62
%88 = tail call i32 @putchar(i8 signext %87)
%89 = load i8, i8* %62
%90 = add i8 %89, -8
store i8 %90, i8* %62
%91 = tail call i32 @putchar(i8 signext %90)
%92 = load i8, i8* %74
%93 = add i8 %92, 1
store i8 %93, i8* %74
%94 = tail call i32 @putchar(i8 signext %93)
%95 = getelementptr inbounds i8, i8* %53, i64 5
%96 = load i8, i8* %95
%97 = add i8 %96, 2
store i8 %97, i8* %95
%98 = tail call i32 @putchar(i8 signext %97)
ret i32 0
}