void kernel_CPU_06_mod_3DRhoVar(float *gU0, float *gU1, float *gVorg,
                                float *gDorg, int nnoi, int nnoj, int k0,
                                int k1, float FATMDFX, float FATMDFY,
                                float FATMDFZ, float *W, float *C) {
  int index_X, index_Y;
  int stride = nnoi * nnoj;
  int index, k;
  for (index_X = 0; index_X < nnoi; index_X++)
    for (index_Y = 0; index_Y < nnoj; index_Y++) {
      index = (index_Y * nnoi + index_X) + k0 * stride;
      for (k = k0; k < k1; ++k) {
        if (gVorg[index] > 0.0f) {
          gU1[index] =
              2.0f * gU0[index] - gU1[index] +
              FATMDFX * gVorg[index] * gVorg[index] *
                  (+W[6] * (gU0[index + 6] + gU0[index - 6]) +
                   W[5] * (gU0[index + 5] + gU0[index - 5]) +
                   W[4] * (gU0[index + 4] + gU0[index - 4]) +
                   W[3] * (gU0[index + 3] + gU0[index - 3]) +
                   W[2] * (gU0[index + 2] + gU0[index - 2]) +
                   W[1] * (gU0[index + 1] + gU0[index - 1]) +
                   W[0] * gU0[index]) +
              FATMDFY * gVorg[index] * gVorg[index] *
                  (+W[6] * (gU0[index + 6 * nnoi] + gU0[index - 6 * nnoi]) +
                   W[5] * (gU0[index + 5 * nnoi] + gU0[index - 5 * nnoi]) +
                   W[4] * (gU0[index + 4 * nnoi] + gU0[index - 4 * nnoi]) +
                   W[3] * (gU0[index + 3 * nnoi] + gU0[index - 3 * nnoi]) +
                   W[2] * (gU0[index + 2 * nnoi] + gU0[index - 2 * nnoi]) +
                   W[1] * (gU0[index + nnoi] + gU0[index - nnoi]) +
                   W[0] * gU0[index]) +
              FATMDFZ * gVorg[index] * gVorg[index] *
                  (+W[6] * (gU0[index + 6 * stride] + gU0[index - 6 * stride]) +
                   W[5] * (gU0[index + 5 * stride] + gU0[index - 5 * stride]) +
                   W[4] * (gU0[index + 4 * stride] + gU0[index - 4 * stride]) +
                   W[3] * (gU0[index + 3 * stride] + gU0[index - 3 * stride]) +
                   W[2] * (gU0[index + 2 * stride] + gU0[index - 2 * stride]) +
                   W[1] * (gU0[index + stride] + gU0[index - stride]) +
                   W[0] * gU0[index]) -
              FATMDFX * gVorg[index] * gVorg[index] * (1.0f / gDorg[index]) *
                  (+C[0] * (gDorg[index + 1] - gDorg[index - 1]) +
                   C[1] * (gDorg[index + 2] - gDorg[index - 2]) +
                   C[2] * (gDorg[index + 3] - gDorg[index - 3])) *
                  (+C[0] * (gU0[index + 1] - gU0[index - 1]) +
                   C[1] * (gU0[index + 2] - gU0[index - 2]) +
                   C[2] * (gU0[index + 3] - gU0[index - 3])) -
              FATMDFY * gVorg[index] * gVorg[index] * (1.0f / gDorg[index]) *
                  (+C[0] * (gDorg[index + nnoi] - gDorg[index - nnoi]) +
                   C[1] * (gDorg[index + 2 * nnoi] - gDorg[index - 2 * nnoi]) +
                   C[2] * (gDorg[index + 3 * nnoi] - gDorg[index - 3 * nnoi])) *
                  (+C[0] * (gU0[index + nnoi] - gU0[index - nnoi]) +
                   C[1] * (gU0[index + 2 * nnoi] - gU0[index - 2 * nnoi]) +
                   C[2] * (gU0[index + 3 * nnoi] - gU0[index - 3 * nnoi])) -
              FATMDFZ * gVorg[index] * gVorg[index] * (1.0f / gDorg[index]) *
                  (+C[0] * (gDorg[index + stride] - gDorg[index - stride]) +
                   C[1] *
                       (gDorg[index + 2 * stride] - gDorg[index - 2 * stride]) +
                   C[2] * (gDorg[index + 3 * stride] -
                           gDorg[index - 3 * stride])) *
                  (+C[0] * (gU0[index + stride] - gU0[index - stride]) +
                   C[1] * (gU0[index + 2 * stride] - gU0[index - 2 * stride]) +
                   C[2] * (gU0[index + 3 * stride] - gU0[index - 3 * stride]));
        }
        index += stride;
      }
    }
}


x86 assembly (clang, -O0):
<kernel_CPU_06_mod_3DRhoVar>:
push   %rbp
mov    %rsp,%rbp
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%eax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8d,-0x24(%rbp)
mov    %r9d,-0x28(%rbp)
movss  %xmm0,-0x2c(%rbp)
movss  %xmm1,-0x30(%rbp)
movss  %xmm2,-0x34(%rbp)
mov    -0x24(%rbp),%eax
imul   -0x28(%rbp),%eax
mov    %eax,-0x40(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1bb8 <kernel_CPU_06_mod_3DRhoVar+0xab8>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1ba5 <kernel_CPU_06_mod_3DRhoVar+0xaa5>
mov    -0x3c(%rbp),%eax
imul   -0x24(%rbp),%eax
add    -0x38(%rbp),%eax
mov    0x10(%rbp),%ecx
imul   -0x40(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x44(%rbp)
mov    0x10(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    1b92 <kernel_CPU_06_mod_3DRhoVar+0xa92>
mov    -0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jbe    1b7b <kernel_CPU_06_mod_3DRhoVar+0xa7b>
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
addss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  -0x2c(%rbp),%xmm1
mov    -0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm1
mov    -0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm1
mov    0x20(%rbp),%rax
movss  0x18(%rax),%xmm3
mov    -0x8(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x6,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm4
mov    -0x8(%rbp),%rax
mov    -0x44(%rbp),%ecx
sub    $0x6,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mov    0x20(%rbp),%rax
movss  0x14(%rax),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x5,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm5
mov    -0x8(%rbp),%rax
mov    -0x44(%rbp),%ecx
sub    $0x5,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm5
mulss  %xmm5,%xmm2
mulss  %xmm4,%xmm3
addss  %xmm2,%xmm3
mov    0x20(%rbp),%rax
movss  0x10(%rax),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm4
mov    -0x8(%rbp),%rax
mov    -0x44(%rbp),%ecx
sub    $0x4,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mulss  %xmm4,%xmm2
addss  %xmm3,%xmm2
mov    0x20(%rbp),%rax
movss  0xc(%rax),%xmm3
mov    -0x8(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm4
mov    -0x8(%rbp),%rax
mov    -0x44(%rbp),%ecx
sub    $0x3,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mulss  %xmm4,%xmm3
addss  %xmm2,%xmm3
mov    0x20(%rbp),%rax
movss  0x8(%rax),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm4
mov    -0x8(%rbp),%rax
mov    -0x44(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mulss  %xmm4,%xmm2
addss  %xmm3,%xmm2
mov    0x20(%rbp),%rax
movss  0x4(%rax),%xmm3
mov    -0x8(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm4
mov    -0x8(%rbp),%rax
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mulss  %xmm4,%xmm3
addss  %xmm2,%xmm3
mov    0x20(%rbp),%rax
movss  (%rax),%xmm2
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm4
mulss  %xmm4,%xmm2
addss  %xmm3,%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x30(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    0x20(%rbp),%rax
movss  0x18(%rax),%xmm3
mov    -0x8(%rbp),%rax
mov    -0x44(%rbp),%ecx
imul   $0x6,-0x24(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm4
mov    -0x8(%rbp),%rax
mov    -0x44(%rbp),%ecx
imul   $0x6,-0x24(%rbp),%edx
sub    %edx,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mov    0x20(%rbp),%rax
movss  0x14(%rax),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x44(%rbp),%ecx
imul   $0x5,-0x24(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm5
mov    -0x8(%rbp),%rax
mov    -0x44(%rbp),%ecx
imul   $0x5,-0x24(%rbp),%edx
sub    %edx,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm5
mulss  %xmm5,%xmm2
mulss  %xmm4,%xmm3
addss  %xmm2,%xmm3
mov    0x20(%rbp),%rax
movss  0x10(%rax),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x44(%rbp),%ecx
mov    -0x24(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm4
mov    -0x8(%rbp),%rax
mov    -0x44(%rbp),%ecx
mov    -0x24(%rbp),%edx
shl    $0x2,%edx
sub    %edx,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mulss  %xmm4,%xmm2
addss  %xmm3,%xmm2
mov    0x20(%rbp),%rax
movss  0xc(%rax),%xmm3
mov    -0x8(%rbp),%rax
mov    -0x44(%rbp),%ecx
imul   $0x3,-0x24(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm4
mov    -0x8(%rbp),%rax
mov    -0x44(%rbp),%ecx
imul   $0x3,-0x24(%rbp),%edx
sub    %edx,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mulss  %xmm4,%xmm3
addss  %xmm2,%xmm3
mov    0x20(%rbp),%rax
movss  0x8(%rax),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x44(%rbp),%ecx
mov    -0x24(%rbp),%edx
shl    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm4
mov    -0x8(%rbp),%rax
mov    -0x44(%rbp),%ecx
mov    -0x24(%rbp),%edx
shl    $0x1,%edx
sub    %edx,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mulss  %xmm4,%xmm2
addss  %xmm3,%xmm2
mov    0x20(%rbp),%rax
movss  0x4(%rax),%xmm3
mov    -0x8(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm4
mov    -0x8(%rbp),%rax
mov    -0x44(%rbp),%ecx
sub    -0x24(%rbp),%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mulss  %xmm4,%xmm3
addss  %xmm2,%xmm3
mov    0x20(%rbp),%rax
movss  (%rax),%xmm2
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm4
mulss  %xmm4,%xmm2
addss  %xmm3,%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x34(%rbp),%xmm1
mov    -0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm1
mov    -0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm1
mov    0x20(%rbp),%rax
movss  0x18(%rax),%xmm3
mov    -0x8(%rbp),%rax
mov    -0x44(%rbp),%ecx
imul   $0x6,-0x40(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm4
mov    -0x8(%rbp),%rax
mov    -0x44(%rbp),%ecx
imul   $0x6,-0x40(%rbp),%edx
sub    %edx,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mov    0x20(%rbp),%rax
movss  0x14(%rax),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x44(%rbp),%ecx
imul   $0x5,-0x40(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm5
mov    -0x8(%rbp),%rax
mov    -0x44(%rbp),%ecx
imul   $0x5,-0x40(%rbp),%edx
sub    %edx,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm5
mulss  %xmm5,%xmm2
mulss  %xmm4,%xmm3
addss  %xmm2,%xmm3
mov    0x20(%rbp),%rax
movss  0x10(%rax),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x44(%rbp),%ecx
mov    -0x40(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm4
mov    -0x8(%rbp),%rax
mov    -0x44(%rbp),%ecx
mov    -0x40(%rbp),%edx
shl    $0x2,%edx
sub    %edx,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mulss  %xmm4,%xmm2
addss  %xmm3,%xmm2
mov    0x20(%rbp),%rax
movss  0xc(%rax),%xmm3
mov    -0x8(%rbp),%rax
mov    -0x44(%rbp),%ecx
imul   $0x3,-0x40(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm4
mov    -0x8(%rbp),%rax
mov    -0x44(%rbp),%ecx
imul   $0x3,-0x40(%rbp),%edx
sub    %edx,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mulss  %xmm4,%xmm3
addss  %xmm2,%xmm3
mov    0x20(%rbp),%rax
movss  0x8(%rax),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x44(%rbp),%ecx
mov    -0x40(%rbp),%edx
shl    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm4
mov    -0x8(%rbp),%rax
mov    -0x44(%rbp),%ecx
mov    -0x40(%rbp),%edx
shl    $0x1,%edx
sub    %edx,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mulss  %xmm4,%xmm2
addss  %xmm3,%xmm2
mov    0x20(%rbp),%rax
movss  0x4(%rax),%xmm3
mov    -0x8(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm4
mov    -0x8(%rbp),%rax
mov    -0x44(%rbp),%ecx
sub    -0x40(%rbp),%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mulss  %xmm4,%xmm3
addss  %xmm2,%xmm3
mov    0x20(%rbp),%rax
movss  (%rax),%xmm2
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm4
mulss  %xmm4,%xmm2
addss  %xmm3,%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x2c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  0x932(%rip),%xmm2
divss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
mov    0x28(%rbp),%rax
movss  (%rax),%xmm3
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm4
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm4
mov    0x28(%rbp),%rax
movss  0x4(%rax),%xmm2
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm5
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm5
mulss  %xmm5,%xmm2
mulss  %xmm4,%xmm3
addss  %xmm2,%xmm3
mov    0x28(%rbp),%rax
movss  0x8(%rax),%xmm2
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm4
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
sub    $0x3,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm4
mulss  %xmm4,%xmm2
addss  %xmm3,%xmm2
mulss  %xmm2,%xmm0
mov    0x28(%rbp),%rax
movss  (%rax),%xmm3
mov    -0x8(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm4
mov    -0x8(%rbp),%rax
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm4
mov    0x28(%rbp),%rax
movss  0x4(%rax),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm5
mov    -0x8(%rbp),%rax
mov    -0x44(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm5
mulss  %xmm5,%xmm2
mulss  %xmm4,%xmm3
addss  %xmm2,%xmm3
mov    0x28(%rbp),%rax
movss  0x8(%rax),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm4
mov    -0x8(%rbp),%rax
mov    -0x44(%rbp),%ecx
sub    $0x3,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm4
mulss  %xmm4,%xmm2
addss  %xmm3,%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x30(%rbp),%xmm1
mov    -0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm1
mov    -0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm1
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  0x7ad(%rip),%xmm2
divss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm1
mov    0x28(%rbp),%rax
movss  (%rax),%xmm3
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm4
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
sub    -0x24(%rbp),%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm4
mov    0x28(%rbp),%rax
movss  0x4(%rax),%xmm2
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
mov    -0x24(%rbp),%edx
shl    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm5
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
mov    -0x24(%rbp),%edx
shl    $0x1,%edx
sub    %edx,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm5
mulss  %xmm5,%xmm2
mulss  %xmm4,%xmm3
addss  %xmm2,%xmm3
mov    0x28(%rbp),%rax
movss  0x8(%rax),%xmm2
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
imul   $0x3,-0x24(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm4
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
imul   $0x3,-0x24(%rbp),%edx
sub    %edx,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm4
mulss  %xmm4,%xmm2
addss  %xmm3,%xmm2
mulss  %xmm2,%xmm1
mov    0x28(%rbp),%rax
movss  (%rax),%xmm3
mov    -0x8(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm4
mov    -0x8(%rbp),%rax
mov    -0x44(%rbp),%ecx
sub    -0x24(%rbp),%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm4
mov    0x28(%rbp),%rax
movss  0x4(%rax),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x44(%rbp),%ecx
mov    -0x24(%rbp),%edx
shl    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm5
mov    -0x8(%rbp),%rax
mov    -0x44(%rbp),%ecx
mov    -0x24(%rbp),%edx
shl    $0x1,%edx
sub    %edx,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm5
mulss  %xmm5,%xmm2
mulss  %xmm4,%xmm3
addss  %xmm2,%xmm3
mov    0x28(%rbp),%rax
movss  0x8(%rax),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x44(%rbp),%ecx
imul   $0x3,-0x24(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm4
mov    -0x8(%rbp),%rax
mov    -0x44(%rbp),%ecx
imul   $0x3,-0x24(%rbp),%edx
sub    %edx,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm4
mulss  %xmm4,%xmm2
addss  %xmm3,%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x34(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  0x608(%rip),%xmm2
divss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
mov    0x28(%rbp),%rax
movss  (%rax),%xmm3
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm4
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
sub    -0x40(%rbp),%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm4
mov    0x28(%rbp),%rax
movss  0x4(%rax),%xmm2
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
mov    -0x40(%rbp),%edx
shl    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm5
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
mov    -0x40(%rbp),%edx
shl    $0x1,%edx
sub    %edx,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm5
mulss  %xmm5,%xmm2
mulss  %xmm4,%xmm3
addss  %xmm2,%xmm3
mov    0x28(%rbp),%rax
movss  0x8(%rax),%xmm2
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
imul   $0x3,-0x40(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm4
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
imul   $0x3,-0x40(%rbp),%edx
sub    %edx,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm4
mulss  %xmm4,%xmm2
addss  %xmm3,%xmm2
mulss  %xmm2,%xmm0
mov    0x28(%rbp),%rax
movss  (%rax),%xmm3
mov    -0x8(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm4
mov    -0x8(%rbp),%rax
mov    -0x44(%rbp),%ecx
sub    -0x40(%rbp),%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm4
mov    0x28(%rbp),%rax
movss  0x4(%rax),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x44(%rbp),%ecx
mov    -0x40(%rbp),%edx
shl    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm5
mov    -0x8(%rbp),%rax
mov    -0x44(%rbp),%ecx
mov    -0x40(%rbp),%edx
shl    $0x1,%edx
sub    %edx,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm5
mulss  %xmm5,%xmm2
mulss  %xmm4,%xmm3
addss  %xmm2,%xmm3
mov    0x28(%rbp),%rax
movss  0x8(%rax),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x44(%rbp),%ecx
imul   $0x3,-0x40(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm4
mov    -0x8(%rbp),%rax
mov    -0x44(%rbp),%ecx
imul   $0x3,-0x40(%rbp),%edx
sub    %edx,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm4
mulss  %xmm4,%xmm2
addss  %xmm3,%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x40(%rbp),%eax
add    -0x44(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1185 <kernel_CPU_06_mod_3DRhoVar+0x85>
jmp    1b97 <kernel_CPU_06_mod_3DRhoVar+0xa97>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    115d <kernel_CPU_06_mod_3DRhoVar+0x5d>
jmp    1baa <kernel_CPU_06_mod_3DRhoVar+0xaaa>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    114a <kernel_CPU_06_mod_3DRhoVar+0x4a>
pop    %rbp
ret

x86 assembly (clang, -O2):
<kernel_CPU_06_mod_3DRhoVar>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x60,%rsp
movss  %xmm2,-0x48(%rsp)
movss  %xmm1,-0x4c(%rsp)
movss  %xmm0,-0x50(%rsp)
mov    %r9d,-0x80(%rsp)
mov    %rsi,-0x18(%rsp)
mov    %r8,-0x68(%rsp)
test   %r8d,%r8d
jle    17bb <kernel_CPU_06_mod_3DRhoVar+0x6bb>
mov    -0x80(%rsp),%eax
mov    -0x68(%rsp),%rsi
imul   %esi,%eax
mov    %eax,%ebp
imul   0x98(%rsp),%ebp
mov    %ebp,-0x6c(%rsp)
lea    (%rsi,%rsi,1),%r15d
lea    (%r15,%r15,2),%r8d
lea    (%rsi,%rsi,4),%r9d
lea    0x0(,%rsi,4),%r10d
lea    (%rsi,%rsi,2),%r11d
lea    (%rax,%rax,1),%ebp
lea    0x0(%rbp,%rbp,2),%r14d
lea    (%rax,%rax,4),%r12d
lea    (%rax,%rax,2),%ebx
movslq %eax,%r13
mov    %r13,-0x20(%rsp)
shl    $0x2,%eax
movslq %ebp,%rbp
mov    %rbp,0x40(%rsp)
movslq %ebx,%rbx
mov    %rbx,0x38(%rsp)
cltq
mov    %rax,0x30(%rsp)
movslq %r12d,%rax
mov    %rax,0x28(%rsp)
movslq %r14d,%rax
mov    %rax,0x20(%rsp)
movslq %r15d,%rax
mov    %rax,0x18(%rsp)
movslq %r11d,%rax
mov    %rax,0x10(%rsp)
movslq %r10d,%rax
mov    %rax,0x8(%rsp)
movslq %r9d,%rax
mov    %rax,(%rsp)
movslq %r8d,%rax
mov    %rax,-0x8(%rsp)
mov    0xa0(%rsp),%eax
sub    0x98(%rsp),%eax
mov    %eax,-0x58(%rsp)
xorps  %xmm0,%xmm0
mov    %esi,%eax
mov    %rax,-0x10(%rsp)
xor    %eax,%eax
mov    %rdx,0x48(%rsp)
jmp    1216 <kernel_CPU_06_mod_3DRhoVar+0x116>
nopw   0x0(%rax,%rax,1)
mov    -0x5c(%rsp),%eax
add    $0x1,%eax
addl   $0x1,-0x6c(%rsp)
cmp    -0x68(%rsp),%eax
je     17bb <kernel_CPU_06_mod_3DRhoVar+0x6bb>
mov    %eax,-0x5c(%rsp)
cmpl   $0x0,-0x80(%rsp)
jle    1200 <kernel_CPU_06_mod_3DRhoVar+0x100>
xor    %eax,%eax
mov    -0x6c(%rsp),%esi
mov    %esi,-0x7c(%rsp)
jmp    1249 <kernel_CPU_06_mod_3DRhoVar+0x149>
nopl   (%rax)
mov    -0x54(%rsp),%eax
add    $0x1,%eax
mov    -0x7c(%rsp),%esi
add    -0x68(%rsp),%esi
mov    %esi,-0x7c(%rsp)
cmp    -0x80(%rsp),%eax
je     1200 <kernel_CPU_06_mod_3DRhoVar+0x100>
mov    %eax,-0x54(%rsp)
mov    0x98(%rsp),%eax
cmp    0xa0(%rsp),%eax
jge    1230 <kernel_CPU_06_mod_3DRhoVar+0x130>
movslq -0x7c(%rsp),%r12
mov    -0x58(%rsp),%r13d
jmp    179b <kernel_CPU_06_mod_3DRhoVar+0x69b>
nopl   0x0(%rax)
movss  (%rdi,%r12,4),%xmm12
movaps %xmm12,%xmm2
addss  %xmm12,%xmm2
mov    -0x18(%rsp),%rax
subss  (%rax,%r12,4),%xmm2
mov    0xa8(%rsp),%rax
movss  0x18(%rax),%xmm1
movss  0x18(%rdi,%r12,4),%xmm4
addss  -0x18(%rdi,%r12,4),%xmm4
movss  0x14(%rax),%xmm9
movss  0x14(%rdi,%r12,4),%xmm0
addss  -0x14(%rdi,%r12,4),%xmm0
mulss  %xmm9,%xmm0
mulss  %xmm1,%xmm4
movaps %xmm1,%xmm10
movss  %xmm1,-0x70(%rsp)
addss  %xmm0,%xmm4
movss  0x10(%rdi,%r12,4),%xmm5
addss  -0x10(%rdi,%r12,4),%xmm5
movss  0x10(%rax),%xmm0
mulss  %xmm0,%xmm5
addss  %xmm4,%xmm5
movss  0xc(%rax),%xmm3
movss  0xc(%rdi,%r12,4),%xmm13
movss  -0xc(%rdi,%r12,4),%xmm1
movss  %xmm1,-0x24(%rsp)
movss  -0x8(%rdi,%r12,4),%xmm7
movss  %xmm7,-0x2c(%rsp)
movaps %xmm13,%xmm4
addss  %xmm1,%xmm4
mulss  %xmm3,%xmm4
movss  %xmm3,-0x74(%rsp)
addss  %xmm5,%xmm4
movss  0x8(%rax),%xmm1
movss  0x8(%rdi,%r12,4),%xmm6
movss  %xmm6,-0x28(%rsp)
addss  %xmm7,%xmm6
mulss  %xmm1,%xmm6
movaps %xmm1,%xmm11
movss  %xmm1,-0x78(%rsp)
addss  %xmm4,%xmm6
movss  0x4(%rdi,%r12,4),%xmm5
movss  -0x4(%rdi,%r12,4),%xmm1
movss  %xmm1,-0x34(%rsp)
movaps %xmm5,%xmm4
addss  %xmm1,%xmm4
movss  0x4(%rax),%xmm1
mulss  %xmm1,%xmm4
movaps %xmm1,%xmm8
movss  %xmm1,-0x44(%rsp)
addss  %xmm6,%xmm4
movaps %xmm15,%xmm7
mulss  -0x50(%rsp),%xmm7
mulss  (%rax),%xmm12
mulss  %xmm15,%xmm7
addss  %xmm12,%xmm4
mulss  %xmm7,%xmm4
mov    -0x8(%rsp),%rsi
lea    (%r12,%rsi,1),%rax
mov    %r12,%rbp
sub    %rsi,%rbp
movss  (%rdi,%rax,4),%xmm6
addss  (%rdi,%rbp,4),%xmm6
addss  %xmm2,%xmm4
mov    (%rsp),%rsi
lea    (%r12,%rsi,1),%rax
mov    %r12,%rbp
sub    %rsi,%rbp
movss  (%rdi,%rax,4),%xmm2
addss  (%rdi,%rbp,4),%xmm2
mulss  %xmm9,%xmm2
mulss  %xmm10,%xmm6
addss  %xmm2,%xmm6
mov    0x8(%rsp),%rsi
lea    (%r12,%rsi,1),%rax
mov    %r12,%rbp
sub    %rsi,%rbp
movss  (%rdi,%rax,4),%xmm2
addss  (%rdi,%rbp,4),%xmm2
mulss  %xmm0,%xmm2
addss  %xmm6,%xmm2
mov    0x10(%rsp),%rax
lea    (%r12,%rax,1),%rsi
mov    %rsi,0x58(%rsp)
mov    %r12,%rbp
sub    %rax,%rbp
movss  (%rdi,%rsi,4),%xmm10
movss  (%rdi,%rbp,4),%xmm1
movss  %xmm1,-0x30(%rsp)
movaps %xmm10,%xmm6
addss  %xmm1,%xmm6
mulss  %xmm3,%xmm6
addss  %xmm2,%xmm6
mov    0x18(%rsp),%rax
lea    (%r12,%rax,1),%rdx
mov    %rdx,0x50(%rsp)
mov    %r12,%r10
sub    %rax,%r10
movss  (%rdi,%rdx,4),%xmm14
movss  (%rdi,%r10,4),%xmm2
movss  %xmm2,-0x38(%rsp)
movaps %xmm14,%xmm1
addss  %xmm2,%xmm1
mulss  %xmm11,%xmm1
addss  %xmm6,%xmm1
mov    -0x10(%rsp),%rax
lea    (%r12,%rax,1),%r11
mov    %r12,%rdx
sub    %rax,%rdx
movss  (%rdi,%r11,4),%xmm6
movss  (%rdi,%rdx,4),%xmm3
movss  %xmm3,-0x3c(%rsp)
movaps %xmm6,%xmm2
addss  %xmm3,%xmm2
mulss  %xmm8,%xmm2
addss  %xmm1,%xmm2
movaps %xmm15,%xmm8
mulss  -0x4c(%rsp),%xmm8
mulss  %xmm15,%xmm8
addss  %xmm12,%xmm2
mulss  %xmm8,%xmm2
addss  %xmm4,%xmm2
movaps %xmm15,%xmm11
mulss  -0x48(%rsp),%xmm11
mov    0x28(%rsp),%rsi
lea    (%r12,%rsi,1),%rax
mov    %r12,%rbx
sub    %rsi,%rbx
movss  (%rdi,%rax,4),%xmm1
addss  (%rdi,%rbx,4),%xmm1
mulss  %xmm15,%xmm11
movss  %xmm11,-0x40(%rsp)
mulss  %xmm9,%xmm1
mov    0x20(%rsp),%rsi
lea    (%r12,%rsi,1),%rax
mov    %r12,%rbx
sub    %rsi,%rbx
movss  (%rdi,%rax,4),%xmm3
addss  (%rdi,%rbx,4),%xmm3
mulss  -0x70(%rsp),%xmm3
addss  %xmm1,%xmm3
mov    0x30(%rsp),%rsi
lea    (%r12,%rsi,1),%rax
mov    %r12,%rbx
sub    %rsi,%rbx
movss  (%rdi,%rax,4),%xmm1
addss  (%rdi,%rbx,4),%xmm1
mulss  %xmm0,%xmm1
addss  %xmm3,%xmm1
mov    0x38(%rsp),%rax
lea    (%r12,%rax,1),%r14
mov    %r12,%r15
sub    %rax,%r15
movss  (%rdi,%r14,4),%xmm9
movss  (%rdi,%r15,4),%xmm3
movss  %xmm3,-0x70(%rsp)
movaps %xmm9,%xmm0
addss  %xmm3,%xmm0
mulss  -0x74(%rsp),%xmm0
addss  %xmm1,%xmm0
mov    0x40(%rsp),%rax
lea    (%r12,%rax,1),%rbx
mov    %r12,%r8
sub    %rax,%r8
movss  (%rdi,%rbx,4),%xmm15
movss  (%rdi,%r8,4),%xmm3
movss  %xmm3,-0x74(%rsp)
movaps %xmm15,%xmm1
addss  %xmm3,%xmm1
mulss  -0x78(%rsp),%xmm1
addss  %xmm0,%xmm1
mov    -0x20(%rsp),%rsi
lea    (%r12,%rsi,1),%r9
mov    %r12,%rax
sub    %rsi,%rax
movss  (%rdi,%r9,4),%xmm4
movss  (%rdi,%rax,4),%xmm0
movss  %xmm0,-0x78(%rsp)
movaps %xmm4,%xmm3
addss  %xmm0,%xmm3
mulss  -0x44(%rsp),%xmm3
addss  %xmm1,%xmm3
addss  %xmm12,%xmm3
mulss  %xmm11,%xmm3
addss  %xmm2,%xmm3
movss  0x4(%rcx,%r12,4),%xmm2
subss  -0x4(%rcx,%r12,4),%xmm2
movss  0x8(%rcx,%r12,4),%xmm1
subss  -0x8(%rcx,%r12,4),%xmm1
mov    0xb0(%rsp),%rsi
movss  0x4(%rsi),%xmm12
mulss  %xmm12,%xmm1
movss  (%rsi),%xmm11
mulss  %xmm11,%xmm2
addss  %xmm1,%xmm2
movss  0xc(%rcx,%r12,4),%xmm0
subss  -0xc(%rcx,%r12,4),%xmm0
movss  0x8(%rsi),%xmm1
mulss  %xmm1,%xmm0
addss  %xmm2,%xmm0
subss  -0x34(%rsp),%xmm5
movss  -0x28(%rsp),%xmm2
subss  -0x2c(%rsp),%xmm2
mulss  %xmm12,%xmm2
mulss  %xmm11,%xmm5
addss  %xmm2,%xmm5
subss  -0x24(%rsp),%xmm13
mulss  %xmm1,%xmm13
addss  %xmm5,%xmm13
movss  0x995(%rip),%xmm5
divss  (%rcx,%r12,4),%xmm5
mulss  %xmm5,%xmm7
mulss  %xmm0,%xmm7
movss  (%rcx,%r11,4),%xmm0
subss  (%rcx,%rdx,4),%xmm0
mulss  %xmm13,%xmm7
mov    0x50(%rsp),%rdx
movss  (%rcx,%rdx,4),%xmm2
mov    0x48(%rsp),%rdx
subss  (%rcx,%r10,4),%xmm2
subss  %xmm7,%xmm3
mulss  %xmm12,%xmm2
mulss  %xmm11,%xmm0
addss  %xmm2,%xmm0
mov    0x58(%rsp),%rsi
movss  (%rcx,%rsi,4),%xmm2
subss  (%rcx,%rbp,4),%xmm2
mulss  %xmm1,%xmm2
addss  %xmm0,%xmm2
subss  -0x3c(%rsp),%xmm6
subss  -0x38(%rsp),%xmm14
mulss  %xmm12,%xmm14
mulss  %xmm11,%xmm6
addss  %xmm14,%xmm6
subss  -0x30(%rsp),%xmm10
mulss  %xmm1,%xmm10
addss  %xmm6,%xmm10
mulss  %xmm5,%xmm8
mulss  %xmm2,%xmm8
movss  (%rcx,%r9,4),%xmm0
subss  (%rcx,%rax,4),%xmm0
mulss  %xmm10,%xmm8
movss  (%rcx,%rbx,4),%xmm2
subss  (%rcx,%r8,4),%xmm2
subss  %xmm8,%xmm3
movss  (%rcx,%r14,4),%xmm6
subss  (%rcx,%r15,4),%xmm6
mulss  %xmm12,%xmm2
mulss  %xmm11,%xmm0
addss  %xmm2,%xmm0
mulss  %xmm1,%xmm6
addss  %xmm0,%xmm6
xorps  %xmm0,%xmm0
subss  -0x78(%rsp),%xmm4
subss  -0x74(%rsp),%xmm15
mulss  %xmm12,%xmm15
mulss  %xmm11,%xmm4
addss  %xmm15,%xmm4
subss  -0x70(%rsp),%xmm9
mulss  %xmm1,%xmm9
addss  %xmm4,%xmm9
mulss  -0x40(%rsp),%xmm5
mulss  %xmm6,%xmm5
mulss  %xmm9,%xmm5
subss  %xmm5,%xmm3
mov    -0x18(%rsp),%rax
movss  %xmm3,(%rax,%r12,4)
mov    %r9,%r12
add    $0xffffffff,%r13d
je     1230 <kernel_CPU_06_mod_3DRhoVar+0x130>
movss  (%rdx,%r12,4),%xmm15
ucomiss %xmm0,%xmm15
ja     1270 <kernel_CPU_06_mod_3DRhoVar+0x170>
add    -0x20(%rsp),%r12
add    $0xffffffff,%r13d
jne    179b <kernel_CPU_06_mod_3DRhoVar+0x69b>
jmp    1230 <kernel_CPU_06_mod_3DRhoVar+0x130>
add    $0x60,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @kernel_CPU_06_mod_3DRhoVar(float* %0, float* %1, float* %2, float* %3, i32 %4, i32 %5, i32 %6, i32 %7, float %8, float %9, float %10, float* %11, float* %12) {
%14 = alloca float*
%15 = alloca float*
%16 = alloca float*
%17 = alloca float*
%18 = alloca i32
%19 = alloca i32
%20 = alloca i32
%21 = alloca i32
%22 = alloca float
%23 = alloca float
%24 = alloca float
%25 = alloca float*
%26 = alloca float*
%27 = alloca i32
%28 = alloca i32
%29 = alloca i32
%30 = alloca i32
%31 = alloca i32
store float* %0, float** %14
store float* %1, float** %15
store float* %2, float** %16
store float* %3, float** %17
store i32 %4, i32* %18
store i32 %5, i32* %19
store i32 %6, i32* %20
store i32 %7, i32* %21
store float %8, float* %22
store float %9, float* %23
store float %10, float* %24
store float* %11, float** %25
store float* %12, float** %26
%32 = load i32, i32* %18
%33 = load i32, i32* %19
%34 = mul nsw i32 %32, %33
store i32 %34, i32* %29
store i32 0, i32* %27
br label %35
35: ; preds = %929, %13
%36 = load i32, i32* %27
%37 = load i32, i32* %18
%38 = icmp slt i32 %36, %37
br i1 %38, label %39, label %932
39: ; preds = %35
store i32 0, i32* %28
br label %40
40: ; preds = %925, %39
%41 = load i32, i32* %28
%42 = load i32, i32* %19
%43 = icmp slt i32 %41, %42
br i1 %43, label %44, label %928
44: ; preds = %40
%45 = load i32, i32* %28
%46 = load i32, i32* %18
%47 = mul nsw i32 %45, %46
%48 = load i32, i32* %27
%49 = add nsw i32 %47, %48
%50 = load i32, i32* %20
%51 = load i32, i32* %29
%52 = mul nsw i32 %50, %51
%53 = add nsw i32 %49, %52
store i32 %53, i32* %30
%54 = load i32, i32* %20
store i32 %54, i32* %31
br label %55
55: ; preds = %921, %44
%56 = load i32, i32* %31
%57 = load i32, i32* %21
%58 = icmp slt i32 %56, %57
br i1 %58, label %59, label %924
59: ; preds = %55
%60 = load float*, float** %16
%61 = load i32, i32* %30
%62 = sext i32 %61 to i64
%63 = getelementptr inbounds float, float* %60, i64 %62
%64 = load float, float* %63
%65 = fcmp ogt float %64, 0.000000e+00
br i1 %65, label %66, label %917
66: ; preds = %59
%67 = load float*, float** %14
%68 = load i32, i32* %30
%69 = sext i32 %68 to i64
%70 = getelementptr inbounds float, float* %67, i64 %69
%71 = load float, float* %70
%72 = load float*, float** %15
%73 = load i32, i32* %30
%74 = sext i32 %73 to i64
%75 = getelementptr inbounds float, float* %72, i64 %74
%76 = load float, float* %75
%77 = fneg float %76
%78 = call float @llvm.fmuladd.f32(float 2.000000e+00, float %71, float %77)
%79 = load float, float* %22
%80 = load float*, float** %16
%81 = load i32, i32* %30
%82 = sext i32 %81 to i64
%83 = getelementptr inbounds float, float* %80, i64 %82
%84 = load float, float* %83
%85 = fmul float %79, %84
%86 = load float*, float** %16
%87 = load i32, i32* %30
%88 = sext i32 %87 to i64
%89 = getelementptr inbounds float, float* %86, i64 %88
%90 = load float, float* %89
%91 = fmul float %85, %90
%92 = load float*, float** %25
%93 = getelementptr inbounds float, float* %92, i64 6
%94 = load float, float* %93
%95 = load float*, float** %14
%96 = load i32, i32* %30
%97 = add nsw i32 %96, 6
%98 = sext i32 %97 to i64
%99 = getelementptr inbounds float, float* %95, i64 %98
%100 = load float, float* %99
%101 = load float*, float** %14
%102 = load i32, i32* %30
%103 = sub nsw i32 %102, 6
%104 = sext i32 %103 to i64
%105 = getelementptr inbounds float, float* %101, i64 %104
%106 = load float, float* %105
%107 = fadd float %100, %106
%108 = load float*, float** %25
%109 = getelementptr inbounds float, float* %108, i64 5
%110 = load float, float* %109
%111 = load float*, float** %14
%112 = load i32, i32* %30
%113 = add nsw i32 %112, 5
%114 = sext i32 %113 to i64
%115 = getelementptr inbounds float, float* %111, i64 %114
%116 = load float, float* %115
%117 = load float*, float** %14
%118 = load i32, i32* %30
%119 = sub nsw i32 %118, 5
%120 = sext i32 %119 to i64
%121 = getelementptr inbounds float, float* %117, i64 %120
%122 = load float, float* %121
%123 = fadd float %116, %122
%124 = fmul float %110, %123
%125 = call float @llvm.fmuladd.f32(float %94, float %107, float %124)
%126 = load float*, float** %25
%127 = getelementptr inbounds float, float* %126, i64 4
%128 = load float, float* %127
%129 = load float*, float** %14
%130 = load i32, i32* %30
%131 = add nsw i32 %130, 4
%132 = sext i32 %131 to i64
%133 = getelementptr inbounds float, float* %129, i64 %132
%134 = load float, float* %133
%135 = load float*, float** %14
%136 = load i32, i32* %30
%137 = sub nsw i32 %136, 4
%138 = sext i32 %137 to i64
%139 = getelementptr inbounds float, float* %135, i64 %138
%140 = load float, float* %139
%141 = fadd float %134, %140
%142 = call float @llvm.fmuladd.f32(float %128, float %141, float %125)
%143 = load float*, float** %25
%144 = getelementptr inbounds float, float* %143, i64 3
%145 = load float, float* %144
%146 = load float*, float** %14
%147 = load i32, i32* %30
%148 = add nsw i32 %147, 3
%149 = sext i32 %148 to i64
%150 = getelementptr inbounds float, float* %146, i64 %149
%151 = load float, float* %150
%152 = load float*, float** %14
%153 = load i32, i32* %30
%154 = sub nsw i32 %153, 3
%155 = sext i32 %154 to i64
%156 = getelementptr inbounds float, float* %152, i64 %155
%157 = load float, float* %156
%158 = fadd float %151, %157
%159 = call float @llvm.fmuladd.f32(float %145, float %158, float %142)
%160 = load float*, float** %25
%161 = getelementptr inbounds float, float* %160, i64 2
%162 = load float, float* %161
%163 = load float*, float** %14
%164 = load i32, i32* %30
%165 = add nsw i32 %164, 2
%166 = sext i32 %165 to i64
%167 = getelementptr inbounds float, float* %163, i64 %166
%168 = load float, float* %167
%169 = load float*, float** %14
%170 = load i32, i32* %30
%171 = sub nsw i32 %170, 2
%172 = sext i32 %171 to i64
%173 = getelementptr inbounds float, float* %169, i64 %172
%174 = load float, float* %173
%175 = fadd float %168, %174
%176 = call float @llvm.fmuladd.f32(float %162, float %175, float %159)
%177 = load float*, float** %25
%178 = getelementptr inbounds float, float* %177, i64 1
%179 = load float, float* %178
%180 = load float*, float** %14
%181 = load i32, i32* %30
%182 = add nsw i32 %181, 1
%183 = sext i32 %182 to i64
%184 = getelementptr inbounds float, float* %180, i64 %183
%185 = load float, float* %184
%186 = load float*, float** %14
%187 = load i32, i32* %30
%188 = sub nsw i32 %187, 1
%189 = sext i32 %188 to i64
%190 = getelementptr inbounds float, float* %186, i64 %189
%191 = load float, float* %190
%192 = fadd float %185, %191
%193 = call float @llvm.fmuladd.f32(float %179, float %192, float %176)
%194 = load float*, float** %25
%195 = getelementptr inbounds float, float* %194, i64 0
%196 = load float, float* %195
%197 = load float*, float** %14
%198 = load i32, i32* %30
%199 = sext i32 %198 to i64
%200 = getelementptr inbounds float, float* %197, i64 %199
%201 = load float, float* %200
%202 = call float @llvm.fmuladd.f32(float %196, float %201, float %193)
%203 = call float @llvm.fmuladd.f32(float %91, float %202, float %78)
%204 = load float, float* %23
%205 = load float*, float** %16
%206 = load i32, i32* %30
%207 = sext i32 %206 to i64
%208 = getelementptr inbounds float, float* %205, i64 %207
%209 = load float, float* %208
%210 = fmul float %204, %209
%211 = load float*, float** %16
%212 = load i32, i32* %30
%213 = sext i32 %212 to i64
%214 = getelementptr inbounds float, float* %211, i64 %213
%215 = load float, float* %214
%216 = fmul float %210, %215
%217 = load float*, float** %25
%218 = getelementptr inbounds float, float* %217, i64 6
%219 = load float, float* %218
%220 = load float*, float** %14
%221 = load i32, i32* %30
%222 = load i32, i32* %18
%223 = mul nsw i32 6, %222
%224 = add nsw i32 %221, %223
%225 = sext i32 %224 to i64
%226 = getelementptr inbounds float, float* %220, i64 %225
%227 = load float, float* %226
%228 = load float*, float** %14
%229 = load i32, i32* %30
%230 = load i32, i32* %18
%231 = mul nsw i32 6, %230
%232 = sub nsw i32 %229, %231
%233 = sext i32 %232 to i64
%234 = getelementptr inbounds float, float* %228, i64 %233
%235 = load float, float* %234
%236 = fadd float %227, %235
%237 = load float*, float** %25
%238 = getelementptr inbounds float, float* %237, i64 5
%239 = load float, float* %238
%240 = load float*, float** %14
%241 = load i32, i32* %30
%242 = load i32, i32* %18
%243 = mul nsw i32 5, %242
%244 = add nsw i32 %241, %243
%245 = sext i32 %244 to i64
%246 = getelementptr inbounds float, float* %240, i64 %245
%247 = load float, float* %246
%248 = load float*, float** %14
%249 = load i32, i32* %30
%250 = load i32, i32* %18
%251 = mul nsw i32 5, %250
%252 = sub nsw i32 %249, %251
%253 = sext i32 %252 to i64
%254 = getelementptr inbounds float, float* %248, i64 %253
%255 = load float, float* %254
%256 = fadd float %247, %255
%257 = fmul float %239, %256
%258 = call float @llvm.fmuladd.f32(float %219, float %236, float %257)
%259 = load float*, float** %25
%260 = getelementptr inbounds float, float* %259, i64 4
%261 = load float, float* %260
%262 = load float*, float** %14
%263 = load i32, i32* %30
%264 = load i32, i32* %18
%265 = mul nsw i32 4, %264
%266 = add nsw i32 %263, %265
%267 = sext i32 %266 to i64
%268 = getelementptr inbounds float, float* %262, i64 %267
%269 = load float, float* %268
%270 = load float*, float** %14
%271 = load i32, i32* %30
%272 = load i32, i32* %18
%273 = mul nsw i32 4, %272
%274 = sub nsw i32 %271, %273
%275 = sext i32 %274 to i64
%276 = getelementptr inbounds float, float* %270, i64 %275
%277 = load float, float* %276
%278 = fadd float %269, %277
%279 = call float @llvm.fmuladd.f32(float %261, float %278, float %258)
%280 = load float*, float** %25
%281 = getelementptr inbounds float, float* %280, i64 3
%282 = load float, float* %281
%283 = load float*, float** %14
%284 = load i32, i32* %30
%285 = load i32, i32* %18
%286 = mul nsw i32 3, %285
%287 = add nsw i32 %284, %286
%288 = sext i32 %287 to i64
%289 = getelementptr inbounds float, float* %283, i64 %288
%290 = load float, float* %289
%291 = load float*, float** %14
%292 = load i32, i32* %30
%293 = load i32, i32* %18
%294 = mul nsw i32 3, %293
%295 = sub nsw i32 %292, %294
%296 = sext i32 %295 to i64
%297 = getelementptr inbounds float, float* %291, i64 %296
%298 = load float, float* %297
%299 = fadd float %290, %298
%300 = call float @llvm.fmuladd.f32(float %282, float %299, float %279)
%301 = load float*, float** %25
%302 = getelementptr inbounds float, float* %301, i64 2
%303 = load float, float* %302
%304 = load float*, float** %14
%305 = load i32, i32* %30
%306 = load i32, i32* %18
%307 = mul nsw i32 2, %306
%308 = add nsw i32 %305, %307
%309 = sext i32 %308 to i64
%310 = getelementptr inbounds float, float* %304, i64 %309
%311 = load float, float* %310
%312 = load float*, float** %14
%313 = load i32, i32* %30
%314 = load i32, i32* %18
%315 = mul nsw i32 2, %314
%316 = sub nsw i32 %313, %315
%317 = sext i32 %316 to i64
%318 = getelementptr inbounds float, float* %312, i64 %317
%319 = load float, float* %318
%320 = fadd float %311, %319
%321 = call float @llvm.fmuladd.f32(float %303, float %320, float %300)
%322 = load float*, float** %25
%323 = getelementptr inbounds float, float* %322, i64 1
%324 = load float, float* %323
%325 = load float*, float** %14
%326 = load i32, i32* %30
%327 = load i32, i32* %18
%328 = add nsw i32 %326, %327
%329 = sext i32 %328 to i64
%330 = getelementptr inbounds float, float* %325, i64 %329
%331 = load float, float* %330
%332 = load float*, float** %14
%333 = load i32, i32* %30
%334 = load i32, i32* %18
%335 = sub nsw i32 %333, %334
%336 = sext i32 %335 to i64
%337 = getelementptr inbounds float, float* %332, i64 %336
%338 = load float, float* %337
%339 = fadd float %331, %338
%340 = call float @llvm.fmuladd.f32(float %324, float %339, float %321)
%341 = load float*, float** %25
%342 = getelementptr inbounds float, float* %341, i64 0
%343 = load float, float* %342
%344 = load float*, float** %14
%345 = load i32, i32* %30
%346 = sext i32 %345 to i64
%347 = getelementptr inbounds float, float* %344, i64 %346
%348 = load float, float* %347
%349 = call float @llvm.fmuladd.f32(float %343, float %348, float %340)
%350 = call float @llvm.fmuladd.f32(float %216, float %349, float %203)
%351 = load float, float* %24
%352 = load float*, float** %16
%353 = load i32, i32* %30
%354 = sext i32 %353 to i64
%355 = getelementptr inbounds float, float* %352, i64 %354
%356 = load float, float* %355
%357 = fmul float %351, %356
%358 = load float*, float** %16
%359 = load i32, i32* %30
%360 = sext i32 %359 to i64
%361 = getelementptr inbounds float, float* %358, i64 %360
%362 = load float, float* %361
%363 = fmul float %357, %362
%364 = load float*, float** %25
%365 = getelementptr inbounds float, float* %364, i64 6
%366 = load float, float* %365
%367 = load float*, float** %14
%368 = load i32, i32* %30
%369 = load i32, i32* %29
%370 = mul nsw i32 6, %369
%371 = add nsw i32 %368, %370
%372 = sext i32 %371 to i64
%373 = getelementptr inbounds float, float* %367, i64 %372
%374 = load float, float* %373
%375 = load float*, float** %14
%376 = load i32, i32* %30
%377 = load i32, i32* %29
%378 = mul nsw i32 6, %377
%379 = sub nsw i32 %376, %378
%380 = sext i32 %379 to i64
%381 = getelementptr inbounds float, float* %375, i64 %380
%382 = load float, float* %381
%383 = fadd float %374, %382
%384 = load float*, float** %25
%385 = getelementptr inbounds float, float* %384, i64 5
%386 = load float, float* %385
%387 = load float*, float** %14
%388 = load i32, i32* %30
%389 = load i32, i32* %29
%390 = mul nsw i32 5, %389
%391 = add nsw i32 %388, %390
%392 = sext i32 %391 to i64
%393 = getelementptr inbounds float, float* %387, i64 %392
%394 = load float, float* %393
%395 = load float*, float** %14
%396 = load i32, i32* %30
%397 = load i32, i32* %29
%398 = mul nsw i32 5, %397
%399 = sub nsw i32 %396, %398
%400 = sext i32 %399 to i64
%401 = getelementptr inbounds float, float* %395, i64 %400
%402 = load float, float* %401
%403 = fadd float %394, %402
%404 = fmul float %386, %403
%405 = call float @llvm.fmuladd.f32(float %366, float %383, float %404)
%406 = load float*, float** %25
%407 = getelementptr inbounds float, float* %406, i64 4
%408 = load float, float* %407
%409 = load float*, float** %14
%410 = load i32, i32* %30
%411 = load i32, i32* %29
%412 = mul nsw i32 4, %411
%413 = add nsw i32 %410, %412
%414 = sext i32 %413 to i64
%415 = getelementptr inbounds float, float* %409, i64 %414
%416 = load float, float* %415
%417 = load float*, float** %14
%418 = load i32, i32* %30
%419 = load i32, i32* %29
%420 = mul nsw i32 4, %419
%421 = sub nsw i32 %418, %420
%422 = sext i32 %421 to i64
%423 = getelementptr inbounds float, float* %417, i64 %422
%424 = load float, float* %423
%425 = fadd float %416, %424
%426 = call float @llvm.fmuladd.f32(float %408, float %425, float %405)
%427 = load float*, float** %25
%428 = getelementptr inbounds float, float* %427, i64 3
%429 = load float, float* %428
%430 = load float*, float** %14
%431 = load i32, i32* %30
%432 = load i32, i32* %29
%433 = mul nsw i32 3, %432
%434 = add nsw i32 %431, %433
%435 = sext i32 %434 to i64
%436 = getelementptr inbounds float, float* %430, i64 %435
%437 = load float, float* %436
%438 = load float*, float** %14
%439 = load i32, i32* %30
%440 = load i32, i32* %29
%441 = mul nsw i32 3, %440
%442 = sub nsw i32 %439, %441
%443 = sext i32 %442 to i64
%444 = getelementptr inbounds float, float* %438, i64 %443
%445 = load float, float* %444
%446 = fadd float %437, %445
%447 = call float @llvm.fmuladd.f32(float %429, float %446, float %426)
%448 = load float*, float** %25
%449 = getelementptr inbounds float, float* %448, i64 2
%450 = load float, float* %449
%451 = load float*, float** %14
%452 = load i32, i32* %30
%453 = load i32, i32* %29
%454 = mul nsw i32 2, %453
%455 = add nsw i32 %452, %454
%456 = sext i32 %455 to i64
%457 = getelementptr inbounds float, float* %451, i64 %456
%458 = load float, float* %457
%459 = load float*, float** %14
%460 = load i32, i32* %30
%461 = load i32, i32* %29
%462 = mul nsw i32 2, %461
%463 = sub nsw i32 %460, %462
%464 = sext i32 %463 to i64
%465 = getelementptr inbounds float, float* %459, i64 %464
%466 = load float, float* %465
%467 = fadd float %458, %466
%468 = call float @llvm.fmuladd.f32(float %450, float %467, float %447)
%469 = load float*, float** %25
%470 = getelementptr inbounds float, float* %469, i64 1
%471 = load float, float* %470
%472 = load float*, float** %14
%473 = load i32, i32* %30
%474 = load i32, i32* %29
%475 = add nsw i32 %473, %474
%476 = sext i32 %475 to i64
%477 = getelementptr inbounds float, float* %472, i64 %476
%478 = load float, float* %477
%479 = load float*, float** %14
%480 = load i32, i32* %30
%481 = load i32, i32* %29
%482 = sub nsw i32 %480, %481
%483 = sext i32 %482 to i64
%484 = getelementptr inbounds float, float* %479, i64 %483
%485 = load float, float* %484
%486 = fadd float %478, %485
%487 = call float @llvm.fmuladd.f32(float %471, float %486, float %468)
%488 = load float*, float** %25
%489 = getelementptr inbounds float, float* %488, i64 0
%490 = load float, float* %489
%491 = load float*, float** %14
%492 = load i32, i32* %30
%493 = sext i32 %492 to i64
%494 = getelementptr inbounds float, float* %491, i64 %493
%495 = load float, float* %494
%496 = call float @llvm.fmuladd.f32(float %490, float %495, float %487)
%497 = call float @llvm.fmuladd.f32(float %363, float %496, float %350)
%498 = load float, float* %22
%499 = load float*, float** %16
%500 = load i32, i32* %30
%501 = sext i32 %500 to i64
%502 = getelementptr inbounds float, float* %499, i64 %501
%503 = load float, float* %502
%504 = fmul float %498, %503
%505 = load float*, float** %16
%506 = load i32, i32* %30
%507 = sext i32 %506 to i64
%508 = getelementptr inbounds float, float* %505, i64 %507
%509 = load float, float* %508
%510 = fmul float %504, %509
%511 = load float*, float** %17
%512 = load i32, i32* %30
%513 = sext i32 %512 to i64
%514 = getelementptr inbounds float, float* %511, i64 %513
%515 = load float, float* %514
%516 = fdiv float 1.000000e+00, %515
%517 = fmul float %510, %516
%518 = load float*, float** %26
%519 = getelementptr inbounds float, float* %518, i64 0
%520 = load float, float* %519
%521 = load float*, float** %17
%522 = load i32, i32* %30
%523 = add nsw i32 %522, 1
%524 = sext i32 %523 to i64
%525 = getelementptr inbounds float, float* %521, i64 %524
%526 = load float, float* %525
%527 = load float*, float** %17
%528 = load i32, i32* %30
%529 = sub nsw i32 %528, 1
%530 = sext i32 %529 to i64
%531 = getelementptr inbounds float, float* %527, i64 %530
%532 = load float, float* %531
%533 = fsub float %526, %532
%534 = load float*, float** %26
%535 = getelementptr inbounds float, float* %534, i64 1
%536 = load float, float* %535
%537 = load float*, float** %17
%538 = load i32, i32* %30
%539 = add nsw i32 %538, 2
%540 = sext i32 %539 to i64
%541 = getelementptr inbounds float, float* %537, i64 %540
%542 = load float, float* %541
%543 = load float*, float** %17
%544 = load i32, i32* %30
%545 = sub nsw i32 %544, 2
%546 = sext i32 %545 to i64
%547 = getelementptr inbounds float, float* %543, i64 %546
%548 = load float, float* %547
%549 = fsub float %542, %548
%550 = fmul float %536, %549
%551 = call float @llvm.fmuladd.f32(float %520, float %533, float %550)
%552 = load float*, float** %26
%553 = getelementptr inbounds float, float* %552, i64 2
%554 = load float, float* %553
%555 = load float*, float** %17
%556 = load i32, i32* %30
%557 = add nsw i32 %556, 3
%558 = sext i32 %557 to i64
%559 = getelementptr inbounds float, float* %555, i64 %558
%560 = load float, float* %559
%561 = load float*, float** %17
%562 = load i32, i32* %30
%563 = sub nsw i32 %562, 3
%564 = sext i32 %563 to i64
%565 = getelementptr inbounds float, float* %561, i64 %564
%566 = load float, float* %565
%567 = fsub float %560, %566
%568 = call float @llvm.fmuladd.f32(float %554, float %567, float %551)
%569 = fmul float %517, %568
%570 = load float*, float** %26
%571 = getelementptr inbounds float, float* %570, i64 0
%572 = load float, float* %571
%573 = load float*, float** %14
%574 = load i32, i32* %30
%575 = add nsw i32 %574, 1
%576 = sext i32 %575 to i64
%577 = getelementptr inbounds float, float* %573, i64 %576
%578 = load float, float* %577
%579 = load float*, float** %14
%580 = load i32, i32* %30
%581 = sub nsw i32 %580, 1
%582 = sext i32 %581 to i64
%583 = getelementptr inbounds float, float* %579, i64 %582
%584 = load float, float* %583
%585 = fsub float %578, %584
%586 = load float*, float** %26
%587 = getelementptr inbounds float, float* %586, i64 1
%588 = load float, float* %587
%589 = load float*, float** %14
%590 = load i32, i32* %30
%591 = add nsw i32 %590, 2
%592 = sext i32 %591 to i64
%593 = getelementptr inbounds float, float* %589, i64 %592
%594 = load float, float* %593
%595 = load float*, float** %14
%596 = load i32, i32* %30
%597 = sub nsw i32 %596, 2
%598 = sext i32 %597 to i64
%599 = getelementptr inbounds float, float* %595, i64 %598
%600 = load float, float* %599
%601 = fsub float %594, %600
%602 = fmul float %588, %601
%603 = call float @llvm.fmuladd.f32(float %572, float %585, float %602)
%604 = load float*, float** %26
%605 = getelementptr inbounds float, float* %604, i64 2
%606 = load float, float* %605
%607 = load float*, float** %14
%608 = load i32, i32* %30
%609 = add nsw i32 %608, 3
%610 = sext i32 %609 to i64
%611 = getelementptr inbounds float, float* %607, i64 %610
%612 = load float, float* %611
%613 = load float*, float** %14
%614 = load i32, i32* %30
%615 = sub nsw i32 %614, 3
%616 = sext i32 %615 to i64
%617 = getelementptr inbounds float, float* %613, i64 %616
%618 = load float, float* %617
%619 = fsub float %612, %618
%620 = call float @llvm.fmuladd.f32(float %606, float %619, float %603)
%621 = fneg float %569
%622 = call float @llvm.fmuladd.f32(float %621, float %620, float %497)
%623 = load float, float* %23
%624 = load float*, float** %16
%625 = load i32, i32* %30
%626 = sext i32 %625 to i64
%627 = getelementptr inbounds float, float* %624, i64 %626
%628 = load float, float* %627
%629 = fmul float %623, %628
%630 = load float*, float** %16
%631 = load i32, i32* %30
%632 = sext i32 %631 to i64
%633 = getelementptr inbounds float, float* %630, i64 %632
%634 = load float, float* %633
%635 = fmul float %629, %634
%636 = load float*, float** %17
%637 = load i32, i32* %30
%638 = sext i32 %637 to i64
%639 = getelementptr inbounds float, float* %636, i64 %638
%640 = load float, float* %639
%641 = fdiv float 1.000000e+00, %640
%642 = fmul float %635, %641
%643 = load float*, float** %26
%644 = getelementptr inbounds float, float* %643, i64 0
%645 = load float, float* %644
%646 = load float*, float** %17
%647 = load i32, i32* %30
%648 = load i32, i32* %18
%649 = add nsw i32 %647, %648
%650 = sext i32 %649 to i64
%651 = getelementptr inbounds float, float* %646, i64 %650
%652 = load float, float* %651
%653 = load float*, float** %17
%654 = load i32, i32* %30
%655 = load i32, i32* %18
%656 = sub nsw i32 %654, %655
%657 = sext i32 %656 to i64
%658 = getelementptr inbounds float, float* %653, i64 %657
%659 = load float, float* %658
%660 = fsub float %652, %659
%661 = load float*, float** %26
%662 = getelementptr inbounds float, float* %661, i64 1
%663 = load float, float* %662
%664 = load float*, float** %17
%665 = load i32, i32* %30
%666 = load i32, i32* %18
%667 = mul nsw i32 2, %666
%668 = add nsw i32 %665, %667
%669 = sext i32 %668 to i64
%670 = getelementptr inbounds float, float* %664, i64 %669
%671 = load float, float* %670
%672 = load float*, float** %17
%673 = load i32, i32* %30
%674 = load i32, i32* %18
%675 = mul nsw i32 2, %674
%676 = sub nsw i32 %673, %675
%677 = sext i32 %676 to i64
%678 = getelementptr inbounds float, float* %672, i64 %677
%679 = load float, float* %678
%680 = fsub float %671, %679
%681 = fmul float %663, %680
%682 = call float @llvm.fmuladd.f32(float %645, float %660, float %681)
%683 = load float*, float** %26
%684 = getelementptr inbounds float, float* %683, i64 2
%685 = load float, float* %684
%686 = load float*, float** %17
%687 = load i32, i32* %30
%688 = load i32, i32* %18
%689 = mul nsw i32 3, %688
%690 = add nsw i32 %687, %689
%691 = sext i32 %690 to i64
%692 = getelementptr inbounds float, float* %686, i64 %691
%693 = load float, float* %692
%694 = load float*, float** %17
%695 = load i32, i32* %30
%696 = load i32, i32* %18
%697 = mul nsw i32 3, %696
%698 = sub nsw i32 %695, %697
%699 = sext i32 %698 to i64
%700 = getelementptr inbounds float, float* %694, i64 %699
%701 = load float, float* %700
%702 = fsub float %693, %701
%703 = call float @llvm.fmuladd.f32(float %685, float %702, float %682)
%704 = fmul float %642, %703
%705 = load float*, float** %26
%706 = getelementptr inbounds float, float* %705, i64 0
%707 = load float, float* %706
%708 = load float*, float** %14
%709 = load i32, i32* %30
%710 = load i32, i32* %18
%711 = add nsw i32 %709, %710
%712 = sext i32 %711 to i64
%713 = getelementptr inbounds float, float* %708, i64 %712
%714 = load float, float* %713
%715 = load float*, float** %14
%716 = load i32, i32* %30
%717 = load i32, i32* %18
%718 = sub nsw i32 %716, %717
%719 = sext i32 %718 to i64
%720 = getelementptr inbounds float, float* %715, i64 %719
%721 = load float, float* %720
%722 = fsub float %714, %721
%723 = load float*, float** %26
%724 = getelementptr inbounds float, float* %723, i64 1
%725 = load float, float* %724
%726 = load float*, float** %14
%727 = load i32, i32* %30
%728 = load i32, i32* %18
%729 = mul nsw i32 2, %728
%730 = add nsw i32 %727, %729
%731 = sext i32 %730 to i64
%732 = getelementptr inbounds float, float* %726, i64 %731
%733 = load float, float* %732
%734 = load float*, float** %14
%735 = load i32, i32* %30
%736 = load i32, i32* %18
%737 = mul nsw i32 2, %736
%738 = sub nsw i32 %735, %737
%739 = sext i32 %738 to i64
%740 = getelementptr inbounds float, float* %734, i64 %739
%741 = load float, float* %740
%742 = fsub float %733, %741
%743 = fmul float %725, %742
%744 = call float @llvm.fmuladd.f32(float %707, float %722, float %743)
%745 = load float*, float** %26
%746 = getelementptr inbounds float, float* %745, i64 2
%747 = load float, float* %746
%748 = load float*, float** %14
%749 = load i32, i32* %30
%750 = load i32, i32* %18
%751 = mul nsw i32 3, %750
%752 = add nsw i32 %749, %751
%753 = sext i32 %752 to i64
%754 = getelementptr inbounds float, float* %748, i64 %753
%755 = load float, float* %754
%756 = load float*, float** %14
%757 = load i32, i32* %30
%758 = load i32, i32* %18
%759 = mul nsw i32 3, %758
%760 = sub nsw i32 %757, %759
%761 = sext i32 %760 to i64
%762 = getelementptr inbounds float, float* %756, i64 %761
%763 = load float, float* %762
%764 = fsub float %755, %763
%765 = call float @llvm.fmuladd.f32(float %747, float %764, float %744)
%766 = fneg float %704
%767 = call float @llvm.fmuladd.f32(float %766, float %765, float %622)
%768 = load float, float* %24
%769 = load float*, float** %16
%770 = load i32, i32* %30
%771 = sext i32 %770 to i64
%772 = getelementptr inbounds float, float* %769, i64 %771
%773 = load float, float* %772
%774 = fmul float %768, %773
%775 = load float*, float** %16
%776 = load i32, i32* %30
%777 = sext i32 %776 to i64
%778 = getelementptr inbounds float, float* %775, i64 %777
%779 = load float, float* %778
%780 = fmul float %774, %779
%781 = load float*, float** %17
%782 = load i32, i32* %30
%783 = sext i32 %782 to i64
%784 = getelementptr inbounds float, float* %781, i64 %783
%785 = load float, float* %784
%786 = fdiv float 1.000000e+00, %785
%787 = fmul float %780, %786
%788 = load float*, float** %26
%789 = getelementptr inbounds float, float* %788, i64 0
%790 = load float, float* %789
%791 = load float*, float** %17
%792 = load i32, i32* %30
%793 = load i32, i32* %29
%794 = add nsw i32 %792, %793
%795 = sext i32 %794 to i64
%796 = getelementptr inbounds float, float* %791, i64 %795
%797 = load float, float* %796
%798 = load float*, float** %17
%799 = load i32, i32* %30
%800 = load i32, i32* %29
%801 = sub nsw i32 %799, %800
%802 = sext i32 %801 to i64
%803 = getelementptr inbounds float, float* %798, i64 %802
%804 = load float, float* %803
%805 = fsub float %797, %804
%806 = load float*, float** %26
%807 = getelementptr inbounds float, float* %806, i64 1
%808 = load float, float* %807
%809 = load float*, float** %17
%810 = load i32, i32* %30
%811 = load i32, i32* %29
%812 = mul nsw i32 2, %811
%813 = add nsw i32 %810, %812
%814 = sext i32 %813 to i64
%815 = getelementptr inbounds float, float* %809, i64 %814
%816 = load float, float* %815
%817 = load float*, float** %17
%818 = load i32, i32* %30
%819 = load i32, i32* %29
%820 = mul nsw i32 2, %819
%821 = sub nsw i32 %818, %820
%822 = sext i32 %821 to i64
%823 = getelementptr inbounds float, float* %817, i64 %822
%824 = load float, float* %823
%825 = fsub float %816, %824
%826 = fmul float %808, %825
%827 = call float @llvm.fmuladd.f32(float %790, float %805, float %826)
%828 = load float*, float** %26
%829 = getelementptr inbounds float, float* %828, i64 2
%830 = load float, float* %829
%831 = load float*, float** %17
%832 = load i32, i32* %30
%833 = load i32, i32* %29
%834 = mul nsw i32 3, %833
%835 = add nsw i32 %832, %834
%836 = sext i32 %835 to i64
%837 = getelementptr inbounds float, float* %831, i64 %836
%838 = load float, float* %837
%839 = load float*, float** %17
%840 = load i32, i32* %30
%841 = load i32, i32* %29
%842 = mul nsw i32 3, %841
%843 = sub nsw i32 %840, %842
%844 = sext i32 %843 to i64
%845 = getelementptr inbounds float, float* %839, i64 %844
%846 = load float, float* %845
%847 = fsub float %838, %846
%848 = call float @llvm.fmuladd.f32(float %830, float %847, float %827)
%849 = fmul float %787, %848
%850 = load float*, float** %26
%851 = getelementptr inbounds float, float* %850, i64 0
%852 = load float, float* %851
%853 = load float*, float** %14
%854 = load i32, i32* %30
%855 = load i32, i32* %29
%856 = add nsw i32 %854, %855
%857 = sext i32 %856 to i64
%858 = getelementptr inbounds float, float* %853, i64 %857
%859 = load float, float* %858
%860 = load float*, float** %14
%861 = load i32, i32* %30
%862 = load i32, i32* %29
%863 = sub nsw i32 %861, %862
%864 = sext i32 %863 to i64
%865 = getelementptr inbounds float, float* %860, i64 %864
%866 = load float, float* %865
%867 = fsub float %859, %866
%868 = load float*, float** %26
%869 = getelementptr inbounds float, float* %868, i64 1
%870 = load float, float* %869
%871 = load float*, float** %14
%872 = load i32, i32* %30
%873 = load i32, i32* %29
%874 = mul nsw i32 2, %873
%875 = add nsw i32 %872, %874
%876 = sext i32 %875 to i64
%877 = getelementptr inbounds float, float* %871, i64 %876
%878 = load float, float* %877
%879 = load float*, float** %14
%880 = load i32, i32* %30
%881 = load i32, i32* %29
%882 = mul nsw i32 2, %881
%883 = sub nsw i32 %880, %882
%884 = sext i32 %883 to i64
%885 = getelementptr inbounds float, float* %879, i64 %884
%886 = load float, float* %885
%887 = fsub float %878, %886
%888 = fmul float %870, %887
%889 = call float @llvm.fmuladd.f32(float %852, float %867, float %888)
%890 = load float*, float** %26
%891 = getelementptr inbounds float, float* %890, i64 2
%892 = load float, float* %891
%893 = load float*, float** %14
%894 = load i32, i32* %30
%895 = load i32, i32* %29
%896 = mul nsw i32 3, %895
%897 = add nsw i32 %894, %896
%898 = sext i32 %897 to i64
%899 = getelementptr inbounds float, float* %893, i64 %898
%900 = load float, float* %899
%901 = load float*, float** %14
%902 = load i32, i32* %30
%903 = load i32, i32* %29
%904 = mul nsw i32 3, %903
%905 = sub nsw i32 %902, %904
%906 = sext i32 %905 to i64
%907 = getelementptr inbounds float, float* %901, i64 %906
%908 = load float, float* %907
%909 = fsub float %900, %908
%910 = call float @llvm.fmuladd.f32(float %892, float %909, float %889)
%911 = fneg float %849
%912 = call float @llvm.fmuladd.f32(float %911, float %910, float %767)
%913 = load float*, float** %15
%914 = load i32, i32* %30
%915 = sext i32 %914 to i64
%916 = getelementptr inbounds float, float* %913, i64 %915
store float %912, float* %916
br label %917
917: ; preds = %66, %59
%918 = load i32, i32* %29
%919 = load i32, i32* %30
%920 = add nsw i32 %919, %918
store i32 %920, i32* %30
br label %921
921: ; preds = %917
%922 = load i32, i32* %31
%923 = add nsw i32 %922, 1
store i32 %923, i32* %31
br label %55
924: ; preds = %55
br label %925
925: ; preds = %924
%926 = load i32, i32* %28
%927 = add nsw i32 %926, 1
store i32 %927, i32* %28
br label %40
928: ; preds = %40
br label %929
929: ; preds = %928
%930 = load i32, i32* %27
%931 = add nsw i32 %930, 1
store i32 %931, i32* %27
br label %35
932: ; preds = %35
ret void
}

LLVM IR (-O2):
define void @kernel_CPU_06_mod_3DRhoVar(float* %0, float* nocapture %1, float* nocapture %2, float* nocapture %3, i32 %4, i32 %5, i32 %6, i32 %7, float %8, float %9, float %10, float* nocapture %11, float* nocapture %12) {
%14 = mul i32 %5, %4
%15 = icmp sgt i32 %4, 0
br i1 %15, label %16, label %338
16: ; preds = %13
%17 = icmp sgt i32 %5, 0
%18 = mul i32 %14, %6
%19 = icmp slt i32 %6, %7
%20 = getelementptr inbounds float, float* %11, i64 6
%21 = getelementptr inbounds float, float* %11, i64 5
%22 = getelementptr inbounds float, float* %11, i64 4
%23 = getelementptr inbounds float, float* %11, i64 3
%24 = getelementptr inbounds float, float* %11, i64 2
%25 = getelementptr inbounds float, float* %11, i64 1
%26 = mul nsw i32 %4, 6
%27 = mul nsw i32 %4, 5
%28 = shl nsw i32 %4, 2
%29 = mul nsw i32 %4, 3
%30 = shl nuw nsw i32 %4, 1
%31 = mul nsw i32 %14, 6
%32 = mul nsw i32 %14, 5
%33 = shl nsw i32 %14, 2
%34 = mul nsw i32 %14, 3
%35 = shl nsw i32 %14, 1
%36 = getelementptr inbounds float, float* %12, i64 1
%37 = getelementptr inbounds float, float* %12, i64 2
%38 = sext i32 %14 to i64
%39 = sext i32 %35 to i64
%40 = sext i32 %34 to i64
%41 = sext i32 %33 to i64
%42 = sext i32 %32 to i64
%43 = sext i32 %31 to i64
%44 = zext i32 %4 to i64
%45 = sext i32 %30 to i64
%46 = sext i32 %29 to i64
%47 = sext i32 %28 to i64
%48 = sext i32 %27 to i64
%49 = sext i32 %26 to i64
br label %50
50: ; preds = %16, %334
%51 = phi i32 [ %18, %16 ], [ %336, %334 ]
%52 = phi i32 [ 0, %16 ], [ %335, %334 ]
br i1 %17, label %53, label %334
53: ; preds = %50, %330
%54 = phi i32 [ %332, %330 ], [ %51, %50 ]
%55 = phi i32 [ %331, %330 ], [ 0, %50 ]
br i1 %19, label %56, label %330
56: ; preds = %53
%57 = sext i32 %54 to i64
br label %58
58: ; preds = %56, %326
%59 = phi i64 [ %57, %56 ], [ %327, %326 ]
%60 = phi i32 [ %6, %56 ], [ %328, %326 ]
%61 = getelementptr inbounds float, float* %2, i64 %59
%62 = load float, float* %61
%63 = fcmp ogt float %62, 0.000000e+00
br i1 %63, label %66, label %64
64: ; preds = %58
%65 = add i64 %59, %38
br label %326
66: ; preds = %58
%67 = getelementptr inbounds float, float* %0, i64 %59
%68 = load float, float* %67
%69 = getelementptr inbounds float, float* %1, i64 %59
%70 = load float, float* %69
%71 = fneg float %70
%72 = tail call float @llvm.fmuladd.f32(float %68, float 2.000000e+00, float %71)
%73 = fmul float %62, %8
%74 = fmul float %62, %73
%75 = load float, float* %20
%76 = add nsw i64 %59, 6
%77 = getelementptr inbounds float, float* %0, i64 %76
%78 = load float, float* %77
%79 = add nsw i64 %59, -6
%80 = getelementptr inbounds float, float* %0, i64 %79
%81 = load float, float* %80
%82 = fadd float %78, %81
%83 = load float, float* %21
%84 = add nsw i64 %59, 5
%85 = getelementptr inbounds float, float* %0, i64 %84
%86 = load float, float* %85
%87 = add nsw i64 %59, -5
%88 = getelementptr inbounds float, float* %0, i64 %87
%89 = load float, float* %88
%90 = fadd float %86, %89
%91 = fmul float %83, %90
%92 = tail call float @llvm.fmuladd.f32(float %75, float %82, float %91)
%93 = load float, float* %22
%94 = add nsw i64 %59, 4
%95 = getelementptr inbounds float, float* %0, i64 %94
%96 = load float, float* %95
%97 = add nsw i64 %59, -4
%98 = getelementptr inbounds float, float* %0, i64 %97
%99 = load float, float* %98
%100 = fadd float %96, %99
%101 = tail call float @llvm.fmuladd.f32(float %93, float %100, float %92)
%102 = load float, float* %23
%103 = add nsw i64 %59, 3
%104 = getelementptr inbounds float, float* %0, i64 %103
%105 = load float, float* %104
%106 = add nsw i64 %59, -3
%107 = getelementptr inbounds float, float* %0, i64 %106
%108 = load float, float* %107
%109 = fadd float %105, %108
%110 = tail call float @llvm.fmuladd.f32(float %102, float %109, float %101)
%111 = load float, float* %24
%112 = add nsw i64 %59, 2
%113 = getelementptr inbounds float, float* %0, i64 %112
%114 = load float, float* %113
%115 = add nsw i64 %59, -2
%116 = getelementptr inbounds float, float* %0, i64 %115
%117 = load float, float* %116
%118 = fadd float %114, %117
%119 = tail call float @llvm.fmuladd.f32(float %111, float %118, float %110)
%120 = load float, float* %25
%121 = add nsw i64 %59, 1
%122 = getelementptr inbounds float, float* %0, i64 %121
%123 = load float, float* %122
%124 = add nsw i64 %59, -1
%125 = getelementptr inbounds float, float* %0, i64 %124
%126 = load float, float* %125
%127 = fadd float %123, %126
%128 = tail call float @llvm.fmuladd.f32(float %120, float %127, float %119)
%129 = load float, float* %11
%130 = tail call float @llvm.fmuladd.f32(float %129, float %68, float %128)
%131 = tail call float @llvm.fmuladd.f32(float %74, float %130, float %72)
%132 = fmul float %62, %9
%133 = fmul float %62, %132
%134 = add nsw i64 %59, %49
%135 = getelementptr inbounds float, float* %0, i64 %134
%136 = load float, float* %135
%137 = sub nsw i64 %59, %49
%138 = getelementptr inbounds float, float* %0, i64 %137
%139 = load float, float* %138
%140 = fadd float %136, %139
%141 = add nsw i64 %59, %48
%142 = getelementptr inbounds float, float* %0, i64 %141
%143 = load float, float* %142
%144 = sub nsw i64 %59, %48
%145 = getelementptr inbounds float, float* %0, i64 %144
%146 = load float, float* %145
%147 = fadd float %143, %146
%148 = fmul float %83, %147
%149 = tail call float @llvm.fmuladd.f32(float %75, float %140, float %148)
%150 = add nsw i64 %59, %47
%151 = getelementptr inbounds float, float* %0, i64 %150
%152 = load float, float* %151
%153 = sub nsw i64 %59, %47
%154 = getelementptr inbounds float, float* %0, i64 %153
%155 = load float, float* %154
%156 = fadd float %152, %155
%157 = tail call float @llvm.fmuladd.f32(float %93, float %156, float %149)
%158 = add nsw i64 %59, %46
%159 = getelementptr inbounds float, float* %0, i64 %158
%160 = load float, float* %159
%161 = sub nsw i64 %59, %46
%162 = getelementptr inbounds float, float* %0, i64 %161
%163 = load float, float* %162
%164 = fadd float %160, %163
%165 = tail call float @llvm.fmuladd.f32(float %102, float %164, float %157)
%166 = add nsw i64 %59, %45
%167 = getelementptr inbounds float, float* %0, i64 %166
%168 = load float, float* %167
%169 = sub nsw i64 %59, %45
%170 = getelementptr inbounds float, float* %0, i64 %169
%171 = load float, float* %170
%172 = fadd float %168, %171
%173 = tail call float @llvm.fmuladd.f32(float %111, float %172, float %165)
%174 = add nsw i64 %59, %44
%175 = getelementptr inbounds float, float* %0, i64 %174
%176 = load float, float* %175
%177 = sub nsw i64 %59, %44
%178 = getelementptr inbounds float, float* %0, i64 %177
%179 = load float, float* %178
%180 = fadd float %176, %179
%181 = tail call float @llvm.fmuladd.f32(float %120, float %180, float %173)
%182 = tail call float @llvm.fmuladd.f32(float %129, float %68, float %181)
%183 = tail call float @llvm.fmuladd.f32(float %133, float %182, float %131)
%184 = fmul float %62, %10
%185 = fmul float %62, %184
%186 = add nsw i64 %59, %43
%187 = getelementptr inbounds float, float* %0, i64 %186
%188 = load float, float* %187
%189 = sub nsw i64 %59, %43
%190 = getelementptr inbounds float, float* %0, i64 %189
%191 = load float, float* %190
%192 = fadd float %188, %191
%193 = add nsw i64 %59, %42
%194 = getelementptr inbounds float, float* %0, i64 %193
%195 = load float, float* %194
%196 = sub nsw i64 %59, %42
%197 = getelementptr inbounds float, float* %0, i64 %196
%198 = load float, float* %197
%199 = fadd float %195, %198
%200 = fmul float %83, %199
%201 = tail call float @llvm.fmuladd.f32(float %75, float %192, float %200)
%202 = add nsw i64 %59, %41
%203 = getelementptr inbounds float, float* %0, i64 %202
%204 = load float, float* %203
%205 = sub nsw i64 %59, %41
%206 = getelementptr inbounds float, float* %0, i64 %205
%207 = load float, float* %206
%208 = fadd float %204, %207
%209 = tail call float @llvm.fmuladd.f32(float %93, float %208, float %201)
%210 = add nsw i64 %59, %40
%211 = getelementptr inbounds float, float* %0, i64 %210
%212 = load float, float* %211
%213 = sub nsw i64 %59, %40
%214 = getelementptr inbounds float, float* %0, i64 %213
%215 = load float, float* %214
%216 = fadd float %212, %215
%217 = tail call float @llvm.fmuladd.f32(float %102, float %216, float %209)
%218 = add nsw i64 %59, %39
%219 = getelementptr inbounds float, float* %0, i64 %218
%220 = load float, float* %219
%221 = sub nsw i64 %59, %39
%222 = getelementptr inbounds float, float* %0, i64 %221
%223 = load float, float* %222
%224 = fadd float %220, %223
%225 = tail call float @llvm.fmuladd.f32(float %111, float %224, float %217)
%226 = add i64 %59, %38
%227 = getelementptr inbounds float, float* %0, i64 %226
%228 = load float, float* %227
%229 = sub nsw i64 %59, %38
%230 = getelementptr inbounds float, float* %0, i64 %229
%231 = load float, float* %230
%232 = fadd float %228, %231
%233 = tail call float @llvm.fmuladd.f32(float %120, float %232, float %225)
%234 = tail call float @llvm.fmuladd.f32(float %129, float %68, float %233)
%235 = tail call float @llvm.fmuladd.f32(float %185, float %234, float %183)
%236 = getelementptr inbounds float, float* %3, i64 %59
%237 = load float, float* %236
%238 = fdiv float 1.000000e+00, %237
%239 = load float, float* %12
%240 = getelementptr inbounds float, float* %3, i64 %121
%241 = load float, float* %240
%242 = getelementptr inbounds float, float* %3, i64 %124
%243 = load float, float* %242
%244 = fsub float %241, %243
%245 = load float, float* %36
%246 = getelementptr inbounds float, float* %3, i64 %112
%247 = load float, float* %246
%248 = getelementptr inbounds float, float* %3, i64 %115
%249 = load float, float* %248
%250 = fsub float %247, %249
%251 = fmul float %245, %250
%252 = tail call float @llvm.fmuladd.f32(float %239, float %244, float %251)
%253 = load float, float* %37
%254 = getelementptr inbounds float, float* %3, i64 %103
%255 = load float, float* %254
%256 = getelementptr inbounds float, float* %3, i64 %106
%257 = load float, float* %256
%258 = fsub float %255, %257
%259 = tail call float @llvm.fmuladd.f32(float %253, float %258, float %252)
%260 = fsub float %123, %126
%261 = fsub float %114, %117
%262 = fmul float %261, %245
%263 = tail call float @llvm.fmuladd.f32(float %239, float %260, float %262)
%264 = fsub float %105, %108
%265 = tail call float @llvm.fmuladd.f32(float %253, float %264, float %263)
%266 = fneg float %74
%267 = fmul float %238, %266
%268 = fmul float %267, %259
%269 = tail call float @llvm.fmuladd.f32(float %268, float %265, float %235)
%270 = getelementptr inbounds float, float* %3, i64 %174
%271 = load float, float* %270
%272 = getelementptr inbounds float, float* %3, i64 %177
%273 = load float, float* %272
%274 = fsub float %271, %273
%275 = getelementptr inbounds float, float* %3, i64 %166
%276 = load float, float* %275
%277 = getelementptr inbounds float, float* %3, i64 %169
%278 = load float, float* %277
%279 = fsub float %276, %278
%280 = fmul float %245, %279
%281 = tail call float @llvm.fmuladd.f32(float %239, float %274, float %280)
%282 = getelementptr inbounds float, float* %3, i64 %158
%283 = load float, float* %282
%284 = getelementptr inbounds float, float* %3, i64 %161
%285 = load float, float* %284
%286 = fsub float %283, %285
%287 = tail call float @llvm.fmuladd.f32(float %253, float %286, float %281)
%288 = fsub float %176, %179
%289 = fsub float %168, %171
%290 = fmul float %289, %245
%291 = tail call float @llvm.fmuladd.f32(float %239, float %288, float %290)
%292 = fsub float %160, %163
%293 = tail call float @llvm.fmuladd.f32(float %253, float %292, float %291)
%294 = fneg float %133
%295 = fmul float %238, %294
%296 = fmul float %295, %287
%297 = tail call float @llvm.fmuladd.f32(float %296, float %293, float %269)
%298 = getelementptr inbounds float, float* %3, i64 %226
%299 = load float, float* %298
%300 = getelementptr inbounds float, float* %3, i64 %229
%301 = load float, float* %300
%302 = fsub float %299, %301
%303 = getelementptr inbounds float, float* %3, i64 %218
%304 = load float, float* %303
%305 = getelementptr inbounds float, float* %3, i64 %221
%306 = load float, float* %305
%307 = fsub float %304, %306
%308 = fmul float %245, %307
%309 = tail call float @llvm.fmuladd.f32(float %239, float %302, float %308)
%310 = getelementptr inbounds float, float* %3, i64 %210
%311 = load float, float* %310
%312 = getelementptr inbounds float, float* %3, i64 %213
%313 = load float, float* %312
%314 = fsub float %311, %313
%315 = tail call float @llvm.fmuladd.f32(float %253, float %314, float %309)
%316 = fsub float %228, %231
%317 = fsub float %220, %223
%318 = fmul float %317, %245
%319 = tail call float @llvm.fmuladd.f32(float %239, float %316, float %318)
%320 = fsub float %212, %215
%321 = tail call float @llvm.fmuladd.f32(float %253, float %320, float %319)
%322 = fneg float %185
%323 = fmul float %238, %322
%324 = fmul float %323, %315
%325 = tail call float @llvm.fmuladd.f32(float %324, float %321, float %297)
store float %325, float* %69
br label %326
326: ; preds = %64, %66
%327 = phi i64 [ %65, %64 ], [ %226, %66 ]
%328 = add nsw i32 %60, 1
%329 = icmp eq i32 %328, %7
br i1 %329, label %330, label %58
330: ; preds = %326, %53
%331 = add nuw nsw i32 %55, 1
%332 = add i32 %54, %4
%333 = icmp eq i32 %331, %5
br i1 %333, label %334, label %53
334: ; preds = %330, %50
%335 = add nuw nsw i32 %52, 1
%336 = add i32 %51, 1
%337 = icmp eq i32 %335, %4
br i1 %337, label %338, label %50
338: ; preds = %334, %13
ret void
}