#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 */
void *malloc(int);
int **generateMatrix(int n) {
  if (!n)
    return (NULL);
  int **m, i, squ, l, u;
  m = malloc(n * sizeof(int *));
  for (i = 0; i < n; i++)
    m[i] = malloc(n * sizeof(int));
  l = 0;
  u = n - 1;
  squ = 1;
  while (l < u) {
    for (i = l; i < u; i++)
      m[l][i] = squ++;
    for (i = l; i < u; i++)
      m[i][u] = squ++;
    for (i = u; i > l; i--)
      m[u][i] = squ++;
    for (i = u; i > l; i--)
      m[i][l] = squ++;
    l++;
    u--;
  }
  if (n % 2)
    m[n / 2][n / 2] = squ++;
  return (m);
}


x86 assembly (clang, -O0):
<generateMatrix>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %edi,-0xc(%rbp)
cmpl   $0x0,-0xc(%rbp)
jne    1132 <generateMatrix+0x22>
movq   $0x0,-0x8(%rbp)
jmp    131c <generateMatrix+0x20c>
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    1184 <generateMatrix+0x74>
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    114c <generateMatrix+0x3c>
movl   $0x0,-0x24(%rbp)
mov    -0xc(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x28(%rbp)
movl   $0x1,-0x20(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    12b6 <generateMatrix+0x1a6>
mov    -0x24(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    11e5 <generateMatrix+0xd5>
mov    -0x20(%rbp),%edx
mov    %edx,%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x1c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    11ad <generateMatrix+0x9d>
mov    -0x24(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1223 <generateMatrix+0x113>
mov    -0x20(%rbp),%edx
mov    %edx,%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    11eb <generateMatrix+0xdb>
mov    -0x28(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jle    1261 <generateMatrix+0x151>
mov    -0x20(%rbp),%edx
mov    %edx,%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x1c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
jmp    1229 <generateMatrix+0x119>
mov    -0x28(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jle    129f <generateMatrix+0x18f>
mov    -0x20(%rbp),%edx
mov    %edx,%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
jmp    1267 <generateMatrix+0x157>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x28(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x28(%rbp)
jmp    119b <generateMatrix+0x8b>
mov    -0xc(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
je     1314 <generateMatrix+0x204>
mov    -0x20(%rbp),%eax
mov    %eax,-0x34(%rbp)
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0xc(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x40(%rbp),%rax
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x30(%rbp)
mov    -0xc(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    -0x34(%rbp),%edx
mov    %eax,%ecx
mov    -0x30(%rbp),%rax
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<generateMatrix>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x78,%rsp
test   %edi,%edi
je     16ad <generateMatrix+0x59d>
mov    %edi,%ebx
lea    0x0(,%rbx,8),%edi
call   1030 <malloc@plt>
mov    %rax,%r15
mov    $0x1,%ebp
test   %ebx,%ebx
mov    %rbx,0x8(%rsp)
jle    168f <generateMatrix+0x57f>
lea    0x0(,%rbx,4),%r12d
mov    %ebx,%r14d
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
mov    %r12d,%edi
call   1030 <malloc@plt>
mov    %rax,(%r15,%rbx,8)
add    $0x1,%rbx
cmp    %rbx,%r14
jne    1160 <generateMatrix+0x50>
cmpl   $0x2,0x8(%rsp)
jl     168f <generateMatrix+0x57f>
lea    -0x1(%r14),%r12
lea    -0x2(%r14),%rbx
lea    -0x9(%r14),%r13
lea    -0x4(%r14),%rax
mov    %rax,0x28(%rsp)
mov    $0x1,%edi
sub    %r14,%rdi
lea    (%r15,%r14,8),%r9
add    $0xfffffffffffffff8,%r9
mov    $0x1,%ebp
mov    $0x1c,%eax
mov    %rax,0x20(%rsp)
mov    $0x4,%eax
mov    %rax,0x30(%rsp)
xor    %eax,%eax
mov    %rax,0x40(%rsp)
movdqa 0xe32(%rip),%xmm8
movdqa 0xe3a(%rip),%xmm1
movdqa 0xe42(%rip),%xmm2
movdqa 0xe4a(%rip),%xmm3
movdqa 0xe52(%rip),%xmm4
movdqa 0xe59(%rip),%xmm9
movdqa 0xe60(%rip),%xmm10
movdqa 0xe67(%rip),%xmm11
movdqa 0xe6f(%rip),%xmm0
mov    %rbx,%rcx
mov    %r15,%r10
mov    %r13,%rax
mov    %r13,(%rsp)
mov    %r12,%r8
xor    %r14d,%r14d
mov    %r12,0x68(%rsp)
mov    %rbx,0x38(%rsp)
jmp    1277 <generateMatrix+0x167>
add    $0x1,%r14
add    $0xffffffffffffffff,%r8
addq   $0x1,0x20(%rsp)
addq   $0xfffffffffffffffe,(%rsp)
addq   $0x1,0x30(%rsp)
addq   $0xffffffffffffffff,0x40(%rsp)
add    $0x8,%r10
addq   $0xffffffffffffffff,0x28(%rsp)
add    $0xffffffffffffffff,%r13
mov    0x70(%rsp),%rcx
add    $0xffffffffffffffff,%rcx
add    $0x1,%rdi
add    $0xfffffffffffffff8,%r9
cmp    %r8,%r14
jge    168f <generateMatrix+0x57f>
mov    %rdi,0x58(%rsp)
cmp    %r14,%rcx
mov    %r14,%rax
cmovl  %rcx,%rax
mov    %rax,0x48(%rsp)
mov    %rbx,%rax
sub    %r14,%rax
cmp    %r14,%rax
mov    %r14,%rdx
cmovl  %rax,%rdx
mov    %rdx,0x50(%rsp)
lea    (%r14,%r14,1),%rsi
mov    %r12,%r11
sub    %rsi,%r11
mov    (%r15,%r14,8),%rdx
cmp    $0x8,%r11
mov    %rcx,0x70(%rsp)
jae    12d0 <generateMatrix+0x1c0>
mov    %r14,%rcx
jmp    1440 <generateMatrix+0x330>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %rsi,0x10(%rsp)
mov    %rax,0x60(%rsp)
mov    (%rsp),%rdi
shr    $0x3,%rdi
lea    -0x8(%r11),%rax
mov    %rax,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
movd   %ebp,%xmm5
pshufd $0x0,%xmm5,%xmm5
paddd  %xmm8,%xmm5
cmp    $0x18,%rax
mov    %r13,0x18(%rsp)
jae    1320 <generateMatrix+0x210>
xor    %r12d,%r12d
jmp    13c5 <generateMatrix+0x2b5>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    0x1(%rdi),%rcx
and    $0xfffffffffffffffc,%rcx
mov    0x20(%rsp),%rax
lea    (%rdx,%rax,4),%r13
xor    %r12d,%r12d
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movdqa %xmm5,%xmm6
paddd  %xmm1,%xmm6
movdqu %xmm5,-0x70(%r13,%r12,4)
movdqu %xmm6,-0x60(%r13,%r12,4)
movdqa %xmm5,%xmm6
paddd  %xmm2,%xmm6
movdqa %xmm5,%xmm7
paddd  %xmm3,%xmm7
movdqu %xmm6,-0x50(%r13,%r12,4)
movdqu %xmm7,-0x40(%r13,%r12,4)
movdqa %xmm5,%xmm6
paddd  %xmm4,%xmm6
movdqa %xmm5,%xmm7
paddd  %xmm9,%xmm7
movdqu %xmm6,-0x30(%r13,%r12,4)
movdqu %xmm7,-0x20(%r13,%r12,4)
movdqa %xmm5,%xmm6
paddd  %xmm10,%xmm6
movdqa %xmm5,%xmm7
paddd  %xmm11,%xmm7
movdqu %xmm6,-0x10(%r13,%r12,4)
movdqu %xmm7,0x0(%r13,%r12,4)
add    $0x20,%r12
paddd  %xmm0,%xmm5
add    $0xfffffffffffffffc,%rcx
jne    1340 <generateMatrix+0x230>
mov    %r11,%rcx
and    $0xfffffffffffffff8,%rcx
test   $0x3,%sil
je     1410 <generateMatrix+0x300>
add    $0x1,%dil
movzbl %dil,%eax
and    $0x3,%eax
shl    $0x5,%rax
add    0x30(%rsp),%r12
lea    (%rdx,%r12,4),%rdi
xor    %ebx,%ebx
nopl   0x0(%rax)
movdqa %xmm5,%xmm6
paddd  %xmm1,%xmm6
movdqu %xmm5,-0x10(%rdi,%rbx,1)
movdqu %xmm6,(%rdi,%rbx,1)
paddd  %xmm2,%xmm5
add    $0x20,%rbx
cmp    %rbx,%rax
jne    13f0 <generateMatrix+0x2e0>
add    %ecx,%ebp
cmp    %rcx,%r11
mov    0x38(%rsp),%rbx
mov    0x60(%rsp),%rax
jne    1430 <generateMatrix+0x320>
mov    0x18(%rsp),%r13
mov    0x10(%rsp),%rsi
jmp    144f <generateMatrix+0x33f>
nopl   (%rax)
add    %r14,%rcx
mov    0x18(%rsp),%r13
mov    0x10(%rsp),%rsi
nopl   (%rax)
mov    %ebp,(%rdx,%rcx,4)
add    $0x1,%ebp
add    $0x1,%rcx
cmp    %rcx,%r8
jne    1440 <generateMatrix+0x330>
mov    %rbx,%rcx
sub    %rsi,%rcx
mov    %rax,%r12
test   $0x3,%r11b
je     1490 <generateMatrix+0x380>
mov    (%rsp),%rax
and    $0x3,%eax
mov    %ebp,%edx
xor    %edi,%edi
nopl   0x0(%rax)
lea    (%rdx,%rdi,1),%ebx
mov    (%r10,%rdi,8),%rsi
mov    %ebx,(%rsi,%r8,4)
add    $0x1,%rdi
cmp    %rdi,%rax
jne    1470 <generateMatrix+0x360>
mov    %rdi,%rdx
sub    0x40(%rsp),%rdx
add    %edi,%ebp
jmp    1493 <generateMatrix+0x383>
mov    %r14,%rdx
mov    0x50(%rsp),%rbx
mov    %r8,%r11
sub    %rbx,%r11
cmp    $0x3,%rcx
jb     14ea <generateMatrix+0x3da>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %ebp,%eax
mov    (%r15,%rdx,8),%rcx
mov    %ebp,(%rcx,%r8,4)
mov    0x8(%r15,%rdx,8),%rcx
lea    0x1(%rax),%esi
mov    %esi,(%rcx,%r8,4)
mov    0x10(%r15,%rdx,8),%rcx
lea    0x2(%rax),%esi
mov    %esi,(%rcx,%r8,4)
lea    0x4(%rax),%ebp
mov    0x18(%r15,%rdx,8),%rcx
add    $0x3,%eax
mov    %eax,(%rcx,%r8,4)
add    $0x4,%rdx
cmp    %rdx,%r8
jne    14b0 <generateMatrix+0x3a0>
mov    (%r15,%r8,8),%rcx
cmp    $0x8,%r11
jae    1500 <generateMatrix+0x3f0>
mov    %r8,%rax
jmp    15e0 <generateMatrix+0x4d0>
nopl   0x0(%rax)
lea    -0x8(%r11),%rax
mov    %rax,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
movd   %ebp,%xmm5
pshufd $0x0,%xmm5,%xmm5
paddd  %xmm8,%xmm5
cmp    $0x8,%rax
jae    1530 <generateMatrix+0x420>
xor    %edi,%edi
jmp    15a4 <generateMatrix+0x494>
nopw   0x0(%rax,%rax,1)
mov    %r13,%rdx
sub    0x48(%rsp),%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
and    $0xfffffffffffffffe,%rdx
mov    0x28(%rsp),%rax
lea    (%rcx,%rax,4),%rax
xor    %edi,%edi
nop
movdqa %xmm5,%xmm6
paddd  %xmm1,%xmm6
pshufd $0x1b,%xmm5,%xmm7
movdqu %xmm7,(%rax,%rdi,4)
pshufd $0x1b,%xmm6,%xmm6
movdqu %xmm6,-0x10(%rax,%rdi,4)
movdqa %xmm5,%xmm6
paddd  %xmm2,%xmm6
movdqa %xmm5,%xmm7
paddd  %xmm3,%xmm7
pshufd $0x1b,%xmm6,%xmm6
movdqu %xmm6,-0x20(%rax,%rdi,4)
pshufd $0x1b,%xmm7,%xmm6
movdqu %xmm6,-0x30(%rax,%rdi,4)
paddd  %xmm4,%xmm5
add    $0xfffffffffffffff0,%rdi
add    $0xfffffffffffffffe,%rdx
jne    1550 <generateMatrix+0x440>
neg    %rdi
mov    %r11,%rdx
and    $0xfffffffffffffff8,%rdx
test   $0x1,%sil
je     15d1 <generateMatrix+0x4c1>
mov    %r8,%rax
sub    %rdi,%rax
pshufd $0x1b,%xmm5,%xmm6
paddd  %xmm1,%xmm5
movdqu %xmm6,-0xc(%rcx,%rax,4)
pshufd $0x1b,%xmm5,%xmm5
movdqu %xmm5,-0x1c(%rcx,%rax,4)
add    %edx,%ebp
cmp    %rdx,%r11
je     15ef <generateMatrix+0x4df>
mov    %r8,%rax
sub    %rdx,%rax
xchg   %ax,%ax
mov    %ebp,(%rcx,%rax,4)
add    $0x1,%ebp
add    $0xffffffffffffffff,%rax
cmp    %r14,%rax
jg     15e0 <generateMatrix+0x4d0>
sub    %rbx,%r12
test   $0x3,%r11b
je     1630 <generateMatrix+0x520>
mov    %r8d,%eax
sub    0x48(%rsp),%al
movzbl %al,%eax
and    $0x3,%eax
neg    %rax
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
mov    (%r9,%rcx,8),%rdx
mov    %ebp,(%rdx,%r14,4)
add    $0x1,%ebp
add    $0xffffffffffffffff,%rcx
cmp    %rcx,%rax
jne    1610 <generateMatrix+0x500>
mov    0x58(%rsp),%rdi
sub    %rdi,%rcx
jmp    1638 <generateMatrix+0x528>
xchg   %ax,%ax
mov    %r8,%rcx
mov    0x58(%rsp),%rdi
cmp    $0x3,%r12
mov    0x68(%rsp),%r12
mov    0x38(%rsp),%rbx
jb     1230 <generateMatrix+0x120>
nopl   0x0(%rax)
mov    %ebp,%eax
mov    (%r15,%rcx,8),%rdx
mov    %ebp,(%rdx,%r14,4)
mov    -0x8(%r15,%rcx,8),%rdx
lea    0x1(%rax),%esi
mov    %esi,(%rdx,%r14,4)
mov    -0x10(%r15,%rcx,8),%rdx
lea    0x2(%rax),%esi
mov    %esi,(%rdx,%r14,4)
lea    0x4(%rax),%ebp
mov    -0x18(%r15,%rcx,8),%rdx
add    $0x3,%eax
mov    %eax,(%rdx,%r14,4)
add    $0xfffffffffffffffc,%rcx
cmp    %r14,%rcx
jg     1650 <generateMatrix+0x540>
jmp    1230 <generateMatrix+0x120>
mov    0x8(%rsp),%rcx
test   $0x1,%cl
je     16b0 <generateMatrix+0x5a0>
mov    %ecx,%eax
shr    $0x1f,%eax
add    %ecx,%eax
sar    %eax
cltq
mov    (%r15,%rax,8),%rcx
mov    %ebp,(%rcx,%rax,4)
jmp    16b0 <generateMatrix+0x5a0>
xor    %r15d,%r15d
mov    %r15,%rax
add    $0x78,%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
store i32 %0, i32* %3
%9 = load i32, i32* %3
%10 = icmp ne i32 %9, 0
br i1 %10, label %12, label %11
11: ; preds = %1
store i32** null, i32*** %2
br label %148
12: ; preds = %1
%13 = load i32, i32* %3
%14 = sext i32 %13 to i64
%15 = mul i64 %14, 8
%16 = trunc i64 %15 to i32
%17 = call i8* @malloc(i32 %16)
%18 = bitcast i8* %17 to i32**
store i32** %18, i32*** %4
store i32 0, i32* %5
br label %19
19: ; preds = %34, %12
%20 = load i32, i32* %5
%21 = load i32, i32* %3
%22 = icmp slt i32 %20, %21
br i1 %22, label %23, label %37
23: ; preds = %19
%24 = load i32, i32* %3
%25 = sext i32 %24 to i64
%26 = mul i64 %25, 4
%27 = trunc i64 %26 to i32
%28 = call i8* @malloc(i32 %27)
%29 = bitcast i8* %28 to i32*
%30 = load i32**, i32*** %4
%31 = load i32, i32* %5
%32 = sext i32 %31 to i64
%33 = getelementptr inbounds i32*, i32** %30, i64 %32
store i32* %29, i32** %33
br label %34
34: ; preds = %23
%35 = load i32, i32* %5
%36 = add nsw i32 %35, 1
store i32 %36, i32* %5
br label %19
37: ; preds = %19
store i32 0, i32* %7
%38 = load i32, i32* %3
%39 = sub nsw i32 %38, 1
store i32 %39, i32* %8
store i32 1, i32* %6
br label %40
40: ; preds = %124, %37
%41 = load i32, i32* %7
%42 = load i32, i32* %8
%43 = icmp slt i32 %41, %42
br i1 %43, label %44, label %129
44: ; preds = %40
%45 = load i32, i32* %7
store i32 %45, i32* %5
br label %46
46: ; preds = %61, %44
%47 = load i32, i32* %5
%48 = load i32, i32* %8
%49 = icmp slt i32 %47, %48
br i1 %49, label %50, label %64
50: ; preds = %46
%51 = load i32, i32* %6
%52 = add nsw i32 %51, 1
store i32 %52, i32* %6
%53 = load i32**, i32*** %4
%54 = load i32, i32* %7
%55 = sext i32 %54 to i64
%56 = getelementptr inbounds i32*, i32** %53, i64 %55
%57 = load i32*, i32** %56
%58 = load i32, i32* %5
%59 = sext i32 %58 to i64
%60 = getelementptr inbounds i32, i32* %57, i64 %59
store i32 %51, i32* %60
br label %61
61: ; preds = %50
%62 = load i32, i32* %5
%63 = add nsw i32 %62, 1
store i32 %63, i32* %5
br label %46
64: ; preds = %46
%65 = load i32, i32* %7
store i32 %65, i32* %5
br label %66
66: ; preds = %81, %64
%67 = load i32, i32* %5
%68 = load i32, i32* %8
%69 = icmp slt i32 %67, %68
br i1 %69, label %70, label %84
70: ; preds = %66
%71 = load i32, i32* %6
%72 = add nsw i32 %71, 1
store i32 %72, i32* %6
%73 = load i32**, i32*** %4
%74 = load i32, i32* %5
%75 = sext i32 %74 to i64
%76 = getelementptr inbounds i32*, i32** %73, i64 %75
%77 = load i32*, i32** %76
%78 = load i32, i32* %8
%79 = sext i32 %78 to i64
%80 = getelementptr inbounds i32, i32* %77, i64 %79
store i32 %71, i32* %80
br label %81
81: ; preds = %70
%82 = load i32, i32* %5
%83 = add nsw i32 %82, 1
store i32 %83, i32* %5
br label %66
84: ; preds = %66
%85 = load i32, i32* %8
store i32 %85, i32* %5
br label %86
86: ; preds = %101, %84
%87 = load i32, i32* %5
%88 = load i32, i32* %7
%89 = icmp sgt i32 %87, %88
br i1 %89, label %90, label %104
90: ; preds = %86
%91 = load i32, i32* %6
%92 = add nsw i32 %91, 1
store i32 %92, i32* %6
%93 = load i32**, i32*** %4
%94 = load i32, i32* %8
%95 = sext i32 %94 to i64
%96 = getelementptr inbounds i32*, i32** %93, i64 %95
%97 = load i32*, i32** %96
%98 = load i32, i32* %5
%99 = sext i32 %98 to i64
%100 = getelementptr inbounds i32, i32* %97, i64 %99
store i32 %91, i32* %100
br label %101
101: ; preds = %90
%102 = load i32, i32* %5
%103 = add nsw i32 %102, -1
store i32 %103, i32* %5
br label %86
104: ; preds = %86
%105 = load i32, i32* %8
store i32 %105, i32* %5
br label %106
106: ; preds = %121, %104
%107 = load i32, i32* %5
%108 = load i32, i32* %7
%109 = icmp sgt i32 %107, %108
br i1 %109, label %110, label %124
110: ; preds = %106
%111 = load i32, i32* %6
%112 = add nsw i32 %111, 1
store i32 %112, i32* %6
%113 = load i32**, i32*** %4
%114 = load i32, i32* %5
%115 = sext i32 %114 to i64
%116 = getelementptr inbounds i32*, i32** %113, i64 %115
%117 = load i32*, i32** %116
%118 = load i32, i32* %7
%119 = sext i32 %118 to i64
%120 = getelementptr inbounds i32, i32* %117, i64 %119
store i32 %111, i32* %120
br label %121
121: ; preds = %110
%122 = load i32, i32* %5
%123 = add nsw i32 %122, -1
store i32 %123, i32* %5
br label %106
124: ; preds = %106
%125 = load i32, i32* %7
%126 = add nsw i32 %125, 1
store i32 %126, i32* %7
%127 = load i32, i32* %8
%128 = add nsw i32 %127, -1
store i32 %128, i32* %8
br label %40
129: ; preds = %40
%130 = load i32, i32* %3
%131 = srem i32 %130, 2
%132 = icmp ne i32 %131, 0
br i1 %132, label %133, label %146
133: ; preds = %129
%134 = load i32, i32* %6
%135 = add nsw i32 %134, 1
store i32 %135, i32* %6
%136 = load i32**, i32*** %4
%137 = load i32, i32* %3
%138 = sdiv i32 %137, 2
%139 = sext i32 %138 to i64
%140 = getelementptr inbounds i32*, i32** %136, i64 %139
%141 = load i32*, i32** %140
%142 = load i32, i32* %3
%143 = sdiv i32 %142, 2
%144 = sext i32 %143 to i64
%145 = getelementptr inbounds i32, i32* %141, i64 %144
store i32 %134, i32* %145
br label %146
146: ; preds = %133, %129
%147 = load i32**, i32*** %4
store i32** %147, i32*** %2
br label %148
148: ; preds = %146, %11
%149 = load i32**, i32*** %2
ret i32** %149
}

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