#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*/ printf(char *, ...);
int main() {
  int i = 0, j = 0;
  int count = 1;
  int arr[11][11] = {0};
  int s;
  int n = 11;
  for (s = 0; s <= n / 2 + 1; s++) {
    for (j; j < n - s - 1; j++) {
      arr[i][j] = count++;
    }
    printf("%d %d\n", i, j);
    for (i; i < n - s - 1; i++) {
      arr[i][j] = count++;
    }
    printf("%d %d\n", i, j);
    for (j; j > s; j--) {
      arr[i][j] = count++;
    }
    printf("%d %d\n", i, j);
    for (i; i > s + 1; i--) {
      arr[i][j] = count++;
    }
    printf("%d %d\n", i, j);
  }
  arr[i][j] = 11 * 11;
  for (i = 0; i < 11; i++) {
    for (j = 0; j < 11; j++) {
      if (arr[i][j] != 0) {
        printf("%4d", arr[i][j]);
      } else
        printf("    ");
    }
    printf("\n");
  }
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x210,%rsp
movl   $0x0,-0x4(%rbp)
movl   $0x0,-0x8(%rbp)
movl   $0x0,-0xc(%rbp)
movl   $0x1,-0x10(%rbp)
lea    -0x200(%rbp),%rdi
xor    %esi,%esi
mov    $0x1e4,%edx
call   1040 <memset@plt>
movl   $0xb,-0x208(%rbp)
movl   $0x0,-0x204(%rbp)
mov    -0x204(%rbp),%eax
mov    %eax,-0x20c(%rbp)
mov    -0x208(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x20c(%rbp),%eax
add    $0x1,%ecx
cmp    %ecx,%eax
jg     131e <main+0x1fe>
mov    -0xc(%rbp),%eax
mov    -0x208(%rbp),%ecx
sub    -0x204(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    11e7 <main+0xc7>
mov    -0x10(%rbp),%edx
mov    %edx,%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
movslq -0x8(%rbp),%rcx
lea    -0x200(%rbp),%rax
imul   $0x2c,%rcx,%rcx
add    %rcx,%rax
movslq -0xc(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    119b <main+0x7b>
mov    -0x8(%rbp),%esi
mov    -0xc(%rbp),%edx
lea    0xe0c(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x8(%rbp),%eax
mov    -0x208(%rbp),%ecx
sub    -0x204(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1247 <main+0x127>
mov    -0x10(%rbp),%edx
mov    %edx,%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
movslq -0x8(%rbp),%rcx
lea    -0x200(%rbp),%rax
imul   $0x2c,%rcx,%rcx
add    %rcx,%rax
movslq -0xc(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    11fb <main+0xdb>
mov    -0x8(%rbp),%esi
mov    -0xc(%rbp),%edx
lea    0xdac(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0xc(%rbp),%eax
cmp    -0x204(%rbp),%eax
jle    129c <main+0x17c>
mov    -0x10(%rbp),%edx
mov    %edx,%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
movslq -0x8(%rbp),%rcx
lea    -0x200(%rbp),%rax
imul   $0x2c,%rcx,%rcx
add    %rcx,%rax
movslq -0xc(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0xc(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xc(%rbp)
jmp    125b <main+0x13b>
mov    -0x8(%rbp),%esi
mov    -0xc(%rbp),%edx
lea    0xd57(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x8(%rbp),%eax
mov    -0x204(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jle    12f6 <main+0x1d6>
mov    -0x10(%rbp),%edx
mov    %edx,%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
movslq -0x8(%rbp),%rcx
lea    -0x200(%rbp),%rax
imul   $0x2c,%rcx,%rcx
add    %rcx,%rax
movslq -0xc(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x8(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x8(%rbp)
jmp    12b0 <main+0x190>
mov    -0x8(%rbp),%esi
mov    -0xc(%rbp),%edx
lea    0xcfd(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x204(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x204(%rbp)
jmp    116e <main+0x4e>
movslq -0x8(%rbp),%rcx
lea    -0x200(%rbp),%rax
imul   $0x2c,%rcx,%rcx
add    %rcx,%rax
movslq -0xc(%rbp),%rcx
movl   $0x79,(%rax,%rcx,4)
movl   $0x0,-0x8(%rbp)
cmpl   $0xb,-0x8(%rbp)
jge    13e6 <main+0x2c6>
movl   $0x0,-0xc(%rbp)
cmpl   $0xb,-0xc(%rbp)
jge    13ca <main+0x2aa>
movslq -0x8(%rbp),%rcx
lea    -0x200(%rbp),%rax
imul   $0x2c,%rcx,%rcx
add    %rcx,%rax
movslq -0xc(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     13a9 <main+0x289>
movslq -0x8(%rbp),%rcx
lea    -0x200(%rbp),%rax
imul   $0x2c,%rcx,%rcx
add    %rcx,%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
lea    0xc6a(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    13b7 <main+0x297>
lea    0xc5b(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    13bc <main+0x29c>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1353 <main+0x233>
lea    0xc34(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1342 <main+0x222>
xor    %eax,%eax
add    $0x210,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x208,%rsp
lea    0x20(%rsp),%rdi
mov    $0x1e4,%edx
xor    %esi,%esi
call   1050 <memset@plt>
mov    $0x1,%r15d
mov    $0xa,%eax
mov    %rax,0x10(%rsp)
movdqa 0xea6(%rip),%xmm3
movdqa 0xeae(%rip),%xmm4
movdqa 0xeb6(%rip),%xmm5
movdqa 0xebe(%rip),%xmm6
xor    %eax,%eax
mov    %rax,0x18(%rsp)
xor    %r12d,%r12d
xor    %ebx,%ebx
xor    %r14d,%r14d
jmp    11e5 <main+0xb5>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %r13,%rdi
mov    %ebx,%esi
mov    %r14d,%edx
xor    %eax,%eax
call   1040 <printf@plt>
addq   $0xffffffffffffffff,0x10(%rsp)
addq   $0xffffffffffffffff,0x18(%rsp)
cmp    $0x7,%r12
movdqa 0xe49(%rip),%xmm3
movdqa 0xe51(%rip),%xmm4
movdqa 0xe59(%rip),%xmm5
movdqa 0xe61(%rip),%xmm6
je     15ec <main+0x4bc>
mov    $0xa,%ebp
sub    %r12,%rbp
movslq %r14d,%rax
movslq %ebx,%r13
cmp    %rax,%rbp
mov    %rbx,0x8(%rsp)
jle    1324 <main+0x1f4>
mov    $0xa,%ecx
sub    %r12,%rcx
sub    %rax,%rcx
cmp    $0x8,%rcx
jb     12fb <main+0x1cb>
mov    %rcx,%r8
and    $0xfffffffffffffff8,%r8
movd   %r15d,%xmm0
pshufd $0x0,%xmm0,%xmm0
paddd  0xdd1(%rip),%xmm0
lea    -0x8(%r8),%rdx
mov    %rdx,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
test   %rdx,%rdx
je     15cb <main+0x49b>
lea    0x0(,%r13,4),%rdx
add    %r13,%rdx
lea    0x0(,%rdx,2),%rdx
add    %r13,%rdx
add    %rax,%rdx
lea    0x20(%rsp),%rdi
lea    (%rdi,%rdx,4),%rbx
add    $0x30,%rbx
mov    0x10(%rsp),%rdx
sub    %rax,%rdx
and    $0xfffffffffffffff8,%rdx
add    $0xfffffffffffffff8,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
and    $0xfffffffffffffffe,%rdx
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
movdqa %xmm0,%xmm1
paddd  %xmm3,%xmm1
movdqu %xmm0,-0x30(%rbx,%rdi,4)
movdqu %xmm1,-0x20(%rbx,%rdi,4)
movdqa %xmm0,%xmm1
paddd  %xmm4,%xmm1
movdqa %xmm0,%xmm2
paddd  %xmm5,%xmm2
movdqu %xmm1,-0x10(%rbx,%rdi,4)
movdqu %xmm2,(%rbx,%rdi,4)
add    $0x10,%rdi
paddd  %xmm6,%xmm0
add    $0xfffffffffffffffe,%rdx
jne    1290 <main+0x160>
test   $0x1,%sil
je     12f0 <main+0x1c0>
add    %rax,%rdi
imul   $0x2c,%r13,%rdx
add    %rsp,%rdx
add    $0x20,%rdx
movdqu %xmm0,(%rdx,%rdi,4)
paddd  %xmm3,%xmm0
movdqu %xmm0,0x10(%rdx,%rdi,4)
add    %r8,%rax
add    %r8d,%r15d
cmp    %r8,%rcx
je     1321 <main+0x1f1>
imul   $0x2c,%r13,%rcx
add    %rsp,%rcx
add    $0x20,%rcx
cs nopw 0x0(%rax,%rax,1)
mov    %r15d,(%rcx,%rax,4)
add    $0x1,%r15d
add    $0x1,%rax
cmp    %rbp,%rax
jl     1310 <main+0x1e0>
mov    %eax,%r14d
lea    0xd25(%rip),%rdi
mov    %r13d,%esi
mov    %r14d,%edx
xor    %eax,%eax
call   1040 <printf@plt>
movslq %r14d,%rbx
cmp    %r13,%rbp
jle    13f3 <main+0x2c3>
lea    (%r12,%r13,1),%rax
mov    $0x2,%ecx
sub    %eax,%ecx
test   $0x3,%cl
je     139e <main+0x26e>
imul   $0x2c,%r13,%rcx
add    %rsp,%rcx
add    $0x20,%rcx
lea    (%rcx,%rbx,4),%rcx
mov    0x10(%rsp),%rdx
sub    %r13b,%dl
movzbl %dl,%edx
and    $0x3,%edx
neg    %rdx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
mov    %r15d,(%rcx)
add    $0x1,%r15d
add    $0xffffffffffffffff,%rsi
add    $0x2c,%rcx
cmp    %rsi,%rdx
jne    1380 <main+0x250>
sub    %rsi,%r13
mov    %r13,0x8(%rsp)
jmp    139e <main+0x26e>
add    $0xfffffffffffffff9,%rax
cmp    $0x3,%rax
jb     13f3 <main+0x2c3>
imul   $0x2c,%r13,%rax
add    %rsp,%rax
add    $0x20,%rax
lea    (%rax,%rbx,4),%rax
nopw   0x0(%rax,%rax,1)
mov    %r15d,%ecx
mov    %r15d,(%rax)
lea    0x1(%rcx),%edx
mov    %edx,0x2c(%rax)
lea    0x2(%rcx),%edx
mov    %edx,0x58(%rax)
lea    0x4(%rcx),%r15d
add    $0x3,%ecx
mov    %ecx,0x84(%rax)
add    $0x4,%r13
add    $0xb0,%rax
cmp    %rbp,%r13
jl     13c0 <main+0x290>
mov    %r13,0x8(%rsp)
lea    0xc56(%rip),%r13
mov    %r13,%rdi
mov    0x8(%rsp),%rbp
mov    %ebp,%esi
mov    %ebx,%edx
xor    %eax,%eax
call   1040 <printf@plt>
movslq %ebp,%rbp
cmp    %rbx,%r12
jge    1574 <main+0x444>
mov    %rbx,%rax
sub    %r12,%rax
cmp    $0x8,%rax
jb     154f <main+0x41f>
mov    %rax,%r8
and    $0xfffffffffffffff8,%r8
movd   %r15d,%xmm0
pshufd $0x0,%xmm0,%xmm0
paddd  0xbbe(%rip),%xmm0
lea    -0x8(%r8),%rcx
mov    %rcx,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
test   %rcx,%rcx
movdqa 0xbb4(%rip),%xmm3
je     15dc <main+0x4ac>
lea    0x0(,%rbp,4),%rcx
add    %rbp,%rcx
lea    0x0(,%rcx,2),%rcx
add    %rbp,%rcx
add    %rbx,%rcx
lea    0x20(%rsp),%rsi
lea    (%rsi,%rcx,4),%rdi
add    $0xfffffffffffffff4,%rdi
mov    0x18(%rsp),%rcx
add    %rbx,%rcx
and    $0xfffffffffffffff8,%rcx
add    $0xfffffffffffffff8,%rcx
shr    $0x3,%rcx
add    $0x1,%rcx
and    $0xfffffffffffffffe,%rcx
xor    %esi,%esi
movdqa 0xb72(%rip),%xmm4
movdqa 0xb7a(%rip),%xmm5
movdqa 0xb82(%rip),%xmm6
xchg   %ax,%ax
movdqa %xmm0,%xmm1
paddd  %xmm3,%xmm1
pshufd $0x1b,%xmm0,%xmm2
movdqu %xmm2,(%rdi,%rsi,4)
pshufd $0x1b,%xmm1,%xmm1
movdqu %xmm1,-0x10(%rdi,%rsi,4)
movdqa %xmm0,%xmm1
paddd  %xmm4,%xmm1
movdqa %xmm0,%xmm2
paddd  %xmm5,%xmm2
pshufd $0x1b,%xmm1,%xmm1
movdqu %xmm1,-0x20(%rdi,%rsi,4)
pshufd $0x1b,%xmm2,%xmm1
movdqu %xmm1,-0x30(%rdi,%rsi,4)
paddd  %xmm6,%xmm0
add    $0xfffffffffffffff0,%rsi
add    $0xfffffffffffffffe,%rcx
jne    14c0 <main+0x390>
neg    %rsi
test   $0x1,%dl
je     1544 <main+0x414>
mov    %rbx,%rcx
sub    %rsi,%rcx
imul   $0x2c,%rbp,%rdx
add    %rsp,%rdx
add    $0x20,%rdx
pshufd $0x1b,%xmm0,%xmm1
paddd  %xmm3,%xmm0
movdqu %xmm1,-0xc(%rdx,%rcx,4)
pshufd $0x1b,%xmm0,%xmm0
movdqu %xmm0,-0x1c(%rdx,%rcx,4)
sub    %r8,%rbx
add    %r8d,%r15d
cmp    %r8,%rax
je     1571 <main+0x441>
imul   $0x2c,%rbp,%rax
add    %rsp,%rax
add    $0x20,%rax
nopw   0x0(%rax,%rax,1)
mov    %r15d,(%rax,%rbx,4)
add    $0x1,%r15d
add    $0xffffffffffffffff,%rbx
cmp    %r12,%rbx
jg     1560 <main+0x430>
mov    %ebx,%r14d
mov    0x8(%rsp),%rbx
mov    %r13,%rdi
mov    %ebp,%esi
mov    %r14d,%edx
xor    %eax,%eax
call   1040 <printf@plt>
add    $0x1,%r12
cmp    %rbp,%r12
jge    11a0 <main+0x70>
movslq %r14d,%rax
imul   $0x2c,%rbp,%rcx
add    %rsp,%rcx
add    $0x20,%rcx
lea    (%rcx,%rax,4),%rax
nopw   0x0(%rax,%rax,1)
mov    %r15d,(%rax)
add    $0x1,%r15d
add    $0xffffffffffffffff,%rbp
add    $0xffffffffffffffd4,%rax
cmp    %r12,%rbp
jg     15b0 <main+0x480>
mov    %ebp,%ebx
jmp    11a0 <main+0x70>
xor    %edi,%edi
test   $0x1,%sil
jne    12d3 <main+0x1a3>
jmp    12f0 <main+0x1c0>
xor    %esi,%esi
test   $0x1,%dl
jne    1519 <main+0x3e9>
jmp    1544 <main+0x414>
movslq %ebx,%rax
movslq %r14d,%rcx
imul   $0x2c,%rax,%rax
add    %rsp,%rax
add    $0x20,%rax
movl   $0x79,(%rax,%rcx,4)
lea    0xa50(%rip),%r14
lea    0xa45(%rip),%rbp
xor    %ebx,%ebx
jmp    1645 <main+0x515>
cs nopw 0x0(%rax,%rax,1)
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
add    $0x2c,%rbx
cmp    $0x1e4,%rbx
je     17a5 <main+0x675>
mov    0x20(%rsp,%rbx,1),%esi
test   %esi,%esi
je     1660 <main+0x530>
mov    %rbp,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
jmp    166a <main+0x53a>
nopl   0x0(%rax)
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x24(%rsp,%rbx,1),%esi
test   %esi,%esi
je     1680 <main+0x550>
mov    %rbp,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
jmp    168a <main+0x55a>
xchg   %ax,%ax
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x28(%rsp,%rbx,1),%esi
test   %esi,%esi
je     16a0 <main+0x570>
mov    %rbp,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
jmp    16aa <main+0x57a>
xchg   %ax,%ax
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x2c(%rsp,%rbx,1),%esi
test   %esi,%esi
je     16c0 <main+0x590>
mov    %rbp,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
jmp    16ca <main+0x59a>
xchg   %ax,%ax
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x30(%rsp,%rbx,1),%esi
test   %esi,%esi
je     16e0 <main+0x5b0>
mov    %rbp,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
jmp    16ea <main+0x5ba>
xchg   %ax,%ax
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x34(%rsp,%rbx,1),%esi
test   %esi,%esi
je     1700 <main+0x5d0>
mov    %rbp,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
jmp    170a <main+0x5da>
xchg   %ax,%ax
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x38(%rsp,%rbx,1),%esi
test   %esi,%esi
je     1720 <main+0x5f0>
mov    %rbp,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
jmp    172a <main+0x5fa>
xchg   %ax,%ax
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x3c(%rsp,%rbx,1),%esi
test   %esi,%esi
je     1740 <main+0x610>
mov    %rbp,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
jmp    174a <main+0x61a>
xchg   %ax,%ax
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x40(%rsp,%rbx,1),%esi
test   %esi,%esi
je     1760 <main+0x630>
mov    %rbp,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
jmp    176a <main+0x63a>
xchg   %ax,%ax
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x44(%rsp,%rbx,1),%esi
test   %esi,%esi
je     1780 <main+0x650>
mov    %rbp,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
jmp    178a <main+0x65a>
xchg   %ax,%ax
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x48(%rsp,%rbx,1),%esi
test   %esi,%esi
je     1620 <main+0x4f0>
mov    %rbp,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
jmp    162a <main+0x4fa>
xor    %eax,%eax
add    $0x208,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [7 x i8] c"%d %d\0A\00"
@.str.1 = [4 x i8] c"%4d\00"
@.str.2 = [5 x i8] c" \00"
@.str.3 = [2 x i8] c"\0A\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca i32
%3 = alloca i32
%4 = alloca i32
%5 = alloca [11 x [11 x i32]]
%6 = alloca i32
%7 = alloca i32
store i32 0, i32* %1
store i32 0, i32* %2
store i32 0, i32* %3
store i32 1, i32* %4
%8 = bitcast [11 x [11 x i32]]* %5 to i8*
store i32 11, i32* %7
store i32 0, i32* %6
br label %9
9: ; preds = %107, %0
%10 = load i32, i32* %6
%11 = load i32, i32* %7
%12 = sdiv i32 %11, 2
%13 = add nsw i32 %12, 1
%14 = icmp sle i32 %10, %13
br i1 %14, label %15, label %110
15: ; preds = %9
%16 = load i32, i32* %3
br label %17
17: ; preds = %33, %15
%18 = load i32, i32* %3
%19 = load i32, i32* %7
%20 = load i32, i32* %6
%21 = sub nsw i32 %19, %20
%22 = sub nsw i32 %21, 1
%23 = icmp slt i32 %18, %22
br i1 %23, label %24, label %36
24: ; preds = %17
%25 = load i32, i32* %4
%26 = add nsw i32 %25, 1
store i32 %26, i32* %4
%27 = load i32, i32* %2
%28 = sext i32 %27 to i64
%29 = getelementptr inbounds [11 x [11 x i32]], [11 x [11 x i32]]* %5, i64 0, i64 %28
%30 = load i32, i32* %3
%31 = sext i32 %30 to i64
%32 = getelementptr inbounds [11 x i32], [11 x i32]* %29, i64 0, i64 %31
store i32 %25, i32* %32
br label %33
33: ; preds = %24
%34 = load i32, i32* %3
%35 = add nsw i32 %34, 1
store i32 %35, i32* %3
br label %17
36: ; preds = %17
%37 = load i32, i32* %2
%38 = load i32, i32* %3
%39 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str, i64 0, i64 0), i32 %37, i32 %38)
%40 = load i32, i32* %2
br label %41
41: ; preds = %57, %36
%42 = load i32, i32* %2
%43 = load i32, i32* %7
%44 = load i32, i32* %6
%45 = sub nsw i32 %43, %44
%46 = sub nsw i32 %45, 1
%47 = icmp slt i32 %42, %46
br i1 %47, label %48, label %60
48: ; preds = %41
%49 = load i32, i32* %4
%50 = add nsw i32 %49, 1
store i32 %50, i32* %4
%51 = load i32, i32* %2
%52 = sext i32 %51 to i64
%53 = getelementptr inbounds [11 x [11 x i32]], [11 x [11 x i32]]* %5, i64 0, i64 %52
%54 = load i32, i32* %3
%55 = sext i32 %54 to i64
%56 = getelementptr inbounds [11 x i32], [11 x i32]* %53, i64 0, i64 %55
store i32 %49, i32* %56
br label %57
57: ; preds = %48
%58 = load i32, i32* %2
%59 = add nsw i32 %58, 1
store i32 %59, i32* %2
br label %41
60: ; preds = %41
%61 = load i32, i32* %2
%62 = load i32, i32* %3
%63 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str, i64 0, i64 0), i32 %61, i32 %62)
%64 = load i32, i32* %3
br label %65
65: ; preds = %78, %60
%66 = load i32, i32* %3
%67 = load i32, i32* %6
%68 = icmp sgt i32 %66, %67
br i1 %68, label %69, label %81
69: ; preds = %65
%70 = load i32, i32* %4
%71 = add nsw i32 %70, 1
store i32 %71, i32* %4
%72 = load i32, i32* %2
%73 = sext i32 %72 to i64
%74 = getelementptr inbounds [11 x [11 x i32]], [11 x [11 x i32]]* %5, i64 0, i64 %73
%75 = load i32, i32* %3
%76 = sext i32 %75 to i64
%77 = getelementptr inbounds [11 x i32], [11 x i32]* %74, i64 0, i64 %76
store i32 %70, i32* %77
br label %78
78: ; preds = %69
%79 = load i32, i32* %3
%80 = add nsw i32 %79, -1
store i32 %80, i32* %3
br label %65
81: ; preds = %65
%82 = load i32, i32* %2
%83 = load i32, i32* %3
%84 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str, i64 0, i64 0), i32 %82, i32 %83)
%85 = load i32, i32* %2
br label %86
86: ; preds = %100, %81
%87 = load i32, i32* %2
%88 = load i32, i32* %6
%89 = add nsw i32 %88, 1
%90 = icmp sgt i32 %87, %89
br i1 %90, label %91, label %103
91: ; preds = %86
%92 = load i32, i32* %4
%93 = add nsw i32 %92, 1
store i32 %93, i32* %4
%94 = load i32, i32* %2
%95 = sext i32 %94 to i64
%96 = getelementptr inbounds [11 x [11 x i32]], [11 x [11 x i32]]* %5, i64 0, i64 %95
%97 = load i32, i32* %3
%98 = sext i32 %97 to i64
%99 = getelementptr inbounds [11 x i32], [11 x i32]* %96, i64 0, i64 %98
store i32 %92, i32* %99
br label %100
100: ; preds = %91
%101 = load i32, i32* %2
%102 = add nsw i32 %101, -1
store i32 %102, i32* %2
br label %86
103: ; preds = %86
%104 = load i32, i32* %2
%105 = load i32, i32* %3
%106 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str, i64 0, i64 0), i32 %104, i32 %105)
br label %107
107: ; preds = %103
%108 = load i32, i32* %6
%109 = add nsw i32 %108, 1
store i32 %109, i32* %6
br label %9
110: ; preds = %9
%111 = load i32, i32* %2
%112 = sext i32 %111 to i64
%113 = getelementptr inbounds [11 x [11 x i32]], [11 x [11 x i32]]* %5, i64 0, i64 %112
%114 = load i32, i32* %3
%115 = sext i32 %114 to i64
%116 = getelementptr inbounds [11 x i32], [11 x i32]* %113, i64 0, i64 %115
store i32 121, i32* %116
store i32 0, i32* %2
br label %117
117: ; preds = %150, %110
%118 = load i32, i32* %2
%119 = icmp slt i32 %118, 11
br i1 %119, label %120, label %153
120: ; preds = %117
store i32 0, i32* %3
br label %121
121: ; preds = %145, %120
%122 = load i32, i32* %3
%123 = icmp slt i32 %122, 11
br i1 %123, label %124, label %148
124: ; preds = %121
%125 = load i32, i32* %2
%126 = sext i32 %125 to i64
%127 = getelementptr inbounds [11 x [11 x i32]], [11 x [11 x i32]]* %5, i64 0, i64 %126
%128 = load i32, i32* %3
%129 = sext i32 %128 to i64
%130 = getelementptr inbounds [11 x i32], [11 x i32]* %127, i64 0, i64 %129
%131 = load i32, i32* %130
%132 = icmp ne i32 %131, 0
br i1 %132, label %133, label %142
133: ; preds = %124
%134 = load i32, i32* %2
%135 = sext i32 %134 to i64
%136 = getelementptr inbounds [11 x [11 x i32]], [11 x [11 x i32]]* %5, i64 0, i64 %135
%137 = load i32, i32* %3
%138 = sext i32 %137 to i64
%139 = getelementptr inbounds [11 x i32], [11 x i32]* %136, i64 0, i64 %138
%140 = load i32, i32* %139
%141 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), i32 %140)
br label %144
142: ; preds = %124
%143 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.2, i64 0, i64 0))
br label %144
144: ; preds = %142, %133
br label %145
145: ; preds = %144
%146 = load i32, i32* %3
%147 = add nsw i32 %146, 1
store i32 %147, i32* %3
br label %121
148: ; preds = %121
%149 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.3, i64 0, i64 0))
br label %150
150: ; preds = %148
%151 = load i32, i32* %2
%152 = add nsw i32 %151, 1
store i32 %152, i32* %2
br label %117
153: ; preds = %117
ret i32 0
}

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