#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 */
scalar_t__ malloc(int);
int **generateMatrix(int n) {
  if (n == 0)
    return NULL;
  int size = n * n;
  int **ret = (int **)malloc(n * sizeof(int *));
  for (int i = 0; i < n; i++)
    ret[i] = (int *)malloc(n * sizeof(int));
  int round = 0;
  int i = 1;
  while (i < size) {
    for (int j = round; j < n - 1 - round; j++, i++)
      ret[round][j] = i;
    for (int j = round; j < n - 1 - round; j++, i++)
      ret[j][n - 1 - round] = i;
    for (int j = round; j < n - 1 - round; j++, i++)
      ret[n - 1 - round][n - 1 - j] = i;
    for (int j = round; j < n - 1 - round; j++, i++)
      ret[n - 1 - j][round] = i;
    round++;
  }
  if (n / 2 * 2 != n)
    ret[n / 2][n / 2] = size;
  return ret;
}


x86 assembly (clang, -O0):
<generateMatrix>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %edi,-0xc(%rbp)
cmpl   $0x0,-0xc(%rbp)
jne    1132 <generateMatrix+0x22>
movq   $0x0,-0x8(%rbp)
jmp    1355 <generateMatrix+0x245>
mov    -0xc(%rbp),%eax
imul   -0xc(%rbp),%eax
mov    %eax,-0x10(%rbp)
movslq -0xc(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1030 <malloc@plt>
mov    %rax,-0x18(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    118e <generateMatrix+0x7e>
movslq -0xc(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1030 <malloc@plt>
mov    %rax,%rdx
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1156 <generateMatrix+0x46>
movl   $0x0,-0x20(%rbp)
movl   $0x1,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    12f2 <generateMatrix+0x1e2>
mov    -0x20(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
sub    -0x20(%rbp),%ecx
cmp    %ecx,%eax
jge    11ef <generateMatrix+0xdf>
mov    -0x24(%rbp),%edx
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    11ae <generateMatrix+0x9e>
mov    -0x20(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
sub    -0x20(%rbp),%ecx
cmp    %ecx,%eax
jge    123e <generateMatrix+0x12e>
mov    -0x24(%rbp),%edx
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
sub    -0x20(%rbp),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    11f5 <generateMatrix+0xe5>
mov    -0x20(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
sub    -0x20(%rbp),%ecx
cmp    %ecx,%eax
jge    1295 <generateMatrix+0x185>
mov    -0x24(%rbp),%edx
mov    -0x18(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
sub    -0x20(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
sub    -0x30(%rbp),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1244 <generateMatrix+0x134>
mov    -0x20(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
sub    -0x20(%rbp),%ecx
cmp    %ecx,%eax
jge    12e4 <generateMatrix+0x1d4>
mov    -0x24(%rbp),%edx
mov    -0x18(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
sub    -0x34(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x20(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    129b <generateMatrix+0x18b>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    119c <generateMatrix+0x8c>
mov    -0xc(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
shl    $0x1,%eax
cmp    -0xc(%rbp),%eax
je     134d <generateMatrix+0x23d>
mov    -0x10(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0xc(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x50(%rbp),%rax
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x40(%rbp)
mov    -0xc(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    -0x44(%rbp),%edx
mov    %eax,%ecx
mov    -0x40(%rbp),%rax
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<generateMatrix>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x88,%rsp
test   %edi,%edi
je     17c8 <generateMatrix+0x6b8>
mov    %edi,%r12d
mov    %edi,%eax
imul   %r12d,%eax
mov    %eax,0x34(%rsp)
lea    0x0(,%r12,8),%edi
call   1030 <malloc@plt>
mov    %rax,%r15
test   %r12d,%r12d
jle    1175 <generateMatrix+0x65>
lea    0x0(,%r12,4),%r14d
mov    %r12d,%ebx
xor    %ebp,%ebp
nopl   0x0(%rax,%rax,1)
mov    %r14d,%edi
call   1030 <malloc@plt>
mov    %rax,(%r15,%rbp,8)
add    $0x1,%rbp
cmp    %rbp,%rbx
jne    1160 <generateMatrix+0x50>
mov    %r12,0x60(%rsp)
mov    %r15,0x50(%rsp)
cmpl   $0x2,0x34(%rsp)
jb     179c <generateMatrix+0x68c>
mov    0x60(%rsp),%rax
lea    -0x1(%rax),%ebx
movslq %ebx,%rcx
lea    0x3(%rax),%r13d
lea    -0x3(%rcx),%r14
mov    0x50(%rsp),%r11
lea    (%r11,%rcx,8),%r12
mov    %r11,%rax
add    $0x18,%rax
mov    %rax,0x78(%rsp)
mov    $0x1,%ebp
mov    $0x1c,%edi
mov    $0xfffffffffffffff8,%r10
mov    $0x4,%edx
xor    %eax,%eax
movdqa 0xe2d(%rip),%xmm8
movdqa 0xe35(%rip),%xmm1
movdqa 0xe3d(%rip),%xmm2
movdqa 0xe45(%rip),%xmm3
movdqa 0xe4d(%rip),%xmm4
movdqa 0xe54(%rip),%xmm9
movdqa 0xe5b(%rip),%xmm10
movdqa 0xe62(%rip),%xmm11
movdqa 0xe6a(%rip),%xmm0
mov    %r12,0x70(%rsp)
xor    %r8d,%r8d
mov    %rcx,0x18(%rsp)
jmp    126b <generateMatrix+0x15b>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x8(%rsp),%rdi
mov    0x38(%rsp),%r10
add    $0x1,%r8
add    $0xffffffff,%ebx
add    $0x1,%rdi
add    $0xffffffffffffffff,%r10
add    $0x1,%rdx
add    $0xffffffffffffffff,%rax
add    $0x8,%r11
add    $0x2,%r13b
add    $0xffffffffffffffff,%r14
add    $0xfffffffffffffff8,%r12
cmp    0x34(%rsp),%ebp
jge    179c <generateMatrix+0x68c>
mov    %ebx,%ebx
movzbl %r13b,%r13d
and    $0x3,%r13d
mov    %rcx,%r9
sub    %r8,%r9
cmp    %r9,%r8
jge    123a <generateMatrix+0x12a>
mov    %r12,0x58(%rsp)
mov    %rcx,%r12
mov    %rax,0x20(%rsp)
mov    %rdi,0x8(%rsp)
mov    %r10,0x38(%rsp)
lea    (%r10,%rbx,1),%r15
shr    $0x3,%r15
lea    0x1(%r15),%r10
mov    %rbx,%rcx
sub    %r8,%rcx
lea    -0x8(%rcx),%rsi
mov    %rsi,%rax
shr    $0x3,%rax
add    $0x1,%rax
mov    %rax,0x68(%rsp)
mov    0x50(%rsp),%rax
mov    (%rax,%r8,8),%rax
mov    %rax,0x40(%rsp)
mov    %rcx,%rax
mov    %rcx,0x48(%rsp)
cmp    $0x8,%rcx
mov    %rdx,0x10(%rsp)
mov    %rbx,0x28(%rsp)
mov    %rsi,0x80(%rsp)
jae    1300 <generateMatrix+0x1f0>
mov    %r14,%rdi
mov    %r8,%r14
mov    %r12,%rcx
mov    0x58(%rsp),%r12
jmp    1452 <generateMatrix+0x342>
xchg   %ax,%ax
movd   %ebp,%xmm5
pshufd $0x0,%xmm5,%xmm5
paddd  %xmm8,%xmm5
mov    %r14,%rdi
cmp    $0x18,%rsi
jae    1326 <generateMatrix+0x216>
xor    %ebx,%ebx
mov    %r12,%rcx
mov    0x58(%rsp),%r12
jmp    13c8 <generateMatrix+0x2b8>
mov    %r10,%rsi
and    $0xfffffffffffffffc,%rsi
mov    0x8(%rsp),%rax
mov    0x40(%rsp),%rcx
lea    (%rcx,%rax,4),%rax
xor    %ebx,%ebx
mov    %r12,%rcx
mov    0x58(%rsp),%r12
cs nopw 0x0(%rax,%rax,1)
nop
movdqa %xmm5,%xmm6
paddd  %xmm1,%xmm6
movdqu %xmm5,-0x70(%rax,%rbx,4)
movdqu %xmm6,-0x60(%rax,%rbx,4)
movdqa %xmm5,%xmm6
paddd  %xmm2,%xmm6
movdqa %xmm5,%xmm7
paddd  %xmm3,%xmm7
movdqu %xmm6,-0x50(%rax,%rbx,4)
movdqu %xmm7,-0x40(%rax,%rbx,4)
movdqa %xmm5,%xmm6
paddd  %xmm4,%xmm6
movdqa %xmm5,%xmm7
paddd  %xmm9,%xmm7
movdqu %xmm6,-0x30(%rax,%rbx,4)
movdqu %xmm7,-0x20(%rax,%rbx,4)
movdqa %xmm5,%xmm6
paddd  %xmm10,%xmm6
movdqa %xmm5,%xmm7
paddd  %xmm11,%xmm7
movdqu %xmm6,-0x10(%rax,%rbx,4)
movdqu %xmm7,(%rax,%rbx,4)
add    $0x20,%rbx
paddd  %xmm0,%xmm5
add    $0xfffffffffffffffc,%rsi
jne    1350 <generateMatrix+0x240>
mov    0x48(%rsp),%r14
and    $0xfffffffffffffff8,%r14
testb  $0x3,0x68(%rsp)
je     1420 <generateMatrix+0x310>
add    $0x1,%r15b
movzbl %r15b,%eax
and    $0x3,%eax
shl    $0x5,%rax
add    0x10(%rsp),%rbx
mov    0x40(%rsp),%rdx
lea    (%rdx,%rbx,4),%rdx
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
movdqa %xmm5,%xmm6
paddd  %xmm1,%xmm6
movdqu %xmm5,-0x10(%rdx,%rsi,1)
movdqu %xmm6,(%rdx,%rsi,1)
paddd  %xmm2,%xmm5
add    $0x20,%rsi
cmp    %rsi,%rax
jne    1400 <generateMatrix+0x2f0>
add    %r14d,%ebp
mov    0x48(%rsp),%r15
cmp    %r14,%r15
jne    144a <generateMatrix+0x33a>
mov    %rdi,%r14
mov    0x10(%rsp),%rdx
mov    0x20(%rsp),%rax
mov    0x28(%rsp),%rbx
cmp    %r9,%r8
jge    1230 <generateMatrix+0x120>
jmp    14a1 <generateMatrix+0x391>
add    %r8,%r14
mov    0x28(%rsp),%rbx
mov    0x40(%rsp),%rax
lea    (%rax,%r14,4),%rax
mov    %rbx,%rdx
sub    %r14,%rdx
mov    %ebp,%ebp
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nop
lea    (%rsi,%rbp,1),%ebx
mov    %ebx,(%rax,%rsi,4)
add    $0x1,%rsi
cmp    %rsi,%rdx
jne    1470 <generateMatrix+0x360>
add    %esi,%ebp
mov    %rdi,%r14
mov    0x10(%rsp),%rdx
mov    0x20(%rsp),%rax
mov    0x28(%rsp),%rbx
mov    0x48(%rsp),%r15
cmp    %r9,%r8
jge    1230 <generateMatrix+0x120>
mov    %r8,%rdi
not    %rdi
add    %rbx,%rdi
test   $0x3,%r15b
je     14eb <generateMatrix+0x3db>
mov    %ebp,%edx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    (%rdx,%rax,1),%esi
mov    (%r11,%rax,8),%rbx
mov    %esi,(%rbx,%r9,4)
add    $0x1,%rax
cmp    %rax,%r13
jne    14c0 <generateMatrix+0x3b0>
mov    %rax,%rdx
mov    0x20(%rsp),%rsi
sub    %rsi,%rdx
add    %eax,%ebp
mov    %rsi,%rax
mov    0x28(%rsp),%rbx
jmp    14ee <generateMatrix+0x3de>
mov    %r8,%rdx
cmp    $0x3,%rdi
mov    %rdi,0x40(%rsp)
jb     1560 <generateMatrix+0x450>
mov    %rbx,%rax
sub    %rdx,%rax
mov    0x78(%rsp),%rcx
lea    (%rcx,%rdx,8),%rsi
mov    %ebp,%edx
xor    %ebx,%ebx
nopl   0x0(%rax)
lea    (%rdx,%rbx,1),%edi
mov    -0x18(%rsi,%rbx,8),%rcx
mov    %edi,(%rcx,%r9,4)
mov    -0x10(%rsi,%rbx,8),%rcx
lea    (%rdx,%rbx,1),%edi
add    $0x1,%edi
mov    %edi,(%rcx,%r9,4)
mov    -0x8(%rsi,%rbx,8),%rcx
lea    0x2(%rdx,%rbx,1),%edi
mov    %edi,(%rcx,%r9,4)
mov    (%rsi,%rbx,8),%rcx
lea    (%rdx,%rbx,1),%edi
add    $0x3,%edi
mov    %edi,(%rcx,%r9,4)
add    $0x4,%rbx
cmp    %rbx,%rax
jne    1510 <generateMatrix+0x400>
add    %ebx,%ebp
mov    0x18(%rsp),%rcx
mov    0x20(%rsp),%rax
mov    0x28(%rsp),%rbx
cmp    %r9,%r8
jge    1594 <generateMatrix+0x484>
mov    %r15,%rcx
mov    %rbx,%r15
neg    %r15
mov    0x50(%rsp),%rax
mov    (%rax,%r9,8),%rax
cmp    $0x8,%rcx
jae    15a8 <generateMatrix+0x498>
mov    %r8,%rbx
mov    0x8(%rsp),%rdi
mov    0x38(%rsp),%r10
mov    0x10(%rsp),%rdx
jmp    16ae <generateMatrix+0x59e>
mov    0x8(%rsp),%rdi
mov    0x38(%rsp),%r10
mov    0x10(%rsp),%rdx
jmp    123a <generateMatrix+0x12a>
movd   %ebp,%xmm5
pshufd $0x0,%xmm5,%xmm5
paddd  %xmm8,%xmm5
cmpq   $0x8,0x80(%rsp)
mov    0x10(%rsp),%rdx
jae    15d4 <generateMatrix+0x4c4>
xor    %esi,%esi
mov    0x8(%rsp),%rdi
mov    0x38(%rsp),%r10
jmp    1651 <generateMatrix+0x541>
and    $0xfffffffffffffffe,%r10
mov    %rax,%rcx
lea    (%rax,%r14,4),%rax
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movdqa %xmm5,%xmm6
paddd  %xmm1,%xmm6
pshufd $0x1b,%xmm5,%xmm7
movdqu %xmm7,(%rax,%rsi,4)
pshufd $0x1b,%xmm6,%xmm6
movdqu %xmm6,-0x10(%rax,%rsi,4)
movdqa %xmm5,%xmm6
paddd  %xmm2,%xmm6
movdqa %xmm5,%xmm7
paddd  %xmm3,%xmm7
pshufd $0x1b,%xmm6,%xmm6
movdqu %xmm6,-0x20(%rax,%rsi,4)
pshufd $0x1b,%xmm7,%xmm6
movdqu %xmm6,-0x30(%rax,%rsi,4)
paddd  %xmm4,%xmm5
add    $0xfffffffffffffff0,%rsi
add    $0xfffffffffffffffe,%r10
jne    15f0 <generateMatrix+0x4e0>
neg    %rsi
mov    0x8(%rsp),%rdi
mov    0x38(%rsp),%r10
mov    %rcx,%rax
mov    0x48(%rsp),%rcx
mov    %rcx,%rbx
and    $0xfffffffffffffff8,%rbx
testb  $0x1,0x68(%rsp)
je     169d <generateMatrix+0x58d>
add    %r8,%rsi
mov    %rax,0x8(%rsp)
mov    0x18(%rsp),%rax
sub    %rsi,%rax
pshufd $0x1b,%xmm5,%xmm6
paddd  %xmm1,%xmm5
mov    0x8(%rsp),%rsi
movdqu %xmm6,-0xc(%rsi,%rax,4)
pshufd $0x1b,%xmm5,%xmm5
mov    0x8(%rsp),%rsi
movdqu %xmm5,-0x1c(%rsi,%rax,4)
mov    0x8(%rsp),%rax
add    %ebx,%ebp
cmp    %rbx,%rcx
jne    16ab <generateMatrix+0x59b>
mov    0x18(%rsp),%rcx
jmp    16cf <generateMatrix+0x5bf>
add    %r8,%rbx
mov    0x18(%rsp),%rcx
lea    (%rax,%rcx,4),%rax
neg    %rbx
nopw   0x0(%rax,%rax,1)
mov    %ebp,(%rax,%rbx,4)
add    $0x1,%ebp
add    $0xffffffffffffffff,%rbx
cmp    %rbx,%r15
jne    16c0 <generateMatrix+0x5b0>
cmp    %r9,%r8
jge    1716 <generateMatrix+0x606>
testb  $0x3,0x48(%rsp)
mov    0x28(%rsp),%rbx
je     1725 <generateMatrix+0x615>
mov    %r13,%rax
neg    %rax
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
mov    (%r12,%rdx,8),%rcx
mov    %ebp,(%rcx,%r8,4)
add    $0x1,%ebp
add    $0xffffffffffffffff,%rdx
cmp    %rdx,%rax
jne    16f0 <generateMatrix+0x5e0>
mov    %r8,%rsi
sub    %rdx,%rsi
mov    0x18(%rsp),%rcx
mov    0x10(%rsp),%rdx
jmp    1728 <generateMatrix+0x618>
mov    0x20(%rsp),%rax
mov    0x28(%rsp),%rbx
jmp    123a <generateMatrix+0x12a>
mov    %r8,%rsi
cmpq   $0x3,0x40(%rsp)
mov    0x20(%rsp),%rax
jb     123a <generateMatrix+0x12a>
neg    %rsi
mov    0x70(%rsp),%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    (%rdx,%rsi,8),%rax
mov    %ebp,(%rax,%r8,4)
mov    -0x8(%rdx,%rsi,8),%rax
lea    0x1(%rbp),%ecx
mov    %ecx,(%rax,%r8,4)
mov    -0x10(%rdx,%rsi,8),%rax
lea    0x2(%rbp),%ecx
mov    %ecx,(%rax,%r8,4)
mov    -0x18(%rdx,%rsi,8),%rax
lea    0x3(%rbp),%ecx
mov    %ecx,(%rax,%r8,4)
add    $0x4,%ebp
add    $0xfffffffffffffffc,%rsi
cmp    %rsi,%r15
jne    1750 <generateMatrix+0x640>
mov    0x18(%rsp),%rcx
mov    0x10(%rsp),%rdx
mov    0x20(%rsp),%rax
jmp    123a <generateMatrix+0x12a>
mov    0x60(%rsp),%rax
mov    %eax,%edx
shr    $0x1f,%edx
add    %eax,%edx
mov    %edx,%ecx
and    $0xfffffffe,%ecx
cmp    %eax,%ecx
mov    0x50(%rsp),%rax
je     17ca <generateMatrix+0x6ba>
sar    %edx
movslq %edx,%rdx
mov    (%rax,%rdx,8),%rcx
mov    0x34(%rsp),%esi
mov    %esi,(%rcx,%rdx,4)
jmp    17ca <generateMatrix+0x6ba>
xor    %eax,%eax
add    $0x88,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define i32** @generateMatrix(i32 %0) {
%2 = alloca i32**
%3 = alloca i32
%4 = alloca i32
%5 = alloca i32**
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
store i32 %0, i32* %3
%13 = load i32, i32* %3
%14 = icmp eq i32 %13, 0
br i1 %14, label %15, label %16
15: ; preds = %1
store i32** null, i32*** %2
br label %180
16: ; preds = %1
%17 = load i32, i32* %3
%18 = load i32, i32* %3
%19 = mul nsw i32 %17, %18
store i32 %19, i32* %4
%20 = load i32, i32* %3
%21 = sext i32 %20 to i64
%22 = mul i64 %21, 8
%23 = trunc i64 %22 to i32
%24 = call i64 @malloc(i32 %23)
%25 = inttoptr i64 %24 to i32**
store i32** %25, i32*** %5
store i32 0, i32* %6
br label %26
26: ; preds = %41, %16
%27 = load i32, i32* %6
%28 = load i32, i32* %3
%29 = icmp slt i32 %27, %28
br i1 %29, label %30, label %44
30: ; preds = %26
%31 = load i32, i32* %3
%32 = sext i32 %31 to i64
%33 = mul i64 %32, 4
%34 = trunc i64 %33 to i32
%35 = call i64 @malloc(i32 %34)
%36 = inttoptr i64 %35 to i32*
%37 = load i32**, i32*** %5
%38 = load i32, i32* %6
%39 = sext i32 %38 to i64
%40 = getelementptr inbounds i32*, i32** %37, i64 %39
store i32* %36, i32** %40
br label %41
41: ; preds = %30
%42 = load i32, i32* %6
%43 = add nsw i32 %42, 1
store i32 %43, i32* %6
br label %26
44: ; preds = %26
store i32 0, i32* %7
store i32 1, i32* %8
br label %45
45: ; preds = %157, %44
%46 = load i32, i32* %8
%47 = load i32, i32* %4
%48 = icmp slt i32 %46, %47
br i1 %48, label %49, label %160
49: ; preds = %45
%50 = load i32, i32* %7
store i32 %50, i32* %9
br label %51
51: ; preds = %68, %49
%52 = load i32, i32* %9
%53 = load i32, i32* %3
%54 = sub nsw i32 %53, 1
%55 = load i32, i32* %7
%56 = sub nsw i32 %54, %55
%57 = icmp slt i32 %52, %56
br i1 %57, label %58, label %73
58: ; preds = %51
%59 = load i32, i32* %8
%60 = load i32**, i32*** %5
%61 = load i32, i32* %7
%62 = sext i32 %61 to i64
%63 = getelementptr inbounds i32*, i32** %60, i64 %62
%64 = load i32*, i32** %63
%65 = load i32, i32* %9
%66 = sext i32 %65 to i64
%67 = getelementptr inbounds i32, i32* %64, i64 %66
store i32 %59, i32* %67
br label %68
68: ; preds = %58
%69 = load i32, i32* %9
%70 = add nsw i32 %69, 1
store i32 %70, i32* %9
%71 = load i32, i32* %8
%72 = add nsw i32 %71, 1
store i32 %72, i32* %8
br label %51
73: ; preds = %51
%74 = load i32, i32* %7
store i32 %74, i32* %10
br label %75
75: ; preds = %95, %73
%76 = load i32, i32* %10
%77 = load i32, i32* %3
%78 = sub nsw i32 %77, 1
%79 = load i32, i32* %7
%80 = sub nsw i32 %78, %79
%81 = icmp slt i32 %76, %80
br i1 %81, label %82, label %100
82: ; preds = %75
%83 = load i32, i32* %8
%84 = load i32**, i32*** %5
%85 = load i32, i32* %10
%86 = sext i32 %85 to i64
%87 = getelementptr inbounds i32*, i32** %84, i64 %86
%88 = load i32*, i32** %87
%89 = load i32, i32* %3
%90 = sub nsw i32 %89, 1
%91 = load i32, i32* %7
%92 = sub nsw i32 %90, %91
%93 = sext i32 %92 to i64
%94 = getelementptr inbounds i32, i32* %88, i64 %93
store i32 %83, i32* %94
br label %95
95: ; preds = %82
%96 = load i32, i32* %10
%97 = add nsw i32 %96, 1
store i32 %97, i32* %10
%98 = load i32, i32* %8
%99 = add nsw i32 %98, 1
store i32 %99, i32* %8
br label %75
100: ; preds = %75
%101 = load i32, i32* %7
store i32 %101, i32* %11
br label %102
102: ; preds = %125, %100
%103 = load i32, i32* %11
%104 = load i32, i32* %3
%105 = sub nsw i32 %104, 1
%106 = load i32, i32* %7
%107 = sub nsw i32 %105, %106
%108 = icmp slt i32 %103, %107
br i1 %108, label %109, label %130
109: ; preds = %102
%110 = load i32, i32* %8
%111 = load i32**, i32*** %5
%112 = load i32, i32* %3
%113 = sub nsw i32 %112, 1
%114 = load i32, i32* %7
%115 = sub nsw i32 %113, %114
%116 = sext i32 %115 to i64
%117 = getelementptr inbounds i32*, i32** %111, i64 %116
%118 = load i32*, i32** %117
%119 = load i32, i32* %3
%120 = sub nsw i32 %119, 1
%121 = load i32, i32* %11
%122 = sub nsw i32 %120, %121
%123 = sext i32 %122 to i64
%124 = getelementptr inbounds i32, i32* %118, i64 %123
store i32 %110, i32* %124
br label %125
125: ; preds = %109
%126 = load i32, i32* %11
%127 = add nsw i32 %126, 1
store i32 %127, i32* %11
%128 = load i32, i32* %8
%129 = add nsw i32 %128, 1
store i32 %129, i32* %8
br label %102
130: ; preds = %102
%131 = load i32, i32* %7
store i32 %131, i32* %12
br label %132
132: ; preds = %152, %130
%133 = load i32, i32* %12
%134 = load i32, i32* %3
%135 = sub nsw i32 %134, 1
%136 = load i32, i32* %7
%137 = sub nsw i32 %135, %136
%138 = icmp slt i32 %133, %137
br i1 %138, label %139, label %157
139: ; preds = %132
%140 = load i32, i32* %8
%141 = load i32**, i32*** %5
%142 = load i32, i32* %3
%143 = sub nsw i32 %142, 1
%144 = load i32, i32* %12
%145 = sub nsw i32 %143, %144
%146 = sext i32 %145 to i64
%147 = getelementptr inbounds i32*, i32** %141, i64 %146
%148 = load i32*, i32** %147
%149 = load i32, i32* %7
%150 = sext i32 %149 to i64
%151 = getelementptr inbounds i32, i32* %148, i64 %150
store i32 %140, i32* %151
br label %152
152: ; preds = %139
%153 = load i32, i32* %12
%154 = add nsw i32 %153, 1
store i32 %154, i32* %12
%155 = load i32, i32* %8
%156 = add nsw i32 %155, 1
store i32 %156, i32* %8
br label %132
157: ; preds = %132
%158 = load i32, i32* %7
%159 = add nsw i32 %158, 1
store i32 %159, i32* %7
br label %45
160: ; preds = %45
%161 = load i32, i32* %3
%162 = sdiv i32 %161, 2
%163 = mul nsw i32 %162, 2
%164 = load i32, i32* %3
%165 = icmp ne i32 %163, %164
br i1 %165, label %166, label %178
166: ; preds = %160
%167 = load i32, i32* %4
%168 = load i32**, i32*** %5
%169 = load i32, i32* %3
%170 = sdiv i32 %169, 2
%171 = sext i32 %170 to i64
%172 = getelementptr inbounds i32*, i32** %168, i64 %171
%173 = load i32*, i32** %172
%174 = load i32, i32* %3
%175 = sdiv i32 %174, 2
%176 = sext i32 %175 to i64
%177 = getelementptr inbounds i32, i32* %173, i64 %176
store i32 %167, i32* %177
br label %178
178: ; preds = %166, %160
%179 = load i32**, i32*** %5
store i32** %179, i32*** %2
br label %180
180: ; preds = %178, %15
%181 = load i32**, i32*** %2
ret i32** %181
}

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