#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 a;
int b;
int /*<<< orphan*/ fputs(char *, int /*<<< orphan*/);
int /*<<< orphan*/ quit(int, char *);
int /*<<< orphan*/ sprintf(char *, char *, short);
int /*<<< orphan*/ stderr;
int /*<<< orphan*/ write(int, char *, int);
main() {
  char *sbrk();
  char *base;
  register char *ptr;
  int xg, xb, h, g, f, e, d, c;
  register b, a;
  fputs("Starting...\n", stderr);
  ptr = base = sbrk((3 * 3 * 3 * 3 * 3 * 3 * 3 * 3 * 3 * 3 * 17));
  for (xg = 0; xg <= 2; xg++)
    for (xb = 0; xb <= 2; xb++)
      for (h = 0; h <= 2; h++)
        for (g = 0; g <= 2; g++)
          for (f = 0; f <= 2; f++)
            for (e = 0; e <= 2; e++)
              for (d = 0; d <= 2; d++)
                for (c = 0; c <= 2; c++)
                  for (b = 0; b <= 2; b++)
                    for (a = 0; a <= 2; a++) {
                      register char *name = "BW.";
                      extern short Edge_Table[3][3][3][3][3][3][3][3][3][3];
                      *ptr++ = name[a];
                      *ptr++ = name[b];
                      *ptr++ = name[c];
                      *ptr++ = name[d];
                      *ptr++ = name[e];
                      *ptr++ = name[f];
                      *ptr++ = name[g];
                      *ptr++ = name[h];
                      *ptr++ = '/';
                      *ptr++ = name[xb];
                      *ptr++ = name[xg];
                      sprintf(ptr, "%5d",
                              Edge_Table[xg][xb][h][g][f][e][d][c][b][a]);
                      ptr += 5;
                      *ptr++ = '\n';
                    }
  if (ptr != base + (3 * 3 * 3 * 3 * 3 * 3 * 3 * 3 * 3 * 3 * 17))
    quit(-1, "Arg!\n");
  fputs("Writing...\n", stderr);
  write(1, base, (3 * 3 * 3 * 3 * 3 * 3 * 3 * 3 * 3 * 3 * 17));
  fputs("Done.\n", stderr);
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
movl   $0x0,-0x4(%rbp)
mov    0x2e72(%rip),%rax
mov    (%rax),%esi
lea    0xe91(%rip),%rdi
call   1050 <fputs@plt>
mov    $0xf5139,%edi
mov    $0x0,%al
call   1060 <sbrk@plt>
mov    %rax,-0x10(%rbp)
mov    %rax,-0x18(%rbp)
movl   $0x0,-0x1c(%rbp)
cmpl   $0x2,-0x1c(%rbp)
jg     14d2 <main+0x382>
movl   $0x0,-0x20(%rbp)
cmpl   $0x2,-0x20(%rbp)
jg     14bf <main+0x36f>
movl   $0x0,-0x24(%rbp)
cmpl   $0x2,-0x24(%rbp)
jg     14ac <main+0x35c>
movl   $0x0,-0x28(%rbp)
cmpl   $0x2,-0x28(%rbp)
jg     1499 <main+0x349>
movl   $0x0,-0x2c(%rbp)
cmpl   $0x2,-0x2c(%rbp)
jg     1486 <main+0x336>
movl   $0x0,-0x30(%rbp)
cmpl   $0x2,-0x30(%rbp)
jg     1473 <main+0x323>
movl   $0x0,-0x34(%rbp)
cmpl   $0x2,-0x34(%rbp)
jg     1460 <main+0x310>
movl   $0x0,-0x38(%rbp)
cmpl   $0x2,-0x38(%rbp)
jg     144d <main+0x2fd>
movl   $0x0,-0x3c(%rbp)
cmpl   $0x2,-0x3c(%rbp)
jg     143a <main+0x2ea>
movl   $0x0,-0x40(%rbp)
cmpl   $0x2,-0x40(%rbp)
jg     1427 <main+0x2d7>
lea    0xdd4(%rip),%rax
mov    %rax,-0x48(%rbp)
mov    -0x48(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x18(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x18(%rbp)
mov    %cl,(%rax)
mov    -0x48(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x18(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x18(%rbp)
mov    %cl,(%rax)
mov    -0x48(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x18(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x18(%rbp)
mov    %cl,(%rax)
mov    -0x48(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x18(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x18(%rbp)
mov    %cl,(%rax)
mov    -0x48(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x18(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x18(%rbp)
mov    %cl,(%rax)
mov    -0x48(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x18(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x18(%rbp)
mov    %cl,(%rax)
mov    -0x48(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x18(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x18(%rbp)
mov    %cl,(%rax)
mov    -0x48(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x18(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x18(%rbp)
mov    %cl,(%rax)
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x18(%rbp)
movb   $0x2f,(%rax)
mov    -0x48(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x18(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x18(%rbp)
mov    %cl,(%rax)
mov    -0x48(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x18(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x18(%rbp)
mov    %cl,(%rax)
mov    -0x18(%rbp),%rdi
movslq -0x1c(%rbp),%rcx
mov    0x2c82(%rip),%rax
imul   $0x99c6,%rcx,%rcx
add    %rcx,%rax
movslq -0x20(%rbp),%rcx
imul   $0x3342,%rcx,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
imul   $0x1116,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
imul   $0x5b2,%rcx,%rcx
add    %rcx,%rax
movslq -0x2c(%rbp),%rcx
imul   $0x1e6,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
imul   $0xa2,%rcx,%rcx
add    %rcx,%rax
movslq -0x34(%rbp),%rcx
imul   $0x36,%rcx,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
imul   $0x12,%rcx,%rcx
add    %rcx,%rax
movslq -0x3c(%rbp),%rcx
imul   $0x6,%rcx,%rcx
add    %rcx,%rax
movslq -0x40(%rbp),%rcx
lea    0xc1f(%rip),%rsi
movswl (%rax,%rcx,2),%edx
call   1070 <sprintf@plt>
mov    -0x18(%rbp),%rax
add    $0x5,%rax
mov    %rax,-0x18(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x18(%rbp)
movb   $0xa,(%rax)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1228 <main+0xd8>
jmp    142c <main+0x2dc>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1217 <main+0xc7>
jmp    143f <main+0x2ef>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1206 <main+0xb6>
jmp    1452 <main+0x302>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    11f5 <main+0xa5>
jmp    1465 <main+0x315>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    11e4 <main+0x94>
jmp    1478 <main+0x328>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    11d3 <main+0x83>
jmp    148b <main+0x33b>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    11c2 <main+0x72>
jmp    149e <main+0x34e>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    11b1 <main+0x61>
jmp    14b1 <main+0x361>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    11a0 <main+0x50>
jmp    14c4 <main+0x374>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    118f <main+0x3f>
mov    -0x18(%rbp),%rax
mov    -0x10(%rbp),%rcx
add    $0xf5139,%rcx
cmp    %rcx,%rax
je     14fb <main+0x3ab>
mov    $0xffffffff,%edi
lea    0xb1f(%rip),%rsi
call   1040 <quit@plt>
mov    0x2ad6(%rip),%rax
mov    (%rax),%esi
lea    0xb10(%rip),%rdi
call   1050 <fputs@plt>
mov    -0x10(%rbp),%rsi
mov    $0x1,%edi
mov    $0xf5139,%edx
call   1030 <write@plt>
mov    0x2aae(%rip),%rax
mov    (%rax),%esi
lea    0xaf4(%rip),%rdi
call   1050 <fputs@plt>
mov    -0x4(%rbp),%eax
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xa8,%rsp
mov    0x2e70(%rip),%rax
mov    (%rax),%esi
lea    0xe8f(%rip),%rdi
call   1050 <fputs@plt>
xor    %r14d,%r14d
mov    $0xf5139,%edi
xor    %eax,%eax
call   1060 <sbrk@plt>
mov    %rax,0x18(%rsp)
mov    0x2e67(%rip),%rcx
add    $0x4,%rcx
lea    0xe75(%rip),%r12
xor    %r15d,%r15d
nop
mov    %r14,0x28(%rsp)
lea    0xe61(%rip),%rdx
mov    (%r14,%rdx,1),%r8b
mov    %rcx,0x20(%rsp)
mov    %rcx,%rsi
xor    %edx,%edx
mov    %r8b,0x12(%rsp)
nop
lea    0xe46(%rip),%rcx
mov    %rdx,0x30(%rsp)
mov    (%rdx,%rcx,1),%r9b
mov    %rsi,0x38(%rsp)
xor    %edx,%edx
mov    %r9b,0x11(%rsp)
nopl   0x0(%rax)
lea    0xe26(%rip),%rcx
mov    %rdx,0x40(%rsp)
mov    (%rdx,%rcx,1),%r10b
mov    %rsi,0x48(%rsp)
xor    %edx,%edx
mov    %r10b,0x10(%rsp)
nopl   0x0(%rax)
lea    0xe06(%rip),%rcx
mov    %rdx,0x50(%rsp)
mov    (%rdx,%rcx,1),%r11b
mov    %rsi,0x58(%rsp)
mov    %rsi,%rdx
xor    %esi,%esi
mov    %r11b,0xf(%rsp)
nop
lea    0xde6(%rip),%rcx
mov    %rsi,0x60(%rsp)
mov    (%rsi,%rcx,1),%sil
mov    %rdx,0x68(%rsp)
mov    %rdx,%r14
xor    %edx,%edx
mov    %sil,0x13(%rsp)
nop
lea    0xdc6(%rip),%rcx
mov    %rdx,0x70(%rsp)
mov    (%rdx,%rcx,1),%dl
mov    %r14,0x78(%rsp)
xor    %ebx,%ebx
mov    %dl,0x14(%rsp)
nopw   0x0(%rax,%rax,1)
lea    0xda6(%rip),%rcx
mov    %rbx,0x80(%rsp)
mov    (%rbx,%rcx,1),%cl
mov    %r14,0x88(%rsp)
mov    %r14,%rbx
xor    %eax,%eax
mov    %cl,0x15(%rsp)
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %r15,%rdi
lea    0xd73(%rip),%r15
mov    %rax,0x90(%rsp)
mov    (%rax,%r15,1),%al
mov    %al,0x16(%rsp)
mov    0x18(%rsp),%rax
mov    %rdi,0xa0(%rsp)
lea    (%rax,%rdi,1),%r14
xor    %ebp,%ebp
mov    %rbx,0x98(%rsp)
cs nopw 0x0(%rax,%rax,1)
nop
movzbl (%r15),%r13d
movb   $0x42,(%r14,%rbp,1)
mov    %r13b,0x1(%r14,%rbp,1)
mov    %r13b,0x17(%rsp)
movzbl 0x16(%rsp),%eax
mov    %al,0x2(%r14,%rbp,1)
mov    %cl,0x3(%r14,%rbp,1)
mov    %dl,0x4(%r14,%rbp,1)
mov    %sil,0x5(%r14,%rbp,1)
mov    %r11b,0x6(%r14,%rbp,1)
mov    %r10b,0x7(%r14,%rbp,1)
movb   $0x2f,0x8(%r14,%rbp,1)
mov    %r9b,0x9(%r14,%rbp,1)
lea    0xb(%r14,%rbp,1),%rdi
mov    %r8b,0xa(%r14,%rbp,1)
movswl -0x4(%rbx),%edx
mov    %r12,%rsi
call   1070 <sprintf@plt>
movw   $0x570a,0x10(%r14,%rbp,1)
57
mov    %r13b,0x12(%r14,%rbp,1)
movzbl 0x16(%rsp),%r13d
mov    %r13b,0x13(%r14,%rbp,1)
movzbl 0x15(%rsp),%eax
mov    %al,0x14(%r14,%rbp,1)
movzbl 0x14(%rsp),%eax
mov    %al,0x15(%r14,%rbp,1)
movzbl 0x13(%rsp),%eax
mov    %al,0x16(%r14,%rbp,1)
movzbl 0xf(%rsp),%eax
mov    %al,0x17(%r14,%rbp,1)
movzbl 0x10(%rsp),%eax
mov    %al,0x18(%r14,%rbp,1)
movb   $0x2f,0x19(%r14,%rbp,1)
movzbl 0x11(%rsp),%eax
mov    %al,0x1a(%r14,%rbp,1)
lea    0x1c(%r14,%rbp,1),%rdi
movzbl 0x12(%rsp),%eax
mov    %al,0x1b(%r14,%rbp,1)
movswl -0x2(%rbx),%edx
mov    %r12,%rsi
call   1070 <sprintf@plt>
movw   $0x2e0a,0x21(%r14,%rbp,1)
2e
movzbl 0x17(%rsp),%eax
mov    %al,0x23(%r14,%rbp,1)
mov    %r13b,0x24(%r14,%rbp,1)
movzbl 0x15(%rsp),%eax
mov    %al,0x25(%r14,%rbp,1)
movzbl 0x14(%rsp),%eax
mov    %al,0x26(%r14,%rbp,1)
movzbl 0x13(%rsp),%eax
mov    %al,0x27(%r14,%rbp,1)
movzbl 0xf(%rsp),%eax
mov    %al,0x28(%r14,%rbp,1)
movzbl 0x10(%rsp),%eax
mov    %al,0x29(%r14,%rbp,1)
movb   $0x2f,0x2a(%r14,%rbp,1)
movzbl 0x11(%rsp),%eax
mov    %al,0x2b(%r14,%rbp,1)
lea    0x2d(%r14,%rbp,1),%rdi
movzbl 0x12(%rsp),%eax
mov    %al,0x2c(%r14,%rbp,1)
movswl (%rbx),%edx
mov    %r12,%rsi
call   1070 <sprintf@plt>
movzbl 0x15(%rsp),%ecx
movzbl 0x14(%rsp),%edx
movzbl 0x13(%rsp),%esi
movzbl 0xf(%rsp),%r11d
movzbl 0x10(%rsp),%r10d
movzbl 0x11(%rsp),%r9d
movzbl 0x12(%rsp),%r8d
movb   $0xa,0x32(%r14,%rbp,1)
add    $0x1,%r15
add    $0x6,%rbx
add    $0x33,%rbp
cmp    $0x99,%rbp
jne    12d0 <main+0x180>
mov    0x90(%rsp),%rax
add    $0x1,%rax
mov    0x98(%rsp),%rbx
add    $0x12,%rbx
mov    0xa0(%rsp),%rdi
lea    (%rdi,%rbp,1),%r15
cmp    $0x3,%rax
jne    1290 <main+0x140>
mov    0x80(%rsp),%rbx
add    $0x1,%rbx
mov    0x88(%rsp),%r14
add    $0x36,%r14
lea    (%rdi,%rbp,1),%r15
cmp    $0x3,%rbx
jne    1260 <main+0x110>
mov    0x70(%rsp),%rdx
add    $0x1,%rdx
mov    0x78(%rsp),%r14
add    $0xa2,%r14
lea    (%rdi,%rbp,1),%r15
cmp    $0x3,%rdx
jne    1240 <main+0xf0>
mov    0x60(%rsp),%rsi
add    $0x1,%rsi
mov    0x68(%rsp),%rdx
add    $0x1e6,%rdx
lea    (%rdi,%rbp,1),%r15
cmp    $0x3,%rsi
jne    1220 <main+0xd0>
mov    0x50(%rsp),%rdx
add    $0x1,%rdx
mov    0x58(%rsp),%rsi
add    $0x5b2,%rsi
lea    (%rdi,%rbp,1),%r15
cmp    $0x3,%rdx
jne    1200 <main+0xb0>
mov    0x40(%rsp),%rdx
add    $0x1,%rdx
mov    0x48(%rsp),%rsi
add    $0x1116,%rsi
lea    (%rdi,%rbp,1),%r15
cmp    $0x3,%rdx
jne    11e0 <main+0x90>
mov    0x30(%rsp),%rdx
add    $0x1,%rdx
mov    0x38(%rsp),%rsi
add    $0x3342,%rsi
lea    (%rdi,%rbp,1),%r15
cmp    $0x3,%rdx
jne    11c0 <main+0x70>
mov    0x28(%rsp),%r14
add    $0x1,%r14
mov    0x20(%rsp),%rcx
add    $0x99c6,%rcx
lea    (%rdi,%rbp,1),%r15
cmp    $0x3,%r14
jne    11a0 <main+0x50>
add    %rbp,%rdi
cmp    $0xf5139,%rdi
je     1598 <main+0x448>
lea    0xa87(%rip),%rsi
mov    $0xffffffff,%edi
call   1040 <quit@plt>
mov    0x2a39(%rip),%rbx
mov    (%rbx),%esi
lea    0xa73(%rip),%rdi
call   1050 <fputs@plt>
mov    $0x1,%edi
mov    0x18(%rsp),%rsi
mov    $0xf5139,%edx
call   1030 <write@plt>
mov    (%rbx),%esi
lea    0xa5d(%rip),%rdi
call   1050 <fputs@plt>
xor    %eax,%eax
add    $0xa8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
@.str = [13 x i8] c"Starting...\0A\00"
@stderr = global i32 0
@.str.1 = [4 x i8] c"BW.\00"
@.str.2 = [4 x i8] c"%5d\00"
@Edge_Table = external global [3 x [3 x [3 x [3 x [3 x [3 x [3 x [3 x [3 x [3 x i16]]]]]]]]]]
@.str.3 = [6 x i8] c"Arg!\0A\00"
@.str.4 = [12 x i8] c"Writing...\0A\00"
@.str.5 = [7 x i8] c"Done.\0A\00"
@a = global i32 0
@b = global i32 0
define i32 @main() {
%1 = load i32, i32* @stderr
%2 = tail call i32 @fputs(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str, i64 0, i64 0), i32 %1)
%3 = tail call i8* (i32, ...) bitcast (i8* (...)* @sbrk to i8* (i32, ...)*)(i32 1003833)
br label %4
4: ; preds = %0, %159
%5 = phi i64 [ 0, %0 ], [ %160, %159 ]
%6 = phi i64 [ 0, %0 ], [ %135, %159 ]
%7 = getelementptr inbounds [4 x i8], [4 x i8]* @.str.1, i64 0, i64 %5
%8 = load i8, i8* %7
br label %9
9: ; preds = %4, %156
%10 = phi i64 [ 0, %4 ], [ %157, %156 ]
%11 = phi i64 [ %6, %4 ], [ %135, %156 ]
%12 = getelementptr inbounds [4 x i8], [4 x i8]* @.str.1, i64 0, i64 %10
%13 = load i8, i8* %12
br label %14
14: ; preds = %9, %153
%15 = phi i64 [ 0, %9 ], [ %154, %153 ]
%16 = phi i64 [ %11, %9 ], [ %135, %153 ]
%17 = getelementptr inbounds [4 x i8], [4 x i8]* @.str.1, i64 0, i64 %15
%18 = load i8, i8* %17
br label %19
19: ; preds = %14, %150
%20 = phi i64 [ 0, %14 ], [ %151, %150 ]
%21 = phi i64 [ %16, %14 ], [ %135, %150 ]
%22 = getelementptr inbounds [4 x i8], [4 x i8]* @.str.1, i64 0, i64 %20
%23 = load i8, i8* %22
br label %24
24: ; preds = %19, %147
%25 = phi i64 [ 0, %19 ], [ %148, %147 ]
%26 = phi i64 [ %21, %19 ], [ %135, %147 ]
%27 = getelementptr inbounds [4 x i8], [4 x i8]* @.str.1, i64 0, i64 %25
%28 = load i8, i8* %27
br label %29
29: ; preds = %24, %144
%30 = phi i64 [ 0, %24 ], [ %145, %144 ]
%31 = phi i64 [ %26, %24 ], [ %135, %144 ]
%32 = getelementptr inbounds [4 x i8], [4 x i8]* @.str.1, i64 0, i64 %30
%33 = load i8, i8* %32
br label %34
34: ; preds = %29, %141
%35 = phi i64 [ 0, %29 ], [ %142, %141 ]
%36 = phi i64 [ %31, %29 ], [ %135, %141 ]
%37 = getelementptr inbounds [4 x i8], [4 x i8]* @.str.1, i64 0, i64 %35
%38 = load i8, i8* %37
br label %39
39: ; preds = %34, %138
%40 = phi i64 [ 0, %34 ], [ %139, %138 ]
%41 = phi i64 [ %36, %34 ], [ %135, %138 ]
%42 = getelementptr inbounds [4 x i8], [4 x i8]* @.str.1, i64 0, i64 %40
%43 = load i8, i8* %42
br label %44
44: ; preds = %39, %44
%45 = phi i64 [ 0, %39 ], [ %136, %44 ]
%46 = phi i64 [ %41, %39 ], [ %135, %44 ]
%47 = getelementptr inbounds [4 x i8], [4 x i8]* @.str.1, i64 0, i64 %45
%48 = load i8, i8* %47
%49 = getelementptr inbounds i8, i8* %3, i64 %46
%50 = add nsw i64 %46, 1
%51 = getelementptr inbounds i8, i8* %3, i64 %50
store i8 66, i8* %49
%52 = add nsw i64 %46, 2
%53 = getelementptr inbounds i8, i8* %3, i64 %52
store i8 %48, i8* %51
%54 = add nsw i64 %46, 3
%55 = getelementptr inbounds i8, i8* %3, i64 %54
store i8 %43, i8* %53
%56 = add nsw i64 %46, 4
%57 = getelementptr inbounds i8, i8* %3, i64 %56
store i8 %38, i8* %55
%58 = add nsw i64 %46, 5
%59 = getelementptr inbounds i8, i8* %3, i64 %58
store i8 %33, i8* %57
%60 = add nsw i64 %46, 6
%61 = getelementptr inbounds i8, i8* %3, i64 %60
store i8 %28, i8* %59
%62 = add nsw i64 %46, 7
%63 = getelementptr inbounds i8, i8* %3, i64 %62
store i8 %23, i8* %61
%64 = add nsw i64 %46, 8
%65 = getelementptr inbounds i8, i8* %3, i64 %64
store i8 %18, i8* %63
%66 = add nsw i64 %46, 9
%67 = getelementptr inbounds i8, i8* %3, i64 %66
store i8 47, i8* %65
%68 = add nsw i64 %46, 10
%69 = getelementptr inbounds i8, i8* %3, i64 %68
store i8 %13, i8* %67
%70 = add nsw i64 %46, 11
%71 = getelementptr inbounds i8, i8* %3, i64 %70
store i8 %8, i8* %69
%72 = getelementptr inbounds [3 x [3 x [3 x [3 x [3 x [3 x [3 x [3 x [3 x [3 x i16]]]]]]]]]], [3 x [3 x [3 x [3 x [3 x [3 x [3 x [3 x [3 x [3 x i16]]]]]]]]]]* @Edge_Table, i64 0, i64 %5, i64 %10, i64 %15, i64 %20, i64 %25, i64 %30, i64 %35, i64 %40, i64 %45, i64 0
%73 = load i16, i16* %72
%74 = tail call i32 @sprintf(i8* dereferenceable(1) %71, i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0), i16 signext %73)
%75 = add nsw i64 %46, 16
%76 = getelementptr inbounds i8, i8* %3, i64 %75
%77 = add nsw i64 %46, 17
store i8 10, i8* %76
%78 = getelementptr inbounds i8, i8* %3, i64 %77
%79 = add nsw i64 %46, 18
%80 = getelementptr inbounds i8, i8* %3, i64 %79
store i8 87, i8* %78
%81 = add nsw i64 %46, 19
%82 = getelementptr inbounds i8, i8* %3, i64 %81
store i8 %48, i8* %80
%83 = add nsw i64 %46, 20
%84 = getelementptr inbounds i8, i8* %3, i64 %83
store i8 %43, i8* %82
%85 = add nsw i64 %46, 21
%86 = getelementptr inbounds i8, i8* %3, i64 %85
store i8 %38, i8* %84
%87 = add nsw i64 %46, 22
%88 = getelementptr inbounds i8, i8* %3, i64 %87
store i8 %33, i8* %86
%89 = add nsw i64 %46, 23
%90 = getelementptr inbounds i8, i8* %3, i64 %89
store i8 %28, i8* %88
%91 = add nsw i64 %46, 24
%92 = getelementptr inbounds i8, i8* %3, i64 %91
store i8 %23, i8* %90
%93 = add nsw i64 %46, 25
%94 = getelementptr inbounds i8, i8* %3, i64 %93
store i8 %18, i8* %92
%95 = add nsw i64 %46, 26
%96 = getelementptr inbounds i8, i8* %3, i64 %95
store i8 47, i8* %94
%97 = add nsw i64 %46, 27
%98 = getelementptr inbounds i8, i8* %3, i64 %97
store i8 %13, i8* %96
%99 = add nsw i64 %46, 28
%100 = getelementptr inbounds i8, i8* %3, i64 %99
store i8 %8, i8* %98
%101 = getelementptr inbounds [3 x [3 x [3 x [3 x [3 x [3 x [3 x [3 x [3 x [3 x i16]]]]]]]]]], [3 x [3 x [3 x [3 x [3 x [3 x [3 x [3 x [3 x [3 x i16]]]]]]]]]]* @Edge_Table, i64 0, i64 %5, i64 %10, i64 %15, i64 %20, i64 %25, i64 %30, i64 %35, i64 %40, i64 %45, i64 1
%102 = load i16, i16* %101
%103 = tail call i32 @sprintf(i8* dereferenceable(1) %100, i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0), i16 signext %102)
%104 = add nsw i64 %46, 33
%105 = getelementptr inbounds i8, i8* %3, i64 %104
%106 = add nsw i64 %46, 34
store i8 10, i8* %105
%107 = getelementptr inbounds i8, i8* %3, i64 %106
%108 = add nsw i64 %46, 35
%109 = getelementptr inbounds i8, i8* %3, i64 %108
store i8 46, i8* %107
%110 = add nsw i64 %46, 36
%111 = getelementptr inbounds i8, i8* %3, i64 %110
store i8 %48, i8* %109
%112 = add nsw i64 %46, 37
%113 = getelementptr inbounds i8, i8* %3, i64 %112
store i8 %43, i8* %111
%114 = add nsw i64 %46, 38
%115 = getelementptr inbounds i8, i8* %3, i64 %114
store i8 %38, i8* %113
%116 = add nsw i64 %46, 39
%117 = getelementptr inbounds i8, i8* %3, i64 %116
store i8 %33, i8* %115
%118 = add nsw i64 %46, 40
%119 = getelementptr inbounds i8, i8* %3, i64 %118
store i8 %28, i8* %117
%120 = add nsw i64 %46, 41
%121 = getelementptr inbounds i8, i8* %3, i64 %120
store i8 %23, i8* %119
%122 = add nsw i64 %46, 42
%123 = getelementptr inbounds i8, i8* %3, i64 %122
store i8 %18, i8* %121
%124 = add nsw i64 %46, 43
%125 = getelementptr inbounds i8, i8* %3, i64 %124
store i8 47, i8* %123
%126 = add nsw i64 %46, 44
%127 = getelementptr inbounds i8, i8* %3, i64 %126
store i8 %13, i8* %125
%128 = add nsw i64 %46, 45
%129 = getelementptr inbounds i8, i8* %3, i64 %128
store i8 %8, i8* %127
%130 = getelementptr inbounds [3 x [3 x [3 x [3 x [3 x [3 x [3 x [3 x [3 x [3 x i16]]]]]]]]]], [3 x [3 x [3 x [3 x [3 x [3 x [3 x [3 x [3 x [3 x i16]]]]]]]]]]* @Edge_Table, i64 0, i64 %5, i64 %10, i64 %15, i64 %20, i64 %25, i64 %30, i64 %35, i64 %40, i64 %45, i64 2
%131 = load i16, i16* %130
%132 = tail call i32 @sprintf(i8* dereferenceable(1) %129, i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0), i16 signext %131)
%133 = add nsw i64 %46, 50
%134 = getelementptr inbounds i8, i8* %3, i64 %133
%135 = add nsw i64 %46, 51
store i8 10, i8* %134
%136 = add nuw nsw i64 %45, 1
%137 = icmp eq i64 %136, 3
br i1 %137, label %138, label %44
138: ; preds = %44
%139 = add nuw nsw i64 %40, 1
%140 = icmp eq i64 %139, 3
br i1 %140, label %141, label %39
141: ; preds = %138
%142 = add nuw nsw i64 %35, 1
%143 = icmp eq i64 %142, 3
br i1 %143, label %144, label %34
144: ; preds = %141
%145 = add nuw nsw i64 %30, 1
%146 = icmp eq i64 %145, 3
br i1 %146, label %147, label %29
147: ; preds = %144
%148 = add nuw nsw i64 %25, 1
%149 = icmp eq i64 %148, 3
br i1 %149, label %150, label %24
150: ; preds = %147
%151 = add nuw nsw i64 %20, 1
%152 = icmp eq i64 %151, 3
br i1 %152, label %153, label %19
153: ; preds = %150
%154 = add nuw nsw i64 %15, 1
%155 = icmp eq i64 %154, 3
br i1 %155, label %156, label %14
156: ; preds = %153
%157 = add nuw nsw i64 %10, 1
%158 = icmp eq i64 %157, 3
br i1 %158, label %159, label %9
159: ; preds = %156
%160 = add nuw nsw i64 %5, 1
%161 = icmp eq i64 %160, 3
br i1 %161, label %162, label %4
162: ; preds = %159
%163 = icmp eq i64 %135, 1003833
br i1 %163, label %166, label %164
164: ; preds = %162
%165 = tail call i32 @quit(i32 -1, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.3, i64 0, i64 0))
br label %166
166: ; preds = %164, %162
%167 = load i32, i32* @stderr
%168 = tail call i32 @fputs(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.4, i64 0, i64 0), i32 %167)
%169 = tail call i32 @write(i32 1, i8* %3, i32 1003833)
%170 = load i32, i32* @stderr
%171 = tail call i32 @fputs(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.5, i64 0, i64 0), i32 %170)
ret i32 0
}