void fill_array_spiral(int n, int arr[][n]) {
  int maxRow, maxCol;
  maxRow = maxCol = n - 1;
  int ctr = 1;
  int row = 0, col = 0;
  int i;
  while (ctr <= n * n) {
    for (i = col; i <= maxCol; i++) {
      arr[row][i] = ctr;
      ctr++;
    }
    row++;
    for (i = row; i <= maxRow; i++) {
      arr[i][maxCol] = ctr;
      ctr++;
    }
    maxCol--;
    for (i = maxCol; i >= col; i--) {
      arr[maxRow][i] = ctr;
      ctr++;
    }
    maxRow--;
    for (i = maxRow; i >= row; i--) {
      arr[i][col] = ctr;
      ctr++;
    }
    col++;
  }
}


x86 assembly (clang, -O0):
<fill_array_spiral>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x4(%rbp),%eax
mov    %rax,-0x30(%rbp)
mov    -0x4(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x18(%rbp)
mov    %eax,-0x14(%rbp)
movl   $0x1,-0x1c(%rbp)
movl   $0x0,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x1c(%rbp),%eax
mov    -0x4(%rbp),%ecx
imul   -0x4(%rbp),%ecx
cmp    %ecx,%eax
jg     1296 <fill_array_spiral+0x196>
mov    -0x24(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x18(%rbp),%eax
jg     118f <fill_array_spiral+0x8f>
mov    -0x30(%rbp),%rsi
mov    -0x1c(%rbp),%edx
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
imul   %rsi,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    114b <fill_array_spiral+0x4b>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     11e2 <fill_array_spiral+0xe2>
mov    -0x30(%rbp),%rsi
mov    -0x1c(%rbp),%edx
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
imul   %rsi,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x18(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    119e <fill_array_spiral+0x9e>
mov    -0x18(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jl     1235 <fill_array_spiral+0x135>
mov    -0x30(%rbp),%rsi
mov    -0x1c(%rbp),%edx
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
imul   %rsi,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x28(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x28(%rbp)
jmp    11f1 <fill_array_spiral+0xf1>
mov    -0x14(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x20(%rbp),%eax
jl     1288 <fill_array_spiral+0x188>
mov    -0x30(%rbp),%rsi
mov    -0x1c(%rbp),%edx
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
imul   %rsi,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x28(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x28(%rbp)
jmp    1244 <fill_array_spiral+0x144>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1133 <fill_array_spiral+0x33>
pop    %rbp
ret

x86 assembly (clang, -O2):
<fill_array_spiral>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x30,%rsp
mov    %rsi,-0x30(%rsp)
mov    %rdi,%rax
mov    %rdi,-0x18(%rsp)
imul   %eax,%eax
mov    %eax,-0x20(%rsp)
test   %eax,%eax
je     18c8 <fill_array_spiral+0x7c8>
mov    -0x18(%rsp),%rdx
mov    %edx,%r13d
lea    -0x1(%rdx),%eax
lea    -0x2(%rdx),%ebp
mov    %eax,-0x28(%rsp)
movslq %eax,%r14
mov    -0x30(%rsp),%r8
lea    0x70(%r8),%rax
lea    0x0(,%r13,4),%rbx
lea    0x4(,%r13,4),%rcx
mov    %rcx,0x20(%rsp)
lea    0x0(,%r13,8),%rcx
add    %r13,%rcx
add    %r14,%rcx
lea    (%r8,%rcx,4),%r11
add    $0x10,%r11
mov    %r13,%rcx
shl    $0x6,%rcx
mov    %rcx,(%rsp)
lea    (%r14,%r13,1),%rcx
lea    (%r8,%rcx,4),%r9
add    $0x10,%r9
mov    %r13,%rcx
shl    $0x4,%rcx
mov    %rcx,0x8(%rsp)
mov    %r14,%rcx
imul   %r13,%rcx
lea    (%r8,%rcx,4),%rsi
add    $0xffffffffffffffe4,%rsi
mov    %rsi,-0x80(%rsp)
mov    %rbx,%r10
neg    %r10
lea    (%r8,%rcx,4),%rsi
movdqa 0xe43(%rip),%xmm8
movdqa 0xe4b(%rip),%xmm1
movdqa 0xe53(%rip),%xmm2
movdqa 0xe5b(%rip),%xmm3
movdqa 0xe63(%rip),%xmm4
movdqa 0xe6a(%rip),%xmm9
movdqa 0xe71(%rip),%xmm10
movdqa 0xe78(%rip),%xmm11
movdqa 0xe80(%rip),%xmm0
lea    -0x4(,%r13,4),%rcx
ff
mov    %rcx,0x18(%rsp)
mov    %r14,-0x70(%rsp)
lea    (%r8,%r14,4),%r15
mov    $0x1,%r14d
mov    $0x1,%ecx
mov    %rcx,-0x50(%rsp)
movq   $0xfffffffffffffff8,-0x10(%rsp)
ff ff
xor    %r12d,%r12d
mov    %r8,-0x8(%rsp)
mov    %ebp,-0x48(%rsp)
mov    %ebp,-0x24(%rsp)
mov    %edx,%edi
mov    %r15,%rdx
mov    %r13,-0x40(%rsp)
mov    %rbx,-0x68(%rsp)
jmp    12a6 <fill_array_spiral+0x1a6>
mov    -0x44(%rsp),%ebp
add    $0x1,%r12
add    $0xffffffff,%r13d
addq   $0x1,-0x50(%rsp)
add    $0xffffffff,%ebp
add    0x20(%rsp),%rax
addq   $0xffffffffffffffff,-0x10(%rsp)
add    %rbx,%r8
mov    0x18(%rsp),%rcx
add    %rcx,%r11
add    %rcx,%r9
addl   $0xfffffffe,-0x48(%rsp)
add    $0xfffffffffffffffc,%rdx
add    %r10,%rdi
mov    %rdi,-0x80(%rsp)
add    %r10,%rsi
addq   $0x4,-0x8(%rsp)
mov    %r13d,%edi
cmp    -0x20(%rsp),%r14d
jg     18c8 <fill_array_spiral+0x7c8>
movslq %ebp,%r15
cmp    %r15,%r12
mov    %r15,%rcx
cmovl  %r12,%rcx
mov    %rcx,0x28(%rsp)
mov    %edi,-0x1c(%rsp)
mov    %edi,%r13d
cmp    -0x70(%rsp),%r12
mov    %ebp,-0x44(%rsp)
jle    12e0 <fill_array_spiral+0x1e0>
mov    -0x80(%rsp),%rdi
jmp    1491 <fill_array_spiral+0x391>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %r13,%rcx
sub    %r12,%rcx
cmp    $0x8,%rcx
jae    1300 <fill_array_spiral+0x200>
mov    %r12,%rbp
jmp    1470 <fill_array_spiral+0x370>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %rdx,-0x78(%rsp)
mov    -0x10(%rsp),%rdx
lea    (%rdx,%r13,1),%rdi
shr    $0x3,%rdi
lea    -0x8(%rcx),%rdx
mov    %rdx,%rbx
shr    $0x3,%rbx
add    $0x1,%rbx
movd   %r14d,%xmm5
pshufd $0x0,%xmm5,%xmm5
paddd  %xmm8,%xmm5
cmp    $0x18,%rdx
mov    %r9,-0x60(%rsp)
mov    %rsi,-0x58(%rsp)
mov    %r11,%rsi
jae    134b <fill_array_spiral+0x24b>
xor    %r11d,%r11d
jmp    13e0 <fill_array_spiral+0x2e0>
lea    0x1(%rdi),%rbp
and    $0xfffffffffffffffc,%rbp
xor    %r11d,%r11d
cs nopw 0x0(%rax,%rax,1)
movdqa %xmm5,%xmm6
paddd  %xmm1,%xmm6
movdqu %xmm5,-0x70(%rax,%r11,4)
movdqu %xmm6,-0x60(%rax,%r11,4)
movdqa %xmm5,%xmm6
paddd  %xmm2,%xmm6
movdqa %xmm5,%xmm7
paddd  %xmm3,%xmm7
movdqu %xmm6,-0x50(%rax,%r11,4)
movdqu %xmm7,-0x40(%rax,%r11,4)
movdqa %xmm5,%xmm6
paddd  %xmm4,%xmm6
movdqa %xmm5,%xmm7
paddd  %xmm9,%xmm7
movdqu %xmm6,-0x30(%rax,%r11,4)
movdqu %xmm7,-0x20(%rax,%r11,4)
movdqa %xmm5,%xmm6
paddd  %xmm10,%xmm6
movdqa %xmm5,%xmm7
paddd  %xmm11,%xmm7
movdqu %xmm6,-0x10(%rax,%r11,4)
movdqu %xmm7,(%rax,%r11,4)
add    $0x20,%r11
paddd  %xmm0,%xmm5
add    $0xfffffffffffffffc,%rbp
jne    1360 <fill_array_spiral+0x260>
mov    %rcx,%rbp
and    $0xfffffffffffffff8,%rbp
test   $0x3,%bl
je     1430 <fill_array_spiral+0x330>
add    $0x1,%dil
movzbl %dil,%edx
and    $0x3,%edx
shl    $0x5,%rdx
add    %r12,%r11
lea    (%r8,%r11,4),%rdi
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movdqa %xmm5,%xmm6
paddd  %xmm1,%xmm6
movdqu %xmm5,(%rdi,%rbx,1)
movdqu %xmm6,0x10(%rdi,%rbx,1)
paddd  %xmm2,%xmm5
add    $0x20,%rbx
cmp    %rbx,%rdx
jne    1410 <fill_array_spiral+0x310>
add    %ebp,%r14d
cmp    %rbp,%rcx
jne    1456 <fill_array_spiral+0x356>
mov    -0x68(%rsp),%rbx
mov    %rsi,%r11
mov    -0x60(%rsp),%r9
mov    -0x58(%rsp),%rsi
mov    -0x78(%rsp),%rdx
mov    -0x80(%rsp),%rdi
jmp    1491 <fill_array_spiral+0x391>
add    %r12,%rbp
mov    -0x68(%rsp),%rbx
mov    %rsi,%r11
mov    -0x60(%rsp),%r9
mov    -0x58(%rsp),%rsi
mov    -0x78(%rsp),%rdx
mov    -0x80(%rsp),%rdi
cs nopw 0x0(%rax,%rax,1)
nop
mov    %r14d,(%r8,%rbp,4)
add    $0x1,%r14d
add    $0x1,%rbp
cmp    %rbp,%r13
jne    1480 <fill_array_spiral+0x380>
mov    -0x70(%rsp),%rbp
cmp    %rbp,%r12
jge    1880 <fill_array_spiral+0x780>
mov    %rdx,-0x78(%rsp)
mov    -0x24(%rsp),%edx
mov    %edx,%ebp
sub    %r12d,%ebp
sub    %r12d,%ebp
cmp    $0x7,%ebp
mov    %r11,-0x38(%rsp)
mov    %r9,-0x60(%rsp)
mov    %rdi,-0x80(%rsp)
mov    %rsi,-0x58(%rsp)
jb     15a0 <fill_array_spiral+0x4a0>
cmpl   $0x1,-0x18(%rsp)
jne    15a0 <fill_array_spiral+0x4a0>
add    $0x1,%rbp
mov    %rbp,%r11
movabs $0x1fffffff8,%rcx
and    %rcx,%r11
lea    -0x8(%r11),%rcx
mov    %rcx,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
movd   %r14d,%xmm5
pshufd $0x0,%xmm5,%xmm5
paddd  %xmm8,%xmm5
test   %rcx,%rcx
mov    %rdx,0x10(%rsp)
je     15ac <fill_array_spiral+0x4ac>
mov    -0x48(%rsp),%r9d
add    $0x1,%r9
and    $0xfffffffffffffff8,%r9
add    $0xfffffffffffffff8,%r9
shr    $0x3,%r9
add    $0x1,%r9
and    $0xfffffffffffffffe,%r9
xor    %ecx,%ecx
xor    %edi,%edi
mov    -0x38(%rsp),%rsi
mov    (%rsp),%rbx
mov    -0x60(%rsp),%rdx
nopw   0x0(%rax,%rax,1)
movdqa %xmm5,%xmm6
paddd  %xmm1,%xmm6
movdqu %xmm5,-0x10(%rdx,%rcx,1)
movdqu %xmm6,(%rdx,%rcx,1)
movdqa %xmm5,%xmm6
paddd  %xmm2,%xmm6
movdqa %xmm5,%xmm7
paddd  %xmm3,%xmm7
movdqu %xmm6,-0x10(%rsi,%rcx,1)
movdqu %xmm7,(%rsi,%rcx,1)
add    $0x10,%rdi
paddd  %xmm4,%xmm5
add    %rbx,%rcx
add    $0xfffffffffffffffe,%r9
jne    1550 <fill_array_spiral+0x450>
jmp    15ae <fill_array_spiral+0x4ae>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    -0x50(%rsp),%r11
mov    -0x70(%rsp),%rbp
jmp    15ff <fill_array_spiral+0x4ff>
xor    %edi,%edi
testb  $0x1,0x10(%rsp)
mov    -0x70(%rsp),%rdx
je     15dd <fill_array_spiral+0x4dd>
mov    -0x30(%rsp),%rcx
lea    (%rcx,%rdx,4),%rcx
add    -0x50(%rsp),%rdi
imul   -0x40(%rsp),%rdi
movdqu %xmm5,(%rcx,%rdi,4)
paddd  %xmm1,%xmm5
movdqu %xmm5,0x10(%rcx,%rdi,4)
add    %r11d,%r14d
cmp    %r11,%rbp
mov    -0x68(%rsp),%rbx
mov    -0x80(%rsp),%rdi
jne    15f7 <fill_array_spiral+0x4f7>
mov    %rdx,%rbp
jmp    16d8 <fill_array_spiral+0x5d8>
add    -0x50(%rsp),%r11
mov    %rdx,%rbp
mov    %r13d,%ecx
sub    %r11d,%ecx
mov    -0x28(%rsp),%edi
sub    %r12d,%edi
sub    %r11d,%edi
test   $0x3,%cl
je     1658 <fill_array_spiral+0x558>
mov    %rbp,%rsi
mov    -0x40(%rsp),%rcx
imul   %r11,%rcx
mov    -0x78(%rsp),%rdx
lea    (%rdx,%rcx,4),%rcx
mov    -0x1c(%rsp),%edx
sub    %r11b,%dl
movzbl %dl,%edx
and    $0x3,%edx
neg    %edx
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
mov    %r14d,(%rcx)
add    $0x1,%r14d
add    $0xffffffffffffffff,%rbp
add    %rbx,%rcx
cmp    %ebp,%edx
jne    1640 <fill_array_spiral+0x540>
sub    %rbp,%r11
mov    %rsi,%rbp
cmp    $0x3,%edi
mov    -0x80(%rsp),%rdi
jb     16d8 <fill_array_spiral+0x5d8>
mov    %rbp,-0x70(%rsp)
lea    0x3(%r11),%rdi
imul   %rbx,%rdi
lea    0x2(%r11),%rbp
imul   %rbx,%rbp
mov    %rbx,%rcx
imul   %r11,%rcx
mov    %r11,%rdx
add    $0x1,%rdx
imul   %rbx,%rdx
mov    -0x78(%rsp),%rbx
mov    0x8(%rsp),%r9
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %r14d,(%rbx,%rcx,1)
lea    0x1(%r14),%esi
mov    %esi,(%rbx,%rdx,1)
lea    0x2(%r14),%esi
mov    %esi,(%rbx,%rbp,1)
lea    0x3(%r14),%esi
mov    %esi,(%rbx,%rdi,1)
add    $0x4,%r14d
add    $0x4,%r11d
add    %r9,%rbx
cmp    %r11d,%r13d
jne    16a0 <fill_array_spiral+0x5a0>
mov    -0x68(%rsp),%rbx
mov    -0x80(%rsp),%rdi
mov    -0x70(%rsp),%rbp
cmp    %rbp,%r12
jge    1720 <fill_array_spiral+0x620>
mov    %rbp,%rbx
mov    0x28(%rsp),%rdx
mov    %rdx,%rcx
neg    %rcx
lea    (%r15,%rcx,1),%r9
add    $0x1,%r9
mov    %r15,%rcx
cmp    $0x8,%r9
jae    1739 <fill_array_spiral+0x639>
mov    %rbx,%rbp
mov    -0x68(%rsp),%rbx
mov    -0x38(%rsp),%r11
mov    -0x60(%rsp),%r9
mov    -0x80(%rsp),%rdi
mov    -0x58(%rsp),%rsi
jmp    1851 <fill_array_spiral+0x751>
nopl   (%rax)
mov    -0x38(%rsp),%r11
mov    -0x60(%rsp),%r9
mov    -0x58(%rsp),%rsi
mov    -0x78(%rsp),%rdx
jmp    1880 <fill_array_spiral+0x780>
sub    %rdx,%rcx
add    $0xfffffffffffffff9,%rcx
mov    %rcx,%r11
shr    $0x3,%r11
add    $0x1,%r11
movd   %r14d,%xmm5
pshufd $0x0,%xmm5,%xmm5
paddd  %xmm8,%xmm5
cmp    $0x8,%rcx
jae    1764 <fill_array_spiral+0x664>
xor    %edi,%edi
jmp    17d4 <fill_array_spiral+0x6d4>
mov    %r11,%rbp
and    $0xfffffffffffffffe,%rbp
mov    -0x80(%rsp),%rcx
lea    (%rcx,%r15,4),%rcx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
movdqa %xmm5,%xmm6
paddd  %xmm1,%xmm6
pshufd $0x1b,%xmm5,%xmm7
movdqu %xmm7,0x10(%rcx,%rdi,4)
pshufd $0x1b,%xmm6,%xmm6
movdqu %xmm6,(%rcx,%rdi,4)
movdqa %xmm5,%xmm6
paddd  %xmm2,%xmm6
movdqa %xmm5,%xmm7
paddd  %xmm3,%xmm7
pshufd $0x1b,%xmm6,%xmm6
movdqu %xmm6,-0x10(%rcx,%rdi,4)
pshufd $0x1b,%xmm7,%xmm6
movdqu %xmm6,-0x20(%rcx,%rdi,4)
paddd  %xmm4,%xmm5
add    $0xfffffffffffffff0,%rdi
add    $0xfffffffffffffffe,%rbp
jne    1780 <fill_array_spiral+0x680>
neg    %rdi
mov    %r9,%rdx
and    $0xfffffffffffffff8,%rdx
test   $0x1,%r11b
je     1813 <fill_array_spiral+0x713>
mov    %rbx,%rcx
imul   -0x40(%rsp),%rcx
mov    -0x30(%rsp),%rsi
lea    (%rsi,%rcx,4),%rcx
mov    %r15,%rsi
sub    %rdi,%rsi
pshufd $0x1b,%xmm5,%xmm6
paddd  %xmm1,%xmm5
movdqu %xmm6,-0xc(%rcx,%rsi,4)
pshufd $0x1b,%xmm5,%xmm5
movdqu %xmm5,-0x1c(%rcx,%rsi,4)
add    %edx,%r14d
cmp    %rdx,%r9
mov    -0x38(%rsp),%r11
mov    -0x60(%rsp),%r9
mov    -0x58(%rsp),%rsi
jne    183e <fill_array_spiral+0x73e>
mov    %rbx,%rbp
mov    -0x68(%rsp),%rbx
mov    -0x80(%rsp),%rdi
mov    -0x78(%rsp),%rdx
jmp    1880 <fill_array_spiral+0x780>
mov    %r15,%rcx
sub    %rdx,%rcx
mov    %rbx,%rbp
mov    -0x68(%rsp),%rbx
mov    -0x80(%rsp),%rdi
mov    -0x78(%rsp),%rdx
add    $0x1,%rcx
nopw   0x0(%rax,%rax,1)
mov    %r14d,-0x4(%rsi,%rcx,4)
add    $0x1,%r14d
add    $0xffffffffffffffff,%rcx
cmp    %r12,%rcx
jg     1860 <fill_array_spiral+0x760>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0xffffffffffffffff,%rbp
cmp    %r12,%rbp
mov    %rbp,-0x70(%rsp)
jle    1250 <fill_array_spiral+0x150>
mov    -0x40(%rsp),%rcx
imul   %r15,%rcx
mov    -0x8(%rsp),%rbp
lea    0x0(,%rcx,4),%rcx
add    %rbp,%rcx
mov    -0x44(%rsp),%ebp
nop
mov    %r14d,(%rcx)
add    $0x1,%r14d
add    $0xffffffffffffffff,%r15
add    %r10,%rcx
cmp    %r12,%r15
jg     18b0 <fill_array_spiral+0x7b0>
jmp    1254 <fill_array_spiral+0x154>
add    $0x30,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @fill_array_spiral(i32 %0, i32* %1) {
%3 = alloca i32
%4 = alloca i32*
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
store i32 %0, i32* %3
store i32* %1, i32** %4
%11 = load i32, i32* %3
%12 = zext i32 %11 to i64
%13 = load i32, i32* %3
%14 = sub nsw i32 %13, 1
store i32 %14, i32* %6
store i32 %14, i32* %5
store i32 1, i32* %7
store i32 0, i32* %8
store i32 0, i32* %9
br label %15
15: ; preds = %111, %2
%16 = load i32, i32* %7
%17 = load i32, i32* %3
%18 = load i32, i32* %3
%19 = mul nsw i32 %17, %18
%20 = icmp sle i32 %16, %19
br i1 %20, label %21, label %114
21: ; preds = %15
%22 = load i32, i32* %9
store i32 %22, i32* %10
br label %23
23: ; preds = %39, %21
%24 = load i32, i32* %10
%25 = load i32, i32* %6
%26 = icmp sle i32 %24, %25
br i1 %26, label %27, label %42
27: ; preds = %23
%28 = load i32, i32* %7
%29 = load i32*, i32** %4
%30 = load i32, i32* %8
%31 = sext i32 %30 to i64
%32 = mul nsw i64 %31, %12
%33 = getelementptr inbounds i32, i32* %29, i64 %32
%34 = load i32, i32* %10
%35 = sext i32 %34 to i64
%36 = getelementptr inbounds i32, i32* %33, i64 %35
store i32 %28, i32* %36
%37 = load i32, i32* %7
%38 = add nsw i32 %37, 1
store i32 %38, i32* %7
br label %39
39: ; preds = %27
%40 = load i32, i32* %10
%41 = add nsw i32 %40, 1
store i32 %41, i32* %10
br label %23
42: ; preds = %23
%43 = load i32, i32* %8
%44 = add nsw i32 %43, 1
store i32 %44, i32* %8
%45 = load i32, i32* %8
store i32 %45, i32* %10
br label %46
46: ; preds = %62, %42
%47 = load i32, i32* %10
%48 = load i32, i32* %5
%49 = icmp sle i32 %47, %48
br i1 %49, label %50, label %65
50: ; preds = %46
%51 = load i32, i32* %7
%52 = load i32*, i32** %4
%53 = load i32, i32* %10
%54 = sext i32 %53 to i64
%55 = mul nsw i64 %54, %12
%56 = getelementptr inbounds i32, i32* %52, i64 %55
%57 = load i32, i32* %6
%58 = sext i32 %57 to i64
%59 = getelementptr inbounds i32, i32* %56, i64 %58
store i32 %51, i32* %59
%60 = load i32, i32* %7
%61 = add nsw i32 %60, 1
store i32 %61, i32* %7
br label %62
62: ; preds = %50
%63 = load i32, i32* %10
%64 = add nsw i32 %63, 1
store i32 %64, i32* %10
br label %46
65: ; preds = %46
%66 = load i32, i32* %6
%67 = add nsw i32 %66, -1
store i32 %67, i32* %6
%68 = load i32, i32* %6
store i32 %68, i32* %10
br label %69
69: ; preds = %85, %65
%70 = load i32, i32* %10
%71 = load i32, i32* %9
%72 = icmp sge i32 %70, %71
br i1 %72, label %73, label %88
73: ; preds = %69
%74 = load i32, i32* %7
%75 = load i32*, i32** %4
%76 = load i32, i32* %5
%77 = sext i32 %76 to i64
%78 = mul nsw i64 %77, %12
%79 = getelementptr inbounds i32, i32* %75, i64 %78
%80 = load i32, i32* %10
%81 = sext i32 %80 to i64
%82 = getelementptr inbounds i32, i32* %79, i64 %81
store i32 %74, i32* %82
%83 = load i32, i32* %7
%84 = add nsw i32 %83, 1
store i32 %84, i32* %7
br label %85
85: ; preds = %73
%86 = load i32, i32* %10
%87 = add nsw i32 %86, -1
store i32 %87, i32* %10
br label %69
88: ; preds = %69
%89 = load i32, i32* %5
%90 = add nsw i32 %89, -1
store i32 %90, i32* %5
%91 = load i32, i32* %5
store i32 %91, i32* %10
br label %92
92: ; preds = %108, %88
%93 = load i32, i32* %10
%94 = load i32, i32* %8
%95 = icmp sge i32 %93, %94
br i1 %95, label %96, label %111
96: ; preds = %92
%97 = load i32, i32* %7
%98 = load i32*, i32** %4
%99 = load i32, i32* %10
%100 = sext i32 %99 to i64
%101 = mul nsw i64 %100, %12
%102 = getelementptr inbounds i32, i32* %98, i64 %101
%103 = load i32, i32* %9
%104 = sext i32 %103 to i64
%105 = getelementptr inbounds i32, i32* %102, i64 %104
store i32 %97, i32* %105
%106 = load i32, i32* %7
%107 = add nsw i32 %106, 1
store i32 %107, i32* %7
br label %108
108: ; preds = %96
%109 = load i32, i32* %10
%110 = add nsw i32 %109, -1
store i32 %110, i32* %10
br label %92
111: ; preds = %92
%112 = load i32, i32* %9
%113 = add nsw i32 %112, 1
store i32 %113, i32* %9
br label %15
114: ; preds = %15
ret void
}

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