#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 arr[11][11] = {0};
  int i = 0, j = 0, k;
  int N = 11;
  int count = 1;
  for (k = 0; k <= N; k++) {
    for (; j < N - 1 - k; j++)
      arr[i][j] = count++;
    for (; i < N - 1 - k; i++)
      arr[i][j] = count++;
    for (; j > k + 0; j--)
      arr[i][j] = count++;
    for (; i > k + 1; i--)
      arr[i][j] = count++;
  }
  arr[i][j] = N * N;
  for (i = 0; i < N; i++) {
    for (j = 0; j < N; 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)
lea    -0x1f0(%rbp),%rdi
xor    %esi,%esi
mov    $0x1e4,%edx
call   1040 <memset@plt>
movl   $0x0,-0x1f4(%rbp)
movl   $0x0,-0x1f8(%rbp)
movl   $0xb,-0x200(%rbp)
movl   $0x1,-0x204(%rbp)
movl   $0x0,-0x1fc(%rbp)
mov    -0x1fc(%rbp),%eax
cmp    -0x200(%rbp),%eax
jg     132e <main+0x20e>
jmp    118e <main+0x6e>
mov    -0x1f8(%rbp),%eax
mov    -0x200(%rbp),%ecx
sub    $0x1,%ecx
sub    -0x1fc(%rbp),%ecx
cmp    %ecx,%eax
jge    11ef <main+0xcf>
mov    -0x204(%rbp),%edx
mov    %edx,%eax
add    $0x1,%eax
mov    %eax,-0x204(%rbp)
movslq -0x1f4(%rbp),%rcx
lea    -0x1f0(%rbp),%rax
imul   $0x2c,%rcx,%rcx
add    %rcx,%rax
movslq -0x1f8(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x1f8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1f8(%rbp)
jmp    118e <main+0x6e>
jmp    11f4 <main+0xd4>
mov    -0x1f4(%rbp),%eax
mov    -0x200(%rbp),%ecx
sub    $0x1,%ecx
sub    -0x1fc(%rbp),%ecx
cmp    %ecx,%eax
jge    1255 <main+0x135>
mov    -0x204(%rbp),%edx
mov    %edx,%eax
add    $0x1,%eax
mov    %eax,-0x204(%rbp)
movslq -0x1f4(%rbp),%rcx
lea    -0x1f0(%rbp),%rax
imul   $0x2c,%rcx,%rcx
add    %rcx,%rax
movslq -0x1f8(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x1f4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1f4(%rbp)
jmp    11f4 <main+0xd4>
jmp    125a <main+0x13a>
mov    -0x1f8(%rbp),%eax
mov    -0x1fc(%rbp),%ecx
add    $0x0,%ecx
cmp    %ecx,%eax
jle    12b5 <main+0x195>
mov    -0x204(%rbp),%edx
mov    %edx,%eax
add    $0x1,%eax
mov    %eax,-0x204(%rbp)
movslq -0x1f4(%rbp),%rcx
lea    -0x1f0(%rbp),%rax
imul   $0x2c,%rcx,%rcx
add    %rcx,%rax
movslq -0x1f8(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x1f8(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1f8(%rbp)
jmp    125a <main+0x13a>
jmp    12ba <main+0x19a>
mov    -0x1f4(%rbp),%eax
mov    -0x1fc(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jle    1315 <main+0x1f5>
mov    -0x204(%rbp),%edx
mov    %edx,%eax
add    $0x1,%eax
mov    %eax,-0x204(%rbp)
movslq -0x1f4(%rbp),%rcx
lea    -0x1f0(%rbp),%rax
imul   $0x2c,%rcx,%rcx
add    %rcx,%rax
movslq -0x1f8(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x1f4(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1f4(%rbp)
jmp    12ba <main+0x19a>
jmp    131a <main+0x1fa>
mov    -0x1fc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1fc(%rbp)
jmp    1177 <main+0x57>
mov    -0x200(%rbp),%edx
imul   -0x200(%rbp),%edx
movslq -0x1f4(%rbp),%rcx
lea    -0x1f0(%rbp),%rax
imul   $0x2c,%rcx,%rcx
add    %rcx,%rax
movslq -0x1f8(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
movl   $0x0,-0x1f4(%rbp)
mov    -0x1f4(%rbp),%eax
cmp    -0x200(%rbp),%eax
jge    1433 <main+0x313>
movl   $0x0,-0x1f8(%rbp)
mov    -0x1f8(%rbp),%eax
cmp    -0x200(%rbp),%eax
jge    1411 <main+0x2f1>
movslq -0x1f4(%rbp),%rcx
lea    -0x1f0(%rbp),%rax
imul   $0x2c,%rcx,%rcx
add    %rcx,%rax
movslq -0x1f8(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     13ea <main+0x2ca>
movslq -0x1f4(%rbp),%rcx
lea    -0x1f0(%rbp),%rax
imul   $0x2c,%rcx,%rcx
add    %rcx,%rax
movslq -0x1f8(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
lea    0xc22(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    13f8 <main+0x2d8>
lea    0xc13(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    13fd <main+0x2dd>
mov    -0x1f8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1f8(%rbp)
jmp    1380 <main+0x260>
lea    0xbf1(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x1f4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1f4(%rbp)
jmp    1364 <main+0x244>
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    $0x1e8,%rsp
mov    %rsp,%r14
xor    %r15d,%r15d
mov    $0x1e4,%edx
mov    %r14,%rdi
xor    %esi,%esi
call   1050 <memset@plt>
mov    $0x1,%ecx
mov    $0xa,%r9d
movdqa 0xe97(%rip),%xmm0
movdqa 0xe9f(%rip),%xmm1
movdqa 0xea7(%rip),%xmm2
movdqa 0xeaf(%rip),%xmm3
movdqa 0xeb7(%rip),%xmm4
xor    %r13d,%r13d
xor    %r8d,%r8d
xor    %r10d,%r10d
jmp    11b2 <main+0x82>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0xffffffffffffffff,%r9
add    $0xffffffffffffffff,%r15
cmp    $0xc,%r13
je     14ec <main+0x3bc>
mov    $0xa,%esi
sub    %r13,%rsi
movslq %r10d,%rdi
movslq %r8d,%rbx
cmp    %rdi,%rsi
jle    12c2 <main+0x192>
mov    $0xa,%r12d
sub    %r13,%r12
sub    %rdi,%r12
cmp    $0x8,%r12
jb     12a7 <main+0x177>
mov    %r12,%r10
and    $0xfffffffffffffff8,%r10
movd   %ecx,%xmm5
pshufd $0x0,%xmm5,%xmm5
paddd  %xmm0,%xmm5
lea    -0x8(%r10),%rax
mov    %rax,%r11
shr    $0x3,%r11
add    $0x1,%r11
test   %rax,%rax
je     14ca <main+0x39a>
lea    (%rbx,%rbx,4),%rax
lea    (%rbx,%rax,2),%rax
add    %rdi,%rax
lea    (%r14,%rax,4),%rdx
add    $0x30,%rdx
mov    %r9,%rbp
sub    %rdi,%rbp
and    $0xfffffffffffffff8,%rbp
add    $0xfffffffffffffff8,%rbp
shr    $0x3,%rbp
add    $0x1,%rbp
and    $0xfffffffffffffffe,%rbp
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
movdqa %xmm5,%xmm6
paddd  %xmm1,%xmm6
movdqu %xmm5,-0x30(%rdx,%rax,4)
movdqu %xmm6,-0x20(%rdx,%rax,4)
movdqa %xmm5,%xmm6
paddd  %xmm2,%xmm6
movdqa %xmm5,%xmm7
paddd  %xmm3,%xmm7
movdqu %xmm6,-0x10(%rdx,%rax,4)
movdqu %xmm7,(%rdx,%rax,4)
add    $0x10,%rax
paddd  %xmm4,%xmm5
add    $0xfffffffffffffffe,%rbp
jne    1240 <main+0x110>
test   $0x1,%r11b
je     129c <main+0x16c>
add    %rdi,%rax
imul   $0x2c,%rbx,%rdx
add    %rsp,%rdx
movdqu %xmm5,(%rdx,%rax,4)
paddd  %xmm1,%xmm5
movdqu %xmm5,0x10(%rdx,%rax,4)
add    %r10,%rdi
add    %r10d,%ecx
cmp    %r10,%r12
je     12bf <main+0x18f>
imul   $0x2c,%rbx,%rax
add    %rsp,%rax
xchg   %ax,%ax
mov    %ecx,(%rax,%rdi,4)
add    $0x1,%ecx
add    $0x1,%rdi
cmp    %rsi,%rdi
jl     12b0 <main+0x180>
mov    %edi,%r10d
movslq %r10d,%rdi
cmp    %rbx,%rsi
jle    135e <main+0x22e>
lea    (%rbx,%r13,1),%r11
mov    $0x2,%eax
sub    %r11d,%eax
test   $0x3,%al
je     131a <main+0x1ea>
imul   $0x2c,%rbx,%rax
add    %rsp,%rax
lea    (%rax,%rdi,4),%rdx
mov    %r9d,%eax
sub    %bl,%al
movzbl %al,%ebp
and    $0x3,%ebp
neg    %rbp
xor    %eax,%eax
nopl   0x0(%rax)
mov    %ecx,(%rdx)
add    $0x1,%ecx
add    $0xffffffffffffffff,%rax
add    $0x2c,%rdx
cmp    %rax,%rbp
jne    1300 <main+0x1d0>
sub    %rax,%rbx
mov    %rbx,%r8
jmp    131a <main+0x1ea>
add    $0xfffffffffffffff9,%r11
cmp    $0x3,%r11
jb     135e <main+0x22e>
imul   $0x2c,%rbx,%rax
add    %rsp,%rax
lea    (%rax,%rdi,4),%rax
nop
mov    %ecx,%edx
mov    %ecx,(%rax)
lea    0x1(%rdx),%ecx
mov    %ecx,0x2c(%rax)
lea    0x2(%rdx),%ecx
mov    %ecx,0x58(%rax)
lea    0x4(%rdx),%ecx
add    $0x3,%edx
mov    %edx,0x84(%rax)
add    $0x4,%rbx
add    $0xb0,%rax
cmp    %rsi,%rbx
jl     1330 <main+0x200>
mov    %rbx,%r8
movslq %r8d,%rsi
cmp    %rdi,%r13
jge    1492 <main+0x362>
mov    %rdi,%r12
sub    %r13,%r12
cmp    $0x8,%r12
jb     146c <main+0x33c>
mov    %r12,%r10
and    $0xfffffffffffffff8,%r10
movd   %ecx,%xmm5
pshufd $0x0,%xmm5,%xmm5
paddd  %xmm0,%xmm5
lea    -0x8(%r10),%rax
mov    %rax,%r11
shr    $0x3,%r11
add    $0x1,%r11
test   %rax,%rax
je     14db <main+0x3ab>
lea    (%rsi,%rsi,4),%rax
lea    (%rsi,%rax,2),%rax
add    %rdi,%rax
lea    (%r14,%rax,4),%rax
add    $0xfffffffffffffff4,%rax
lea    (%r15,%rdi,1),%rdx
and    $0xfffffffffffffff8,%rdx
add    $0xfffffffffffffff8,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
and    $0xfffffffffffffffe,%rdx
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movdqa %xmm5,%xmm6
paddd  %xmm1,%xmm6
pshufd $0x1b,%xmm5,%xmm7
movdqu %xmm7,(%rax,%rbx,4)
pshufd $0x1b,%xmm6,%xmm6
movdqu %xmm6,-0x10(%rax,%rbx,4)
movdqa %xmm5,%xmm6
paddd  %xmm2,%xmm6
movdqa %xmm5,%xmm7
paddd  %xmm3,%xmm7
pshufd $0x1b,%xmm6,%xmm6
movdqu %xmm6,-0x20(%rax,%rbx,4)
pshufd $0x1b,%xmm7,%xmm6
movdqu %xmm6,-0x30(%rax,%rbx,4)
paddd  %xmm4,%xmm5
add    $0xfffffffffffffff0,%rbx
add    $0xfffffffffffffffe,%rdx
jne    13e0 <main+0x2b0>
neg    %rbx
test   $0x1,%r11b
je     1461 <main+0x331>
mov    %rdi,%rax
sub    %rbx,%rax
imul   $0x2c,%rsi,%rdx
add    %rsp,%rdx
pshufd $0x1b,%xmm5,%xmm6
paddd  %xmm1,%xmm5
movdqu %xmm6,-0xc(%rdx,%rax,4)
pshufd $0x1b,%xmm5,%xmm5
movdqu %xmm5,-0x1c(%rdx,%rax,4)
sub    %r10,%rdi
add    %r10d,%ecx
cmp    %r10,%r12
je     148f <main+0x35f>
imul   $0x2c,%rsi,%rax
add    %rsp,%rax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %ecx,(%rax,%rdi,4)
add    $0x1,%ecx
add    $0xffffffffffffffff,%rdi
cmp    %r13,%rdi
jg     1480 <main+0x350>
mov    %edi,%r10d
add    $0x1,%r13
cmp    %rsi,%r13
jge    11a0 <main+0x70>
movslq %r10d,%rax
imul   $0x2c,%rsi,%rdx
add    %rsp,%rdx
lea    (%rdx,%rax,4),%rax
nopl   (%rax)
mov    %ecx,(%rax)
add    $0x1,%ecx
add    $0xffffffffffffffff,%rsi
add    $0xffffffffffffffd4,%rax
cmp    %r13,%rsi
jg     14b0 <main+0x380>
mov    %esi,%r8d
jmp    11a0 <main+0x70>
xor    %eax,%eax
test   $0x1,%r11b
jne    1283 <main+0x153>
jmp    129c <main+0x16c>
xor    %ebx,%ebx
test   $0x1,%r11b
jne    143a <main+0x30a>
jmp    1461 <main+0x331>
movslq %r8d,%rax
movslq %r10d,%rcx
imul   $0x2c,%rax,%rax
add    %rsp,%rax
movl   $0x79,(%rax,%rcx,4)
lea    0xb4d(%rip),%r14
lea    0xb42(%rip),%r15
xor    %ebx,%ebx
jmp    1545 <main+0x415>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
add    $0x2c,%rbx
cmp    $0x1e4,%rbx
je     16a5 <main+0x575>
mov    (%rsp,%rbx,1),%esi
test   %esi,%esi
je     1560 <main+0x430>
mov    %r15,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
jmp    156a <main+0x43a>
nopl   0x0(%rax,%rax,1)
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x4(%rsp,%rbx,1),%esi
test   %esi,%esi
je     1580 <main+0x450>
mov    %r15,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
jmp    158a <main+0x45a>
xchg   %ax,%ax
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x8(%rsp,%rbx,1),%esi
test   %esi,%esi
je     15a0 <main+0x470>
mov    %r15,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
jmp    15aa <main+0x47a>
xchg   %ax,%ax
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0xc(%rsp,%rbx,1),%esi
test   %esi,%esi
je     15c0 <main+0x490>
mov    %r15,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
jmp    15ca <main+0x49a>
xchg   %ax,%ax
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x10(%rsp,%rbx,1),%esi
test   %esi,%esi
je     15e0 <main+0x4b0>
mov    %r15,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
jmp    15ea <main+0x4ba>
xchg   %ax,%ax
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x14(%rsp,%rbx,1),%esi
test   %esi,%esi
je     1600 <main+0x4d0>
mov    %r15,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
jmp    160a <main+0x4da>
xchg   %ax,%ax
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x18(%rsp,%rbx,1),%esi
test   %esi,%esi
je     1620 <main+0x4f0>
mov    %r15,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
jmp    162a <main+0x4fa>
xchg   %ax,%ax
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x1c(%rsp,%rbx,1),%esi
test   %esi,%esi
je     1640 <main+0x510>
mov    %r15,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
jmp    164a <main+0x51a>
xchg   %ax,%ax
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x20(%rsp,%rbx,1),%esi
test   %esi,%esi
je     1660 <main+0x530>
mov    %r15,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
jmp    166a <main+0x53a>
xchg   %ax,%ax
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x24(%rsp,%rbx,1),%esi
test   %esi,%esi
je     1680 <main+0x550>
mov    %r15,%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     1520 <main+0x3f0>
mov    %r15,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
jmp    152a <main+0x3fa>
xor    %eax,%eax
add    $0x1e8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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