#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 rSize, int **colSizes) {
  if (rSize == 0)
    return NULL;
  *colSizes = (int *)malloc(sizeof(int) * rSize);
  int **arrs = (int **)malloc(sizeof(int *) * rSize);
  for (int i = 0; i < rSize; i++) {
    (*colSizes)[i] = i + 1;
    arrs[i] = (int *)malloc(sizeof(int) * (i + 1));
    for (int j = 0; j < i + 1; j++)
      arrs[i][j] = 1;
  }
  for (int i = 2; i < rSize; i++)
    for (int j = 1; j < (*colSizes)[i]; j++)
      if (j < (*colSizes)[i - 1])
        arrs[i][j] = arrs[i - 1][j - 1] + arrs[i - 1][j];
  return arrs;
}


x86 assembly (clang, -O0):
<generate>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %edi,-0xc(%rbp)
mov    %rsi,-0x18(%rbp)
cmpl   $0x0,-0xc(%rbp)
jne    1136 <generate+0x26>
movq   $0x0,-0x8(%rbp)
jmp    12be <generate+0x1ae>
movslq -0xc(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1030 <malloc@plt>
mov    %rax,%rcx
mov    -0x18(%rbp),%rax
mov    %rcx,(%rax)
movslq -0xc(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1030 <malloc@plt>
mov    %rax,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    11fb <generate+0xeb>
mov    -0x24(%rbp),%edx
add    $0x1,%edx
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
movslq -0x24(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
cltq
shl    $0x2,%rax
mov    %eax,%edi
call   1030 <malloc@plt>
mov    %rax,%rdx
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    11e8 <generate+0xd8>
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movl   $0x1,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    11b2 <generate+0xa2>
jmp    11ed <generate+0xdd>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1169 <generate+0x59>
movl   $0x2,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    12b6 <generate+0x1a6>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x18(%rbp),%rcx
mov    (%rcx),%rcx
movslq -0x2c(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    12a3 <generate+0x193>
mov    -0x30(%rbp),%eax
mov    -0x18(%rbp),%rcx
mov    (%rcx),%rcx
mov    -0x2c(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
jge    1290 <generate+0x180>
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
add    (%rax,%rcx,4),%edx
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1295 <generate+0x185>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1215 <generate+0x105>
jmp    12a8 <generate+0x198>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1202 <generate+0xf2>
mov    -0x20(%rbp),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%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
test   %edi,%edi
je     133e <generate+0x22e>
mov    %rsi,%r14
mov    %edi,%ebx
lea    0x0(,%rbx,4),%edi
call   1030 <malloc@plt>
mov    %rax,(%r14)
lea    0x0(,%rbx,8),%edi
call   1030 <malloc@plt>
mov    %rax,%r15
test   %ebx,%ebx
jle    1341 <generate+0x231>
mov    %rbx,(%rsp)
mov    %ebx,%r12d
mov    $0x1,%ebp
xor    %r13d,%r13d
jmp    116d <generate+0x5d>
nop
add    $0x1,%rbp
cmp    %r12,%r13
je     12d6 <generate+0x1c6>
mov    %r13,%rbx
add    $0x1,%r13
mov    (%r14),%rax
mov    %r13d,(%rax,%rbx,4)
lea    0x0(,%r13,4),%edi
call   1030 <malloc@plt>
mov    %rax,(%r15,%rbx,8)
cmp    $0x8,%rbp
jae    11a0 <generate+0x90>
xor    %ecx,%ecx
jmp    12c9 <generate+0x1b9>
nopl   0x0(%rax)
mov    %rbp,%rdx
and    $0xfffffffffffffff8,%rdx
add    $0xfffffffffffffff8,%rdx
shr    $0x3,%rdx
mov    %rbp,%rcx
movabs $0x7ffffffffffffff8,%rsi
ff ff 7f
and    %rsi,%rcx
lea    -0x8(%rcx),%rsi
mov    %rsi,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
cmp    $0x38,%rsi
jae    11f0 <generate+0xe0>
xor    %esi,%esi
movaps 0xe23(%rip),%xmm0
jmp    1281 <generate+0x171>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    0x1(%rdx),%rbx
and    $0xfffffffffffffff8,%rbx
xor    %esi,%esi
movaps 0xdff(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movups %xmm0,(%rax,%rsi,4)
movups %xmm0,0x10(%rax,%rsi,4)
movups %xmm0,0x20(%rax,%rsi,4)
movups %xmm0,0x30(%rax,%rsi,4)
movups %xmm0,0x40(%rax,%rsi,4)
movups %xmm0,0x50(%rax,%rsi,4)
movups %xmm0,0x60(%rax,%rsi,4)
movups %xmm0,0x70(%rax,%rsi,4)
movups %xmm0,0x80(%rax,%rsi,4)
movups %xmm0,0x90(%rax,%rsi,4)
movups %xmm0,0xa0(%rax,%rsi,4)
movups %xmm0,0xb0(%rax,%rsi,4)
movups %xmm0,0xc0(%rax,%rsi,4)
movups %xmm0,0xd0(%rax,%rsi,4)
movups %xmm0,0xe0(%rax,%rsi,4)
movups %xmm0,0xf0(%rax,%rsi,4)
add    $0x40,%rsi
add    $0xfffffffffffffff8,%rbx
jne    1210 <generate+0x100>
test   $0x7,%dil
je     12c0 <generate+0x1b0>
add    $0x1,%dl
movzbl %dl,%edx
and    $0x7,%edx
shl    $0x5,%rdx
lea    (%rax,%rsi,4),%rsi
add    $0x10,%rsi
xor    %edi,%edi
xchg   %ax,%ax
movups %xmm0,-0x10(%rsi,%rdi,1)
movups %xmm0,(%rsi,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%rdx
jne    12a0 <generate+0x190>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
cmp    %rcx,%rbp
je     1160 <generate+0x50>
movl   $0x1,(%rax,%rcx,4)
add    $0x1,%rcx
jmp    12c0 <generate+0x1b0>
cmpl   $0x3,(%rsp)
jl     1341 <generate+0x231>
mov    (%r14),%rax
mov    $0x2,%ecx
jmp    12f9 <generate+0x1e9>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%rcx
cmp    %r12,%rcx
je     1341 <generate+0x231>
mov    (%rax,%rcx,4),%esi
cmp    $0x2,%esi
jl     12f0 <generate+0x1e0>
mov    $0x1,%edx
jmp    131c <generate+0x20c>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rdx
movslq %esi,%rdi
cmp    %rdi,%rdx
jge    12f0 <generate+0x1e0>
movslq -0x4(%rax,%rcx,4),%rdi
cmp    %rdi,%rdx
jge    1310 <generate+0x200>
mov    -0x8(%r15,%rcx,8),%rsi
mov    (%r15,%rcx,8),%rdi
mov    (%rsi,%rdx,4),%ebp
add    -0x4(%rsi,%rdx,4),%ebp
mov    %ebp,(%rdi,%rdx,4)
mov    (%rax,%rcx,4),%esi
jmp    1310 <generate+0x200>
xor    %r15d,%r15d
mov    %r15,%rax
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define i32** @generate(i32 %0, i32** nocapture %1) {
%3 = icmp eq i32 %0, 0
br i1 %3, label %146, label %4
4: ; preds = %2
%5 = shl i32 %0, 2
%6 = tail call i64 @malloc(i32 %5)
%7 = inttoptr i64 %6 to i32*
store i32* %7, i32** %1
%8 = shl i32 %0, 3
%9 = tail call i64 @malloc(i32 %8)
%10 = inttoptr i64 %9 to i32**
%11 = icmp sgt i32 %0, 0
br i1 %11, label %12, label %146
12: ; preds = %4
%13 = zext i32 %0 to i64
br label %22
14: ; preds = %106, %102
%15 = add nuw nsw i64 %24, 1
%16 = icmp eq i64 %29, %13
br i1 %16, label %17, label %22
17: ; preds = %14
%18 = icmp sgt i32 %0, 2
br i1 %18, label %19, label %146
19: ; preds = %17
%20 = load i32*, i32** %1
%21 = zext i32 %0 to i64
br label %111
22: ; preds = %12, %14
%23 = phi i64 [ 0, %12 ], [ %29, %14 ]
%24 = phi i64 [ 1, %12 ], [ %15, %14 ]
%25 = and i64 %24, 9223372036854775800
%26 = add nsw i64 %25, -8
%27 = lshr exact i64 %26, 3
%28 = add nuw nsw i64 %27, 1
%29 = add nuw nsw i64 %23, 1
%30 = load i32*, i32** %1
%31 = getelementptr inbounds i32, i32* %30, i64 %23
%32 = trunc i64 %29 to i32
store i32 %32, i32* %31
%33 = shl i32 %32, 2
%34 = tail call i64 @malloc(i32 %33)
%35 = inttoptr i64 %34 to i32*
%36 = getelementptr inbounds i32*, i32** %10, i64 %23
store i32* %35, i32** %36
%37 = icmp ult i64 %24, 8
br i1 %37, label %104, label %38
38: ; preds = %22
%39 = and i64 %24, 9223372036854775800
%40 = and i64 %28, 7
%41 = icmp ult i64 %26, 56
br i1 %41, label %89, label %42
42: ; preds = %38
%43 = and i64 %28, 4611686018427387896
br label %44
44: ; preds = %44, %42
%45 = phi i64 [ 0, %42 ], [ %86, %44 ]
%46 = phi i64 [ 0, %42 ], [ %87, %44 ]
%47 = getelementptr inbounds i32, i32* %35, i64 %45
%48 = bitcast i32* %47 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %48
%49 = getelementptr inbounds i32, i32* %47, i64 4
%50 = bitcast i32* %49 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %50
%51 = or i64 %45, 8
%52 = getelementptr inbounds i32, i32* %35, i64 %51
%53 = bitcast i32* %52 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %53
%54 = getelementptr inbounds i32, i32* %52, i64 4
%55 = bitcast i32* %54 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %55
%56 = or i64 %45, 16
%57 = getelementptr inbounds i32, i32* %35, i64 %56
%58 = bitcast i32* %57 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %58
%59 = getelementptr inbounds i32, i32* %57, i64 4
%60 = bitcast i32* %59 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %60
%61 = or i64 %45, 24
%62 = getelementptr inbounds i32, i32* %35, i64 %61
%63 = bitcast i32* %62 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %63
%64 = getelementptr inbounds i32, i32* %62, i64 4
%65 = bitcast i32* %64 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %65
%66 = or i64 %45, 32
%67 = getelementptr inbounds i32, i32* %35, i64 %66
%68 = bitcast i32* %67 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %68
%69 = getelementptr inbounds i32, i32* %67, i64 4
%70 = bitcast i32* %69 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %70
%71 = or i64 %45, 40
%72 = getelementptr inbounds i32, i32* %35, i64 %71
%73 = bitcast i32* %72 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %73
%74 = getelementptr inbounds i32, i32* %72, i64 4
%75 = bitcast i32* %74 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %75
%76 = or i64 %45, 48
%77 = getelementptr inbounds i32, i32* %35, i64 %76
%78 = bitcast i32* %77 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %78
%79 = getelementptr inbounds i32, i32* %77, i64 4
%80 = bitcast i32* %79 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %80
%81 = or i64 %45, 56
%82 = getelementptr inbounds i32, i32* %35, i64 %81
%83 = bitcast i32* %82 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %83
%84 = getelementptr inbounds i32, i32* %82, i64 4
%85 = bitcast i32* %84 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %85
%86 = add nuw i64 %45, 64
%87 = add nuw i64 %46, 8
%88 = icmp eq i64 %87, %43
br i1 %88, label %89, label %44
89: ; preds = %44, %38
%90 = phi i64 [ 0, %38 ], [ %86, %44 ]
%91 = icmp eq i64 %40, 0
br i1 %91, label %102, label %92
92: ; preds = %89, %92
%93 = phi i64 [ %99, %92 ], [ %90, %89 ]
%94 = phi i64 [ %100, %92 ], [ 0, %89 ]
%95 = getelementptr inbounds i32, i32* %35, i64 %93
%96 = bitcast i32* %95 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %96
%97 = getelementptr inbounds i32, i32* %95, i64 4
%98 = bitcast i32* %97 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %98
%99 = add nuw i64 %93, 8
%100 = add i64 %94, 1
%101 = icmp eq i64 %100, %40
br i1 %101, label %102, label %92
102: ; preds = %92, %89
%103 = icmp eq i64 %24, %39
br i1 %103, label %14, label %104
104: ; preds = %22, %102
%105 = phi i64 [ 0, %22 ], [ %39, %102 ]
br label %106
106: ; preds = %104, %106
%107 = phi i64 [ %109, %106 ], [ %105, %104 ]
%108 = getelementptr inbounds i32, i32* %35, i64 %107
store i32 1, i32* %108
%109 = add nuw nsw i64 %107, 1
%110 = icmp eq i64 %109, %24
br i1 %110, label %14, label %106
111: ; preds = %19, %121
%112 = phi i64 [ 2, %19 ], [ %122, %121 ]
%113 = getelementptr inbounds i32, i32* %20, i64 %112
%114 = load i32, i32* %113
%115 = icmp sgt i32 %114, 1
br i1 %115, label %116, label %121
116: ; preds = %111
%117 = add nsw i64 %112, -1
%118 = getelementptr inbounds i32, i32* %20, i64 %117
%119 = getelementptr inbounds i32*, i32** %10, i64 %117
%120 = getelementptr inbounds i32*, i32** %10, i64 %112
br label %124
121: ; preds = %141, %111
%122 = add nuw nsw i64 %112, 1
%123 = icmp eq i64 %122, %21
br i1 %123, label %146, label %111
124: ; preds = %116, %141
%125 = phi i32 [ %114, %116 ], [ %142, %141 ]
%126 = phi i64 [ 1, %116 ], [ %143, %141 ]
%127 = load i32, i32* %118
%128 = sext i32 %127 to i64
%129 = icmp slt i64 %126, %128
br i1 %129, label %130, label %141
130: ; preds = %124
%131 = load i32*, i32** %119
%132 = add nsw i64 %126, -1
%133 = getelementptr inbounds i32, i32* %131, i64 %132
%134 = load i32, i32* %133
%135 = getelementptr inbounds i32, i32* %131, i64 %126
%136 = load i32, i32* %135
%137 = add nsw i32 %136, %134
%138 = load i32*, i32** %120
%139 = getelementptr inbounds i32, i32* %138, i64 %126
store i32 %137, i32* %139
%140 = load i32, i32* %113
br label %141
141: ; preds = %124, %130
%142 = phi i32 [ %125, %124 ], [ %140, %130 ]
%143 = add nuw nsw i64 %126, 1
%144 = sext i32 %142 to i64
%145 = icmp slt i64 %143, %144
br i1 %145, label %124, label %121
146: ; preds = %121, %4, %17, %2
%147 = phi i32** [ null, %2 ], [ %10, %17 ], [ %10, %4 ], [ %10, %121 ]
ret i32** %147
}