void acd_2d_2_d_b(float **uc, float **ucb, float **ucd, float **ucdb,
                  float **up, float **upb, float **upd, float **updb,
                  float **csq, float **csqb, float **csqd, int *s, int *e,
                  float c0, float *c1) {
  int i0, i1;
  float tempb1;
  float tempb0;
  float tempb;
  for (i1 = e[1]; i1 > s[1] - 1; --i1)
    for (i0 = e[0]; i0 > s[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]));
      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]));
      tempb = csq[i1][i0] * upb[i1][i0];
      ucb[i1][i0] = ucb[i1][i0] + c0 * tempb + 2.0 * upb[i1][i0];
      csqb[i1][i0] = csqb[i1][i0] + lap * upb[i1][i0];
      ucb[i1][i0 + 1] = ucb[i1][i0 + 1] + c1[0] * tempb;
      ucb[i1][i0 - 1] = ucb[i1][i0 - 1] + c1[0] * tempb;
      ucb[i1 + 1][i0] = ucb[i1 + 1][i0] + c1[1] * tempb;
      ucb[i1 - 1][i0] = ucb[i1 - 1][i0] + c1[1] * tempb;
      upb[i1][i0] = -upb[i1][i0];
      tempb0 = csqd[i1][i0] * updb[i1][i0];
      tempb1 = csq[i1][i0] * updb[i1][i0];
      ucdb[i1][i0] = ucdb[i1][i0] + c0 * tempb1 + 2.0 * updb[i1][i0];
      ucb[i1][i0] = ucb[i1][i0] + c0 * tempb0;
      ucb[i1][i0 + 1] = ucb[i1][i0 + 1] + c1[0] * tempb0;
      ucb[i1][i0 - 1] = ucb[i1][i0 - 1] + c1[0] * tempb0;
      ucb[i1 + 1][i0] = ucb[i1 + 1][i0] + c1[1] * tempb0;
      ucb[i1 - 1][i0] = ucb[i1 - 1][i0] + c1[1] * tempb0;
      csqb[i1][i0] = csqb[i1][i0] + lapd * updb[i1][i0];
      ucdb[i1][i0 + 1] = ucdb[i1][i0 + 1] + c1[0] * tempb1;
      ucdb[i1][i0 - 1] = ucdb[i1][i0 - 1] + c1[0] * tempb1;
      ucdb[i1 + 1][i0] = ucdb[i1 + 1][i0] + c1[1] * tempb1;
      ucdb[i1 - 1][i0] = ucdb[i1 - 1][i0] + c1[1] * tempb1;
      updb[i1][i0] = -updb[i1][i0];
    }
}


x86 assembly (clang, -O0):
<acd_2d_2_d_b>:
push   %rbp
mov    %rsp,%rbp
mov    0x48(%rbp),%rax
mov    0x40(%rbp),%rax
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
movss  %xmm0,-0x34(%rbp)
mov    0x40(%rbp),%rax
mov    0x4(%rax),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    0x38(%rbp),%rcx
mov    0x4(%rcx),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jle    1901 <acd_2d_2_d_b+0x801>
mov    0x40(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    0x38(%rbp),%rcx
mov    (%rcx),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jle    18ee <acd_2d_2_d_b+0x7ee>
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
movss  %xmm0,-0x4c(%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
movss  %xmm0,-0x50(%rbp)
mov    0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x34(%rbp),%xmm0
movss  -0x48(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm1
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%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
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x4c(%rbp),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    0x28(%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
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    0x48(%rbp),%rax
movss  (%rax),%xmm0
movss  -0x48(%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
add    $0x1,%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    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    0x48(%rbp),%rax
movss  (%rax),%xmm0
movss  -0x48(%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    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    0x48(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  -0x48(%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
movslq -0x38(%rbp),%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
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    0x48(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  -0x48(%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
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%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
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x34(%rbp),%xmm0
movss  -0x40(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm1
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
addsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x34(%rbp),%xmm0
movss  -0x44(%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
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    0x48(%rbp),%rax
movss  (%rax),%xmm0
movss  -0x44(%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
add    $0x1,%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    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    0x48(%rbp),%rax
movss  (%rax),%xmm0
movss  -0x44(%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    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    0x48(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  -0x44(%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
movslq -0x38(%rbp),%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
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    0x48(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  -0x44(%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
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x50(%rbp),%xmm0
mov    0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
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),%xmm1
mov    0x48(%rbp),%rax
movss  (%rax),%xmm0
movss  -0x40(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%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  %xmm0,(%rax,%rcx,4)
mov    -0x20(%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    0x48(%rbp),%rax
movss  (%rax),%xmm0
movss  -0x40(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x20(%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    -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),%xmm1
mov    0x48(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  -0x40(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%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  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    0x48(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  -0x40(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%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
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x38(%rbp)
jmp    1169 <acd_2d_2_d_b+0x69>
jmp    18f3 <acd_2d_2_d_b+0x7f3>
mov    -0x3c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x3c(%rbp)
jmp    114b <acd_2d_2_d_b+0x4b>
pop    %rbp
ret

x86 assembly (clang, -O2):
<acd_2d_2_d_b>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x10,%rsp
mov    %r9,-0x40(%rsp)
mov    %rcx,-0x48(%rsp)
mov    %rdx,-0x50(%rsp)
mov    %rsi,-0x58(%rsp)
mov    %rdi,-0x60(%rsp)
mov    0x78(%rsp),%rdx
mov    0x70(%rsp),%rcx
movslq 0x4(%rdx),%rbp
movslq 0x4(%rcx),%rsi
cmp    %esi,%ebp
jge    114c <acd_2d_2_d_b+0x4c>
add    $0x10,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    0x80(%rsp),%rax
movslq (%rdx),%rdx
movslq (%rcx),%rcx
mov    %rdx,%rdi
add    $0x1,%rdi
mov    %rdi,-0x78(%rsp)
movaps 0xe92(%rip),%xmm8
mov    %rsi,-0x68(%rsp)
mov    %rdx,-0x70(%rsp)
mov    %rcx,-0x80(%rsp)
jmp    118c <acd_2d_2_d_b+0x8c>
nop
lea    -0x1(%rbp),%rdi
cmp    %rsi,%rbp
mov    %rdi,%rbp
jle    113d <acd_2d_2_d_b+0x3d>
cmp    %ecx,%edx
jl     1180 <acd_2d_2_d_b+0x80>
mov    -0x60(%rsp),%rcx
mov    -0x8(%rcx,%rbp,8),%rdx
mov    %rdx,0x8(%rsp)
mov    (%rcx,%rbp,8),%r15
mov    0x8(%rcx,%rbp,8),%rcx
mov    %rcx,(%rsp)
lea    -0x1(%rbp),%rcx
mov    %rcx,-0x38(%rsp)
mov    -0x50(%rsp),%rcx
mov    -0x8(%rcx,%rbp,8),%rdx
mov    %rdx,-0x8(%rsp)
mov    (%rcx,%rbp,8),%r9
mov    0x8(%rcx,%rbp,8),%rcx
mov    %rcx,-0x10(%rsp)
mov    0x58(%rsp),%rcx
mov    (%rcx,%rbp,8),%rcx
mov    %rcx,-0x18(%rsp)
mov    -0x40(%rsp),%rcx
mov    (%rcx,%rbp,8),%r11
mov    -0x58(%rsp),%rdi
mov    -0x8(%rdi,%rbp,8),%r14
mov    (%rdi,%rbp,8),%rdx
mov    0x60(%rsp),%rsi
mov    (%rsi,%rbp,8),%rsi
mov    0x8(%rdi,%rbp,8),%rdi
mov    0x68(%rsp),%rbx
mov    (%rbx,%rbp,8),%rcx
mov    %rcx,-0x20(%rsp)
mov    0x50(%rsp),%rbx
mov    (%rbx,%rbp,8),%rbx
mov    -0x48(%rsp),%r13
mov    -0x8(%r13,%rbp,8),%rcx
mov    %rcx,-0x28(%rsp)
mov    0x0(%r13,%rbp,8),%r12
mov    %rbp,-0x30(%rsp)
mov    0x8(%r13,%rbp,8),%r8
mov    -0x78(%rsp),%r13
nop
movss  (%r15,%r13,4),%xmm1
addss  -0x8(%r15,%r13,4),%xmm1
movss  (%rax),%xmm6
movss  0x4(%rax),%xmm9
mulss  %xmm6,%xmm1
movss  -0x4(%r15,%r13,4),%xmm3
mulss  %xmm0,%xmm3
addss  %xmm1,%xmm3
mov    (%rsp),%rbp
movss  -0x4(%rbp,%r13,4),%xmm7
mov    0x8(%rsp),%r10
addss  -0x4(%r10,%r13,4),%xmm7
mulss  %xmm9,%xmm7
movss  (%r9,%r13,4),%xmm4
addss  -0x8(%r9,%r13,4),%xmm4
addss  %xmm3,%xmm7
mov    -0x10(%rsp),%rbp
movss  -0x4(%rbp,%r13,4),%xmm3
mov    -0x8(%rsp),%rbp
addss  -0x4(%rbp,%r13,4),%xmm3
movss  -0x4(%r11,%r13,4),%xmm5
mov    -0x18(%rsp),%rbp
movss  -0x4(%rbp,%r13,4),%xmm1
mulss  %xmm5,%xmm1
movaps %xmm0,%xmm2
mulss  %xmm1,%xmm2
addss  -0x4(%rdx,%r13,4),%xmm2
cvtss2sd %xmm2,%xmm2
cvtss2sd %xmm5,%xmm5
addsd  %xmm5,%xmm5
addsd  %xmm2,%xmm5
xorps  %xmm2,%xmm2
cvtsd2ss %xmm5,%xmm2
movss  -0x4(%r9,%r13,4),%xmm5
movss  %xmm2,-0x4(%rdx,%r13,4)
mulss  -0x4(%r11,%r13,4),%xmm7
addss  -0x4(%rsi,%r13,4),%xmm7
movss  %xmm7,-0x4(%rsi,%r13,4)
movss  (%rax),%xmm2
mulss  %xmm1,%xmm2
addss  (%rdx,%r13,4),%xmm2
movss  %xmm2,(%rdx,%r13,4)
movss  (%rax),%xmm2
mulss  %xmm1,%xmm2
addss  -0x8(%rdx,%r13,4),%xmm2
movss  %xmm2,-0x8(%rdx,%r13,4)
movss  0x4(%rax),%xmm2
mulss  %xmm1,%xmm2
addss  -0x4(%rdi,%r13,4),%xmm2
movss  %xmm2,-0x4(%rdi,%r13,4)
mulss  0x4(%rax),%xmm1
addss  -0x4(%r14,%r13,4),%xmm1
mulss  %xmm6,%xmm4
movss  %xmm1,-0x4(%r14,%r13,4)
movss  -0x4(%r11,%r13,4),%xmm1
xorps  %xmm8,%xmm1
movss  %xmm1,-0x4(%r11,%r13,4)
movss  -0x4(%rbx,%r13,4),%xmm6
mov    -0x20(%rsp),%rcx
movss  -0x4(%rcx,%r13,4),%xmm7
mulss  %xmm6,%xmm7
xorps  %xmm1,%xmm1
cvtss2sd %xmm6,%xmm1
mulss  -0x4(%rbp,%r13,4),%xmm6
movaps %xmm0,%xmm2
mulss  %xmm6,%xmm2
addss  -0x4(%r12,%r13,4),%xmm2
cvtss2sd %xmm2,%xmm2
addsd  %xmm1,%xmm1
addsd  %xmm2,%xmm1
mulss  %xmm0,%xmm5
cvtsd2ss %xmm1,%xmm1
movss  %xmm1,-0x4(%r12,%r13,4)
movaps %xmm0,%xmm1
mulss  %xmm7,%xmm1
addss  -0x4(%rdx,%r13,4),%xmm1
addss  %xmm4,%xmm5
movss  %xmm1,-0x4(%rdx,%r13,4)
movss  (%rax),%xmm1
mulss  %xmm7,%xmm1
addss  (%rdx,%r13,4),%xmm1
movss  %xmm1,(%rdx,%r13,4)
movss  (%rax),%xmm1
mulss  %xmm7,%xmm1
addss  -0x8(%rdx,%r13,4),%xmm1
movss  %xmm1,-0x8(%rdx,%r13,4)
movss  0x4(%rax),%xmm1
mulss  %xmm7,%xmm1
addss  -0x4(%rdi,%r13,4),%xmm1
mulss  %xmm9,%xmm3
movss  %xmm1,-0x4(%rdi,%r13,4)
mulss  0x4(%rax),%xmm7
addss  %xmm5,%xmm3
addss  -0x4(%r14,%r13,4),%xmm7
movss  %xmm7,-0x4(%r14,%r13,4)
mulss  -0x4(%rbx,%r13,4),%xmm3
addss  -0x4(%rsi,%r13,4),%xmm3
movss  %xmm3,-0x4(%rsi,%r13,4)
movss  (%rax),%xmm1
mulss  %xmm6,%xmm1
addss  (%r12,%r13,4),%xmm1
movss  %xmm1,(%r12,%r13,4)
movss  (%rax),%xmm1
mulss  %xmm6,%xmm1
addss  -0x8(%r12,%r13,4),%xmm1
movss  %xmm1,-0x8(%r12,%r13,4)
movss  0x4(%rax),%xmm1
mulss  %xmm6,%xmm1
addss  -0x4(%r8,%r13,4),%xmm1
movss  %xmm1,-0x4(%r8,%r13,4)
mulss  0x4(%rax),%xmm6
mov    -0x28(%rsp),%rcx
addss  -0x4(%rcx,%r13,4),%xmm6
movss  %xmm6,-0x4(%rcx,%r13,4)
movss  -0x4(%rbx,%r13,4),%xmm1
xorps  %xmm8,%xmm1
movss  %xmm1,-0x4(%rbx,%r13,4)
add    $0xffffffffffffffff,%r13
cmp    -0x80(%rsp),%r13
jg     1240 <acd_2d_2_d_b+0x140>
mov    -0x30(%rsp),%rbp
mov    -0x68(%rsp),%rsi
mov    -0x70(%rsp),%rdx
mov    -0x80(%rsp),%rcx
mov    -0x38(%rsp),%rdi
jmp    1184 <acd_2d_2_d_b+0x84>

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

LLVM IR (-O2):
define void @acd_2d_2_d_b(float** nocapture %0, float** nocapture %1, float** nocapture %2, float** nocapture %3, float** nocapture readnone %4, float** nocapture %5, float** nocapture readnone %6, float** nocapture %7, float** nocapture %8, float** nocapture %9, float** nocapture %10, i32* nocapture %11, i32* nocapture %12, float %13, float* nocapture %14) {
%16 = getelementptr inbounds i32, i32* %12, i64 1
%17 = load i32, i32* %16
%18 = getelementptr inbounds i32, i32* %11, i64 1
%19 = load i32, i32* %18
%20 = icmp slt i32 %17, %19
br i1 %20, label %194, label %21
21: ; preds = %15
%22 = load i32, i32* %12
%23 = load i32, i32* %11
%24 = icmp slt i32 %22, %23
%25 = getelementptr inbounds float, float* %14, i64 1
%26 = sext i32 %22 to i64
%27 = sext i32 %23 to i64
%28 = sext i32 %17 to i64
%29 = sext i32 %19 to i64
br label %30
30: ; preds = %21, %191
%31 = phi i64 [ %28, %21 ], [ %192, %191 ]
br i1 %24, label %32, label %34
32: ; preds = %30
%33 = add nsw i64 %31, -1
br label %191
34: ; preds = %30
%35 = getelementptr inbounds float*, float** %0, i64 %31
%36 = load float*, float** %35
%37 = add nsw i64 %31, 1
%38 = getelementptr inbounds float*, float** %0, i64 %37
%39 = load float*, float** %38
%40 = add nsw i64 %31, -1
%41 = getelementptr inbounds float*, float** %0, i64 %40
%42 = load float*, float** %41
%43 = getelementptr inbounds float*, float** %2, i64 %31
%44 = load float*, float** %43
%45 = getelementptr inbounds float*, float** %2, i64 %37
%46 = load float*, float** %45
%47 = getelementptr inbounds float*, float** %2, i64 %40
%48 = load float*, float** %47
%49 = getelementptr inbounds float*, float** %8, i64 %31
%50 = load float*, float** %49
%51 = getelementptr inbounds float*, float** %5, i64 %31
%52 = load float*, float** %51
%53 = getelementptr inbounds float*, float** %1, i64 %31
%54 = load float*, float** %53
%55 = getelementptr inbounds float*, float** %9, i64 %31
%56 = load float*, float** %55
%57 = getelementptr inbounds float*, float** %1, i64 %37
%58 = load float*, float** %57
%59 = getelementptr inbounds float*, float** %1, i64 %40
%60 = load float*, float** %59
%61 = getelementptr inbounds float*, float** %10, i64 %31
%62 = load float*, float** %61
%63 = getelementptr inbounds float*, float** %7, i64 %31
%64 = load float*, float** %63
%65 = getelementptr inbounds float*, float** %3, i64 %31
%66 = load float*, float** %65
%67 = getelementptr inbounds float*, float** %3, i64 %37
%68 = load float*, float** %67
%69 = getelementptr inbounds float*, float** %3, i64 %40
%70 = load float*, float** %69
br label %71
71: ; preds = %34, %71
%72 = phi i64 [ %26, %34 ], [ %79, %71 ]
%73 = getelementptr inbounds float, float* %36, i64 %72
%74 = load float, float* %73
%75 = load float, float* %14
%76 = add nsw i64 %72, 1
%77 = getelementptr inbounds float, float* %36, i64 %76
%78 = load float, float* %77
%79 = add nsw i64 %72, -1
%80 = getelementptr inbounds float, float* %36, i64 %79
%81 = load float, float* %80
%82 = fadd float %78, %81
%83 = fmul float %75, %82
%84 = tail call float @llvm.fmuladd.f32(float %13, float %74, float %83)
%85 = load float, float* %25
%86 = getelementptr inbounds float, float* %39, i64 %72
%87 = load float, float* %86
%88 = getelementptr inbounds float, float* %42, i64 %72
%89 = load float, float* %88
%90 = fadd float %87, %89
%91 = tail call float @llvm.fmuladd.f32(float %85, float %90, float %84)
%92 = getelementptr inbounds float, float* %44, i64 %72
%93 = load float, float* %92
%94 = getelementptr inbounds float, float* %44, i64 %76
%95 = load float, float* %94
%96 = getelementptr inbounds float, float* %44, i64 %79
%97 = load float, float* %96
%98 = fadd float %95, %97
%99 = fmul float %75, %98
%100 = tail call float @llvm.fmuladd.f32(float %13, float %93, float %99)
%101 = getelementptr inbounds float, float* %46, i64 %72
%102 = load float, float* %101
%103 = getelementptr inbounds float, float* %48, i64 %72
%104 = load float, float* %103
%105 = fadd float %102, %104
%106 = tail call float @llvm.fmuladd.f32(float %85, float %105, float %100)
%107 = getelementptr inbounds float, float* %50, i64 %72
%108 = load float, float* %107
%109 = getelementptr inbounds float, float* %52, i64 %72
%110 = load float, float* %109
%111 = fmul float %108, %110
%112 = getelementptr inbounds float, float* %54, i64 %72
%113 = load float, float* %112
%114 = tail call float @llvm.fmuladd.f32(float %13, float %111, float %113)
%115 = fpext float %114 to double
%116 = fpext float %110 to double
%117 = tail call double @llvm.fmuladd.f64(double %116, double 2.000000e+00, double %115)
%118 = fptrunc double %117 to float
store float %118, float* %112
%119 = getelementptr inbounds float, float* %56, i64 %72
%120 = load float, float* %119
%121 = load float, float* %109
%122 = tail call float @llvm.fmuladd.f32(float %91, float %121, float %120)
store float %122, float* %119
%123 = getelementptr inbounds float, float* %54, i64 %76
%124 = load float, float* %123
%125 = load float, float* %14
%126 = tail call float @llvm.fmuladd.f32(float %125, float %111, float %124)
store float %126, float* %123
%127 = getelementptr inbounds float, float* %54, i64 %79
%128 = load float, float* %127
%129 = load float, float* %14
%130 = tail call float @llvm.fmuladd.f32(float %129, float %111, float %128)
store float %130, float* %127
%131 = getelementptr inbounds float, float* %58, i64 %72
%132 = load float, float* %131
%133 = load float, float* %25
%134 = tail call float @llvm.fmuladd.f32(float %133, float %111, float %132)
store float %134, float* %131
%135 = getelementptr inbounds float, float* %60, i64 %72
%136 = load float, float* %135
%137 = load float, float* %25
%138 = tail call float @llvm.fmuladd.f32(float %137, float %111, float %136)
store float %138, float* %135
%139 = load float, float* %109
%140 = fneg float %139
store float %140, float* %109
%141 = getelementptr inbounds float, float* %62, i64 %72
%142 = load float, float* %141
%143 = getelementptr inbounds float, float* %64, i64 %72
%144 = load float, float* %143
%145 = fmul float %142, %144
%146 = load float, float* %107
%147 = fmul float %144, %146
%148 = getelementptr inbounds float, float* %66, i64 %72
%149 = load float, float* %148
%150 = tail call float @llvm.fmuladd.f32(float %13, float %147, float %149)
%151 = fpext float %150 to double
%152 = fpext float %144 to double
%153 = tail call double @llvm.fmuladd.f64(double %152, double 2.000000e+00, double %151)
%154 = fptrunc double %153 to float
store float %154, float* %148
%155 = load float, float* %112
%156 = tail call float @llvm.fmuladd.f32(float %13, float %145, float %155)
store float %156, float* %112
%157 = load float, float* %123
%158 = load float, float* %14
%159 = tail call float @llvm.fmuladd.f32(float %158, float %145, float %157)
store float %159, float* %123
%160 = load float, float* %127
%161 = load float, float* %14
%162 = tail call float @llvm.fmuladd.f32(float %161, float %145, float %160)
store float %162, float* %127
%163 = load float, float* %131
%164 = load float, float* %25
%165 = tail call float @llvm.fmuladd.f32(float %164, float %145, float %163)
store float %165, float* %131
%166 = load float, float* %135
%167 = load float, float* %25
%168 = tail call float @llvm.fmuladd.f32(float %167, float %145, float %166)
store float %168, float* %135
%169 = load float, float* %119
%170 = load float, float* %143
%171 = tail call float @llvm.fmuladd.f32(float %106, float %170, float %169)
store float %171, float* %119
%172 = getelementptr inbounds float, float* %66, i64 %76
%173 = load float, float* %172
%174 = load float, float* %14
%175 = tail call float @llvm.fmuladd.f32(float %174, float %147, float %173)
store float %175, float* %172
%176 = getelementptr inbounds float, float* %66, i64 %79
%177 = load float, float* %176
%178 = load float, float* %14
%179 = tail call float @llvm.fmuladd.f32(float %178, float %147, float %177)
store float %179, float* %176
%180 = getelementptr inbounds float, float* %68, i64 %72
%181 = load float, float* %180
%182 = load float, float* %25
%183 = tail call float @llvm.fmuladd.f32(float %182, float %147, float %181)
store float %183, float* %180
%184 = getelementptr inbounds float, float* %70, i64 %72
%185 = load float, float* %184
%186 = load float, float* %25
%187 = tail call float @llvm.fmuladd.f32(float %186, float %147, float %185)
store float %187, float* %184
%188 = load float, float* %143
%189 = fneg float %188
store float %189, float* %143
%190 = icmp sgt i64 %72, %27
br i1 %190, label %71, label %191
191: ; preds = %71, %32
%192 = phi i64 [ %33, %32 ], [ %40, %71 ]
%193 = icmp sgt i64 %31, %29
br i1 %193, label %30, label %194
194: ; preds = %191, %15
ret void
}