#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) {
  int **ret = (int **)malloc(sizeof(int *) * n);
  int i;
  for (i = 0; i < n; i++)
    ret[i] = (int *)malloc(sizeof(int) * n);
  int loop = n / 2;
  int north = 0;
  int south = n - 1;
  int west = 0;
  int east = n - 1;
  int k = 1;
  while (loop--) {
    for (i = west; i <= east; i++)
      ret[north][i] = k++;
    for (i = north + 1; i <= south - 1; i++)
      ret[i][east] = k++;
    for (i = east; i >= west; i--)
      ret[south][i] = k++;
    for (i = south - 1; i >= north + 1; i--)
      ret[i][west] = k++;
    north++, south--;
    west++, east--;
  }
  loop = n / 2;
  if (n % 2)
    ret[loop][loop] = k;
  return ret;
}


x86 assembly (clang, -O0):
<generateMatrix>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %edi,-0x4(%rbp)
movslq -0x4(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1030 <malloc@plt>
mov    %rax,-0x10(%rbp)
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    116d <generateMatrix+0x5d>
movslq -0x4(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1030 <malloc@plt>
mov    %rax,%rdx
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1135 <generateMatrix+0x25>
mov    -0x4(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x18(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x4(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x4(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x28(%rbp)
movl   $0x1,-0x2c(%rbp)
mov    -0x18(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x18(%rbp)
cmp    $0x0,%eax
je     12e7 <generateMatrix+0x1d7>
mov    -0x24(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x28(%rbp),%eax
jg     11f4 <generateMatrix+0xe4>
mov    -0x2c(%rbp),%edx
mov    %edx,%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x14(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    11bc <generateMatrix+0xac>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
mov    -0x20(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     123a <generateMatrix+0x12a>
mov    -0x2c(%rbp),%edx
mov    %edx,%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    11fd <generateMatrix+0xed>
mov    -0x28(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x24(%rbp),%eax
jl     1278 <generateMatrix+0x168>
mov    -0x2c(%rbp),%edx
mov    %edx,%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x14(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x14(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x14(%rbp)
jmp    1240 <generateMatrix+0x130>
mov    -0x20(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jl     12be <generateMatrix+0x1ae>
mov    -0x2c(%rbp),%edx
mov    %edx,%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x14(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x14(%rbp)
jmp    1281 <generateMatrix+0x171>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x20(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x20(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x28(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x28(%rbp)
jmp    11a2 <generateMatrix+0x92>
mov    -0x4(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x18(%rbp)
mov    -0x4(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
je     131f <generateMatrix+0x20f>
mov    -0x2c(%rbp),%edx
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x18(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<generateMatrix>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x58,%rsp
mov    %edi,%ebx
lea    0x0(,%rbx,8),%edi
call   1030 <malloc@plt>
mov    %rax,%r15
mov    %rbx,0x10(%rsp)
test   %ebx,%ebx
jle    1165 <generateMatrix+0x55>
mov    0x10(%rsp),%rax
lea    0x0(,%rax,4),%r14d
mov    %eax,%ebx
xor    %ebp,%ebp
nopl   0x0(%rax)
mov    %r14d,%edi
call   1030 <malloc@plt>
mov    %rax,(%r15,%rbp,8)
add    $0x1,%rbp
cmp    %rbp,%rbx
jne    1150 <generateMatrix+0x40>
mov    0x10(%rsp),%rax
mov    %eax,%ecx
shr    $0x1f,%ecx
add    %eax,%ecx
sar    %ecx
mov    %ecx,0x24(%rsp)
add    $0x1,%eax
mov    $0x1,%ecx
cmp    $0x3,%eax
jae    11a9 <generateMatrix+0x99>
testb  $0x1,0x10(%rsp)
je     1197 <generateMatrix+0x87>
movslq 0x24(%rsp),%rax
mov    (%r15,%rax,8),%rdx
mov    %ecx,(%rdx,%rax,4)
mov    %r15,%rax
add    $0x58,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    0x10(%rsp),%r10
lea    -0x1(%r10),%eax
movslq %eax,%rdx
lea    0x1(%rdx),%rax
mov    %rax,0x50(%rsp)
mov    %r15,%r13
add    $0x8,%r13
lea    -0x3(%rdx),%r11
lea    -0x7(%rdx),%r12
mov    $0x1,%ecx
mov    $0x1c,%r14d
movq   $0xfffffffffffffff8,0x40(%rsp)
ff ff
mov    $0x4,%eax
mov    %rax,0x38(%rsp)
mov    $0xffffffffffffffff,%rdi
xor    %r8d,%r8d
movdqa 0xe02(%rip),%xmm8
movdqa 0xe0a(%rip),%xmm1
movdqa 0xe12(%rip),%xmm2
movdqa 0xe1a(%rip),%xmm3
movdqa 0xe22(%rip),%xmm4
movdqa 0xe29(%rip),%xmm9
movdqa 0xe30(%rip),%xmm10
movdqa 0xe37(%rip),%xmm11
movdqa 0xe3f(%rip),%xmm0
mov    0x24(%rsp),%ebx
jmp    1283 <generateMatrix+0x173>
nopw   0x0(%rax,%rax,1)
add    $0xffffffffffffffff,%rdx
add    $0xffffffff,%r10d
add    $0x1,%r14
addq   $0xffffffffffffffff,0x40(%rsp)
addq   $0x1,0x38(%rsp)
add    $0x8,%r13
add    $0xffffffffffffffff,%rdi
add    $0xffffffffffffffff,%r11
add    $0xfffffffffffffffe,%r12
mov    %r9,%r8
test   %ebx,%ebx
je     1184 <generateMatrix+0x74>
mov    %r10d,%r10d
cmp    %rdx,%r8
mov    %rdi,0x18(%rsp)
mov    %ebx,0xc(%rsp)
jg     144d <generateMatrix+0x33d>
mov    %r12,%rbx
mov    %r10,%r12
sub    %r8,%r12
mov    (%r15,%r8,8),%rsi
cmp    $0x8,%r12
jae    12c0 <generateMatrix+0x1b0>
mov    %r14,%rdi
mov    %r8,%r14
mov    %rbx,%r12
jmp    141e <generateMatrix+0x30e>
nopl   0x0(%rax)
mov    %r11,0x30(%rsp)
mov    0x40(%rsp),%rax
lea    (%rax,%r10,1),%rbp
shr    $0x3,%rbp
mov    0x10(%rsp),%rax
sub    %r8d,%eax
sub    %r8,%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,%r11
shr    $0x3,%r11
add    $0x1,%r11
movd   %ecx,%xmm5
pshufd $0x0,%xmm5,%xmm5
paddd  %xmm8,%xmm5
cmp    $0x18,%rax
mov    %rsi,0x28(%rsp)
mov    %rbp,0x48(%rsp)
jae    1315 <generateMatrix+0x205>
mov    %r14,%rdi
xor    %r9d,%r9d
jmp    13b0 <generateMatrix+0x2a0>
add    $0x1,%rbp
and    $0xfffffffffffffffc,%rbp
mov    %r14,%rdi
lea    (%rsi,%r14,4),%rax
xor    %r9d,%r9d
nopw   0x0(%rax,%rax,1)
movdqa %xmm5,%xmm6
paddd  %xmm1,%xmm6
movdqu %xmm5,-0x70(%rax,%r9,4)
movdqu %xmm6,-0x60(%rax,%r9,4)
movdqa %xmm5,%xmm6
paddd  %xmm2,%xmm6
movdqa %xmm5,%xmm7
paddd  %xmm3,%xmm7
movdqu %xmm6,-0x50(%rax,%r9,4)
movdqu %xmm7,-0x40(%rax,%r9,4)
movdqa %xmm5,%xmm6
paddd  %xmm4,%xmm6
movdqa %xmm5,%xmm7
paddd  %xmm9,%xmm7
movdqu %xmm6,-0x30(%rax,%r9,4)
movdqu %xmm7,-0x20(%rax,%r9,4)
movdqa %xmm5,%xmm6
paddd  %xmm10,%xmm6
movdqa %xmm5,%xmm7
paddd  %xmm11,%xmm7
movdqu %xmm6,-0x10(%rax,%r9,4)
movdqu %xmm7,(%rax,%r9,4)
add    $0x20,%r9
paddd  %xmm0,%xmm5
add    $0xfffffffffffffffc,%rbp
jne    1330 <generateMatrix+0x220>
mov    %r12,%r14
and    $0xfffffffffffffff8,%r14
test   $0x3,%r11b
je     1401 <generateMatrix+0x2f1>
mov    0x48(%rsp),%rax
add    $0x1,%al
movzbl %al,%eax
and    $0x3,%eax
shl    $0x5,%rax
add    0x38(%rsp),%r9
mov    0x28(%rsp),%rsi
lea    (%rsi,%r9,4),%rbp
xor    %esi,%esi
xchg   %ax,%ax
movdqa %xmm5,%xmm6
paddd  %xmm1,%xmm6
movdqu %xmm5,-0x10(%rbp,%rsi,1)
movdqu %xmm6,0x0(%rbp,%rsi,1)
paddd  %xmm2,%xmm5
add    $0x20,%rsi
cmp    %rsi,%rax
jne    13e0 <generateMatrix+0x2d0>
add    %r14d,%ecx
cmp    %r14,%r12
mov    0x30(%rsp),%r11
jne    1413 <generateMatrix+0x303>
mov    %rbx,%r12
jmp    1441 <generateMatrix+0x331>
add    %r8,%r14
mov    %rbx,%r12
mov    0x28(%rsp),%rsi
lea    (%rsi,%r14,4),%rax
mov    %r10,%rsi
sub    %r14,%rsi
mov    %ecx,%ecx
xor    %ebp,%ebp
nopl   0x0(%rax)
lea    (%rcx,%rbp,1),%ebx
mov    %ebx,(%rax,%rbp,4)
add    $0x1,%rbp
cmp    %rbp,%rsi
jne    1430 <generateMatrix+0x320>
add    %ebp,%ecx
mov    %rdi,%r14
mov    0x18(%rsp),%rdi
mov    0xc(%rsp),%ebx
lea    0x1(%r8),%r9
cmp    %rdx,%r9
jge    147f <generateMatrix+0x36f>
mov    %edx,%eax
add    %rdi,%rax
mov    %ecx,%ebp
xor    %esi,%esi
nop
lea    (%rsi,%rbp,1),%ebx
mov    0x0(%r13,%rsi,8),%rdi
mov    %ebx,(%rdi,%rdx,4)
add    $0x1,%rsi
cmp    %rsi,%rax
jne    1460 <generateMatrix+0x350>
add    %esi,%ecx
mov    0x18(%rsp),%rdi
mov    0xc(%rsp),%ebx
cmp    %rdx,%r8
jg     15e0 <generateMatrix+0x4d0>
mov    0x50(%rsp),%rax
sub    %r8,%rax
sub    %r8,%rax
mov    (%r15,%rdx,8),%rbp
cmp    $0x8,%rax
jae    14b0 <generateMatrix+0x3a0>
mov    %rdx,%rax
jmp    15c8 <generateMatrix+0x4b8>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %r14,0x28(%rsp)
lea    -0x8(%rax),%rsi
mov    %rsi,%r14
shr    $0x3,%r14
add    $0x1,%r14
movd   %ecx,%xmm5
pshufd $0x0,%xmm5,%xmm5
paddd  %xmm8,%xmm5
cmp    $0x8,%rsi
mov    %r11,0x30(%rsp)
jae    14e5 <generateMatrix+0x3d5>
xor    %r11d,%r11d
jmp    156f <generateMatrix+0x45f>
mov    %r12,%rbx
mov    %r12,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
and    $0xfffffffffffffffe,%rsi
lea    0x0(,%r11,4),%r12
add    %rbp,%r12
xor    %r11d,%r11d
cs nopw 0x0(%rax,%rax,1)
nop
movdqa %xmm5,%xmm6
paddd  %xmm1,%xmm6
pshufd $0x1b,%xmm5,%xmm7
movdqu %xmm7,(%r12,%r11,4)
pshufd $0x1b,%xmm6,%xmm6
movdqu %xmm6,-0x10(%r12,%r11,4)
movdqa %xmm5,%xmm6
paddd  %xmm2,%xmm6
movdqa %xmm5,%xmm7
paddd  %xmm3,%xmm7
pshufd $0x1b,%xmm6,%xmm6
movdqu %xmm6,-0x20(%r12,%r11,4)
pshufd $0x1b,%xmm7,%xmm6
movdqu %xmm6,-0x30(%r12,%r11,4)
paddd  %xmm4,%xmm5
add    $0xfffffffffffffff0,%r11
add    $0xfffffffffffffffe,%rsi
jne    1510 <generateMatrix+0x400>
neg    %r11
mov    %rbx,%r12
mov    0xc(%rsp),%ebx
mov    %rax,%rsi
and    $0xfffffffffffffff8,%rsi
test   $0x1,%r14b
je     15a0 <generateMatrix+0x490>
mov    %ebx,%edi
mov    %rdx,%rbx
sub    %r11,%rbx
pshufd $0x1b,%xmm5,%xmm6
paddd  %xmm1,%xmm5
movdqu %xmm6,-0xc(%rbp,%rbx,4)
pshufd $0x1b,%xmm5,%xmm5
movdqu %xmm5,-0x1c(%rbp,%rbx,4)
mov    %edi,%ebx
add    %esi,%ecx
cmp    %rsi,%rax
mov    0x28(%rsp),%r14
jne    15b8 <generateMatrix+0x4a8>
mov    0x30(%rsp),%r11
mov    0x18(%rsp),%rdi
jmp    15e0 <generateMatrix+0x4d0>
mov    %rdx,%rax
sub    %rsi,%rax
mov    0x30(%rsp),%r11
mov    0x18(%rsp),%rdi
add    $0x1,%rax
nopl   0x0(%rax)
mov    %ecx,-0x4(%rbp,%rax,4)
add    $0x1,%ecx
add    $0xffffffffffffffff,%rax
cmp    %r8,%rax
jg     15d0 <generateMatrix+0x4c0>
add    $0xffffffff,%ebx
mov    %rdx,%rax
cmp    %rdx,%r9
jge    1250 <generateMatrix+0x140>
nop
mov    -0x8(%r15,%rax,8),%rsi
add    $0xffffffffffffffff,%rax
mov    %ecx,(%rsi,%r8,4)
add    $0x1,%ecx
cmp    %r9,%rax
jg     15f0 <generateMatrix+0x4e0>
jmp    1250 <generateMatrix+0x140>

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

LLVM IR (-O2):
define i32** @generateMatrix(i32 %0) {
%2 = shl i32 %0, 3
%3 = tail call i64 @malloc(i32 %2)
%4 = inttoptr i64 %3 to i32**
%5 = icmp sgt i32 %0, 0
br i1 %5, label %6, label %16
6: ; preds = %1
%7 = shl i32 %0, 2
%8 = zext i32 %0 to i64
br label %9
9: ; preds = %6, %9
%10 = phi i64 [ 0, %6 ], [ %14, %9 ]
%11 = tail call i64 @malloc(i32 %7)
%12 = inttoptr i64 %11 to i32*
%13 = getelementptr inbounds i32*, i32** %4, i64 %10
store i32* %12, i32** %13
%14 = add nuw nsw i64 %10, 1
%15 = icmp eq i64 %14, %8
br i1 %15, label %16, label %9
16: ; preds = %9, %1
%17 = sdiv i32 %0, 2
%18 = add i32 %0, 1
%19 = icmp ult i32 %18, 3
br i1 %19, label %242, label %20
20: ; preds = %16
%21 = add i32 %0, -1
%22 = sext i32 %21 to i64
%23 = add nsw i64 %22, 1
%24 = add nsw i64 %22, 1
br label %25
25: ; preds = %20, %236
%26 = phi i64 [ %22, %20 ], [ %238, %236 ]
%27 = phi i64 [ 1, %20 ], [ %241, %236 ]
%28 = phi i32 [ %0, %20 ], [ %240, %236 ]
%29 = phi i64 [ 0, %20 ], [ %137, %236 ]
%30 = phi i32 [ %17, %20 ], [ %48, %236 ]
%31 = phi i32 [ 1, %20 ], [ %237, %236 ]
%32 = mul nsw i64 %29, -2
%33 = add i64 %24, %32
%34 = add i64 %33, -8
%35 = lshr i64 %34, 3
%36 = add nuw nsw i64 %35, 1
%37 = trunc i64 %29 to i32
%38 = sub i32 %0, %37
%39 = zext i32 %38 to i64
%40 = sub nsw i64 %39, %29
%41 = add i64 %40, -8
%42 = lshr i64 %41, 3
%43 = add nuw nsw i64 %42, 1
%44 = zext i32 %28 to i64
%45 = sub nsw i64 %44, %29
%46 = mul nsw i64 %29, -2
%47 = add i64 %23, %46
%48 = add nsw i32 %30, -1
%49 = icmp sgt i64 %29, %26
br i1 %49, label %135, label %50
50: ; preds = %25
%51 = getelementptr inbounds i32*, i32** %4, i64 %29
%52 = load i32*, i32** %51
%53 = zext i32 %28 to i64
%54 = icmp ult i64 %45, 8
br i1 %54, label %125, label %55
55: ; preds = %50
%56 = and i64 %45, -8
%57 = add i64 %29, %56
%58 = trunc i64 %56 to i32
%59 = add i32 %31, %58
%60 = insertelement <4 x i32> poison, i32 %31, 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 %43, 3
%64 = icmp ult i64 %41, 24
br i1 %64, label %105, label %65
65: ; preds = %55
%66 = and i64 %43, 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 %29, %68
%72 = add <4 x i32> %69, <i32 4, i32 4, i32 4, i32 4>
%73 = getelementptr inbounds i32, i32* %52, 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 %29, %77
%80 = add <4 x i32> %69, <i32 12, i32 12, i32 12, i32 12>
%81 = getelementptr inbounds i32, i32* %52, 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 %29, %85
%88 = add <4 x i32> %69, <i32 20, i32 20, i32 20, i32 20>
%89 = getelementptr inbounds i32, i32* %52, 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 %29, %93
%96 = add <4 x i32> %69, <i32 28, i32 28, i32 28, i32 28>
%97 = getelementptr inbounds i32, i32* %52, 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 %29, %110
%114 = add <4 x i32> %111, <i32 4, i32 4, i32 4, i32 4>
%115 = getelementptr inbounds i32, i32* %52, 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 %45, %56
br i1 %124, label %135, label %125
125: ; preds = %50, %123
%126 = phi i64 [ %29, %50 ], [ %57, %123 ]
%127 = phi i32 [ %31, %50 ], [ %59, %123 ]
br label %128
128: ; preds = %125, %128
%129 = phi i64 [ %133, %128 ], [ %126, %125 ]
%130 = phi i32 [ %131, %128 ], [ %127, %125 ]
%131 = add nsw i32 %130, 1
%132 = getelementptr inbounds i32, i32* %52, i64 %129
store i32 %130, i32* %132
%133 = add nuw nsw i64 %129, 1
%134 = icmp eq i64 %133, %53
br i1 %134, label %135, label %128
135: ; preds = %128, %123, %25
%136 = phi i32 [ %31, %25 ], [ %59, %123 ], [ %131, %128 ]
%137 = add nuw nsw i64 %29, 1
%138 = icmp slt i64 %137, %26
br i1 %138, label %139, label %141
139: ; preds = %135
%140 = and i64 %26, 4294967295
br label %209
141: ; preds = %209, %135
%142 = phi i32 [ %136, %135 ], [ %212, %209 ]
br i1 %49, label %218, label %143
143: ; preds = %141
%144 = getelementptr inbounds i32*, i32** %4, i64 %26
%145 = load i32*, i32** %144
%146 = icmp ult i64 %47, 8
br i1 %146, label %206, label %147
147: ; preds = %143
%148 = and i64 %47, -8
%149 = sub i64 %26, %148
%150 = trunc i64 %148 to i32
%151 = add i32 %142, %150
%152 = insertelement <4 x i32> poison, i32 %142, i64 0
%153 = shufflevector <4 x i32> %152, <4 x i32> poison, <4 x i32> zeroinitializer
%154 = add <4 x i32> %153, <i32 0, i32 1, i32 2, i32 3>
%155 = and i64 %36, 1
%156 = icmp ult i64 %34, 8
br i1 %156, label %189, label %157
157: ; preds = %147
%158 = and i64 %36, 4611686018427387902
br label %159
159: ; preds = %159, %157
%160 = phi i64 [ 0, %157 ], [ %185, %159 ]
%161 = phi <4 x i32> [ %154, %157 ], [ %186, %159 ]
%162 = phi i64 [ 0, %157 ], [ %187, %159 ]
%163 = sub i64 %26, %160
%164 = add <4 x i32> %161, <i32 4, i32 4, i32 4, i32 4>
%165 = getelementptr inbounds i32, i32* %145, i64 %163
%166 = shufflevector <4 x i32> %161, <4 x i32> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%167 = getelementptr inbounds i32, i32* %165, i64 -3
%168 = bitcast i32* %167 to <4 x i32>*
store <4 x i32> %166, <4 x i32>* %168
%169 = shufflevector <4 x i32> %164, <4 x i32> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%170 = getelementptr inbounds i32, i32* %165, i64 -4
%171 = getelementptr inbounds i32, i32* %170, i64 -3
%172 = bitcast i32* %171 to <4 x i32>*
store <4 x i32> %169, <4 x i32>* %172
%173 = or i64 %160, 8
%174 = add <4 x i32> %161, <i32 8, i32 8, i32 8, i32 8>
%175 = sub i64 %26, %173
%176 = add <4 x i32> %161, <i32 12, i32 12, i32 12, i32 12>
%177 = getelementptr inbounds i32, i32* %145, i64 %175
%178 = shufflevector <4 x i32> %174, <4 x i32> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%179 = getelementptr inbounds i32, i32* %177, i64 -3
%180 = bitcast i32* %179 to <4 x i32>*
store <4 x i32> %178, <4 x i32>* %180
%181 = shufflevector <4 x i32> %176, <4 x i32> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%182 = getelementptr inbounds i32, i32* %177, i64 -4
%183 = getelementptr inbounds i32, i32* %182, i64 -3
%184 = bitcast i32* %183 to <4 x i32>*
store <4 x i32> %181, <4 x i32>* %184
%185 = add nuw i64 %160, 16
%186 = add <4 x i32> %161, <i32 16, i32 16, i32 16, i32 16>
%187 = add i64 %162, 2
%188 = icmp eq i64 %187, %158
br i1 %188, label %189, label %159
189: ; preds = %159, %147
%190 = phi i64 [ 0, %147 ], [ %185, %159 ]
%191 = phi <4 x i32> [ %154, %147 ], [ %186, %159 ]
%192 = icmp eq i64 %155, 0
br i1 %192, label %204, label %193
193: ; preds = %189
%194 = sub i64 %26, %190
%195 = add <4 x i32> %191, <i32 4, i32 4, i32 4, i32 4>
%196 = getelementptr inbounds i32, i32* %145, i64 %194
%197 = shufflevector <4 x i32> %191, <4 x i32> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%198 = getelementptr inbounds i32, i32* %196, i64 -3
%199 = bitcast i32* %198 to <4 x i32>*
store <4 x i32> %197, <4 x i32>* %199
%200 = shufflevector <4 x i32> %195, <4 x i32> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%201 = getelementptr inbounds i32, i32* %196, i64 -4
%202 = getelementptr inbounds i32, i32* %201, i64 -3
%203 = bitcast i32* %202 to <4 x i32>*
store <4 x i32> %200, <4 x i32>* %203
br label %204
204: ; preds = %189, %193
%205 = icmp eq i64 %47, %148
br i1 %205, label %218, label %206
206: ; preds = %143, %204
%207 = phi i64 [ %26, %143 ], [ %149, %204 ]
%208 = phi i32 [ %142, %143 ], [ %151, %204 ]
br label %220
209: ; preds = %139, %209
%210 = phi i64 [ %27, %139 ], [ %216, %209 ]
%211 = phi i32 [ %136, %139 ], [ %212, %209 ]
%212 = add nsw i32 %211, 1
%213 = getelementptr inbounds i32*, i32** %4, i64 %210
%214 = load i32*, i32** %213
%215 = getelementptr inbounds i32, i32* %214, i64 %26
store i32 %211, i32* %215
%216 = add nuw nsw i64 %210, 1
%217 = icmp eq i64 %216, %140
br i1 %217, label %141, label %209
218: ; preds = %220, %204, %141
%219 = phi i32 [ %142, %141 ], [ %151, %204 ], [ %223, %220 ]
br i1 %138, label %227, label %236
220: ; preds = %206, %220
%221 = phi i64 [ %225, %220 ], [ %207, %206 ]
%222 = phi i32 [ %223, %220 ], [ %208, %206 ]
%223 = add nsw i32 %222, 1
%224 = getelementptr inbounds i32, i32* %145, i64 %221
store i32 %222, i32* %224
%225 = add nsw i64 %221, -1
%226 = icmp sgt i64 %221, %29
br i1 %226, label %220, label %218
227: ; preds = %218, %227
%228 = phi i64 [ %230, %227 ], [ %26, %218 ]
%229 = phi i32 [ %231, %227 ], [ %219, %218 ]
%230 = add nsw i64 %228, -1
%231 = add nsw i32 %229, 1
%232 = getelementptr inbounds i32*, i32** %4, i64 %230
%233 = load i32*, i32** %232
%234 = getelementptr inbounds i32, i32* %233, i64 %29
store i32 %229, i32* %234
%235 = icmp sgt i64 %230, %137
br i1 %235, label %227, label %236
236: ; preds = %227, %218
%237 = phi i32 [ %219, %218 ], [ %231, %227 ]
%238 = add nsw i64 %26, -1
%239 = icmp eq i32 %48, 0
%240 = add i32 %28, -1
%241 = add nuw nsw i64 %27, 1
br i1 %239, label %242, label %25
242: ; preds = %236, %16
%243 = phi i32 [ 1, %16 ], [ %237, %236 ]
%244 = and i32 %0, 1
%245 = icmp eq i32 %244, 0
br i1 %245, label %251, label %246
246: ; preds = %242
%247 = sext i32 %17 to i64
%248 = getelementptr inbounds i32*, i32** %4, i64 %247
%249 = load i32*, i32** %248
%250 = getelementptr inbounds i32, i32* %249, i64 %247
store i32 %243, i32* %250
br label %251
251: ; preds = %246, %242
ret i32** %4
}