#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 **generate(int numRows, int **columnSizes) {
  int **result = (int **)malloc(sizeof(int *) * numRows);
  for (int i = 0; i < numRows; ++i)
    result[i] = (int *)malloc(sizeof(int) * (i + 1));
  *columnSizes = (int *)malloc(sizeof(int) * numRows);
  for (int i = 0; i < numRows; ++i)
    (*columnSizes)[i] = i + 1;
  for (int i = 0; i < numRows; ++i)
    result[i][0] = result[i][i] = 1;
  for (int i = 1; i < numRows; ++i)
    for (int j = 1; j < i; ++j)
      result[i][j] = result[i - 1][j - 1] + result[i - 1][j];
  return result;
}


x86 assembly (clang, -O0):
<generate>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
movslq -0x4(%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    -0x4(%rbp),%eax
jge    1175 <generate+0x65>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
cltq
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    1139 <generate+0x29>
movslq -0x4(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1030 <malloc@plt>
mov    %rax,%rcx
mov    -0x10(%rbp),%rax
mov    %rcx,(%rax)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    11c3 <generate+0xb3>
mov    -0x20(%rbp),%edx
add    $0x1,%edx
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
movslq -0x20(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1195 <generate+0x85>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    120d <generate+0xfd>
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movl   $0x1,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movl   $0x1,(%rax)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    11ca <generate+0xba>
movl   $0x1,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    129c <generate+0x18c>
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1289 <generate+0x179>
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
add    (%rax,%rcx,4),%edx
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1227 <generate+0x117>
jmp    128e <generate+0x17e>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1214 <generate+0x104>
mov    -0x18(%rbp),%rax
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<generate>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %rsi,%rbx
mov    %edi,%r14d
lea    0x0(,%r14,8),%edi
call   1030 <malloc@plt>
mov    %rax,%r12
test   %r14d,%r14d
jle    1192 <generate+0x82>
mov    %rbx,(%rsp)
mov    %r14d,%r13d
lea    0x0(,%r13,4),%rbp
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
lea    0x4(%rbx),%r15
mov    %r15d,%edi
call   1030 <malloc@plt>
mov    %rax,(%r12,%rbx,2)
mov    %r15,%rbx
cmp    %r15,%rbp
jne    1150 <generate+0x40>
lea    0x0(,%r14,4),%edi
call   1030 <malloc@plt>
mov    (%rsp),%rcx
mov    %rax,(%rcx)
test   %r14d,%r14d
jle    14e3 <generate+0x3d3>
cmp    $0x8,%r14d
jae    11a6 <generate+0x96>
xor    %ecx,%ecx
jmp    1290 <generate+0x180>
shl    $0x2,%r14d
mov    %r14d,%edi
call   1030 <malloc@plt>
mov    %rax,(%rbx)
jmp    14e3 <generate+0x3d3>
mov    %r13d,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rsi
mov    %rsi,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
test   %rsi,%rsi
je     14f5 <generate+0x3e5>
mov    %rdx,%rdi
and    $0xfffffffffffffffe,%rdi
movaps 0xe3e(%rip),%xmm1
movaps 0xe47(%rip),%xmm0
xor    %esi,%esi
pcmpeqd %xmm8,%xmm8
movdqa 0xe47(%rip),%xmm9
movdqa 0xe4f(%rip),%xmm4
movdqa 0xe57(%rip),%xmm5
movdqa 0xe5f(%rip),%xmm6
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movaps %xmm0,%xmm7
shufps $0x88,%xmm1,%xmm7
movaps %xmm7,%xmm2
psubd  %xmm8,%xmm2
movaps %xmm7,%xmm3
paddd  %xmm9,%xmm3
movdqu %xmm2,(%rax,%rsi,4)
movdqu %xmm3,0x10(%rax,%rsi,4)
movaps %xmm7,%xmm2
paddd  %xmm4,%xmm2
paddd  %xmm5,%xmm7
movdqu %xmm2,0x20(%rax,%rsi,4)
movdqu %xmm7,0x30(%rax,%rsi,4)
add    $0x10,%rsi
paddq  %xmm6,%xmm0
paddq  %xmm6,%xmm1
add    $0xfffffffffffffffe,%rdi
jne    1210 <generate+0x100>
shufps $0x88,%xmm1,%xmm0
test   $0x1,%dl
je     1282 <generate+0x172>
pcmpeqd %xmm1,%xmm1
movaps %xmm0,%xmm2
psubd  %xmm1,%xmm2
paddd  0xdb9(%rip),%xmm0
movdqu %xmm2,(%rax,%rsi,4)
movdqu %xmm0,0x10(%rax,%rsi,4)
cmp    %r13,%rcx
je     129f <generate+0x18f>
nopw   0x0(%rax,%rax,1)
lea    0x1(%rcx),%rdx
mov    %edx,(%rax,%rcx,4)
mov    %rdx,%rcx
cmp    %rdx,%r13
jne    1290 <generate+0x180>
test   %r14d,%r14d
jle    14e3 <generate+0x3d3>
lea    -0x1(%r13),%rcx
mov    %r13d,%eax
and    $0x3,%eax
cmp    $0x3,%rcx
jae    12bc <generate+0x1ac>
xor    %ecx,%ecx
jmp    1323 <generate+0x213>
mov    %r13d,%edx
and    $0xfffffffc,%edx
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    (%r12,%rcx,8),%rsi
movl   $0x1,(%rsi,%rcx,4)
movl   $0x1,(%rsi)
mov    0x8(%r12,%rcx,8),%rsi
movl   $0x1,0x4(%rsi,%rcx,4)
movl   $0x1,(%rsi)
mov    0x10(%r12,%rcx,8),%rsi
movl   $0x1,0x8(%rsi,%rcx,4)
movl   $0x1,(%rsi)
mov    0x18(%r12,%rcx,8),%rsi
movl   $0x1,0xc(%rsi,%rcx,4)
movl   $0x1,(%rsi)
add    $0x4,%rcx
cmp    %rcx,%rdx
jne    12d0 <generate+0x1c0>
test   %rax,%rax
je     134b <generate+0x23b>
nopl   0x0(%rax,%rax,1)
mov    (%r12,%rcx,8),%rdx
movl   $0x1,(%rdx,%rcx,4)
movl   $0x1,(%rdx)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rax
jne    1330 <generate+0x220>
cmp    $0x2,%r14d
jl     14e3 <generate+0x3d3>
mov    $0x1,%eax
mov    $0xfffffffffffffff8,%r9
xor    %edx,%edx
jmp    1385 <generate+0x275>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%rax
add    $0x1,%rdx
add    $0x1,%r9
cmp    %r13,%rax
je     14e3 <generate+0x3d3>
cmp    $0x2,%rax
jb     1370 <generate+0x260>
mov    -0x8(%r12,%rax,8),%rsi
mov    (%r12,%rax,8),%rdi
mov    $0x1,%ebx
cmp    $0x8,%rdx
jb     14a0 <generate+0x390>
lea    0x4(%rdi),%rcx
lea    (%rsi,%rax,4),%rbp
cmp    %rbp,%rcx
jae    13bd <generate+0x2ad>
lea    (%rdi,%rax,4),%rcx
cmp    %rcx,%rsi
jb     14a0 <generate+0x390>
lea    -0x8(%rdx),%rcx
mov    %rcx,%r8
shr    $0x3,%r8
add    $0x1,%r8
cmp    $0x8,%rcx
jae    13d6 <generate+0x2c6>
xor    %ecx,%ecx
jmp    1451 <generate+0x341>
mov    %r9,%rbx
shr    $0x3,%rbx
add    $0x1,%rbx
and    $0xfffffffffffffffe,%rbx
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
movdqu (%rsi,%rcx,4),%xmm0
movdqu 0x4(%rsi,%rcx,4),%xmm1
paddd  %xmm0,%xmm1
movdqu 0x10(%rsi,%rcx,4),%xmm0
movdqu 0x14(%rsi,%rcx,4),%xmm2
paddd  %xmm0,%xmm2
movdqu %xmm1,0x4(%rdi,%rcx,4)
movdqu %xmm2,0x14(%rdi,%rcx,4)
movdqu 0x20(%rsi,%rcx,4),%xmm0
movdqu 0x24(%rsi,%rcx,4),%xmm1
paddd  %xmm0,%xmm1
movdqu 0x30(%rsi,%rcx,4),%xmm0
movdqu 0x34(%rsi,%rcx,4),%xmm2
paddd  %xmm0,%xmm2
movdqu %xmm1,0x24(%rdi,%rcx,4)
movdqu %xmm2,0x34(%rdi,%rcx,4)
add    $0x10,%rcx
add    $0xfffffffffffffffe,%rbx
jne    13f0 <generate+0x2e0>
mov    %rdx,%rbx
and    $0xfffffffffffffff8,%rbx
test   $0x1,%r8b
je     1493 <generate+0x383>
lea    0x0(,%rcx,4),%rbp
movdqu (%rsi,%rcx,4),%xmm0
movdqu 0x10(%rsi,%rcx,4),%xmm1
or     $0x4,%rbp
movdqu (%rsi,%rbp,1),%xmm2
paddd  %xmm0,%xmm2
movdqu 0x10(%rsi,%rbp,1),%xmm0
paddd  %xmm1,%xmm0
movdqu %xmm2,(%rdi,%rbp,1)
movdqu %xmm0,0x10(%rdi,%rbp,1)
cmp    %rbx,%rdx
je     1370 <generate+0x260>
or     $0x1,%rbx
mov    %rbx,%rcx
test   $0x1,%al
jne    14b5 <generate+0x3a5>
mov    (%rsi,%rbx,4),%ecx
add    -0x4(%rsi,%rbx,4),%ecx
mov    %ecx,(%rdi,%rbx,4)
lea    0x1(%rbx),%rcx
cmp    %rbx,%rdx
je     1370 <generate+0x260>
xchg   %ax,%ax
mov    (%rsi,%rcx,4),%ebp
add    -0x4(%rsi,%rcx,4),%ebp
mov    %ebp,(%rdi,%rcx,4)
mov    0x4(%rsi,%rcx,4),%ebp
add    (%rsi,%rcx,4),%ebp
mov    %ebp,0x4(%rdi,%rcx,4)
add    $0x2,%rcx
cmp    %rcx,%rax
jne    14c0 <generate+0x3b0>
jmp    1370 <generate+0x260>
mov    %r12,%rax
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
movaps 0xb04(%rip),%xmm0
xor    %esi,%esi
test   $0x1,%dl
jne    1264 <generate+0x154>
jmp    1282 <generate+0x172>

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

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