void acd_2d_8_d(float **uc, float **ucd, float **up, float **upd, float **csq,
                float **csqd, int *s, int *e, float c0, float *c1, float *c2,
                float *c3, float *c4, int *lbc, int *rbc) {
  int i0, i1;
  for (i1 = s[1]; i1 < e[1] + 1; ++i1)
#pragma ivdep
    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]) +
                   c3[0] * (uc[i1][i0 + 3] + uc[i1][i0 - 3]) +
                   c3[1] * (uc[i1 + 3][i0] + uc[i1 - 3][i0]) +
                   c4[0] * (uc[i1][i0 + 4] + uc[i1][i0 - 4]) +
                   c4[1] * (uc[i1 + 4][i0] + uc[i1 - 4][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]) +
           c3[0] * (ucd[i1][i0 + 3] + ucd[i1][i0 - 3]) +
           c3[1] * (ucd[i1 + 3][i0] + ucd[i1 - 3][i0]) +
           c4[0] * (ucd[i1][i0 + 4] + ucd[i1][i0 - 4]) +
           c4[1] * (ucd[i1 + 4][i0] + ucd[i1 - 4][i0]));
      upd[i1][i0] = 2.0 * ucd[i1][i0] - upd[i1][i0] + csqd[i1][i0] * lap +
                    csq[i1][i0] * lapd;
      up[i1][i0] = 2.0 * uc[i1][i0] - up[i1][i0] + csq[i1][i0] * lap;
    }
  if (lbc[1])
#pragma ivdep
    for (i0 = s[0]; i0 < e[0] + 1; ++i0) {
      upd[s[1] - 2][i0] = -upd[s[1] + 0][i0];
      up[s[1] - 2][i0] = -up[s[1] + 0][i0];
      upd[s[1] - 3][i0] = -upd[s[1] + 1][i0];
      up[s[1] - 3][i0] = -up[s[1] + 1][i0];
      upd[s[1] - 4][i0] = -upd[s[1] + 2][i0];
      up[s[1] - 4][i0] = -up[s[1] + 2][i0];
    }
  if (rbc[1])
#pragma ivdep
    for (i0 = s[0]; i0 < e[0] + 1; ++i0) {
      upd[e[1] + 2][i0] = -upd[e[1] - 0][i0];
      up[e[1] + 2][i0] = -up[e[1] - 0][i0];
      upd[e[1] + 3][i0] = -upd[e[1] - 1][i0];
      up[e[1] + 3][i0] = -up[e[1] - 1][i0];
      upd[e[1] + 4][i0] = -upd[e[1] - 2][i0];
      up[e[1] + 4][i0] = -up[e[1] - 2][i0];
    }
  if (lbc[0])
#pragma ivdep
    for (i1 = s[1]; i1 < e[1] + 1; ++i1) {
      upd[i1][s[0] - 2] = -upd[i1][s[0] + 0];
      up[i1][s[0] - 2] = -up[i1][s[0] + 0];
      upd[i1][s[0] - 3] = -upd[i1][s[0] + 1];
      up[i1][s[0] - 3] = -up[i1][s[0] + 1];
      upd[i1][s[0] - 4] = -upd[i1][s[0] + 2];
      up[i1][s[0] - 4] = -up[i1][s[0] + 2];
    }
  if (rbc[0])
#pragma ivdep
    for (i1 = s[1]; i1 < e[1] + 1; ++i1) {
      upd[i1][e[0] + 2] = -upd[i1][e[0] - 0];
      up[i1][e[0] + 2] = -up[i1][e[0] - 0];
      upd[i1][e[0] + 3] = -upd[i1][e[0] - 1];
      up[i1][e[0] + 3] = -up[i1][e[0] - 1];
      upd[i1][e[0] + 4] = -upd[i1][e[0] - 2];
      up[i1][e[0] + 4] = -up[i1][e[0] - 2];
    }
}


x86 assembly (clang, -O0):
<acd_2d_8_d>:
push   %rbp
mov    %rsp,%rbp
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    0x10(%rbp),%rax
mov    0x4(%rax),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    0x18(%rbp),%rcx
mov    0x4(%rcx),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1766 <acd_2d_8_d+0x666>
mov    0x10(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    0x18(%rbp),%rcx
mov    (%rcx),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1753 <acd_2d_8_d+0x653>
movss  -0x34(%rbp),%xmm1
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    0x20(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm3
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm3
mulss  %xmm3,%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    0x20(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    0x28(%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    0x28(%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
mov    0x30(%rbp),%rax
movss  (%rax),%xmm1
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
add    $0x3,%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    $0x3,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    0x30(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x3,%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    $0x3,%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    0x38(%rbp),%rax
movss  (%rax),%xmm1
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
add    $0x4,%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    $0x4,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    0x38(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x4,%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    $0x4,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x34(%rbp),%xmm1
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    0x20(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm3
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm3
mulss  %xmm3,%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    0x20(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    0x28(%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    0x28(%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
mov    0x30(%rbp),%rax
movss  (%rax),%xmm1
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
add    $0x3,%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    $0x3,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    0x30(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x3,%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    $0x3,%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    0x38(%rbp),%rax
movss  (%rax),%xmm1
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
add    $0x4,%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    $0x4,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    0x38(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x4,%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    $0x4,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
addsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  -0x40(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  -0x44(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
addsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  -0x40(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1169 <acd_2d_8_d+0x69>
jmp    1758 <acd_2d_8_d+0x658>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    114b <acd_2d_8_d+0x4b>
mov    0x40(%rbp),%rax
cmpl   $0x0,0x4(%rax)
je     195a <acd_2d_8_d+0x85a>
mov    0x10(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    0x18(%rbp),%rcx
mov    (%rcx),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1955 <acd_2d_8_d+0x855>
mov    -0x20(%rbp),%rax
mov    0x10(%rbp),%rcx
mov    0x4(%rcx),%ecx
add    $0x0,%ecx
movslq %ecx,%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    -0x20(%rbp),%rax
mov    0x10(%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    -0x18(%rbp),%rax
mov    0x10(%rbp),%rcx
mov    0x4(%rcx),%ecx
add    $0x0,%ecx
movslq %ecx,%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    0x10(%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    -0x20(%rbp),%rax
mov    0x10(%rbp),%rcx
mov    0x4(%rcx),%ecx
add    $0x1,%ecx
movslq %ecx,%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    -0x20(%rbp),%rax
mov    0x10(%rbp),%rcx
mov    0x4(%rcx),%ecx
sub    $0x3,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    0x10(%rbp),%rcx
mov    0x4(%rcx),%ecx
add    $0x1,%ecx
movslq %ecx,%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    0x10(%rbp),%rcx
mov    0x4(%rcx),%ecx
sub    $0x3,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
mov    0x10(%rbp),%rcx
mov    0x4(%rcx),%ecx
add    $0x2,%ecx
movslq %ecx,%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    -0x20(%rbp),%rax
mov    0x10(%rbp),%rcx
mov    0x4(%rcx),%ecx
sub    $0x4,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    0x10(%rbp),%rcx
mov    0x4(%rcx),%ecx
add    $0x2,%ecx
movslq %ecx,%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    0x10(%rbp),%rcx
mov    0x4(%rcx),%ecx
sub    $0x4,%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    177d <acd_2d_8_d+0x67d>
jmp    195a <acd_2d_8_d+0x85a>
mov    0x48(%rbp),%rax
cmpl   $0x0,0x4(%rax)
je     1b4e <acd_2d_8_d+0xa4e>
mov    0x10(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    0x18(%rbp),%rcx
mov    (%rcx),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1b49 <acd_2d_8_d+0xa49>
mov    -0x20(%rbp),%rax
mov    0x18(%rbp),%rcx
mov    0x4(%rcx),%ecx
sub    $0x0,%ecx
movslq %ecx,%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    -0x20(%rbp),%rax
mov    0x18(%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    -0x18(%rbp),%rax
mov    0x18(%rbp),%rcx
mov    0x4(%rcx),%ecx
sub    $0x0,%ecx
movslq %ecx,%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    0x18(%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    -0x20(%rbp),%rax
mov    0x18(%rbp),%rcx
mov    0x4(%rcx),%ecx
sub    $0x1,%ecx
movslq %ecx,%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    -0x20(%rbp),%rax
mov    0x18(%rbp),%rcx
mov    0x4(%rcx),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    0x18(%rbp),%rcx
mov    0x4(%rcx),%ecx
sub    $0x1,%ecx
movslq %ecx,%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    0x18(%rbp),%rcx
mov    0x4(%rcx),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
mov    0x18(%rbp),%rcx
mov    0x4(%rcx),%ecx
sub    $0x2,%ecx
movslq %ecx,%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    -0x20(%rbp),%rax
mov    0x18(%rbp),%rcx
mov    0x4(%rcx),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    0x18(%rbp),%rcx
mov    0x4(%rcx),%ecx
sub    $0x2,%ecx
movslq %ecx,%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    0x18(%rbp),%rcx
mov    0x4(%rcx),%ecx
add    $0x4,%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    1971 <acd_2d_8_d+0x871>
jmp    1b4e <acd_2d_8_d+0xa4e>
mov    0x40(%rbp),%rax
cmpl   $0x0,(%rax)
je     1d37 <acd_2d_8_d+0xc37>
mov    0x10(%rbp),%rax
mov    0x4(%rax),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    0x18(%rbp),%rcx
mov    0x4(%rcx),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1d32 <acd_2d_8_d+0xc32>
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x10(%rbp),%rcx
mov    (%rcx),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x10(%rbp),%rcx
mov    (%rcx),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x10(%rbp),%rcx
mov    (%rcx),%ecx
add    $0x0,%ecx
movslq %ecx,%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    0x10(%rbp),%rcx
mov    (%rcx),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x10(%rbp),%rcx
mov    (%rcx),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x10(%rbp),%rcx
mov    (%rcx),%ecx
sub    $0x3,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x10(%rbp),%rcx
mov    (%rcx),%ecx
add    $0x1,%ecx
movslq %ecx,%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    0x10(%rbp),%rcx
mov    (%rcx),%ecx
sub    $0x3,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x10(%rbp),%rcx
mov    (%rcx),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x10(%rbp),%rcx
mov    (%rcx),%ecx
sub    $0x4,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x10(%rbp),%rcx
mov    (%rcx),%ecx
add    $0x2,%ecx
movslq %ecx,%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    0x10(%rbp),%rcx
mov    (%rcx),%ecx
sub    $0x4,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1b65 <acd_2d_8_d+0xa65>
jmp    1d37 <acd_2d_8_d+0xc37>
mov    0x48(%rbp),%rax
cmpl   $0x0,(%rax)
je     1f20 <acd_2d_8_d+0xe20>
mov    0x10(%rbp),%rax
mov    0x4(%rax),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    0x18(%rbp),%rcx
mov    0x4(%rcx),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1f1b <acd_2d_8_d+0xe1b>
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x18(%rbp),%rcx
mov    (%rcx),%ecx
sub    $0x0,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x18(%rbp),%rcx
mov    (%rcx),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x18(%rbp),%rcx
mov    (%rcx),%ecx
sub    $0x0,%ecx
movslq %ecx,%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    0x18(%rbp),%rcx
mov    (%rcx),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x18(%rbp),%rcx
mov    (%rcx),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x18(%rbp),%rcx
mov    (%rcx),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x18(%rbp),%rcx
mov    (%rcx),%ecx
sub    $0x1,%ecx
movslq %ecx,%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    0x18(%rbp),%rcx
mov    (%rcx),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x18(%rbp),%rcx
mov    (%rcx),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x18(%rbp),%rcx
mov    (%rcx),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x18(%rbp),%rcx
mov    (%rcx),%ecx
sub    $0x2,%ecx
movslq %ecx,%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    0x18(%rbp),%rcx
mov    (%rcx),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1d4e <acd_2d_8_d+0xc4e>
jmp    1f20 <acd_2d_8_d+0xe20>
pop    %rbp
ret

x86 assembly (clang, -O2):
<acd_2d_8_d>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x50,%rsp
mov    %r9,-0x30(%rsp)
mov    %r8,-0x38(%rsp)
mov    %rcx,-0x78(%rsp)
mov    %rdx,-0x70(%rsp)
mov    %rsi,-0x40(%rsp)
mov    %rdi,-0x48(%rsp)
mov    0x90(%rsp),%rax
mov    0x88(%rsp),%rcx
movslq 0x4(%rcx),%rcx
movslq 0x4(%rax),%rax
mov    %rcx,-0x80(%rsp)
cmp    %eax,%ecx
mov    %rax,-0x58(%rsp)
jg     1556 <acd_2d_8_d+0x456>
mov    0xa8(%rsp),%rbx
mov    0xa0(%rsp),%rbp
mov    0x98(%rsp),%r10
mov    0x88(%rsp),%rcx
movslq (%rcx),%rdx
mov    0x90(%rsp),%rcx
mov    (%rcx),%ecx
add    $0x1,%eax
mov    %ecx,%r8d
sub    %edx,%r8d
add    $0x1,%r8d
mov    -0x80(%rsp),%rdi
mov    %rdx,-0x50(%rsp)
mov    %ecx,-0x5c(%rsp)
mov    %eax,-0x60(%rsp)
mov    %r8,-0x20(%rsp)
jmp    11bf <acd_2d_8_d+0xbf>
nopl   0x0(%rax)
add    $0x1,%rdi
mov    %rdi,%rsi
cmp    %esi,%eax
je     1556 <acd_2d_8_d+0x456>
cmp    %ecx,%edx
jg     11b0 <acd_2d_8_d+0xb0>
lea    0x0(,%rdx,4),%r12
mov    -0x48(%rsp),%rsi
mov    (%rsi,%rdi,8),%rdx
add    %r12,%rdx
mov    -0x40(%rsp),%r9
mov    (%r9,%rdi,8),%rcx
add    %r12,%rcx
mov    0x8(%rsi,%rdi,8),%rax
add    %r12,%rax
mov    %rax,-0x68(%rsp)
mov    -0x8(%rsi,%rdi,8),%rax
add    %r12,%rax
mov    %rax,0x48(%rsp)
mov    0x10(%rsi,%rdi,8),%rax
add    %r12,%rax
mov    %rax,0x40(%rsp)
mov    -0x10(%rsi,%rdi,8),%rax
add    %r12,%rax
mov    %rax,0x38(%rsp)
mov    0x18(%rsi,%rdi,8),%rax
add    %r12,%rax
mov    %rax,0x30(%rsp)
mov    -0x18(%rsi,%rdi,8),%rax
add    %r12,%rax
mov    %rax,0x28(%rsp)
mov    0x20(%rsi,%rdi,8),%rax
add    %r12,%rax
mov    %rax,0x20(%rsp)
mov    -0x20(%rsi,%rdi,8),%rax
add    %r12,%rax
mov    %rax,0x18(%rsp)
mov    0x8(%r9,%rdi,8),%rax
add    %r12,%rax
mov    %rax,0x10(%rsp)
mov    -0x8(%r9,%rdi,8),%rax
add    %r12,%rax
mov    %rax,0x8(%rsp)
mov    0x10(%r9,%rdi,8),%rax
add    %r12,%rax
mov    %rax,(%rsp)
mov    -0x10(%r9,%rdi,8),%rax
add    %r12,%rax
mov    %rax,-0x8(%rsp)
mov    0x18(%r9,%rdi,8),%rax
add    %r12,%rax
mov    %rax,-0x10(%rsp)
mov    -0x18(%r9,%rdi,8),%rax
add    %r12,%rax
mov    %rax,-0x18(%rsp)
mov    0x20(%r9,%rdi,8),%r15
add    %r12,%r15
mov    -0x20(%r9,%rdi,8),%r11
add    %r12,%r11
mov    -0x78(%rsp),%rax
mov    (%rax,%rdi,8),%r14
add    %r12,%r14
mov    -0x30(%rsp),%rax
mov    (%rax,%rdi,8),%r13
add    %r12,%r13
mov    -0x38(%rsp),%rax
mov    (%rax,%rdi,8),%r8
add    %r12,%r8
mov    -0x70(%rsp),%rax
add    (%rax,%rdi,8),%r12
mov    0xb0(%rsp),%rax
lea    0x1(%rdi),%rsi
mov    %rsi,-0x28(%rsp)
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
movss  0x4(%rdx,%rdi,4),%xmm2
movss  0x8(%rdx,%rdi,4),%xmm1
addss  -0x4(%rdx,%rdi,4),%xmm2
movss  (%r10),%xmm11
movss  0x4(%r10),%xmm8
mulss  %xmm11,%xmm2
movss  (%rdx,%rdi,4),%xmm3
mulss  %xmm0,%xmm3
mov    -0x68(%rsp),%r9
movss  (%r9,%rdi,4),%xmm4
mov    0x48(%rsp),%rsi
addss  (%rsi,%rdi,4),%xmm4
addss  %xmm2,%xmm3
mulss  %xmm8,%xmm4
addss  -0x8(%rdx,%rdi,4),%xmm1
addss  %xmm3,%xmm4
movss  0x0(%rbp),%xmm13
movss  0x4(%rbp),%xmm9
mulss  %xmm13,%xmm1
addss  %xmm4,%xmm1
mov    0x40(%rsp),%rsi
movss  (%rsi,%rdi,4),%xmm3
mov    0x38(%rsp),%rsi
addss  (%rsi,%rdi,4),%xmm3
mulss  %xmm9,%xmm3
movss  0xc(%rdx,%rdi,4),%xmm4
addss  -0xc(%rdx,%rdi,4),%xmm4
addss  %xmm1,%xmm3
movss  (%rbx),%xmm2
movss  0x4(%rbx),%xmm10
mulss  %xmm2,%xmm4
addss  %xmm3,%xmm4
mov    0x30(%rsp),%rsi
movss  (%rsi,%rdi,4),%xmm1
mov    0x28(%rsp),%rsi
addss  (%rsi,%rdi,4),%xmm1
mulss  %xmm10,%xmm1
movss  0x10(%rdx,%rdi,4),%xmm5
addss  -0x10(%rdx,%rdi,4),%xmm5
addss  %xmm4,%xmm1
movss  (%rax),%xmm3
movss  0x4(%rax),%xmm12
mulss  %xmm3,%xmm5
addss  %xmm1,%xmm5
mov    0x20(%rsp),%rsi
movss  (%rsi,%rdi,4),%xmm1
mov    0x18(%rsp),%rsi
addss  (%rsi,%rdi,4),%xmm1
mulss  %xmm12,%xmm1
addss  %xmm5,%xmm1
movss  (%rcx,%rdi,4),%xmm4
movss  0x4(%rcx,%rdi,4),%xmm5
addss  -0x4(%rcx,%rdi,4),%xmm5
mulss  %xmm11,%xmm5
movaps %xmm0,%xmm6
mulss  %xmm4,%xmm6
addss  %xmm5,%xmm6
mov    0x10(%rsp),%rsi
movss  (%rsi,%rdi,4),%xmm5
mov    0x8(%rsp),%rsi
addss  (%rsi,%rdi,4),%xmm5
mulss  %xmm8,%xmm5
movss  0x8(%rcx,%rdi,4),%xmm7
addss  -0x8(%rcx,%rdi,4),%xmm7
addss  %xmm6,%xmm5
mulss  %xmm13,%xmm7
addss  %xmm5,%xmm7
mov    (%rsp),%rsi
movss  (%rsi,%rdi,4),%xmm5
mov    -0x8(%rsp),%rsi
addss  (%rsi,%rdi,4),%xmm5
mulss  %xmm9,%xmm5
addss  %xmm7,%xmm5
movss  0xc(%rcx,%rdi,4),%xmm6
addss  -0xc(%rcx,%rdi,4),%xmm6
mulss  %xmm2,%xmm6
addss  %xmm5,%xmm6
mov    -0x10(%rsp),%rsi
movss  (%rsi,%rdi,4),%xmm2
mov    -0x18(%rsp),%rsi
addss  (%rsi,%rdi,4),%xmm2
mulss  %xmm10,%xmm2
movss  0x10(%rcx,%rdi,4),%xmm5
addss  -0x10(%rcx,%rdi,4),%xmm5
addss  %xmm6,%xmm2
mulss  %xmm3,%xmm5
addss  %xmm2,%xmm5
movss  (%r15,%rdi,4),%xmm2
addss  (%r11,%rdi,4),%xmm2
mulss  %xmm12,%xmm2
addss  %xmm5,%xmm2
xorps  %xmm3,%xmm3
cvtss2sd %xmm4,%xmm3
movss  (%r14,%rdi,4),%xmm4
cvtss2sd %xmm4,%xmm4
addsd  %xmm3,%xmm3
subsd  %xmm4,%xmm3
movss  0x0(%r13,%rdi,4),%xmm4
mulss  %xmm1,%xmm4
cvtss2sd %xmm4,%xmm4
addsd  %xmm3,%xmm4
mulss  (%r8,%rdi,4),%xmm2
cvtss2sd %xmm2,%xmm2
addsd  %xmm4,%xmm2
cvtsd2ss %xmm2,%xmm2
movss  %xmm2,(%r14,%rdi,4)
movss  (%rdx,%rdi,4),%xmm2
cvtss2sd %xmm2,%xmm2
movss  (%r12,%rdi,4),%xmm3
cvtss2sd %xmm3,%xmm3
addsd  %xmm2,%xmm2
subsd  %xmm3,%xmm2
mulss  (%r8,%rdi,4),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm2,%xmm1
cvtsd2ss %xmm1,%xmm1
movss  %xmm1,(%r12,%rdi,4)
add    $0x1,%rdi
cmp    %edi,-0x20(%rsp)
jne    12f0 <acd_2d_8_d+0x1f0>
mov    -0x28(%rsp),%rsi
mov    %rsi,%rdi
mov    -0x50(%rsp),%rdx
mov    -0x5c(%rsp),%ecx
mov    -0x60(%rsp),%eax
cmp    %esi,%eax
jne    11bf <acd_2d_8_d+0xbf>
mov    0xc0(%rsp),%r13
mov    0xb8(%rsp),%rax
cmpl   $0x0,0x4(%rax)
je     167e <acd_2d_8_d+0x57e>
mov    0x88(%rsp),%rax
movslq (%rax),%rcx
mov    0x90(%rsp),%rax
mov    (%rax),%r11d
cmp    %r11d,%ecx
jg     167e <acd_2d_8_d+0x57e>
mov    %rcx,%rdx
mov    %rcx,-0x68(%rsp)
shl    $0x2,%rdx
mov    -0x78(%rsp),%rax
mov    -0x80(%rsp),%r13
mov    (%rax,%r13,8),%r9
add    %rdx,%r9
mov    -0x10(%rax,%r13,8),%r10
add    %rdx,%r10
mov    -0x70(%rsp),%rsi
mov    (%rsi,%r13,8),%r14
add    %rdx,%r14
mov    -0x10(%rsi,%r13,8),%r15
add    %rdx,%r15
mov    0x8(%rax,%r13,8),%r12
add    %rdx,%r12
mov    -0x18(%rax,%r13,8),%r8
add    %rdx,%r8
mov    0x8(%rsi,%r13,8),%rdi
add    %rdx,%rdi
mov    -0x18(%rsi,%r13,8),%rcx
add    %rdx,%rcx
mov    0x10(%rax,%r13,8),%rbp
add    %rdx,%rbp
mov    -0x20(%rax,%r13,8),%rbx
add    %rdx,%rbx
mov    0x10(%rsi,%r13,8),%rax
add    %rdx,%rax
add    -0x20(%rsi,%r13,8),%rdx
mov    0xc0(%rsp),%r13
sub    -0x68(%rsp),%r11d
add    $0x1,%r11d
xor    %esi,%esi
movaps 0x9e1(%rip),%xmm0
nop
movss  (%r9,%rsi,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,(%r10,%rsi,4)
movss  (%r14,%rsi,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,(%r15,%rsi,4)
movss  (%r12,%rsi,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,(%r8,%rsi,4)
movss  (%rdi,%rsi,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,(%rcx,%rsi,4)
movss  0x0(%rbp,%rsi,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,(%rbx,%rsi,4)
movss  (%rax,%rsi,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,(%rdx,%rsi,4)
add    $0x1,%rsi
cmp    %esi,%r11d
jne    1620 <acd_2d_8_d+0x520>
cmpl   $0x0,0x4(%r13)
je     179e <acd_2d_8_d+0x69e>
mov    0x88(%rsp),%rax
movslq (%rax),%rcx
mov    0x90(%rsp),%rax
mov    (%rax),%r14d
cmp    %r14d,%ecx
jg     179e <acd_2d_8_d+0x69e>
mov    %rcx,%rdx
mov    %rcx,-0x68(%rsp)
shl    $0x2,%rdx
mov    -0x58(%rsp),%rsi
mov    -0x78(%rsp),%rax
mov    (%rax,%rsi,8),%r9
add    %rdx,%r9
mov    0x10(%rax,%rsi,8),%r10
add    %rdx,%r10
mov    -0x70(%rsp),%r13
mov    0x0(%r13,%rsi,8),%r11
add    %rdx,%r11
mov    0x10(%r13,%rsi,8),%r15
add    %rdx,%r15
mov    -0x8(%rax,%rsi,8),%r12
add    %rdx,%r12
mov    0x18(%rax,%rsi,8),%r8
add    %rdx,%r8
mov    -0x8(%r13,%rsi,8),%rdi
add    %rdx,%rdi
mov    0x18(%r13,%rsi,8),%rbp
add    %rdx,%rbp
mov    -0x10(%rax,%rsi,8),%rcx
add    %rdx,%rcx
mov    0x20(%rax,%rsi,8),%rbx
add    %rdx,%rbx
mov    -0x10(%r13,%rsi,8),%rax
add    %rdx,%rax
add    0x20(%r13,%rsi,8),%rdx
mov    0xc0(%rsp),%r13
sub    -0x68(%rsp),%r14d
add    $0x1,%r14d
xor    %esi,%esi
movaps 0x8c7(%rip),%xmm0
nopl   0x0(%rax)
movss  (%r9,%rsi,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,(%r10,%rsi,4)
movss  (%r11,%rsi,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,(%r15,%rsi,4)
movss  (%r12,%rsi,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,(%r8,%rsi,4)
movss  (%rdi,%rsi,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,0x0(%rbp,%rsi,4)
movss  (%rcx,%rsi,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,(%rbx,%rsi,4)
movss  (%rax,%rsi,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,(%rdx,%rsi,4)
add    $0x1,%rsi
cmp    %esi,%r14d
jne    1740 <acd_2d_8_d+0x640>
mov    0xb8(%rsp),%rax
cmpl   $0x0,(%rax)
mov    -0x58(%rsp),%r8
je     1869 <acd_2d_8_d+0x769>
cmp    %r8d,-0x80(%rsp)
jg     1869 <acd_2d_8_d+0x769>
mov    0x88(%rsp),%rax
movslq (%rax),%rax
mov    -0x78(%rsp),%rcx
mov    -0x80(%rsp),%rdi
lea    (%rcx,%rdi,8),%rcx
mov    -0x70(%rsp),%rdx
lea    (%rdx,%rdi,8),%rdx
mov    %r8d,%esi
sub    %edi,%esi
add    $0x1,%esi
xor    %edi,%edi
movaps 0x80e(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    (%rcx,%rdi,8),%rbp
movss  0x0(%rbp,%rax,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,-0x8(%rbp,%rax,4)
mov    (%rdx,%rdi,8),%rbx
movss  (%rbx,%rax,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,-0x8(%rbx,%rax,4)
movss  0x4(%rbp,%rax,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,-0xc(%rbp,%rax,4)
movss  0x4(%rbx,%rax,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,-0xc(%rbx,%rax,4)
movss  0x8(%rbp,%rax,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,-0x10(%rbp,%rax,4)
movss  0x8(%rbx,%rax,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,-0x10(%rbx,%rax,4)
add    $0x1,%rdi
cmp    %edi,%esi
jne    1800 <acd_2d_8_d+0x700>
cmpl   $0x0,0x0(%r13)
je     192a <acd_2d_8_d+0x82a>
cmp    %r8d,-0x80(%rsp)
jg     192a <acd_2d_8_d+0x82a>
mov    0x90(%rsp),%rax
movslq (%rax),%rax
mov    -0x78(%rsp),%rcx
mov    -0x80(%rsp),%rsi
lea    (%rcx,%rsi,8),%rcx
mov    -0x70(%rsp),%rdx
lea    (%rdx,%rsi,8),%rdx
sub    %esi,%r8d
add    $0x1,%r8d
xor    %esi,%esi
movaps 0x74f(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    (%rcx,%rsi,8),%rdi
movss  (%rdi,%rax,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,0x8(%rdi,%rax,4)
mov    (%rdx,%rsi,8),%rbp
movss  0x0(%rbp,%rax,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,0x8(%rbp,%rax,4)
movss  -0x4(%rdi,%rax,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,0xc(%rdi,%rax,4)
movss  -0x4(%rbp,%rax,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,0xc(%rbp,%rax,4)
movss  -0x8(%rdi,%rax,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,0x10(%rdi,%rax,4)
movss  -0x8(%rbp,%rax,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,0x10(%rbp,%rax,4)
add    $0x1,%rsi
cmp    %esi,%r8d
jne    18c0 <acd_2d_8_d+0x7c0>
add    $0x50,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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