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


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    12c6 <generate+0x1b6>
movslq -0xc(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1030 <malloc@plt>
mov    %rax,-0x20(%rbp)
movslq -0xc(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1030 <malloc@plt>
mov    %rax,%rcx
mov    -0x18(%rbp),%rax
mov    %rcx,(%rax)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    11b9 <generate+0xa9>
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)
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
mov    %eax,-0x24(%rbp)
jmp    1169 <generate+0x59>
mov    -0x20(%rbp),%rax
mov    (%rax),%rax
movl   $0x1,(%rax)
cmpl   $0x1,-0xc(%rbp)
jne    11dd <generate+0xcd>
mov    -0x20(%rbp),%rax
mov    %rax,-0x8(%rbp)
jmp    12c6 <generate+0x1b6>
mov    -0x20(%rbp),%rax
mov    0x8(%rax),%rax
movl   $0x1,(%rax)
mov    -0x20(%rbp),%rax
mov    0x8(%rax),%rax
movl   $0x1,0x4(%rax)
movl   $0x2,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    12be <generate+0x1ae>
movl   $0x0,-0x28(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movl   $0x1,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movl   $0x1,(%rax,%rcx,4)
movl   $0x1,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    12ab <generate+0x19b>
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
add    (%rax,%rcx,4),%edx
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1249 <generate+0x139>
jmp    12b0 <generate+0x1a0>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1201 <generate+0xf1>
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     1375 <generate+0x265>
mov    %rsi,%rbp
mov    %edi,%ebx
lea    0x0(,%rbx,8),%edi
call   1030 <malloc@plt>
mov    %rax,%r15
lea    0x0(,%rbx,4),%edi
call   1030 <malloc@plt>
mov    %rax,0x0(%rbp)
test   %ebx,%ebx
jle    137a <generate+0x26a>
mov    %rax,%r13
mov    %rbx,(%rsp)
mov    %ebx,%r12d
mov    $0x4,%ebp
xor    %ebx,%ebx
lea    0x1(%rbx),%r14
mov    %ebp,%edi
call   1030 <malloc@plt>
mov    %rax,(%r15,%rbx,8)
mov    %r14d,0x0(%r13,%rbx,4)
add    $0x4,%ebp
mov    %r14,%rbx
cmp    %r14,%r12
jne    1160 <generate+0x50>
mov    (%r15),%rax
movl   $0x1,(%rax)
cmpl   $0x1,(%rsp)
je     1394 <generate+0x284>
mov    0x8(%r15),%rax
movabs $0x100000001,%rcx
mov    %rcx,(%rax)
cmp    $0x3,%r12d
jl     1394 <generate+0x284>
mov    $0x2,%ecx
mov    $0xfffffffffffffff9,%r10
xor    %r9d,%r9d
jmp    11d1 <generate+0xc1>
xchg   %ax,%ax
add    $0x1,%rcx
add    $0x1,%r10
cmp    %r12,%rcx
je     1394 <generate+0x284>
mov    %rax,%rdi
mov    %r9,%rbp
add    $0x1,%r9
mov    (%r15,%rcx,8),%rax
movl   $0x1,(%rax)
movl   $0x1,(%rax,%rcx,4)
mov    $0x1,%edx
cmp    $0x8,%r9
jae    1240 <generate+0x130>
mov    %rdx,%rsi
test   $0x1,%cl
jne    120d <generate+0xfd>
mov    (%rdi,%rdx,4),%esi
add    -0x4(%rdi,%rdx,4),%esi
mov    %esi,(%rax,%rdx,4)
lea    0x1(%rdx),%rsi
cmp    %rdx,%r9
je     11c0 <generate+0xb0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    (%rdi,%rsi,4),%edx
add    -0x4(%rdi,%rsi,4),%edx
mov    %edx,(%rax,%rsi,4)
mov    0x4(%rdi,%rsi,4),%edx
add    (%rdi,%rsi,4),%edx
mov    %edx,0x4(%rax,%rsi,4)
add    $0x2,%rsi
cmp    %rsi,%rcx
jne    1220 <generate+0x110>
jmp    11c0 <generate+0xb0>
lea    0x2(%rbp),%rsi
lea    0x4(%rax),%rbx
lea    (%rax,%rsi,4),%r8
lea    (%rdi,%rbp,4),%r11
add    $0x4,%r11
lea    0x4(%rdi),%r14
lea    (%rdi,%rsi,4),%rsi
cmp    %r11,%rbx
setb   %r11b
cmp    %r8,%rdi
setb   %r13b
cmp    %rsi,%rbx
setb   %bl
cmp    %r8,%r14
setb   %sil
test   %r13b,%r11b
jne    11f7 <generate+0xe7>
and    %sil,%bl
jne    11f7 <generate+0xe7>
add    $0xfffffffffffffff9,%rbp
mov    %rbp,%r8
shr    $0x3,%r8
add    $0x1,%r8
cmp    $0x8,%rbp
jae    12a2 <generate+0x192>
xor    %ebx,%ebx
jmp    1321 <generate+0x211>
mov    %r10,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movdqu (%rdi,%rbx,4),%xmm0
movdqu 0x4(%rdi,%rbx,4),%xmm1
paddd  %xmm0,%xmm1
movdqu 0x10(%rdi,%rbx,4),%xmm0
movdqu 0x14(%rdi,%rbx,4),%xmm2
paddd  %xmm0,%xmm2
movdqu %xmm1,0x4(%rax,%rbx,4)
movdqu %xmm2,0x14(%rax,%rbx,4)
movdqu 0x20(%rdi,%rbx,4),%xmm0
movdqu 0x24(%rdi,%rbx,4),%xmm1
paddd  %xmm0,%xmm1
movdqu 0x30(%rdi,%rbx,4),%xmm0
movdqu 0x34(%rdi,%rbx,4),%xmm2
paddd  %xmm0,%xmm2
movdqu %xmm1,0x24(%rax,%rbx,4)
movdqu %xmm2,0x34(%rax,%rbx,4)
add    $0x10,%rbx
add    $0xfffffffffffffffe,%rsi
jne    12c0 <generate+0x1b0>
mov    %r9,%rdx
and    $0xfffffffffffffff8,%rdx
test   $0x1,%r8b
je     1363 <generate+0x253>
lea    0x0(,%rbx,4),%rsi
movdqu (%rdi,%rbx,4),%xmm0
movdqu 0x10(%rdi,%rbx,4),%xmm1
or     $0x4,%rsi
movdqu (%rdi,%rsi,1),%xmm2
paddd  %xmm0,%xmm2
movdqu 0x10(%rdi,%rsi,1),%xmm0
paddd  %xmm1,%xmm0
movdqu %xmm2,(%rax,%rsi,1)
movdqu %xmm0,0x10(%rax,%rsi,1)
cmp    %rdx,%r9
je     11c0 <generate+0xb0>
or     $0x1,%rdx
jmp    11f7 <generate+0xe7>
xor    %r15d,%r15d
jmp    1394 <generate+0x284>
mov    (%r15),%rax
movl   $0x1,(%rax)
mov    0x8(%r15),%rax
movabs $0x100000001,%rcx
mov    %rcx,(%rax)
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
store i32 %0, i32* %4
store i32** %1, i32*** %5
%9 = load i32, i32* %4
%10 = icmp eq i32 %9, 0
br i1 %10, label %11, label %12
11: ; preds = %2
store i32** null, i32*** %3
br label %133
12: ; preds = %2
%13 = load i32, i32* %4
%14 = sext i32 %13 to i64
%15 = mul i64 8, %14
%16 = trunc i64 %15 to i32
%17 = call i32* @malloc(i32 %16)
%18 = bitcast i32* %17 to i32**
store i32** %18, i32*** %6
%19 = load i32, i32* %4
%20 = sext i32 %19 to i64
%21 = mul i64 4, %20
%22 = trunc i64 %21 to i32
%23 = call i32* @malloc(i32 %22)
%24 = load i32**, i32*** %5
store i32* %23, i32** %24
store i32 0, i32* %7
br label %25
25: ; preds = %47, %12
%26 = load i32, i32* %7
%27 = load i32, i32* %4
%28 = icmp slt i32 %26, %27
br i1 %28, label %29, label %50
29: ; preds = %25
%30 = load i32, i32* %7
%31 = add nsw i32 %30, 1
%32 = sext i32 %31 to i64
%33 = mul i64 4, %32
%34 = trunc i64 %33 to i32
%35 = call i32* @malloc(i32 %34)
%36 = load i32**, i32*** %6
%37 = load i32, i32* %7
%38 = sext i32 %37 to i64
%39 = getelementptr inbounds i32*, i32** %36, i64 %38
store i32* %35, i32** %39
%40 = load i32, i32* %7
%41 = add nsw i32 %40, 1
%42 = load i32**, i32*** %5
%43 = load i32*, i32** %42
%44 = load i32, i32* %7
%45 = sext i32 %44 to i64
%46 = getelementptr inbounds i32, i32* %43, i64 %45
store i32 %41, i32* %46
br label %47
47: ; preds = %29
%48 = load i32, i32* %7
%49 = add nsw i32 %48, 1
store i32 %49, i32* %7
br label %25
50: ; preds = %25
%51 = load i32**, i32*** %6
%52 = getelementptr inbounds i32*, i32** %51, i64 0
%53 = load i32*, i32** %52
%54 = getelementptr inbounds i32, i32* %53, i64 0
store i32 1, i32* %54
%55 = load i32, i32* %4
%56 = icmp eq i32 %55, 1
br i1 %56, label %57, label %59
57: ; preds = %50
%58 = load i32**, i32*** %6
store i32** %58, i32*** %3
br label %133
59: ; preds = %50
%60 = load i32**, i32*** %6
%61 = getelementptr inbounds i32*, i32** %60, i64 1
%62 = load i32*, i32** %61
%63 = getelementptr inbounds i32, i32* %62, i64 0
store i32 1, i32* %63
%64 = load i32**, i32*** %6
%65 = getelementptr inbounds i32*, i32** %64, i64 1
%66 = load i32*, i32** %65
%67 = getelementptr inbounds i32, i32* %66, i64 1
store i32 1, i32* %67
store i32 2, i32* %7
br label %68
68: ; preds = %128, %59
%69 = load i32, i32* %7
%70 = load i32, i32* %4
%71 = icmp slt i32 %69, %70
br i1 %71, label %72, label %131
72: ; preds = %68
store i32 0, i32* %8
%73 = load i32**, i32*** %6
%74 = load i32, i32* %7
%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 1, i32* %80
%81 = load i32**, i32*** %6
%82 = load i32, i32* %7
%83 = sext i32 %82 to i64
%84 = getelementptr inbounds i32*, i32** %81, i64 %83
%85 = load i32*, i32** %84
%86 = load i32, i32* %7
%87 = sext i32 %86 to i64
%88 = getelementptr inbounds i32, i32* %85, i64 %87
store i32 1, i32* %88
store i32 1, i32* %8
br label %89
89: ; preds = %124, %72
%90 = load i32, i32* %8
%91 = load i32, i32* %7
%92 = icmp slt i32 %90, %91
br i1 %92, label %93, label %127
93: ; preds = %89
%94 = load i32**, i32*** %6
%95 = load i32, i32* %7
%96 = sub nsw i32 %95, 1
%97 = sext i32 %96 to i64
%98 = getelementptr inbounds i32*, i32** %94, i64 %97
%99 = load i32*, i32** %98
%100 = load i32, i32* %8
%101 = sub nsw i32 %100, 1
%102 = sext i32 %101 to i64
%103 = getelementptr inbounds i32, i32* %99, i64 %102
%104 = load i32, i32* %103
%105 = load i32**, i32*** %6
%106 = load i32, i32* %7
%107 = sub nsw i32 %106, 1
%108 = sext i32 %107 to i64
%109 = getelementptr inbounds i32*, i32** %105, i64 %108
%110 = load i32*, i32** %109
%111 = load i32, i32* %8
%112 = sext i32 %111 to i64
%113 = getelementptr inbounds i32, i32* %110, i64 %112
%114 = load i32, i32* %113
%115 = add nsw i32 %104, %114
%116 = load i32**, i32*** %6
%117 = load i32, i32* %7
%118 = sext i32 %117 to i64
%119 = getelementptr inbounds i32*, i32** %116, i64 %118
%120 = load i32*, i32** %119
%121 = load i32, i32* %8
%122 = sext i32 %121 to i64
%123 = getelementptr inbounds i32, i32* %120, i64 %122
store i32 %115, i32* %123
br label %124
124: ; preds = %93
%125 = load i32, i32* %8
%126 = add nsw i32 %125, 1
store i32 %126, i32* %8
br label %89
127: ; preds = %89
br label %128
128: ; preds = %127
%129 = load i32, i32* %7
%130 = add nsw i32 %129, 1
store i32 %130, i32* %7
br label %68
131: ; preds = %68
%132 = load i32**, i32*** %6
store i32** %132, i32*** %3
br label %133
133: ; preds = %131, %57, %11
%134 = load i32**, i32*** %3
ret i32** %134
}

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