void acd_2d_4_d_b(float **uc, float **ucb, float **ucd, float **ucdb,
                  float **up, float **upb, float **upd, float **updb,
                  float **csq, float **csqb, float **csqd, int *s, int *e,
                  float c0, float *c1, float *c2, int *lbc, int *rbc) {
  int i0, i1;
  int branch;
  float tempb1;
  float tempb0;
  float tmpb;
  float tmp0b;
  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]] = upb[i1][e[0]] - upb[i1][e[0] + 2];
      upb[i1][e[0] + 2] = 0.0;
      updb[i1][e[0]] = updb[i1][e[0]] - updb[i1][e[0] + 2];
      updb[i1][e[0] + 2] = 0.0;
    }
  popcontrol1b(&branch);
  if (branch == 0)
    for (i1 = e[1]; i1 > s[1] - 1; --i1) {
      upb[i1][s[0]] = upb[i1][s[0]] - upb[i1][s[0] - 2];
      upb[i1][s[0] - 2] = 0.0;
      updb[i1][s[0]] = updb[i1][s[0]] - updb[i1][s[0] - 2];
      updb[i1][s[0] - 2] = 0.0;
    }
  popcontrol1b(&branch);
  if (branch == 0)
    for (i0 = e[0]; i0 > s[0] - 1; --i0) {
      tmp2b = upb[e[1] + 2][i0];
      upb[e[1] + 2][i0] = 0.0;
      upb[e[1]][i0] = upb[e[1]][i0] - tmp2b;
      tmp1b = updb[e[1] + 2][i0];
      updb[e[1] + 2][i0] = 0.0;
      updb[e[1]][i0] = updb[e[1]][i0] - tmp1b;
    }
  popcontrol1b(&branch);
  if (branch == 0)
    for (i0 = e[0]; i0 > s[0] - 1; --i0) {
      tmp0b = upb[s[1] - 2][i0];
      upb[s[1] - 2][i0] = 0.0;
      upb[s[1]][i0] = upb[s[1]][i0] - tmp0b;
      tmpb = updb[s[1] - 2][i0];
      updb[s[1] - 2][i0] = 0.0;
      updb[s[1]][i0] = updb[s[1]][i0] - tmpb;
    }
  for (i1 = e[1]; i1 > s[1] - 1; --i1)
    for (i0 = e[0]; i0 > s[0] - 1; --i0) {
      tempb = csq[i1][i0] * upb[i1][i0];
      ucb[i1][i0] = ucb[i1][i0] + c0 * tempb + 2.0 * upb[i1][i0];
      csqb[i1][i0] =
          csqb[i1][i0] +
          (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])) *
              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;
      upb[i1][i0] = -upb[i1][i0];
      tempb0 = csqd[i1][i0] * updb[i1][i0];
      tempb1 = csq[i1][i0] * updb[i1][i0];
      ucdb[i1][i0] = ucdb[i1][i0] + c0 * tempb1 + 2.0 * updb[i1][i0];
      ucb[i1][i0] = ucb[i1][i0] + c0 * tempb0;
      ucb[i1][i0 + 1] = ucb[i1][i0 + 1] + c1[0] * tempb0;
      ucb[i1][i0 - 1] = ucb[i1][i0 - 1] + c1[0] * tempb0;
      ucb[i1 + 1][i0] = ucb[i1 + 1][i0] + c1[1] * tempb0;
      ucb[i1 - 1][i0] = ucb[i1 - 1][i0] + c1[1] * tempb0;
      ucb[i1][i0 + 2] = ucb[i1][i0 + 2] + c2[0] * tempb0;
      ucb[i1][i0 - 2] = ucb[i1][i0 - 2] + c2[0] * tempb0;
      ucb[i1 + 2][i0] = ucb[i1 + 2][i0] + c2[1] * tempb0;
      ucb[i1 - 2][i0] = ucb[i1 - 2][i0] + c2[1] * tempb0;
      csqb[i1][i0] =
          csqb[i1][i0] +
          (c0 * ucd[i1][i0] + c1[0] * (ucd[i1][i0 + 1] + ucd[i1][i0 - 1]) +
           c1[1] * (ucd[i1 + 1][i0] + ucd[i1 - 1][i0]) +
           c2[0] * (ucd[i1][i0 + 2] + ucd[i1][i0 - 2]) +
           c2[1] * (ucd[i1 + 2][i0] + ucd[i1 - 2][i0])) *
              updb[i1][i0];
      ucdb[i1][i0 + 1] = ucdb[i1][i0 + 1] + c1[0] * tempb1;
      ucdb[i1][i0 - 1] = ucdb[i1][i0 - 1] + c1[0] * tempb1;
      ucdb[i1 + 1][i0] = ucdb[i1 + 1][i0] + c1[1] * tempb1;
      ucdb[i1 - 1][i0] = ucdb[i1 - 1][i0] + c1[1] * tempb1;
      ucdb[i1][i0 + 2] = ucdb[i1][i0 + 2] + c2[0] * tempb1;
      ucdb[i1][i0 - 2] = ucdb[i1][i0 - 2] + c2[0] * tempb1;
      ucdb[i1 + 2][i0] = ucdb[i1 + 2][i0] + c2[1] * tempb1;
      ucdb[i1 - 2][i0] = ucdb[i1 - 2][i0] + c2[1] * tempb1;
      updb[i1][i0] = -updb[i1][i0];
    }
}


x86 assembly (clang, -O0):
<acd_2d_4_d_b>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    0x60(%rbp),%rax
mov    0x58(%rbp),%rax
mov    0x50(%rbp),%rax
mov    0x48(%rbp),%rax
mov    0x40(%rbp),%rax
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
movss  %xmm0,-0x34(%rbp)
mov    0x58(%rbp),%rax
cmpl   $0x0,0x4(%rax)
je     118d <acd_2d_4_d_b+0x6d>
xor    %edi,%edi
mov    $0x0,%al
call   1040 <pushcontrol1b@plt>
jmp    1199 <acd_2d_4_d_b+0x79>
mov    $0x1,%edi
mov    $0x0,%al
call   1040 <pushcontrol1b@plt>
mov    0x60(%rbp),%rax
cmpl   $0x0,0x4(%rax)
je     11b5 <acd_2d_4_d_b+0x95>
xor    %edi,%edi
mov    $0x0,%al
call   1040 <pushcontrol1b@plt>
jmp    11c1 <acd_2d_4_d_b+0xa1>
mov    $0x1,%edi
mov    $0x0,%al
call   1040 <pushcontrol1b@plt>
mov    0x58(%rbp),%rax
cmpl   $0x0,(%rax)
je     11dc <acd_2d_4_d_b+0xbc>
xor    %edi,%edi
mov    $0x0,%al
call   1040 <pushcontrol1b@plt>
jmp    11e8 <acd_2d_4_d_b+0xc8>
mov    $0x1,%edi
mov    $0x0,%al
call   1040 <pushcontrol1b@plt>
mov    0x60(%rbp),%rax
cmpl   $0x0,(%rax)
je     1301 <acd_2d_4_d_b+0x1e1>
mov    0x40(%rbp),%rax
mov    0x4(%rax),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    0x38(%rbp),%rcx
mov    0x4(%rcx),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jle    12fc <acd_2d_4_d_b+0x1dc>
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x40(%rbp),%rcx
movslq (%rcx),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x40(%rbp),%rcx
mov    (%rcx),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x40(%rbp),%rcx
movslq (%rcx),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x40(%rbp),%rcx
mov    (%rcx),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x40(%rbp),%rcx
movslq (%rcx),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x40(%rbp),%rcx
mov    (%rcx),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
mov    0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x40(%rbp),%rcx
movslq (%rcx),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x40(%rbp),%rcx
mov    (%rcx),%ecx
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    11ff <acd_2d_4_d_b+0xdf>
jmp    1301 <acd_2d_4_d_b+0x1e1>
lea    -0x40(%rbp),%rdi
mov    $0x0,%al
call   1030 <popcontrol1b@plt>
cmpl   $0x0,-0x40(%rbp)
jne    1422 <acd_2d_4_d_b+0x302>
mov    0x40(%rbp),%rax
mov    0x4(%rax),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    0x38(%rbp),%rcx
mov    0x4(%rcx),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jle    141d <acd_2d_4_d_b+0x2fd>
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x38(%rbp),%rcx
movslq (%rcx),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x38(%rbp),%rcx
mov    (%rcx),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x38(%rbp),%rcx
movslq (%rcx),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x38(%rbp),%rcx
mov    (%rcx),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x38(%rbp),%rcx
movslq (%rcx),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x38(%rbp),%rcx
mov    (%rcx),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
mov    0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x38(%rbp),%rcx
movslq (%rcx),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x38(%rbp),%rcx
mov    (%rcx),%ecx
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    1320 <acd_2d_4_d_b+0x200>
jmp    1422 <acd_2d_4_d_b+0x302>
lea    -0x40(%rbp),%rdi
mov    $0x0,%al
call   1030 <popcontrol1b@plt>
cmpl   $0x0,-0x40(%rbp)
jne    155d <acd_2d_4_d_b+0x43d>
mov    0x40(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    0x38(%rbp),%rcx
mov    (%rcx),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jle    1558 <acd_2d_4_d_b+0x438>
mov    -0x30(%rbp),%rax
mov    0x40(%rbp),%rcx
mov    0x4(%rcx),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x30(%rbp),%rax
mov    0x40(%rbp),%rcx
mov    0x4(%rcx),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%rax
mov    0x40(%rbp),%rcx
movslq 0x4(%rcx),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  -0x58(%rbp),%xmm0
mov    -0x30(%rbp),%rax
mov    0x40(%rbp),%rcx
movslq 0x4(%rcx),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x18(%rbp),%rax
mov    0x40(%rbp),%rcx
mov    0x4(%rcx),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    0x18(%rbp),%rax
mov    0x40(%rbp),%rcx
mov    0x4(%rcx),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    0x18(%rbp),%rax
mov    0x40(%rbp),%rcx
movslq 0x4(%rcx),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  -0x5c(%rbp),%xmm0
mov    0x18(%rbp),%rax
mov    0x40(%rbp),%rcx
movslq 0x4(%rcx),%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    1440 <acd_2d_4_d_b+0x320>
jmp    155d <acd_2d_4_d_b+0x43d>
lea    -0x40(%rbp),%rdi
mov    $0x0,%al
call   1030 <popcontrol1b@plt>
cmpl   $0x0,-0x40(%rbp)
jne    1698 <acd_2d_4_d_b+0x578>
mov    0x40(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    0x38(%rbp),%rcx
mov    (%rcx),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jle    1693 <acd_2d_4_d_b+0x573>
mov    -0x30(%rbp),%rax
mov    0x38(%rbp),%rcx
mov    0x4(%rcx),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x30(%rbp),%rax
mov    0x38(%rbp),%rcx
mov    0x4(%rcx),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%rax
mov    0x38(%rbp),%rcx
movslq 0x4(%rcx),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  -0x50(%rbp),%xmm0
mov    -0x30(%rbp),%rax
mov    0x38(%rbp),%rcx
movslq 0x4(%rcx),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x18(%rbp),%rax
mov    0x38(%rbp),%rcx
mov    0x4(%rcx),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    0x18(%rbp),%rax
mov    0x38(%rbp),%rcx
mov    0x4(%rcx),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    0x18(%rbp),%rax
mov    0x38(%rbp),%rcx
movslq 0x4(%rcx),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  -0x4c(%rbp),%xmm0
mov    0x18(%rbp),%rax
mov    0x38(%rbp),%rcx
movslq 0x4(%rcx),%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    157b <acd_2d_4_d_b+0x45b>
jmp    1698 <acd_2d_4_d_b+0x578>
mov    0x40(%rbp),%rax
mov    0x4(%rax),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    0x38(%rbp),%rcx
mov    0x4(%rcx),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jle    22c8 <acd_2d_4_d_b+0x11a8>
mov    0x40(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    0x38(%rbp),%rcx
mov    (%rcx),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jle    22b5 <acd_2d_4_d_b+0x1195>
mov    0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-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    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x34(%rbp),%xmm2
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm3
mov    0x48(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm4
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),%xmm4
mulss  %xmm4,%xmm0
mulss  %xmm3,%xmm2
addss  %xmm0,%xmm2
mov    0x48(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm3
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),%xmm3
mulss  %xmm3,%xmm0
addss  %xmm2,%xmm0
mov    0x50(%rbp),%rax
movss  (%rax),%xmm2
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),%xmm3
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),%xmm3
mulss  %xmm3,%xmm2
addss  %xmm0,%xmm2
mov    0x50(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm3
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),%xmm3
mulss  %xmm3,%xmm0
addss  %xmm2,%xmm0
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    0x48(%rbp),%rax
movss  (%rax),%xmm0
movss  -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    0x48(%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    0x48(%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    0x48(%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    0x50(%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    0x50(%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    0x50(%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    0x50(%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    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x48(%rbp)
mov    0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x34(%rbp),%xmm0
movss  -0x44(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm1
mov    0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x34(%rbp),%xmm0
movss  -0x48(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    0x48(%rbp),%rax
movss  (%rax),%xmm0
movss  -0x48(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    0x48(%rbp),%rax
movss  (%rax),%xmm0
movss  -0x48(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    0x48(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  -0x48(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    0x48(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  -0x48(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -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    0x50(%rbp),%rax
movss  (%rax),%xmm0
movss  -0x48(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
add    $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    0x50(%rbp),%rax
movss  (%rax),%xmm0
movss  -0x48(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
sub    $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    0x50(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  -0x48(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $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    0x50(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  -0x48(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x34(%rbp),%xmm2
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm3
mov    0x48(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm4
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm4
mulss  %xmm4,%xmm0
mulss  %xmm3,%xmm2
addss  %xmm0,%xmm2
mov    0x48(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm3
mov    -0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm3
mulss  %xmm3,%xmm0
addss  %xmm2,%xmm0
mov    0x50(%rbp),%rax
movss  (%rax),%xmm2
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm3
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm3
mulss  %xmm3,%xmm2
addss  %xmm0,%xmm2
mov    0x50(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm3
mov    -0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm3
mulss  %xmm3,%xmm0
addss  %xmm2,%xmm0
mov    0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    0x48(%rbp),%rax
movss  (%rax),%xmm0
movss  -0x44(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    0x48(%rbp),%rax
movss  (%rax),%xmm0
movss  -0x44(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    0x48(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    0x48(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    0x50(%rbp),%rax
movss  (%rax),%xmm0
movss  -0x44(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    0x50(%rbp),%rax
movss  (%rax),%xmm0
movss  -0x44(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    0x50(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%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    0x50(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x20(%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    0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x38(%rbp)
jmp    16c0 <acd_2d_4_d_b+0x5a0>
jmp    22ba <acd_2d_4_d_b+0x119a>
mov    -0x3c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x3c(%rbp)
jmp    16a2 <acd_2d_4_d_b+0x582>
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<acd_2d_4_d_b>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x108,%rsp
movss  %xmm0,0x4c(%rsp)
mov    %r9,%rbp
mov    %rcx,0x78(%rsp)
mov    %rdx,0x70(%rsp)
mov    %rsi,0x68(%rsp)
mov    %rdi,0x60(%rsp)
mov    0x170(%rsp),%r13
mov    0x168(%rsp),%r12
mov    0x148(%rsp),%rbx
mov    0x190(%rsp),%r14
mov    0x188(%rsp),%r15
xor    %edi,%edi
cmpl   $0x0,0x4(%r15)
sete   %dil
xor    %eax,%eax
call   1040 <pushcontrol1b@plt>
xor    %edi,%edi
cmpl   $0x0,0x4(%r14)
sete   %dil
xor    %eax,%eax
call   1040 <pushcontrol1b@plt>
xor    %edi,%edi
cmpl   $0x0,(%r15)
sete   %dil
xor    %eax,%eax
call   1040 <pushcontrol1b@plt>
cmpl   $0x0,(%r14)
je     1213 <acd_2d_4_d_b+0xf3>
movslq 0x4(%r13),%rax
movslq 0x4(%r12),%rcx
cmp    %ecx,%eax
jl     1213 <acd_2d_4_d_b+0xf3>
movslq 0x0(%r13),%rdx
add    $0x1,%rax
cs nopw 0x0(%rax,%rax,1)
mov    -0x8(%rbp,%rax,8),%rsi
movss  (%rsi,%rdx,4),%xmm0
subss  0x8(%rsi,%rdx,4),%xmm0
movss  %xmm0,(%rsi,%rdx,4)
movl   $0x0,0x8(%rsi,%rdx,4)
mov    -0x8(%rbx,%rax,8),%rsi
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     11d0 <acd_2d_4_d_b+0xb0>
lea    0x4(%rsp),%rdi
xor    %eax,%eax
call   1030 <popcontrol1b@plt>
cmpl   $0x0,0x4(%rsp)
jne    1283 <acd_2d_4_d_b+0x163>
movslq 0x4(%r13),%rax
movslq 0x4(%r12),%rcx
cmp    %ecx,%eax
jl     1283 <acd_2d_4_d_b+0x163>
movslq (%r12),%rdx
add    $0x1,%rax
nopl   0x0(%rax,%rax,1)
mov    -0x8(%rbp,%rax,8),%rsi
movss  (%rsi,%rdx,4),%xmm0
subss  -0x8(%rsi,%rdx,4),%xmm0
movss  %xmm0,(%rsi,%rdx,4)
movl   $0x0,-0x8(%rsi,%rdx,4)
mov    -0x8(%rbx,%rax,8),%rsi
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_4_d_b+0x120>
lea    0x4(%rsp),%rdi
xor    %eax,%eax
call   1030 <popcontrol1b@plt>
cmpl   $0x0,0x4(%rsp)
jne    134d <acd_2d_4_d_b+0x22d>
mov    0x170(%rsp),%rax
movslq (%rax),%rax
mov    0x168(%rsp),%rcx
movslq (%rcx),%r11
cmp    %r11d,%eax
jl     134d <acd_2d_4_d_b+0x22d>
mov    0x170(%rsp),%rcx
movslq 0x4(%rcx),%rcx
mov    0x0(%rbp,%rcx,8),%r14
mov    0x10(%rbp,%rcx,8),%r15
mov    0x148(%rsp),%rdx
mov    (%rdx,%rcx,8),%r12
mov    0x10(%rdx,%rcx,8),%r13
mov    %rax,%r10
sub    %r11,%r10
add    $0x1,%r10
cmp    $0x4,%r10
jae    1a6a <acd_2d_4_d_b+0x94a>
add    $0x1,%rax
nopl   0x0(%rax,%rax,1)
movss  -0x4(%r15,%rax,4),%xmm0
movl   $0x0,-0x4(%r15,%rax,4)
movss  -0x4(%r14,%rax,4),%xmm1
subss  %xmm0,%xmm1
movss  %xmm1,-0x4(%r14,%rax,4)
movss  -0x4(%r13,%rax,4),%xmm0
movl   $0x0,-0x4(%r13,%rax,4)
movss  -0x4(%r12,%rax,4),%xmm1
subss  %xmm0,%xmm1
movss  %xmm1,-0x4(%r12,%rax,4)
add    $0xffffffffffffffff,%rax
cmp    %r11,%rax
jg     1300 <acd_2d_4_d_b+0x1e0>
lea    0x4(%rsp),%rdi
xor    %eax,%eax
call   1030 <popcontrol1b@plt>
cmpl   $0x0,0x4(%rsp)
movss  0x4c(%rsp),%xmm5
jne    141d <acd_2d_4_d_b+0x2fd>
mov    0x170(%rsp),%rax
movslq (%rax),%rax
mov    0x168(%rsp),%rcx
movslq (%rcx),%r11
cmp    %r11d,%eax
jl     141d <acd_2d_4_d_b+0x2fd>
mov    0x168(%rsp),%rcx
movslq 0x4(%rcx),%rcx
mov    -0x10(%rbp,%rcx,8),%r14
mov    0x0(%rbp,%rcx,8),%r15
mov    0x148(%rsp),%rdx
mov    -0x10(%rdx,%rcx,8),%r12
mov    (%rdx,%rcx,8),%r13
mov    %rax,%r10
sub    %r11,%r10
add    $0x1,%r10
cmp    $0x4,%r10
jae    1c5e <acd_2d_4_d_b+0xb3e>
add    $0x1,%rax
nopl   0x0(%rax,%rax,1)
movss  -0x4(%r14,%rax,4),%xmm0
movl   $0x0,-0x4(%r14,%rax,4)
movss  -0x4(%r15,%rax,4),%xmm1
subss  %xmm0,%xmm1
movss  %xmm1,-0x4(%r15,%rax,4)
movss  -0x4(%r12,%rax,4),%xmm0
movl   $0x0,-0x4(%r12,%rax,4)
movss  -0x4(%r13,%rax,4),%xmm1
subss  %xmm0,%xmm1
movss  %xmm1,-0x4(%r13,%rax,4)
add    $0xffffffffffffffff,%rax
cmp    %r11,%rax
jg     13d0 <acd_2d_4_d_b+0x2b0>
mov    0x170(%rsp),%rcx
movslq 0x4(%rcx),%rdi
mov    0x168(%rsp),%rax
movslq 0x4(%rax),%rbx
cmp    %ebx,%edi
jge    144b <acd_2d_4_d_b+0x32b>
add    $0x108,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    0x180(%rsp),%r8
mov    0x178(%rsp),%r13
movslq (%rcx),%r11
movslq (%rax),%rax
mov    %rax,0x10(%rsp)
movaps 0xb93(%rip),%xmm0
mov    %rbp,0x8(%rsp)
mov    %rbx,0x58(%rsp)
mov    %r11,0x50(%rsp)
jmp    148c <acd_2d_4_d_b+0x36c>
xchg   %ax,%ax
lea    -0x1(%rdi),%rax
cmp    %rbx,%rdi
mov    %rax,%rdi
jle    1439 <acd_2d_4_d_b+0x319>
cmp    0x10(%rsp),%r11d
jl     1480 <acd_2d_4_d_b+0x360>
mov    0x150(%rsp),%rax
mov    (%rax,%rdi,8),%rax
mov    %rax,0x40(%rsp)
mov    0x0(%rbp,%rdi,8),%rax
mov    %rax,0x38(%rsp)
mov    0x68(%rsp),%rax
mov    (%rax,%rdi,8),%r9
mov    0x158(%rsp),%rcx
mov    (%rcx,%rdi,8),%rcx
mov    %rcx,0x28(%rsp)
mov    0x60(%rsp),%rcx
mov    (%rcx,%rdi,8),%r15
mov    0x8(%rcx,%rdi,8),%rbp
mov    %rbp,0x30(%rsp)
lea    -0x1(%rdi),%rbp
mov    %rbp,0x80(%rsp)
mov    -0x10(%rcx,%rdi,8),%rbp
mov    %rbp,0x20(%rsp)
mov    -0x8(%rcx,%rdi,8),%rbp
mov    %rbp,0x18(%rsp)
mov    0x10(%rcx,%rdi,8),%rcx
mov    %rcx,0x100(%rsp)
mov    0x8(%rax,%rdi,8),%rcx
mov    %rcx,0xf8(%rsp)
mov    -0x10(%rax,%rdi,8),%rcx
mov    %rcx,0xf0(%rsp)
mov    -0x8(%rax,%rdi,8),%rcx
mov    %rcx,0xe8(%rsp)
mov    0x10(%rax,%rdi,8),%rax
mov    %rax,0xe0(%rsp)
mov    0x160(%rsp),%rcx
mov    (%rcx,%rdi,8),%rax
mov    %rax,0xd8(%rsp)
mov    0x148(%rsp),%rcx
mov    (%rcx,%rdi,8),%rax
mov    %rax,0xd0(%rsp)
mov    %r11,%rdx
mov    0x78(%rsp),%r12
mov    (%r12,%rdi,8),%r14
mov    0x70(%rsp),%rcx
mov    (%rcx,%rdi,8),%r11
mov    0x8(%rcx,%rdi,8),%rax
mov    %rax,0xc8(%rsp)
mov    -0x10(%rcx,%rdi,8),%rax
mov    %rax,0xc0(%rsp)
mov    -0x8(%rcx,%rdi,8),%rax
mov    %rax,0xb8(%rsp)
mov    0x10(%rcx,%rdi,8),%rax
mov    %rax,0xb0(%rsp)
mov    0x8(%r12,%rdi,8),%rax
mov    %rax,0xa8(%rsp)
mov    -0x10(%r12,%rdi,8),%rax
mov    %rax,0xa0(%rsp)
mov    -0x8(%r12,%rdi,8),%rax
mov    %rax,0x98(%rsp)
mov    %rdi,0x88(%rsp)
mov    0x10(%r12,%rdi,8),%rax
mov    %rax,0x90(%rsp)
mov    %rdx,%r12
nopl   0x0(%rax)
mov    0x38(%rsp),%rcx
movss  (%rcx,%r12,4),%xmm2
mov    0x40(%rsp),%rdi
movss  (%rdi,%r12,4),%xmm1
mulss  %xmm2,%xmm1
movaps %xmm5,%xmm3
mulss  %xmm1,%xmm3
addss  (%r9,%r12,4),%xmm3
cvtss2sd %xmm3,%xmm3
cvtss2sd %xmm2,%xmm2
addsd  %xmm2,%xmm2
addsd  %xmm3,%xmm2
cvtsd2ss %xmm2,%xmm2
movss  %xmm2,(%r9,%r12,4)
movss  0x4(%r15,%r12,4),%xmm2
movss  0x8(%r15,%r12,4),%xmm3
addss  -0x4(%r15,%r12,4),%xmm2
mulss  0x0(%r13),%xmm2
movss  (%r15,%r12,4),%xmm4
mulss  %xmm5,%xmm4
addss  %xmm2,%xmm4
mov    0x30(%rsp),%r10
movss  (%r10,%r12,4),%xmm2
mov    0x18(%rsp),%rbx
addss  (%rbx,%r12,4),%xmm2
mulss  0x4(%r13),%xmm2
addss  -0x8(%r15,%r12,4),%xmm3
addss  %xmm4,%xmm2
mulss  (%r8),%xmm3
mov    0x100(%rsp),%rbx
movss  (%rbx,%r12,4),%xmm4
mov    0x20(%rsp),%rbx
addss  (%rbx,%r12,4),%xmm4
mulss  0x4(%r8),%xmm4
addss  %xmm2,%xmm3
addss  %xmm3,%xmm4
mulss  (%rcx,%r12,4),%xmm4
mov    0x28(%rsp),%r10
addss  (%r10,%r12,4),%xmm4
movss  %xmm4,(%r10,%r12,4)
movss  0x0(%r13),%xmm2
mulss  %xmm1,%xmm2
addss  0x4(%r9,%r12,4),%xmm2
movss  %xmm2,0x4(%r9,%r12,4)
movss  0x0(%r13),%xmm2
mulss  %xmm1,%xmm2
addss  -0x4(%r9,%r12,4),%xmm2
movss  %xmm2,-0x4(%r9,%r12,4)
movss  0x4(%r13),%xmm2
mulss  %xmm1,%xmm2
mov    0xf8(%rsp),%rbp
addss  0x0(%rbp,%r12,4),%xmm2
movss  %xmm2,0x0(%rbp,%r12,4)
movss  0x4(%r13),%xmm2
mulss  %xmm1,%xmm2
mov    0xe8(%rsp),%rdx
addss  (%rdx,%r12,4),%xmm2
movss  %xmm2,(%rdx,%r12,4)
movss  (%r8),%xmm2
mulss  %xmm1,%xmm2
addss  0x8(%r9,%r12,4),%xmm2
movss  %xmm2,0x8(%r9,%r12,4)
movss  (%r8),%xmm2
mulss  %xmm1,%xmm2
addss  -0x8(%r9,%r12,4),%xmm2
movss  %xmm2,-0x8(%r9,%r12,4)
movss  0x4(%r8),%xmm2
mulss  %xmm1,%xmm2
mov    0xe0(%rsp),%rsi
addss  (%rsi,%r12,4),%xmm2
movss  %xmm2,(%rsi,%r12,4)
mulss  0x4(%r8),%xmm1
mov    0xf0(%rsp),%rax
addss  (%rax,%r12,4),%xmm1
movss  %xmm1,(%rax,%r12,4)
movss  (%rcx,%r12,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,(%rcx,%r12,4)
mov    0xd0(%rsp),%rbx
movss  (%rbx,%r12,4),%xmm1
mov    0xd8(%rsp),%rcx
movss  (%rcx,%r12,4),%xmm2
mulss  %xmm1,%xmm2
xorps  %xmm3,%xmm3
cvtss2sd %xmm1,%xmm3
mulss  (%rdi,%r12,4),%xmm1
movaps %xmm5,%xmm4
mulss  %xmm1,%xmm4
addss  (%r14,%r12,4),%xmm4
cvtss2sd %xmm4,%xmm4
addsd  %xmm3,%xmm3
addsd  %xmm4,%xmm3
cvtsd2ss %xmm3,%xmm3
movss  %xmm3,(%r14,%r12,4)
movaps %xmm5,%xmm3
mulss  %xmm2,%xmm3
addss  (%r9,%r12,4),%xmm3
movss  %xmm3,(%r9,%r12,4)
movss  0x0(%r13),%xmm3
mulss  %xmm2,%xmm3
addss  0x4(%r9,%r12,4),%xmm3
movss  %xmm3,0x4(%r9,%r12,4)
movss  0x0(%r13),%xmm3
mulss  %xmm2,%xmm3
addss  -0x4(%r9,%r12,4),%xmm3
movss  %xmm3,-0x4(%r9,%r12,4)
movss  0x4(%r13),%xmm3
mulss  %xmm2,%xmm3
addss  0x0(%rbp,%r12,4),%xmm3
movss  %xmm3,0x0(%rbp,%r12,4)
movss  0x4(%r13),%xmm3
mulss  %xmm2,%xmm3
addss  (%rdx,%r12,4),%xmm3
movss  %xmm3,(%rdx,%r12,4)
movss  (%r8),%xmm3
mulss  %xmm2,%xmm3
addss  0x8(%r9,%r12,4),%xmm3
movss  %xmm3,0x8(%r9,%r12,4)
movss  (%r8),%xmm3
mulss  %xmm2,%xmm3
addss  -0x8(%r9,%r12,4),%xmm3
movss  %xmm3,-0x8(%r9,%r12,4)
movss  0x4(%r8),%xmm3
mulss  %xmm2,%xmm3
addss  (%rsi,%r12,4),%xmm3
movss  %xmm3,(%rsi,%r12,4)
mulss  0x4(%r8),%xmm2
addss  (%rax,%r12,4),%xmm2
movss  %xmm2,(%rax,%r12,4)
movss  0x4(%r11,%r12,4),%xmm2
movss  0x8(%r11,%r12,4),%xmm3
addss  -0x4(%r11,%r12,4),%xmm2
mulss  0x0(%r13),%xmm2
movss  (%r11,%r12,4),%xmm4
mulss  %xmm5,%xmm4
addss  %xmm2,%xmm4
mov    0xc8(%rsp),%rax
movss  (%rax,%r12,4),%xmm2
mov    0xb8(%rsp),%rax
addss  (%rax,%r12,4),%xmm2
mulss  0x4(%r13),%xmm2
addss  -0x8(%r11,%r12,4),%xmm3
addss  %xmm4,%xmm2
mulss  (%r8),%xmm3
mov    0xb0(%rsp),%rax
movss  (%rax,%r12,4),%xmm4
mov    0xc0(%rsp),%rax
addss  (%rax,%r12,4),%xmm4
mulss  0x4(%r8),%xmm4
addss  %xmm2,%xmm3
addss  %xmm3,%xmm4
mulss  (%rbx,%r12,4),%xmm4
addss  (%r10,%r12,4),%xmm4
movss  %xmm4,(%r10,%r12,4)
movss  0x0(%r13),%xmm2
mulss  %xmm1,%xmm2
addss  0x4(%r14,%r12,4),%xmm2
movss  %xmm2,0x4(%r14,%r12,4)
movss  0x0(%r13),%xmm2
mulss  %xmm1,%xmm2
addss  -0x4(%r14,%r12,4),%xmm2
movss  %xmm2,-0x4(%r14,%r12,4)
movss  0x4(%r13),%xmm2
mulss  %xmm1,%xmm2
mov    0xa8(%rsp),%rax
addss  (%rax,%r12,4),%xmm2
movss  %xmm2,(%rax,%r12,4)
movss  0x4(%r13),%xmm2
mulss  %xmm1,%xmm2
mov    0x98(%rsp),%rax
addss  (%rax,%r12,4),%xmm2
movss  %xmm2,(%rax,%r12,4)
movss  (%r8),%xmm2
mulss  %xmm1,%xmm2
addss  0x8(%r14,%r12,4),%xmm2
movss  %xmm2,0x8(%r14,%r12,4)
movss  (%r8),%xmm2
mulss  %xmm1,%xmm2
addss  -0x8(%r14,%r12,4),%xmm2
movss  %xmm2,-0x8(%r14,%r12,4)
movss  0x4(%r8),%xmm2
mulss  %xmm1,%xmm2
mov    0x90(%rsp),%rax
addss  (%rax,%r12,4),%xmm2
movss  %xmm2,(%rax,%r12,4)
mulss  0x4(%r8),%xmm1
mov    0xa0(%rsp),%rax
addss  (%rax,%r12,4),%xmm1
movss  %xmm1,(%rax,%r12,4)
movss  (%rbx,%r12,4),%xmm1
xorps  %xmm0,%xmm1
movss  %xmm1,(%rbx,%r12,4)
cmp    0x10(%rsp),%r12
lea    -0x1(%r12),%r12
jg     15f0 <acd_2d_4_d_b+0x4d0>
mov    0x8(%rsp),%rbp
mov    0x88(%rsp),%rdi
mov    0x58(%rsp),%rbx
mov    0x50(%rsp),%r11
mov    0x80(%rsp),%rax
jmp    1484 <acd_2d_4_d_b+0x364>
mov    %rbp,0x8(%rsp)
lea    (%r15,%r11,4),%rdx
lea    (%r15,%rax,4),%rsi
add    $0x4,%rsi
lea    (%r14,%r11,4),%rdi
lea    0x4(%r14,%rax,4),%rbp
lea    0x0(%r13,%r11,4),%r9
lea    0x4(,%rax,4),%r8
add    %r13,%r8
lea    (%r12,%r11,4),%rbx
lea    (%r12,%rax,4),%rcx
add    $0x4,%rcx
cmp    %rbp,%rdx
setb   0x10(%rsp)
cmp    %rsi,%rdi
setb   0x40(%rsp)
cmp    %r8,%rdx
setb   0x38(%rsp)
cmp    %rsi,%r9
setb   0x30(%rsp)
cmp    %rcx,%rdx
setb   0x20(%rsp)
cmp    %rsi,%rbx
setb   0x28(%rsp)
cmp    %r8,%rdi
setb   %sil
cmp    %rbp,%r9
setb   0x18(%rsp)
cmp    %rcx,%rdi
setb   %dil
cmp    %rbp,%rbx
setb   %dl
cmp    %rcx,%r9
setb   %r9b
cmp    %r8,%rbx
setb   %r8b
mov    0x40(%rsp),%cl
test   %cl,0x10(%rsp)
jne    1e69 <acd_2d_4_d_b+0xd49>
mov    0x30(%rsp),%cl
and    %cl,0x38(%rsp)
mov    0x8(%rsp),%rbp
jne    12f4 <acd_2d_4_d_b+0x1d4>
mov    0x20(%rsp),%cl
and    0x28(%rsp),%cl
jne    12f4 <acd_2d_4_d_b+0x1d4>
and    0x18(%rsp),%sil
jne    12f4 <acd_2d_4_d_b+0x1d4>
mov    %edx,%ebx
and    %dl,%dil
jne    12f4 <acd_2d_4_d_b+0x1d4>
and    %r8b,%r9b
jne    12f4 <acd_2d_4_d_b+0x1d4>
mov    %r10,%r8
and    $0xfffffffffffffffc,%r8
lea    -0x4(%r8),%rcx
mov    %rcx,%r9
shr    $0x2,%r9
add    $0x1,%r9
test   %rcx,%rcx
je     1e4e <acd_2d_4_d_b+0xd2e>
mov    %r9,%rcx
and    $0xfffffffffffffffe,%rcx
lea    (%r12,%rax,4),%rdx
add    $0xfffffffffffffff4,%rdx
lea    -0xc(,%rax,4),%rsi
ff
add    %r13,%rsi
lea    (%r14,%rax,4),%rdi
add    $0xfffffffffffffff4,%rdi
lea    (%r15,%rax,4),%rbp
add    $0xfffffffffffffff4,%rbp
xor    %ebx,%ebx
xorps  %xmm0,%xmm0
cs nopw 0x0(%rax,%rax,1)
movups 0x0(%rbp,%rbx,4),%xmm1
movups %xmm0,0x0(%rbp,%rbx,4)
movups (%rdi,%rbx,4),%xmm2
subps  %xmm1,%xmm2
movups %xmm2,(%rdi,%rbx,4)
movups (%rsi,%rbx,4),%xmm1
movups %xmm0,(%rsi,%rbx,4)
movups (%rdx,%rbx,4),%xmm2
subps  %xmm1,%xmm2
movups %xmm2,(%rdx,%rbx,4)
movups -0x10(%rbp,%rbx,4),%xmm1
movups %xmm0,-0x10(%rbp,%rbx,4)
movups -0x10(%rdi,%rbx,4),%xmm2
subps  %xmm1,%xmm2
movups %xmm2,-0x10(%rdi,%rbx,4)
movups -0x10(%rsi,%rbx,4),%xmm1
movups %xmm0,-0x10(%rsi,%rbx,4)
movups -0x10(%rdx,%rbx,4),%xmm2
subps  %xmm1,%xmm2
movups %xmm2,-0x10(%rdx,%rbx,4)
add    $0xfffffffffffffff8,%rbx
add    $0xfffffffffffffffe,%rcx
jne    1ba0 <acd_2d_4_d_b+0xa80>
neg    %rbx
mov    0x8(%rsp),%rbp
test   $0x1,%r9b
je     1c4d <acd_2d_4_d_b+0xb2d>
mov    %rax,%rcx
sub    %rbx,%rcx
movups -0xc(%r15,%rcx,4),%xmm0
xorps  %xmm1,%xmm1
movups %xmm1,-0xc(%r15,%rcx,4)
movups -0xc(%r14,%rcx,4),%xmm2
subps  %xmm0,%xmm2
movups %xmm2,-0xc(%r14,%rcx,4)
movups -0xc(%r13,%rcx,4),%xmm0
movups %xmm1,-0xc(%r13,%rcx,4)
movups -0xc(%r12,%rcx,4),%xmm1
subps  %xmm0,%xmm1
movups %xmm1,-0xc(%r12,%rcx,4)
cmp    %r8,%r10
je     134d <acd_2d_4_d_b+0x22d>
sub    %r8,%rax
jmp    12f4 <acd_2d_4_d_b+0x1d4>
mov    %rbp,0x8(%rsp)
lea    (%r14,%r11,4),%rdx
lea    (%r14,%rax,4),%rsi
add    $0x4,%rsi
lea    (%r15,%r11,4),%rdi
lea    0x4(%r15,%rax,4),%rbp
lea    (%r12,%r11,4),%r9
lea    (%r12,%rax,4),%r8
add    $0x4,%r8
lea    0x0(,%r11,4),%rbx
add    %r13,%rbx
lea    0x4(,%rax,4),%rcx
add    %r13,%rcx
cmp    %rbp,%rdx
setb   0x10(%rsp)
cmp    %rsi,%rdi
setb   0x40(%rsp)
cmp    %r8,%rdx
setb   0x38(%rsp)
cmp    %rsi,%r9
setb   0x30(%rsp)
cmp    %rcx,%rdx
setb   0x20(%rsp)
cmp    %rsi,%rbx
setb   0x28(%rsp)
cmp    %r8,%rdi
setb   %sil
cmp    %rbp,%r9
setb   0x18(%rsp)
cmp    %rcx,%rdi
setb   %dil
cmp    %rbp,%rbx
setb   %dl
cmp    %rcx,%r9
setb   %r9b
cmp    %r8,%rbx
setb   %r8b
mov    0x40(%rsp),%cl
test   %cl,0x10(%rsp)
jne    1e73 <acd_2d_4_d_b+0xd53>
mov    0x30(%rsp),%cl
and    %cl,0x38(%rsp)
mov    0x8(%rsp),%rbp
jne    13c4 <acd_2d_4_d_b+0x2a4>
mov    0x20(%rsp),%cl
and    0x28(%rsp),%cl
jne    13c4 <acd_2d_4_d_b+0x2a4>
and    0x18(%rsp),%sil
jne    13c4 <acd_2d_4_d_b+0x2a4>
mov    %edx,%ebx
and    %dl,%dil
jne    13c4 <acd_2d_4_d_b+0x2a4>
and    %r8b,%r9b
jne    13c4 <acd_2d_4_d_b+0x2a4>
mov    %r10,%r8
and    $0xfffffffffffffffc,%r8
lea    -0x4(%r8),%rcx
mov    %rcx,%r9
shr    $0x2,%r9
add    $0x1,%r9
test   %rcx,%rcx
je     1e5f <acd_2d_4_d_b+0xd3f>
mov    %r9,%rcx
and    $0xfffffffffffffffe,%rcx
lea    -0xc(,%rax,4),%rdx
ff
add    %r13,%rdx
lea    (%r12,%rax,4),%rsi
add    $0xfffffffffffffff4,%rsi
lea    (%r15,%rax,4),%rdi
add    $0xfffffffffffffff4,%rdi
lea    (%r14,%rax,4),%rbp
add    $0xfffffffffffffff4,%rbp
xor    %ebx,%ebx
xorps  %xmm0,%xmm0
movups 0x0(%rbp,%rbx,4),%xmm1
movups %xmm0,0x0(%rbp,%rbx,4)
movups (%rdi,%rbx,4),%xmm2
subps  %xmm1,%xmm2
movups %xmm2,(%rdi,%rbx,4)
movups (%rsi,%rbx,4),%xmm1
movups %xmm0,(%rsi,%rbx,4)
movups (%rdx,%rbx,4),%xmm2
subps  %xmm1,%xmm2
movups %xmm2,(%rdx,%rbx,4)
movups -0x10(%rbp,%rbx,4),%xmm1
movups %xmm0,-0x10(%rbp,%rbx,4)
movups -0x10(%rdi,%rbx,4),%xmm2
subps  %xmm1,%xmm2
movups %xmm2,-0x10(%rdi,%rbx,4)
movups -0x10(%rsi,%rbx,4),%xmm1
movups %xmm0,-0x10(%rsi,%rbx,4)
movups -0x10(%rdx,%rbx,4),%xmm2
subps  %xmm1,%xmm2
movups %xmm2,-0x10(%rdx,%rbx,4)
add    $0xfffffffffffffff8,%rbx
add    $0xfffffffffffffffe,%rcx
jne    1d90 <acd_2d_4_d_b+0xc70>
neg    %rbx
mov    0x8(%rsp),%rbp
test   $0x1,%r9b
je     1e3d <acd_2d_4_d_b+0xd1d>
mov    %rax,%rcx
sub    %rbx,%rcx
movups -0xc(%r14,%rcx,4),%xmm0
xorps  %xmm1,%xmm1
movups %xmm1,-0xc(%r14,%rcx,4)
movups -0xc(%r15,%rcx,4),%xmm2
subps  %xmm0,%xmm2
movups %xmm2,-0xc(%r15,%rcx,4)
movups -0xc(%r12,%rcx,4),%xmm0
movups %xmm1,-0xc(%r12,%rcx,4)
movups -0xc(%r13,%rcx,4),%xmm1
subps  %xmm0,%xmm1
movups %xmm1,-0xc(%r13,%rcx,4)
cmp    %r8,%r10
je     141d <acd_2d_4_d_b+0x2fd>
sub    %r8,%rax
jmp    13c4 <acd_2d_4_d_b+0x2a4>
xor    %ebx,%ebx
test   $0x1,%r9b
jne    1c0e <acd_2d_4_d_b+0xaee>
jmp    1c4d <acd_2d_4_d_b+0xb2d>
xor    %ebx,%ebx
test   $0x1,%r9b
jne    1dfe <acd_2d_4_d_b+0xcde>
jmp    1e3d <acd_2d_4_d_b+0xd1d>
mov    0x8(%rsp),%rbp
jmp    12f4 <acd_2d_4_d_b+0x1d4>
mov    0x8(%rsp),%rbp
jmp    13c4 <acd_2d_4_d_b+0x2a4>

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

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