void acd_2d_4_d_d(float **uc, float **ucd0, float **ucd, float **ucdd,
                  float **up, float **upd0, float **upd, float **updd,
                  float **csq, float **csqd0, float **csqd, int *s, int *e,
                  float c0, float *c1, float *c2, int *lbc, int *rbc) {
  int i0, i1;
  for (i1 = s[1]; i1 < e[1] + 1; ++i1)
    for (i0 = s[0]; i0 < e[0] + 1; ++i0) {
      float lap = c0 * uc[i1][i0] + c1[0] * (uc[i1][i0 + 1] + uc[i1][i0 - 1]) +
                  c1[1] * (uc[i1 + 1][i0] + uc[i1 - 1][i0]) +
                  c2[0] * (uc[i1][i0 + 2] + uc[i1][i0 - 2]) +
                  c2[1] * (uc[i1 + 2][i0] + uc[i1 - 2][i0]);
      float lapd0 = c0 * ucd0[i1][i0] +
                    c1[0] * (ucd0[i1][i0 + 1] + ucd0[i1][i0 - 1]) +
                    c1[1] * (ucd0[i1 + 1][i0] + ucd0[i1 - 1][i0]) +
                    c2[0] * (ucd0[i1][i0 + 2] + ucd0[i1][i0 - 2]) +
                    c2[1] * (ucd0[i1 + 2][i0] + ucd0[i1 - 2][i0]);
      float lapd = c0 * ucd[i1][i0] +
                   c1[0] * (ucd[i1][i0 + 1] + ucd[i1][i0 - 1]) +
                   c1[1] * (ucd[i1 + 1][i0] + ucd[i1 - 1][i0]) +
                   c2[0] * (ucd[i1][i0 + 2] + ucd[i1][i0 - 2]) +
                   c2[1] * (ucd[i1 + 2][i0] + ucd[i1 - 2][i0]);
      float lapdd = c0 * ucdd[i1][i0] +
                    c1[0] * (ucdd[i1][i0 + 1] + ucdd[i1][i0 - 1]) +
                    c1[1] * (ucdd[i1 + 1][i0] + ucdd[i1 - 1][i0]) +
                    c2[0] * (ucdd[i1][i0 + 2] + ucdd[i1][i0 - 2]) +
                    c2[1] * (ucdd[i1 + 2][i0] + ucdd[i1 - 2][i0]);
      updd[i1][i0] = 2.0 * ucdd[i1][i0] - updd[i1][i0] + csqd[i1][i0] * lapd0 +
                     csqd0[i1][i0] * lapd + csq[i1][i0] * lapdd;
      upd[i1][i0] = 2.0 * ucd[i1][i0] - upd[i1][i0] + csqd[i1][i0] * lap +
                    csq[i1][i0] * lapd;
      upd0[i1][i0] = 2.0 * ucd0[i1][i0] - upd0[i1][i0] + csqd0[i1][i0] * lap +
                     csq[i1][i0] * lapd0;
      up[i1][i0] = 2.0 * uc[i1][i0] - up[i1][i0] + csq[i1][i0] * lap;
    }
  if (lbc[1])
    for (i0 = s[0]; i0 < e[0] + 1; ++i0) {
      updd[s[1] - 2][i0] = -updd[s[1]][i0];
      upd[s[1] - 2][i0] = -upd[s[1]][i0];
      upd0[s[1] - 2][i0] = -upd0[s[1]][i0];
      up[s[1] - 2][i0] = -up[s[1]][i0];
    }
  if (rbc[1])
    for (i0 = s[0]; i0 < e[0] + 1; ++i0) {
      updd[e[1] + 2][i0] = -updd[e[1]][i0];
      upd[e[1] + 2][i0] = -upd[e[1]][i0];
      upd0[e[1] + 2][i0] = -upd0[e[1]][i0];
      up[e[1] + 2][i0] = -up[e[1]][i0];
    }
  if (lbc[0])
    for (i1 = s[1]; i1 < e[1] + 1; ++i1) {
      updd[i1][s[0] - 2] = -updd[i1][s[0]];
      upd[i1][s[0] - 2] = -upd[i1][s[0]];
      upd0[i1][s[0] - 2] = -upd0[i1][s[0]];
      up[i1][s[0] - 2] = -up[i1][s[0]];
    }
  if (rbc[0])
    for (i1 = s[1]; i1 < e[1] + 1; ++i1) {
      updd[i1][e[0] + 2] = -updd[i1][e[0]];
      upd[i1][e[0] + 2] = -upd[i1][e[0]];
      upd0[i1][e[0] + 2] = -upd0[i1][e[0]];
      up[i1][e[0] + 2] = -up[i1][e[0]];
    }
}


x86 assembly (clang, -O0):
<acd_2d_4_d_d>:
push   %rbp
mov    %rsp,%rbp
mov    0x60(%rbp),%rax
mov    0x58(%rbp),%rax
mov    0x50(%rbp),%rax
mov    0x48(%rbp),%rax
mov    0x40(%rbp),%rax
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
movss  %xmm0,-0x34(%rbp)
mov    0x38(%rbp),%rax
mov    0x4(%rax),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    0x40(%rbp),%rcx
mov    0x4(%rcx),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1936 <acd_2d_4_d_d+0x836>
mov    0x38(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    0x40(%rbp),%rcx
mov    (%rcx),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1923 <acd_2d_4_d_d+0x823>
movss  -0x34(%rbp),%xmm1
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    0x48(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm3
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm3
mulss  %xmm3,%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    0x48(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    0x50(%rbp),%rax
movss  (%rax),%xmm1
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    0x50(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x34(%rbp),%xmm1
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    0x48(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm3
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm3
mulss  %xmm3,%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    0x48(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    0x50(%rbp),%rax
movss  (%rax),%xmm1
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    0x50(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x34(%rbp),%xmm1
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    0x48(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm3
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm3
mulss  %xmm3,%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    0x48(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    0x50(%rbp),%rax
movss  (%rax),%xmm1
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    0x50(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x34(%rbp),%xmm1
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    0x48(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm3
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm3
mulss  %xmm3,%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    0x48(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    0x50(%rbp),%rax
movss  (%rax),%xmm1
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    0x50(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
addsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
mov    0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  -0x44(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm1,%xmm0
mov    0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  -0x48(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm1,%xmm0
mov    0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  -0x4c(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
addsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
mov    0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  -0x40(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm1,%xmm0
mov    0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  -0x48(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
addsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
mov    0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  -0x40(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm1,%xmm0
mov    0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  -0x44(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
addsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
mov    0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  -0x40(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1175 <acd_2d_4_d_d+0x75>
jmp    1928 <acd_2d_4_d_d+0x828>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1157 <acd_2d_4_d_d+0x57>
mov    0x58(%rbp),%rax
cmpl   $0x0,0x4(%rax)
je     1a84 <acd_2d_4_d_d+0x984>
mov    0x38(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    0x40(%rbp),%rcx
mov    (%rcx),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1a7f <acd_2d_4_d_d+0x97f>
mov    0x18(%rbp),%rax
mov    0x38(%rbp),%rcx
movslq 0x4(%rcx),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    0x18(%rbp),%rax
mov    0x38(%rbp),%rcx
mov    0x4(%rcx),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x10(%rbp),%rax
mov    0x38(%rbp),%rcx
movslq 0x4(%rcx),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    0x10(%rbp),%rax
mov    0x38(%rbp),%rcx
mov    0x4(%rcx),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%rax
mov    0x38(%rbp),%rcx
movslq 0x4(%rcx),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x30(%rbp),%rax
mov    0x38(%rbp),%rcx
mov    0x4(%rcx),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%rax
mov    0x38(%rbp),%rcx
movslq 0x4(%rcx),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x28(%rbp),%rax
mov    0x38(%rbp),%rcx
mov    0x4(%rcx),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    194d <acd_2d_4_d_d+0x84d>
jmp    1a84 <acd_2d_4_d_d+0x984>
mov    0x60(%rbp),%rax
cmpl   $0x0,0x4(%rax)
je     1bd2 <acd_2d_4_d_d+0xad2>
mov    0x38(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    0x40(%rbp),%rcx
mov    (%rcx),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1bcd <acd_2d_4_d_d+0xacd>
mov    0x18(%rbp),%rax
mov    0x40(%rbp),%rcx
movslq 0x4(%rcx),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    0x18(%rbp),%rax
mov    0x40(%rbp),%rcx
mov    0x4(%rcx),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x10(%rbp),%rax
mov    0x40(%rbp),%rcx
movslq 0x4(%rcx),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    0x10(%rbp),%rax
mov    0x40(%rbp),%rcx
mov    0x4(%rcx),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%rax
mov    0x40(%rbp),%rcx
movslq 0x4(%rcx),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x30(%rbp),%rax
mov    0x40(%rbp),%rcx
mov    0x4(%rcx),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%rax
mov    0x40(%rbp),%rcx
movslq 0x4(%rcx),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x28(%rbp),%rax
mov    0x40(%rbp),%rcx
mov    0x4(%rcx),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1a9b <acd_2d_4_d_d+0x99b>
jmp    1bd2 <acd_2d_4_d_d+0xad2>
mov    0x58(%rbp),%rax
cmpl   $0x0,(%rax)
je     1d19 <acd_2d_4_d_d+0xc19>
mov    0x38(%rbp),%rax
mov    0x4(%rax),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    0x40(%rbp),%rcx
mov    0x4(%rcx),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1d14 <acd_2d_4_d_d+0xc14>
mov    0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x38(%rbp),%rcx
movslq (%rcx),%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x38(%rbp),%rcx
mov    (%rcx),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x38(%rbp),%rcx
movslq (%rcx),%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x38(%rbp),%rcx
mov    (%rcx),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x38(%rbp),%rcx
movslq (%rcx),%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x38(%rbp),%rcx
mov    (%rcx),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x38(%rbp),%rcx
movslq (%rcx),%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x38(%rbp),%rcx
mov    (%rcx),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1be9 <acd_2d_4_d_d+0xae9>
jmp    1d19 <acd_2d_4_d_d+0xc19>
mov    0x60(%rbp),%rax
cmpl   $0x0,(%rax)
je     1e60 <acd_2d_4_d_d+0xd60>
mov    0x38(%rbp),%rax
mov    0x4(%rax),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    0x40(%rbp),%rcx
mov    0x4(%rcx),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1e5b <acd_2d_4_d_d+0xd5b>
mov    0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x40(%rbp),%rcx
movslq (%rcx),%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x40(%rbp),%rcx
mov    (%rcx),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x40(%rbp),%rcx
movslq (%rcx),%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x40(%rbp),%rcx
mov    (%rcx),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x40(%rbp),%rcx
movslq (%rcx),%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x40(%rbp),%rcx
mov    (%rcx),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x40(%rbp),%rcx
movslq (%rcx),%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x40(%rbp),%rcx
mov    (%rcx),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1d30 <acd_2d_4_d_d+0xc30>
jmp    1e60 <acd_2d_4_d_d+0xd60>
pop    %rbp
ret

x86 assembly (clang, -O2):
<acd_2d_4_d_d>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x60,%rsp
mov    %r9,-0x78(%rsp)
mov    %r8,-0x70(%rsp)
mov    %rcx,-0x38(%rsp)
mov    %rdx,-0x40(%rsp)
mov    %rsi,-0x48(%rsp)
mov    %rdi,-0x50(%rsp)
mov    0xc8(%rsp),%rcx
mov    0xc0(%rsp),%rax
movslq 0x4(%rax),%rax
movslq 0x4(%rcx),%r15
mov    %rax,-0x80(%rsp)
cmp    %r15d,%eax
jg     1680 <acd_2d_4_d_d+0x580>
mov    0xd8(%rsp),%rcx
mov    0xc0(%rsp),%rax
movslq (%rax),%rdx
mov    0xc8(%rsp),%rax
mov    (%rax),%eax
lea    0x1(%r15),%esi
mov    %eax,%edi
sub    %edx,%edi
add    $0x1,%edi
mov    -0x80(%rsp),%rbx
mov    %r15,-0x58(%rsp)
mov    %rdx,-0x60(%rsp)
mov    %eax,-0x64(%rsp)
mov    %esi,-0x68(%rsp)
mov    %rdi,-0x28(%rsp)
jmp    11af <acd_2d_4_d_d+0xaf>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rbx
mov    %rbx,%rbp
cmp    %ebp,%esi
je     1680 <acd_2d_4_d_d+0x580>
cmp    %eax,%edx
jg     11a0 <acd_2d_4_d_d+0xa0>
lea    0x0(,%rdx,4),%r15
mov    -0x50(%rsp),%rdi
mov    (%rdi,%rbx,8),%r10
add    %r15,%r10
mov    -0x48(%rsp),%rsi
mov    (%rsi,%rbx,8),%r8
add    %r15,%r8
mov    -0x40(%rsp),%rdx
mov    (%rdx,%rbx,8),%r9
add    %r15,%r9
mov    %rcx,%r11
mov    -0x38(%rsp),%rcx
mov    (%rcx,%rbx,8),%rax
add    %r15,%rax
mov    0x8(%rdi,%rbx,8),%rbp
add    %r15,%rbp
mov    %rbp,0x58(%rsp)
mov    -0x8(%rdi,%rbx,8),%rbp
add    %r15,%rbp
mov    %rbp,0x50(%rsp)
mov    0x10(%rdi,%rbx,8),%rbp
add    %r15,%rbp
mov    %rbp,0x48(%rsp)
mov    -0x10(%rdi,%rbx,8),%rdi
add    %r15,%rdi
mov    %rdi,0x40(%rsp)
mov    0x8(%rsi,%rbx,8),%rdi
add    %r15,%rdi
mov    %rdi,0x38(%rsp)
mov    -0x8(%rsi,%rbx,8),%rdi
add    %r15,%rdi
mov    %rdi,0x30(%rsp)
mov    0x10(%rsi,%rbx,8),%rdi
add    %r15,%rdi
mov    %rdi,0x28(%rsp)
mov    -0x10(%rsi,%rbx,8),%rsi
add    %r15,%rsi
mov    %rsi,0x20(%rsp)
mov    0x8(%rdx,%rbx,8),%rsi
add    %r15,%rsi
mov    %rsi,0x18(%rsp)
mov    -0x8(%rdx,%rbx,8),%rsi
add    %r15,%rsi
mov    %rsi,0x10(%rsp)
mov    0x10(%rdx,%rbx,8),%rsi
add    %r15,%rsi
mov    %rsi,0x8(%rsp)
mov    -0x10(%rdx,%rbx,8),%rdx
add    %r15,%rdx
mov    %rdx,(%rsp)
mov    0x8(%rcx,%rbx,8),%rdx
add    %r15,%rdx
mov    %rdx,-0x8(%rsp)
mov    -0x8(%rcx,%rbx,8),%rdx
add    %r15,%rdx
mov    %rdx,-0x10(%rsp)
mov    0x10(%rcx,%rbx,8),%rdx
add    %r15,%rdx
mov    %rdx,-0x18(%rsp)
mov    -0x10(%rcx,%rbx,8),%rcx
add    %r15,%rcx
mov    %rcx,-0x20(%rsp)
mov    0xa0(%rsp),%rcx
mov    (%rcx,%rbx,8),%rsi
add    %r15,%rsi
mov    0xb8(%rsp),%rcx
mov    (%rcx,%rbx,8),%rdi
add    %r15,%rdi
mov    0xb0(%rsp),%rcx
mov    (%rcx,%rbx,8),%rbp
add    %r15,%rbp
mov    0xa8(%rsp),%rcx
mov    (%rcx,%rbx,8),%r14
add    %r15,%r14
mov    0x98(%rsp),%rcx
mov    (%rcx,%rbx,8),%r12
add    %r15,%r12
mov    -0x78(%rsp),%rcx
mov    (%rcx,%rbx,8),%r13
add    %r15,%r13
mov    -0x70(%rsp),%rcx
add    (%rcx,%rbx,8),%r15
mov    %r11,%rcx
lea    0x1(%rbx),%rdx
mov    %rdx,-0x30(%rsp)
xor    %r11d,%r11d
mov    0xd0(%rsp),%rbx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  0x4(%r10,%r11,4),%xmm1
movss  0x8(%r10,%r11,4),%xmm2
addss  -0x4(%r10,%r11,4),%xmm1
movss  (%rbx),%xmm10
movss  0x4(%rbx),%xmm8
mulss  %xmm10,%xmm1
movss  (%r10,%r11,4),%xmm3
mulss  %xmm0,%xmm3
addss  %xmm1,%xmm3
mov    0x58(%rsp),%rdx
movss  (%rdx,%r11,4),%xmm1
mov    0x50(%rsp),%rdx
addss  (%rdx,%r11,4),%xmm1
mulss  %xmm8,%xmm1
addss  %xmm3,%xmm1
addss  -0x8(%r10,%r11,4),%xmm2
movss  (%rcx),%xmm11
movss  0x4(%rcx),%xmm9
mulss  %xmm11,%xmm2
addss  %xmm1,%xmm2
mov    0x48(%rsp),%rdx
movss  (%rdx,%r11,4),%xmm1
mov    0x40(%rsp),%rdx
addss  (%rdx,%r11,4),%xmm1
movss  0x4(%r8,%r11,4),%xmm3
movss  0x8(%r8,%r11,4),%xmm4
addss  -0x4(%r8,%r11,4),%xmm3
mulss  %xmm10,%xmm3
movss  (%r8,%r11,4),%xmm5
mulss  %xmm0,%xmm5
mov    0x38(%rsp),%rdx
movss  (%rdx,%r11,4),%xmm6
mov    0x30(%rsp),%rdx
addss  (%rdx,%r11,4),%xmm6
addss  %xmm3,%xmm5
mulss  %xmm8,%xmm6
addss  -0x8(%r8,%r11,4),%xmm4
addss  %xmm5,%xmm6
mulss  %xmm11,%xmm4
addss  %xmm6,%xmm4
mov    0x28(%rsp),%rdx
movss  (%rdx,%r11,4),%xmm3
mov    0x20(%rsp),%rdx
addss  (%rdx,%r11,4),%xmm3
mulss  %xmm9,%xmm3
addss  %xmm4,%xmm3
movss  0x4(%r9,%r11,4),%xmm4
movss  0x8(%r9,%r11,4),%xmm5
addss  -0x4(%r9,%r11,4),%xmm4
mulss  %xmm10,%xmm4
movss  (%r9,%r11,4),%xmm6
mulss  %xmm0,%xmm6
addss  %xmm4,%xmm6
mov    0x18(%rsp),%rdx
movss  (%rdx,%r11,4),%xmm4
mov    0x10(%rsp),%rdx
addss  (%rdx,%r11,4),%xmm4
mulss  %xmm8,%xmm4
addss  %xmm6,%xmm4
addss  -0x8(%r9,%r11,4),%xmm5
mulss  %xmm11,%xmm5
addss  %xmm4,%xmm5
mov    0x8(%rsp),%rdx
movss  (%rdx,%r11,4),%xmm4
mov    (%rsp),%rdx
addss  (%rdx,%r11,4),%xmm4
mulss  %xmm9,%xmm4
addss  %xmm5,%xmm4
movss  (%rax,%r11,4),%xmm5
movss  0x4(%rax,%r11,4),%xmm6
addss  -0x4(%rax,%r11,4),%xmm6
mulss  %xmm10,%xmm6
movaps %xmm0,%xmm7
mulss  %xmm5,%xmm7
addss  %xmm6,%xmm7
mov    -0x8(%rsp),%rdx
movss  (%rdx,%r11,4),%xmm6
mov    -0x10(%rsp),%rdx
addss  (%rdx,%r11,4),%xmm6
mulss  %xmm8,%xmm6
mulss  %xmm9,%xmm1
addss  %xmm7,%xmm6
movss  0x8(%rax,%r11,4),%xmm7
addss  -0x8(%rax,%r11,4),%xmm7
mulss  %xmm11,%xmm7
addss  %xmm6,%xmm7
mov    -0x18(%rsp),%rdx
movss  (%rdx,%r11,4),%xmm6
mov    -0x20(%rsp),%rdx
addss  (%rdx,%r11,4),%xmm6
mulss  %xmm9,%xmm6
addss  %xmm7,%xmm6
cvtss2sd %xmm5,%xmm5
movss  (%rsi,%r11,4),%xmm7
cvtss2sd %xmm7,%xmm7
addsd  %xmm5,%xmm5
subsd  %xmm7,%xmm5
movss  (%rdi,%r11,4),%xmm7
mulss  %xmm3,%xmm7
cvtss2sd %xmm7,%xmm7
addsd  %xmm5,%xmm7
movss  0x0(%rbp,%r11,4),%xmm5
mulss  %xmm4,%xmm5
cvtss2sd %xmm5,%xmm5
addsd  %xmm7,%xmm5
mulss  (%r14,%r11,4),%xmm6
cvtss2sd %xmm6,%xmm6
addsd  %xmm5,%xmm6
xorps  %xmm5,%xmm5
cvtsd2ss %xmm6,%xmm5
addss  %xmm2,%xmm1
movss  %xmm5,(%rsi,%r11,4)
movss  (%r9,%r11,4),%xmm2
cvtss2sd %xmm2,%xmm2
movss  (%r12,%r11,4),%xmm5
cvtss2sd %xmm5,%xmm5
addsd  %xmm2,%xmm2
subsd  %xmm5,%xmm2
movss  (%rdi,%r11,4),%xmm5
mulss  %xmm1,%xmm5
cvtss2sd %xmm5,%xmm5
addsd  %xmm2,%xmm5
mulss  (%r14,%r11,4),%xmm4
xorps  %xmm2,%xmm2
cvtss2sd %xmm4,%xmm2
addsd  %xmm5,%xmm2
cvtsd2ss %xmm2,%xmm2
movss  %xmm2,(%r12,%r11,4)
movss  (%r8,%r11,4),%xmm2
cvtss2sd %xmm2,%xmm2
movss  0x0(%r13,%r11,4),%xmm4
cvtss2sd %xmm4,%xmm4
addsd  %xmm2,%xmm2
subsd  %xmm4,%xmm2
movss  0x0(%rbp,%r11,4),%xmm4
mulss  %xmm1,%xmm4
cvtss2sd %xmm4,%xmm4
addsd  %xmm2,%xmm4
mulss  (%r14,%r11,4),%xmm3
xorps  %xmm2,%xmm2
cvtss2sd %xmm3,%xmm2
addsd  %xmm4,%xmm2
cvtsd2ss %xmm2,%xmm2
movss  %xmm2,0x0(%r13,%r11,4)
movss  (%r10,%r11,4),%xmm2
cvtss2sd %xmm2,%xmm2
movss  (%r15,%r11,4),%xmm3
cvtss2sd %xmm3,%xmm3
addsd  %xmm2,%xmm2
subsd  %xmm3,%xmm2
mulss  (%r14,%r11,4),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm2,%xmm1
cvtsd2ss %xmm1,%xmm1
movss  %xmm1,(%r15,%r11,4)
add    $0x1,%r11
cmp    %r11d,-0x28(%rsp)
jne    1340 <acd_2d_4_d_d+0x240>
mov    -0x30(%rsp),%rbp
mov    %rbp,%rbx
mov    -0x58(%rsp),%r15
mov    -0x60(%rsp),%rdx
mov    -0x64(%rsp),%eax
mov    -0x68(%rsp),%esi
cmp    %ebp,%esi
jne    11af <acd_2d_4_d_d+0xaf>
mov    0xe8(%rsp),%r8
mov    0xe0(%rsp),%rax
cmpl   $0x0,0x4(%rax)
je     1770 <acd_2d_4_d_d+0x670>
mov    0xc0(%rsp),%rax
movslq (%rax),%r11
mov    0xc8(%rsp),%rax
mov    (%rax),%r14d
cmp    %r14d,%r11d
jg     1770 <acd_2d_4_d_d+0x670>
mov    %r11,%rdx
shl    $0x2,%rdx
mov    -0x80(%rsp),%rcx
mov    0xa0(%rsp),%rax
mov    (%rax,%rcx,8),%r9
add    %rdx,%r9
mov    -0x10(%rax,%rcx,8),%r10
add    %rdx,%r10
mov    0x98(%rsp),%rax
mov    (%rax,%rcx,8),%rbp
add    %rdx,%rbp
mov    -0x10(%rax,%rcx,8),%rbx
add    %rdx,%rbx
mov    -0x78(%rsp),%rsi
mov    (%rsi,%rcx,8),%rax
add    %rdx,%rax
mov    -0x10(%rsi,%rcx,8),%rsi
add    %rdx,%rsi
mov    -0x70(%rsp),%r12
mov    (%r12,%rcx,8),%rdi
add    %rdx,%rdi
add    -0x10(%r12,%rcx,8),%rdx
sub    %r11d,%r14d
add    $0x1,%r14d
xor    %ecx,%ecx
movaps 0x8d8(%rip),%xmm0
nopl   0x0(%rax,%rax,1)
movss  (%r9,%rcx,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,(%r10,%rcx,4)
movss  0x0(%rbp,%rcx,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,(%rbx,%rcx,4)
movss  (%rax,%rcx,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,(%rsi,%rcx,4)
movss  (%rdi,%rcx,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,(%rdx,%rcx,4)
add    $0x1,%rcx
cmp    %ecx,%r14d
jne    1730 <acd_2d_4_d_d+0x630>
cmpl   $0x0,0x4(%r8)
je     1850 <acd_2d_4_d_d+0x750>
mov    0xc0(%rsp),%rax
movslq (%rax),%r11
mov    0xc8(%rsp),%rax
mov    (%rax),%r14d
cmp    %r14d,%r11d
jg     1850 <acd_2d_4_d_d+0x750>
mov    %r11,%rdx
shl    $0x2,%rdx
mov    0xa0(%rsp),%rax
mov    (%rax,%r15,8),%r9
add    %rdx,%r9
mov    0x10(%rax,%r15,8),%r10
add    %rdx,%r10
mov    0x98(%rsp),%rax
mov    (%rax,%r15,8),%rbp
add    %rdx,%rbp
mov    0x10(%rax,%r15,8),%rbx
add    %rdx,%rbx
mov    -0x78(%rsp),%rcx
mov    (%rcx,%r15,8),%rax
add    %rdx,%rax
mov    0x10(%rcx,%r15,8),%rsi
add    %rdx,%rsi
mov    -0x70(%rsp),%rcx
mov    (%rcx,%r15,8),%rdi
add    %rdx,%rdi
add    0x10(%rcx,%r15,8),%rdx
sub    %r11d,%r14d
add    $0x1,%r14d
xor    %ecx,%ecx
movaps 0x7fc(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  (%r9,%rcx,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,(%r10,%rcx,4)
movss  0x0(%rbp,%rcx,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,(%rbx,%rcx,4)
movss  (%rax,%rcx,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,(%rsi,%rcx,4)
movss  (%rdi,%rcx,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,(%rdx,%rcx,4)
add    $0x1,%rcx
cmp    %ecx,%r14d
jne    1810 <acd_2d_4_d_d+0x710>
mov    0xe0(%rsp),%rax
cmpl   $0x0,(%rax)
je     1910 <acd_2d_4_d_d+0x810>
cmp    %r15d,-0x80(%rsp)
jg     1910 <acd_2d_4_d_d+0x810>
mov    0xc0(%rsp),%rax
movslq (%rax),%rax
mov    -0x80(%rsp),%rbx
mov    0xa0(%rsp),%rcx
lea    (%rcx,%rbx,8),%r9
mov    0x98(%rsp),%rcx
lea    (%rcx,%rbx,8),%rdx
mov    -0x78(%rsp),%rcx
lea    (%rcx,%rbx,8),%rsi
mov    -0x70(%rsp),%rcx
lea    (%rcx,%rbx,8),%rdi
mov    %r15d,%ebp
sub    %ebx,%ebp
add    $0x1,%ebp
xor    %ebx,%ebx
movaps 0x749(%rip),%xmm0
nopw   0x0(%rax,%rax,1)
mov    (%r9,%rbx,8),%rcx
movss  (%rcx,%rax,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,-0x8(%rcx,%rax,4)
mov    (%rdx,%rbx,8),%rcx
movss  (%rcx,%rax,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,-0x8(%rcx,%rax,4)
mov    (%rsi,%rbx,8),%rcx
movss  (%rcx,%rax,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,-0x8(%rcx,%rax,4)
mov    (%rdi,%rbx,8),%rcx
movss  (%rcx,%rax,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,-0x8(%rcx,%rax,4)
add    $0x1,%rbx
cmp    %ebx,%ebp
jne    18c0 <acd_2d_4_d_d+0x7c0>
cmpl   $0x0,(%r8)
je     19c1 <acd_2d_4_d_d+0x8c1>
cmp    %r15d,-0x80(%rsp)
jg     19c1 <acd_2d_4_d_d+0x8c1>
mov    0xc8(%rsp),%rax
movslq (%rax),%rax
mov    -0x80(%rsp),%rbp
mov    0xa0(%rsp),%rcx
lea    (%rcx,%rbp,8),%rcx
mov    0x98(%rsp),%rdx
lea    (%rdx,%rbp,8),%rdx
mov    -0x78(%rsp),%rsi
lea    (%rsi,%rbp,8),%rsi
mov    -0x70(%rsp),%rdi
lea    (%rdi,%rbp,8),%rdi
sub    %ebp,%r15d
add    $0x1,%r15d
xor    %ebp,%ebp
movaps 0x691(%rip),%xmm0
nop
mov    (%rcx,%rbp,8),%rbx
movss  (%rbx,%rax,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,0x8(%rbx,%rax,4)
mov    (%rdx,%rbp,8),%rbx
movss  (%rbx,%rax,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,0x8(%rbx,%rax,4)
mov    (%rsi,%rbp,8),%rbx
movss  (%rbx,%rax,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,0x8(%rbx,%rax,4)
mov    (%rdi,%rbp,8),%rbx
movss  (%rbx,%rax,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,0x8(%rbx,%rax,4)
add    $0x1,%rbp
cmp    %ebp,%r15d
jne    1970 <acd_2d_4_d_d+0x870>
add    $0x60,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @acd_2d_4_d_d(float** %0, float** %1, float** %2, float** %3, float** %4, float** %5, float** %6, float** %7, float** %8, float** %9, float** %10, i32* %11, i32* %12, float %13, float* %14, float* %15, i32* %16, i32* %17) {
%19 = alloca float**
%20 = alloca float**
%21 = alloca float**
%22 = alloca float**
%23 = alloca float**
%24 = alloca float**
%25 = alloca float**
%26 = alloca float**
%27 = alloca float**
%28 = alloca float**
%29 = alloca float**
%30 = alloca i32*
%31 = alloca i32*
%32 = alloca float
%33 = alloca float*
%34 = alloca float*
%35 = alloca i32*
%36 = alloca i32*
%37 = alloca i32
%38 = alloca i32
%39 = alloca float
%40 = alloca float
%41 = alloca float
%42 = alloca float
store float** %0, float*** %19
store float** %1, float*** %20
store float** %2, float*** %21
store float** %3, float*** %22
store float** %4, float*** %23
store float** %5, float*** %24
store float** %6, float*** %25
store float** %7, float*** %26
store float** %8, float*** %27
store float** %9, float*** %28
store float** %10, float*** %29
store i32* %11, i32** %30
store i32* %12, i32** %31
store float %13, float* %32
store float* %14, float** %33
store float* %15, float** %34
store i32* %16, i32** %35
store i32* %17, i32** %36
%43 = load i32*, i32** %30
%44 = getelementptr inbounds i32, i32* %43, i64 1
%45 = load i32, i32* %44
store i32 %45, i32* %38
br label %46
46: ; preds = %741, %18
%47 = load i32, i32* %38
%48 = load i32*, i32** %31
%49 = getelementptr inbounds i32, i32* %48, i64 1
%50 = load i32, i32* %49
%51 = add nsw i32 %50, 1
%52 = icmp slt i32 %47, %51
br i1 %52, label %53, label %744
53: ; preds = %46
%54 = load i32*, i32** %30
%55 = getelementptr inbounds i32, i32* %54, i64 0
%56 = load i32, i32* %55
store i32 %56, i32* %37
br label %57
57: ; preds = %737, %53
%58 = load i32, i32* %37
%59 = load i32*, i32** %31
%60 = getelementptr inbounds i32, i32* %59, i64 0
%61 = load i32, i32* %60
%62 = add nsw i32 %61, 1
%63 = icmp slt i32 %58, %62
br i1 %63, label %64, label %740
64: ; preds = %57
%65 = load float, float* %32
%66 = load float**, float*** %19
%67 = load i32, i32* %38
%68 = sext i32 %67 to i64
%69 = getelementptr inbounds float*, float** %66, i64 %68
%70 = load float*, float** %69
%71 = load i32, i32* %37
%72 = sext i32 %71 to i64
%73 = getelementptr inbounds float, float* %70, i64 %72
%74 = load float, float* %73
%75 = load float*, float** %33
%76 = getelementptr inbounds float, float* %75, i64 0
%77 = load float, float* %76
%78 = load float**, float*** %19
%79 = load i32, i32* %38
%80 = sext i32 %79 to i64
%81 = getelementptr inbounds float*, float** %78, i64 %80
%82 = load float*, float** %81
%83 = load i32, i32* %37
%84 = add nsw i32 %83, 1
%85 = sext i32 %84 to i64
%86 = getelementptr inbounds float, float* %82, i64 %85
%87 = load float, float* %86
%88 = load float**, float*** %19
%89 = load i32, i32* %38
%90 = sext i32 %89 to i64
%91 = getelementptr inbounds float*, float** %88, i64 %90
%92 = load float*, float** %91
%93 = load i32, i32* %37
%94 = sub nsw i32 %93, 1
%95 = sext i32 %94 to i64
%96 = getelementptr inbounds float, float* %92, i64 %95
%97 = load float, float* %96
%98 = fadd float %87, %97
%99 = fmul float %77, %98
%100 = call float @llvm.fmuladd.f32(float %65, float %74, float %99)
%101 = load float*, float** %33
%102 = getelementptr inbounds float, float* %101, i64 1
%103 = load float, float* %102
%104 = load float**, float*** %19
%105 = load i32, i32* %38
%106 = add nsw i32 %105, 1
%107 = sext i32 %106 to i64
%108 = getelementptr inbounds float*, float** %104, i64 %107
%109 = load float*, float** %108
%110 = load i32, i32* %37
%111 = sext i32 %110 to i64
%112 = getelementptr inbounds float, float* %109, i64 %111
%113 = load float, float* %112
%114 = load float**, float*** %19
%115 = load i32, i32* %38
%116 = sub nsw i32 %115, 1
%117 = sext i32 %116 to i64
%118 = getelementptr inbounds float*, float** %114, i64 %117
%119 = load float*, float** %118
%120 = load i32, i32* %37
%121 = sext i32 %120 to i64
%122 = getelementptr inbounds float, float* %119, i64 %121
%123 = load float, float* %122
%124 = fadd float %113, %123
%125 = call float @llvm.fmuladd.f32(float %103, float %124, float %100)
%126 = load float*, float** %34
%127 = getelementptr inbounds float, float* %126, i64 0
%128 = load float, float* %127
%129 = load float**, float*** %19
%130 = load i32, i32* %38
%131 = sext i32 %130 to i64
%132 = getelementptr inbounds float*, float** %129, i64 %131
%133 = load float*, float** %132
%134 = load i32, i32* %37
%135 = add nsw i32 %134, 2
%136 = sext i32 %135 to i64
%137 = getelementptr inbounds float, float* %133, i64 %136
%138 = load float, float* %137
%139 = load float**, float*** %19
%140 = load i32, i32* %38
%141 = sext i32 %140 to i64
%142 = getelementptr inbounds float*, float** %139, i64 %141
%143 = load float*, float** %142
%144 = load i32, i32* %37
%145 = sub nsw i32 %144, 2
%146 = sext i32 %145 to i64
%147 = getelementptr inbounds float, float* %143, i64 %146
%148 = load float, float* %147
%149 = fadd float %138, %148
%150 = call float @llvm.fmuladd.f32(float %128, float %149, float %125)
%151 = load float*, float** %34
%152 = getelementptr inbounds float, float* %151, i64 1
%153 = load float, float* %152
%154 = load float**, float*** %19
%155 = load i32, i32* %38
%156 = add nsw i32 %155, 2
%157 = sext i32 %156 to i64
%158 = getelementptr inbounds float*, float** %154, i64 %157
%159 = load float*, float** %158
%160 = load i32, i32* %37
%161 = sext i32 %160 to i64
%162 = getelementptr inbounds float, float* %159, i64 %161
%163 = load float, float* %162
%164 = load float**, float*** %19
%165 = load i32, i32* %38
%166 = sub nsw i32 %165, 2
%167 = sext i32 %166 to i64
%168 = getelementptr inbounds float*, float** %164, i64 %167
%169 = load float*, float** %168
%170 = load i32, i32* %37
%171 = sext i32 %170 to i64
%172 = getelementptr inbounds float, float* %169, i64 %171
%173 = load float, float* %172
%174 = fadd float %163, %173
%175 = call float @llvm.fmuladd.f32(float %153, float %174, float %150)
store float %175, float* %39
%176 = load float, float* %32
%177 = load float**, float*** %20
%178 = load i32, i32* %38
%179 = sext i32 %178 to i64
%180 = getelementptr inbounds float*, float** %177, i64 %179
%181 = load float*, float** %180
%182 = load i32, i32* %37
%183 = sext i32 %182 to i64
%184 = getelementptr inbounds float, float* %181, i64 %183
%185 = load float, float* %184
%186 = load float*, float** %33
%187 = getelementptr inbounds float, float* %186, i64 0
%188 = load float, float* %187
%189 = load float**, float*** %20
%190 = load i32, i32* %38
%191 = sext i32 %190 to i64
%192 = getelementptr inbounds float*, float** %189, i64 %191
%193 = load float*, float** %192
%194 = load i32, i32* %37
%195 = add nsw i32 %194, 1
%196 = sext i32 %195 to i64
%197 = getelementptr inbounds float, float* %193, i64 %196
%198 = load float, float* %197
%199 = load float**, float*** %20
%200 = load i32, i32* %38
%201 = sext i32 %200 to i64
%202 = getelementptr inbounds float*, float** %199, i64 %201
%203 = load float*, float** %202
%204 = load i32, i32* %37
%205 = sub nsw i32 %204, 1
%206 = sext i32 %205 to i64
%207 = getelementptr inbounds float, float* %203, i64 %206
%208 = load float, float* %207
%209 = fadd float %198, %208
%210 = fmul float %188, %209
%211 = call float @llvm.fmuladd.f32(float %176, float %185, float %210)
%212 = load float*, float** %33
%213 = getelementptr inbounds float, float* %212, i64 1
%214 = load float, float* %213
%215 = load float**, float*** %20
%216 = load i32, i32* %38
%217 = add nsw i32 %216, 1
%218 = sext i32 %217 to i64
%219 = getelementptr inbounds float*, float** %215, i64 %218
%220 = load float*, float** %219
%221 = load i32, i32* %37
%222 = sext i32 %221 to i64
%223 = getelementptr inbounds float, float* %220, i64 %222
%224 = load float, float* %223
%225 = load float**, float*** %20
%226 = load i32, i32* %38
%227 = sub nsw i32 %226, 1
%228 = sext i32 %227 to i64
%229 = getelementptr inbounds float*, float** %225, i64 %228
%230 = load float*, float** %229
%231 = load i32, i32* %37
%232 = sext i32 %231 to i64
%233 = getelementptr inbounds float, float* %230, i64 %232
%234 = load float, float* %233
%235 = fadd float %224, %234
%236 = call float @llvm.fmuladd.f32(float %214, float %235, float %211)
%237 = load float*, float** %34
%238 = getelementptr inbounds float, float* %237, i64 0
%239 = load float, float* %238
%240 = load float**, float*** %20
%241 = load i32, i32* %38
%242 = sext i32 %241 to i64
%243 = getelementptr inbounds float*, float** %240, i64 %242
%244 = load float*, float** %243
%245 = load i32, i32* %37
%246 = add nsw i32 %245, 2
%247 = sext i32 %246 to i64
%248 = getelementptr inbounds float, float* %244, i64 %247
%249 = load float, float* %248
%250 = load float**, float*** %20
%251 = load i32, i32* %38
%252 = sext i32 %251 to i64
%253 = getelementptr inbounds float*, float** %250, i64 %252
%254 = load float*, float** %253
%255 = load i32, i32* %37
%256 = sub nsw i32 %255, 2
%257 = sext i32 %256 to i64
%258 = getelementptr inbounds float, float* %254, i64 %257
%259 = load float, float* %258
%260 = fadd float %249, %259
%261 = call float @llvm.fmuladd.f32(float %239, float %260, float %236)
%262 = load float*, float** %34
%263 = getelementptr inbounds float, float* %262, i64 1
%264 = load float, float* %263
%265 = load float**, float*** %20
%266 = load i32, i32* %38
%267 = add nsw i32 %266, 2
%268 = sext i32 %267 to i64
%269 = getelementptr inbounds float*, float** %265, i64 %268
%270 = load float*, float** %269
%271 = load i32, i32* %37
%272 = sext i32 %271 to i64
%273 = getelementptr inbounds float, float* %270, i64 %272
%274 = load float, float* %273
%275 = load float**, float*** %20
%276 = load i32, i32* %38
%277 = sub nsw i32 %276, 2
%278 = sext i32 %277 to i64
%279 = getelementptr inbounds float*, float** %275, i64 %278
%280 = load float*, float** %279
%281 = load i32, i32* %37
%282 = sext i32 %281 to i64
%283 = getelementptr inbounds float, float* %280, i64 %282
%284 = load float, float* %283
%285 = fadd float %274, %284
%286 = call float @llvm.fmuladd.f32(float %264, float %285, float %261)
store float %286, float* %40
%287 = load float, float* %32
%288 = load float**, float*** %21
%289 = load i32, i32* %38
%290 = sext i32 %289 to i64
%291 = getelementptr inbounds float*, float** %288, i64 %290
%292 = load float*, float** %291
%293 = load i32, i32* %37
%294 = sext i32 %293 to i64
%295 = getelementptr inbounds float, float* %292, i64 %294
%296 = load float, float* %295
%297 = load float*, float** %33
%298 = getelementptr inbounds float, float* %297, i64 0
%299 = load float, float* %298
%300 = load float**, float*** %21
%301 = load i32, i32* %38
%302 = sext i32 %301 to i64
%303 = getelementptr inbounds float*, float** %300, i64 %302
%304 = load float*, float** %303
%305 = load i32, i32* %37
%306 = add nsw i32 %305, 1
%307 = sext i32 %306 to i64
%308 = getelementptr inbounds float, float* %304, i64 %307
%309 = load float, float* %308
%310 = load float**, float*** %21
%311 = load i32, i32* %38
%312 = sext i32 %311 to i64
%313 = getelementptr inbounds float*, float** %310, i64 %312
%314 = load float*, float** %313
%315 = load i32, i32* %37
%316 = sub nsw i32 %315, 1
%317 = sext i32 %316 to i64
%318 = getelementptr inbounds float, float* %314, i64 %317
%319 = load float, float* %318
%320 = fadd float %309, %319
%321 = fmul float %299, %320
%322 = call float @llvm.fmuladd.f32(float %287, float %296, float %321)
%323 = load float*, float** %33
%324 = getelementptr inbounds float, float* %323, i64 1
%325 = load float, float* %324
%326 = load float**, float*** %21
%327 = load i32, i32* %38
%328 = add nsw i32 %327, 1
%329 = sext i32 %328 to i64
%330 = getelementptr inbounds float*, float** %326, i64 %329
%331 = load float*, float** %330
%332 = load i32, i32* %37
%333 = sext i32 %332 to i64
%334 = getelementptr inbounds float, float* %331, i64 %333
%335 = load float, float* %334
%336 = load float**, float*** %21
%337 = load i32, i32* %38
%338 = sub nsw i32 %337, 1
%339 = sext i32 %338 to i64
%340 = getelementptr inbounds float*, float** %336, i64 %339
%341 = load float*, float** %340
%342 = load i32, i32* %37
%343 = sext i32 %342 to i64
%344 = getelementptr inbounds float, float* %341, i64 %343
%345 = load float, float* %344
%346 = fadd float %335, %345
%347 = call float @llvm.fmuladd.f32(float %325, float %346, float %322)
%348 = load float*, float** %34
%349 = getelementptr inbounds float, float* %348, i64 0
%350 = load float, float* %349
%351 = load float**, float*** %21
%352 = load i32, i32* %38
%353 = sext i32 %352 to i64
%354 = getelementptr inbounds float*, float** %351, i64 %353
%355 = load float*, float** %354
%356 = load i32, i32* %37
%357 = add nsw i32 %356, 2
%358 = sext i32 %357 to i64
%359 = getelementptr inbounds float, float* %355, i64 %358
%360 = load float, float* %359
%361 = load float**, float*** %21
%362 = load i32, i32* %38
%363 = sext i32 %362 to i64
%364 = getelementptr inbounds float*, float** %361, i64 %363
%365 = load float*, float** %364
%366 = load i32, i32* %37
%367 = sub nsw i32 %366, 2
%368 = sext i32 %367 to i64
%369 = getelementptr inbounds float, float* %365, i64 %368
%370 = load float, float* %369
%371 = fadd float %360, %370
%372 = call float @llvm.fmuladd.f32(float %350, float %371, float %347)
%373 = load float*, float** %34
%374 = getelementptr inbounds float, float* %373, i64 1
%375 = load float, float* %374
%376 = load float**, float*** %21
%377 = load i32, i32* %38
%378 = add nsw i32 %377, 2
%379 = sext i32 %378 to i64
%380 = getelementptr inbounds float*, float** %376, i64 %379
%381 = load float*, float** %380
%382 = load i32, i32* %37
%383 = sext i32 %382 to i64
%384 = getelementptr inbounds float, float* %381, i64 %383
%385 = load float, float* %384
%386 = load float**, float*** %21
%387 = load i32, i32* %38
%388 = sub nsw i32 %387, 2
%389 = sext i32 %388 to i64
%390 = getelementptr inbounds float*, float** %386, i64 %389
%391 = load float*, float** %390
%392 = load i32, i32* %37
%393 = sext i32 %392 to i64
%394 = getelementptr inbounds float, float* %391, i64 %393
%395 = load float, float* %394
%396 = fadd float %385, %395
%397 = call float @llvm.fmuladd.f32(float %375, float %396, float %372)
store float %397, float* %41
%398 = load float, float* %32
%399 = load float**, float*** %22
%400 = load i32, i32* %38
%401 = sext i32 %400 to i64
%402 = getelementptr inbounds float*, float** %399, i64 %401
%403 = load float*, float** %402
%404 = load i32, i32* %37
%405 = sext i32 %404 to i64
%406 = getelementptr inbounds float, float* %403, i64 %405
%407 = load float, float* %406
%408 = load float*, float** %33
%409 = getelementptr inbounds float, float* %408, i64 0
%410 = load float, float* %409
%411 = load float**, float*** %22
%412 = load i32, i32* %38
%413 = sext i32 %412 to i64
%414 = getelementptr inbounds float*, float** %411, i64 %413
%415 = load float*, float** %414
%416 = load i32, i32* %37
%417 = add nsw i32 %416, 1
%418 = sext i32 %417 to i64
%419 = getelementptr inbounds float, float* %415, i64 %418
%420 = load float, float* %419
%421 = load float**, float*** %22
%422 = load i32, i32* %38
%423 = sext i32 %422 to i64
%424 = getelementptr inbounds float*, float** %421, i64 %423
%425 = load float*, float** %424
%426 = load i32, i32* %37
%427 = sub nsw i32 %426, 1
%428 = sext i32 %427 to i64
%429 = getelementptr inbounds float, float* %425, i64 %428
%430 = load float, float* %429
%431 = fadd float %420, %430
%432 = fmul float %410, %431
%433 = call float @llvm.fmuladd.f32(float %398, float %407, float %432)
%434 = load float*, float** %33
%435 = getelementptr inbounds float, float* %434, i64 1
%436 = load float, float* %435
%437 = load float**, float*** %22
%438 = load i32, i32* %38
%439 = add nsw i32 %438, 1
%440 = sext i32 %439 to i64
%441 = getelementptr inbounds float*, float** %437, i64 %440
%442 = load float*, float** %441
%443 = load i32, i32* %37
%444 = sext i32 %443 to i64
%445 = getelementptr inbounds float, float* %442, i64 %444
%446 = load float, float* %445
%447 = load float**, float*** %22
%448 = load i32, i32* %38
%449 = sub nsw i32 %448, 1
%450 = sext i32 %449 to i64
%451 = getelementptr inbounds float*, float** %447, i64 %450
%452 = load float*, float** %451
%453 = load i32, i32* %37
%454 = sext i32 %453 to i64
%455 = getelementptr inbounds float, float* %452, i64 %454
%456 = load float, float* %455
%457 = fadd float %446, %456
%458 = call float @llvm.fmuladd.f32(float %436, float %457, float %433)
%459 = load float*, float** %34
%460 = getelementptr inbounds float, float* %459, i64 0
%461 = load float, float* %460
%462 = load float**, float*** %22
%463 = load i32, i32* %38
%464 = sext i32 %463 to i64
%465 = getelementptr inbounds float*, float** %462, i64 %464
%466 = load float*, float** %465
%467 = load i32, i32* %37
%468 = add nsw i32 %467, 2
%469 = sext i32 %468 to i64
%470 = getelementptr inbounds float, float* %466, i64 %469
%471 = load float, float* %470
%472 = load float**, float*** %22
%473 = load i32, i32* %38
%474 = sext i32 %473 to i64
%475 = getelementptr inbounds float*, float** %472, i64 %474
%476 = load float*, float** %475
%477 = load i32, i32* %37
%478 = sub nsw i32 %477, 2
%479 = sext i32 %478 to i64
%480 = getelementptr inbounds float, float* %476, i64 %479
%481 = load float, float* %480
%482 = fadd float %471, %481
%483 = call float @llvm.fmuladd.f32(float %461, float %482, float %458)
%484 = load float*, float** %34
%485 = getelementptr inbounds float, float* %484, i64 1
%486 = load float, float* %485
%487 = load float**, float*** %22
%488 = load i32, i32* %38
%489 = add nsw i32 %488, 2
%490 = sext i32 %489 to i64
%491 = getelementptr inbounds float*, float** %487, i64 %490
%492 = load float*, float** %491
%493 = load i32, i32* %37
%494 = sext i32 %493 to i64
%495 = getelementptr inbounds float, float* %492, i64 %494
%496 = load float, float* %495
%497 = load float**, float*** %22
%498 = load i32, i32* %38
%499 = sub nsw i32 %498, 2
%500 = sext i32 %499 to i64
%501 = getelementptr inbounds float*, float** %497, i64 %500
%502 = load float*, float** %501
%503 = load i32, i32* %37
%504 = sext i32 %503 to i64
%505 = getelementptr inbounds float, float* %502, i64 %504
%506 = load float, float* %505
%507 = fadd float %496, %506
%508 = call float @llvm.fmuladd.f32(float %486, float %507, float %483)
store float %508, float* %42
%509 = load float**, float*** %22
%510 = load i32, i32* %38
%511 = sext i32 %510 to i64
%512 = getelementptr inbounds float*, float** %509, i64 %511
%513 = load float*, float** %512
%514 = load i32, i32* %37
%515 = sext i32 %514 to i64
%516 = getelementptr inbounds float, float* %513, i64 %515
%517 = load float, float* %516
%518 = fpext float %517 to double
%519 = load float**, float*** %26
%520 = load i32, i32* %38
%521 = sext i32 %520 to i64
%522 = getelementptr inbounds float*, float** %519, i64 %521
%523 = load float*, float** %522
%524 = load i32, i32* %37
%525 = sext i32 %524 to i64
%526 = getelementptr inbounds float, float* %523, i64 %525
%527 = load float, float* %526
%528 = fpext float %527 to double
%529 = fneg double %528
%530 = call double @llvm.fmuladd.f64(double 2.000000e+00, double %518, double %529)
%531 = load float**, float*** %29
%532 = load i32, i32* %38
%533 = sext i32 %532 to i64
%534 = getelementptr inbounds float*, float** %531, i64 %533
%535 = load float*, float** %534
%536 = load i32, i32* %37
%537 = sext i32 %536 to i64
%538 = getelementptr inbounds float, float* %535, i64 %537
%539 = load float, float* %538
%540 = load float, float* %40
%541 = fmul float %539, %540
%542 = fpext float %541 to double
%543 = fadd double %530, %542
%544 = load float**, float*** %28
%545 = load i32, i32* %38
%546 = sext i32 %545 to i64
%547 = getelementptr inbounds float*, float** %544, i64 %546
%548 = load float*, float** %547
%549 = load i32, i32* %37
%550 = sext i32 %549 to i64
%551 = getelementptr inbounds float, float* %548, i64 %550
%552 = load float, float* %551
%553 = load float, float* %41
%554 = fmul float %552, %553
%555 = fpext float %554 to double
%556 = fadd double %543, %555
%557 = load float**, float*** %27
%558 = load i32, i32* %38
%559 = sext i32 %558 to i64
%560 = getelementptr inbounds float*, float** %557, i64 %559
%561 = load float*, float** %560
%562 = load i32, i32* %37
%563 = sext i32 %562 to i64
%564 = getelementptr inbounds float, float* %561, i64 %563
%565 = load float, float* %564
%566 = load float, float* %42
%567 = fmul float %565, %566
%568 = fpext float %567 to double
%569 = fadd double %556, %568
%570 = fptrunc double %569 to float
%571 = load float**, float*** %26
%572 = load i32, i32* %38
%573 = sext i32 %572 to i64
%574 = getelementptr inbounds float*, float** %571, i64 %573
%575 = load float*, float** %574
%576 = load i32, i32* %37
%577 = sext i32 %576 to i64
%578 = getelementptr inbounds float, float* %575, i64 %577
store float %570, float* %578
%579 = load float**, float*** %21
%580 = load i32, i32* %38
%581 = sext i32 %580 to i64
%582 = getelementptr inbounds float*, float** %579, i64 %581
%583 = load float*, float** %582
%584 = load i32, i32* %37
%585 = sext i32 %584 to i64
%586 = getelementptr inbounds float, float* %583, i64 %585
%587 = load float, float* %586
%588 = fpext float %587 to double
%589 = load float**, float*** %25
%590 = load i32, i32* %38
%591 = sext i32 %590 to i64
%592 = getelementptr inbounds float*, float** %589, i64 %591
%593 = load float*, float** %592
%594 = load i32, i32* %37
%595 = sext i32 %594 to i64
%596 = getelementptr inbounds float, float* %593, i64 %595
%597 = load float, float* %596
%598 = fpext float %597 to double
%599 = fneg double %598
%600 = call double @llvm.fmuladd.f64(double 2.000000e+00, double %588, double %599)
%601 = load float**, float*** %29
%602 = load i32, i32* %38
%603 = sext i32 %602 to i64
%604 = getelementptr inbounds float*, float** %601, i64 %603
%605 = load float*, float** %604
%606 = load i32, i32* %37
%607 = sext i32 %606 to i64
%608 = getelementptr inbounds float, float* %605, i64 %607
%609 = load float, float* %608
%610 = load float, float* %39
%611 = fmul float %609, %610
%612 = fpext float %611 to double
%613 = fadd double %600, %612
%614 = load float**, float*** %27
%615 = load i32, i32* %38
%616 = sext i32 %615 to i64
%617 = getelementptr inbounds float*, float** %614, i64 %616
%618 = load float*, float** %617
%619 = load i32, i32* %37
%620 = sext i32 %619 to i64
%621 = getelementptr inbounds float, float* %618, i64 %620
%622 = load float, float* %621
%623 = load float, float* %41
%624 = fmul float %622, %623
%625 = fpext float %624 to double
%626 = fadd double %613, %625
%627 = fptrunc double %626 to float
%628 = load float**, float*** %25
%629 = load i32, i32* %38
%630 = sext i32 %629 to i64
%631 = getelementptr inbounds float*, float** %628, i64 %630
%632 = load float*, float** %631
%633 = load i32, i32* %37
%634 = sext i32 %633 to i64
%635 = getelementptr inbounds float, float* %632, i64 %634
store float %627, float* %635
%636 = load float**, float*** %20
%637 = load i32, i32* %38
%638 = sext i32 %637 to i64
%639 = getelementptr inbounds float*, float** %636, i64 %638
%640 = load float*, float** %639
%641 = load i32, i32* %37
%642 = sext i32 %641 to i64
%643 = getelementptr inbounds float, float* %640, i64 %642
%644 = load float, float* %643
%645 = fpext float %644 to double
%646 = load float**, float*** %24
%647 = load i32, i32* %38
%648 = sext i32 %647 to i64
%649 = getelementptr inbounds float*, float** %646, i64 %648
%650 = load float*, float** %649
%651 = load i32, i32* %37
%652 = sext i32 %651 to i64
%653 = getelementptr inbounds float, float* %650, i64 %652
%654 = load float, float* %653
%655 = fpext float %654 to double
%656 = fneg double %655
%657 = call double @llvm.fmuladd.f64(double 2.000000e+00, double %645, double %656)
%658 = load float**, float*** %28
%659 = load i32, i32* %38
%660 = sext i32 %659 to i64
%661 = getelementptr inbounds float*, float** %658, i64 %660
%662 = load float*, float** %661
%663 = load i32, i32* %37
%664 = sext i32 %663 to i64
%665 = getelementptr inbounds float, float* %662, i64 %664
%666 = load float, float* %665
%667 = load float, float* %39
%668 = fmul float %666, %667
%669 = fpext float %668 to double
%670 = fadd double %657, %669
%671 = load float**, float*** %27
%672 = load i32, i32* %38
%673 = sext i32 %672 to i64
%674 = getelementptr inbounds float*, float** %671, i64 %673
%675 = load float*, float** %674
%676 = load i32, i32* %37
%677 = sext i32 %676 to i64
%678 = getelementptr inbounds float, float* %675, i64 %677
%679 = load float, float* %678
%680 = load float, float* %40
%681 = fmul float %679, %680
%682 = fpext float %681 to double
%683 = fadd double %670, %682
%684 = fptrunc double %683 to float
%685 = load float**, float*** %24
%686 = load i32, i32* %38
%687 = sext i32 %686 to i64
%688 = getelementptr inbounds float*, float** %685, i64 %687
%689 = load float*, float** %688
%690 = load i32, i32* %37
%691 = sext i32 %690 to i64
%692 = getelementptr inbounds float, float* %689, i64 %691
store float %684, float* %692
%693 = load float**, float*** %19
%694 = load i32, i32* %38
%695 = sext i32 %694 to i64
%696 = getelementptr inbounds float*, float** %693, i64 %695
%697 = load float*, float** %696
%698 = load i32, i32* %37
%699 = sext i32 %698 to i64
%700 = getelementptr inbounds float, float* %697, i64 %699
%701 = load float, float* %700
%702 = fpext float %701 to double
%703 = load float**, float*** %23
%704 = load i32, i32* %38
%705 = sext i32 %704 to i64
%706 = getelementptr inbounds float*, float** %703, i64 %705
%707 = load float*, float** %706
%708 = load i32, i32* %37
%709 = sext i32 %708 to i64
%710 = getelementptr inbounds float, float* %707, i64 %709
%711 = load float, float* %710
%712 = fpext float %711 to double
%713 = fneg double %712
%714 = call double @llvm.fmuladd.f64(double 2.000000e+00, double %702, double %713)
%715 = load float**, float*** %27
%716 = load i32, i32* %38
%717 = sext i32 %716 to i64
%718 = getelementptr inbounds float*, float** %715, i64 %717
%719 = load float*, float** %718
%720 = load i32, i32* %37
%721 = sext i32 %720 to i64
%722 = getelementptr inbounds float, float* %719, i64 %721
%723 = load float, float* %722
%724 = load float, float* %39
%725 = fmul float %723, %724
%726 = fpext float %725 to double
%727 = fadd double %714, %726
%728 = fptrunc double %727 to float
%729 = load float**, float*** %23
%730 = load i32, i32* %38
%731 = sext i32 %730 to i64
%732 = getelementptr inbounds float*, float** %729, i64 %731
%733 = load float*, float** %732
%734 = load i32, i32* %37
%735 = sext i32 %734 to i64
%736 = getelementptr inbounds float, float* %733, i64 %735
store float %728, float* %736
br label %737
737: ; preds = %64
%738 = load i32, i32* %37
%739 = add nsw i32 %738, 1
store i32 %739, i32* %37
br label %57
740: ; preds = %57
br label %741
741: ; preds = %740
%742 = load i32, i32* %38
%743 = add nsw i32 %742, 1
store i32 %743, i32* %38
br label %46
744: ; preds = %46
%745 = load i32*, i32** %35
%746 = getelementptr inbounds i32, i32* %745, i64 1
%747 = load i32, i32* %746
%748 = icmp ne i32 %747, 0
br i1 %748, label %749, label %857
749: ; preds = %744
%750 = load i32*, i32** %30
%751 = getelementptr inbounds i32, i32* %750, i64 0
%752 = load i32, i32* %751
store i32 %752, i32* %37
br label %753
753: ; preds = %853, %749
%754 = load i32, i32* %37
%755 = load i32*, i32** %31
%756 = getelementptr inbounds i32, i32* %755, i64 0
%757 = load i32, i32* %756
%758 = add nsw i32 %757, 1
%759 = icmp slt i32 %754, %758
br i1 %759, label %760, label %856
760: ; preds = %753
%761 = load float**, float*** %26
%762 = load i32*, i32** %30
%763 = getelementptr inbounds i32, i32* %762, i64 1
%764 = load i32, i32* %763
%765 = sext i32 %764 to i64
%766 = getelementptr inbounds float*, float** %761, i64 %765
%767 = load float*, float** %766
%768 = load i32, i32* %37
%769 = sext i32 %768 to i64
%770 = getelementptr inbounds float, float* %767, i64 %769
%771 = load float, float* %770
%772 = fneg float %771
%773 = load float**, float*** %26
%774 = load i32*, i32** %30
%775 = getelementptr inbounds i32, i32* %774, i64 1
%776 = load i32, i32* %775
%777 = sub nsw i32 %776, 2
%778 = sext i32 %777 to i64
%779 = getelementptr inbounds float*, float** %773, i64 %778
%780 = load float*, float** %779
%781 = load i32, i32* %37
%782 = sext i32 %781 to i64
%783 = getelementptr inbounds float, float* %780, i64 %782
store float %772, float* %783
%784 = load float**, float*** %25
%785 = load i32*, i32** %30
%786 = getelementptr inbounds i32, i32* %785, i64 1
%787 = load i32, i32* %786
%788 = sext i32 %787 to i64
%789 = getelementptr inbounds float*, float** %784, i64 %788
%790 = load float*, float** %789
%791 = load i32, i32* %37
%792 = sext i32 %791 to i64
%793 = getelementptr inbounds float, float* %790, i64 %792
%794 = load float, float* %793
%795 = fneg float %794
%796 = load float**, float*** %25
%797 = load i32*, i32** %30
%798 = getelementptr inbounds i32, i32* %797, i64 1
%799 = load i32, i32* %798
%800 = sub nsw i32 %799, 2
%801 = sext i32 %800 to i64
%802 = getelementptr inbounds float*, float** %796, i64 %801
%803 = load float*, float** %802
%804 = load i32, i32* %37
%805 = sext i32 %804 to i64
%806 = getelementptr inbounds float, float* %803, i64 %805
store float %795, float* %806
%807 = load float**, float*** %24
%808 = load i32*, i32** %30
%809 = getelementptr inbounds i32, i32* %808, i64 1
%810 = load i32, i32* %809
%811 = sext i32 %810 to i64
%812 = getelementptr inbounds float*, float** %807, i64 %811
%813 = load float*, float** %812
%814 = load i32, i32* %37
%815 = sext i32 %814 to i64
%816 = getelementptr inbounds float, float* %813, i64 %815
%817 = load float, float* %816
%818 = fneg float %817
%819 = load float**, float*** %24
%820 = load i32*, i32** %30
%821 = getelementptr inbounds i32, i32* %820, i64 1
%822 = load i32, i32* %821
%823 = sub nsw i32 %822, 2
%824 = sext i32 %823 to i64
%825 = getelementptr inbounds float*, float** %819, i64 %824
%826 = load float*, float** %825
%827 = load i32, i32* %37
%828 = sext i32 %827 to i64
%829 = getelementptr inbounds float, float* %826, i64 %828
store float %818, float* %829
%830 = load float**, float*** %23
%831 = load i32*, i32** %30
%832 = getelementptr inbounds i32, i32* %831, i64 1
%833 = load i32, i32* %832
%834 = sext i32 %833 to i64
%835 = getelementptr inbounds float*, float** %830, i64 %834
%836 = load float*, float** %835
%837 = load i32, i32* %37
%838 = sext i32 %837 to i64
%839 = getelementptr inbounds float, float* %836, i64 %838
%840 = load float, float* %839
%841 = fneg float %840
%842 = load float**, float*** %23
%843 = load i32*, i32** %30
%844 = getelementptr inbounds i32, i32* %843, i64 1
%845 = load i32, i32* %844
%846 = sub nsw i32 %845, 2
%847 = sext i32 %846 to i64
%848 = getelementptr inbounds float*, float** %842, i64 %847
%849 = load float*, float** %848
%850 = load i32, i32* %37
%851 = sext i32 %850 to i64
%852 = getelementptr inbounds float, float* %849, i64 %851
store float %841, float* %852
br label %853
853: ; preds = %760
%854 = load i32, i32* %37
%855 = add nsw i32 %854, 1
store i32 %855, i32* %37
br label %753
856: ; preds = %753
br label %857
857: ; preds = %856, %744
%858 = load i32*, i32** %36
%859 = getelementptr inbounds i32, i32* %858, i64 1
%860 = load i32, i32* %859
%861 = icmp ne i32 %860, 0
br i1 %861, label %862, label %970
862: ; preds = %857
%863 = load i32*, i32** %30
%864 = getelementptr inbounds i32, i32* %863, i64 0
%865 = load i32, i32* %864
store i32 %865, i32* %37
br label %866
866: ; preds = %966, %862
%867 = load i32, i32* %37
%868 = load i32*, i32** %31
%869 = getelementptr inbounds i32, i32* %868, i64 0
%870 = load i32, i32* %869
%871 = add nsw i32 %870, 1
%872 = icmp slt i32 %867, %871
br i1 %872, label %873, label %969
873: ; preds = %866
%874 = load float**, float*** %26
%875 = load i32*, i32** %31
%876 = getelementptr inbounds i32, i32* %875, i64 1
%877 = load i32, i32* %876
%878 = sext i32 %877 to i64
%879 = getelementptr inbounds float*, float** %874, i64 %878
%880 = load float*, float** %879
%881 = load i32, i32* %37
%882 = sext i32 %881 to i64
%883 = getelementptr inbounds float, float* %880, i64 %882
%884 = load float, float* %883
%885 = fneg float %884
%886 = load float**, float*** %26
%887 = load i32*, i32** %31
%888 = getelementptr inbounds i32, i32* %887, i64 1
%889 = load i32, i32* %888
%890 = add nsw i32 %889, 2
%891 = sext i32 %890 to i64
%892 = getelementptr inbounds float*, float** %886, i64 %891
%893 = load float*, float** %892
%894 = load i32, i32* %37
%895 = sext i32 %894 to i64
%896 = getelementptr inbounds float, float* %893, i64 %895
store float %885, float* %896
%897 = load float**, float*** %25
%898 = load i32*, i32** %31
%899 = getelementptr inbounds i32, i32* %898, i64 1
%900 = load i32, i32* %899
%901 = sext i32 %900 to i64
%902 = getelementptr inbounds float*, float** %897, i64 %901
%903 = load float*, float** %902
%904 = load i32, i32* %37
%905 = sext i32 %904 to i64
%906 = getelementptr inbounds float, float* %903, i64 %905
%907 = load float, float* %906
%908 = fneg float %907
%909 = load float**, float*** %25
%910 = load i32*, i32** %31
%911 = getelementptr inbounds i32, i32* %910, i64 1
%912 = load i32, i32* %911
%913 = add nsw i32 %912, 2
%914 = sext i32 %913 to i64
%915 = getelementptr inbounds float*, float** %909, i64 %914
%916 = load float*, float** %915
%917 = load i32, i32* %37
%918 = sext i32 %917 to i64
%919 = getelementptr inbounds float, float* %916, i64 %918
store float %908, float* %919
%920 = load float**, float*** %24
%921 = load i32*, i32** %31
%922 = getelementptr inbounds i32, i32* %921, i64 1
%923 = load i32, i32* %922
%924 = sext i32 %923 to i64
%925 = getelementptr inbounds float*, float** %920, i64 %924
%926 = load float*, float** %925
%927 = load i32, i32* %37
%928 = sext i32 %927 to i64
%929 = getelementptr inbounds float, float* %926, i64 %928
%930 = load float, float* %929
%931 = fneg float %930
%932 = load float**, float*** %24
%933 = load i32*, i32** %31
%934 = getelementptr inbounds i32, i32* %933, i64 1
%935 = load i32, i32* %934
%936 = add nsw i32 %935, 2
%937 = sext i32 %936 to i64
%938 = getelementptr inbounds float*, float** %932, i64 %937
%939 = load float*, float** %938
%940 = load i32, i32* %37
%941 = sext i32 %940 to i64
%942 = getelementptr inbounds float, float* %939, i64 %941
store float %931, float* %942
%943 = load float**, float*** %23
%944 = load i32*, i32** %31
%945 = getelementptr inbounds i32, i32* %944, i64 1
%946 = load i32, i32* %945
%947 = sext i32 %946 to i64
%948 = getelementptr inbounds float*, float** %943, i64 %947
%949 = load float*, float** %948
%950 = load i32, i32* %37
%951 = sext i32 %950 to i64
%952 = getelementptr inbounds float, float* %949, i64 %951
%953 = load float, float* %952
%954 = fneg float %953
%955 = load float**, float*** %23
%956 = load i32*, i32** %31
%957 = getelementptr inbounds i32, i32* %956, i64 1
%958 = load i32, i32* %957
%959 = add nsw i32 %958, 2
%960 = sext i32 %959 to i64
%961 = getelementptr inbounds float*, float** %955, i64 %960
%962 = load float*, float** %961
%963 = load i32, i32* %37
%964 = sext i32 %963 to i64
%965 = getelementptr inbounds float, float* %962, i64 %964
store float %954, float* %965
br label %966
966: ; preds = %873
%967 = load i32, i32* %37
%968 = add nsw i32 %967, 1
store i32 %968, i32* %37
br label %866
969: ; preds = %866
br label %970
970: ; preds = %969, %857
%971 = load i32*, i32** %35
%972 = getelementptr inbounds i32, i32* %971, i64 0
%973 = load i32, i32* %972
%974 = icmp ne i32 %973, 0
br i1 %974, label %975, label %1083
975: ; preds = %970
%976 = load i32*, i32** %30
%977 = getelementptr inbounds i32, i32* %976, i64 1
%978 = load i32, i32* %977
store i32 %978, i32* %38
br label %979
979: ; preds = %1079, %975
%980 = load i32, i32* %38
%981 = load i32*, i32** %31
%982 = getelementptr inbounds i32, i32* %981, i64 1
%983 = load i32, i32* %982
%984 = add nsw i32 %983, 1
%985 = icmp slt i32 %980, %984
br i1 %985, label %986, label %1082
986: ; preds = %979
%987 = load float**, float*** %26
%988 = load i32, i32* %38
%989 = sext i32 %988 to i64
%990 = getelementptr inbounds float*, float** %987, i64 %989
%991 = load float*, float** %990
%992 = load i32*, i32** %30
%993 = getelementptr inbounds i32, i32* %992, i64 0
%994 = load i32, i32* %993
%995 = sext i32 %994 to i64
%996 = getelementptr inbounds float, float* %991, i64 %995
%997 = load float, float* %996
%998 = fneg float %997
%999 = load float**, float*** %26
%1000 = load i32, i32* %38
%1001 = sext i32 %1000 to i64
%1002 = getelementptr inbounds float*, float** %999, i64 %1001
%1003 = load float*, float** %1002
%1004 = load i32*, i32** %30
%1005 = getelementptr inbounds i32, i32* %1004, i64 0
%1006 = load i32, i32* %1005
%1007 = sub nsw i32 %1006, 2
%1008 = sext i32 %1007 to i64
%1009 = getelementptr inbounds float, float* %1003, i64 %1008
store float %998, float* %1009
%1010 = load float**, float*** %25
%1011 = load i32, i32* %38
%1012 = sext i32 %1011 to i64
%1013 = getelementptr inbounds float*, float** %1010, i64 %1012
%1014 = load float*, float** %1013
%1015 = load i32*, i32** %30
%1016 = getelementptr inbounds i32, i32* %1015, i64 0
%1017 = load i32, i32* %1016
%1018 = sext i32 %1017 to i64
%1019 = getelementptr inbounds float, float* %1014, i64 %1018
%1020 = load float, float* %1019
%1021 = fneg float %1020
%1022 = load float**, float*** %25
%1023 = load i32, i32* %38
%1024 = sext i32 %1023 to i64
%1025 = getelementptr inbounds float*, float** %1022, i64 %1024
%1026 = load float*, float** %1025
%1027 = load i32*, i32** %30
%1028 = getelementptr inbounds i32, i32* %1027, i64 0
%1029 = load i32, i32* %1028
%1030 = sub nsw i32 %1029, 2
%1031 = sext i32 %1030 to i64
%1032 = getelementptr inbounds float, float* %1026, i64 %1031
store float %1021, float* %1032
%1033 = load float**, float*** %24
%1034 = load i32, i32* %38
%1035 = sext i32 %1034 to i64
%1036 = getelementptr inbounds float*, float** %1033, i64 %1035
%1037 = load float*, float** %1036
%1038 = load i32*, i32** %30
%1039 = getelementptr inbounds i32, i32* %1038, i64 0
%1040 = load i32, i32* %1039
%1041 = sext i32 %1040 to i64
%1042 = getelementptr inbounds float, float* %1037, i64 %1041
%1043 = load float, float* %1042
%1044 = fneg float %1043
%1045 = load float**, float*** %24
%1046 = load i32, i32* %38
%1047 = sext i32 %1046 to i64
%1048 = getelementptr inbounds float*, float** %1045, i64 %1047
%1049 = load float*, float** %1048
%1050 = load i32*, i32** %30
%1051 = getelementptr inbounds i32, i32* %1050, i64 0
%1052 = load i32, i32* %1051
%1053 = sub nsw i32 %1052, 2
%1054 = sext i32 %1053 to i64
%1055 = getelementptr inbounds float, float* %1049, i64 %1054
store float %1044, float* %1055
%1056 = load float**, float*** %23
%1057 = load i32, i32* %38
%1058 = sext i32 %1057 to i64
%1059 = getelementptr inbounds float*, float** %1056, i64 %1058
%1060 = load float*, float** %1059
%1061 = load i32*, i32** %30
%1062 = getelementptr inbounds i32, i32* %1061, i64 0
%1063 = load i32, i32* %1062
%1064 = sext i32 %1063 to i64
%1065 = getelementptr inbounds float, float* %1060, i64 %1064
%1066 = load float, float* %1065
%1067 = fneg float %1066
%1068 = load float**, float*** %23
%1069 = load i32, i32* %38
%1070 = sext i32 %1069 to i64
%1071 = getelementptr inbounds float*, float** %1068, i64 %1070
%1072 = load float*, float** %1071
%1073 = load i32*, i32** %30
%1074 = getelementptr inbounds i32, i32* %1073, i64 0
%1075 = load i32, i32* %1074
%1076 = sub nsw i32 %1075, 2
%1077 = sext i32 %1076 to i64
%1078 = getelementptr inbounds float, float* %1072, i64 %1077
store float %1067, float* %1078
br label %1079
1079: ; preds = %986
%1080 = load i32, i32* %38
%1081 = add nsw i32 %1080, 1
store i32 %1081, i32* %38
br label %979
1082: ; preds = %979
br label %1083
1083: ; preds = %1082, %970
%1084 = load i32*, i32** %36
%1085 = getelementptr inbounds i32, i32* %1084, i64 0
%1086 = load i32, i32* %1085
%1087 = icmp ne i32 %1086, 0
br i1 %1087, label %1088, label %1196
1088: ; preds = %1083
%1089 = load i32*, i32** %30
%1090 = getelementptr inbounds i32, i32* %1089, i64 1
%1091 = load i32, i32* %1090
store i32 %1091, i32* %38
br label %1092
1092: ; preds = %1192, %1088
%1093 = load i32, i32* %38
%1094 = load i32*, i32** %31
%1095 = getelementptr inbounds i32, i32* %1094, i64 1
%1096 = load i32, i32* %1095
%1097 = add nsw i32 %1096, 1
%1098 = icmp slt i32 %1093, %1097
br i1 %1098, label %1099, label %1195
1099: ; preds = %1092
%1100 = load float**, float*** %26
%1101 = load i32, i32* %38
%1102 = sext i32 %1101 to i64
%1103 = getelementptr inbounds float*, float** %1100, i64 %1102
%1104 = load float*, float** %1103
%1105 = load i32*, i32** %31
%1106 = getelementptr inbounds i32, i32* %1105, i64 0
%1107 = load i32, i32* %1106
%1108 = sext i32 %1107 to i64
%1109 = getelementptr inbounds float, float* %1104, i64 %1108
%1110 = load float, float* %1109
%1111 = fneg float %1110
%1112 = load float**, float*** %26
%1113 = load i32, i32* %38
%1114 = sext i32 %1113 to i64
%1115 = getelementptr inbounds float*, float** %1112, i64 %1114
%1116 = load float*, float** %1115
%1117 = load i32*, i32** %31
%1118 = getelementptr inbounds i32, i32* %1117, i64 0
%1119 = load i32, i32* %1118
%1120 = add nsw i32 %1119, 2
%1121 = sext i32 %1120 to i64
%1122 = getelementptr inbounds float, float* %1116, i64 %1121
store float %1111, float* %1122
%1123 = load float**, float*** %25
%1124 = load i32, i32* %38
%1125 = sext i32 %1124 to i64
%1126 = getelementptr inbounds float*, float** %1123, i64 %1125
%1127 = load float*, float** %1126
%1128 = load i32*, i32** %31
%1129 = getelementptr inbounds i32, i32* %1128, i64 0
%1130 = load i32, i32* %1129
%1131 = sext i32 %1130 to i64
%1132 = getelementptr inbounds float, float* %1127, i64 %1131
%1133 = load float, float* %1132
%1134 = fneg float %1133
%1135 = load float**, float*** %25
%1136 = load i32, i32* %38
%1137 = sext i32 %1136 to i64
%1138 = getelementptr inbounds float*, float** %1135, i64 %1137
%1139 = load float*, float** %1138
%1140 = load i32*, i32** %31
%1141 = getelementptr inbounds i32, i32* %1140, i64 0
%1142 = load i32, i32* %1141
%1143 = add nsw i32 %1142, 2
%1144 = sext i32 %1143 to i64
%1145 = getelementptr inbounds float, float* %1139, i64 %1144
store float %1134, float* %1145
%1146 = load float**, float*** %24
%1147 = load i32, i32* %38
%1148 = sext i32 %1147 to i64
%1149 = getelementptr inbounds float*, float** %1146, i64 %1148
%1150 = load float*, float** %1149
%1151 = load i32*, i32** %31
%1152 = getelementptr inbounds i32, i32* %1151, i64 0
%1153 = load i32, i32* %1152
%1154 = sext i32 %1153 to i64
%1155 = getelementptr inbounds float, float* %1150, i64 %1154
%1156 = load float, float* %1155
%1157 = fneg float %1156
%1158 = load float**, float*** %24
%1159 = load i32, i32* %38
%1160 = sext i32 %1159 to i64
%1161 = getelementptr inbounds float*, float** %1158, i64 %1160
%1162 = load float*, float** %1161
%1163 = load i32*, i32** %31
%1164 = getelementptr inbounds i32, i32* %1163, i64 0
%1165 = load i32, i32* %1164
%1166 = add nsw i32 %1165, 2
%1167 = sext i32 %1166 to i64
%1168 = getelementptr inbounds float, float* %1162, i64 %1167
store float %1157, float* %1168
%1169 = load float**, float*** %23
%1170 = load i32, i32* %38
%1171 = sext i32 %1170 to i64
%1172 = getelementptr inbounds float*, float** %1169, i64 %1171
%1173 = load float*, float** %1172
%1174 = load i32*, i32** %31
%1175 = getelementptr inbounds i32, i32* %1174, i64 0
%1176 = load i32, i32* %1175
%1177 = sext i32 %1176 to i64
%1178 = getelementptr inbounds float, float* %1173, i64 %1177
%1179 = load float, float* %1178
%1180 = fneg float %1179
%1181 = load float**, float*** %23
%1182 = load i32, i32* %38
%1183 = sext i32 %1182 to i64
%1184 = getelementptr inbounds float*, float** %1181, i64 %1183
%1185 = load float*, float** %1184
%1186 = load i32*, i32** %31
%1187 = getelementptr inbounds i32, i32* %1186, i64 0
%1188 = load i32, i32* %1187
%1189 = add nsw i32 %1188, 2
%1190 = sext i32 %1189 to i64
%1191 = getelementptr inbounds float, float* %1185, i64 %1190
store float %1180, float* %1191
br label %1192
1192: ; preds = %1099
%1193 = load i32, i32* %38
%1194 = add nsw i32 %1193, 1
store i32 %1194, i32* %38
br label %1092
1195: ; preds = %1092
br label %1196
1196: ; preds = %1195, %1083
ret void
}

LLVM IR (-O2):
define void @acd_2d_4_d_d(float** nocapture %0, float** nocapture %1, float** nocapture %2, float** nocapture %3, float** nocapture %4, float** nocapture %5, float** nocapture %6, float** nocapture %7, float** nocapture %8, float** nocapture %9, float** nocapture %10, i32* nocapture %11, i32* nocapture %12, float %13, float* nocapture %14, float* nocapture %15, i32* nocapture %16, i32* nocapture %17) {
%19 = getelementptr inbounds i32, i32* %11, i64 1
%20 = load i32, i32* %19
%21 = getelementptr inbounds i32, i32* %12, i64 1
%22 = load i32, i32* %21
%23 = icmp sgt i32 %20, %22
br i1 %23, label %287, label %24
24: ; preds = %18
%25 = load i32, i32* %11
%26 = load i32, i32* %12
%27 = icmp sgt i32 %25, %26
%28 = getelementptr inbounds float, float* %14, i64 1
%29 = getelementptr inbounds float, float* %15, i64 1
%30 = sext i32 %25 to i64
%31 = add i32 %26, 1
%32 = sext i32 %20 to i64
%33 = add i32 %22, 1
br label %34
34: ; preds = %24, %283
%35 = phi i64 [ %32, %24 ], [ %284, %283 ]
br i1 %27, label %36, label %38
36: ; preds = %34
%37 = add nsw i64 %35, 1
br label %283
38: ; preds = %34
%39 = getelementptr inbounds float*, float** %0, i64 %35
%40 = load float*, float** %39
%41 = add nsw i64 %35, 1
%42 = getelementptr inbounds float*, float** %0, i64 %41
%43 = load float*, float** %42
%44 = add nsw i64 %35, -1
%45 = getelementptr inbounds float*, float** %0, i64 %44
%46 = load float*, float** %45
%47 = add nsw i64 %35, 2
%48 = getelementptr inbounds float*, float** %0, i64 %47
%49 = load float*, float** %48
%50 = add nsw i64 %35, -2
%51 = getelementptr inbounds float*, float** %0, i64 %50
%52 = load float*, float** %51
%53 = getelementptr inbounds float*, float** %1, i64 %35
%54 = load float*, float** %53
%55 = getelementptr inbounds float*, float** %1, i64 %41
%56 = load float*, float** %55
%57 = getelementptr inbounds float*, float** %1, i64 %44
%58 = load float*, float** %57
%59 = getelementptr inbounds float*, float** %1, i64 %47
%60 = load float*, float** %59
%61 = getelementptr inbounds float*, float** %1, i64 %50
%62 = load float*, float** %61
%63 = getelementptr inbounds float*, float** %2, i64 %35
%64 = load float*, float** %63
%65 = getelementptr inbounds float*, float** %2, i64 %41
%66 = load float*, float** %65
%67 = getelementptr inbounds float*, float** %2, i64 %44
%68 = load float*, float** %67
%69 = getelementptr inbounds float*, float** %2, i64 %47
%70 = load float*, float** %69
%71 = getelementptr inbounds float*, float** %2, i64 %50
%72 = load float*, float** %71
%73 = getelementptr inbounds float*, float** %3, i64 %35
%74 = load float*, float** %73
%75 = getelementptr inbounds float*, float** %3, i64 %41
%76 = load float*, float** %75
%77 = getelementptr inbounds float*, float** %3, i64 %44
%78 = load float*, float** %77
%79 = getelementptr inbounds float*, float** %3, i64 %47
%80 = load float*, float** %79
%81 = getelementptr inbounds float*, float** %3, i64 %50
%82 = load float*, float** %81
%83 = getelementptr inbounds float*, float** %7, i64 %35
%84 = load float*, float** %83
%85 = getelementptr inbounds float*, float** %10, i64 %35
%86 = load float*, float** %85
%87 = getelementptr inbounds float*, float** %9, i64 %35
%88 = load float*, float** %87
%89 = getelementptr inbounds float*, float** %8, i64 %35
%90 = load float*, float** %89
%91 = getelementptr inbounds float*, float** %6, i64 %35
%92 = load float*, float** %91
%93 = getelementptr inbounds float*, float** %5, i64 %35
%94 = load float*, float** %93
%95 = getelementptr inbounds float*, float** %4, i64 %35
%96 = load float*, float** %95
br label %97
97: ; preds = %38, %97
%98 = phi i64 [ %30, %38 ], [ %102, %97 ]
%99 = getelementptr inbounds float, float* %40, i64 %98
%100 = load float, float* %99
%101 = load float, float* %14
%102 = add nsw i64 %98, 1
%103 = getelementptr inbounds float, float* %40, i64 %102
%104 = load float, float* %103
%105 = add nsw i64 %98, -1
%106 = getelementptr inbounds float, float* %40, i64 %105
%107 = load float, float* %106
%108 = fadd float %104, %107
%109 = fmul float %101, %108
%110 = tail call float @llvm.fmuladd.f32(float %13, float %100, float %109)
%111 = load float, float* %28
%112 = getelementptr inbounds float, float* %43, i64 %98
%113 = load float, float* %112
%114 = getelementptr inbounds float, float* %46, i64 %98
%115 = load float, float* %114
%116 = fadd float %113, %115
%117 = tail call float @llvm.fmuladd.f32(float %111, float %116, float %110)
%118 = load float, float* %15
%119 = add nsw i64 %98, 2
%120 = getelementptr inbounds float, float* %40, i64 %119
%121 = load float, float* %120
%122 = add nsw i64 %98, -2
%123 = getelementptr inbounds float, float* %40, i64 %122
%124 = load float, float* %123
%125 = fadd float %121, %124
%126 = tail call float @llvm.fmuladd.f32(float %118, float %125, float %117)
%127 = load float, float* %29
%128 = getelementptr inbounds float, float* %49, i64 %98
%129 = load float, float* %128
%130 = getelementptr inbounds float, float* %52, i64 %98
%131 = load float, float* %130
%132 = fadd float %129, %131
%133 = tail call float @llvm.fmuladd.f32(float %127, float %132, float %126)
%134 = getelementptr inbounds float, float* %54, i64 %98
%135 = load float, float* %134
%136 = getelementptr inbounds float, float* %54, i64 %102
%137 = load float, float* %136
%138 = getelementptr inbounds float, float* %54, i64 %105
%139 = load float, float* %138
%140 = fadd float %137, %139
%141 = fmul float %101, %140
%142 = tail call float @llvm.fmuladd.f32(float %13, float %135, float %141)
%143 = getelementptr inbounds float, float* %56, i64 %98
%144 = load float, float* %143
%145 = getelementptr inbounds float, float* %58, i64 %98
%146 = load float, float* %145
%147 = fadd float %144, %146
%148 = tail call float @llvm.fmuladd.f32(float %111, float %147, float %142)
%149 = getelementptr inbounds float, float* %54, i64 %119
%150 = load float, float* %149
%151 = getelementptr inbounds float, float* %54, i64 %122
%152 = load float, float* %151
%153 = fadd float %150, %152
%154 = tail call float @llvm.fmuladd.f32(float %118, float %153, float %148)
%155 = getelementptr inbounds float, float* %60, i64 %98
%156 = load float, float* %155
%157 = getelementptr inbounds float, float* %62, i64 %98
%158 = load float, float* %157
%159 = fadd float %156, %158
%160 = tail call float @llvm.fmuladd.f32(float %127, float %159, float %154)
%161 = getelementptr inbounds float, float* %64, i64 %98
%162 = load float, float* %161
%163 = getelementptr inbounds float, float* %64, i64 %102
%164 = load float, float* %163
%165 = getelementptr inbounds float, float* %64, i64 %105
%166 = load float, float* %165
%167 = fadd float %164, %166
%168 = fmul float %101, %167
%169 = tail call float @llvm.fmuladd.f32(float %13, float %162, float %168)
%170 = getelementptr inbounds float, float* %66, i64 %98
%171 = load float, float* %170
%172 = getelementptr inbounds float, float* %68, i64 %98
%173 = load float, float* %172
%174 = fadd float %171, %173
%175 = tail call float @llvm.fmuladd.f32(float %111, float %174, float %169)
%176 = getelementptr inbounds float, float* %64, i64 %119
%177 = load float, float* %176
%178 = getelementptr inbounds float, float* %64, i64 %122
%179 = load float, float* %178
%180 = fadd float %177, %179
%181 = tail call float @llvm.fmuladd.f32(float %118, float %180, float %175)
%182 = getelementptr inbounds float, float* %70, i64 %98
%183 = load float, float* %182
%184 = getelementptr inbounds float, float* %72, i64 %98
%185 = load float, float* %184
%186 = fadd float %183, %185
%187 = tail call float @llvm.fmuladd.f32(float %127, float %186, float %181)
%188 = getelementptr inbounds float, float* %74, i64 %98
%189 = load float, float* %188
%190 = getelementptr inbounds float, float* %74, i64 %102
%191 = load float, float* %190
%192 = getelementptr inbounds float, float* %74, i64 %105
%193 = load float, float* %192
%194 = fadd float %191, %193
%195 = fmul float %101, %194
%196 = tail call float @llvm.fmuladd.f32(float %13, float %189, float %195)
%197 = getelementptr inbounds float, float* %76, i64 %98
%198 = load float, float* %197
%199 = getelementptr inbounds float, float* %78, i64 %98
%200 = load float, float* %199
%201 = fadd float %198, %200
%202 = tail call float @llvm.fmuladd.f32(float %111, float %201, float %196)
%203 = getelementptr inbounds float, float* %74, i64 %119
%204 = load float, float* %203
%205 = getelementptr inbounds float, float* %74, i64 %122
%206 = load float, float* %205
%207 = fadd float %204, %206
%208 = tail call float @llvm.fmuladd.f32(float %118, float %207, float %202)
%209 = getelementptr inbounds float, float* %80, i64 %98
%210 = load float, float* %209
%211 = getelementptr inbounds float, float* %82, i64 %98
%212 = load float, float* %211
%213 = fadd float %210, %212
%214 = tail call float @llvm.fmuladd.f32(float %127, float %213, float %208)
%215 = fpext float %189 to double
%216 = getelementptr inbounds float, float* %84, i64 %98
%217 = load float, float* %216
%218 = fpext float %217 to double
%219 = fneg double %218
%220 = tail call double @llvm.fmuladd.f64(double %215, double 2.000000e+00, double %219)
%221 = getelementptr inbounds float, float* %86, i64 %98
%222 = load float, float* %221
%223 = fmul float %160, %222
%224 = fpext float %223 to double
%225 = fadd double %220, %224
%226 = getelementptr inbounds float, float* %88, i64 %98
%227 = load float, float* %226
%228 = fmul float %187, %227
%229 = fpext float %228 to double
%230 = fadd double %225, %229
%231 = getelementptr inbounds float, float* %90, i64 %98
%232 = load float, float* %231
%233 = fmul float %214, %232
%234 = fpext float %233 to double
%235 = fadd double %230, %234
%236 = fptrunc double %235 to float
store float %236, float* %216
%237 = load float, float* %161
%238 = fpext float %237 to double
%239 = getelementptr inbounds float, float* %92, i64 %98
%240 = load float, float* %239
%241 = fpext float %240 to double
%242 = fneg double %241
%243 = tail call double @llvm.fmuladd.f64(double %238, double 2.000000e+00, double %242)
%244 = load float, float* %221
%245 = fmul float %133, %244
%246 = fpext float %245 to double
%247 = fadd double %243, %246
%248 = load float, float* %231
%249 = fmul float %187, %248
%250 = fpext float %249 to double
%251 = fadd double %247, %250
%252 = fptrunc double %251 to float
store float %252, float* %239
%253 = load float, float* %134
%254 = fpext float %253 to double
%255 = getelementptr inbounds float, float* %94, i64 %98
%256 = load float, float* %255
%257 = fpext float %256 to double
%258 = fneg double %257
%259 = tail call double @llvm.fmuladd.f64(double %254, double 2.000000e+00, double %258)
%260 = load float, float* %226
%261 = fmul float %133, %260
%262 = fpext float %261 to double
%263 = fadd double %259, %262
%264 = load float, float* %231
%265 = fmul float %160, %264
%266 = fpext float %265 to double
%267 = fadd double %263, %266
%268 = fptrunc double %267 to float
store float %268, float* %255
%269 = load float, float* %99
%270 = fpext float %269 to double
%271 = getelementptr inbounds float, float* %96, i64 %98
%272 = load float, float* %271
%273 = fpext float %272 to double
%274 = fneg double %273
%275 = tail call double @llvm.fmuladd.f64(double %270, double 2.000000e+00, double %274)
%276 = load float, float* %231
%277 = fmul float %133, %276
%278 = fpext float %277 to double
%279 = fadd double %275, %278
%280 = fptrunc double %279 to float
store float %280, float* %271
%281 = trunc i64 %102 to i32
%282 = icmp eq i32 %31, %281
br i1 %282, label %283, label %97
283: ; preds = %97, %36
%284 = phi i64 [ %37, %36 ], [ %41, %97 ]
%285 = trunc i64 %284 to i32
%286 = icmp eq i32 %33, %285
br i1 %286, label %287, label %34
287: ; preds = %283, %18
%288 = getelementptr inbounds i32, i32* %16, i64 1
%289 = load i32, i32* %288
%290 = icmp eq i32 %289, 0
br i1 %290, label %338, label %291
291: ; preds = %287
%292 = load i32, i32* %11
%293 = load i32, i32* %12
%294 = icmp sgt i32 %292, %293
br i1 %294, label %338, label %295
295: ; preds = %291
%296 = sext i32 %20 to i64
%297 = getelementptr inbounds float*, float** %7, i64 %296
%298 = load float*, float** %297
%299 = add nsw i32 %20, -2
%300 = sext i32 %299 to i64
%301 = getelementptr inbounds float*, float** %7, i64 %300
%302 = load float*, float** %301
%303 = getelementptr inbounds float*, float** %6, i64 %296
%304 = load float*, float** %303
%305 = getelementptr inbounds float*, float** %6, i64 %300
%306 = load float*, float** %305
%307 = getelementptr inbounds float*, float** %5, i64 %296
%308 = load float*, float** %307
%309 = getelementptr inbounds float*, float** %5, i64 %300
%310 = load float*, float** %309
%311 = getelementptr inbounds float*, float** %4, i64 %296
%312 = load float*, float** %311
%313 = getelementptr inbounds float*, float** %4, i64 %300
%314 = load float*, float** %313
%315 = sext i32 %292 to i64
%316 = add i32 %293, 1
br label %317
317: ; preds = %295, %317
%318 = phi i64 [ %315, %295 ], [ %335, %317 ]
%319 = getelementptr inbounds float, float* %298, i64 %318
%320 = load float, float* %319
%321 = fneg float %320
%322 = getelementptr inbounds float, float* %302, i64 %318
store float %321, float* %322
%323 = getelementptr inbounds float, float* %304, i64 %318
%324 = load float, float* %323
%325 = fneg float %324
%326 = getelementptr inbounds float, float* %306, i64 %318
store float %325, float* %326
%327 = getelementptr inbounds float, float* %308, i64 %318
%328 = load float, float* %327
%329 = fneg float %328
%330 = getelementptr inbounds float, float* %310, i64 %318
store float %329, float* %330
%331 = getelementptr inbounds float, float* %312, i64 %318
%332 = load float, float* %331
%333 = fneg float %332
%334 = getelementptr inbounds float, float* %314, i64 %318
store float %333, float* %334
%335 = add nsw i64 %318, 1
%336 = trunc i64 %335 to i32
%337 = icmp eq i32 %316, %336
br i1 %337, label %338, label %317
338: ; preds = %317, %291, %287
%339 = getelementptr inbounds i32, i32* %17, i64 1
%340 = load i32, i32* %339
%341 = icmp eq i32 %340, 0
br i1 %341, label %389, label %342
342: ; preds = %338
%343 = load i32, i32* %11
%344 = load i32, i32* %12
%345 = icmp sgt i32 %343, %344
br i1 %345, label %389, label %346
346: ; preds = %342
%347 = sext i32 %22 to i64
%348 = getelementptr inbounds float*, float** %7, i64 %347
%349 = load float*, float** %348
%350 = add nsw i32 %22, 2
%351 = sext i32 %350 to i64
%352 = getelementptr inbounds float*, float** %7, i64 %351
%353 = load float*, float** %352
%354 = getelementptr inbounds float*, float** %6, i64 %347
%355 = load float*, float** %354
%356 = getelementptr inbounds float*, float** %6, i64 %351
%357 = load float*, float** %356
%358 = getelementptr inbounds float*, float** %5, i64 %347
%359 = load float*, float** %358
%360 = getelementptr inbounds float*, float** %5, i64 %351
%361 = load float*, float** %360
%362 = getelementptr inbounds float*, float** %4, i64 %347
%363 = load float*, float** %362
%364 = getelementptr inbounds float*, float** %4, i64 %351
%365 = load float*, float** %364
%366 = sext i32 %343 to i64
%367 = add i32 %344, 1
br label %368
368: ; preds = %346, %368
%369 = phi i64 [ %366, %346 ], [ %386, %368 ]
%370 = getelementptr inbounds float, float* %349, i64 %369
%371 = load float, float* %370
%372 = fneg float %371
%373 = getelementptr inbounds float, float* %353, i64 %369
store float %372, float* %373
%374 = getelementptr inbounds float, float* %355, i64 %369
%375 = load float, float* %374
%376 = fneg float %375
%377 = getelementptr inbounds float, float* %357, i64 %369
store float %376, float* %377
%378 = getelementptr inbounds float, float* %359, i64 %369
%379 = load float, float* %378
%380 = fneg float %379
%381 = getelementptr inbounds float, float* %361, i64 %369
store float %380, float* %381
%382 = getelementptr inbounds float, float* %363, i64 %369
%383 = load float, float* %382
%384 = fneg float %383
%385 = getelementptr inbounds float, float* %365, i64 %369
store float %384, float* %385
%386 = add nsw i64 %369, 1
%387 = trunc i64 %386 to i32
%388 = icmp eq i32 %367, %387
br i1 %388, label %389, label %368
389: ; preds = %368, %342, %338
%390 = load i32, i32* %16
%391 = icmp eq i32 %390, 0
%392 = select i1 %391, i1 true, i1 %23
br i1 %392, label %429, label %393
393: ; preds = %389
%394 = load i32, i32* %11
%395 = sext i32 %394 to i64
%396 = add nsw i32 %394, -2
%397 = sext i32 %396 to i64
%398 = sext i32 %20 to i64
%399 = add i32 %22, 1
br label %400
400: ; preds = %393, %400
%401 = phi i64 [ %398, %393 ], [ %426, %400 ]
%402 = getelementptr inbounds float*, float** %7, i64 %401
%403 = load float*, float** %402
%404 = getelementptr inbounds float, float* %403, i64 %395
%405 = load float, float* %404
%406 = fneg float %405
%407 = getelementptr inbounds float, float* %403, i64 %397
store float %406, float* %407
%408 = getelementptr inbounds float*, float** %6, i64 %401
%409 = load float*, float** %408
%410 = getelementptr inbounds float, float* %409, i64 %395
%411 = load float, float* %410
%412 = fneg float %411
%413 = getelementptr inbounds float, float* %409, i64 %397
store float %412, float* %413
%414 = getelementptr inbounds float*, float** %5, i64 %401
%415 = load float*, float** %414
%416 = getelementptr inbounds float, float* %415, i64 %395
%417 = load float, float* %416
%418 = fneg float %417
%419 = getelementptr inbounds float, float* %415, i64 %397
store float %418, float* %419
%420 = getelementptr inbounds float*, float** %4, i64 %401
%421 = load float*, float** %420
%422 = getelementptr inbounds float, float* %421, i64 %395
%423 = load float, float* %422
%424 = fneg float %423
%425 = getelementptr inbounds float, float* %421, i64 %397
store float %424, float* %425
%426 = add nsw i64 %401, 1
%427 = trunc i64 %426 to i32
%428 = icmp eq i32 %399, %427
br i1 %428, label %429, label %400
429: ; preds = %400, %389
%430 = load i32, i32* %17
%431 = icmp eq i32 %430, 0
%432 = select i1 %431, i1 true, i1 %23
br i1 %432, label %469, label %433
433: ; preds = %429
%434 = load i32, i32* %12
%435 = sext i32 %434 to i64
%436 = add nsw i32 %434, 2
%437 = sext i32 %436 to i64
%438 = sext i32 %20 to i64
%439 = add i32 %22, 1
br label %440
440: ; preds = %433, %440
%441 = phi i64 [ %438, %433 ], [ %466, %440 ]
%442 = getelementptr inbounds float*, float** %7, i64 %441
%443 = load float*, float** %442
%444 = getelementptr inbounds float, float* %443, i64 %435
%445 = load float, float* %444
%446 = fneg float %445
%447 = getelementptr inbounds float, float* %443, i64 %437
store float %446, float* %447
%448 = getelementptr inbounds float*, float** %6, i64 %441
%449 = load float*, float** %448
%450 = getelementptr inbounds float, float* %449, i64 %435
%451 = load float, float* %450
%452 = fneg float %451
%453 = getelementptr inbounds float, float* %449, i64 %437
store float %452, float* %453
%454 = getelementptr inbounds float*, float** %5, i64 %441
%455 = load float*, float** %454
%456 = getelementptr inbounds float, float* %455, i64 %435
%457 = load float, float* %456
%458 = fneg float %457
%459 = getelementptr inbounds float, float* %455, i64 %437
store float %458, float* %459
%460 = getelementptr inbounds float*, float** %4, i64 %441
%461 = load float*, float** %460
%462 = getelementptr inbounds float, float* %461, i64 %435
%463 = load float, float* %462
%464 = fneg float %463
%465 = getelementptr inbounds float, float* %461, i64 %437
store float %464, float* %465
%466 = add nsw i64 %441, 1
%467 = trunc i64 %466 to i32
%468 = icmp eq i32 %439, %467
br i1 %468, label %469, label %440
469: ; preds = %440, %429
ret void
}