#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 minPathSum(int **grid, int gridRowSize, int gridColSize) {
  int **f;
  int i, j;
  f = (int **)malloc(sizeof(int *) * gridRowSize);
  for (i = 0; i < gridRowSize; i++) {
    f[i] = (int *)malloc(sizeof(int) * gridColSize);
  }
  f[0][0] = grid[0][0];
  for (j = 1; j < gridColSize; j++) {
    f[0][j] = f[0][j - 1] + grid[0][j];
  }
  for (i = 1; i < gridRowSize; i++) {
    f[i][0] = f[i - 1][0] + grid[i][0];
  }
  for (i = 1; i < gridRowSize; i++) {
    for (j = 1; j < gridColSize; j++) {
      f[i][j] = f[i - 1][j] < f[i][j - 1] ? f[i - 1][j] + grid[i][j]
                                          : f[i][j - 1] + grid[i][j];
    }
  }
  return f[gridRowSize - 1][gridColSize - 1];
}


x86 assembly (clang, -O0):
<minPathSum>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
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    1174 <minPathSum+0x64>
movslq -0x10(%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    113c <minPathSum+0x2c>
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
mov    (%rax),%ecx
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
mov    %ecx,(%rax)
movl   $0x1,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    11d6 <minPathSum+0xc6>
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
mov    -0x20(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
movslq -0x20(%rbp),%rcx
add    (%rax,%rcx,4),%edx
mov    -0x18(%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    118d <minPathSum+0x7d>
movl   $0x1,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1226 <minPathSum+0x116>
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    (%rax),%ecx
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rdx
mov    (%rax,%rdx,8),%rax
add    (%rax),%ecx
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rdx
mov    (%rax,%rdx,8),%rax
mov    %ecx,(%rax)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    11dd <minPathSum+0xcd>
movl   $0x1,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    131a <minPathSum+0x20a>
movl   $0x1,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1307 <minPathSum+0x1f7>
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x18(%rbp),%rcx
movslq -0x1c(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
mov    -0x20(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
jge    12b5 <minPathSum+0x1a5>
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x8(%rbp),%rcx
movslq -0x1c(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
movslq -0x20(%rbp),%rdx
add    (%rcx,%rdx,4),%eax
mov    %eax,-0x24(%rbp)
jmp    12e3 <minPathSum+0x1d3>
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x20(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x8(%rbp),%rcx
movslq -0x1c(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
movslq -0x20(%rbp),%rdx
add    (%rcx,%rdx,4),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%edx
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x20(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1240 <minPathSum+0x130>
jmp    130c <minPathSum+0x1fc>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    122d <minPathSum+0x11d>
mov    -0x18(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<minPathSum>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %edx,%r15d
mov    %esi,%ebx
mov    %rdi,%r12
lea    0x0(,%rbx,8),%edi
call   1030 <malloc@plt>
mov    %rax,%r14
mov    %ebx,%r13d
mov    %rbx,(%rsp)
test   %ebx,%ebx
jle    1164 <minPathSum+0x54>
lea    0x0(,%r15,4),%ebp
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
mov    %ebp,%edi
call   1030 <malloc@plt>
mov    %rax,(%r14,%rbx,8)
add    $0x1,%rbx
cmp    %rbx,%r13
jne    1150 <minPathSum+0x40>
mov    (%r12),%rdx
mov    (%rdx),%eax
mov    (%r14),%rsi
mov    %eax,(%rsi)
cmp    $0x2,%r15d
mov    (%rsp),%r10
jl     11ef <minPathSum+0xdf>
mov    %r15d,%ebx
lea    -0x1(%rbx),%rcx
add    $0xfffffffffffffffe,%rbx
mov    %ecx,%r8d
and    $0x3,%r8d
mov    $0x1,%ebp
mov    %eax,%edi
cmp    $0x3,%rbx
jb     11cd <minPathSum+0xbd>
and    $0xfffffffffffffffc,%rcx
xor    %ebp,%ebp
mov    %eax,%edi
add    0x4(%rdx,%rbp,4),%edi
mov    %edi,0x4(%rsi,%rbp,4)
add    0x8(%rdx,%rbp,4),%edi
mov    %edi,0x8(%rsi,%rbp,4)
add    0xc(%rdx,%rbp,4),%edi
mov    %edi,0xc(%rsi,%rbp,4)
add    0x10(%rdx,%rbp,4),%edi
mov    %edi,0x10(%rsi,%rbp,4)
add    $0x4,%rbp
cmp    %rbp,%rcx
jne    11a0 <minPathSum+0x90>
add    $0x1,%rbp
test   %r8,%r8
je     11ef <minPathSum+0xdf>
lea    (%rsi,%rbp,4),%rcx
lea    (%rdx,%rbp,4),%rdx
xor    %esi,%esi
nopl   0x0(%rax)
add    (%rdx,%rsi,4),%edi
mov    %edi,(%rcx,%rsi,4)
add    $0x1,%rsi
cmp    %rsi,%r8
jne    11e0 <minPathSum+0xd0>
cmp    $0x2,%r10d
jl     1346 <minPathSum+0x236>
lea    -0x1(%r13),%rsi
lea    -0x2(%r13),%rdi
mov    %esi,%ecx
and    $0x3,%ecx
mov    $0x1,%edx
cmp    $0x3,%rdi
jb     1265 <minPathSum+0x155>
and    $0xfffffffffffffffc,%rsi
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
mov    0x8(%r12,%rdx,8),%rdi
add    (%rdi),%eax
mov    0x8(%r14,%rdx,8),%rdi
mov    %eax,(%rdi)
mov    0x10(%r12,%rdx,8),%rdi
add    (%rdi),%eax
mov    0x10(%r14,%rdx,8),%rdi
mov    %eax,(%rdi)
mov    0x18(%r12,%rdx,8),%rdi
add    (%rdi),%eax
mov    0x18(%r14,%rdx,8),%rdi
mov    %eax,(%rdi)
mov    0x20(%r12,%rdx,8),%rdi
add    (%rdi),%eax
mov    0x20(%r14,%rdx,8),%rdi
mov    %eax,(%rdi)
add    $0x4,%rdx
cmp    %rdx,%rsi
jne    1220 <minPathSum+0x110>
add    $0x1,%rdx
test   %rcx,%rcx
je     1297 <minPathSum+0x187>
lea    (%r14,%rdx,8),%rsi
lea    (%r12,%rdx,8),%rdx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    (%rdx,%rdi,8),%rbp
add    0x0(%rbp),%eax
mov    (%rsi,%rdi,8),%rbp
mov    %eax,0x0(%rbp)
add    $0x1,%rdi
cmp    %rdi,%rcx
jne    1280 <minPathSum+0x170>
cmp    $0x2,%r10d
jl     1346 <minPathSum+0x236>
mov    %r15d,%r8d
add    $0xffffffffffffffff,%r8
mov    %r8,%r9
and    $0xfffffffffffffffe,%r9
neg    %r9
mov    $0x1,%edx
jmp    12c9 <minPathSum+0x1b9>
nopl   0x0(%rax)
add    $0x1,%rdx
cmp    %r13,%rdx
je     1346 <minPathSum+0x236>
cmp    $0x2,%r15d
jl     12c0 <minPathSum+0x1b0>
mov    -0x8(%r14,%rdx,8),%rbp
mov    (%r14,%rdx,8),%rsi
mov    (%rsi),%ecx
mov    $0x1,%edi
jne    1300 <minPathSum+0x1f0>
test   $0x1,%r8b
je     12c0 <minPathSum+0x1b0>
mov    0x0(%rbp,%rdi,4),%eax
cmp    %ecx,%eax
cmovl  %eax,%ecx
mov    (%r12,%rdx,8),%rax
add    (%rax,%rdi,4),%ecx
mov    %ecx,(%rsi,%rdi,4)
jmp    12c0 <minPathSum+0x1b0>
nopl   0x0(%rax)
mov    (%r12,%rdx,8),%rbx
mov    $0x1,%edi
jmp    132a <minPathSum+0x21a>
nopl   0x0(%rax,%rax,1)
add    0x4(%rbx,%rdi,4),%ecx
mov    %ecx,0x4(%rsi,%rdi,4)
lea    (%r9,%rdi,1),%rax
add    $0x2,%rax
add    $0x2,%rdi
cmp    $0x1,%rax
je     12e1 <minPathSum+0x1d1>
mov    0x0(%rbp,%rdi,4),%eax
cmp    %ecx,%eax
jl     1334 <minPathSum+0x224>
mov    %ecx,%eax
add    (%rbx,%rdi,4),%eax
mov    %eax,(%rsi,%rdi,4)
mov    0x4(%rbp,%rdi,4),%ecx
cmp    %eax,%ecx
jl     1310 <minPathSum+0x200>
mov    %eax,%ecx
jmp    1310 <minPathSum+0x200>
movslq %r10d,%rax
mov    -0x8(%r14,%rax,8),%rax
movslq %r15d,%rcx
mov    -0x4(%rax,%rcx,4),%eax
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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