void acd_2d_2_d(float **uc, float **ucd, float **up, float **upd, float **csq,
                float **csqd, int *s, int *e, float c0, float *c1) {
  int i0, i1;
  for (i1 = s[1]; i1 < e[1] + 1; ++i1)
    for (i0 = s[0]; i0 < e[0] + 1; ++i0) {
      float lap = (c0 * uc[i1][i0] + c1[0] * (uc[i1][i0 + 1] + uc[i1][i0 - 1]) +
                   c1[1] * (uc[i1 + 1][i0] + uc[i1 - 1][i0]));
      float lapd = c0 * ucd[i1][i0] +
                   c1[0] * (ucd[i1][i0 + 1] + ucd[i1][i0 - 1]) +
                   c1[1] * (ucd[i1 + 1][i0] + ucd[i1 - 1][i0]);
      upd[i1][i0] = 2.0 * ucd[i1][i0] - upd[i1][i0] + csqd[i1][i0] * lap +
                    csq[i1][i0] * lapd;
      up[i1][i0] = 2.0 * uc[i1][i0] - up[i1][i0] + csq[i1][i0] * lap;
    }
}


x86 assembly (clang, -O0):
<acd_2d_2_d>:
push   %rbp
mov    %rsp,%rbp
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
movss  %xmm0,-0x34(%rbp)
mov    0x10(%rbp),%rax
mov    0x4(%rax),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    0x18(%rbp),%rcx
mov    0x4(%rcx),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    141c <acd_2d_2_d+0x31c>
mov    0x10(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    0x18(%rbp),%rcx
mov    (%rcx),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1409 <acd_2d_2_d+0x309>
movss  -0x34(%rbp),%xmm1
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    0x20(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm3
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm3
mulss  %xmm3,%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    0x20(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x34(%rbp),%xmm1
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    0x20(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm3
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm3
mulss  %xmm3,%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    0x20(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
addsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  -0x40(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  -0x44(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
addsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  -0x40(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1155 <acd_2d_2_d+0x55>
jmp    140e <acd_2d_2_d+0x30e>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1137 <acd_2d_2_d+0x37>
pop    %rbp
ret

x86 assembly (clang, -O2):
<acd_2d_2_d>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %r9,-0x8(%rsp)
mov    %r8,-0x10(%rsp)
mov    %rcx,-0x18(%rsp)
mov    %rdx,-0x20(%rsp)
mov    %rsi,-0x28(%rsp)
mov    %rdi,-0x30(%rsp)
mov    0x40(%rsp),%rax
mov    0x38(%rsp),%rcx
movslq 0x4(%rcx),%rsi
mov    0x4(%rax),%edx
cmp    %edx,%esi
jg     1310 <acd_2d_2_d+0x210>
mov    0x48(%rsp),%r12
movslq (%rcx),%rcx
mov    (%rax),%eax
add    $0x1,%edx
mov    %eax,%r13d
sub    %ecx,%r13d
add    $0x1,%r13d
mov    %edx,-0x3c(%rsp)
mov    %rcx,-0x38(%rsp)
mov    %eax,-0x40(%rsp)
jmp    1180 <acd_2d_2_d+0x80>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rsi
mov    %rsi,%r15
cmp    %r15d,%edx
je     1310 <acd_2d_2_d+0x210>
cmp    %eax,%ecx
jg     1170 <acd_2d_2_d+0x70>
lea    0x1(%rsi),%r15
lea    0x0(,%rcx,4),%rbp
mov    -0x30(%rsp),%rcx
mov    (%rcx,%rsi,8),%rax
add    %rbp,%rax
mov    0x8(%rcx,%rsi,8),%rbx
add    %rbp,%rbx
mov    -0x8(%rcx,%rsi,8),%r14
add    %rbp,%r14
mov    -0x28(%rsp),%rcx
mov    (%rcx,%rsi,8),%r9
add    %rbp,%r9
mov    0x8(%rcx,%rsi,8),%r8
add    %rbp,%r8
mov    -0x8(%rcx,%rsi,8),%rcx
add    %rbp,%rcx
mov    -0x18(%rsp),%rdx
mov    (%rdx,%rsi,8),%rdx
add    %rbp,%rdx
mov    -0x8(%rsp),%rdi
mov    (%rdi,%rsi,8),%r10
add    %rbp,%r10
mov    -0x10(%rsp),%rdi
mov    (%rdi,%rsi,8),%r11
add    %rbp,%r11
mov    -0x20(%rsp),%rdi
add    (%rdi,%rsi,8),%rbp
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
movss  0x4(%rax,%rsi,4),%xmm1
addss  -0x4(%rax,%rsi,4),%xmm1
movss  (%r12),%xmm2
movss  0x4(%r12),%xmm3
mulss  %xmm2,%xmm1
movss  (%rax,%rsi,4),%xmm4
mulss  %xmm0,%xmm4
addss  %xmm1,%xmm4
movss  (%rbx,%rsi,4),%xmm1
addss  (%r14,%rsi,4),%xmm1
mulss  %xmm3,%xmm1
addss  %xmm4,%xmm1
movss  (%r9,%rsi,4),%xmm4
movss  0x4(%r9,%rsi,4),%xmm5
addss  -0x4(%r9,%rsi,4),%xmm5
mulss  %xmm2,%xmm5
movaps %xmm0,%xmm2
mulss  %xmm4,%xmm2
addss  %xmm5,%xmm2
movss  (%r8,%rsi,4),%xmm5
addss  (%rcx,%rsi,4),%xmm5
mulss  %xmm3,%xmm5
addss  %xmm2,%xmm5
xorps  %xmm2,%xmm2
cvtss2sd %xmm4,%xmm2
movss  (%rdx,%rsi,4),%xmm3
cvtss2sd %xmm3,%xmm3
addsd  %xmm2,%xmm2
subsd  %xmm3,%xmm2
movss  (%r10,%rsi,4),%xmm3
mulss  %xmm1,%xmm3
cvtss2sd %xmm3,%xmm3
addsd  %xmm2,%xmm3
mulss  (%r11,%rsi,4),%xmm5
xorps  %xmm2,%xmm2
cvtss2sd %xmm5,%xmm2
addsd  %xmm3,%xmm2
cvtsd2ss %xmm2,%xmm2
movss  %xmm2,(%rdx,%rsi,4)
movss  (%rax,%rsi,4),%xmm2
cvtss2sd %xmm2,%xmm2
movss  0x0(%rbp,%rsi,4),%xmm3
cvtss2sd %xmm3,%xmm3
addsd  %xmm2,%xmm2
subsd  %xmm3,%xmm2
mulss  (%r11,%rsi,4),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm2,%xmm1
cvtsd2ss %xmm1,%xmm1
movss  %xmm1,0x0(%rbp,%rsi,4)
add    $0x1,%rsi
cmp    %esi,%r13d
jne    1200 <acd_2d_2_d+0x100>
mov    %r15,%rsi
mov    -0x3c(%rsp),%edx
mov    -0x38(%rsp),%rcx
mov    -0x40(%rsp),%eax
cmp    %r15d,%edx
jne    1180 <acd_2d_2_d+0x80>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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