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


x86 assembly (clang, -O0):
<acd_2d_8_d_d>:
push   %rbp
mov    %rsp,%rbp
mov    0x70(%rbp),%rax
mov    0x68(%rbp),%rax
mov    0x60(%rbp),%rax
mov    0x58(%rbp),%rax
mov    0x50(%rbp),%rax
mov    0x48(%rbp),%rax
mov    0x40(%rbp),%rax
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
movss  %xmm0,-0x34(%rbp)
mov    0x38(%rbp),%rax
mov    0x4(%rax),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    0x40(%rbp),%rcx
mov    0x4(%rcx),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1d86 <acd_2d_8_d_d+0xc86>
mov    0x38(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    0x40(%rbp),%rcx
mov    (%rcx),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1d73 <acd_2d_8_d_d+0xc73>
movss  -0x34(%rbp),%xmm1
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    0x48(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm3
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm3
mulss  %xmm3,%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    0x48(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    0x50(%rbp),%rax
movss  (%rax),%xmm1
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    0x50(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    0x58(%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    0x58(%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    0x60(%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    0x60(%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    0x48(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm3
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm3
mulss  %xmm3,%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    0x48(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    0x50(%rbp),%rax
movss  (%rax),%xmm1
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    0x50(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    0x58(%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    0x58(%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    0x60(%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    0x60(%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)
movss  -0x34(%rbp),%xmm1
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    0x48(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm3
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm3
mulss  %xmm3,%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    0x48(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    0x50(%rbp),%rax
movss  (%rax),%xmm1
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    0x50(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    0x58(%rbp),%rax
movss  (%rax),%xmm1
mov    -0x18(%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    -0x18(%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    0x58(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x18(%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    -0x18(%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    0x60(%rbp),%rax
movss  (%rax),%xmm1
mov    -0x18(%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    -0x18(%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    0x60(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x18(%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    -0x18(%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,-0x48(%rbp)
movss  -0x34(%rbp),%xmm1
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    0x48(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm3
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm3
mulss  %xmm3,%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    0x48(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    0x50(%rbp),%rax
movss  (%rax),%xmm1
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    0x50(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    0x58(%rbp),%rax
movss  (%rax),%xmm1
mov    -0x20(%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    -0x20(%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    0x58(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x20(%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    -0x20(%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    0x60(%rbp),%rax
movss  (%rax),%xmm1
mov    -0x20(%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    -0x20(%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    0x60(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x20(%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    -0x20(%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,-0x4c(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
addsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
mov    0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  -0x44(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm1,%xmm0
mov    0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  -0x48(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm1,%xmm0
mov    0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  -0x4c(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
addsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
mov    0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  -0x40(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm1,%xmm0
mov    0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  -0x48(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
addsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
mov    0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  -0x40(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm1,%xmm0
mov    0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  -0x44(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
addsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
mov    0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  -0x40(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    117d <acd_2d_8_d_d+0x7d>
jmp    1d78 <acd_2d_8_d_d+0xc78>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    115f <acd_2d_8_d_d+0x5f>
mov    0x68(%rbp),%rax
cmpl   $0x0,0x4(%rax)
je     2130 <acd_2d_8_d_d+0x1030>
mov    0x38(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    0x40(%rbp),%rcx
mov    (%rcx),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    212b <acd_2d_8_d_d+0x102b>
mov    0x18(%rbp),%rax
mov    0x38(%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    0x38(%rbp),%rcx
mov    0x4(%rcx),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x10(%rbp),%rax
mov    0x38(%rbp),%rcx
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    0x10(%rbp),%rax
mov    0x38(%rbp),%rcx
mov    0x4(%rcx),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%rax
mov    0x38(%rbp),%rcx
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    -0x30(%rbp),%rax
mov    0x38(%rbp),%rcx
mov    0x4(%rcx),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%rax
mov    0x38(%rbp),%rcx
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    -0x28(%rbp),%rax
mov    0x38(%rbp),%rcx
mov    0x4(%rcx),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x18(%rbp),%rax
mov    0x38(%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    0x38(%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    0x10(%rbp),%rax
mov    0x38(%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    0x10(%rbp),%rax
mov    0x38(%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    -0x30(%rbp),%rax
mov    0x38(%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    -0x30(%rbp),%rax
mov    0x38(%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    -0x28(%rbp),%rax
mov    0x38(%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    -0x28(%rbp),%rax
mov    0x38(%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    0x38(%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    0x38(%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    0x10(%rbp),%rax
mov    0x38(%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    0x10(%rbp),%rax
mov    0x38(%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    -0x30(%rbp),%rax
mov    0x38(%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    -0x30(%rbp),%rax
mov    0x38(%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    -0x28(%rbp),%rax
mov    0x38(%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    -0x28(%rbp),%rax
mov    0x38(%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    1d9d <acd_2d_8_d_d+0xc9d>
jmp    2130 <acd_2d_8_d_d+0x1030>
mov    0x70(%rbp),%rax
cmpl   $0x0,0x4(%rax)
je     24da <acd_2d_8_d_d+0x13da>
mov    0x38(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    0x40(%rbp),%rcx
mov    (%rcx),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    24d5 <acd_2d_8_d_d+0x13d5>
mov    0x18(%rbp),%rax
mov    0x40(%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    0x40(%rbp),%rcx
mov    0x4(%rcx),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x10(%rbp),%rax
mov    0x40(%rbp),%rcx
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    0x10(%rbp),%rax
mov    0x40(%rbp),%rcx
mov    0x4(%rcx),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%rax
mov    0x40(%rbp),%rcx
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    -0x30(%rbp),%rax
mov    0x40(%rbp),%rcx
mov    0x4(%rcx),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%rax
mov    0x40(%rbp),%rcx
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    -0x28(%rbp),%rax
mov    0x40(%rbp),%rcx
mov    0x4(%rcx),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x18(%rbp),%rax
mov    0x40(%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    0x40(%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    0x10(%rbp),%rax
mov    0x40(%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    0x10(%rbp),%rax
mov    0x40(%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    -0x30(%rbp),%rax
mov    0x40(%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    -0x30(%rbp),%rax
mov    0x40(%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    -0x28(%rbp),%rax
mov    0x40(%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    -0x28(%rbp),%rax
mov    0x40(%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    0x40(%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    0x40(%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    0x10(%rbp),%rax
mov    0x40(%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    0x10(%rbp),%rax
mov    0x40(%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    -0x30(%rbp),%rax
mov    0x40(%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    -0x30(%rbp),%rax
mov    0x40(%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    -0x28(%rbp),%rax
mov    0x40(%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    -0x28(%rbp),%rax
mov    0x40(%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    2147 <acd_2d_8_d_d+0x1047>
jmp    24da <acd_2d_8_d_d+0x13da>
mov    0x68(%rbp),%rax
cmpl   $0x0,(%rax)
je     286d <acd_2d_8_d_d+0x176d>
mov    0x38(%rbp),%rax
mov    0x4(%rax),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    0x40(%rbp),%rcx
mov    0x4(%rcx),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    2868 <acd_2d_8_d_d+0x1768>
mov    0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x38(%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    0x38(%rbp),%rcx
mov    (%rcx),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x38(%rbp),%rcx
mov    (%rcx),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x38(%rbp),%rcx
mov    (%rcx),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x38(%rbp),%rcx
mov    (%rcx),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x38(%rbp),%rcx
mov    (%rcx),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x38(%rbp),%rcx
mov    (%rcx),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x38(%rbp),%rcx
mov    (%rcx),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x38(%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    0x38(%rbp),%rcx
mov    (%rcx),%ecx
sub    $0x3,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x38(%rbp),%rcx
mov    (%rcx),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x38(%rbp),%rcx
mov    (%rcx),%ecx
sub    $0x3,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x38(%rbp),%rcx
mov    (%rcx),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x38(%rbp),%rcx
mov    (%rcx),%ecx
sub    $0x3,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x38(%rbp),%rcx
mov    (%rcx),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x38(%rbp),%rcx
mov    (%rcx),%ecx
sub    $0x3,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x38(%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    0x38(%rbp),%rcx
mov    (%rcx),%ecx
sub    $0x4,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x38(%rbp),%rcx
mov    (%rcx),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x38(%rbp),%rcx
mov    (%rcx),%ecx
sub    $0x4,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x38(%rbp),%rcx
mov    (%rcx),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x38(%rbp),%rcx
mov    (%rcx),%ecx
sub    $0x4,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x38(%rbp),%rcx
mov    (%rcx),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x38(%rbp),%rcx
mov    (%rcx),%ecx
sub    $0x4,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    24f1 <acd_2d_8_d_d+0x13f1>
jmp    286d <acd_2d_8_d_d+0x176d>
mov    0x70(%rbp),%rax
cmpl   $0x0,(%rax)
je     2c00 <acd_2d_8_d_d+0x1b00>
mov    0x38(%rbp),%rax
mov    0x4(%rax),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    0x40(%rbp),%rcx
mov    0x4(%rcx),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    2bfb <acd_2d_8_d_d+0x1afb>
mov    0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x40(%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    0x40(%rbp),%rcx
mov    (%rcx),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x40(%rbp),%rcx
mov    (%rcx),%ecx
sub    $0x0,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x40(%rbp),%rcx
mov    (%rcx),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x40(%rbp),%rcx
mov    (%rcx),%ecx
sub    $0x0,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x40(%rbp),%rcx
mov    (%rcx),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x40(%rbp),%rcx
mov    (%rcx),%ecx
sub    $0x0,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x40(%rbp),%rcx
mov    (%rcx),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x40(%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    0x40(%rbp),%rcx
mov    (%rcx),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x40(%rbp),%rcx
mov    (%rcx),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x40(%rbp),%rcx
mov    (%rcx),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x40(%rbp),%rcx
mov    (%rcx),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x40(%rbp),%rcx
mov    (%rcx),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x40(%rbp),%rcx
mov    (%rcx),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x40(%rbp),%rcx
mov    (%rcx),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x40(%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    0x40(%rbp),%rcx
mov    (%rcx),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x40(%rbp),%rcx
mov    (%rcx),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x40(%rbp),%rcx
mov    (%rcx),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x40(%rbp),%rcx
mov    (%rcx),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x40(%rbp),%rcx
mov    (%rcx),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x40(%rbp),%rcx
mov    (%rcx),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x40(%rbp),%rcx
mov    (%rcx),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    2884 <acd_2d_8_d_d+0x1784>
jmp    2c00 <acd_2d_8_d_d+0x1b00>
pop    %rbp
ret

x86 assembly (clang, -O2):
<acd_2d_8_d_d>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xe0,%rsp
mov    %r9,-0x78(%rsp)
mov    %r8,-0x70(%rsp)
mov    %rcx,0x38(%rsp)
mov    %rdx,0x30(%rsp)
mov    %rsi,0x28(%rsp)
mov    %rdi,0x20(%rsp)
mov    0x148(%rsp),%rax
mov    0x140(%rsp),%rcx
movslq 0x4(%rcx),%rcx
movslq 0x4(%rax),%rax
mov    %rcx,-0x80(%rsp)
cmp    %eax,%ecx
mov    %rax,0x10(%rsp)
jg     196d <acd_2d_8_d_d+0x86d>
mov    0x158(%rsp),%r10
mov    0x140(%rsp),%rcx
movslq (%rcx),%rsi
mov    0x148(%rsp),%rcx
mov    (%rcx),%ecx
add    $0x1,%eax
mov    %ecx,%edi
sub    %esi,%edi
add    $0x1,%edi
mov    -0x80(%rsp),%rbx
mov    %rsi,0x18(%rsp)
mov    %ecx,0xc(%rsp)
mov    %eax,0x8(%rsp)
mov    %rdi,0x48(%rsp)
jmp    11af <acd_2d_8_d_d+0xaf>
nopl   0x0(%rax)
add    $0x1,%rbx
mov    %rbx,%rdx
cmp    %edx,%eax
je     196d <acd_2d_8_d_d+0x86d>
cmp    %ecx,%esi
jg     11a0 <acd_2d_8_d_d+0xa0>
lea    0x0(,%rsi,4),%r8
mov    0x20(%rsp),%rdi
mov    (%rdi,%rbx,8),%r9
add    %r8,%r9
mov    0x28(%rsp),%rsi
mov    (%rsi,%rbx,8),%rax
add    %r8,%rax
mov    0x30(%rsp),%rdx
mov    (%rdx,%rbx,8),%r13
add    %r8,%r13
mov    0x38(%rsp),%rcx
mov    (%rcx,%rbx,8),%r11
add    %r8,%r11
mov    0x8(%rdi,%rbx,8),%rbp
add    %r8,%rbp
mov    %rbp,(%rsp)
mov    -0x8(%rdi,%rbx,8),%rbp
add    %r8,%rbp
mov    %rbp,-0x8(%rsp)
mov    0x10(%rdi,%rbx,8),%rbp
add    %r8,%rbp
mov    %rbp,-0x10(%rsp)
mov    -0x10(%rdi,%rbx,8),%rbp
add    %r8,%rbp
mov    %rbp,-0x18(%rsp)
mov    0x18(%rdi,%rbx,8),%rbp
add    %r8,%rbp
mov    %rbp,-0x20(%rsp)
mov    -0x18(%rdi,%rbx,8),%rbp
add    %r8,%rbp
mov    %rbp,-0x28(%rsp)
mov    0x20(%rdi,%rbx,8),%rbp
add    %r8,%rbp
mov    %rbp,-0x30(%rsp)
mov    -0x20(%rdi,%rbx,8),%rdi
add    %r8,%rdi
mov    %rdi,-0x38(%rsp)
mov    0x8(%rsi,%rbx,8),%rdi
add    %r8,%rdi
mov    %rdi,-0x40(%rsp)
mov    -0x8(%rsi,%rbx,8),%rdi
add    %r8,%rdi
mov    %rdi,-0x48(%rsp)
mov    0x10(%rsi,%rbx,8),%rdi
add    %r8,%rdi
mov    %rdi,-0x50(%rsp)
mov    -0x10(%rsi,%rbx,8),%rdi
add    %r8,%rdi
mov    %rdi,-0x58(%rsp)
mov    0x18(%rsi,%rbx,8),%rdi
add    %r8,%rdi
mov    %rdi,-0x60(%rsp)
mov    -0x18(%rsi,%rbx,8),%rdi
add    %r8,%rdi
mov    %rdi,-0x68(%rsp)
mov    0x20(%rsi,%rbx,8),%rdi
add    %r8,%rdi
mov    %rdi,0xd8(%rsp)
mov    -0x20(%rsi,%rbx,8),%rsi
add    %r8,%rsi
mov    %rsi,0xd0(%rsp)
mov    0x8(%rdx,%rbx,8),%rsi
add    %r8,%rsi
mov    %rsi,0xc8(%rsp)
mov    -0x8(%rdx,%rbx,8),%rsi
add    %r8,%rsi
mov    %rsi,0xc0(%rsp)
mov    0x10(%rdx,%rbx,8),%rsi
add    %r8,%rsi
mov    %rsi,0xb8(%rsp)
mov    -0x10(%rdx,%rbx,8),%rsi
add    %r8,%rsi
mov    %rsi,0xb0(%rsp)
mov    0x18(%rdx,%rbx,8),%rsi
add    %r8,%rsi
mov    %rsi,0xa8(%rsp)
mov    -0x18(%rdx,%rbx,8),%rsi
add    %r8,%rsi
mov    %rsi,0xa0(%rsp)
mov    0x20(%rdx,%rbx,8),%rsi
add    %r8,%rsi
mov    %rsi,0x98(%rsp)
mov    -0x20(%rdx,%rbx,8),%rdx
add    %r8,%rdx
mov    %rdx,0x90(%rsp)
mov    0x8(%rcx,%rbx,8),%rdx
add    %r8,%rdx
mov    %rdx,0x88(%rsp)
mov    -0x8(%rcx,%rbx,8),%rdx
add    %r8,%rdx
mov    %rdx,0x80(%rsp)
mov    0x10(%rcx,%rbx,8),%rdx
add    %r8,%rdx
mov    %rdx,0x78(%rsp)
mov    -0x10(%rcx,%rbx,8),%rdx
add    %r8,%rdx
mov    %rdx,0x70(%rsp)
mov    0x18(%rcx,%rbx,8),%rdx
add    %r8,%rdx
mov    %rdx,0x68(%rsp)
mov    -0x18(%rcx,%rbx,8),%rdx
add    %r8,%rdx
mov    %rdx,0x60(%rsp)
mov    0x20(%rcx,%rbx,8),%rdx
add    %r8,%rdx
mov    %rdx,0x58(%rsp)
mov    -0x20(%rcx,%rbx,8),%rcx
add    %r8,%rcx
mov    %rcx,0x50(%rsp)
mov    0x120(%rsp),%rcx
mov    (%rcx,%rbx,8),%r15
add    %r8,%r15
mov    0x138(%rsp),%rcx
mov    (%rcx,%rbx,8),%rdx
add    %r8,%rdx
mov    0x130(%rsp),%rcx
mov    (%rcx,%rbx,8),%rsi
add    %r8,%rsi
mov    0x128(%rsp),%rcx
mov    (%rcx,%rbx,8),%rdi
add    %r8,%rdi
mov    0x118(%rsp),%rcx
mov    (%rcx,%rbx,8),%rbp
add    %r8,%rbp
mov    -0x78(%rsp),%rcx
mov    (%rcx,%rbx,8),%r12
add    %r8,%r12
mov    -0x70(%rsp),%rcx
add    (%rcx,%rbx,8),%r8
lea    0x1(%rbx),%rcx
mov    %rcx,0x40(%rsp)
xor    %r14d,%r14d
mov    0x160(%rsp),%rbx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movss  0x4(%r9,%r14,4),%xmm2
movss  0x8(%r9,%r14,4),%xmm1
addss  -0x4(%r9,%r14,4),%xmm2
mov    0x150(%rsp),%rcx
movss  (%rcx),%xmm12
movss  0x4(%rcx),%xmm8
mulss  %xmm12,%xmm2
movss  (%r9,%r14,4),%xmm3
mulss  %xmm0,%xmm3
addss  %xmm2,%xmm3
mov    (%rsp),%rcx
movss  (%rcx,%r14,4),%xmm2
mov    -0x8(%rsp),%rcx
addss  (%rcx,%r14,4),%xmm2
mulss  %xmm8,%xmm2
addss  %xmm3,%xmm2
addss  -0x8(%r9,%r14,4),%xmm1
movss  (%r10),%xmm13
movss  0x4(%r10),%xmm9
mulss  %xmm13,%xmm1
addss  %xmm2,%xmm1
mov    -0x10(%rsp),%rcx
movss  (%rcx,%r14,4),%xmm2
mov    -0x18(%rsp),%rcx
addss  (%rcx,%r14,4),%xmm2
mulss  %xmm9,%xmm2
addss  %xmm1,%xmm2
movss  0xc(%r9,%r14,4),%xmm1
addss  -0xc(%r9,%r14,4),%xmm1
movss  (%rbx),%xmm14
movss  0x4(%rbx),%xmm10
mulss  %xmm14,%xmm1
addss  %xmm2,%xmm1
mov    -0x20(%rsp),%rcx
movss  (%rcx,%r14,4),%xmm4
mov    -0x28(%rsp),%rcx
addss  (%rcx,%r14,4),%xmm4
mulss  %xmm10,%xmm4
addss  %xmm1,%xmm4
movss  0x10(%r9,%r14,4),%xmm2
addss  -0x10(%r9,%r14,4),%xmm2
mov    0x168(%rsp),%rcx
movss  (%rcx),%xmm15
movss  0x4(%rcx),%xmm11
mulss  %xmm15,%xmm2
addss  %xmm4,%xmm2
mov    -0x30(%rsp),%rcx
movss  (%rcx,%r14,4),%xmm1
mov    -0x38(%rsp),%rcx
addss  (%rcx,%r14,4),%xmm1
movss  0x4(%rax,%r14,4),%xmm4
movss  0x8(%rax,%r14,4),%xmm6
addss  -0x4(%rax,%r14,4),%xmm4
mulss  %xmm12,%xmm4
movss  (%rax,%r14,4),%xmm7
mulss  %xmm0,%xmm7
mov    -0x40(%rsp),%rcx
movss  (%rcx,%r14,4),%xmm5
mov    -0x48(%rsp),%rcx
addss  (%rcx,%r14,4),%xmm5
addss  %xmm4,%xmm7
mulss  %xmm8,%xmm5
addss  -0x8(%rax,%r14,4),%xmm6
addss  %xmm7,%xmm5
mulss  %xmm13,%xmm6
addss  %xmm5,%xmm6
mov    -0x50(%rsp),%rcx
movss  (%rcx,%r14,4),%xmm4
mov    -0x58(%rsp),%rcx
addss  (%rcx,%r14,4),%xmm4
mulss  %xmm9,%xmm4
addss  %xmm6,%xmm4
movss  0xc(%rax,%r14,4),%xmm5
addss  -0xc(%rax,%r14,4),%xmm5
mulss  %xmm14,%xmm5
addss  %xmm4,%xmm5
mov    -0x60(%rsp),%rcx
movss  (%rcx,%r14,4),%xmm4
mov    -0x68(%rsp),%rcx
addss  (%rcx,%r14,4),%xmm4
mulss  %xmm10,%xmm4
movss  0x10(%rax,%r14,4),%xmm7
addss  -0x10(%rax,%r14,4),%xmm7
addss  %xmm5,%xmm4
mulss  %xmm15,%xmm7
addss  %xmm4,%xmm7
mov    0xd8(%rsp),%rcx
movss  (%rcx,%r14,4),%xmm6
mov    0xd0(%rsp),%rcx
addss  (%rcx,%r14,4),%xmm6
mulss  %xmm11,%xmm6
addss  %xmm7,%xmm6
movss  0x4(%r13,%r14,4),%xmm4
movss  0x8(%r13,%r14,4),%xmm5
addss  -0x4(%r13,%r14,4),%xmm4
mulss  %xmm12,%xmm4
movss  0x0(%r13,%r14,4),%xmm7
mulss  %xmm0,%xmm7
addss  %xmm4,%xmm7
mov    0xc8(%rsp),%rcx
movss  (%rcx,%r14,4),%xmm4
mov    0xc0(%rsp),%rcx
addss  (%rcx,%r14,4),%xmm4
mulss  %xmm8,%xmm4
addss  %xmm7,%xmm4
addss  -0x8(%r13,%r14,4),%xmm5
mulss  %xmm13,%xmm5
addss  %xmm4,%xmm5
mov    0xb8(%rsp),%rcx
movss  (%rcx,%r14,4),%xmm4
mov    0xb0(%rsp),%rcx
addss  (%rcx,%r14,4),%xmm4
mulss  %xmm9,%xmm4
movss  0xc(%r13,%r14,4),%xmm7
addss  -0xc(%r13,%r14,4),%xmm7
addss  %xmm5,%xmm4
mulss  %xmm14,%xmm7
addss  %xmm4,%xmm7
mov    0xa8(%rsp),%rcx
movss  (%rcx,%r14,4),%xmm4
mov    0xa0(%rsp),%rcx
addss  (%rcx,%r14,4),%xmm4
mulss  %xmm10,%xmm4
addss  %xmm7,%xmm4
movss  0x10(%r13,%r14,4),%xmm5
addss  -0x10(%r13,%r14,4),%xmm5
mulss  %xmm15,%xmm5
addss  %xmm4,%xmm5
mov    0x98(%rsp),%rcx
movss  (%rcx,%r14,4),%xmm7
mov    0x90(%rsp),%rcx
addss  (%rcx,%r14,4),%xmm7
mulss  %xmm11,%xmm7
addss  %xmm5,%xmm7
movss  (%r11,%r14,4),%xmm4
movss  0x4(%r11,%r14,4),%xmm5
addss  -0x4(%r11,%r14,4),%xmm5
mulss  %xmm12,%xmm5
movaps %xmm0,%xmm3
mulss  %xmm4,%xmm3
addss  %xmm5,%xmm3
mov    0x88(%rsp),%rcx
movss  (%rcx,%r14,4),%xmm5
mov    0x80(%rsp),%rcx
addss  (%rcx,%r14,4),%xmm5
mulss  %xmm8,%xmm5
mulss  %xmm11,%xmm1
addss  %xmm3,%xmm5
movss  0x8(%r11,%r14,4),%xmm3
addss  -0x8(%r11,%r14,4),%xmm3
mulss  %xmm13,%xmm3
addss  %xmm5,%xmm3
mov    0x78(%rsp),%rcx
movss  (%rcx,%r14,4),%xmm8
mov    0x70(%rsp),%rcx
addss  (%rcx,%r14,4),%xmm8
mulss  %xmm9,%xmm8
addss  %xmm3,%xmm8
movss  0xc(%r11,%r14,4),%xmm3
addss  -0xc(%r11,%r14,4),%xmm3
mulss  %xmm14,%xmm3
mov    0x68(%rsp),%rcx
movss  (%rcx,%r14,4),%xmm5
mov    0x60(%rsp),%rcx
addss  (%rcx,%r14,4),%xmm5
addss  %xmm8,%xmm3
mulss  %xmm10,%xmm5
addss  %xmm3,%xmm5
movss  0x10(%r11,%r14,4),%xmm3
addss  -0x10(%r11,%r14,4),%xmm3
mulss  %xmm15,%xmm3
addss  %xmm5,%xmm3
mov    0x58(%rsp),%rcx
movss  (%rcx,%r14,4),%xmm5
mov    0x50(%rsp),%rcx
addss  (%rcx,%r14,4),%xmm5
mulss  %xmm11,%xmm5
addss  %xmm3,%xmm5
xorps  %xmm3,%xmm3
cvtss2sd %xmm4,%xmm3
movss  (%r15,%r14,4),%xmm4
cvtss2sd %xmm4,%xmm4
addsd  %xmm3,%xmm3
subsd  %xmm4,%xmm3
movss  (%rdx,%r14,4),%xmm4
mulss  %xmm6,%xmm4
cvtss2sd %xmm4,%xmm4
addsd  %xmm3,%xmm4
movss  (%rsi,%r14,4),%xmm3
mulss  %xmm7,%xmm3
cvtss2sd %xmm3,%xmm3
addsd  %xmm4,%xmm3
mulss  (%rdi,%r14,4),%xmm5
xorps  %xmm4,%xmm4
cvtss2sd %xmm5,%xmm4
addsd  %xmm3,%xmm4
xorps  %xmm3,%xmm3
cvtsd2ss %xmm4,%xmm3
addss  %xmm2,%xmm1
movss  %xmm3,(%r15,%r14,4)
movss  0x0(%r13,%r14,4),%xmm2
cvtss2sd %xmm2,%xmm2
movss  0x0(%rbp,%r14,4),%xmm3
cvtss2sd %xmm3,%xmm3
addsd  %xmm2,%xmm2
subsd  %xmm3,%xmm2
movss  (%rdx,%r14,4),%xmm3
mulss  %xmm1,%xmm3
cvtss2sd %xmm3,%xmm3
addsd  %xmm2,%xmm3
mulss  (%rdi,%r14,4),%xmm7
xorps  %xmm2,%xmm2
cvtss2sd %xmm7,%xmm2
addsd  %xmm3,%xmm2
cvtsd2ss %xmm2,%xmm2
movss  %xmm2,0x0(%rbp,%r14,4)
movss  (%rax,%r14,4),%xmm2
cvtss2sd %xmm2,%xmm2
movss  (%r12,%r14,4),%xmm3
cvtss2sd %xmm3,%xmm3
addsd  %xmm2,%xmm2
subsd  %xmm3,%xmm2
movss  (%rsi,%r14,4),%xmm3
mulss  %xmm1,%xmm3
cvtss2sd %xmm3,%xmm3
addsd  %xmm2,%xmm3
mulss  (%rdi,%r14,4),%xmm6
xorps  %xmm2,%xmm2
cvtss2sd %xmm6,%xmm2
addsd  %xmm3,%xmm2
cvtsd2ss %xmm2,%xmm2
movss  %xmm2,(%r12,%r14,4)
movss  (%r9,%r14,4),%xmm2
cvtss2sd %xmm2,%xmm2
movss  (%r8,%r14,4),%xmm3
cvtss2sd %xmm3,%xmm3
addsd  %xmm2,%xmm2
subsd  %xmm3,%xmm2
mulss  (%rdi,%r14,4),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm2,%xmm1
cvtsd2ss %xmm1,%xmm1
movss  %xmm1,(%r8,%r14,4)
add    $0x1,%r14
cmp    %r14d,0x48(%rsp)
jne    1430 <acd_2d_8_d_d+0x330>
mov    0x40(%rsp),%rdx
mov    %rdx,%rbx
mov    0x18(%rsp),%rsi
mov    0xc(%rsp),%ecx
mov    0x8(%rsp),%eax
cmp    %edx,%eax
jne    11af <acd_2d_8_d_d+0xaf>
mov    0x170(%rsp),%rax
cmpl   $0x0,0x4(%rax)
je     1bcd <acd_2d_8_d_d+0xacd>
mov    0x140(%rsp),%rax
movslq (%rax),%rcx
mov    0x148(%rsp),%rax
mov    (%rax),%eax
mov    %rax,-0x60(%rsp)
cmp    %eax,%ecx
jg     1bcd <acd_2d_8_d_d+0xacd>
mov    %rcx,%rdx
mov    %rcx,-0x68(%rsp)
shl    $0x2,%rdx
mov    -0x80(%rsp),%rax
mov    0x120(%rsp),%rbp
mov    0x0(%rbp,%rax,8),%rcx
add    %rdx,%rcx
mov    %rcx,(%rsp)
mov    -0x10(%rbp,%rax,8),%rcx
add    %rdx,%rcx
mov    %rcx,-0x8(%rsp)
mov    0x118(%rsp),%rdi
mov    (%rdi,%rax,8),%rcx
add    %rdx,%rcx
mov    %rcx,-0x10(%rsp)
mov    -0x10(%rdi,%rax,8),%rcx
add    %rdx,%rcx
mov    %rcx,-0x18(%rsp)
mov    -0x78(%rsp),%rbx
mov    (%rbx,%rax,8),%rcx
add    %rdx,%rcx
mov    %rcx,-0x20(%rsp)
mov    -0x10(%rbx,%rax,8),%rcx
add    %rdx,%rcx
mov    %rcx,-0x28(%rsp)
mov    -0x70(%rsp),%rsi
mov    (%rsi,%rax,8),%rcx
add    %rdx,%rcx
mov    %rcx,-0x30(%rsp)
mov    -0x10(%rsi,%rax,8),%rcx
add    %rdx,%rcx
mov    %rcx,-0x38(%rsp)
mov    0x8(%rbp,%rax,8),%rcx
add    %rdx,%rcx
mov    %rcx,-0x40(%rsp)
mov    -0x18(%rbp,%rax,8),%rcx
add    %rdx,%rcx
mov    %rcx,-0x48(%rsp)
mov    0x8(%rdi,%rax,8),%rcx
add    %rdx,%rcx
mov    %rcx,-0x50(%rsp)
mov    -0x18(%rdi,%rax,8),%rcx
add    %rdx,%rcx
mov    %rcx,-0x58(%rsp)
mov    0x8(%rbx,%rax,8),%r8
add    %rdx,%r8
mov    -0x18(%rbx,%rax,8),%r9
add    %rdx,%r9
mov    0x8(%rsi,%rax,8),%r10
add    %rdx,%r10
mov    -0x18(%rsi,%rax,8),%r11
add    %rdx,%r11
mov    0x10(%rbp,%rax,8),%r14
add    %rdx,%r14
mov    -0x20(%rbp,%rax,8),%r15
add    %rdx,%r15
mov    0x10(%rdi,%rax,8),%r12
add    %rdx,%r12
mov    -0x20(%rdi,%rax,8),%r13
add    %rdx,%r13
mov    0x10(%rbx,%rax,8),%rdi
add    %rdx,%rdi
mov    -0x20(%rbx,%rax,8),%rbp
add    %rdx,%rbp
mov    0x10(%rsi,%rax,8),%rbx
add    %rdx,%rbx
add    -0x20(%rsi,%rax,8),%rdx
mov    -0x60(%rsp),%rcx
sub    -0x68(%rsp),%ecx
add    $0x1,%ecx
movaps 0x152c(%rip),%xmm0
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
mov    (%rsp),%rsi
movss  (%rsi,%rax,4),%xmm1
xorps  %xmm0,%xmm1
mov    -0x8(%rsp),%rsi
movss  %xmm1,(%rsi,%rax,4)
mov    -0x10(%rsp),%rsi
movss  (%rsi,%rax,4),%xmm1
xorps  %xmm0,%xmm1
mov    -0x18(%rsp),%rsi
movss  %xmm1,(%rsi,%rax,4)
mov    -0x20(%rsp),%rsi
movss  (%rsi,%rax,4),%xmm1
xorps  %xmm0,%xmm1
mov    -0x28(%rsp),%rsi
movss  %xmm1,(%rsi,%rax,4)
mov    -0x30(%rsp),%rsi
movss  (%rsi,%rax,4),%xmm1
xorps  %xmm0,%xmm1
mov    -0x38(%rsp),%rsi
movss  %xmm1,(%rsi,%rax,4)
mov    -0x40(%rsp),%rsi
movss  (%rsi,%rax,4),%xmm1
xorps  %xmm0,%xmm1
mov    -0x48(%rsp),%rsi
movss  %xmm1,(%rsi,%rax,4)
mov    -0x50(%rsp),%rsi
movss  (%rsi,%rax,4),%xmm1
xorps  %xmm0,%xmm1
mov    -0x58(%rsp),%rsi
movss  %xmm1,(%rsi,%rax,4)
movss  (%r8,%rax,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,(%r9,%rax,4)
movss  (%r10,%rax,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,(%r11,%rax,4)
movss  (%r14,%rax,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,(%r15,%rax,4)
movss  (%r12,%rax,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,0x0(%r13,%rax,4)
movss  (%rdi,%rax,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,0x0(%rbp,%rax,4)
movss  (%rbx,%rax,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,(%rdx,%rax,4)
add    $0x1,%rax
cmp    %eax,%ecx
jne    1ae0 <acd_2d_8_d_d+0x9e0>
mov    0x178(%rsp),%rax
cmpl   $0x0,0x4(%rax)
je     1e2d <acd_2d_8_d_d+0xd2d>
mov    0x140(%rsp),%rax
movslq (%rax),%rcx
mov    0x148(%rsp),%rax
mov    (%rax),%eax
mov    %rax,-0x60(%rsp)
cmp    %eax,%ecx
jg     1e2d <acd_2d_8_d_d+0xd2d>
mov    %rcx,%rdx
mov    %rcx,-0x68(%rsp)
shl    $0x2,%rdx
mov    0x10(%rsp),%rax
mov    0x120(%rsp),%r8
mov    (%r8,%rax,8),%rcx
add    %rdx,%rcx
mov    %rcx,(%rsp)
mov    0x10(%r8,%rax,8),%rcx
add    %rdx,%rcx
mov    %rcx,-0x8(%rsp)
mov    0x118(%rsp),%rbp
mov    0x0(%rbp,%rax,8),%rcx
add    %rdx,%rcx
mov    %rcx,-0x10(%rsp)
mov    0x10(%rbp,%rax,8),%rcx
add    %rdx,%rcx
mov    %rcx,-0x18(%rsp)
mov    -0x78(%rsp),%rbx
mov    (%rbx,%rax,8),%rcx
add    %rdx,%rcx
mov    %rcx,-0x20(%rsp)
mov    0x10(%rbx,%rax,8),%rcx
add    %rdx,%rcx
mov    %rcx,-0x28(%rsp)
mov    -0x70(%rsp),%rsi
mov    (%rsi,%rax,8),%rcx
add    %rdx,%rcx
mov    %rcx,-0x30(%rsp)
mov    0x10(%rsi,%rax,8),%rcx
add    %rdx,%rcx
mov    %rcx,-0x38(%rsp)
mov    -0x8(%r8,%rax,8),%rcx
add    %rdx,%rcx
mov    %rcx,-0x40(%rsp)
mov    0x18(%r8,%rax,8),%rcx
add    %rdx,%rcx
mov    %rcx,-0x48(%rsp)
mov    -0x8(%rbp,%rax,8),%rcx
add    %rdx,%rcx
mov    %rcx,-0x50(%rsp)
mov    0x18(%rbp,%rax,8),%rcx
add    %rdx,%rcx
mov    %rcx,-0x58(%rsp)
mov    -0x8(%rbx,%rax,8),%rdi
add    %rdx,%rdi
mov    0x18(%rbx,%rax,8),%r9
add    %rdx,%r9
mov    -0x8(%rsi,%rax,8),%r10
add    %rdx,%r10
mov    0x18(%rsi,%rax,8),%r11
add    %rdx,%r11
mov    -0x10(%r8,%rax,8),%r14
add    %rdx,%r14
mov    0x20(%r8,%rax,8),%r15
add    %rdx,%r15
mov    -0x10(%rbp,%rax,8),%r12
add    %rdx,%r12
mov    0x20(%rbp,%rax,8),%r13
add    %rdx,%r13
mov    -0x10(%rbx,%rax,8),%r8
add    %rdx,%r8
mov    0x20(%rbx,%rax,8),%rbp
add    %rdx,%rbp
mov    -0x10(%rsi,%rax,8),%rbx
add    %rdx,%rbx
add    0x20(%rsi,%rax,8),%rdx
mov    -0x60(%rsp),%rcx
sub    -0x68(%rsp),%ecx
add    $0x1,%ecx
movaps 0x12cc(%rip),%xmm0
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
mov    (%rsp),%rsi
movss  (%rsi,%rax,4),%xmm1
xorps  %xmm0,%xmm1
mov    -0x8(%rsp),%rsi
movss  %xmm1,(%rsi,%rax,4)
mov    -0x10(%rsp),%rsi
movss  (%rsi,%rax,4),%xmm1
xorps  %xmm0,%xmm1
mov    -0x18(%rsp),%rsi
movss  %xmm1,(%rsi,%rax,4)
mov    -0x20(%rsp),%rsi
movss  (%rsi,%rax,4),%xmm1
xorps  %xmm0,%xmm1
mov    -0x28(%rsp),%rsi
movss  %xmm1,(%rsi,%rax,4)
mov    -0x30(%rsp),%rsi
movss  (%rsi,%rax,4),%xmm1
xorps  %xmm0,%xmm1
mov    -0x38(%rsp),%rsi
movss  %xmm1,(%rsi,%rax,4)
mov    -0x40(%rsp),%rsi
movss  (%rsi,%rax,4),%xmm1
xorps  %xmm0,%xmm1
mov    -0x48(%rsp),%rsi
movss  %xmm1,(%rsi,%rax,4)
mov    -0x50(%rsp),%rsi
movss  (%rsi,%rax,4),%xmm1
xorps  %xmm0,%xmm1
mov    -0x58(%rsp),%rsi
movss  %xmm1,(%rsi,%rax,4)
movss  (%rdi,%rax,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,(%r9,%rax,4)
movss  (%r10,%rax,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,(%r11,%rax,4)
movss  (%r14,%rax,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,(%r15,%rax,4)
movss  (%r12,%rax,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,0x0(%r13,%rax,4)
movss  (%r8,%rax,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,0x0(%rbp,%rax,4)
movss  (%rbx,%rax,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,(%rdx,%rax,4)
add    $0x1,%rax
cmp    %eax,%ecx
jne    1d40 <acd_2d_8_d_d+0xc40>
mov    0x170(%rsp),%rax
cmpl   $0x0,(%rax)
mov    0x10(%rsp),%r14
je     1f6c <acd_2d_8_d_d+0xe6c>
cmp    %r14d,-0x80(%rsp)
jg     1f6c <acd_2d_8_d_d+0xe6c>
mov    0x140(%rsp),%rax
movslq (%rax),%rax
mov    -0x80(%rsp),%rdx
mov    0x120(%rsp),%rcx
lea    (%rcx,%rdx,8),%r8
mov    0x118(%rsp),%rcx
lea    (%rcx,%rdx,8),%r9
mov    -0x78(%rsp),%rcx
lea    (%rcx,%rdx,8),%r10
mov    -0x70(%rsp),%rcx
lea    (%rcx,%rdx,8),%r11
mov    %r14d,%ebp
sub    %edx,%ebp
add    $0x1,%ebp
xor    %ebx,%ebx
movaps 0x1167(%rip),%xmm0
nopl   0x0(%rax)
mov    (%r8,%rbx,8),%rcx
movss  (%rcx,%rax,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,-0x8(%rcx,%rax,4)
mov    (%r9,%rbx,8),%rdx
movss  (%rdx,%rax,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,-0x8(%rdx,%rax,4)
mov    (%r10,%rbx,8),%rsi
movss  (%rsi,%rax,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,-0x8(%rsi,%rax,4)
mov    (%r11,%rbx,8),%rdi
movss  (%rdi,%rax,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,-0x8(%rdi,%rax,4)
movss  0x4(%rcx,%rax,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,-0xc(%rcx,%rax,4)
movss  0x4(%rdx,%rax,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,-0xc(%rdx,%rax,4)
movss  0x4(%rsi,%rax,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,-0xc(%rsi,%rax,4)
movss  0x4(%rdi,%rax,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,-0xc(%rdi,%rax,4)
movss  0x8(%rcx,%rax,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,-0x10(%rcx,%rax,4)
movss  0x8(%rdx,%rax,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,-0x10(%rdx,%rax,4)
movss  0x8(%rsi,%rax,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,-0x10(%rsi,%rax,4)
movss  0x8(%rdi,%rax,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,-0x10(%rdi,%rax,4)
add    $0x1,%rbx
cmp    %ebx,%ebp
jne    1ea0 <acd_2d_8_d_d+0xda0>
mov    0x178(%rsp),%rax
cmpl   $0x0,(%rax)
je     20ad <acd_2d_8_d_d+0xfad>
cmp    %r14d,-0x80(%rsp)
jg     20ad <acd_2d_8_d_d+0xfad>
mov    0x148(%rsp),%rax
movslq (%rax),%rax
mov    -0x80(%rsp),%rdx
mov    0x120(%rsp),%rcx
lea    (%rcx,%rdx,8),%r8
mov    0x118(%rsp),%rcx
lea    (%rcx,%rdx,8),%r9
mov    -0x78(%rsp),%rcx
lea    (%rcx,%rdx,8),%r10
mov    -0x70(%rsp),%rcx
lea    (%rcx,%rdx,8),%rdi
sub    %edx,%r14d
add    $0x1,%r14d
xor    %ebp,%ebp
movaps 0x102e(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    (%r8,%rbp,8),%rbx
movss  (%rbx,%rax,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,0x8(%rbx,%rax,4)
mov    (%r9,%rbp,8),%rcx
movss  (%rcx,%rax,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,0x8(%rcx,%rax,4)
mov    (%r10,%rbp,8),%rdx
movss  (%rdx,%rax,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,0x8(%rdx,%rax,4)
mov    (%rdi,%rbp,8),%rsi
movss  (%rsi,%rax,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,0x8(%rsi,%rax,4)
movss  -0x4(%rbx,%rax,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,0xc(%rbx,%rax,4)
movss  -0x4(%rcx,%rax,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,0xc(%rcx,%rax,4)
movss  -0x4(%rdx,%rax,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,0xc(%rdx,%rax,4)
movss  -0x4(%rsi,%rax,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,0xc(%rsi,%rax,4)
movss  -0x8(%rbx,%rax,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,0x10(%rbx,%rax,4)
movss  -0x8(%rcx,%rax,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,0x10(%rcx,%rax,4)
movss  -0x8(%rdx,%rax,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,0x10(%rdx,%rax,4)
movss  -0x8(%rsi,%rax,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,0x10(%rsi,%rax,4)
add    $0x1,%rbp
cmp    %ebp,%r14d
jne    1fe0 <acd_2d_8_d_d+0xee0>
add    $0xe0,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @acd_2d_8_d_d(float** %0, float** %1, float** %2, float** %3, float** %4, float** %5, float** %6, float** %7, float** %8, float** %9, float** %10, i32* %11, i32* %12, float %13, float* %14, float* %15, float* %16, float* %17, i32* %18, i32* %19) {
%21 = alloca float**
%22 = alloca float**
%23 = alloca float**
%24 = alloca float**
%25 = alloca float**
%26 = alloca float**
%27 = alloca float**
%28 = alloca float**
%29 = alloca float**
%30 = alloca float**
%31 = alloca float**
%32 = alloca i32*
%33 = alloca i32*
%34 = alloca float
%35 = alloca float*
%36 = alloca float*
%37 = alloca float*
%38 = alloca float*
%39 = alloca i32*
%40 = alloca i32*
%41 = alloca i32
%42 = alloca i32
%43 = alloca float
%44 = alloca float
%45 = alloca float
%46 = alloca float
store float** %0, float*** %21
store float** %1, float*** %22
store float** %2, float*** %23
store float** %3, float*** %24
store float** %4, float*** %25
store float** %5, float*** %26
store float** %6, float*** %27
store float** %7, float*** %28
store float** %8, float*** %29
store float** %9, float*** %30
store float** %10, float*** %31
store i32* %11, i32** %32
store i32* %12, i32** %33
store float %13, float* %34
store float* %14, float** %35
store float* %15, float** %36
store float* %16, float** %37
store float* %17, float** %38
store i32* %18, i32** %39
store i32* %19, i32** %40
%47 = load i32*, i32** %32
%48 = getelementptr inbounds i32, i32* %47, i64 1
%49 = load i32, i32* %48
store i32 %49, i32* %42
br label %50
50: ; preds = %1145, %20
%51 = load i32, i32* %42
%52 = load i32*, i32** %33
%53 = getelementptr inbounds i32, i32* %52, i64 1
%54 = load i32, i32* %53
%55 = add nsw i32 %54, 1
%56 = icmp slt i32 %51, %55
br i1 %56, label %57, label %1148
57: ; preds = %50
%58 = load i32*, i32** %32
%59 = getelementptr inbounds i32, i32* %58, i64 0
%60 = load i32, i32* %59
store i32 %60, i32* %41
br label %61
61: ; preds = %1141, %57
%62 = load i32, i32* %41
%63 = load i32*, i32** %33
%64 = getelementptr inbounds i32, i32* %63, i64 0
%65 = load i32, i32* %64
%66 = add nsw i32 %65, 1
%67 = icmp slt i32 %62, %66
br i1 %67, label %68, label %1144
68: ; preds = %61
%69 = load float, float* %34
%70 = load float**, float*** %21
%71 = load i32, i32* %42
%72 = sext i32 %71 to i64
%73 = getelementptr inbounds float*, float** %70, i64 %72
%74 = load float*, float** %73
%75 = load i32, i32* %41
%76 = sext i32 %75 to i64
%77 = getelementptr inbounds float, float* %74, i64 %76
%78 = load float, float* %77
%79 = load float*, float** %35
%80 = getelementptr inbounds float, float* %79, i64 0
%81 = load float, float* %80
%82 = load float**, float*** %21
%83 = load i32, i32* %42
%84 = sext i32 %83 to i64
%85 = getelementptr inbounds float*, float** %82, i64 %84
%86 = load float*, float** %85
%87 = load i32, i32* %41
%88 = add nsw i32 %87, 1
%89 = sext i32 %88 to i64
%90 = getelementptr inbounds float, float* %86, i64 %89
%91 = load float, float* %90
%92 = load float**, float*** %21
%93 = load i32, i32* %42
%94 = sext i32 %93 to i64
%95 = getelementptr inbounds float*, float** %92, i64 %94
%96 = load float*, float** %95
%97 = load i32, i32* %41
%98 = sub nsw i32 %97, 1
%99 = sext i32 %98 to i64
%100 = getelementptr inbounds float, float* %96, i64 %99
%101 = load float, float* %100
%102 = fadd float %91, %101
%103 = fmul float %81, %102
%104 = call float @llvm.fmuladd.f32(float %69, float %78, float %103)
%105 = load float*, float** %35
%106 = getelementptr inbounds float, float* %105, i64 1
%107 = load float, float* %106
%108 = load float**, float*** %21
%109 = load i32, i32* %42
%110 = add nsw i32 %109, 1
%111 = sext i32 %110 to i64
%112 = getelementptr inbounds float*, float** %108, i64 %111
%113 = load float*, float** %112
%114 = load i32, i32* %41
%115 = sext i32 %114 to i64
%116 = getelementptr inbounds float, float* %113, i64 %115
%117 = load float, float* %116
%118 = load float**, float*** %21
%119 = load i32, i32* %42
%120 = sub nsw i32 %119, 1
%121 = sext i32 %120 to i64
%122 = getelementptr inbounds float*, float** %118, i64 %121
%123 = load float*, float** %122
%124 = load i32, i32* %41
%125 = sext i32 %124 to i64
%126 = getelementptr inbounds float, float* %123, i64 %125
%127 = load float, float* %126
%128 = fadd float %117, %127
%129 = call float @llvm.fmuladd.f32(float %107, float %128, float %104)
%130 = load float*, float** %36
%131 = getelementptr inbounds float, float* %130, i64 0
%132 = load float, float* %131
%133 = load float**, float*** %21
%134 = load i32, i32* %42
%135 = sext i32 %134 to i64
%136 = getelementptr inbounds float*, float** %133, i64 %135
%137 = load float*, float** %136
%138 = load i32, i32* %41
%139 = add nsw i32 %138, 2
%140 = sext i32 %139 to i64
%141 = getelementptr inbounds float, float* %137, i64 %140
%142 = load float, float* %141
%143 = load float**, float*** %21
%144 = load i32, i32* %42
%145 = sext i32 %144 to i64
%146 = getelementptr inbounds float*, float** %143, i64 %145
%147 = load float*, float** %146
%148 = load i32, i32* %41
%149 = sub nsw i32 %148, 2
%150 = sext i32 %149 to i64
%151 = getelementptr inbounds float, float* %147, i64 %150
%152 = load float, float* %151
%153 = fadd float %142, %152
%154 = call float @llvm.fmuladd.f32(float %132, float %153, float %129)
%155 = load float*, float** %36
%156 = getelementptr inbounds float, float* %155, i64 1
%157 = load float, float* %156
%158 = load float**, float*** %21
%159 = load i32, i32* %42
%160 = add nsw i32 %159, 2
%161 = sext i32 %160 to i64
%162 = getelementptr inbounds float*, float** %158, i64 %161
%163 = load float*, float** %162
%164 = load i32, i32* %41
%165 = sext i32 %164 to i64
%166 = getelementptr inbounds float, float* %163, i64 %165
%167 = load float, float* %166
%168 = load float**, float*** %21
%169 = load i32, i32* %42
%170 = sub nsw i32 %169, 2
%171 = sext i32 %170 to i64
%172 = getelementptr inbounds float*, float** %168, i64 %171
%173 = load float*, float** %172
%174 = load i32, i32* %41
%175 = sext i32 %174 to i64
%176 = getelementptr inbounds float, float* %173, i64 %175
%177 = load float, float* %176
%178 = fadd float %167, %177
%179 = call float @llvm.fmuladd.f32(float %157, float %178, float %154)
%180 = load float*, float** %37
%181 = getelementptr inbounds float, float* %180, i64 0
%182 = load float, float* %181
%183 = load float**, float*** %21
%184 = load i32, i32* %42
%185 = sext i32 %184 to i64
%186 = getelementptr inbounds float*, float** %183, i64 %185
%187 = load float*, float** %186
%188 = load i32, i32* %41
%189 = add nsw i32 %188, 3
%190 = sext i32 %189 to i64
%191 = getelementptr inbounds float, float* %187, i64 %190
%192 = load float, float* %191
%193 = load float**, float*** %21
%194 = load i32, i32* %42
%195 = sext i32 %194 to i64
%196 = getelementptr inbounds float*, float** %193, i64 %195
%197 = load float*, float** %196
%198 = load i32, i32* %41
%199 = sub nsw i32 %198, 3
%200 = sext i32 %199 to i64
%201 = getelementptr inbounds float, float* %197, i64 %200
%202 = load float, float* %201
%203 = fadd float %192, %202
%204 = call float @llvm.fmuladd.f32(float %182, float %203, float %179)
%205 = load float*, float** %37
%206 = getelementptr inbounds float, float* %205, i64 1
%207 = load float, float* %206
%208 = load float**, float*** %21
%209 = load i32, i32* %42
%210 = add nsw i32 %209, 3
%211 = sext i32 %210 to i64
%212 = getelementptr inbounds float*, float** %208, i64 %211
%213 = load float*, float** %212
%214 = load i32, i32* %41
%215 = sext i32 %214 to i64
%216 = getelementptr inbounds float, float* %213, i64 %215
%217 = load float, float* %216
%218 = load float**, float*** %21
%219 = load i32, i32* %42
%220 = sub nsw i32 %219, 3
%221 = sext i32 %220 to i64
%222 = getelementptr inbounds float*, float** %218, i64 %221
%223 = load float*, float** %222
%224 = load i32, i32* %41
%225 = sext i32 %224 to i64
%226 = getelementptr inbounds float, float* %223, i64 %225
%227 = load float, float* %226
%228 = fadd float %217, %227
%229 = call float @llvm.fmuladd.f32(float %207, float %228, float %204)
%230 = load float*, float** %38
%231 = getelementptr inbounds float, float* %230, i64 0
%232 = load float, float* %231
%233 = load float**, float*** %21
%234 = load i32, i32* %42
%235 = sext i32 %234 to i64
%236 = getelementptr inbounds float*, float** %233, i64 %235
%237 = load float*, float** %236
%238 = load i32, i32* %41
%239 = add nsw i32 %238, 4
%240 = sext i32 %239 to i64
%241 = getelementptr inbounds float, float* %237, i64 %240
%242 = load float, float* %241
%243 = load float**, float*** %21
%244 = load i32, i32* %42
%245 = sext i32 %244 to i64
%246 = getelementptr inbounds float*, float** %243, i64 %245
%247 = load float*, float** %246
%248 = load i32, i32* %41
%249 = sub nsw i32 %248, 4
%250 = sext i32 %249 to i64
%251 = getelementptr inbounds float, float* %247, i64 %250
%252 = load float, float* %251
%253 = fadd float %242, %252
%254 = call float @llvm.fmuladd.f32(float %232, float %253, float %229)
%255 = load float*, float** %38
%256 = getelementptr inbounds float, float* %255, i64 1
%257 = load float, float* %256
%258 = load float**, float*** %21
%259 = load i32, i32* %42
%260 = add nsw i32 %259, 4
%261 = sext i32 %260 to i64
%262 = getelementptr inbounds float*, float** %258, i64 %261
%263 = load float*, float** %262
%264 = load i32, i32* %41
%265 = sext i32 %264 to i64
%266 = getelementptr inbounds float, float* %263, i64 %265
%267 = load float, float* %266
%268 = load float**, float*** %21
%269 = load i32, i32* %42
%270 = sub nsw i32 %269, 4
%271 = sext i32 %270 to i64
%272 = getelementptr inbounds float*, float** %268, i64 %271
%273 = load float*, float** %272
%274 = load i32, i32* %41
%275 = sext i32 %274 to i64
%276 = getelementptr inbounds float, float* %273, i64 %275
%277 = load float, float* %276
%278 = fadd float %267, %277
%279 = call float @llvm.fmuladd.f32(float %257, float %278, float %254)
store float %279, float* %43
%280 = load float, float* %34
%281 = load float**, float*** %22
%282 = load i32, i32* %42
%283 = sext i32 %282 to i64
%284 = getelementptr inbounds float*, float** %281, i64 %283
%285 = load float*, float** %284
%286 = load i32, i32* %41
%287 = sext i32 %286 to i64
%288 = getelementptr inbounds float, float* %285, i64 %287
%289 = load float, float* %288
%290 = load float*, float** %35
%291 = getelementptr inbounds float, float* %290, i64 0
%292 = load float, float* %291
%293 = load float**, float*** %22
%294 = load i32, i32* %42
%295 = sext i32 %294 to i64
%296 = getelementptr inbounds float*, float** %293, i64 %295
%297 = load float*, float** %296
%298 = load i32, i32* %41
%299 = add nsw i32 %298, 1
%300 = sext i32 %299 to i64
%301 = getelementptr inbounds float, float* %297, i64 %300
%302 = load float, float* %301
%303 = load float**, float*** %22
%304 = load i32, i32* %42
%305 = sext i32 %304 to i64
%306 = getelementptr inbounds float*, float** %303, i64 %305
%307 = load float*, float** %306
%308 = load i32, i32* %41
%309 = sub nsw i32 %308, 1
%310 = sext i32 %309 to i64
%311 = getelementptr inbounds float, float* %307, i64 %310
%312 = load float, float* %311
%313 = fadd float %302, %312
%314 = fmul float %292, %313
%315 = call float @llvm.fmuladd.f32(float %280, float %289, float %314)
%316 = load float*, float** %35
%317 = getelementptr inbounds float, float* %316, i64 1
%318 = load float, float* %317
%319 = load float**, float*** %22
%320 = load i32, i32* %42
%321 = add nsw i32 %320, 1
%322 = sext i32 %321 to i64
%323 = getelementptr inbounds float*, float** %319, i64 %322
%324 = load float*, float** %323
%325 = load i32, i32* %41
%326 = sext i32 %325 to i64
%327 = getelementptr inbounds float, float* %324, i64 %326
%328 = load float, float* %327
%329 = load float**, float*** %22
%330 = load i32, i32* %42
%331 = sub nsw i32 %330, 1
%332 = sext i32 %331 to i64
%333 = getelementptr inbounds float*, float** %329, i64 %332
%334 = load float*, float** %333
%335 = load i32, i32* %41
%336 = sext i32 %335 to i64
%337 = getelementptr inbounds float, float* %334, i64 %336
%338 = load float, float* %337
%339 = fadd float %328, %338
%340 = call float @llvm.fmuladd.f32(float %318, float %339, float %315)
%341 = load float*, float** %36
%342 = getelementptr inbounds float, float* %341, i64 0
%343 = load float, float* %342
%344 = load float**, float*** %22
%345 = load i32, i32* %42
%346 = sext i32 %345 to i64
%347 = getelementptr inbounds float*, float** %344, i64 %346
%348 = load float*, float** %347
%349 = load i32, i32* %41
%350 = add nsw i32 %349, 2
%351 = sext i32 %350 to i64
%352 = getelementptr inbounds float, float* %348, i64 %351
%353 = load float, float* %352
%354 = load float**, float*** %22
%355 = load i32, i32* %42
%356 = sext i32 %355 to i64
%357 = getelementptr inbounds float*, float** %354, i64 %356
%358 = load float*, float** %357
%359 = load i32, i32* %41
%360 = sub nsw i32 %359, 2
%361 = sext i32 %360 to i64
%362 = getelementptr inbounds float, float* %358, i64 %361
%363 = load float, float* %362
%364 = fadd float %353, %363
%365 = call float @llvm.fmuladd.f32(float %343, float %364, float %340)
%366 = load float*, float** %36
%367 = getelementptr inbounds float, float* %366, i64 1
%368 = load float, float* %367
%369 = load float**, float*** %22
%370 = load i32, i32* %42
%371 = add nsw i32 %370, 2
%372 = sext i32 %371 to i64
%373 = getelementptr inbounds float*, float** %369, i64 %372
%374 = load float*, float** %373
%375 = load i32, i32* %41
%376 = sext i32 %375 to i64
%377 = getelementptr inbounds float, float* %374, i64 %376
%378 = load float, float* %377
%379 = load float**, float*** %22
%380 = load i32, i32* %42
%381 = sub nsw i32 %380, 2
%382 = sext i32 %381 to i64
%383 = getelementptr inbounds float*, float** %379, i64 %382
%384 = load float*, float** %383
%385 = load i32, i32* %41
%386 = sext i32 %385 to i64
%387 = getelementptr inbounds float, float* %384, i64 %386
%388 = load float, float* %387
%389 = fadd float %378, %388
%390 = call float @llvm.fmuladd.f32(float %368, float %389, float %365)
%391 = load float*, float** %37
%392 = getelementptr inbounds float, float* %391, i64 0
%393 = load float, float* %392
%394 = load float**, float*** %22
%395 = load i32, i32* %42
%396 = sext i32 %395 to i64
%397 = getelementptr inbounds float*, float** %394, i64 %396
%398 = load float*, float** %397
%399 = load i32, i32* %41
%400 = add nsw i32 %399, 3
%401 = sext i32 %400 to i64
%402 = getelementptr inbounds float, float* %398, i64 %401
%403 = load float, float* %402
%404 = load float**, float*** %22
%405 = load i32, i32* %42
%406 = sext i32 %405 to i64
%407 = getelementptr inbounds float*, float** %404, i64 %406
%408 = load float*, float** %407
%409 = load i32, i32* %41
%410 = sub nsw i32 %409, 3
%411 = sext i32 %410 to i64
%412 = getelementptr inbounds float, float* %408, i64 %411
%413 = load float, float* %412
%414 = fadd float %403, %413
%415 = call float @llvm.fmuladd.f32(float %393, float %414, float %390)
%416 = load float*, float** %37
%417 = getelementptr inbounds float, float* %416, i64 1
%418 = load float, float* %417
%419 = load float**, float*** %22
%420 = load i32, i32* %42
%421 = add nsw i32 %420, 3
%422 = sext i32 %421 to i64
%423 = getelementptr inbounds float*, float** %419, i64 %422
%424 = load float*, float** %423
%425 = load i32, i32* %41
%426 = sext i32 %425 to i64
%427 = getelementptr inbounds float, float* %424, i64 %426
%428 = load float, float* %427
%429 = load float**, float*** %22
%430 = load i32, i32* %42
%431 = sub nsw i32 %430, 3
%432 = sext i32 %431 to i64
%433 = getelementptr inbounds float*, float** %429, i64 %432
%434 = load float*, float** %433
%435 = load i32, i32* %41
%436 = sext i32 %435 to i64
%437 = getelementptr inbounds float, float* %434, i64 %436
%438 = load float, float* %437
%439 = fadd float %428, %438
%440 = call float @llvm.fmuladd.f32(float %418, float %439, float %415)
%441 = load float*, float** %38
%442 = getelementptr inbounds float, float* %441, i64 0
%443 = load float, float* %442
%444 = load float**, float*** %22
%445 = load i32, i32* %42
%446 = sext i32 %445 to i64
%447 = getelementptr inbounds float*, float** %444, i64 %446
%448 = load float*, float** %447
%449 = load i32, i32* %41
%450 = add nsw i32 %449, 4
%451 = sext i32 %450 to i64
%452 = getelementptr inbounds float, float* %448, i64 %451
%453 = load float, float* %452
%454 = load float**, float*** %22
%455 = load i32, i32* %42
%456 = sext i32 %455 to i64
%457 = getelementptr inbounds float*, float** %454, i64 %456
%458 = load float*, float** %457
%459 = load i32, i32* %41
%460 = sub nsw i32 %459, 4
%461 = sext i32 %460 to i64
%462 = getelementptr inbounds float, float* %458, i64 %461
%463 = load float, float* %462
%464 = fadd float %453, %463
%465 = call float @llvm.fmuladd.f32(float %443, float %464, float %440)
%466 = load float*, float** %38
%467 = getelementptr inbounds float, float* %466, i64 1
%468 = load float, float* %467
%469 = load float**, float*** %22
%470 = load i32, i32* %42
%471 = add nsw i32 %470, 4
%472 = sext i32 %471 to i64
%473 = getelementptr inbounds float*, float** %469, i64 %472
%474 = load float*, float** %473
%475 = load i32, i32* %41
%476 = sext i32 %475 to i64
%477 = getelementptr inbounds float, float* %474, i64 %476
%478 = load float, float* %477
%479 = load float**, float*** %22
%480 = load i32, i32* %42
%481 = sub nsw i32 %480, 4
%482 = sext i32 %481 to i64
%483 = getelementptr inbounds float*, float** %479, i64 %482
%484 = load float*, float** %483
%485 = load i32, i32* %41
%486 = sext i32 %485 to i64
%487 = getelementptr inbounds float, float* %484, i64 %486
%488 = load float, float* %487
%489 = fadd float %478, %488
%490 = call float @llvm.fmuladd.f32(float %468, float %489, float %465)
store float %490, float* %44
%491 = load float, float* %34
%492 = load float**, float*** %23
%493 = load i32, i32* %42
%494 = sext i32 %493 to i64
%495 = getelementptr inbounds float*, float** %492, i64 %494
%496 = load float*, float** %495
%497 = load i32, i32* %41
%498 = sext i32 %497 to i64
%499 = getelementptr inbounds float, float* %496, i64 %498
%500 = load float, float* %499
%501 = load float*, float** %35
%502 = getelementptr inbounds float, float* %501, i64 0
%503 = load float, float* %502
%504 = load float**, float*** %23
%505 = load i32, i32* %42
%506 = sext i32 %505 to i64
%507 = getelementptr inbounds float*, float** %504, i64 %506
%508 = load float*, float** %507
%509 = load i32, i32* %41
%510 = add nsw i32 %509, 1
%511 = sext i32 %510 to i64
%512 = getelementptr inbounds float, float* %508, i64 %511
%513 = load float, float* %512
%514 = load float**, float*** %23
%515 = load i32, i32* %42
%516 = sext i32 %515 to i64
%517 = getelementptr inbounds float*, float** %514, i64 %516
%518 = load float*, float** %517
%519 = load i32, i32* %41
%520 = sub nsw i32 %519, 1
%521 = sext i32 %520 to i64
%522 = getelementptr inbounds float, float* %518, i64 %521
%523 = load float, float* %522
%524 = fadd float %513, %523
%525 = fmul float %503, %524
%526 = call float @llvm.fmuladd.f32(float %491, float %500, float %525)
%527 = load float*, float** %35
%528 = getelementptr inbounds float, float* %527, i64 1
%529 = load float, float* %528
%530 = load float**, float*** %23
%531 = load i32, i32* %42
%532 = add nsw i32 %531, 1
%533 = sext i32 %532 to i64
%534 = getelementptr inbounds float*, float** %530, i64 %533
%535 = load float*, float** %534
%536 = load i32, i32* %41
%537 = sext i32 %536 to i64
%538 = getelementptr inbounds float, float* %535, i64 %537
%539 = load float, float* %538
%540 = load float**, float*** %23
%541 = load i32, i32* %42
%542 = sub nsw i32 %541, 1
%543 = sext i32 %542 to i64
%544 = getelementptr inbounds float*, float** %540, i64 %543
%545 = load float*, float** %544
%546 = load i32, i32* %41
%547 = sext i32 %546 to i64
%548 = getelementptr inbounds float, float* %545, i64 %547
%549 = load float, float* %548
%550 = fadd float %539, %549
%551 = call float @llvm.fmuladd.f32(float %529, float %550, float %526)
%552 = load float*, float** %36
%553 = getelementptr inbounds float, float* %552, i64 0
%554 = load float, float* %553
%555 = load float**, float*** %23
%556 = load i32, i32* %42
%557 = sext i32 %556 to i64
%558 = getelementptr inbounds float*, float** %555, i64 %557
%559 = load float*, float** %558
%560 = load i32, i32* %41
%561 = add nsw i32 %560, 2
%562 = sext i32 %561 to i64
%563 = getelementptr inbounds float, float* %559, i64 %562
%564 = load float, float* %563
%565 = load float**, float*** %23
%566 = load i32, i32* %42
%567 = sext i32 %566 to i64
%568 = getelementptr inbounds float*, float** %565, i64 %567
%569 = load float*, float** %568
%570 = load i32, i32* %41
%571 = sub nsw i32 %570, 2
%572 = sext i32 %571 to i64
%573 = getelementptr inbounds float, float* %569, i64 %572
%574 = load float, float* %573
%575 = fadd float %564, %574
%576 = call float @llvm.fmuladd.f32(float %554, float %575, float %551)
%577 = load float*, float** %36
%578 = getelementptr inbounds float, float* %577, i64 1
%579 = load float, float* %578
%580 = load float**, float*** %23
%581 = load i32, i32* %42
%582 = add nsw i32 %581, 2
%583 = sext i32 %582 to i64
%584 = getelementptr inbounds float*, float** %580, i64 %583
%585 = load float*, float** %584
%586 = load i32, i32* %41
%587 = sext i32 %586 to i64
%588 = getelementptr inbounds float, float* %585, i64 %587
%589 = load float, float* %588
%590 = load float**, float*** %23
%591 = load i32, i32* %42
%592 = sub nsw i32 %591, 2
%593 = sext i32 %592 to i64
%594 = getelementptr inbounds float*, float** %590, i64 %593
%595 = load float*, float** %594
%596 = load i32, i32* %41
%597 = sext i32 %596 to i64
%598 = getelementptr inbounds float, float* %595, i64 %597
%599 = load float, float* %598
%600 = fadd float %589, %599
%601 = call float @llvm.fmuladd.f32(float %579, float %600, float %576)
%602 = load float*, float** %37
%603 = getelementptr inbounds float, float* %602, i64 0
%604 = load float, float* %603
%605 = load float**, float*** %23
%606 = load i32, i32* %42
%607 = sext i32 %606 to i64
%608 = getelementptr inbounds float*, float** %605, i64 %607
%609 = load float*, float** %608
%610 = load i32, i32* %41
%611 = add nsw i32 %610, 3
%612 = sext i32 %611 to i64
%613 = getelementptr inbounds float, float* %609, i64 %612
%614 = load float, float* %613
%615 = load float**, float*** %23
%616 = load i32, i32* %42
%617 = sext i32 %616 to i64
%618 = getelementptr inbounds float*, float** %615, i64 %617
%619 = load float*, float** %618
%620 = load i32, i32* %41
%621 = sub nsw i32 %620, 3
%622 = sext i32 %621 to i64
%623 = getelementptr inbounds float, float* %619, i64 %622
%624 = load float, float* %623
%625 = fadd float %614, %624
%626 = call float @llvm.fmuladd.f32(float %604, float %625, float %601)
%627 = load float*, float** %37
%628 = getelementptr inbounds float, float* %627, i64 1
%629 = load float, float* %628
%630 = load float**, float*** %23
%631 = load i32, i32* %42
%632 = add nsw i32 %631, 3
%633 = sext i32 %632 to i64
%634 = getelementptr inbounds float*, float** %630, i64 %633
%635 = load float*, float** %634
%636 = load i32, i32* %41
%637 = sext i32 %636 to i64
%638 = getelementptr inbounds float, float* %635, i64 %637
%639 = load float, float* %638
%640 = load float**, float*** %23
%641 = load i32, i32* %42
%642 = sub nsw i32 %641, 3
%643 = sext i32 %642 to i64
%644 = getelementptr inbounds float*, float** %640, i64 %643
%645 = load float*, float** %644
%646 = load i32, i32* %41
%647 = sext i32 %646 to i64
%648 = getelementptr inbounds float, float* %645, i64 %647
%649 = load float, float* %648
%650 = fadd float %639, %649
%651 = call float @llvm.fmuladd.f32(float %629, float %650, float %626)
%652 = load float*, float** %38
%653 = getelementptr inbounds float, float* %652, i64 0
%654 = load float, float* %653
%655 = load float**, float*** %23
%656 = load i32, i32* %42
%657 = sext i32 %656 to i64
%658 = getelementptr inbounds float*, float** %655, i64 %657
%659 = load float*, float** %658
%660 = load i32, i32* %41
%661 = add nsw i32 %660, 4
%662 = sext i32 %661 to i64
%663 = getelementptr inbounds float, float* %659, i64 %662
%664 = load float, float* %663
%665 = load float**, float*** %23
%666 = load i32, i32* %42
%667 = sext i32 %666 to i64
%668 = getelementptr inbounds float*, float** %665, i64 %667
%669 = load float*, float** %668
%670 = load i32, i32* %41
%671 = sub nsw i32 %670, 4
%672 = sext i32 %671 to i64
%673 = getelementptr inbounds float, float* %669, i64 %672
%674 = load float, float* %673
%675 = fadd float %664, %674
%676 = call float @llvm.fmuladd.f32(float %654, float %675, float %651)
%677 = load float*, float** %38
%678 = getelementptr inbounds float, float* %677, i64 1
%679 = load float, float* %678
%680 = load float**, float*** %23
%681 = load i32, i32* %42
%682 = add nsw i32 %681, 4
%683 = sext i32 %682 to i64
%684 = getelementptr inbounds float*, float** %680, i64 %683
%685 = load float*, float** %684
%686 = load i32, i32* %41
%687 = sext i32 %686 to i64
%688 = getelementptr inbounds float, float* %685, i64 %687
%689 = load float, float* %688
%690 = load float**, float*** %23
%691 = load i32, i32* %42
%692 = sub nsw i32 %691, 4
%693 = sext i32 %692 to i64
%694 = getelementptr inbounds float*, float** %690, i64 %693
%695 = load float*, float** %694
%696 = load i32, i32* %41
%697 = sext i32 %696 to i64
%698 = getelementptr inbounds float, float* %695, i64 %697
%699 = load float, float* %698
%700 = fadd float %689, %699
%701 = call float @llvm.fmuladd.f32(float %679, float %700, float %676)
store float %701, float* %45
%702 = load float, float* %34
%703 = load float**, float*** %24
%704 = load i32, i32* %42
%705 = sext i32 %704 to i64
%706 = getelementptr inbounds float*, float** %703, i64 %705
%707 = load float*, float** %706
%708 = load i32, i32* %41
%709 = sext i32 %708 to i64
%710 = getelementptr inbounds float, float* %707, i64 %709
%711 = load float, float* %710
%712 = load float*, float** %35
%713 = getelementptr inbounds float, float* %712, i64 0
%714 = load float, float* %713
%715 = load float**, float*** %24
%716 = load i32, i32* %42
%717 = sext i32 %716 to i64
%718 = getelementptr inbounds float*, float** %715, i64 %717
%719 = load float*, float** %718
%720 = load i32, i32* %41
%721 = add nsw i32 %720, 1
%722 = sext i32 %721 to i64
%723 = getelementptr inbounds float, float* %719, i64 %722
%724 = load float, float* %723
%725 = load float**, float*** %24
%726 = load i32, i32* %42
%727 = sext i32 %726 to i64
%728 = getelementptr inbounds float*, float** %725, i64 %727
%729 = load float*, float** %728
%730 = load i32, i32* %41
%731 = sub nsw i32 %730, 1
%732 = sext i32 %731 to i64
%733 = getelementptr inbounds float, float* %729, i64 %732
%734 = load float, float* %733
%735 = fadd float %724, %734
%736 = fmul float %714, %735
%737 = call float @llvm.fmuladd.f32(float %702, float %711, float %736)
%738 = load float*, float** %35
%739 = getelementptr inbounds float, float* %738, i64 1
%740 = load float, float* %739
%741 = load float**, float*** %24
%742 = load i32, i32* %42
%743 = add nsw i32 %742, 1
%744 = sext i32 %743 to i64
%745 = getelementptr inbounds float*, float** %741, i64 %744
%746 = load float*, float** %745
%747 = load i32, i32* %41
%748 = sext i32 %747 to i64
%749 = getelementptr inbounds float, float* %746, i64 %748
%750 = load float, float* %749
%751 = load float**, float*** %24
%752 = load i32, i32* %42
%753 = sub nsw i32 %752, 1
%754 = sext i32 %753 to i64
%755 = getelementptr inbounds float*, float** %751, i64 %754
%756 = load float*, float** %755
%757 = load i32, i32* %41
%758 = sext i32 %757 to i64
%759 = getelementptr inbounds float, float* %756, i64 %758
%760 = load float, float* %759
%761 = fadd float %750, %760
%762 = call float @llvm.fmuladd.f32(float %740, float %761, float %737)
%763 = load float*, float** %36
%764 = getelementptr inbounds float, float* %763, i64 0
%765 = load float, float* %764
%766 = load float**, float*** %24
%767 = load i32, i32* %42
%768 = sext i32 %767 to i64
%769 = getelementptr inbounds float*, float** %766, i64 %768
%770 = load float*, float** %769
%771 = load i32, i32* %41
%772 = add nsw i32 %771, 2
%773 = sext i32 %772 to i64
%774 = getelementptr inbounds float, float* %770, i64 %773
%775 = load float, float* %774
%776 = load float**, float*** %24
%777 = load i32, i32* %42
%778 = sext i32 %777 to i64
%779 = getelementptr inbounds float*, float** %776, i64 %778
%780 = load float*, float** %779
%781 = load i32, i32* %41
%782 = sub nsw i32 %781, 2
%783 = sext i32 %782 to i64
%784 = getelementptr inbounds float, float* %780, i64 %783
%785 = load float, float* %784
%786 = fadd float %775, %785
%787 = call float @llvm.fmuladd.f32(float %765, float %786, float %762)
%788 = load float*, float** %36
%789 = getelementptr inbounds float, float* %788, i64 1
%790 = load float, float* %789
%791 = load float**, float*** %24
%792 = load i32, i32* %42
%793 = add nsw i32 %792, 2
%794 = sext i32 %793 to i64
%795 = getelementptr inbounds float*, float** %791, i64 %794
%796 = load float*, float** %795
%797 = load i32, i32* %41
%798 = sext i32 %797 to i64
%799 = getelementptr inbounds float, float* %796, i64 %798
%800 = load float, float* %799
%801 = load float**, float*** %24
%802 = load i32, i32* %42
%803 = sub nsw i32 %802, 2
%804 = sext i32 %803 to i64
%805 = getelementptr inbounds float*, float** %801, i64 %804
%806 = load float*, float** %805
%807 = load i32, i32* %41
%808 = sext i32 %807 to i64
%809 = getelementptr inbounds float, float* %806, i64 %808
%810 = load float, float* %809
%811 = fadd float %800, %810
%812 = call float @llvm.fmuladd.f32(float %790, float %811, float %787)
%813 = load float*, float** %37
%814 = getelementptr inbounds float, float* %813, i64 0
%815 = load float, float* %814
%816 = load float**, float*** %24
%817 = load i32, i32* %42
%818 = sext i32 %817 to i64
%819 = getelementptr inbounds float*, float** %816, i64 %818
%820 = load float*, float** %819
%821 = load i32, i32* %41
%822 = add nsw i32 %821, 3
%823 = sext i32 %822 to i64
%824 = getelementptr inbounds float, float* %820, i64 %823
%825 = load float, float* %824
%826 = load float**, float*** %24
%827 = load i32, i32* %42
%828 = sext i32 %827 to i64
%829 = getelementptr inbounds float*, float** %826, i64 %828
%830 = load float*, float** %829
%831 = load i32, i32* %41
%832 = sub nsw i32 %831, 3
%833 = sext i32 %832 to i64
%834 = getelementptr inbounds float, float* %830, i64 %833
%835 = load float, float* %834
%836 = fadd float %825, %835
%837 = call float @llvm.fmuladd.f32(float %815, float %836, float %812)
%838 = load float*, float** %37
%839 = getelementptr inbounds float, float* %838, i64 1
%840 = load float, float* %839
%841 = load float**, float*** %24
%842 = load i32, i32* %42
%843 = add nsw i32 %842, 3
%844 = sext i32 %843 to i64
%845 = getelementptr inbounds float*, float** %841, i64 %844
%846 = load float*, float** %845
%847 = load i32, i32* %41
%848 = sext i32 %847 to i64
%849 = getelementptr inbounds float, float* %846, i64 %848
%850 = load float, float* %849
%851 = load float**, float*** %24
%852 = load i32, i32* %42
%853 = sub nsw i32 %852, 3
%854 = sext i32 %853 to i64
%855 = getelementptr inbounds float*, float** %851, i64 %854
%856 = load float*, float** %855
%857 = load i32, i32* %41
%858 = sext i32 %857 to i64
%859 = getelementptr inbounds float, float* %856, i64 %858
%860 = load float, float* %859
%861 = fadd float %850, %860
%862 = call float @llvm.fmuladd.f32(float %840, float %861, float %837)
%863 = load float*, float** %38
%864 = getelementptr inbounds float, float* %863, i64 0
%865 = load float, float* %864
%866 = load float**, float*** %24
%867 = load i32, i32* %42
%868 = sext i32 %867 to i64
%869 = getelementptr inbounds float*, float** %866, i64 %868
%870 = load float*, float** %869
%871 = load i32, i32* %41
%872 = add nsw i32 %871, 4
%873 = sext i32 %872 to i64
%874 = getelementptr inbounds float, float* %870, i64 %873
%875 = load float, float* %874
%876 = load float**, float*** %24
%877 = load i32, i32* %42
%878 = sext i32 %877 to i64
%879 = getelementptr inbounds float*, float** %876, i64 %878
%880 = load float*, float** %879
%881 = load i32, i32* %41
%882 = sub nsw i32 %881, 4
%883 = sext i32 %882 to i64
%884 = getelementptr inbounds float, float* %880, i64 %883
%885 = load float, float* %884
%886 = fadd float %875, %885
%887 = call float @llvm.fmuladd.f32(float %865, float %886, float %862)
%888 = load float*, float** %38
%889 = getelementptr inbounds float, float* %888, i64 1
%890 = load float, float* %889
%891 = load float**, float*** %24
%892 = load i32, i32* %42
%893 = add nsw i32 %892, 4
%894 = sext i32 %893 to i64
%895 = getelementptr inbounds float*, float** %891, i64 %894
%896 = load float*, float** %895
%897 = load i32, i32* %41
%898 = sext i32 %897 to i64
%899 = getelementptr inbounds float, float* %896, i64 %898
%900 = load float, float* %899
%901 = load float**, float*** %24
%902 = load i32, i32* %42
%903 = sub nsw i32 %902, 4
%904 = sext i32 %903 to i64
%905 = getelementptr inbounds float*, float** %901, i64 %904
%906 = load float*, float** %905
%907 = load i32, i32* %41
%908 = sext i32 %907 to i64
%909 = getelementptr inbounds float, float* %906, i64 %908
%910 = load float, float* %909
%911 = fadd float %900, %910
%912 = call float @llvm.fmuladd.f32(float %890, float %911, float %887)
store float %912, float* %46
%913 = load float**, float*** %24
%914 = load i32, i32* %42
%915 = sext i32 %914 to i64
%916 = getelementptr inbounds float*, float** %913, i64 %915
%917 = load float*, float** %916
%918 = load i32, i32* %41
%919 = sext i32 %918 to i64
%920 = getelementptr inbounds float, float* %917, i64 %919
%921 = load float, float* %920
%922 = fpext float %921 to double
%923 = load float**, float*** %28
%924 = load i32, i32* %42
%925 = sext i32 %924 to i64
%926 = getelementptr inbounds float*, float** %923, i64 %925
%927 = load float*, float** %926
%928 = load i32, i32* %41
%929 = sext i32 %928 to i64
%930 = getelementptr inbounds float, float* %927, i64 %929
%931 = load float, float* %930
%932 = fpext float %931 to double
%933 = fneg double %932
%934 = call double @llvm.fmuladd.f64(double 2.000000e+00, double %922, double %933)
%935 = load float**, float*** %31
%936 = load i32, i32* %42
%937 = sext i32 %936 to i64
%938 = getelementptr inbounds float*, float** %935, i64 %937
%939 = load float*, float** %938
%940 = load i32, i32* %41
%941 = sext i32 %940 to i64
%942 = getelementptr inbounds float, float* %939, i64 %941
%943 = load float, float* %942
%944 = load float, float* %44
%945 = fmul float %943, %944
%946 = fpext float %945 to double
%947 = fadd double %934, %946
%948 = load float**, float*** %30
%949 = load i32, i32* %42
%950 = sext i32 %949 to i64
%951 = getelementptr inbounds float*, float** %948, i64 %950
%952 = load float*, float** %951
%953 = load i32, i32* %41
%954 = sext i32 %953 to i64
%955 = getelementptr inbounds float, float* %952, i64 %954
%956 = load float, float* %955
%957 = load float, float* %45
%958 = fmul float %956, %957
%959 = fpext float %958 to double
%960 = fadd double %947, %959
%961 = load float**, float*** %29
%962 = load i32, i32* %42
%963 = sext i32 %962 to i64
%964 = getelementptr inbounds float*, float** %961, i64 %963
%965 = load float*, float** %964
%966 = load i32, i32* %41
%967 = sext i32 %966 to i64
%968 = getelementptr inbounds float, float* %965, i64 %967
%969 = load float, float* %968
%970 = load float, float* %46
%971 = fmul float %969, %970
%972 = fpext float %971 to double
%973 = fadd double %960, %972
%974 = fptrunc double %973 to float
%975 = load float**, float*** %28
%976 = load i32, i32* %42
%977 = sext i32 %976 to i64
%978 = getelementptr inbounds float*, float** %975, i64 %977
%979 = load float*, float** %978
%980 = load i32, i32* %41
%981 = sext i32 %980 to i64
%982 = getelementptr inbounds float, float* %979, i64 %981
store float %974, float* %982
%983 = load float**, float*** %23
%984 = load i32, i32* %42
%985 = sext i32 %984 to i64
%986 = getelementptr inbounds float*, float** %983, i64 %985
%987 = load float*, float** %986
%988 = load i32, i32* %41
%989 = sext i32 %988 to i64
%990 = getelementptr inbounds float, float* %987, i64 %989
%991 = load float, float* %990
%992 = fpext float %991 to double
%993 = load float**, float*** %27
%994 = load i32, i32* %42
%995 = sext i32 %994 to i64
%996 = getelementptr inbounds float*, float** %993, i64 %995
%997 = load float*, float** %996
%998 = load i32, i32* %41
%999 = sext i32 %998 to i64
%1000 = getelementptr inbounds float, float* %997, i64 %999
%1001 = load float, float* %1000
%1002 = fpext float %1001 to double
%1003 = fneg double %1002
%1004 = call double @llvm.fmuladd.f64(double 2.000000e+00, double %992, double %1003)
%1005 = load float**, float*** %31
%1006 = load i32, i32* %42
%1007 = sext i32 %1006 to i64
%1008 = getelementptr inbounds float*, float** %1005, i64 %1007
%1009 = load float*, float** %1008
%1010 = load i32, i32* %41
%1011 = sext i32 %1010 to i64
%1012 = getelementptr inbounds float, float* %1009, i64 %1011
%1013 = load float, float* %1012
%1014 = load float, float* %43
%1015 = fmul float %1013, %1014
%1016 = fpext float %1015 to double
%1017 = fadd double %1004, %1016
%1018 = load float**, float*** %29
%1019 = load i32, i32* %42
%1020 = sext i32 %1019 to i64
%1021 = getelementptr inbounds float*, float** %1018, i64 %1020
%1022 = load float*, float** %1021
%1023 = load i32, i32* %41
%1024 = sext i32 %1023 to i64
%1025 = getelementptr inbounds float, float* %1022, i64 %1024
%1026 = load float, float* %1025
%1027 = load float, float* %45
%1028 = fmul float %1026, %1027
%1029 = fpext float %1028 to double
%1030 = fadd double %1017, %1029
%1031 = fptrunc double %1030 to float
%1032 = load float**, float*** %27
%1033 = load i32, i32* %42
%1034 = sext i32 %1033 to i64
%1035 = getelementptr inbounds float*, float** %1032, i64 %1034
%1036 = load float*, float** %1035
%1037 = load i32, i32* %41
%1038 = sext i32 %1037 to i64
%1039 = getelementptr inbounds float, float* %1036, i64 %1038
store float %1031, float* %1039
%1040 = load float**, float*** %22
%1041 = load i32, i32* %42
%1042 = sext i32 %1041 to i64
%1043 = getelementptr inbounds float*, float** %1040, i64 %1042
%1044 = load float*, float** %1043
%1045 = load i32, i32* %41
%1046 = sext i32 %1045 to i64
%1047 = getelementptr inbounds float, float* %1044, i64 %1046
%1048 = load float, float* %1047
%1049 = fpext float %1048 to double
%1050 = load float**, float*** %26
%1051 = load i32, i32* %42
%1052 = sext i32 %1051 to i64
%1053 = getelementptr inbounds float*, float** %1050, i64 %1052
%1054 = load float*, float** %1053
%1055 = load i32, i32* %41
%1056 = sext i32 %1055 to i64
%1057 = getelementptr inbounds float, float* %1054, i64 %1056
%1058 = load float, float* %1057
%1059 = fpext float %1058 to double
%1060 = fneg double %1059
%1061 = call double @llvm.fmuladd.f64(double 2.000000e+00, double %1049, double %1060)
%1062 = load float**, float*** %30
%1063 = load i32, i32* %42
%1064 = sext i32 %1063 to i64
%1065 = getelementptr inbounds float*, float** %1062, i64 %1064
%1066 = load float*, float** %1065
%1067 = load i32, i32* %41
%1068 = sext i32 %1067 to i64
%1069 = getelementptr inbounds float, float* %1066, i64 %1068
%1070 = load float, float* %1069
%1071 = load float, float* %43
%1072 = fmul float %1070, %1071
%1073 = fpext float %1072 to double
%1074 = fadd double %1061, %1073
%1075 = load float**, float*** %29
%1076 = load i32, i32* %42
%1077 = sext i32 %1076 to i64
%1078 = getelementptr inbounds float*, float** %1075, i64 %1077
%1079 = load float*, float** %1078
%1080 = load i32, i32* %41
%1081 = sext i32 %1080 to i64
%1082 = getelementptr inbounds float, float* %1079, i64 %1081
%1083 = load float, float* %1082
%1084 = load float, float* %44
%1085 = fmul float %1083, %1084
%1086 = fpext float %1085 to double
%1087 = fadd double %1074, %1086
%1088 = fptrunc double %1087 to float
%1089 = load float**, float*** %26
%1090 = load i32, i32* %42
%1091 = sext i32 %1090 to i64
%1092 = getelementptr inbounds float*, float** %1089, i64 %1091
%1093 = load float*, float** %1092
%1094 = load i32, i32* %41
%1095 = sext i32 %1094 to i64
%1096 = getelementptr inbounds float, float* %1093, i64 %1095
store float %1088, float* %1096
%1097 = load float**, float*** %21
%1098 = load i32, i32* %42
%1099 = sext i32 %1098 to i64
%1100 = getelementptr inbounds float*, float** %1097, i64 %1099
%1101 = load float*, float** %1100
%1102 = load i32, i32* %41
%1103 = sext i32 %1102 to i64
%1104 = getelementptr inbounds float, float* %1101, i64 %1103
%1105 = load float, float* %1104
%1106 = fpext float %1105 to double
%1107 = load float**, float*** %25
%1108 = load i32, i32* %42
%1109 = sext i32 %1108 to i64
%1110 = getelementptr inbounds float*, float** %1107, i64 %1109
%1111 = load float*, float** %1110
%1112 = load i32, i32* %41
%1113 = sext i32 %1112 to i64
%1114 = getelementptr inbounds float, float* %1111, i64 %1113
%1115 = load float, float* %1114
%1116 = fpext float %1115 to double
%1117 = fneg double %1116
%1118 = call double @llvm.fmuladd.f64(double 2.000000e+00, double %1106, double %1117)
%1119 = load float**, float*** %29
%1120 = load i32, i32* %42
%1121 = sext i32 %1120 to i64
%1122 = getelementptr inbounds float*, float** %1119, i64 %1121
%1123 = load float*, float** %1122
%1124 = load i32, i32* %41
%1125 = sext i32 %1124 to i64
%1126 = getelementptr inbounds float, float* %1123, i64 %1125
%1127 = load float, float* %1126
%1128 = load float, float* %43
%1129 = fmul float %1127, %1128
%1130 = fpext float %1129 to double
%1131 = fadd double %1118, %1130
%1132 = fptrunc double %1131 to float
%1133 = load float**, float*** %25
%1134 = load i32, i32* %42
%1135 = sext i32 %1134 to i64
%1136 = getelementptr inbounds float*, float** %1133, i64 %1135
%1137 = load float*, float** %1136
%1138 = load i32, i32* %41
%1139 = sext i32 %1138 to i64
%1140 = getelementptr inbounds float, float* %1137, i64 %1139
store float %1132, float* %1140
br label %1141
1141: ; preds = %68
%1142 = load i32, i32* %41
%1143 = add nsw i32 %1142, 1
store i32 %1143, i32* %41
br label %61
1144: ; preds = %61
br label %1145
1145: ; preds = %1144
%1146 = load i32, i32* %42
%1147 = add nsw i32 %1146, 1
store i32 %1147, i32* %42
br label %50
1148: ; preds = %50
%1149 = load i32*, i32** %39
%1150 = getelementptr inbounds i32, i32* %1149, i64 1
%1151 = load i32, i32* %1150
%1152 = icmp ne i32 %1151, 0
br i1 %1152, label %1153, label %1457
1153: ; preds = %1148
%1154 = load i32*, i32** %32
%1155 = getelementptr inbounds i32, i32* %1154, i64 0
%1156 = load i32, i32* %1155
store i32 %1156, i32* %41
br label %1157
1157: ; preds = %1453, %1153
%1158 = load i32, i32* %41
%1159 = load i32*, i32** %33
%1160 = getelementptr inbounds i32, i32* %1159, i64 0
%1161 = load i32, i32* %1160
%1162 = add nsw i32 %1161, 1
%1163 = icmp slt i32 %1158, %1162
br i1 %1163, label %1164, label %1456
1164: ; preds = %1157
%1165 = load float**, float*** %28
%1166 = load i32*, i32** %32
%1167 = getelementptr inbounds i32, i32* %1166, i64 1
%1168 = load i32, i32* %1167
%1169 = add nsw i32 %1168, 0
%1170 = sext i32 %1169 to i64
%1171 = getelementptr inbounds float*, float** %1165, i64 %1170
%1172 = load float*, float** %1171
%1173 = load i32, i32* %41
%1174 = sext i32 %1173 to i64
%1175 = getelementptr inbounds float, float* %1172, i64 %1174
%1176 = load float, float* %1175
%1177 = fneg float %1176
%1178 = load float**, float*** %28
%1179 = load i32*, i32** %32
%1180 = getelementptr inbounds i32, i32* %1179, i64 1
%1181 = load i32, i32* %1180
%1182 = sub nsw i32 %1181, 2
%1183 = sext i32 %1182 to i64
%1184 = getelementptr inbounds float*, float** %1178, i64 %1183
%1185 = load float*, float** %1184
%1186 = load i32, i32* %41
%1187 = sext i32 %1186 to i64
%1188 = getelementptr inbounds float, float* %1185, i64 %1187
store float %1177, float* %1188
%1189 = load float**, float*** %27
%1190 = load i32*, i32** %32
%1191 = getelementptr inbounds i32, i32* %1190, i64 1
%1192 = load i32, i32* %1191
%1193 = add nsw i32 %1192, 0
%1194 = sext i32 %1193 to i64
%1195 = getelementptr inbounds float*, float** %1189, i64 %1194
%1196 = load float*, float** %1195
%1197 = load i32, i32* %41
%1198 = sext i32 %1197 to i64
%1199 = getelementptr inbounds float, float* %1196, i64 %1198
%1200 = load float, float* %1199
%1201 = fneg float %1200
%1202 = load float**, float*** %27
%1203 = load i32*, i32** %32
%1204 = getelementptr inbounds i32, i32* %1203, i64 1
%1205 = load i32, i32* %1204
%1206 = sub nsw i32 %1205, 2
%1207 = sext i32 %1206 to i64
%1208 = getelementptr inbounds float*, float** %1202, i64 %1207
%1209 = load float*, float** %1208
%1210 = load i32, i32* %41
%1211 = sext i32 %1210 to i64
%1212 = getelementptr inbounds float, float* %1209, i64 %1211
store float %1201, float* %1212
%1213 = load float**, float*** %26
%1214 = load i32*, i32** %32
%1215 = getelementptr inbounds i32, i32* %1214, i64 1
%1216 = load i32, i32* %1215
%1217 = add nsw i32 %1216, 0
%1218 = sext i32 %1217 to i64
%1219 = getelementptr inbounds float*, float** %1213, i64 %1218
%1220 = load float*, float** %1219
%1221 = load i32, i32* %41
%1222 = sext i32 %1221 to i64
%1223 = getelementptr inbounds float, float* %1220, i64 %1222
%1224 = load float, float* %1223
%1225 = fneg float %1224
%1226 = load float**, float*** %26
%1227 = load i32*, i32** %32
%1228 = getelementptr inbounds i32, i32* %1227, i64 1
%1229 = load i32, i32* %1228
%1230 = sub nsw i32 %1229, 2
%1231 = sext i32 %1230 to i64
%1232 = getelementptr inbounds float*, float** %1226, i64 %1231
%1233 = load float*, float** %1232
%1234 = load i32, i32* %41
%1235 = sext i32 %1234 to i64
%1236 = getelementptr inbounds float, float* %1233, i64 %1235
store float %1225, float* %1236
%1237 = load float**, float*** %25
%1238 = load i32*, i32** %32
%1239 = getelementptr inbounds i32, i32* %1238, i64 1
%1240 = load i32, i32* %1239
%1241 = add nsw i32 %1240, 0
%1242 = sext i32 %1241 to i64
%1243 = getelementptr inbounds float*, float** %1237, i64 %1242
%1244 = load float*, float** %1243
%1245 = load i32, i32* %41
%1246 = sext i32 %1245 to i64
%1247 = getelementptr inbounds float, float* %1244, i64 %1246
%1248 = load float, float* %1247
%1249 = fneg float %1248
%1250 = load float**, float*** %25
%1251 = load i32*, i32** %32
%1252 = getelementptr inbounds i32, i32* %1251, i64 1
%1253 = load i32, i32* %1252
%1254 = sub nsw i32 %1253, 2
%1255 = sext i32 %1254 to i64
%1256 = getelementptr inbounds float*, float** %1250, i64 %1255
%1257 = load float*, float** %1256
%1258 = load i32, i32* %41
%1259 = sext i32 %1258 to i64
%1260 = getelementptr inbounds float, float* %1257, i64 %1259
store float %1249, float* %1260
%1261 = load float**, float*** %28
%1262 = load i32*, i32** %32
%1263 = getelementptr inbounds i32, i32* %1262, i64 1
%1264 = load i32, i32* %1263
%1265 = add nsw i32 %1264, 1
%1266 = sext i32 %1265 to i64
%1267 = getelementptr inbounds float*, float** %1261, i64 %1266
%1268 = load float*, float** %1267
%1269 = load i32, i32* %41
%1270 = sext i32 %1269 to i64
%1271 = getelementptr inbounds float, float* %1268, i64 %1270
%1272 = load float, float* %1271
%1273 = fneg float %1272
%1274 = load float**, float*** %28
%1275 = load i32*, i32** %32
%1276 = getelementptr inbounds i32, i32* %1275, i64 1
%1277 = load i32, i32* %1276
%1278 = sub nsw i32 %1277, 3
%1279 = sext i32 %1278 to i64
%1280 = getelementptr inbounds float*, float** %1274, i64 %1279
%1281 = load float*, float** %1280
%1282 = load i32, i32* %41
%1283 = sext i32 %1282 to i64
%1284 = getelementptr inbounds float, float* %1281, i64 %1283
store float %1273, float* %1284
%1285 = load float**, float*** %27
%1286 = load i32*, i32** %32
%1287 = getelementptr inbounds i32, i32* %1286, i64 1
%1288 = load i32, i32* %1287
%1289 = add nsw i32 %1288, 1
%1290 = sext i32 %1289 to i64
%1291 = getelementptr inbounds float*, float** %1285, i64 %1290
%1292 = load float*, float** %1291
%1293 = load i32, i32* %41
%1294 = sext i32 %1293 to i64
%1295 = getelementptr inbounds float, float* %1292, i64 %1294
%1296 = load float, float* %1295
%1297 = fneg float %1296
%1298 = load float**, float*** %27
%1299 = load i32*, i32** %32
%1300 = getelementptr inbounds i32, i32* %1299, i64 1
%1301 = load i32, i32* %1300
%1302 = sub nsw i32 %1301, 3
%1303 = sext i32 %1302 to i64
%1304 = getelementptr inbounds float*, float** %1298, i64 %1303
%1305 = load float*, float** %1304
%1306 = load i32, i32* %41
%1307 = sext i32 %1306 to i64
%1308 = getelementptr inbounds float, float* %1305, i64 %1307
store float %1297, float* %1308
%1309 = load float**, float*** %26
%1310 = load i32*, i32** %32
%1311 = getelementptr inbounds i32, i32* %1310, i64 1
%1312 = load i32, i32* %1311
%1313 = add nsw i32 %1312, 1
%1314 = sext i32 %1313 to i64
%1315 = getelementptr inbounds float*, float** %1309, i64 %1314
%1316 = load float*, float** %1315
%1317 = load i32, i32* %41
%1318 = sext i32 %1317 to i64
%1319 = getelementptr inbounds float, float* %1316, i64 %1318
%1320 = load float, float* %1319
%1321 = fneg float %1320
%1322 = load float**, float*** %26
%1323 = load i32*, i32** %32
%1324 = getelementptr inbounds i32, i32* %1323, i64 1
%1325 = load i32, i32* %1324
%1326 = sub nsw i32 %1325, 3
%1327 = sext i32 %1326 to i64
%1328 = getelementptr inbounds float*, float** %1322, i64 %1327
%1329 = load float*, float** %1328
%1330 = load i32, i32* %41
%1331 = sext i32 %1330 to i64
%1332 = getelementptr inbounds float, float* %1329, i64 %1331
store float %1321, float* %1332
%1333 = load float**, float*** %25
%1334 = load i32*, i32** %32
%1335 = getelementptr inbounds i32, i32* %1334, i64 1
%1336 = load i32, i32* %1335
%1337 = add nsw i32 %1336, 1
%1338 = sext i32 %1337 to i64
%1339 = getelementptr inbounds float*, float** %1333, i64 %1338
%1340 = load float*, float** %1339
%1341 = load i32, i32* %41
%1342 = sext i32 %1341 to i64
%1343 = getelementptr inbounds float, float* %1340, i64 %1342
%1344 = load float, float* %1343
%1345 = fneg float %1344
%1346 = load float**, float*** %25
%1347 = load i32*, i32** %32
%1348 = getelementptr inbounds i32, i32* %1347, i64 1
%1349 = load i32, i32* %1348
%1350 = sub nsw i32 %1349, 3
%1351 = sext i32 %1350 to i64
%1352 = getelementptr inbounds float*, float** %1346, i64 %1351
%1353 = load float*, float** %1352
%1354 = load i32, i32* %41
%1355 = sext i32 %1354 to i64
%1356 = getelementptr inbounds float, float* %1353, i64 %1355
store float %1345, float* %1356
%1357 = load float**, float*** %28
%1358 = load i32*, i32** %32
%1359 = getelementptr inbounds i32, i32* %1358, i64 1
%1360 = load i32, i32* %1359
%1361 = add nsw i32 %1360, 2
%1362 = sext i32 %1361 to i64
%1363 = getelementptr inbounds float*, float** %1357, i64 %1362
%1364 = load float*, float** %1363
%1365 = load i32, i32* %41
%1366 = sext i32 %1365 to i64
%1367 = getelementptr inbounds float, float* %1364, i64 %1366
%1368 = load float, float* %1367
%1369 = fneg float %1368
%1370 = load float**, float*** %28
%1371 = load i32*, i32** %32
%1372 = getelementptr inbounds i32, i32* %1371, i64 1
%1373 = load i32, i32* %1372
%1374 = sub nsw i32 %1373, 4
%1375 = sext i32 %1374 to i64
%1376 = getelementptr inbounds float*, float** %1370, i64 %1375
%1377 = load float*, float** %1376
%1378 = load i32, i32* %41
%1379 = sext i32 %1378 to i64
%1380 = getelementptr inbounds float, float* %1377, i64 %1379
store float %1369, float* %1380
%1381 = load float**, float*** %27
%1382 = load i32*, i32** %32
%1383 = getelementptr inbounds i32, i32* %1382, i64 1
%1384 = load i32, i32* %1383
%1385 = add nsw i32 %1384, 2
%1386 = sext i32 %1385 to i64
%1387 = getelementptr inbounds float*, float** %1381, i64 %1386
%1388 = load float*, float** %1387
%1389 = load i32, i32* %41
%1390 = sext i32 %1389 to i64
%1391 = getelementptr inbounds float, float* %1388, i64 %1390
%1392 = load float, float* %1391
%1393 = fneg float %1392
%1394 = load float**, float*** %27
%1395 = load i32*, i32** %32
%1396 = getelementptr inbounds i32, i32* %1395, i64 1
%1397 = load i32, i32* %1396
%1398 = sub nsw i32 %1397, 4
%1399 = sext i32 %1398 to i64
%1400 = getelementptr inbounds float*, float** %1394, i64 %1399
%1401 = load float*, float** %1400
%1402 = load i32, i32* %41
%1403 = sext i32 %1402 to i64
%1404 = getelementptr inbounds float, float* %1401, i64 %1403
store float %1393, float* %1404
%1405 = load float**, float*** %26
%1406 = load i32*, i32** %32
%1407 = getelementptr inbounds i32, i32* %1406, i64 1
%1408 = load i32, i32* %1407
%1409 = add nsw i32 %1408, 2
%1410 = sext i32 %1409 to i64
%1411 = getelementptr inbounds float*, float** %1405, i64 %1410
%1412 = load float*, float** %1411
%1413 = load i32, i32* %41
%1414 = sext i32 %1413 to i64
%1415 = getelementptr inbounds float, float* %1412, i64 %1414
%1416 = load float, float* %1415
%1417 = fneg float %1416
%1418 = load float**, float*** %26
%1419 = load i32*, i32** %32
%1420 = getelementptr inbounds i32, i32* %1419, i64 1
%1421 = load i32, i32* %1420
%1422 = sub nsw i32 %1421, 4
%1423 = sext i32 %1422 to i64
%1424 = getelementptr inbounds float*, float** %1418, i64 %1423
%1425 = load float*, float** %1424
%1426 = load i32, i32* %41
%1427 = sext i32 %1426 to i64
%1428 = getelementptr inbounds float, float* %1425, i64 %1427
store float %1417, float* %1428
%1429 = load float**, float*** %25
%1430 = load i32*, i32** %32
%1431 = getelementptr inbounds i32, i32* %1430, i64 1
%1432 = load i32, i32* %1431
%1433 = add nsw i32 %1432, 2
%1434 = sext i32 %1433 to i64
%1435 = getelementptr inbounds float*, float** %1429, i64 %1434
%1436 = load float*, float** %1435
%1437 = load i32, i32* %41
%1438 = sext i32 %1437 to i64
%1439 = getelementptr inbounds float, float* %1436, i64 %1438
%1440 = load float, float* %1439
%1441 = fneg float %1440
%1442 = load float**, float*** %25
%1443 = load i32*, i32** %32
%1444 = getelementptr inbounds i32, i32* %1443, i64 1
%1445 = load i32, i32* %1444
%1446 = sub nsw i32 %1445, 4
%1447 = sext i32 %1446 to i64
%1448 = getelementptr inbounds float*, float** %1442, i64 %1447
%1449 = load float*, float** %1448
%1450 = load i32, i32* %41
%1451 = sext i32 %1450 to i64
%1452 = getelementptr inbounds float, float* %1449, i64 %1451
store float %1441, float* %1452
br label %1453
1453: ; preds = %1164
%1454 = load i32, i32* %41
%1455 = add nsw i32 %1454, 1
store i32 %1455, i32* %41
br label %1157
1456: ; preds = %1157
br label %1457
1457: ; preds = %1456, %1148
%1458 = load i32*, i32** %40
%1459 = getelementptr inbounds i32, i32* %1458, i64 1
%1460 = load i32, i32* %1459
%1461 = icmp ne i32 %1460, 0
br i1 %1461, label %1462, label %1766
1462: ; preds = %1457
%1463 = load i32*, i32** %32
%1464 = getelementptr inbounds i32, i32* %1463, i64 0
%1465 = load i32, i32* %1464
store i32 %1465, i32* %41
br label %1466
1466: ; preds = %1762, %1462
%1467 = load i32, i32* %41
%1468 = load i32*, i32** %33
%1469 = getelementptr inbounds i32, i32* %1468, i64 0
%1470 = load i32, i32* %1469
%1471 = add nsw i32 %1470, 1
%1472 = icmp slt i32 %1467, %1471
br i1 %1472, label %1473, label %1765
1473: ; preds = %1466
%1474 = load float**, float*** %28
%1475 = load i32*, i32** %33
%1476 = getelementptr inbounds i32, i32* %1475, i64 1
%1477 = load i32, i32* %1476
%1478 = sub nsw i32 %1477, 0
%1479 = sext i32 %1478 to i64
%1480 = getelementptr inbounds float*, float** %1474, i64 %1479
%1481 = load float*, float** %1480
%1482 = load i32, i32* %41
%1483 = sext i32 %1482 to i64
%1484 = getelementptr inbounds float, float* %1481, i64 %1483
%1485 = load float, float* %1484
%1486 = fneg float %1485
%1487 = load float**, float*** %28
%1488 = load i32*, i32** %33
%1489 = getelementptr inbounds i32, i32* %1488, i64 1
%1490 = load i32, i32* %1489
%1491 = add nsw i32 %1490, 2
%1492 = sext i32 %1491 to i64
%1493 = getelementptr inbounds float*, float** %1487, i64 %1492
%1494 = load float*, float** %1493
%1495 = load i32, i32* %41
%1496 = sext i32 %1495 to i64
%1497 = getelementptr inbounds float, float* %1494, i64 %1496
store float %1486, float* %1497
%1498 = load float**, float*** %27
%1499 = load i32*, i32** %33
%1500 = getelementptr inbounds i32, i32* %1499, i64 1
%1501 = load i32, i32* %1500
%1502 = sub nsw i32 %1501, 0
%1503 = sext i32 %1502 to i64
%1504 = getelementptr inbounds float*, float** %1498, i64 %1503
%1505 = load float*, float** %1504
%1506 = load i32, i32* %41
%1507 = sext i32 %1506 to i64
%1508 = getelementptr inbounds float, float* %1505, i64 %1507
%1509 = load float, float* %1508
%1510 = fneg float %1509
%1511 = load float**, float*** %27
%1512 = load i32*, i32** %33
%1513 = getelementptr inbounds i32, i32* %1512, i64 1
%1514 = load i32, i32* %1513
%1515 = add nsw i32 %1514, 2
%1516 = sext i32 %1515 to i64
%1517 = getelementptr inbounds float*, float** %1511, i64 %1516
%1518 = load float*, float** %1517
%1519 = load i32, i32* %41
%1520 = sext i32 %1519 to i64
%1521 = getelementptr inbounds float, float* %1518, i64 %1520
store float %1510, float* %1521
%1522 = load float**, float*** %26
%1523 = load i32*, i32** %33
%1524 = getelementptr inbounds i32, i32* %1523, i64 1
%1525 = load i32, i32* %1524
%1526 = sub nsw i32 %1525, 0
%1527 = sext i32 %1526 to i64
%1528 = getelementptr inbounds float*, float** %1522, i64 %1527
%1529 = load float*, float** %1528
%1530 = load i32, i32* %41
%1531 = sext i32 %1530 to i64
%1532 = getelementptr inbounds float, float* %1529, i64 %1531
%1533 = load float, float* %1532
%1534 = fneg float %1533
%1535 = load float**, float*** %26
%1536 = load i32*, i32** %33
%1537 = getelementptr inbounds i32, i32* %1536, i64 1
%1538 = load i32, i32* %1537
%1539 = add nsw i32 %1538, 2
%1540 = sext i32 %1539 to i64
%1541 = getelementptr inbounds float*, float** %1535, i64 %1540
%1542 = load float*, float** %1541
%1543 = load i32, i32* %41
%1544 = sext i32 %1543 to i64
%1545 = getelementptr inbounds float, float* %1542, i64 %1544
store float %1534, float* %1545
%1546 = load float**, float*** %25
%1547 = load i32*, i32** %33
%1548 = getelementptr inbounds i32, i32* %1547, i64 1
%1549 = load i32, i32* %1548
%1550 = sub nsw i32 %1549, 0
%1551 = sext i32 %1550 to i64
%1552 = getelementptr inbounds float*, float** %1546, i64 %1551
%1553 = load float*, float** %1552
%1554 = load i32, i32* %41
%1555 = sext i32 %1554 to i64
%1556 = getelementptr inbounds float, float* %1553, i64 %1555
%1557 = load float, float* %1556
%1558 = fneg float %1557
%1559 = load float**, float*** %25
%1560 = load i32*, i32** %33
%1561 = getelementptr inbounds i32, i32* %1560, i64 1
%1562 = load i32, i32* %1561
%1563 = add nsw i32 %1562, 2
%1564 = sext i32 %1563 to i64
%1565 = getelementptr inbounds float*, float** %1559, i64 %1564
%1566 = load float*, float** %1565
%1567 = load i32, i32* %41
%1568 = sext i32 %1567 to i64
%1569 = getelementptr inbounds float, float* %1566, i64 %1568
store float %1558, float* %1569
%1570 = load float**, float*** %28
%1571 = load i32*, i32** %33
%1572 = getelementptr inbounds i32, i32* %1571, i64 1
%1573 = load i32, i32* %1572
%1574 = sub nsw i32 %1573, 1
%1575 = sext i32 %1574 to i64
%1576 = getelementptr inbounds float*, float** %1570, i64 %1575
%1577 = load float*, float** %1576
%1578 = load i32, i32* %41
%1579 = sext i32 %1578 to i64
%1580 = getelementptr inbounds float, float* %1577, i64 %1579
%1581 = load float, float* %1580
%1582 = fneg float %1581
%1583 = load float**, float*** %28
%1584 = load i32*, i32** %33
%1585 = getelementptr inbounds i32, i32* %1584, i64 1
%1586 = load i32, i32* %1585
%1587 = add nsw i32 %1586, 3
%1588 = sext i32 %1587 to i64
%1589 = getelementptr inbounds float*, float** %1583, i64 %1588
%1590 = load float*, float** %1589
%1591 = load i32, i32* %41
%1592 = sext i32 %1591 to i64
%1593 = getelementptr inbounds float, float* %1590, i64 %1592
store float %1582, float* %1593
%1594 = load float**, float*** %27
%1595 = load i32*, i32** %33
%1596 = getelementptr inbounds i32, i32* %1595, i64 1
%1597 = load i32, i32* %1596
%1598 = sub nsw i32 %1597, 1
%1599 = sext i32 %1598 to i64
%1600 = getelementptr inbounds float*, float** %1594, i64 %1599
%1601 = load float*, float** %1600
%1602 = load i32, i32* %41
%1603 = sext i32 %1602 to i64
%1604 = getelementptr inbounds float, float* %1601, i64 %1603
%1605 = load float, float* %1604
%1606 = fneg float %1605
%1607 = load float**, float*** %27
%1608 = load i32*, i32** %33
%1609 = getelementptr inbounds i32, i32* %1608, i64 1
%1610 = load i32, i32* %1609
%1611 = add nsw i32 %1610, 3
%1612 = sext i32 %1611 to i64
%1613 = getelementptr inbounds float*, float** %1607, i64 %1612
%1614 = load float*, float** %1613
%1615 = load i32, i32* %41
%1616 = sext i32 %1615 to i64
%1617 = getelementptr inbounds float, float* %1614, i64 %1616
store float %1606, float* %1617
%1618 = load float**, float*** %26
%1619 = load i32*, i32** %33
%1620 = getelementptr inbounds i32, i32* %1619, i64 1
%1621 = load i32, i32* %1620
%1622 = sub nsw i32 %1621, 1
%1623 = sext i32 %1622 to i64
%1624 = getelementptr inbounds float*, float** %1618, i64 %1623
%1625 = load float*, float** %1624
%1626 = load i32, i32* %41
%1627 = sext i32 %1626 to i64
%1628 = getelementptr inbounds float, float* %1625, i64 %1627
%1629 = load float, float* %1628
%1630 = fneg float %1629
%1631 = load float**, float*** %26
%1632 = load i32*, i32** %33
%1633 = getelementptr inbounds i32, i32* %1632, i64 1
%1634 = load i32, i32* %1633
%1635 = add nsw i32 %1634, 3
%1636 = sext i32 %1635 to i64
%1637 = getelementptr inbounds float*, float** %1631, i64 %1636
%1638 = load float*, float** %1637
%1639 = load i32, i32* %41
%1640 = sext i32 %1639 to i64
%1641 = getelementptr inbounds float, float* %1638, i64 %1640
store float %1630, float* %1641
%1642 = load float**, float*** %25
%1643 = load i32*, i32** %33
%1644 = getelementptr inbounds i32, i32* %1643, i64 1
%1645 = load i32, i32* %1644
%1646 = sub nsw i32 %1645, 1
%1647 = sext i32 %1646 to i64
%1648 = getelementptr inbounds float*, float** %1642, i64 %1647
%1649 = load float*, float** %1648
%1650 = load i32, i32* %41
%1651 = sext i32 %1650 to i64
%1652 = getelementptr inbounds float, float* %1649, i64 %1651
%1653 = load float, float* %1652
%1654 = fneg float %1653
%1655 = load float**, float*** %25
%1656 = load i32*, i32** %33
%1657 = getelementptr inbounds i32, i32* %1656, i64 1
%1658 = load i32, i32* %1657
%1659 = add nsw i32 %1658, 3
%1660 = sext i32 %1659 to i64
%1661 = getelementptr inbounds float*, float** %1655, i64 %1660
%1662 = load float*, float** %1661
%1663 = load i32, i32* %41
%1664 = sext i32 %1663 to i64
%1665 = getelementptr inbounds float, float* %1662, i64 %1664
store float %1654, float* %1665
%1666 = load float**, float*** %28
%1667 = load i32*, i32** %33
%1668 = getelementptr inbounds i32, i32* %1667, i64 1
%1669 = load i32, i32* %1668
%1670 = sub nsw i32 %1669, 2
%1671 = sext i32 %1670 to i64
%1672 = getelementptr inbounds float*, float** %1666, i64 %1671
%1673 = load float*, float** %1672
%1674 = load i32, i32* %41
%1675 = sext i32 %1674 to i64
%1676 = getelementptr inbounds float, float* %1673, i64 %1675
%1677 = load float, float* %1676
%1678 = fneg float %1677
%1679 = load float**, float*** %28
%1680 = load i32*, i32** %33
%1681 = getelementptr inbounds i32, i32* %1680, i64 1
%1682 = load i32, i32* %1681
%1683 = add nsw i32 %1682, 4
%1684 = sext i32 %1683 to i64
%1685 = getelementptr inbounds float*, float** %1679, i64 %1684
%1686 = load float*, float** %1685
%1687 = load i32, i32* %41
%1688 = sext i32 %1687 to i64
%1689 = getelementptr inbounds float, float* %1686, i64 %1688
store float %1678, float* %1689
%1690 = load float**, float*** %27
%1691 = load i32*, i32** %33
%1692 = getelementptr inbounds i32, i32* %1691, i64 1
%1693 = load i32, i32* %1692
%1694 = sub nsw i32 %1693, 2
%1695 = sext i32 %1694 to i64
%1696 = getelementptr inbounds float*, float** %1690, i64 %1695
%1697 = load float*, float** %1696
%1698 = load i32, i32* %41
%1699 = sext i32 %1698 to i64
%1700 = getelementptr inbounds float, float* %1697, i64 %1699
%1701 = load float, float* %1700
%1702 = fneg float %1701
%1703 = load float**, float*** %27
%1704 = load i32*, i32** %33
%1705 = getelementptr inbounds i32, i32* %1704, i64 1
%1706 = load i32, i32* %1705
%1707 = add nsw i32 %1706, 4
%1708 = sext i32 %1707 to i64
%1709 = getelementptr inbounds float*, float** %1703, i64 %1708
%1710 = load float*, float** %1709
%1711 = load i32, i32* %41
%1712 = sext i32 %1711 to i64
%1713 = getelementptr inbounds float, float* %1710, i64 %1712
store float %1702, float* %1713
%1714 = load float**, float*** %26
%1715 = load i32*, i32** %33
%1716 = getelementptr inbounds i32, i32* %1715, i64 1
%1717 = load i32, i32* %1716
%1718 = sub nsw i32 %1717, 2
%1719 = sext i32 %1718 to i64
%1720 = getelementptr inbounds float*, float** %1714, i64 %1719
%1721 = load float*, float** %1720
%1722 = load i32, i32* %41
%1723 = sext i32 %1722 to i64
%1724 = getelementptr inbounds float, float* %1721, i64 %1723
%1725 = load float, float* %1724
%1726 = fneg float %1725
%1727 = load float**, float*** %26
%1728 = load i32*, i32** %33
%1729 = getelementptr inbounds i32, i32* %1728, i64 1
%1730 = load i32, i32* %1729
%1731 = add nsw i32 %1730, 4
%1732 = sext i32 %1731 to i64
%1733 = getelementptr inbounds float*, float** %1727, i64 %1732
%1734 = load float*, float** %1733
%1735 = load i32, i32* %41
%1736 = sext i32 %1735 to i64
%1737 = getelementptr inbounds float, float* %1734, i64 %1736
store float %1726, float* %1737
%1738 = load float**, float*** %25
%1739 = load i32*, i32** %33
%1740 = getelementptr inbounds i32, i32* %1739, i64 1
%1741 = load i32, i32* %1740
%1742 = sub nsw i32 %1741, 2
%1743 = sext i32 %1742 to i64
%1744 = getelementptr inbounds float*, float** %1738, i64 %1743
%1745 = load float*, float** %1744
%1746 = load i32, i32* %41
%1747 = sext i32 %1746 to i64
%1748 = getelementptr inbounds float, float* %1745, i64 %1747
%1749 = load float, float* %1748
%1750 = fneg float %1749
%1751 = load float**, float*** %25
%1752 = load i32*, i32** %33
%1753 = getelementptr inbounds i32, i32* %1752, i64 1
%1754 = load i32, i32* %1753
%1755 = add nsw i32 %1754, 4
%1756 = sext i32 %1755 to i64
%1757 = getelementptr inbounds float*, float** %1751, i64 %1756
%1758 = load float*, float** %1757
%1759 = load i32, i32* %41
%1760 = sext i32 %1759 to i64
%1761 = getelementptr inbounds float, float* %1758, i64 %1760
store float %1750, float* %1761
br label %1762
1762: ; preds = %1473
%1763 = load i32, i32* %41
%1764 = add nsw i32 %1763, 1
store i32 %1764, i32* %41
br label %1466
1765: ; preds = %1466
br label %1766
1766: ; preds = %1765, %1457
%1767 = load i32*, i32** %39
%1768 = getelementptr inbounds i32, i32* %1767, i64 0
%1769 = load i32, i32* %1768
%1770 = icmp ne i32 %1769, 0
br i1 %1770, label %1771, label %2075
1771: ; preds = %1766
%1772 = load i32*, i32** %32
%1773 = getelementptr inbounds i32, i32* %1772, i64 1
%1774 = load i32, i32* %1773
store i32 %1774, i32* %42
br label %1775
1775: ; preds = %2071, %1771
%1776 = load i32, i32* %42
%1777 = load i32*, i32** %33
%1778 = getelementptr inbounds i32, i32* %1777, i64 1
%1779 = load i32, i32* %1778
%1780 = add nsw i32 %1779, 1
%1781 = icmp slt i32 %1776, %1780
br i1 %1781, label %1782, label %2074
1782: ; preds = %1775
%1783 = load float**, float*** %28
%1784 = load i32, i32* %42
%1785 = sext i32 %1784 to i64
%1786 = getelementptr inbounds float*, float** %1783, i64 %1785
%1787 = load float*, float** %1786
%1788 = load i32*, i32** %32
%1789 = getelementptr inbounds i32, i32* %1788, i64 0
%1790 = load i32, i32* %1789
%1791 = add nsw i32 %1790, 0
%1792 = sext i32 %1791 to i64
%1793 = getelementptr inbounds float, float* %1787, i64 %1792
%1794 = load float, float* %1793
%1795 = fneg float %1794
%1796 = load float**, float*** %28
%1797 = load i32, i32* %42
%1798 = sext i32 %1797 to i64
%1799 = getelementptr inbounds float*, float** %1796, i64 %1798
%1800 = load float*, float** %1799
%1801 = load i32*, i32** %32
%1802 = getelementptr inbounds i32, i32* %1801, i64 0
%1803 = load i32, i32* %1802
%1804 = sub nsw i32 %1803, 2
%1805 = sext i32 %1804 to i64
%1806 = getelementptr inbounds float, float* %1800, i64 %1805
store float %1795, float* %1806
%1807 = load float**, float*** %27
%1808 = load i32, i32* %42
%1809 = sext i32 %1808 to i64
%1810 = getelementptr inbounds float*, float** %1807, i64 %1809
%1811 = load float*, float** %1810
%1812 = load i32*, i32** %32
%1813 = getelementptr inbounds i32, i32* %1812, i64 0
%1814 = load i32, i32* %1813
%1815 = add nsw i32 %1814, 0
%1816 = sext i32 %1815 to i64
%1817 = getelementptr inbounds float, float* %1811, i64 %1816
%1818 = load float, float* %1817
%1819 = fneg float %1818
%1820 = load float**, float*** %27
%1821 = load i32, i32* %42
%1822 = sext i32 %1821 to i64
%1823 = getelementptr inbounds float*, float** %1820, i64 %1822
%1824 = load float*, float** %1823
%1825 = load i32*, i32** %32
%1826 = getelementptr inbounds i32, i32* %1825, i64 0
%1827 = load i32, i32* %1826
%1828 = sub nsw i32 %1827, 2
%1829 = sext i32 %1828 to i64
%1830 = getelementptr inbounds float, float* %1824, i64 %1829
store float %1819, float* %1830
%1831 = load float**, float*** %26
%1832 = load i32, i32* %42
%1833 = sext i32 %1832 to i64
%1834 = getelementptr inbounds float*, float** %1831, i64 %1833
%1835 = load float*, float** %1834
%1836 = load i32*, i32** %32
%1837 = getelementptr inbounds i32, i32* %1836, i64 0
%1838 = load i32, i32* %1837
%1839 = add nsw i32 %1838, 0
%1840 = sext i32 %1839 to i64
%1841 = getelementptr inbounds float, float* %1835, i64 %1840
%1842 = load float, float* %1841
%1843 = fneg float %1842
%1844 = load float**, float*** %26
%1845 = load i32, i32* %42
%1846 = sext i32 %1845 to i64
%1847 = getelementptr inbounds float*, float** %1844, i64 %1846
%1848 = load float*, float** %1847
%1849 = load i32*, i32** %32
%1850 = getelementptr inbounds i32, i32* %1849, i64 0
%1851 = load i32, i32* %1850
%1852 = sub nsw i32 %1851, 2
%1853 = sext i32 %1852 to i64
%1854 = getelementptr inbounds float, float* %1848, i64 %1853
store float %1843, float* %1854
%1855 = load float**, float*** %25
%1856 = load i32, i32* %42
%1857 = sext i32 %1856 to i64
%1858 = getelementptr inbounds float*, float** %1855, i64 %1857
%1859 = load float*, float** %1858
%1860 = load i32*, i32** %32
%1861 = getelementptr inbounds i32, i32* %1860, i64 0
%1862 = load i32, i32* %1861
%1863 = add nsw i32 %1862, 0
%1864 = sext i32 %1863 to i64
%1865 = getelementptr inbounds float, float* %1859, i64 %1864
%1866 = load float, float* %1865
%1867 = fneg float %1866
%1868 = load float**, float*** %25
%1869 = load i32, i32* %42
%1870 = sext i32 %1869 to i64
%1871 = getelementptr inbounds float*, float** %1868, i64 %1870
%1872 = load float*, float** %1871
%1873 = load i32*, i32** %32
%1874 = getelementptr inbounds i32, i32* %1873, i64 0
%1875 = load i32, i32* %1874
%1876 = sub nsw i32 %1875, 2
%1877 = sext i32 %1876 to i64
%1878 = getelementptr inbounds float, float* %1872, i64 %1877
store float %1867, float* %1878
%1879 = load float**, float*** %28
%1880 = load i32, i32* %42
%1881 = sext i32 %1880 to i64
%1882 = getelementptr inbounds float*, float** %1879, i64 %1881
%1883 = load float*, float** %1882
%1884 = load i32*, i32** %32
%1885 = getelementptr inbounds i32, i32* %1884, i64 0
%1886 = load i32, i32* %1885
%1887 = add nsw i32 %1886, 1
%1888 = sext i32 %1887 to i64
%1889 = getelementptr inbounds float, float* %1883, i64 %1888
%1890 = load float, float* %1889
%1891 = fneg float %1890
%1892 = load float**, float*** %28
%1893 = load i32, i32* %42
%1894 = sext i32 %1893 to i64
%1895 = getelementptr inbounds float*, float** %1892, i64 %1894
%1896 = load float*, float** %1895
%1897 = load i32*, i32** %32
%1898 = getelementptr inbounds i32, i32* %1897, i64 0
%1899 = load i32, i32* %1898
%1900 = sub nsw i32 %1899, 3
%1901 = sext i32 %1900 to i64
%1902 = getelementptr inbounds float, float* %1896, i64 %1901
store float %1891, float* %1902
%1903 = load float**, float*** %27
%1904 = load i32, i32* %42
%1905 = sext i32 %1904 to i64
%1906 = getelementptr inbounds float*, float** %1903, i64 %1905
%1907 = load float*, float** %1906
%1908 = load i32*, i32** %32
%1909 = getelementptr inbounds i32, i32* %1908, i64 0
%1910 = load i32, i32* %1909
%1911 = add nsw i32 %1910, 1
%1912 = sext i32 %1911 to i64
%1913 = getelementptr inbounds float, float* %1907, i64 %1912
%1914 = load float, float* %1913
%1915 = fneg float %1914
%1916 = load float**, float*** %27
%1917 = load i32, i32* %42
%1918 = sext i32 %1917 to i64
%1919 = getelementptr inbounds float*, float** %1916, i64 %1918
%1920 = load float*, float** %1919
%1921 = load i32*, i32** %32
%1922 = getelementptr inbounds i32, i32* %1921, i64 0
%1923 = load i32, i32* %1922
%1924 = sub nsw i32 %1923, 3
%1925 = sext i32 %1924 to i64
%1926 = getelementptr inbounds float, float* %1920, i64 %1925
store float %1915, float* %1926
%1927 = load float**, float*** %26
%1928 = load i32, i32* %42
%1929 = sext i32 %1928 to i64
%1930 = getelementptr inbounds float*, float** %1927, i64 %1929
%1931 = load float*, float** %1930
%1932 = load i32*, i32** %32
%1933 = getelementptr inbounds i32, i32* %1932, i64 0
%1934 = load i32, i32* %1933
%1935 = add nsw i32 %1934, 1
%1936 = sext i32 %1935 to i64
%1937 = getelementptr inbounds float, float* %1931, i64 %1936
%1938 = load float, float* %1937
%1939 = fneg float %1938
%1940 = load float**, float*** %26
%1941 = load i32, i32* %42
%1942 = sext i32 %1941 to i64
%1943 = getelementptr inbounds float*, float** %1940, i64 %1942
%1944 = load float*, float** %1943
%1945 = load i32*, i32** %32
%1946 = getelementptr inbounds i32, i32* %1945, i64 0
%1947 = load i32, i32* %1946
%1948 = sub nsw i32 %1947, 3
%1949 = sext i32 %1948 to i64
%1950 = getelementptr inbounds float, float* %1944, i64 %1949
store float %1939, float* %1950
%1951 = load float**, float*** %25
%1952 = load i32, i32* %42
%1953 = sext i32 %1952 to i64
%1954 = getelementptr inbounds float*, float** %1951, i64 %1953
%1955 = load float*, float** %1954
%1956 = load i32*, i32** %32
%1957 = getelementptr inbounds i32, i32* %1956, i64 0
%1958 = load i32, i32* %1957
%1959 = add nsw i32 %1958, 1
%1960 = sext i32 %1959 to i64
%1961 = getelementptr inbounds float, float* %1955, i64 %1960
%1962 = load float, float* %1961
%1963 = fneg float %1962
%1964 = load float**, float*** %25
%1965 = load i32, i32* %42
%1966 = sext i32 %1965 to i64
%1967 = getelementptr inbounds float*, float** %1964, i64 %1966
%1968 = load float*, float** %1967
%1969 = load i32*, i32** %32
%1970 = getelementptr inbounds i32, i32* %1969, i64 0
%1971 = load i32, i32* %1970
%1972 = sub nsw i32 %1971, 3
%1973 = sext i32 %1972 to i64
%1974 = getelementptr inbounds float, float* %1968, i64 %1973
store float %1963, float* %1974
%1975 = load float**, float*** %28
%1976 = load i32, i32* %42
%1977 = sext i32 %1976 to i64
%1978 = getelementptr inbounds float*, float** %1975, i64 %1977
%1979 = load float*, float** %1978
%1980 = load i32*, i32** %32
%1981 = getelementptr inbounds i32, i32* %1980, i64 0
%1982 = load i32, i32* %1981
%1983 = add nsw i32 %1982, 2
%1984 = sext i32 %1983 to i64
%1985 = getelementptr inbounds float, float* %1979, i64 %1984
%1986 = load float, float* %1985
%1987 = fneg float %1986
%1988 = load float**, float*** %28
%1989 = load i32, i32* %42
%1990 = sext i32 %1989 to i64
%1991 = getelementptr inbounds float*, float** %1988, i64 %1990
%1992 = load float*, float** %1991
%1993 = load i32*, i32** %32
%1994 = getelementptr inbounds i32, i32* %1993, i64 0
%1995 = load i32, i32* %1994
%1996 = sub nsw i32 %1995, 4
%1997 = sext i32 %1996 to i64
%1998 = getelementptr inbounds float, float* %1992, i64 %1997
store float %1987, float* %1998
%1999 = load float**, float*** %27
%2000 = load i32, i32* %42
%2001 = sext i32 %2000 to i64
%2002 = getelementptr inbounds float*, float** %1999, i64 %2001
%2003 = load float*, float** %2002
%2004 = load i32*, i32** %32
%2005 = getelementptr inbounds i32, i32* %2004, i64 0
%2006 = load i32, i32* %2005
%2007 = add nsw i32 %2006, 2
%2008 = sext i32 %2007 to i64
%2009 = getelementptr inbounds float, float* %2003, i64 %2008
%2010 = load float, float* %2009
%2011 = fneg float %2010
%2012 = load float**, float*** %27
%2013 = load i32, i32* %42
%2014 = sext i32 %2013 to i64
%2015 = getelementptr inbounds float*, float** %2012, i64 %2014
%2016 = load float*, float** %2015
%2017 = load i32*, i32** %32
%2018 = getelementptr inbounds i32, i32* %2017, i64 0
%2019 = load i32, i32* %2018
%2020 = sub nsw i32 %2019, 4
%2021 = sext i32 %2020 to i64
%2022 = getelementptr inbounds float, float* %2016, i64 %2021
store float %2011, float* %2022
%2023 = load float**, float*** %26
%2024 = load i32, i32* %42
%2025 = sext i32 %2024 to i64
%2026 = getelementptr inbounds float*, float** %2023, i64 %2025
%2027 = load float*, float** %2026
%2028 = load i32*, i32** %32
%2029 = getelementptr inbounds i32, i32* %2028, i64 0
%2030 = load i32, i32* %2029
%2031 = add nsw i32 %2030, 2
%2032 = sext i32 %2031 to i64
%2033 = getelementptr inbounds float, float* %2027, i64 %2032
%2034 = load float, float* %2033
%2035 = fneg float %2034
%2036 = load float**, float*** %26
%2037 = load i32, i32* %42
%2038 = sext i32 %2037 to i64
%2039 = getelementptr inbounds float*, float** %2036, i64 %2038
%2040 = load float*, float** %2039
%2041 = load i32*, i32** %32
%2042 = getelementptr inbounds i32, i32* %2041, i64 0
%2043 = load i32, i32* %2042
%2044 = sub nsw i32 %2043, 4
%2045 = sext i32 %2044 to i64
%2046 = getelementptr inbounds float, float* %2040, i64 %2045
store float %2035, float* %2046
%2047 = load float**, float*** %25
%2048 = load i32, i32* %42
%2049 = sext i32 %2048 to i64
%2050 = getelementptr inbounds float*, float** %2047, i64 %2049
%2051 = load float*, float** %2050
%2052 = load i32*, i32** %32
%2053 = getelementptr inbounds i32, i32* %2052, i64 0
%2054 = load i32, i32* %2053
%2055 = add nsw i32 %2054, 2
%2056 = sext i32 %2055 to i64
%2057 = getelementptr inbounds float, float* %2051, i64 %2056
%2058 = load float, float* %2057
%2059 = fneg float %2058
%2060 = load float**, float*** %25
%2061 = load i32, i32* %42
%2062 = sext i32 %2061 to i64
%2063 = getelementptr inbounds float*, float** %2060, i64 %2062
%2064 = load float*, float** %2063
%2065 = load i32*, i32** %32
%2066 = getelementptr inbounds i32, i32* %2065, i64 0
%2067 = load i32, i32* %2066
%2068 = sub nsw i32 %2067, 4
%2069 = sext i32 %2068 to i64
%2070 = getelementptr inbounds float, float* %2064, i64 %2069
store float %2059, float* %2070
br label %2071
2071: ; preds = %1782
%2072 = load i32, i32* %42
%2073 = add nsw i32 %2072, 1
store i32 %2073, i32* %42
br label %1775
2074: ; preds = %1775
br label %2075
2075: ; preds = %2074, %1766
%2076 = load i32*, i32** %40
%2077 = getelementptr inbounds i32, i32* %2076, i64 0
%2078 = load i32, i32* %2077
%2079 = icmp ne i32 %2078, 0
br i1 %2079, label %2080, label %2384
2080: ; preds = %2075
%2081 = load i32*, i32** %32
%2082 = getelementptr inbounds i32, i32* %2081, i64 1
%2083 = load i32, i32* %2082
store i32 %2083, i32* %42
br label %2084
2084: ; preds = %2380, %2080
%2085 = load i32, i32* %42
%2086 = load i32*, i32** %33
%2087 = getelementptr inbounds i32, i32* %2086, i64 1
%2088 = load i32, i32* %2087
%2089 = add nsw i32 %2088, 1
%2090 = icmp slt i32 %2085, %2089
br i1 %2090, label %2091, label %2383
2091: ; preds = %2084
%2092 = load float**, float*** %28
%2093 = load i32, i32* %42
%2094 = sext i32 %2093 to i64
%2095 = getelementptr inbounds float*, float** %2092, i64 %2094
%2096 = load float*, float** %2095
%2097 = load i32*, i32** %33
%2098 = getelementptr inbounds i32, i32* %2097, i64 0
%2099 = load i32, i32* %2098
%2100 = sub nsw i32 %2099, 0
%2101 = sext i32 %2100 to i64
%2102 = getelementptr inbounds float, float* %2096, i64 %2101
%2103 = load float, float* %2102
%2104 = fneg float %2103
%2105 = load float**, float*** %28
%2106 = load i32, i32* %42
%2107 = sext i32 %2106 to i64
%2108 = getelementptr inbounds float*, float** %2105, i64 %2107
%2109 = load float*, float** %2108
%2110 = load i32*, i32** %33
%2111 = getelementptr inbounds i32, i32* %2110, i64 0
%2112 = load i32, i32* %2111
%2113 = add nsw i32 %2112, 2
%2114 = sext i32 %2113 to i64
%2115 = getelementptr inbounds float, float* %2109, i64 %2114
store float %2104, float* %2115
%2116 = load float**, float*** %27
%2117 = load i32, i32* %42
%2118 = sext i32 %2117 to i64
%2119 = getelementptr inbounds float*, float** %2116, i64 %2118
%2120 = load float*, float** %2119
%2121 = load i32*, i32** %33
%2122 = getelementptr inbounds i32, i32* %2121, i64 0
%2123 = load i32, i32* %2122
%2124 = sub nsw i32 %2123, 0
%2125 = sext i32 %2124 to i64
%2126 = getelementptr inbounds float, float* %2120, i64 %2125
%2127 = load float, float* %2126
%2128 = fneg float %2127
%2129 = load float**, float*** %27
%2130 = load i32, i32* %42
%2131 = sext i32 %2130 to i64
%2132 = getelementptr inbounds float*, float** %2129, i64 %2131
%2133 = load float*, float** %2132
%2134 = load i32*, i32** %33
%2135 = getelementptr inbounds i32, i32* %2134, i64 0
%2136 = load i32, i32* %2135
%2137 = add nsw i32 %2136, 2
%2138 = sext i32 %2137 to i64
%2139 = getelementptr inbounds float, float* %2133, i64 %2138
store float %2128, float* %2139
%2140 = load float**, float*** %26
%2141 = load i32, i32* %42
%2142 = sext i32 %2141 to i64
%2143 = getelementptr inbounds float*, float** %2140, i64 %2142
%2144 = load float*, float** %2143
%2145 = load i32*, i32** %33
%2146 = getelementptr inbounds i32, i32* %2145, i64 0
%2147 = load i32, i32* %2146
%2148 = sub nsw i32 %2147, 0
%2149 = sext i32 %2148 to i64
%2150 = getelementptr inbounds float, float* %2144, i64 %2149
%2151 = load float, float* %2150
%2152 = fneg float %2151
%2153 = load float**, float*** %26
%2154 = load i32, i32* %42
%2155 = sext i32 %2154 to i64
%2156 = getelementptr inbounds float*, float** %2153, i64 %2155
%2157 = load float*, float** %2156
%2158 = load i32*, i32** %33
%2159 = getelementptr inbounds i32, i32* %2158, i64 0
%2160 = load i32, i32* %2159
%2161 = add nsw i32 %2160, 2
%2162 = sext i32 %2161 to i64
%2163 = getelementptr inbounds float, float* %2157, i64 %2162
store float %2152, float* %2163
%2164 = load float**, float*** %25
%2165 = load i32, i32* %42
%2166 = sext i32 %2165 to i64
%2167 = getelementptr inbounds float*, float** %2164, i64 %2166
%2168 = load float*, float** %2167
%2169 = load i32*, i32** %33
%2170 = getelementptr inbounds i32, i32* %2169, i64 0
%2171 = load i32, i32* %2170
%2172 = sub nsw i32 %2171, 0
%2173 = sext i32 %2172 to i64
%2174 = getelementptr inbounds float, float* %2168, i64 %2173
%2175 = load float, float* %2174
%2176 = fneg float %2175
%2177 = load float**, float*** %25
%2178 = load i32, i32* %42
%2179 = sext i32 %2178 to i64
%2180 = getelementptr inbounds float*, float** %2177, i64 %2179
%2181 = load float*, float** %2180
%2182 = load i32*, i32** %33
%2183 = getelementptr inbounds i32, i32* %2182, i64 0
%2184 = load i32, i32* %2183
%2185 = add nsw i32 %2184, 2
%2186 = sext i32 %2185 to i64
%2187 = getelementptr inbounds float, float* %2181, i64 %2186
store float %2176, float* %2187
%2188 = load float**, float*** %28
%2189 = load i32, i32* %42
%2190 = sext i32 %2189 to i64
%2191 = getelementptr inbounds float*, float** %2188, i64 %2190
%2192 = load float*, float** %2191
%2193 = load i32*, i32** %33
%2194 = getelementptr inbounds i32, i32* %2193, i64 0
%2195 = load i32, i32* %2194
%2196 = sub nsw i32 %2195, 1
%2197 = sext i32 %2196 to i64
%2198 = getelementptr inbounds float, float* %2192, i64 %2197
%2199 = load float, float* %2198
%2200 = fneg float %2199
%2201 = load float**, float*** %28
%2202 = load i32, i32* %42
%2203 = sext i32 %2202 to i64
%2204 = getelementptr inbounds float*, float** %2201, i64 %2203
%2205 = load float*, float** %2204
%2206 = load i32*, i32** %33
%2207 = getelementptr inbounds i32, i32* %2206, i64 0
%2208 = load i32, i32* %2207
%2209 = add nsw i32 %2208, 3
%2210 = sext i32 %2209 to i64
%2211 = getelementptr inbounds float, float* %2205, i64 %2210
store float %2200, float* %2211
%2212 = load float**, float*** %27
%2213 = load i32, i32* %42
%2214 = sext i32 %2213 to i64
%2215 = getelementptr inbounds float*, float** %2212, i64 %2214
%2216 = load float*, float** %2215
%2217 = load i32*, i32** %33
%2218 = getelementptr inbounds i32, i32* %2217, i64 0
%2219 = load i32, i32* %2218
%2220 = sub nsw i32 %2219, 1
%2221 = sext i32 %2220 to i64
%2222 = getelementptr inbounds float, float* %2216, i64 %2221
%2223 = load float, float* %2222
%2224 = fneg float %2223
%2225 = load float**, float*** %27
%2226 = load i32, i32* %42
%2227 = sext i32 %2226 to i64
%2228 = getelementptr inbounds float*, float** %2225, i64 %2227
%2229 = load float*, float** %2228
%2230 = load i32*, i32** %33
%2231 = getelementptr inbounds i32, i32* %2230, i64 0
%2232 = load i32, i32* %2231
%2233 = add nsw i32 %2232, 3
%2234 = sext i32 %2233 to i64
%2235 = getelementptr inbounds float, float* %2229, i64 %2234
store float %2224, float* %2235
%2236 = load float**, float*** %26
%2237 = load i32, i32* %42
%2238 = sext i32 %2237 to i64
%2239 = getelementptr inbounds float*, float** %2236, i64 %2238
%2240 = load float*, float** %2239
%2241 = load i32*, i32** %33
%2242 = getelementptr inbounds i32, i32* %2241, i64 0
%2243 = load i32, i32* %2242
%2244 = sub nsw i32 %2243, 1
%2245 = sext i32 %2244 to i64
%2246 = getelementptr inbounds float, float* %2240, i64 %2245
%2247 = load float, float* %2246
%2248 = fneg float %2247
%2249 = load float**, float*** %26
%2250 = load i32, i32* %42
%2251 = sext i32 %2250 to i64
%2252 = getelementptr inbounds float*, float** %2249, i64 %2251
%2253 = load float*, float** %2252
%2254 = load i32*, i32** %33
%2255 = getelementptr inbounds i32, i32* %2254, i64 0
%2256 = load i32, i32* %2255
%2257 = add nsw i32 %2256, 3
%2258 = sext i32 %2257 to i64
%2259 = getelementptr inbounds float, float* %2253, i64 %2258
store float %2248, float* %2259
%2260 = load float**, float*** %25
%2261 = load i32, i32* %42
%2262 = sext i32 %2261 to i64
%2263 = getelementptr inbounds float*, float** %2260, i64 %2262
%2264 = load float*, float** %2263
%2265 = load i32*, i32** %33
%2266 = getelementptr inbounds i32, i32* %2265, i64 0
%2267 = load i32, i32* %2266
%2268 = sub nsw i32 %2267, 1
%2269 = sext i32 %2268 to i64
%2270 = getelementptr inbounds float, float* %2264, i64 %2269
%2271 = load float, float* %2270
%2272 = fneg float %2271
%2273 = load float**, float*** %25
%2274 = load i32, i32* %42
%2275 = sext i32 %2274 to i64
%2276 = getelementptr inbounds float*, float** %2273, i64 %2275
%2277 = load float*, float** %2276
%2278 = load i32*, i32** %33
%2279 = getelementptr inbounds i32, i32* %2278, i64 0
%2280 = load i32, i32* %2279
%2281 = add nsw i32 %2280, 3
%2282 = sext i32 %2281 to i64
%2283 = getelementptr inbounds float, float* %2277, i64 %2282
store float %2272, float* %2283
%2284 = load float**, float*** %28
%2285 = load i32, i32* %42
%2286 = sext i32 %2285 to i64
%2287 = getelementptr inbounds float*, float** %2284, i64 %2286
%2288 = load float*, float** %2287
%2289 = load i32*, i32** %33
%2290 = getelementptr inbounds i32, i32* %2289, i64 0
%2291 = load i32, i32* %2290
%2292 = sub nsw i32 %2291, 2
%2293 = sext i32 %2292 to i64
%2294 = getelementptr inbounds float, float* %2288, i64 %2293
%2295 = load float, float* %2294
%2296 = fneg float %2295
%2297 = load float**, float*** %28
%2298 = load i32, i32* %42
%2299 = sext i32 %2298 to i64
%2300 = getelementptr inbounds float*, float** %2297, i64 %2299
%2301 = load float*, float** %2300
%2302 = load i32*, i32** %33
%2303 = getelementptr inbounds i32, i32* %2302, i64 0
%2304 = load i32, i32* %2303
%2305 = add nsw i32 %2304, 4
%2306 = sext i32 %2305 to i64
%2307 = getelementptr inbounds float, float* %2301, i64 %2306
store float %2296, float* %2307
%2308 = load float**, float*** %27
%2309 = load i32, i32* %42
%2310 = sext i32 %2309 to i64
%2311 = getelementptr inbounds float*, float** %2308, i64 %2310
%2312 = load float*, float** %2311
%2313 = load i32*, i32** %33
%2314 = getelementptr inbounds i32, i32* %2313, i64 0
%2315 = load i32, i32* %2314
%2316 = sub nsw i32 %2315, 2
%2317 = sext i32 %2316 to i64
%2318 = getelementptr inbounds float, float* %2312, i64 %2317
%2319 = load float, float* %2318
%2320 = fneg float %2319
%2321 = load float**, float*** %27
%2322 = load i32, i32* %42
%2323 = sext i32 %2322 to i64
%2324 = getelementptr inbounds float*, float** %2321, i64 %2323
%2325 = load float*, float** %2324
%2326 = load i32*, i32** %33
%2327 = getelementptr inbounds i32, i32* %2326, i64 0
%2328 = load i32, i32* %2327
%2329 = add nsw i32 %2328, 4
%2330 = sext i32 %2329 to i64
%2331 = getelementptr inbounds float, float* %2325, i64 %2330
store float %2320, float* %2331
%2332 = load float**, float*** %26
%2333 = load i32, i32* %42
%2334 = sext i32 %2333 to i64
%2335 = getelementptr inbounds float*, float** %2332, i64 %2334
%2336 = load float*, float** %2335
%2337 = load i32*, i32** %33
%2338 = getelementptr inbounds i32, i32* %2337, i64 0
%2339 = load i32, i32* %2338
%2340 = sub nsw i32 %2339, 2
%2341 = sext i32 %2340 to i64
%2342 = getelementptr inbounds float, float* %2336, i64 %2341
%2343 = load float, float* %2342
%2344 = fneg float %2343
%2345 = load float**, float*** %26
%2346 = load i32, i32* %42
%2347 = sext i32 %2346 to i64
%2348 = getelementptr inbounds float*, float** %2345, i64 %2347
%2349 = load float*, float** %2348
%2350 = load i32*, i32** %33
%2351 = getelementptr inbounds i32, i32* %2350, i64 0
%2352 = load i32, i32* %2351
%2353 = add nsw i32 %2352, 4
%2354 = sext i32 %2353 to i64
%2355 = getelementptr inbounds float, float* %2349, i64 %2354
store float %2344, float* %2355
%2356 = load float**, float*** %25
%2357 = load i32, i32* %42
%2358 = sext i32 %2357 to i64
%2359 = getelementptr inbounds float*, float** %2356, i64 %2358
%2360 = load float*, float** %2359
%2361 = load i32*, i32** %33
%2362 = getelementptr inbounds i32, i32* %2361, i64 0
%2363 = load i32, i32* %2362
%2364 = sub nsw i32 %2363, 2
%2365 = sext i32 %2364 to i64
%2366 = getelementptr inbounds float, float* %2360, i64 %2365
%2367 = load float, float* %2366
%2368 = fneg float %2367
%2369 = load float**, float*** %25
%2370 = load i32, i32* %42
%2371 = sext i32 %2370 to i64
%2372 = getelementptr inbounds float*, float** %2369, i64 %2371
%2373 = load float*, float** %2372
%2374 = load i32*, i32** %33
%2375 = getelementptr inbounds i32, i32* %2374, i64 0
%2376 = load i32, i32* %2375
%2377 = add nsw i32 %2376, 4
%2378 = sext i32 %2377 to i64
%2379 = getelementptr inbounds float, float* %2373, i64 %2378
store float %2368, float* %2379
br label %2380
2380: ; preds = %2091
%2381 = load i32, i32* %42
%2382 = add nsw i32 %2381, 1
store i32 %2382, i32* %42
br label %2084
2383: ; preds = %2084
br label %2384
2384: ; preds = %2383, %2075
ret void
}

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