#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 /*<<< orphan*/ Free2DArray(void **, int);
scalar_t__ Get2DMem(int, int, int, int);
scalar_t__ LRound(float);
float ModDiff(float, float);
void CycleResidue(float **phase, signed char **residue, int nrow, int ncol) {
  int row, col;
  float **rowdiff, **coldiff;
  rowdiff = (float **)Get2DMem(nrow - 1, ncol, sizeof(float *), sizeof(float));
  coldiff = (float **)Get2DMem(nrow, ncol - 1, sizeof(float *), sizeof(float));
  for (row = 0; row < nrow - 1; row++) {
    for (col = 0; col < ncol; col++) {
      rowdiff[row][col] = ModDiff(phase[row + 1][col], phase[row][col]);
    }
  }
  for (row = 0; row < nrow; row++) {
    for (col = 0; col < ncol - 1; col++) {
      coldiff[row][col] = ModDiff(phase[row][col + 1], phase[row][col]);
    }
  }
  for (row = 0; row < nrow - 1; row++) {
    for (col = 0; col < ncol - 1; col++) {
      residue[row][col] =
          (signed char)LRound((coldiff[row][col] + rowdiff[row][col + 1] -
                               coldiff[row + 1][col] - rowdiff[row][col]) /
                              6.28318530717958647692);
    }
  }
  Free2DArray((void **)rowdiff, nrow - 1);
  Free2DArray((void **)coldiff, nrow);
}


x86 assembly (clang, -O0):
<CycleResidue>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    -0x14(%rbp),%edi
sub    $0x1,%edi
mov    -0x18(%rbp),%esi
mov    $0x8,%edx
mov    $0x4,%ecx
call   1030 <Get2DMem@plt>
mov    %rax,-0x28(%rbp)
mov    -0x14(%rbp),%edi
mov    -0x18(%rbp),%esi
sub    $0x1,%esi
mov    $0x8,%edx
mov    $0x4,%ecx
call   1030 <Get2DMem@plt>
mov    %rax,-0x30(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1223 <CycleResidue+0xe3>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1210 <CycleResidue+0xd0>
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
call   1040 <ModDiff@plt>
mov    -0x28(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    11ad <CycleResidue+0x6d>
jmp    1215 <CycleResidue+0xd5>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1195 <CycleResidue+0x55>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    12b8 <CycleResidue+0x178>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    12a5 <CycleResidue+0x165>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
call   1040 <ModDiff@plt>
mov    -0x30(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    123d <CycleResidue+0xfd>
jmp    12aa <CycleResidue+0x16a>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    122a <CycleResidue+0xea>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1395 <CycleResidue+0x255>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1382 <CycleResidue+0x242>
mov    -0x30(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x20(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x20(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xcae(%rip),%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
call   1060 <LRound@plt>
mov    %al,%dl
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x20(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    12d7 <CycleResidue+0x197>
jmp    1387 <CycleResidue+0x247>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    12bf <CycleResidue+0x17f>
mov    -0x28(%rbp),%rdi
mov    -0x14(%rbp),%esi
sub    $0x1,%esi
call   1050 <Free2DArray@plt>
mov    -0x30(%rbp),%rdi
mov    -0x14(%rbp),%esi
call   1050 <Free2DArray@plt>
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<CycleResidue>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
mov    %ecx,%ebp
mov    %edx,%ebx
mov    %rsi,0x40(%rsp)
mov    %rdi,%r15
lea    -0x1(%rbx),%r14d
mov    %r14d,%edi
mov    %ecx,%esi
mov    $0x8,%edx
mov    $0x4,%ecx
call   1030 <Get2DMem@plt>
mov    %rax,0x20(%rsp)
mov    %rbp,0x18(%rsp)
lea    -0x1(%rbp),%esi
mov    %ebx,%edi
mov    %esi,0x8(%rsp)
mov    $0x8,%edx
mov    $0x4,%ecx
call   1030 <Get2DMem@plt>
mov    %rax,0x38(%rsp)
mov    %r14d,0x2c(%rsp)
mov    %r14d,%eax
mov    %rax,0x30(%rsp)
mov    %rbx,0x10(%rsp)
cmp    $0x2,%ebx
jl     120f <CycleResidue+0xcf>
mov    0x18(%rsp),%r14d
xor    %ebp,%ebp
mov    0x20(%rsp),%r13
jmp    11ca <CycleResidue+0x8a>
xchg   %ax,%ax
mov    %rbx,%rbp
cmp    0x30(%rsp),%rbx
je     120f <CycleResidue+0xcf>
lea    0x1(%rbp),%rbx
cmpl   $0x0,0x18(%rsp)
jle    11c0 <CycleResidue+0x80>
xor    %r12d,%r12d
nopl   0x0(%rax,%rax,1)
mov    (%r15,%rbx,8),%rax
movss  (%rax,%r12,4),%xmm0
mov    (%r15,%rbp,8),%rax
movss  (%rax,%r12,4),%xmm1
call   1040 <ModDiff@plt>
mov    0x0(%r13,%rbp,8),%rax
movss  %xmm0,(%rax,%r12,4)
add    $0x1,%r12
cmp    %r12,%r14
jne    11e0 <CycleResidue+0xa0>
jmp    11c0 <CycleResidue+0x80>
mov    0x8(%rsp),%r14d
cmpl   $0x0,0x10(%rsp)
mov    0x38(%rsp),%r13
jle    127c <CycleResidue+0x13c>
mov    0x10(%rsp),%eax
mov    %rax,0x8(%rsp)
xor    %r12d,%r12d
jmp    123b <CycleResidue+0xfb>
xchg   %ax,%ax
add    $0x1,%r12
cmp    0x8(%rsp),%r12
je     127c <CycleResidue+0x13c>
cmpl   $0x2,0x18(%rsp)
jl     1230 <CycleResidue+0xf0>
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    (%r15,%r12,8),%rax
lea    0x1(%rbp),%rbx
movss  (%rax,%rbp,4),%xmm1
movss  0x4(%rax,%rbp,4),%xmm0
call   1040 <ModDiff@plt>
mov    0x0(%r13,%r12,8),%rax
movss  %xmm0,(%rax,%rbp,4)
mov    %rbx,%rbp
cmp    %rbx,%r14
jne    1250 <CycleResidue+0x110>
jmp    1230 <CycleResidue+0xf0>
cmpl   $0x2,0x10(%rsp)
mov    0x20(%rsp),%rdi
jl     1337 <CycleResidue+0x1f7>
xor    %r12d,%r12d
movsd  0xd69(%rip),%xmm1
mov    0x40(%rsp),%r15
jmp    12b2 <CycleResidue+0x172>
xchg   %ax,%ax
add    $0x1,%r12
mov    %r12,%rax
cmp    0x30(%rsp),%rax
je     1337 <CycleResidue+0x1f7>
cmpl   $0x1,0x18(%rsp)
jle    12a0 <CycleResidue+0x160>
lea    0x1(%r12),%rax
mov    %rax,0x8(%rsp)
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x0(%r13,%r12,8),%rax
mov    0x8(%r13,%r12,8),%rcx
movss  (%rax,%rbp,4),%xmm0
mov    (%rdi,%r12,8),%rax
lea    0x1(%rbp),%rbx
addss  0x4(%rax,%rbp,4),%xmm0
subss  (%rcx,%rbp,4),%xmm0
subss  (%rax,%rbp,4),%xmm0
cvtss2sd %xmm0,%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
call   1060 <LRound@plt>
movsd  0xcf0(%rip),%xmm1
mov    0x20(%rsp),%rdi
mov    (%r15,%r12,8),%rcx
mov    %al,(%rcx,%rbp,1)
mov    %rbx,%rbp
cmp    %rbx,%r14
jne    12d0 <CycleResidue+0x190>
mov    0x8(%rsp),%rax
mov    %rax,%r12
cmp    0x30(%rsp),%rax
jne    12b2 <CycleResidue+0x172>
mov    0x2c(%rsp),%esi
call   1050 <Free2DArray@plt>
mov    %r13,%rdi
mov    0x10(%rsp),%rsi
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1050 <Free2DArray@plt>

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

LLVM IR (-O2):
define void @CycleResidue(float** nocapture %0, i8** nocapture %1, i32 %2, i32 %3) {
%5 = add nsw i32 %2, -1
%6 = tail call i64 @Get2DMem(i32 %5, i32 %3, i32 8, i32 4)
%7 = inttoptr i64 %6 to float**
%8 = add nsw i32 %3, -1
%9 = tail call i64 @Get2DMem(i32 %2, i32 %8, i32 8, i32 4)
%10 = inttoptr i64 %9 to float**
%11 = icmp sgt i32 %2, 1
br i1 %11, label %12, label %23
12: ; preds = %4
%13 = icmp sgt i32 %3, 0
%14 = zext i32 %5 to i64
%15 = zext i32 %3 to i64
br label %16
16: ; preds = %12, %42
%17 = phi i64 [ 0, %12 ], [ %18, %42 ]
%18 = add nuw nsw i64 %17, 1
br i1 %13, label %19, label %42
19: ; preds = %16
%20 = getelementptr inbounds float*, float** %0, i64 %18
%21 = getelementptr inbounds float*, float** %0, i64 %17
%22 = getelementptr inbounds float*, float** %7, i64 %17
br label %29
23: ; preds = %42, %4
%24 = icmp sgt i32 %2, 0
br i1 %24, label %25, label %49
25: ; preds = %23
%26 = icmp sgt i32 %3, 1
%27 = zext i32 %2 to i64
%28 = zext i32 %8 to i64
br label %44
29: ; preds = %19, %29
%30 = phi i64 [ 0, %19 ], [ %40, %29 ]
%31 = load float*, float** %20
%32 = getelementptr inbounds float, float* %31, i64 %30
%33 = load float, float* %32
%34 = load float*, float** %21
%35 = getelementptr inbounds float, float* %34, i64 %30
%36 = load float, float* %35
%37 = tail call float @ModDiff(float %33, float %36)
%38 = load float*, float** %22
%39 = getelementptr inbounds float, float* %38, i64 %30
store float %37, float* %39
%40 = add nuw nsw i64 %30, 1
%41 = icmp eq i64 %40, %15
br i1 %41, label %42, label %29
42: ; preds = %29, %16
%43 = icmp eq i64 %18, %14
br i1 %43, label %23, label %16
44: ; preds = %25, %66
%45 = phi i64 [ 0, %25 ], [ %67, %66 ]
br i1 %26, label %46, label %66
46: ; preds = %44
%47 = getelementptr inbounds float*, float** %0, i64 %45
%48 = getelementptr inbounds float*, float** %10, i64 %45
br label %54
49: ; preds = %66, %23
br i1 %11, label %50, label %107
50: ; preds = %49
%51 = icmp sgt i32 %3, 1
%52 = zext i32 %5 to i64
%53 = zext i32 %8 to i64
br label %69
54: ; preds = %46, %54
%55 = phi i64 [ 0, %46 ], [ %57, %54 ]
%56 = load float*, float** %47
%57 = add nuw nsw i64 %55, 1
%58 = getelementptr inbounds float, float* %56, i64 %57
%59 = load float, float* %58
%60 = getelementptr inbounds float, float* %56, i64 %55
%61 = load float, float* %60
%62 = tail call float @ModDiff(float %59, float %61)
%63 = load float*, float** %48
%64 = getelementptr inbounds float, float* %63, i64 %55
store float %62, float* %64
%65 = icmp eq i64 %57, %28
br i1 %65, label %66, label %54
66: ; preds = %54, %44
%67 = add nuw nsw i64 %45, 1
%68 = icmp eq i64 %67, %27
br i1 %68, label %49, label %44
69: ; preds = %50, %104
%70 = phi i64 [ 0, %50 ], [ %105, %104 ]
br i1 %51, label %73, label %71
71: ; preds = %69
%72 = add nuw nsw i64 %70, 1
br label %104
73: ; preds = %69
%74 = getelementptr inbounds float*, float** %10, i64 %70
%75 = getelementptr inbounds float*, float** %7, i64 %70
%76 = add nuw nsw i64 %70, 1
%77 = getelementptr inbounds float*, float** %10, i64 %76
%78 = getelementptr inbounds i8*, i8** %1, i64 %70
br label %79
79: ; preds = %73, %79
%80 = phi i64 [ 0, %73 ], [ %85, %79 ]
%81 = load float*, float** %74
%82 = getelementptr inbounds float, float* %81, i64 %80
%83 = load float, float* %82
%84 = load float*, float** %75
%85 = add nuw nsw i64 %80, 1
%86 = getelementptr inbounds float, float* %84, i64 %85
%87 = load float, float* %86
%88 = fadd float %83, %87
%89 = load float*, float** %77
%90 = getelementptr inbounds float, float* %89, i64 %80
%91 = load float, float* %90
%92 = fsub float %88, %91
%93 = getelementptr inbounds float, float* %84, i64 %80
%94 = load float, float* %93
%95 = fsub float %92, %94
%96 = fpext float %95 to double
%97 = fdiv double %96, 0x401921FB54442D18
%98 = fptrunc double %97 to float
%99 = tail call i64 @LRound(float %98)
%100 = trunc i64 %99 to i8
%101 = load i8*, i8** %78
%102 = getelementptr inbounds i8, i8* %101, i64 %80
store i8 %100, i8* %102
%103 = icmp eq i64 %85, %53
br i1 %103, label %104, label %79
104: ; preds = %79, %71
%105 = phi i64 [ %72, %71 ], [ %76, %79 ]
%106 = icmp eq i64 %105, %52
br i1 %106, label %107, label %69
107: ; preds = %104, %49
%108 = inttoptr i64 %6 to i8**
%109 = tail call i32 @Free2DArray(i8** %108, i32 %5)
%110 = inttoptr i64 %9 to i8**
%111 = tail call i32 @Free2DArray(i8** %110, i32 %2)
ret void
}