void acd_2d_8_b(float **uc, float **ucb, float **up, float **upb, float **csq,
                float **csqb, int *s, int *e, float c0, float *c1, float *c2,
                float *c3, float *c4, int *lbc, int *rbc) {
  int i0, i1;
  int branch;
  float tmp4b;
  float tmpb;
  float tmp0b;
  float tmp3b;
  float tempb;
  float tmp2b;
  float tmp1b;
  if (lbc[1])
    pushcontrol1b(0);
  else
    pushcontrol1b(1);
  if (rbc[1])
    pushcontrol1b(0);
  else
    pushcontrol1b(1);
  if (lbc[0])
    pushcontrol1b(0);
  else
    pushcontrol1b(1);
  if (rbc[0])
    for (i1 = e[1]; i1 > s[1] - 1; --i1) {
      upb[i1][e[0] - 2] = upb[i1][e[0] - 2] - upb[i1][e[0] + 4];
      upb[i1][e[0] + 4] = 0.0;
      upb[i1][e[0] - 1] = upb[i1][e[0] - 1] - upb[i1][e[0] + 3];
      upb[i1][e[0] + 3] = 0.0;
      upb[i1][e[0] - 0] = upb[i1][e[0] - 0] - upb[i1][e[0] + 2];
      upb[i1][e[0] + 2] = 0.0;
    }
  popcontrol1b(&branch);
  if (branch == 0)
    for (i1 = e[1]; i1 > s[1] - 1; --i1) {
      upb[i1][s[0] + 2] = upb[i1][s[0] + 2] - upb[i1][s[0] - 4];
      upb[i1][s[0] - 4] = 0.0;
      upb[i1][s[0] + 1] = upb[i1][s[0] + 1] - upb[i1][s[0] - 3];
      upb[i1][s[0] - 3] = 0.0;
      upb[i1][s[0] + 0] = upb[i1][s[0] + 0] - upb[i1][s[0] - 2];
      upb[i1][s[0] - 2] = 0.0;
    }
  popcontrol1b(&branch);
  if (branch == 0)
    for (i0 = e[0]; i0 > s[0] - 1; --i0) {
      tmp4b = upb[e[1] + 4][i0];
      upb[e[1] + 4][i0] = 0.0;
      upb[e[1] - 2][i0] = upb[e[1] - 2][i0] - tmp4b;
      tmp3b = upb[e[1] + 3][i0];
      upb[e[1] + 3][i0] = 0.0;
      upb[e[1] - 1][i0] = upb[e[1] - 1][i0] - tmp3b;
      tmp2b = upb[e[1] + 2][i0];
      upb[e[1] + 2][i0] = 0.0;
      upb[e[1] - 0][i0] = upb[e[1] - 0][i0] - tmp2b;
    }
  popcontrol1b(&branch);
  if (branch == 0)
    for (i0 = e[0]; i0 > s[0] - 1; --i0) {
      tmp1b = upb[s[1] - 4][i0];
      upb[s[1] - 4][i0] = 0.0;
      upb[s[1] + 2][i0] = upb[s[1] + 2][i0] - tmp1b;
      tmp0b = upb[s[1] - 3][i0];
      upb[s[1] - 3][i0] = 0.0;
      upb[s[1] + 1][i0] = upb[s[1] + 1][i0] - tmp0b;
      tmpb = upb[s[1] - 2][i0];
      upb[s[1] - 2][i0] = 0.0;
      upb[s[1] + 0][i0] = upb[s[1] + 0][i0] - tmpb;
    }
  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]) +
                  c2[0] * (uc[i1][i0 + 2] + uc[i1][i0 - 2]) +
                  c2[1] * (uc[i1 + 2][i0] + uc[i1 - 2][i0]) +
                  c3[0] * (uc[i1][i0 + 3] + uc[i1][i0 - 3]) +
                  c3[1] * (uc[i1 + 3][i0] + uc[i1 - 3][i0]) +
                  c4[0] * (uc[i1][i0 + 4] + uc[i1][i0 - 4]) +
                  c4[1] * (uc[i1 + 4][i0] + uc[i1 - 4][i0]);
      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;
      ucb[i1][i0 + 2] = ucb[i1][i0 + 2] + c2[0] * tempb;
      ucb[i1][i0 - 2] = ucb[i1][i0 - 2] + c2[0] * tempb;
      ucb[i1 + 2][i0] = ucb[i1 + 2][i0] + c2[1] * tempb;
      ucb[i1 - 2][i0] = ucb[i1 - 2][i0] + c2[1] * tempb;
      ucb[i1][i0 + 3] = ucb[i1][i0 + 3] + c3[0] * tempb;
      ucb[i1][i0 - 3] = ucb[i1][i0 - 3] + c3[0] * tempb;
      ucb[i1 + 3][i0] = ucb[i1 + 3][i0] + c3[1] * tempb;
      ucb[i1 - 3][i0] = ucb[i1 - 3][i0] + c3[1] * tempb;
      ucb[i1][i0 + 4] = ucb[i1][i0 + 4] + c4[0] * tempb;
      ucb[i1][i0 - 4] = ucb[i1][i0 - 4] + c4[0] * tempb;
      ucb[i1 + 4][i0] = ucb[i1 + 4][i0] + c4[1] * tempb;
      ucb[i1 - 4][i0] = ucb[i1 - 4][i0] + c4[1] * tempb;
      upb[i1][i0] = -upb[i1][i0];
    }
}


x86 assembly (clang, -O0):
<acd_2d_8_b>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
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
cmpl   $0x0,0x4(%rax)
je     1181 <acd_2d_8_b+0x61>
xor    %edi,%edi
mov    $0x0,%al
call   1040 <pushcontrol1b@plt>
jmp    118d <acd_2d_8_b+0x6d>
mov    $0x1,%edi
mov    $0x0,%al
call   1040 <pushcontrol1b@plt>
mov    0x48(%rbp),%rax
cmpl   $0x0,0x4(%rax)
je     11a9 <acd_2d_8_b+0x89>
xor    %edi,%edi
mov    $0x0,%al
call   1040 <pushcontrol1b@plt>
jmp    11b5 <acd_2d_8_b+0x95>
mov    $0x1,%edi
mov    $0x0,%al
call   1040 <pushcontrol1b@plt>
mov    0x40(%rbp),%rax
cmpl   $0x0,(%rax)
je     11d0 <acd_2d_8_b+0xb0>
xor    %edi,%edi
mov    $0x0,%al
call   1040 <pushcontrol1b@plt>
jmp    11dc <acd_2d_8_b+0xbc>
mov    $0x1,%edi
mov    $0x0,%al
call   1040 <pushcontrol1b@plt>
mov    0x48(%rbp),%rax
cmpl   $0x0,(%rax)
je     1380 <acd_2d_8_b+0x260>
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    137b <acd_2d_8_b+0x25b>
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x18(%rbp),%rcx
mov    (%rcx),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x18(%rbp),%rcx
mov    (%rcx),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x18(%rbp),%rcx
mov    (%rcx),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  %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    $0x4,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x18(%rbp),%rcx
mov    (%rcx),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x18(%rbp),%rcx
mov    (%rcx),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x18(%rbp),%rcx
mov    (%rcx),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %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    $0x3,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x18(%rbp),%rcx
mov    (%rcx),%ecx
sub    $0x0,%ecx
movslq %ecx,%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
mov    (%rcx),%ecx
sub    $0x0,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x18(%rbp),%rcx
mov    (%rcx),%ecx
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    11f3 <acd_2d_8_b+0xd3>
jmp    1380 <acd_2d_8_b+0x260>
lea    -0x40(%rbp),%rdi
mov    $0x0,%al
call   1030 <popcontrol1b@plt>
cmpl   $0x0,-0x40(%rbp)
jne    152c <acd_2d_8_b+0x40c>
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    1527 <acd_2d_8_b+0x407>
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x10(%rbp),%rcx
mov    (%rcx),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x10(%rbp),%rcx
mov    (%rcx),%ecx
sub    $0x4,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x10(%rbp),%rcx
mov    (%rcx),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  %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    $0x4,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x10(%rbp),%rcx
mov    (%rcx),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x10(%rbp),%rcx
mov    (%rcx),%ecx
sub    $0x3,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x10(%rbp),%rcx
mov    (%rcx),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %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    $0x3,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x10(%rbp),%rcx
mov    (%rcx),%ecx
add    $0x0,%ecx
movslq %ecx,%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
mov    (%rcx),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x10(%rbp),%rcx
mov    (%rcx),%ecx
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    139f <acd_2d_8_b+0x27f>
jmp    152c <acd_2d_8_b+0x40c>
lea    -0x40(%rbp),%rdi
mov    $0x0,%al
call   1030 <popcontrol1b@plt>
cmpl   $0x0,-0x40(%rbp)
jne    1700 <acd_2d_8_b+0x5e0>
mov    0x18(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    0x10(%rbp),%rcx
mov    (%rcx),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jle    16fb <acd_2d_8_b+0x5db>
mov    -0x20(%rbp),%rax
mov    0x18(%rbp),%rcx
mov    0x4(%rcx),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x20(%rbp),%rax
mov    0x18(%rbp),%rcx
mov    0x4(%rcx),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
mov    0x18(%rbp),%rcx
mov    0x4(%rcx),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  -0x44(%rbp),%xmm0
mov    -0x20(%rbp),%rax
mov    0x18(%rbp),%rcx
mov    0x4(%rcx),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
mov    0x18(%rbp),%rcx
mov    0x4(%rcx),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x20(%rbp),%rax
mov    0x18(%rbp),%rcx
mov    0x4(%rcx),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
mov    0x18(%rbp),%rcx
mov    0x4(%rcx),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  -0x50(%rbp),%xmm0
mov    -0x20(%rbp),%rax
mov    0x18(%rbp),%rcx
mov    0x4(%rcx),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  %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
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x58(%rbp)
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    -0x20(%rbp),%rax
mov    0x18(%rbp),%rcx
mov    0x4(%rcx),%ecx
sub    $0x0,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  -0x58(%rbp),%xmm0
mov    -0x20(%rbp),%rax
mov    0x18(%rbp),%rcx
mov    0x4(%rcx),%ecx
sub    $0x0,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x38(%rbp)
jmp    154a <acd_2d_8_b+0x42a>
jmp    1700 <acd_2d_8_b+0x5e0>
lea    -0x40(%rbp),%rdi
mov    $0x0,%al
call   1030 <popcontrol1b@plt>
cmpl   $0x0,-0x40(%rbp)
jne    18d4 <acd_2d_8_b+0x7b4>
mov    0x18(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    0x10(%rbp),%rcx
mov    (%rcx),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jle    18cf <acd_2d_8_b+0x7af>
mov    -0x20(%rbp),%rax
mov    0x10(%rbp),%rcx
mov    0x4(%rcx),%ecx
sub    $0x4,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x20(%rbp),%rax
mov    0x10(%rbp),%rcx
mov    0x4(%rcx),%ecx
sub    $0x4,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
mov    0x10(%rbp),%rcx
mov    0x4(%rcx),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  -0x5c(%rbp),%xmm0
mov    -0x20(%rbp),%rax
mov    0x10(%rbp),%rcx
mov    0x4(%rcx),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
mov    0x10(%rbp),%rcx
mov    0x4(%rcx),%ecx
sub    $0x3,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x20(%rbp),%rax
mov    0x10(%rbp),%rcx
mov    0x4(%rcx),%ecx
sub    $0x3,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
mov    0x10(%rbp),%rcx
mov    0x4(%rcx),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  -0x4c(%rbp),%xmm0
mov    -0x20(%rbp),%rax
mov    0x10(%rbp),%rcx
mov    0x4(%rcx),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  %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
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x48(%rbp)
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    -0x20(%rbp),%rax
mov    0x10(%rbp),%rcx
mov    0x4(%rcx),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  -0x48(%rbp),%xmm0
mov    -0x20(%rbp),%rax
mov    0x10(%rbp),%rcx
mov    0x4(%rcx),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x38(%rbp)
jmp    171e <acd_2d_8_b+0x5fe>
jmp    18d4 <acd_2d_8_b+0x7b4>
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    2127 <acd_2d_8_b+0x1007>
mov    0x18(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    0x10(%rbp),%rcx
mov    (%rcx),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jle    2114 <acd_2d_8_b+0xff4>
movss  -0x34(%rbp),%xmm1
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    0x20(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm3
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm3
mulss  %xmm3,%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    0x20(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    0x28(%rbp),%rax
movss  (%rax),%xmm1
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    0x28(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    0x30(%rbp),%rax
movss  (%rax),%xmm1
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
sub    $0x3,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    0x30(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x3,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    0x38(%rbp),%rax
movss  (%rax),%xmm1
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
sub    $0x4,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    0x38(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x4,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x54(%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  -0x54(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm1
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
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    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x60(%rbp),%xmm0
mov    -0x20(%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    -0x30(%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    0x20(%rbp),%rax
movss  (%rax),%xmm0
movss  -0x54(%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    0x20(%rbp),%rax
movss  (%rax),%xmm0
movss  -0x54(%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    0x20(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  -0x54(%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    0x20(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  -0x54(%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    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    0x28(%rbp),%rax
movss  (%rax),%xmm0
movss  -0x54(%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    $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
mov    0x28(%rbp),%rax
movss  (%rax),%xmm0
movss  -0x54(%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    $0x2,%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
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    0x28(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  -0x54(%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
movslq -0x38(%rbp),%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
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    0x28(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  -0x54(%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
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    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    0x30(%rbp),%rax
movss  (%rax),%xmm0
movss  -0x54(%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    $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    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    0x30(%rbp),%rax
movss  (%rax),%xmm0
movss  -0x54(%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
mov    -0x3c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    0x30(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  -0x54(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x3,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    0x30(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  -0x54(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x3,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    0x38(%rbp),%rax
movss  (%rax),%xmm0
movss  -0x54(%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    $0x4,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
sub    $0x4,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    0x38(%rbp),%rax
movss  (%rax),%xmm0
movss  -0x54(%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    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    0x38(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  -0x54(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x4,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    0x38(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  -0x54(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x4,%ecx
movslq %ecx,%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
movslq -0x38(%rbp),%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
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x38(%rbp)
jmp    18fc <acd_2d_8_b+0x7dc>
jmp    2119 <acd_2d_8_b+0xff9>
mov    -0x3c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x3c(%rbp)
jmp    18de <acd_2d_8_b+0x7be>
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<acd_2d_8_b>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xb8,%rsp
movss  %xmm0,0x4(%rsp)
mov    %r9,0x40(%rsp)
mov    %r8,0x38(%rsp)
mov    %rcx,%r14
mov    %rsi,0x30(%rsp)
mov    %rdi,0x28(%rsp)
mov    0xf8(%rsp),%r12
mov    0xf0(%rsp),%r15
mov    0x128(%rsp),%rbx
mov    0x120(%rsp),%rbp
xor    %edi,%edi
cmpl   $0x0,0x4(%rbp)
sete   %dil
xor    %eax,%eax
call   1040 <pushcontrol1b@plt>
xor    %edi,%edi
cmpl   $0x0,0x4(%rbx)
sete   %dil
xor    %eax,%eax
call   1040 <pushcontrol1b@plt>
xor    %edi,%edi
cmpl   $0x0,0x0(%rbp)
sete   %dil
xor    %eax,%eax
call   1040 <pushcontrol1b@plt>
cmpl   $0x0,(%rbx)
je     121a <acd_2d_8_b+0xfa>
movslq 0x4(%r12),%rax
movslq 0x4(%r15),%rcx
cmp    %ecx,%eax
jl     121a <acd_2d_8_b+0xfa>
movslq (%r12),%rdx
add    $0x1,%rax
nopl   0x0(%rax,%rax,1)
mov    -0x8(%r14,%rax,8),%rsi
movss  -0x8(%rsi,%rdx,4),%xmm0
subss  0x10(%rsi,%rdx,4),%xmm0
movss  %xmm0,-0x8(%rsi,%rdx,4)
movl   $0x0,0x10(%rsi,%rdx,4)
movss  -0x4(%rsi,%rdx,4),%xmm0
subss  0xc(%rsi,%rdx,4),%xmm0
movss  %xmm0,-0x4(%rsi,%rdx,4)
movl   $0x0,0xc(%rsi,%rdx,4)
movss  (%rsi,%rdx,4),%xmm0
subss  0x8(%rsi,%rdx,4),%xmm0
movss  %xmm0,(%rsi,%rdx,4)
movl   $0x0,0x8(%rsi,%rdx,4)
add    $0xffffffffffffffff,%rax
cmp    %rcx,%rax
jg     11c0 <acd_2d_8_b+0xa0>
mov    %rsp,%rdi
xor    %eax,%eax
call   1030 <popcontrol1b@plt>
cmpl   $0x0,(%rsp)
jne    129a <acd_2d_8_b+0x17a>
movslq 0x4(%r12),%rax
movslq 0x4(%r15),%rcx
cmp    %ecx,%eax
jl     129a <acd_2d_8_b+0x17a>
movslq (%r15),%rdx
add    $0x1,%rax
xchg   %ax,%ax
mov    -0x8(%r14,%rax,8),%rsi
movss  0x8(%rsi,%rdx,4),%xmm0
subss  -0x10(%rsi,%rdx,4),%xmm0
movss  %xmm0,0x8(%rsi,%rdx,4)
movl   $0x0,-0x10(%rsi,%rdx,4)
movss  0x4(%rsi,%rdx,4),%xmm0
subss  -0xc(%rsi,%rdx,4),%xmm0
movss  %xmm0,0x4(%rsi,%rdx,4)
movl   $0x0,-0xc(%rsi,%rdx,4)
movss  (%rsi,%rdx,4),%xmm0
subss  -0x8(%rsi,%rdx,4),%xmm0
movss  %xmm0,(%rsi,%rdx,4)
movl   $0x0,-0x8(%rsi,%rdx,4)
add    $0xffffffffffffffff,%rax
cmp    %rcx,%rax
jg     1240 <acd_2d_8_b+0x120>
mov    %rsp,%rdi
xor    %eax,%eax
call   1030 <popcontrol1b@plt>
cmpl   $0x0,(%rsp)
jne    1353 <acd_2d_8_b+0x233>
movslq (%r12),%rax
movslq (%r15),%r8
cmp    %r8d,%eax
jl     1353 <acd_2d_8_b+0x233>
movslq 0x4(%r12),%rcx
mov    0x20(%r14,%rcx,8),%rdx
mov    -0x10(%r14,%rcx,8),%rsi
mov    -0x8(%r14,%rcx,8),%rdi
mov    0x18(%r14,%rcx,8),%rbp
mov    0x10(%r14,%rcx,8),%rbx
mov    (%r14,%rcx,8),%rcx
add    $0x1,%rax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  -0x4(%rdx,%rax,4),%xmm0
movl   $0x0,-0x4(%rdx,%rax,4)
movss  -0x4(%rsi,%rax,4),%xmm1
subss  %xmm0,%xmm1
movss  %xmm1,-0x4(%rsi,%rax,4)
movss  -0x4(%rbp,%rax,4),%xmm0
movl   $0x0,-0x4(%rbp,%rax,4)
movss  -0x4(%rdi,%rax,4),%xmm1
subss  %xmm0,%xmm1
movss  %xmm1,-0x4(%rdi,%rax,4)
movss  -0x4(%rbx,%rax,4),%xmm0
movl   $0x0,-0x4(%rbx,%rax,4)
movss  -0x4(%rcx,%rax,4),%xmm1
subss  %xmm0,%xmm1
movss  %xmm1,-0x4(%rcx,%rax,4)
add    $0xffffffffffffffff,%rax
cmp    %r8,%rax
jg     12f0 <acd_2d_8_b+0x1d0>
mov    %rsp,%rdi
xor    %eax,%eax
call   1030 <popcontrol1b@plt>
cmpl   $0x0,(%rsp)
jne    1403 <acd_2d_8_b+0x2e3>
movslq (%r12),%rax
movslq (%r15),%r8
cmp    %r8d,%eax
jl     1403 <acd_2d_8_b+0x2e3>
movslq 0x4(%r15),%rcx
mov    -0x20(%r14,%rcx,8),%rdx
mov    -0x18(%r14,%rcx,8),%rsi
mov    0x10(%r14,%rcx,8),%rdi
mov    0x8(%r14,%rcx,8),%rbp
mov    -0x10(%r14,%rcx,8),%rbx
mov    (%r14,%rcx,8),%rcx
add    $0x1,%rax
nopl   0x0(%rax)
movss  -0x4(%rdx,%rax,4),%xmm0
movl   $0x0,-0x4(%rdx,%rax,4)
movss  -0x4(%rdi,%rax,4),%xmm1
subss  %xmm0,%xmm1
movss  %xmm1,-0x4(%rdi,%rax,4)
movss  -0x4(%rsi,%rax,4),%xmm0
movl   $0x0,-0x4(%rsi,%rax,4)
movss  -0x4(%rbp,%rax,4),%xmm1
subss  %xmm0,%xmm1
movss  %xmm1,-0x4(%rbp,%rax,4)
movss  -0x4(%rbx,%rax,4),%xmm0
movl   $0x0,-0x4(%rbx,%rax,4)
movss  -0x4(%rcx,%rax,4),%xmm1
subss  %xmm0,%xmm1
movss  %xmm1,-0x4(%rcx,%rax,4)
add    $0xffffffffffffffff,%rax
cmp    %r8,%rax
jg     13a0 <acd_2d_8_b+0x280>
movslq 0x4(%r12),%rcx
movslq 0x4(%r15),%rax
cmp    %eax,%ecx
movss  0x4(%rsp),%xmm6
jge    1428 <acd_2d_8_b+0x308>
add    $0xb8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    0x118(%rsp),%r8
mov    0x110(%rsp),%r9
mov    0x108(%rsp),%rdi
mov    0x100(%rsp),%rbp
movslq (%r12),%r12
movslq (%r15),%rdx
movaps 0xbaa(%rip),%xmm0
mov    %r14,0x20(%rsp)
mov    %rax,0x18(%rsp)
mov    %r12,0x10(%rsp)
mov    %rdx,0x8(%rsp)
jmp    147c <acd_2d_8_b+0x35c>
nopl   0x0(%rax)
lea    -0x1(%rcx),%rsi
cmp    %rax,%rcx
mov    %rsi,%rcx
jle    1416 <acd_2d_8_b+0x2f6>
cmp    %edx,%r12d
jl     1470 <acd_2d_8_b+0x350>
mov    0x28(%rsp),%rax
mov    (%rax,%rcx,8),%rbx
mov    0x8(%rax,%rcx,8),%rsi
mov    %rsi,0xb0(%rsp)
lea    -0x1(%rcx),%rsi
mov    %rsi,0x48(%rsp)
mov    -0x8(%rax,%rcx,8),%rsi
mov    %rsi,0xa8(%rsp)
mov    0x10(%rax,%rcx,8),%rsi
mov    %rsi,0xa0(%rsp)
mov    -0x10(%rax,%rcx,8),%rsi
mov    %rsi,0x98(%rsp)
mov    0x18(%rax,%rcx,8),%rsi
mov    %rsi,0x90(%rsp)
mov    -0x20(%rax,%rcx,8),%rsi
mov    %rsi,0x88(%rsp)
mov    -0x18(%rax,%rcx,8),%rsi
mov    %rsi,0x80(%rsp)
mov    0x20(%rax,%rcx,8),%rax
mov    %rax,0x78(%rsp)
mov    0x38(%rsp),%rax
mov    (%rax,%rcx,8),%rax
mov    %rax,0x70(%rsp)
mov    %rcx,%rsi
mov    (%r14,%rcx,8),%rcx
mov    0x30(%rsp),%r15
mov    (%r15,%rsi,8),%rax
mov    0x40(%rsp),%rdx
mov    (%rdx,%rsi,8),%rdx
mov    %rdx,0x68(%rsp)
mov    0x8(%r15,%rsi,8),%rdx
mov    %rdx,0x60(%rsp)
mov    -0x8(%r15,%rsi,8),%rdx
mov    %rdx,0x58(%rsp)
mov    0x10(%r15,%rsi,8),%rdx
mov    -0x10(%r15,%rsi,8),%r10
mov    0x18(%r15,%rsi,8),%r13
mov    -0x20(%r15,%rsi,8),%r14
mov    -0x18(%r15,%rsi,8),%r11
mov    %rsi,0x50(%rsp)
mov    0x20(%r15,%rsi,8),%r15
nopl   0x0(%rax,%rax,1)
movss  0x4(%rbx,%r12,4),%xmm1
addss  -0x4(%rbx,%r12,4),%xmm1
movss  0x8(%rbx,%r12,4),%xmm2
mulss  0x0(%rbp),%xmm1
movss  (%rbx,%r12,4),%xmm3
mulss  %xmm6,%xmm3
mov    0xb0(%rsp),%rsi
movss  (%rsi,%r12,4),%xmm4
mov    0xa8(%rsp),%rsi
addss  (%rsi,%r12,4),%xmm4
addss  %xmm1,%xmm3
mulss  0x4(%rbp),%xmm4
addss  %xmm3,%xmm4
addss  -0x8(%rbx,%r12,4),%xmm2
mulss  (%rdi),%xmm2
addss  %xmm4,%xmm2
mov    0xa0(%rsp),%rsi
movss  (%rsi,%r12,4),%xmm1
mov    0x98(%rsp),%rsi
addss  (%rsi,%r12,4),%xmm1
mulss  0x4(%rdi),%xmm1
addss  %xmm2,%xmm1
movss  0xc(%rbx,%r12,4),%xmm2
addss  -0xc(%rbx,%r12,4),%xmm2
mulss  (%r9),%xmm2
addss  %xmm1,%xmm2
mov    0x90(%rsp),%rsi
movss  (%rsi,%r12,4),%xmm1
mov    0x80(%rsp),%rsi
addss  (%rsi,%r12,4),%xmm1
mulss  0x4(%r9),%xmm1
addss  %xmm2,%xmm1
movss  0x10(%rbx,%r12,4),%xmm2
addss  -0x10(%rbx,%r12,4),%xmm2
mulss  (%r8),%xmm2
addss  %xmm1,%xmm2
mov    0x78(%rsp),%rsi
movss  (%rsi,%r12,4),%xmm3
mov    0x88(%rsp),%rsi
addss  (%rsi,%r12,4),%xmm3
mulss  0x4(%r8),%xmm3
movss  (%rcx,%r12,4),%xmm4
mov    0x70(%rsp),%rsi
movss  (%rsi,%r12,4),%xmm1
mulss  %xmm4,%xmm1
movaps %xmm6,%xmm5
mulss  %xmm1,%xmm5
addss  (%rax,%r12,4),%xmm5
addss  %xmm2,%xmm3
xorps  %xmm2,%xmm2
cvtss2sd %xmm5,%xmm2
cvtss2sd %xmm4,%xmm4
addsd  %xmm4,%xmm4
addsd  %xmm2,%xmm4
xorps  %xmm2,%xmm2
cvtsd2ss %xmm4,%xmm2
movss  %xmm2,(%rax,%r12,4)
mulss  (%rcx,%r12,4),%xmm3
mov    0x68(%rsp),%rsi
addss  (%rsi,%r12,4),%xmm3
movss  %xmm3,(%rsi,%r12,4)
movss  0x0(%rbp),%xmm2
mulss  %xmm1,%xmm2
addss  0x4(%rax,%r12,4),%xmm2
movss  %xmm2,0x4(%rax,%r12,4)
movss  0x0(%rbp),%xmm2
mulss  %xmm1,%xmm2
addss  -0x4(%rax,%r12,4),%xmm2
movss  %xmm2,-0x4(%rax,%r12,4)
movss  0x4(%rbp),%xmm2
mulss  %xmm1,%xmm2
mov    0x60(%rsp),%rsi
addss  (%rsi,%r12,4),%xmm2
movss  %xmm2,(%rsi,%r12,4)
movss  0x4(%rbp),%xmm2
mulss  %xmm1,%xmm2
mov    0x58(%rsp),%rsi
addss  (%rsi,%r12,4),%xmm2
movss  %xmm2,(%rsi,%r12,4)
movss  (%rdi),%xmm2
mulss  %xmm1,%xmm2
addss  0x8(%rax,%r12,4),%xmm2
movss  %xmm2,0x8(%rax,%r12,4)
movss  (%rdi),%xmm2
mulss  %xmm1,%xmm2
addss  -0x8(%rax,%r12,4),%xmm2
movss  %xmm2,-0x8(%rax,%r12,4)
movss  0x4(%rdi),%xmm2
mulss  %xmm1,%xmm2
addss  (%rdx,%r12,4),%xmm2
movss  %xmm2,(%rdx,%r12,4)
movss  0x4(%rdi),%xmm2
mulss  %xmm1,%xmm2
addss  (%r10,%r12,4),%xmm2
movss  %xmm2,(%r10,%r12,4)
movss  (%r9),%xmm2
mulss  %xmm1,%xmm2
addss  0xc(%rax,%r12,4),%xmm2
movss  %xmm2,0xc(%rax,%r12,4)
movss  (%r9),%xmm2
mulss  %xmm1,%xmm2
addss  -0xc(%rax,%r12,4),%xmm2
movss  %xmm2,-0xc(%rax,%r12,4)
movss  0x4(%r9),%xmm2
mulss  %xmm1,%xmm2
addss  0x0(%r13,%r12,4),%xmm2
movss  %xmm2,0x0(%r13,%r12,4)
movss  0x4(%r9),%xmm2
mulss  %xmm1,%xmm2
addss  (%r11,%r12,4),%xmm2
movss  %xmm2,(%r11,%r12,4)
movss  (%r8),%xmm2
mulss  %xmm1,%xmm2
addss  0x10(%rax,%r12,4),%xmm2
movss  %xmm2,0x10(%rax,%r12,4)
movss  (%r8),%xmm2
mulss  %xmm1,%xmm2
addss  -0x10(%rax,%r12,4),%xmm2
movss  %xmm2,-0x10(%rax,%r12,4)
movss  0x4(%r8),%xmm2
mulss  %xmm1,%xmm2
addss  (%r15,%r12,4),%xmm2
movss  %xmm2,(%r15,%r12,4)
mulss  0x4(%r8),%xmm1
addss  (%r14,%r12,4),%xmm1
movss  %xmm1,(%r14,%r12,4)
movss  (%rcx,%r12,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,(%rcx,%r12,4)
cmp    0x8(%rsp),%r12
lea    -0x1(%r12),%r12
jg     1560 <acd_2d_8_b+0x440>
mov    0x20(%rsp),%r14
mov    0x50(%rsp),%rcx
mov    0x18(%rsp),%rax
mov    0x10(%rsp),%r12
mov    0x8(%rsp),%rdx
mov    0x48(%rsp),%rsi
jmp    1474 <acd_2d_8_b+0x354>

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

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