double interpolation(float *gvf, int dimx, int dimy, int dimz, const double x,
                     const double y, const double z) {
  double alpha, beta, gamma;
  alpha = x - (int)(x);
  beta = y - (int)(y);
  gamma = z - (int)(z);
  return (
      gvf[(((int)(y)) * (dimx) + ((int)(x)) + ((int)(z)) * (dimx) * (dimy))] *
          (1 - alpha) * (1 - beta) * (1 - gamma) +
      gvf[(((int)(y)) * (dimx) + ((int)(x)) +
           ((int)(z + 1)) * (dimx) * (dimy))] *
          (1 - alpha) * (1 - beta) * gamma +
      gvf[(((int)(y + 1)) * (dimx) + ((int)(x)) +
           ((int)(z)) * (dimx) * (dimy))] *
          (1 - alpha) * beta * (1 - gamma) +
      gvf[(((int)(y)) * (dimx) + ((int)(x + 1)) +
           ((int)(z)) * (dimx) * (dimy))] *
          alpha * (1 - beta) * (1 - gamma) +
      gvf[(((int)(y)) * (dimx) + ((int)(x + 1)) +
           ((int)(z + 1)) * (dimx) * (dimy))] *
          alpha * (1 - beta) * gamma +
      gvf[(((int)(y + 1)) * (dimx) + ((int)(x + 1)) +
           ((int)(z)) * (dimx) * (dimy))] *
          alpha * beta * (1 - gamma) +
      gvf[(((int)(y + 1)) * (dimx) + ((int)(x)) +
           ((int)(z + 1)) * (dimx) * (dimy))] *
          (1 - alpha) * beta * gamma +
      gvf[(((int)(y + 1)) * (dimx) + ((int)(x + 1)) +
           ((int)(z + 1)) * (dimx) * (dimy))] *
          (alpha * beta * gamma));
}


x86 assembly (clang, -O0):
<interpolation>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %ecx,-0x14(%rbp)
movsd  %xmm0,-0x20(%rbp)
movsd  %xmm1,-0x28(%rbp)
movsd  %xmm2,-0x30(%rbp)
movsd  -0x20(%rbp),%xmm0
cvttsd2si -0x20(%rbp),%eax
cvtsi2sd %eax,%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  -0x28(%rbp),%xmm0
cvttsd2si -0x28(%rbp),%eax
cvtsi2sd %eax,%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x30(%rbp),%xmm0
cvttsd2si -0x30(%rbp),%eax
cvtsi2sd %eax,%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x8(%rbp),%rax
cvttsd2si -0x28(%rbp),%ecx
imul   -0xc(%rbp),%ecx
cvttsd2si -0x20(%rbp),%edx
add    %edx,%ecx
cvttsd2si -0x30(%rbp),%edx
imul   -0xc(%rbp),%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xe64(%rip),%xmm1
subsd  -0x38(%rbp),%xmm1
mulsd  %xmm1,%xmm0
movsd  0xe53(%rip),%xmm1
subsd  -0x40(%rbp),%xmm1
mulsd  %xmm1,%xmm0
movsd  0xe42(%rip),%xmm2
subsd  -0x48(%rbp),%xmm2
mov    -0x8(%rbp),%rax
cvttsd2si -0x28(%rbp),%ecx
imul   -0xc(%rbp),%ecx
cvttsd2si -0x20(%rbp),%edx
add    %edx,%ecx
movsd  0xe21(%rip),%xmm1
addsd  -0x30(%rbp),%xmm1
cvttsd2si %xmm1,%edx
imul   -0xc(%rbp),%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
movsd  0xdfa(%rip),%xmm3
subsd  -0x38(%rbp),%xmm3
mulsd  %xmm3,%xmm1
movsd  0xde9(%rip),%xmm3
subsd  -0x40(%rbp),%xmm3
mulsd  %xmm3,%xmm1
mulsd  -0x48(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0xdc7(%rip),%xmm1
addsd  -0x28(%rbp),%xmm1
cvttsd2si %xmm1,%ecx
imul   -0xc(%rbp),%ecx
cvttsd2si -0x20(%rbp),%edx
add    %edx,%ecx
cvttsd2si -0x30(%rbp),%edx
imul   -0xc(%rbp),%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
movsd  0xd90(%rip),%xmm2
subsd  -0x38(%rbp),%xmm2
mulsd  %xmm2,%xmm1
mulsd  -0x40(%rbp),%xmm1
movsd  0xd7a(%rip),%xmm2
subsd  -0x48(%rbp),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
cvttsd2si -0x28(%rbp),%ecx
imul   -0xc(%rbp),%ecx
movsd  0xd58(%rip),%xmm0
addsd  -0x20(%rbp),%xmm0
cvttsd2si %xmm0,%edx
add    %edx,%ecx
cvttsd2si -0x30(%rbp),%edx
imul   -0xc(%rbp),%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mulsd  -0x38(%rbp),%xmm0
movsd  0xd25(%rip),%xmm2
subsd  -0x40(%rbp),%xmm2
mulsd  %xmm2,%xmm0
movsd  0xd14(%rip),%xmm2
subsd  -0x48(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
cvttsd2si -0x28(%rbp),%ecx
imul   -0xc(%rbp),%ecx
movsd  0xcf2(%rip),%xmm1
addsd  -0x20(%rbp),%xmm1
cvttsd2si %xmm1,%edx
add    %edx,%ecx
movsd  0xcdf(%rip),%xmm1
addsd  -0x30(%rbp),%xmm1
cvttsd2si %xmm1,%edx
imul   -0xc(%rbp),%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  -0x38(%rbp),%xmm1
movsd  0xcb3(%rip),%xmm2
subsd  -0x40(%rbp),%xmm2
mulsd  %xmm2,%xmm1
movsd  -0x48(%rbp),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0xc91(%rip),%xmm0
addsd  -0x28(%rbp),%xmm0
cvttsd2si %xmm0,%ecx
imul   -0xc(%rbp),%ecx
movsd  0xc7c(%rip),%xmm0
addsd  -0x20(%rbp),%xmm0
cvttsd2si %xmm0,%edx
add    %edx,%ecx
cvttsd2si -0x30(%rbp),%edx
imul   -0xc(%rbp),%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mulsd  -0x38(%rbp),%xmm0
mulsd  -0x40(%rbp),%xmm0
movsd  0xc44(%rip),%xmm2
subsd  -0x48(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movsd  0xc2b(%rip),%xmm1
addsd  -0x28(%rbp),%xmm1
cvttsd2si %xmm1,%ecx
imul   -0xc(%rbp),%ecx
cvttsd2si -0x20(%rbp),%edx
add    %edx,%ecx
movsd  0xc0f(%rip),%xmm1
addsd  -0x30(%rbp),%xmm1
cvttsd2si %xmm1,%edx
imul   -0xc(%rbp),%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
movsd  0xbe8(%rip),%xmm2
subsd  -0x38(%rbp),%xmm2
mulsd  %xmm2,%xmm1
mulsd  -0x40(%rbp),%xmm1
movsd  -0x48(%rbp),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movsd  0xbc1(%rip),%xmm0
addsd  -0x28(%rbp),%xmm0
cvttsd2si %xmm0,%ecx
imul   -0xc(%rbp),%ecx
movsd  0xbac(%rip),%xmm0
addsd  -0x20(%rbp),%xmm0
cvttsd2si %xmm0,%edx
add    %edx,%ecx
movsd  0xb99(%rip),%xmm0
addsd  -0x30(%rbp),%xmm0
cvttsd2si %xmm0,%edx
imul   -0xc(%rbp),%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  -0x38(%rbp),%xmm2
mulsd  -0x40(%rbp),%xmm2
mulsd  -0x48(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
pop    %rbp
ret

x86 assembly (clang, -O2):
<interpolation>:
movapd %xmm0,%xmm8
cvttsd2si %xmm1,%r11d
cvttpd2dq %xmm1,%xmm0
cvtdq2pd %xmm0,%xmm0
movapd %xmm1,%xmm9
subsd  %xmm0,%xmm9
movapd %xmm8,%xmm0
unpcklpd %xmm2,%xmm0
cvttpd2dq %xmm0,%xmm3
cvtdq2pd %xmm3,%xmm4
subpd  %xmm4,%xmm0
imul   %esi,%r11d
movd   %xmm3,%r8d
lea    (%r11,%r8,1),%eax
imul   %esi,%edx
pshufd $0x55,%xmm3,%xmm3
movd   %xmm3,%r10d
imul   %edx,%r10d
lea    (%r10,%rax,1),%ecx
movslq %ecx,%rcx
movss  (%rdi,%rcx,4),%xmm3
xorps  %xmm4,%xmm4
cvtss2sd %xmm3,%xmm4
movsd  0xe96(%rip),%xmm6
movapd %xmm6,%xmm10
subsd  %xmm0,%xmm10
mulsd  %xmm10,%xmm4
movapd %xmm6,%xmm3
subsd  %xmm9,%xmm3
mulsd  %xmm3,%xmm4
movapd %xmm0,%xmm5
unpckhpd %xmm0,%xmm5
movapd %xmm6,%xmm7
subsd  %xmm5,%xmm7
addsd  %xmm6,%xmm2
cvttsd2si %xmm2,%r9d
imul   %edx,%r9d
add    %r9d,%eax
cltq
movss  (%rdi,%rax,4),%xmm2
cvtss2sd %xmm2,%xmm2
mulsd  %xmm10,%xmm2
mulsd  %xmm3,%xmm2
mulsd  %xmm5,%xmm2
mulsd  %xmm7,%xmm4
addsd  %xmm6,%xmm1
cvttsd2si %xmm1,%edx
addsd  %xmm2,%xmm4
imul   %esi,%edx
add    %edx,%r8d
lea    (%r8,%r10,1),%eax
cltq
movss  (%rdi,%rax,4),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm10,%xmm1
mulsd  %xmm9,%xmm1
mulsd  %xmm7,%xmm1
addsd  %xmm4,%xmm1
addsd  %xmm8,%xmm6
cvttsd2si %xmm6,%eax
add    %eax,%r11d
lea    (%r10,%r11,1),%ecx
movslq %ecx,%rcx
movss  (%rdi,%rcx,4),%xmm2
cvtss2sd %xmm2,%xmm2
mulsd  %xmm0,%xmm2
mulsd  %xmm3,%xmm2
mulsd  %xmm7,%xmm2
addsd  %xmm1,%xmm2
add    %r9d,%r11d
movslq %r11d,%rcx
movss  (%rdi,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm3,%xmm1
mulsd  %xmm5,%xmm1
addsd  %xmm2,%xmm1
add    %eax,%edx
add    %edx,%r10d
movslq %r10d,%rax
movss  (%rdi,%rax,4),%xmm2
cvtss2sd %xmm2,%xmm2
mulsd  %xmm0,%xmm2
mulsd  %xmm9,%xmm2
mulsd  %xmm7,%xmm2
addsd  %xmm1,%xmm2
add    %r9d,%r8d
movslq %r8d,%rax
movss  (%rdi,%rax,4),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm10,%xmm1
mulsd  %xmm9,%xmm1
mulsd  %xmm5,%xmm1
addsd  %xmm2,%xmm1
add    %r9d,%edx
movslq %edx,%rax
movss  (%rdi,%rax,4),%xmm2
cvtss2sd %xmm2,%xmm2
mulsd  %xmm9,%xmm0
mulsd  %xmm5,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
ret

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

LLVM IR (-O2):
define double @interpolation(float* nocapture %0, i32 %1, i32 %2, i32 %3, double %4, double %5, double %6) {
%8 = fptosi double %5 to i32
%9 = sitofp i32 %8 to double
%10 = fsub double %5, %9
%11 = insertelement <2 x double> poison, double %4, i64 0
%12 = insertelement <2 x double> %11, double %6, i64 1
%13 = fptosi <2 x double> %12 to <2 x i32>
%14 = sitofp <2 x i32> %13 to <2 x double>
%15 = fsub <2 x double> %12, %14
%16 = mul nsw i32 %8, %1
%17 = extractelement <2 x i32> %13, i64 0
%18 = add nsw i32 %16, %17
%19 = mul i32 %2, %1
%20 = extractelement <2 x i32> %13, i64 1
%21 = mul i32 %19, %20
%22 = add nsw i32 %21, %18
%23 = sext i32 %22 to i64
%24 = getelementptr inbounds float, float* %0, i64 %23
%25 = load float, float* %24
%26 = fpext float %25 to double
%27 = extractelement <2 x double> %15, i64 0
%28 = fsub double 1.000000e+00, %27
%29 = fmul double %28, %26
%30 = fsub double 1.000000e+00, %10
%31 = fmul double %30, %29
%32 = extractelement <2 x double> %15, i64 1
%33 = fsub double 1.000000e+00, %32
%34 = fadd double %6, 1.000000e+00
%35 = fptosi double %34 to i32
%36 = mul i32 %19, %35
%37 = add nsw i32 %36, %18
%38 = sext i32 %37 to i64
%39 = getelementptr inbounds float, float* %0, i64 %38
%40 = load float, float* %39
%41 = fpext float %40 to double
%42 = fmul double %28, %41
%43 = fmul double %30, %42
%44 = fmul double %32, %43
%45 = tail call double @llvm.fmuladd.f64(double %31, double %33, double %44)
%46 = fadd double %5, 1.000000e+00
%47 = fptosi double %46 to i32
%48 = mul nsw i32 %47, %1
%49 = add nsw i32 %48, %17
%50 = add nsw i32 %49, %21
%51 = sext i32 %50 to i64
%52 = getelementptr inbounds float, float* %0, i64 %51
%53 = load float, float* %52
%54 = fpext float %53 to double
%55 = fmul double %28, %54
%56 = fmul double %10, %55
%57 = tail call double @llvm.fmuladd.f64(double %56, double %33, double %45)
%58 = fadd double %4, 1.000000e+00
%59 = fptosi double %58 to i32
%60 = add nsw i32 %16, %59
%61 = add nsw i32 %21, %60
%62 = sext i32 %61 to i64
%63 = getelementptr inbounds float, float* %0, i64 %62
%64 = load float, float* %63
%65 = fpext float %64 to double
%66 = fmul double %27, %65
%67 = fmul double %30, %66
%68 = tail call double @llvm.fmuladd.f64(double %67, double %33, double %57)
%69 = add nsw i32 %36, %60
%70 = sext i32 %69 to i64
%71 = getelementptr inbounds float, float* %0, i64 %70
%72 = load float, float* %71
%73 = fpext float %72 to double
%74 = fmul double %27, %73
%75 = fmul double %30, %74
%76 = tail call double @llvm.fmuladd.f64(double %75, double %32, double %68)
%77 = add nsw i32 %48, %59
%78 = add nsw i32 %77, %21
%79 = sext i32 %78 to i64
%80 = getelementptr inbounds float, float* %0, i64 %79
%81 = load float, float* %80
%82 = fpext float %81 to double
%83 = fmul double %27, %82
%84 = fmul double %10, %83
%85 = tail call double @llvm.fmuladd.f64(double %84, double %33, double %76)
%86 = add nsw i32 %36, %49
%87 = sext i32 %86 to i64
%88 = getelementptr inbounds float, float* %0, i64 %87
%89 = load float, float* %88
%90 = fpext float %89 to double
%91 = fmul double %28, %90
%92 = fmul double %10, %91
%93 = tail call double @llvm.fmuladd.f64(double %92, double %32, double %85)
%94 = add nsw i32 %36, %77
%95 = sext i32 %94 to i64
%96 = getelementptr inbounds float, float* %0, i64 %95
%97 = load float, float* %96
%98 = fpext float %97 to double
%99 = fmul double %27, %10
%100 = fmul double %99, %32
%101 = tail call double @llvm.fmuladd.f64(double %98, double %100, double %93)
ret double %101
}