void acd_2d_4_b(float **uc, float **ucb, float **up, float **upb, float **csq,
                float **csqb, int *s, int *e, float c0, float *c1, float *c2,
                int *lbc, int *rbc) {
  int i0, i1;
  int s0 = s[0];
  int e0 = e[0];
  float lap;
  float tempb;
  if (rbc[0])
    for (i1 = e[1]; i1 > s[1] - 1; --i1) {
      upb[i1][e[0]] = upb[i1][e[0]] - upb[i1][e[0] + 2];
      upb[i1][e[0] + 2] = 0.0;
    }
  if (lbc[0])
    for (i1 = e[1]; i1 > s[1] - 1; --i1) {
      upb[i1][s[0]] = upb[i1][s[0]] - upb[i1][s[0] - 2];
      upb[i1][s[0] - 2] = 0.0;
    }
  if (rbc[1])
#pragma ivdep
    for (i0 = e0; i0 > s0 - 1; --i0) {
      upb[e[1]][i0] = upb[e[1]][i0] - upb[e[1] + 2][i0];
      upb[e[1] + 2][i0] = 0.0;
    }
  if (lbc[1])
#pragma ivdep
    for (i0 = e0; i0 > s0 - 1; --i0) {
      upb[s[1]][i0] = upb[s[1]][i0] - upb[s[1] - 2][i0];
      upb[s[1] - 2][i0] = 0.0;
    }
  for (i1 = e[1]; i1 > s[1] - 1; --i1)
#pragma ivdep
    for (i0 = s0 + 2; i0 <= e0 + 2; i0++) {
      lap = (c0 * uc[i1][i0 - 2] + c1[0] * (uc[i1][i0 - 1] + uc[i1][i0 - 3]) +
             c1[1] * (uc[i1 + 1][i0 - 2] + uc[i1 - 1][i0 - 2]) +
             c2[0] * (uc[i1][i0] + uc[i1][i0 - 4]) +
             c2[1] * (uc[i1 + 2][i0 - 2] + uc[i1 - 2][i0 - 2]));
      tempb = csq[i1][i0 - 2] * upb[i1][i0 - 2];
      csqb[i1][i0 - 2] = csqb[i1][i0 - 2] + lap * upb[i1][i0 - 2];
      ucb[i1][i0] = ucb[i1][i0] + c2[0] * tempb;
      ucb[i1][i0 - 1] = ucb[i1][i0 - 1] + c1[0] * tempb;
      ucb[i1 + 2][i0 - 2] = ucb[i1 + 2][i0 - 2] + c2[1] * tempb;
      ucb[i1 + 1][i0 - 2] = ucb[i1 + 1][i0 - 2] + c1[1] * tempb;
      ucb[i1][i0 - 2] = ucb[i1][i0 - 2] + c0 * tempb + 2.0 * upb[i1][i0 - 2];
      ucb[i1 - 1][i0 - 2] = ucb[i1 - 1][i0 - 2] + c1[1] * tempb;
      ucb[i1 - 2][i0 - 2] = ucb[i1 - 2][i0 - 2] + c2[1] * tempb;
      ucb[i1][i0 - 3] = ucb[i1][i0 - 3] + c1[0] * tempb;
      ucb[i1][i0 - 4] = ucb[i1][i0 - 4] + c2[0] * tempb;
      upb[i1][i0 - 2] = -upb[i1][i0 - 2];
    }
}


x86 assembly (clang, -O0):
<acd_2d_4_b>:
push   %rbp
mov    %rsp,%rbp
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
movss  %xmm0,-0x34(%rbp)
mov    0x10(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x40(%rbp)
mov    0x18(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x44(%rbp)
mov    0x38(%rbp),%rax
cmpl   $0x0,(%rax)
je     11f7 <acd_2d_4_b+0xf7>
mov    0x18(%rbp),%rax
mov    0x4(%rax),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    0x10(%rbp),%rcx
mov    0x4(%rcx),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jle    11f2 <acd_2d_4_b+0xf2>
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x18(%rbp),%rcx
movslq (%rcx),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x18(%rbp),%rcx
mov    (%rcx),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x18(%rbp),%rcx
movslq (%rcx),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x18(%rbp),%rcx
mov    (%rcx),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x3c(%rbp)
jmp    1162 <acd_2d_4_b+0x62>
jmp    11f7 <acd_2d_4_b+0xf7>
mov    0x30(%rbp),%rax
cmpl   $0x0,(%rax)
je     12a3 <acd_2d_4_b+0x1a3>
mov    0x18(%rbp),%rax
mov    0x4(%rax),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    0x10(%rbp),%rcx
mov    0x4(%rcx),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jle    129e <acd_2d_4_b+0x19e>
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x10(%rbp),%rcx
movslq (%rcx),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x10(%rbp),%rcx
mov    (%rcx),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x10(%rbp),%rcx
movslq (%rcx),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x10(%rbp),%rcx
mov    (%rcx),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x3c(%rbp)
jmp    120e <acd_2d_4_b+0x10e>
jmp    12a3 <acd_2d_4_b+0x1a3>
mov    0x38(%rbp),%rax
cmpl   $0x0,0x4(%rax)
je     134c <acd_2d_4_b+0x24c>
mov    -0x44(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x40(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jle    1347 <acd_2d_4_b+0x247>
mov    -0x20(%rbp),%rax
mov    0x18(%rbp),%rcx
movslq 0x4(%rcx),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
mov    0x18(%rbp),%rcx
mov    0x4(%rcx),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
mov    0x18(%rbp),%rcx
movslq 0x4(%rcx),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
mov    0x18(%rbp),%rcx
mov    0x4(%rcx),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x38(%rbp)
jmp    12b7 <acd_2d_4_b+0x1b7>
jmp    134c <acd_2d_4_b+0x24c>
mov    0x30(%rbp),%rax
cmpl   $0x0,0x4(%rax)
je     13f5 <acd_2d_4_b+0x2f5>
mov    -0x44(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x40(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jle    13f0 <acd_2d_4_b+0x2f0>
mov    -0x20(%rbp),%rax
mov    0x10(%rbp),%rcx
movslq 0x4(%rcx),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
mov    0x10(%rbp),%rcx
mov    0x4(%rcx),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
mov    0x10(%rbp),%rcx
movslq 0x4(%rcx),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
mov    0x10(%rbp),%rcx
mov    0x4(%rcx),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x38(%rbp)
jmp    1360 <acd_2d_4_b+0x260>
jmp    13f5 <acd_2d_4_b+0x2f5>
mov    0x18(%rbp),%rax
mov    0x4(%rax),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    0x10(%rbp),%rcx
mov    0x4(%rcx),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jle    194b <acd_2d_4_b+0x84b>
mov    -0x40(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x44(%rbp),%ecx
add    $0x2,%ecx
cmp    %ecx,%eax
jg     1938 <acd_2d_4_b+0x838>
movss  -0x34(%rbp),%xmm1
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    0x20(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
sub    $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    $0x3,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm3
mulss  %xmm3,%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    0x20(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%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
mov    -0x38(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    0x28(%rbp),%rax
movss  (%rax),%xmm1
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%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    0x28(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%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
mov    -0x38(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x48(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%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
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    0x28(%rbp),%rax
movss  (%rax),%xmm0
movss  -0x4c(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%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
mov    -0x38(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    0x20(%rbp),%rax
movss  (%rax),%xmm0
movss  -0x4c(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    0x28(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  -0x4c(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    0x20(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  -0x4c(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%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),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x34(%rbp),%xmm0
movss  -0x4c(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm1
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    0x20(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  -0x4c(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    0x28(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  -0x4c(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%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),%ecx
sub    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    0x20(%rbp),%rax
movss  (%rax),%xmm0
movss  -0x4c(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%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),%ecx
sub    $0x4,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    0x28(%rbp),%rax
movss  (%rax),%xmm0
movss  -0x4c(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
sub    $0x4,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    141d <acd_2d_4_b+0x31d>
jmp    193d <acd_2d_4_b+0x83d>
mov    -0x3c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x3c(%rbp)
jmp    13ff <acd_2d_4_b+0x2ff>
pop    %rbp
ret

x86 assembly (clang, -O2):
<acd_2d_4_b>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %r9,-0x38(%rsp)
mov    %r8,-0x40(%rsp)
mov    %rcx,%r13
mov    %rsi,-0x48(%rsp)
mov    %rdi,-0x50(%rsp)
mov    0x60(%rsp),%rax
mov    0x58(%rsp),%r14
mov    0x40(%rsp),%r10
mov    0x38(%rsp),%r9
movslq (%r9),%rcx
movslq (%r10),%r12
mov    %r12,%rdx
cmpl   $0x0,(%rax)
je     11d3 <acd_2d_4_b+0xd3>
movslq 0x4(%r10),%rbp
movslq 0x4(%r9),%rbx
cmp    %ebx,%ebp
jl     11d3 <acd_2d_4_b+0xd3>
mov    %ebp,%edi
sub    %ebx,%edi
add    $0x1,%edi
mov    %rbp,%rsi
test   $0x1,%dil
je     1188 <acd_2d_4_b+0x88>
mov    0x0(%r13,%rbp,8),%rsi
movss  (%rsi,%rdx,4),%xmm1
subss  0x8(%rsi,%rdx,4),%xmm1
movss  %xmm1,(%rsi,%rdx,4)
movl   $0x0,0x8(%rsi,%rdx,4)
lea    -0x1(%rbp),%rsi
cmp    %ebx,%ebp
je     11d3 <acd_2d_4_b+0xd3>
add    $0x1,%rsi
mov    -0x8(%r13,%rsi,8),%rdi
movss  (%rdi,%rdx,4),%xmm1
subss  0x8(%rdi,%rdx,4),%xmm1
movss  %xmm1,(%rdi,%rdx,4)
movl   $0x0,0x8(%rdi,%rdx,4)
mov    -0x10(%r13,%rsi,8),%rdi
movss  (%rdi,%rdx,4),%xmm1
subss  0x8(%rdi,%rdx,4),%xmm1
movss  %xmm1,(%rdi,%rdx,4)
movl   $0x0,0x8(%rdi,%rdx,4)
add    $0xfffffffffffffffe,%rsi
cmp    %rbx,%rsi
jg     1190 <acd_2d_4_b+0x90>
cmpl   $0x0,(%r14)
je     1273 <acd_2d_4_b+0x173>
movslq 0x4(%r10),%rbp
movslq 0x4(%r9),%rbx
cmp    %ebx,%ebp
jl     1273 <acd_2d_4_b+0x173>
mov    %ebp,%edi
sub    %ebx,%edi
add    $0x1,%edi
mov    %rbp,%rsi
test   $0x1,%dil
je     121e <acd_2d_4_b+0x11e>
mov    0x0(%r13,%rbp,8),%rsi
movss  (%rsi,%rcx,4),%xmm1
subss  -0x8(%rsi,%rcx,4),%xmm1
movss  %xmm1,(%rsi,%rcx,4)
movl   $0x0,-0x8(%rsi,%rcx,4)
lea    -0x1(%rbp),%rsi
cmp    %ebx,%ebp
je     1273 <acd_2d_4_b+0x173>
add    $0x1,%rsi
cs nopw 0x0(%rax,%rax,1)
mov    -0x8(%r13,%rsi,8),%rdi
movss  (%rdi,%rcx,4),%xmm1
subss  -0x8(%rdi,%rcx,4),%xmm1
movss  %xmm1,(%rdi,%rcx,4)
movl   $0x0,-0x8(%rdi,%rcx,4)
mov    -0x10(%r13,%rsi,8),%rdi
movss  (%rdi,%rcx,4),%xmm1
subss  -0x8(%rdi,%rcx,4),%xmm1
movss  %xmm1,(%rdi,%rcx,4)
movl   $0x0,-0x8(%rdi,%rcx,4)
add    $0xfffffffffffffffe,%rsi
cmp    %rbx,%rsi
jg     1230 <acd_2d_4_b+0x130>
cmpl   $0x0,0x4(%rax)
je     13c3 <acd_2d_4_b+0x2c3>
cmp    %ecx,%edx
jl     13c3 <acd_2d_4_b+0x2c3>
movslq 0x4(%r10),%rsi
mov    0x0(%r13,%rsi,8),%rax
mov    0x10(%r13,%rsi,8),%rbx
mov    %r12,%r15
sub    %rcx,%r15
add    $0x1,%r15
cmp    $0x4,%r15
jae    12ab <acd_2d_4_b+0x1ab>
mov    %rdx,%rsi
jmp    1391 <acd_2d_4_b+0x291>
lea    (%rax,%rcx,4),%rsi
lea    (%rbx,%rdx,4),%rdi
add    $0x4,%rdi
cmp    %rdi,%rsi
jae    12d4 <acd_2d_4_b+0x1d4>
lea    (%rax,%rdx,4),%rdi
add    $0x4,%rdi
lea    (%rbx,%rcx,4),%rbp
mov    %rdx,%rsi
cmp    %rdi,%rbp
jb     1391 <acd_2d_4_b+0x291>
mov    %r15,%r8
and    $0xfffffffffffffffc,%r8
lea    -0x4(%r8),%rsi
mov    %rsi,%r11
shr    $0x2,%r11
add    $0x1,%r11
test   %rsi,%rsi
je     178f <acd_2d_4_b+0x68f>
mov    %r12,-0x78(%rsp)
mov    %r11,%rbp
and    $0xfffffffffffffffe,%rbp
lea    (%rbx,%rdx,4),%r12
add    $0xfffffffffffffff4,%r12
lea    (%rax,%rdx,4),%rsi
add    $0xfffffffffffffff4,%rsi
xor    %edi,%edi
xorps  %xmm1,%xmm1
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movups (%rsi,%rdi,4),%xmm2
movups (%r12,%rdi,4),%xmm3
subps  %xmm3,%xmm2
movups %xmm2,(%rsi,%rdi,4)
movups %xmm1,(%r12,%rdi,4)
movups -0x10(%rsi,%rdi,4),%xmm2
movups -0x10(%r12,%rdi,4),%xmm3
subps  %xmm3,%xmm2
movups %xmm2,-0x10(%rsi,%rdi,4)
movups %xmm1,-0x10(%r12,%rdi,4)
add    $0xfffffffffffffff8,%rdi
add    $0xfffffffffffffffe,%rbp
jne    1320 <acd_2d_4_b+0x220>
neg    %rdi
mov    -0x78(%rsp),%r12
test   $0x1,%r11b
je     1386 <acd_2d_4_b+0x286>
mov    %rdx,%rsi
sub    %rdi,%rsi
movups -0xc(%rax,%rsi,4),%xmm1
movups -0xc(%rbx,%rsi,4),%xmm2
subps  %xmm2,%xmm1
movups %xmm1,-0xc(%rax,%rsi,4)
xorps  %xmm1,%xmm1
movups %xmm1,-0xc(%rbx,%rsi,4)
cmp    %r8,%r15
je     13c3 <acd_2d_4_b+0x2c3>
mov    %rdx,%rsi
sub    %r8,%rsi
add    $0x1,%rsi
cs nopw 0x0(%rax,%rax,1)
nop
movss  -0x4(%rax,%rsi,4),%xmm1
subss  -0x4(%rbx,%rsi,4),%xmm1
movss  %xmm1,-0x4(%rax,%rsi,4)
movl   $0x0,-0x4(%rbx,%rsi,4)
add    $0xffffffffffffffff,%rsi
cmp    %rcx,%rsi
jg     13a0 <acd_2d_4_b+0x2a0>
cmpl   $0x0,0x4(%r14)
movslq 0x4(%r9),%r15
je     14f3 <acd_2d_4_b+0x3f3>
cmp    %ecx,%r12d
jl     14f3 <acd_2d_4_b+0x3f3>
mov    0x0(%r13,%r15,8),%rax
mov    -0x10(%r13,%r15,8),%rsi
mov    %r12,%r11
sub    %rcx,%r11
add    $0x1,%r11
cmp    $0x4,%r11
jb     14c9 <acd_2d_4_b+0x3c9>
lea    (%rax,%rcx,4),%rbp
lea    (%rsi,%rdx,4),%rdi
add    $0x4,%rdi
cmp    %rdi,%rbp
jae    141f <acd_2d_4_b+0x31f>
lea    (%rax,%rdx,4),%rbp
add    $0x4,%rbp
lea    (%rsi,%rcx,4),%rdi
cmp    %rbp,%rdi
jb     14c9 <acd_2d_4_b+0x3c9>
mov    %r11,%r8
and    $0xfffffffffffffffc,%r8
lea    -0x4(%r8),%rdi
mov    %rdi,%r9
shr    $0x2,%r9
add    $0x1,%r9
test   %rdi,%rdi
je     17a0 <acd_2d_4_b+0x6a0>
mov    %r9,%rbp
and    $0xfffffffffffffffe,%rbp
lea    (%rsi,%rdx,4),%r14
add    $0xfffffffffffffff4,%r14
lea    (%rax,%rdx,4),%rdi
add    $0xfffffffffffffff4,%rdi
xor    %ebx,%ebx
xorps  %xmm1,%xmm1
nopw   0x0(%rax,%rax,1)
movups (%rdi,%rbx,4),%xmm2
movups (%r14,%rbx,4),%xmm3
subps  %xmm3,%xmm2
movups %xmm2,(%rdi,%rbx,4)
movups %xmm1,(%r14,%rbx,4)
movups -0x10(%rdi,%rbx,4),%xmm2
movups -0x10(%r14,%rbx,4),%xmm3
subps  %xmm3,%xmm2
movups %xmm2,-0x10(%rdi,%rbx,4)
movups %xmm1,-0x10(%r14,%rbx,4)
add    $0xfffffffffffffff8,%rbx
add    $0xfffffffffffffffe,%rbp
jne    1460 <acd_2d_4_b+0x360>
neg    %rbx
test   $0x1,%r9b
je     14c1 <acd_2d_4_b+0x3c1>
mov    %rdx,%rdi
sub    %rbx,%rdi
movups -0xc(%rax,%rdi,4),%xmm1
movups -0xc(%rsi,%rdi,4),%xmm2
subps  %xmm2,%xmm1
movups %xmm1,-0xc(%rax,%rdi,4)
xorps  %xmm1,%xmm1
movups %xmm1,-0xc(%rsi,%rdi,4)
cmp    %r8,%r11
je     14f3 <acd_2d_4_b+0x3f3>
sub    %r8,%rdx
add    $0x1,%rdx
nopl   (%rax)
movss  -0x4(%rax,%rdx,4),%xmm1
subss  -0x4(%rsi,%rdx,4),%xmm1
movss  %xmm1,-0x4(%rax,%rdx,4)
movl   $0x0,-0x4(%rsi,%rdx,4)
add    $0xffffffffffffffff,%rdx
cmp    %rcx,%rdx
jg     14d0 <acd_2d_4_b+0x3d0>
movslq 0x4(%r10),%r11
cmp    %r15d,%r11d
jge    1507 <acd_2d_4_b+0x407>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    0x50(%rsp),%rbx
mov    0x48(%rsp),%rax
lea    0x2(%rcx),%edx
lea    0x2(%r12),%r9
movslq %edx,%rdx
mov    %rdx,-0x70(%rsp)
movaps 0xad8(%rip),%xmm1
mov    %r13,-0x58(%rsp)
mov    %rcx,-0x60(%rsp)
mov    %r12,-0x78(%rsp)
mov    %r15,-0x68(%rsp)
jmp    154c <acd_2d_4_b+0x44c>
xchg   %ax,%ax
lea    -0x1(%r11),%rdx
cmp    %r15,%r11
mov    %rdx,%r11
jle    14fc <acd_2d_4_b+0x3fc>
cmp    %ecx,%r12d
jl     1540 <acd_2d_4_b+0x440>
mov    -0x50(%rsp),%rcx
mov    (%rcx,%r11,8),%rbp
mov    0x8(%rcx,%r11,8),%rdx
mov    %rdx,-0x8(%rsp)
lea    -0x1(%r11),%rdx
mov    %rdx,-0x30(%rsp)
mov    -0x10(%rcx,%r11,8),%rdx
mov    %rdx,-0x10(%rsp)
mov    -0x8(%rcx,%r11,8),%rdx
mov    %rdx,-0x18(%rsp)
mov    0x10(%rcx,%r11,8),%rcx
mov    %rcx,-0x20(%rsp)
mov    -0x40(%rsp),%rcx
mov    (%rcx,%r11,8),%r14
mov    0x0(%r13,%r11,8),%rcx
mov    -0x38(%rsp),%rdx
mov    (%rdx,%r11,8),%r15
mov    -0x48(%rsp),%rdx
mov    (%rdx,%r11,8),%rsi
mov    0x10(%rdx,%r11,8),%r12
mov    0x8(%rdx,%r11,8),%r13
mov    -0x10(%rdx,%r11,8),%r10
mov    %r11,-0x28(%rsp)
mov    -0x8(%rdx,%r11,8),%rdx
mov    -0x70(%rsp),%r11
nopl   0x0(%rax)
movss  -0x4(%rbp,%r11,4),%xmm2
addss  -0xc(%rbp,%r11,4),%xmm2
mulss  (%rax),%xmm2
movss  -0x8(%rbp,%r11,4),%xmm3
mulss  %xmm0,%xmm3
addss  %xmm2,%xmm3
mov    -0x8(%rsp),%r8
movss  -0x8(%r8,%r11,4),%xmm2
mov    -0x18(%rsp),%rdi
addss  -0x8(%rdi,%r11,4),%xmm2
mulss  0x4(%rax),%xmm2
movss  0x0(%rbp,%r11,4),%xmm4
addss  %xmm3,%xmm2
addss  -0x10(%rbp,%r11,4),%xmm4
mulss  (%rbx),%xmm4
addss  %xmm2,%xmm4
mov    -0x20(%rsp),%rdi
movss  -0x8(%rdi,%r11,4),%xmm3
mov    -0x10(%rsp),%rdi
addss  -0x8(%rdi,%r11,4),%xmm3
mulss  0x4(%rbx),%xmm3
addss  %xmm4,%xmm3
movss  -0x8(%rcx,%r11,4),%xmm4
movss  -0x8(%r14,%r11,4),%xmm2
mulss  %xmm4,%xmm2
mulss  %xmm4,%xmm3
addss  -0x8(%r15,%r11,4),%xmm3
movss  %xmm3,-0x8(%r15,%r11,4)
movss  (%rbx),%xmm3
mulss  %xmm2,%xmm3
addss  (%rsi,%r11,4),%xmm3
movss  %xmm3,(%rsi,%r11,4)
movss  (%rax),%xmm3
mulss  %xmm2,%xmm3
addss  -0x4(%rsi,%r11,4),%xmm3
movss  %xmm3,-0x4(%rsi,%r11,4)
movss  0x4(%rbx),%xmm3
mulss  %xmm2,%xmm3
addss  -0x8(%r12,%r11,4),%xmm3
movss  %xmm3,-0x8(%r12,%r11,4)
movss  0x4(%rax),%xmm3
mulss  %xmm2,%xmm3
addss  -0x8(%r13,%r11,4),%xmm3
movss  %xmm3,-0x8(%r13,%r11,4)
movaps %xmm0,%xmm3
mulss  %xmm2,%xmm3
addss  -0x8(%rsi,%r11,4),%xmm3
cvtss2sd %xmm3,%xmm3
movss  -0x8(%rcx,%r11,4),%xmm4
cvtss2sd %xmm4,%xmm4
addsd  %xmm4,%xmm4
addsd  %xmm3,%xmm4
xorps  %xmm3,%xmm3
cvtsd2ss %xmm4,%xmm3
movss  %xmm3,-0x8(%rsi,%r11,4)
movss  0x4(%rax),%xmm3
mulss  %xmm2,%xmm3
addss  -0x8(%rdx,%r11,4),%xmm3
movss  %xmm3,-0x8(%rdx,%r11,4)
movss  0x4(%rbx),%xmm3
mulss  %xmm2,%xmm3
addss  -0x8(%r10,%r11,4),%xmm3
movss  %xmm3,-0x8(%r10,%r11,4)
movss  (%rax),%xmm3
mulss  %xmm2,%xmm3
addss  -0xc(%rsi,%r11,4),%xmm3
movss  %xmm3,-0xc(%rsi,%r11,4)
mulss  (%rbx),%xmm2
addss  -0x10(%rsi,%r11,4),%xmm2
movss  %xmm2,-0x10(%rsi,%r11,4)
movss  -0x8(%rcx,%r11,4),%xmm2
xorps  %xmm1,%xmm2
movss  %xmm2,-0x8(%rcx,%r11,4)
cmp    %r9,%r11
lea    0x1(%r11),%r11
jl     15d0 <acd_2d_4_b+0x4d0>
mov    -0x58(%rsp),%r13
mov    -0x60(%rsp),%rcx
mov    -0x78(%rsp),%r12
mov    -0x68(%rsp),%r15
mov    -0x28(%rsp),%r11
mov    -0x30(%rsp),%rdx
jmp    1544 <acd_2d_4_b+0x444>
xor    %edi,%edi
test   $0x1,%r11b
jne    1366 <acd_2d_4_b+0x266>
jmp    1386 <acd_2d_4_b+0x286>
xor    %ebx,%ebx
test   $0x1,%r9b
jne    14a1 <acd_2d_4_b+0x3a1>
jmp    14c1 <acd_2d_4_b+0x3c1>

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

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