void cgdcjpost2l(float part[], float fxy[], float bxy[], float cu[],
                 float dcu[], float amu[], float qm, float qbm, float dt,
                 int idimp, int nop, int nxv, int nyv) {
  int j, nn, mm, np, mp, nnn, mmm, nnp, mmp, nxv3, nxv4;
  float qtmh, dti, dxp, dyp, amx, amy, dx, dy, dz, ox, oy, oz;
  float acx, acy, acz, omxt, omyt, omzt, omt, anorm;
  float rot1, rot2, rot3, rot4, rot5, rot6, rot7, rot8, rot9;
  float vx, vy, vz, v1, v2, v3, v4;
  nxv3 = 3 * nxv;
  nxv4 = 4 * nxv;
  qtmh = 0.5 * qbm * dt;
  dti = 1.0 / dt;
  for (j = 0; j < nop; j++) {
    nnn = part[idimp * j];
    mmm = part[1 + idimp * j];
    dxp = part[idimp * j] - (float)nnn;
    dyp = part[1 + idimp * j] - (float)mmm;
    nn = 3 * nnn;
    mm = nxv3 * mmm;
    amx = 1.0 - dxp;
    mp = mm + nxv3;
    amy = 1.0 - dyp;
    np = nn + 3;
    nnn = 4 * nnn;
    mmm = nxv4 * mmm;
    mmp = mmm + nxv4;
    nnp = nnn + 4;
    dx = dyp * (dxp * fxy[np + mp] + amx * fxy[nn + mp]) +
         amy * (dxp * fxy[np + mm] + amx * fxy[nn + mm]);
    dy = dyp * (dxp * fxy[1 + np + mp] + amx * fxy[1 + nn + mp]) +
         amy * (dxp * fxy[1 + np + mm] + amx * fxy[1 + nn + mm]);
    dz = dyp * (dxp * fxy[2 + np + mp] + amx * fxy[2 + nn + mp]) +
         amy * (dxp * fxy[2 + np + mm] + amx * fxy[2 + nn + mm]);
    ox = dyp * (dxp * bxy[np + mp] + amx * bxy[nn + mp]) +
         amy * (dxp * bxy[np + mm] + amx * bxy[nn + mm]);
    oy = dyp * (dxp * bxy[1 + np + mp] + amx * bxy[1 + nn + mp]) +
         amy * (dxp * bxy[1 + np + mm] + amx * bxy[1 + nn + mm]);
    oz = dyp * (dxp * bxy[2 + np + mp] + amx * bxy[2 + nn + mp]) +
         amy * (dxp * bxy[2 + np + mm] + amx * bxy[2 + nn + mm]);
    dx *= qtmh;
    dy *= qtmh;
    dz *= qtmh;
    vx = part[2 + idimp * j];
    vy = part[3 + idimp * j];
    vz = part[4 + idimp * j];
    acx = vx + dx;
    acy = vy + dy;
    acz = vz + dz;
    omxt = qtmh * ox;
    omyt = qtmh * oy;
    omzt = qtmh * oz;
    omt = omxt * omxt + omyt * omyt + omzt * omzt;
    anorm = 2.0 / (1.0 + omt);
    omt = 0.5 * (1.0 - omt);
    rot4 = omxt * omyt;
    rot7 = omxt * omzt;
    rot8 = omyt * omzt;
    rot1 = omt + omxt * omxt;
    rot5 = omt + omyt * omyt;
    rot9 = omt + omzt * omzt;
    rot2 = omzt + rot4;
    rot4 -= omzt;
    rot3 = -omyt + rot7;
    rot7 += omyt;
    rot6 = omxt + rot8;
    rot8 -= omxt;
    dx += (rot1 * acx + rot2 * acy + rot3 * acz) * anorm;
    dy += (rot4 * acx + rot5 * acy + rot6 * acz) * anorm;
    dz += (rot7 * acx + rot8 * acy + rot9 * acz) * anorm;
    amx = qm * amx;
    dxp = qm * dxp;
    ox = 0.5 * (dx + vx);
    oy = 0.5 * (dy + vy);
    oz = 0.5 * (dz + vz);
    vx = dti * (dx - vx);
    vy = dti * (dy - vy);
    vz = dti * (dz - vz);
    dx = dxp * dyp;
    dy = amx * dyp;
    v1 = ox * ox - oy * oy;
    v2 = ox * oy;
    v3 = oz * ox;
    v4 = oz * oy;
    amu[nnp + mmp] += v1 * dx;
    amu[1 + nnp + mmp] += v2 * dx;
    amu[2 + nnp + mmp] += v3 * dx;
    amu[3 + nnp + mmp] += v4 * dx;
    dcu[np + mp] += vx * dx;
    dcu[1 + np + mp] += vy * dx;
    dcu[2 + np + mp] += vz * dx;
    cu[np + mp] += ox * dx;
    cu[1 + np + mp] += oy * dx;
    cu[2 + np + mp] += oz * dx;
    dx = dxp * amy;
    amu[nnn + mmp] += v1 * dy;
    amu[1 + nnn + mmp] += v2 * dy;
    amu[2 + nnn + mmp] += v3 * dy;
    amu[3 + nnn + mmp] += v4 * dy;
    dcu[nn + mp] += vx * dy;
    dcu[1 + nn + mp] += vy * dy;
    dcu[2 + nn + mp] += vz * dy;
    cu[nn + mp] += ox * dy;
    cu[1 + nn + mp] += oy * dy;
    cu[2 + nn + mp] += oz * dy;
    dy = amx * amy;
    amu[nnp + mmm] += v1 * dx;
    amu[1 + nnp + mmm] += v2 * dx;
    amu[2 + nnp + mmm] += v3 * dx;
    amu[3 + nnp + mmm] += v4 * dx;
    dcu[np + mm] += vx * dx;
    dcu[1 + np + mm] += vy * dx;
    dcu[2 + np + mm] += vz * dx;
    cu[np + mm] += ox * dx;
    cu[1 + np + mm] += oy * dx;
    cu[2 + np + mm] += oz * dx;
    amu[nnn + mmm] += v1 * dy;
    amu[1 + nnn + mmm] += v2 * dy;
    amu[2 + nnn + mmm] += v3 * dy;
    amu[3 + nnn + mmm] += v4 * dy;
    dcu[nn + mm] += vx * dy;
    dcu[1 + nn + mm] += vy * dy;
    dcu[2 + nn + mm] += vz * dy;
    cu[nn + mm] += ox * dy;
    cu[1 + nn + mm] += oy * dy;
    cu[2 + nn + mm] += oz * dy;
  }
  return;
}


x86 assembly (clang, -O0):
<cgdcjpost2l>:
push   %rbp
mov    %rsp,%rbp
sub    $0x78,%rsp
mov    0x28(%rbp),%eax
mov    0x20(%rbp),%eax
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%eax
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)
movss  %xmm1,-0x38(%rbp)
movss  %xmm2,-0x3c(%rbp)
imul   $0x3,0x20(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    0x20(%rbp),%eax
shl    $0x2,%eax
mov    %eax,-0x68(%rbp)
movss  -0x38(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x1eac(%rip),%xmm0
mulsd  %xmm1,%xmm0
movss  -0x3c(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x6c(%rbp)
movss  -0x3c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x1e79(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x70(%rbp)
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    23e4 <cgdcjpost2l+0x12e4>
mov    -0x8(%rbp),%rax
mov    0x10(%rbp),%ecx
imul   -0x40(%rbp),%ecx
movslq %ecx,%rcx
cvttss2si (%rax,%rcx,4),%eax
mov    %eax,-0x54(%rbp)
mov    -0x8(%rbp),%rax
mov    0x10(%rbp),%ecx
imul   -0x40(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
cvttss2si (%rax,%rcx,4),%eax
mov    %eax,-0x58(%rbp)
mov    -0x8(%rbp),%rax
mov    0x10(%rbp),%ecx
imul   -0x40(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtsi2ssl -0x54(%rbp),%xmm1
subss  %xmm1,%xmm0
movss  %xmm0,-0x74(%rbp)
mov    -0x8(%rbp),%rax
mov    0x10(%rbp),%ecx
imul   -0x40(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtsi2ssl -0x58(%rbp),%xmm1
subss  %xmm1,%xmm0
movss  %xmm0,-0x78(%rbp)
imul   $0x3,-0x54(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x64(%rbp),%eax
imul   -0x58(%rbp),%eax
mov    %eax,-0x48(%rbp)
movss  -0x74(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x1dc3(%rip),%xmm0
subsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x7c(%rbp)
mov    -0x48(%rbp),%eax
add    -0x64(%rbp),%eax
mov    %eax,-0x50(%rbp)
movss  -0x78(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x1d9c(%rip),%xmm0
subsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x80(%rbp)
mov    -0x44(%rbp),%eax
add    $0x3,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x54(%rbp),%eax
shl    $0x2,%eax
mov    %eax,-0x54(%rbp)
mov    -0x68(%rbp),%eax
imul   -0x58(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x58(%rbp),%eax
add    -0x68(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x54(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x5c(%rbp)
movss  -0x78(%rbp),%xmm0
movss  -0x74(%rbp),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm3
movss  -0x7c(%rbp),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm1
mulss  %xmm3,%xmm2
addss  %xmm1,%xmm2
movss  -0x80(%rbp),%xmm1
movss  -0x74(%rbp),%xmm3
mov    -0x10(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm5
movss  -0x7c(%rbp),%xmm4
mov    -0x10(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm4
mulss  %xmm5,%xmm3
addss  %xmm4,%xmm3
mulss  %xmm3,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x78(%rbp),%xmm0
movss  -0x74(%rbp),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm3
movss  -0x7c(%rbp),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x1,%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm1
mulss  %xmm3,%xmm2
addss  %xmm1,%xmm2
movss  -0x80(%rbp),%xmm1
movss  -0x74(%rbp),%xmm3
mov    -0x10(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm5
movss  -0x7c(%rbp),%xmm4
mov    -0x10(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x1,%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm4
mulss  %xmm5,%xmm3
addss  %xmm4,%xmm3
mulss  %xmm3,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x88(%rbp)
ff
movss  -0x78(%rbp),%xmm0
movss  -0x74(%rbp),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x2,%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm3
movss  -0x7c(%rbp),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x2,%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm1
mulss  %xmm3,%xmm2
addss  %xmm1,%xmm2
movss  -0x80(%rbp),%xmm1
movss  -0x74(%rbp),%xmm3
mov    -0x10(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x2,%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm5
movss  -0x7c(%rbp),%xmm4
mov    -0x10(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x2,%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm4
mulss  %xmm5,%xmm3
addss  %xmm4,%xmm3
mulss  %xmm3,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
movss  -0x78(%rbp),%xmm0
movss  -0x74(%rbp),%xmm2
mov    -0x18(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm3
movss  -0x7c(%rbp),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm1
mulss  %xmm3,%xmm2
addss  %xmm1,%xmm2
movss  -0x80(%rbp),%xmm1
movss  -0x74(%rbp),%xmm3
mov    -0x18(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm5
movss  -0x7c(%rbp),%xmm4
mov    -0x18(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm4
mulss  %xmm5,%xmm3
addss  %xmm4,%xmm3
mulss  %xmm3,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x90(%rbp)
ff
movss  -0x78(%rbp),%xmm0
movss  -0x74(%rbp),%xmm2
mov    -0x18(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm3
movss  -0x7c(%rbp),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x1,%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm1
mulss  %xmm3,%xmm2
addss  %xmm1,%xmm2
movss  -0x80(%rbp),%xmm1
movss  -0x74(%rbp),%xmm3
mov    -0x18(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm5
movss  -0x7c(%rbp),%xmm4
mov    -0x18(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x1,%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm4
mulss  %xmm5,%xmm3
addss  %xmm4,%xmm3
mulss  %xmm3,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x94(%rbp)
ff
movss  -0x78(%rbp),%xmm0
movss  -0x74(%rbp),%xmm2
mov    -0x18(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x2,%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm3
movss  -0x7c(%rbp),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x2,%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm1
mulss  %xmm3,%xmm2
addss  %xmm1,%xmm2
movss  -0x80(%rbp),%xmm1
movss  -0x74(%rbp),%xmm3
mov    -0x18(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x2,%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm5
movss  -0x7c(%rbp),%xmm4
mov    -0x18(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x2,%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm4
mulss  %xmm5,%xmm3
addss  %xmm4,%xmm3
mulss  %xmm3,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x98(%rbp)
ff
movss  -0x6c(%rbp),%xmm0
mulss  -0x84(%rbp),%xmm0
ff
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x6c(%rbp),%xmm0
mulss  -0x88(%rbp),%xmm0
ff
movss  %xmm0,-0x88(%rbp)
ff
movss  -0x6c(%rbp),%xmm0
mulss  -0x8c(%rbp),%xmm0
ff
movss  %xmm0,-0x8c(%rbp)
ff
mov    -0x8(%rbp),%rax
mov    0x10(%rbp),%ecx
imul   -0x40(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0xe0(%rbp)
ff
mov    -0x8(%rbp),%rax
mov    0x10(%rbp),%ecx
imul   -0x40(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0xe4(%rbp)
ff
mov    -0x8(%rbp),%rax
mov    0x10(%rbp),%ecx
imul   -0x40(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0xe8(%rbp)
ff
movss  -0xe0(%rbp),%xmm0
ff
addss  -0x84(%rbp),%xmm0
ff
movss  %xmm0,-0x9c(%rbp)
ff
movss  -0xe4(%rbp),%xmm0
ff
addss  -0x88(%rbp),%xmm0
ff
movss  %xmm0,-0xa0(%rbp)
ff
movss  -0xe8(%rbp),%xmm0
ff
addss  -0x8c(%rbp),%xmm0
ff
movss  %xmm0,-0xa4(%rbp)
ff
movss  -0x6c(%rbp),%xmm0
mulss  -0x90(%rbp),%xmm0
ff
movss  %xmm0,-0xa8(%rbp)
movss  -0x6c(%rbp),%xmm0
mulss  -0x94(%rbp),%xmm0
ff
movss  %xmm0,-0xac(%rbp)
ff
movss  -0x6c(%rbp),%xmm0
mulss  -0x98(%rbp),%xmm0
ff
movss  %xmm0,-0xb0(%rbp)
ff
movss  -0xa8(%rbp),%xmm1
ff
movss  -0xa8(%rbp),%xmm2
ff
movss  -0xac(%rbp),%xmm0
ff
mulss  -0xac(%rbp),%xmm0
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0xb0(%rbp),%xmm0
ff
movss  -0xb0(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xb4(%rbp)
ff
movss  -0xb4(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movsd  0x1879(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0x187d(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0xb8(%rbp)
ff
movss  -0xb4(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movsd  0x1849(%rip),%xmm1
subsd  %xmm0,%xmm1
movsd  0x1845(%rip),%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0xb4(%rbp)
ff
movss  -0xa8(%rbp),%xmm0
ff
mulss  -0xac(%rbp),%xmm0
ff
movss  %xmm0,-0xc8(%rbp)
ff
movss  -0xa8(%rbp),%xmm0
ff
mulss  -0xb0(%rbp),%xmm0
ff
movss  %xmm0,-0xd4(%rbp)
ff
movss  -0xac(%rbp),%xmm0
ff
mulss  -0xb0(%rbp),%xmm0
ff
movss  %xmm0,-0xd8(%rbp)
ff
movss  -0xb4(%rbp),%xmm1
ff
movss  -0xa8(%rbp),%xmm0
ff
movss  -0xa8(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xbc(%rbp)
ff
movss  -0xb4(%rbp),%xmm1
ff
movss  -0xac(%rbp),%xmm0
ff
movss  -0xac(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xcc(%rbp)
ff
movss  -0xb4(%rbp),%xmm1
ff
movss  -0xb0(%rbp),%xmm0
ff
movss  -0xb0(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xdc(%rbp)
ff
movss  -0xb0(%rbp),%xmm0
ff
addss  -0xc8(%rbp),%xmm0
ff
movss  %xmm0,-0xc0(%rbp)
ff
movss  -0xb0(%rbp),%xmm1
ff
movss  -0xc8(%rbp),%xmm0
ff
subss  %xmm1,%xmm0
movss  %xmm0,-0xc8(%rbp)
ff
movss  -0xac(%rbp),%xmm0
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
addss  -0xd4(%rbp),%xmm0
ff
movss  %xmm0,-0xc4(%rbp)
ff
movss  -0xac(%rbp),%xmm0
ff
addss  -0xd4(%rbp),%xmm0
ff
movss  %xmm0,-0xd4(%rbp)
ff
movss  -0xa8(%rbp),%xmm0
ff
addss  -0xd8(%rbp),%xmm0
ff
movss  %xmm0,-0xd0(%rbp)
ff
movss  -0xa8(%rbp),%xmm1
ff
movss  -0xd8(%rbp),%xmm0
ff
subss  %xmm1,%xmm0
movss  %xmm0,-0xd8(%rbp)
ff
movss  -0xbc(%rbp),%xmm1
ff
movss  -0x9c(%rbp),%xmm2
ff
movss  -0xc0(%rbp),%xmm0
ff
mulss  -0xa0(%rbp),%xmm0
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0xc4(%rbp),%xmm0
ff
movss  -0xa4(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0xb8(%rbp),%xmm2
ff
movss  -0x84(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x84(%rbp)
ff
movss  -0xc8(%rbp),%xmm1
ff
movss  -0x9c(%rbp),%xmm2
ff
movss  -0xcc(%rbp),%xmm0
ff
mulss  -0xa0(%rbp),%xmm0
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0xd0(%rbp),%xmm0
ff
movss  -0xa4(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0xb8(%rbp),%xmm2
ff
movss  -0x88(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x88(%rbp)
ff
movss  -0xd4(%rbp),%xmm1
ff
movss  -0x9c(%rbp),%xmm2
ff
movss  -0xd8(%rbp),%xmm0
ff
mulss  -0xa0(%rbp),%xmm0
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0xdc(%rbp),%xmm0
ff
movss  -0xa4(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0xb8(%rbp),%xmm2
ff
movss  -0x8c(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
movss  -0x34(%rbp),%xmm0
mulss  -0x7c(%rbp),%xmm0
movss  %xmm0,-0x7c(%rbp)
movss  -0x34(%rbp),%xmm0
mulss  -0x74(%rbp),%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x84(%rbp),%xmm0
ff
addss  -0xe0(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm1
movsd  0x1576(%rip),%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x90(%rbp)
ff
movss  -0x88(%rbp),%xmm0
ff
addss  -0xe4(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm1
movsd  0x154a(%rip),%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x94(%rbp)
ff
movss  -0x8c(%rbp),%xmm0
ff
addss  -0xe8(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm1
movsd  0x151e(%rip),%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x98(%rbp)
ff
movss  -0x70(%rbp),%xmm0
movss  -0x84(%rbp),%xmm1
ff
subss  -0xe0(%rbp),%xmm1
ff
mulss  %xmm1,%xmm0
movss  %xmm0,-0xe0(%rbp)
ff
movss  -0x70(%rbp),%xmm0
movss  -0x88(%rbp),%xmm1
ff
subss  -0xe4(%rbp),%xmm1
ff
mulss  %xmm1,%xmm0
movss  %xmm0,-0xe4(%rbp)
ff
movss  -0x70(%rbp),%xmm0
movss  -0x8c(%rbp),%xmm1
ff
subss  -0xe8(%rbp),%xmm1
ff
mulss  %xmm1,%xmm0
movss  %xmm0,-0xe8(%rbp)
ff
movss  -0x74(%rbp),%xmm0
mulss  -0x78(%rbp),%xmm0
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x7c(%rbp),%xmm0
mulss  -0x78(%rbp),%xmm0
movss  %xmm0,-0x88(%rbp)
ff
movss  -0x90(%rbp),%xmm0
ff
movss  -0x90(%rbp),%xmm2
ff
movss  -0x94(%rbp),%xmm1
ff
mulss  -0x94(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xec(%rbp)
ff
movss  -0x90(%rbp),%xmm0
ff
mulss  -0x94(%rbp),%xmm0
ff
movss  %xmm0,-0xf0(%rbp)
ff
movss  -0x98(%rbp),%xmm0
ff
mulss  -0x90(%rbp),%xmm0
ff
movss  %xmm0,-0xf4(%rbp)
ff
movss  -0x98(%rbp),%xmm0
ff
mulss  -0x94(%rbp),%xmm0
ff
movss  %xmm0,-0xf8(%rbp)
ff
movss  -0xec(%rbp),%xmm0
ff
movss  -0x84(%rbp),%xmm2
ff
mov    -0x30(%rbp),%rax
mov    -0x5c(%rbp),%ecx
add    -0x60(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0xf0(%rbp),%xmm0
ff
movss  -0x84(%rbp),%xmm2
ff
mov    -0x30(%rbp),%rax
mov    -0x5c(%rbp),%ecx
add    $0x1,%ecx
add    -0x60(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0xf4(%rbp),%xmm0
ff
movss  -0x84(%rbp),%xmm2
ff
mov    -0x30(%rbp),%rax
mov    -0x5c(%rbp),%ecx
add    $0x2,%ecx
add    -0x60(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0xf8(%rbp),%xmm0
ff
movss  -0x84(%rbp),%xmm2
ff
mov    -0x30(%rbp),%rax
mov    -0x5c(%rbp),%ecx
add    $0x3,%ecx
add    -0x60(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0xe0(%rbp),%xmm0
ff
movss  -0x84(%rbp),%xmm2
ff
mov    -0x28(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0xe4(%rbp),%xmm0
ff
movss  -0x84(%rbp),%xmm2
ff
mov    -0x28(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0xe8(%rbp),%xmm0
ff
movss  -0x84(%rbp),%xmm2
ff
mov    -0x28(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x2,%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0x90(%rbp),%xmm0
ff
movss  -0x84(%rbp),%xmm2
ff
mov    -0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0x94(%rbp),%xmm0
ff
movss  -0x84(%rbp),%xmm2
ff
mov    -0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0x98(%rbp),%xmm0
ff
movss  -0x84(%rbp),%xmm2
ff
mov    -0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x2,%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0x74(%rbp),%xmm0
mulss  -0x80(%rbp),%xmm0
movss  %xmm0,-0x84(%rbp)
ff
movss  -0xec(%rbp),%xmm0
ff
movss  -0x88(%rbp),%xmm2
ff
mov    -0x30(%rbp),%rax
mov    -0x54(%rbp),%ecx
add    -0x60(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0xf0(%rbp),%xmm0
ff
movss  -0x88(%rbp),%xmm2
ff
mov    -0x30(%rbp),%rax
mov    -0x54(%rbp),%ecx
add    $0x1,%ecx
add    -0x60(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0xf4(%rbp),%xmm0
ff
movss  -0x88(%rbp),%xmm2
ff
mov    -0x30(%rbp),%rax
mov    -0x54(%rbp),%ecx
add    $0x2,%ecx
add    -0x60(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0xf8(%rbp),%xmm0
ff
movss  -0x88(%rbp),%xmm2
ff
mov    -0x30(%rbp),%rax
mov    -0x54(%rbp),%ecx
add    $0x3,%ecx
add    -0x60(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0xe0(%rbp),%xmm0
ff
movss  -0x88(%rbp),%xmm2
ff
mov    -0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0xe4(%rbp),%xmm0
ff
movss  -0x88(%rbp),%xmm2
ff
mov    -0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x1,%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0xe8(%rbp),%xmm0
ff
movss  -0x88(%rbp),%xmm2
ff
mov    -0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x2,%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0x90(%rbp),%xmm0
ff
movss  -0x88(%rbp),%xmm2
ff
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0x94(%rbp),%xmm0
ff
movss  -0x88(%rbp),%xmm2
ff
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x1,%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0x98(%rbp),%xmm0
ff
movss  -0x88(%rbp),%xmm2
ff
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x2,%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0x7c(%rbp),%xmm0
mulss  -0x80(%rbp),%xmm0
movss  %xmm0,-0x88(%rbp)
ff
movss  -0xec(%rbp),%xmm0
movss  -0x84(%rbp),%xmm2
mov    -0x30(%rbp),%rax
mov    -0x5c(%rbp),%ecx
add    -0x58(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0xf0(%rbp),%xmm0
ff
movss  -0x84(%rbp),%xmm2
ff
mov    -0x30(%rbp),%rax
mov    -0x5c(%rbp),%ecx
add    $0x1,%ecx
add    -0x58(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0xf4(%rbp),%xmm0
ff
movss  -0x84(%rbp),%xmm2
ff
mov    -0x30(%rbp),%rax
mov    -0x5c(%rbp),%ecx
add    $0x2,%ecx
add    -0x58(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0xf8(%rbp),%xmm0
ff
movss  -0x84(%rbp),%xmm2
ff
mov    -0x30(%rbp),%rax
mov    -0x5c(%rbp),%ecx
add    $0x3,%ecx
add    -0x58(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0xe0(%rbp),%xmm0
ff
movss  -0x84(%rbp),%xmm2
ff
mov    -0x28(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0xe4(%rbp),%xmm0
ff
movss  -0x84(%rbp),%xmm2
ff
mov    -0x28(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0xe8(%rbp),%xmm0
ff
movss  -0x84(%rbp),%xmm2
ff
mov    -0x28(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x2,%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0x90(%rbp),%xmm0
ff
movss  -0x84(%rbp),%xmm2
ff
mov    -0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0x94(%rbp),%xmm0
ff
movss  -0x84(%rbp),%xmm2
ff
mov    -0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0x98(%rbp),%xmm0
ff
movss  -0x84(%rbp),%xmm2
ff
mov    -0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x2,%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0xec(%rbp),%xmm0
ff
movss  -0x88(%rbp),%xmm2
ff
mov    -0x30(%rbp),%rax
mov    -0x54(%rbp),%ecx
add    -0x58(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0xf0(%rbp),%xmm0
ff
movss  -0x88(%rbp),%xmm2
ff
mov    -0x30(%rbp),%rax
mov    -0x54(%rbp),%ecx
add    $0x1,%ecx
add    -0x58(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0xf4(%rbp),%xmm0
ff
movss  -0x88(%rbp),%xmm2
ff
mov    -0x30(%rbp),%rax
mov    -0x54(%rbp),%ecx
add    $0x2,%ecx
add    -0x58(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0xf8(%rbp),%xmm0
ff
movss  -0x88(%rbp),%xmm2
ff
mov    -0x30(%rbp),%rax
mov    -0x54(%rbp),%ecx
add    $0x3,%ecx
add    -0x58(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0xe0(%rbp),%xmm0
ff
movss  -0x88(%rbp),%xmm2
ff
mov    -0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0xe4(%rbp),%xmm0
ff
movss  -0x88(%rbp),%xmm2
ff
mov    -0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x1,%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0xe8(%rbp),%xmm0
ff
movss  -0x88(%rbp),%xmm2
ff
mov    -0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x2,%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0x90(%rbp),%xmm0
ff
movss  -0x88(%rbp),%xmm2
ff
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0x94(%rbp),%xmm0
ff
movss  -0x88(%rbp),%xmm2
ff
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x1,%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0x98(%rbp),%xmm0
ff
movss  -0x88(%rbp),%xmm2
ff
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x2,%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    119b <cgdcjpost2l+0x9b>
add    $0x78,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<cgdcjpost2l>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x58,%rsp
mov    %rdx,-0x28(%rsp)
mov    0x98(%rsp),%eax
test   %eax,%eax
jle    1908 <cgdcjpost2l+0x808>
movaps %xmm0,%xmm5
mov    0xa0(%rsp),%edx
lea    (%rdx,%rdx,2),%ebp
mov    %rbp,-0x38(%rsp)
shl    $0x2,%edx
mov    %rdx,-0x30(%rsp)
xorps  %xmm0,%xmm0
cvtss2sd %xmm1,%xmm0
mulsd  0xeb5(%rip),%xmm0
xorps  %xmm1,%xmm1
cvtss2sd %xmm2,%xmm1
mulsd  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtsd2ss %xmm1,%xmm0
movss  0xeb3(%rip),%xmm1
divss  %xmm2,%xmm1
movss  %xmm1,-0x50(%rsp)
movslq 0x90(%rsp),%rdx
mov    %eax,%eax
movaps %xmm0,0x10(%rsp)
shufps $0x0,%xmm0,%xmm0
movaps %xmm0,0x20(%rsp)
add    $0x10,%rdi
shl    $0x2,%rdx
mov    %rdx,-0x40(%rsp)
movss  %xmm5,-0x4c(%rsp)
mov    %r9,-0x70(%rsp)
mov    %rsi,-0x78(%rsp)
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %rax,0x8(%rsp)
mov    %rdi,-0x58(%rsp)
movss  -0x10(%rdi),%xmm6
movss  -0xc(%rdi),%xmm14
cvttss2si %xmm6,%edx
cvttss2si %xmm14,%edi
mov    %rdi,-0x60(%rsp)
cvttps2dq %xmm6,%xmm0
cvtdq2ps %xmm0,%xmm0
subss  %xmm0,%xmm6
cvttps2dq %xmm14,%xmm0
cvtdq2ps %xmm0,%xmm0
subss  %xmm0,%xmm14
lea    (%rdx,%rdx,2),%ebx
mov    -0x38(%rsp),%rax
mov    %eax,%ebp
imul   %edi,%ebp
movss  0xe18(%rip),%xmm0
movaps %xmm0,%xmm15
lea    (%rax,%rbp,1),%edi
movaps %xmm0,%xmm5
subss  %xmm6,%xmm15
subss  %xmm14,%xmm5
lea    (%rdx,%rdx,2),%r9d
add    $0x3,%r9d
add    %edi,%r9d
lea    (%rdi,%rbx,1),%eax
mov    %eax,-0x68(%rsp)
lea    (%rbx,%rbp,1),%r15d
add    $0x3,%r15d
lea    0x4(%rbp,%rbx,1),%r11d
lea    0x1(%rbp,%rbx,1),%r12d
movslq %r15d,%rax
mov    %rax,-0x48(%rsp)
lea    (%rbx,%rbp,1),%r14d
add    $0x5,%r14d
lea    (%rbx,%rbp,1),%r10d
add    $0x2,%r10d
add    %ebx,%ebp
movslq %r9d,%r13
movslq %ebp,%r15
mov    %rdx,%rax
lea    (%rdx,%rdx,2),%ebx
add    $0x4,%ebx
add    %edi,%ebx
movslq -0x68(%rsp),%rbp
mov    %rbp,-0x20(%rsp)
movslq %ebx,%r9
lea    (%rdx,%rdx,2),%ebx
add    $0x1,%ebx
mov    %rdx,-0x10(%rsp)
add    %edi,%ebx
movslq %ebx,%rdx
mov    %rdx,-0x18(%rsp)
movss  (%rsi,%rdx,4),%xmm8
movss  (%rsi,%rbp,4),%xmm0
movaps %xmm6,%xmm2
shufps $0x0,%xmm6,%xmm2
movss  (%rsi,%r9,4),%xmm10
movaps %xmm15,%xmm1
movss  (%rsi,%r13,4),%xmm9
movslq %r11d,%r11
movslq %r12d,%rdx
shufps $0x0,%xmm15,%xmm1
movss  (%rsi,%r15,4),%xmm4
mov    %r15,%r12
mov    %r15,(%rsp)
movss  (%rsi,%rdx,4),%xmm7
mov    %rdx,%r15
mov    %rdx,-0x68(%rsp)
unpcklps %xmm7,%xmm4
unpcklps %xmm8,%xmm0
movss  (%rsi,%r11,4),%xmm7
mov    -0x48(%rsp),%rdx
movss  (%rsi,%rdx,4),%xmm12
unpcklps %xmm7,%xmm12
movaps %xmm14,%xmm8
unpcklps %xmm10,%xmm9
shufps $0x0,%xmm14,%xmm8
lea    (%rax,%rax,2),%ebx
add    $0x5,%ebx
add    %edi,%ebx
mulps  %xmm1,%xmm4
movslq %ebx,%rbx
lea    (%rax,%rax,2),%ebp
add    $0x2,%ebp
add    %edi,%ebp
mulps  %xmm2,%xmm12
movslq %ebp,%rsi
mov    -0x78(%rsp),%rdi
movss  (%rdi,%rsi,4),%xmm11
movslq %r14d,%r14
mulps  %xmm1,%xmm0
movslq %r10d,%rdi
mov    -0x78(%rsp),%rax
movss  (%rax,%rdi,4),%xmm1
mov    %rdi,-0x8(%rsp)
mulss  %xmm15,%xmm1
mulps  %xmm2,%xmm9
mov    -0x78(%rsp),%rax
movss  (%rax,%r14,4),%xmm13
mulss  %xmm6,%xmm13
addss  %xmm1,%xmm13
addps  %xmm4,%xmm12
mov    -0x28(%rsp),%rax
movss  (%rax,%r12,4),%xmm4
mulss  %xmm15,%xmm4
movss  (%rax,%rdx,4),%xmm3
addps  %xmm0,%xmm9
mulss  %xmm6,%xmm3
addss  %xmm4,%xmm3
movss  (%rax,%r15,4),%xmm4
mulss  %xmm5,%xmm13
mulss  %xmm15,%xmm4
movss  (%rax,%r11,4),%xmm0
mulss  %xmm6,%xmm0
mulss  %xmm5,%xmm3
addss  %xmm4,%xmm0
movss  (%rax,%rdi,4),%xmm4
mulss  %xmm15,%xmm4
mulss  %xmm5,%xmm0
movss  (%rax,%r14,4),%xmm7
mulss  %xmm6,%xmm7
addss  %xmm4,%xmm7
movaps %xmm5,%xmm2
movaps %xmm5,0x40(%rsp)
mulss  %xmm5,%xmm7
movaps %xmm15,%xmm5
movaps %xmm15,0x30(%rsp)
mulss  %xmm15,%xmm11
mov    -0x78(%rsp),%rdi
movss  (%rdi,%rbx,4),%xmm10
mulss  %xmm6,%xmm10
shufps $0x0,%xmm2,%xmm2
addss  %xmm11,%xmm10
mulss  %xmm14,%xmm10
mov    -0x20(%rsp),%r15
movss  (%rax,%r15,4),%xmm4
mulps  %xmm12,%xmm2
mulss  %xmm15,%xmm4
movss  (%rax,%r13,4),%xmm15
mulss  %xmm6,%xmm15
mulps  %xmm9,%xmm8
addss  %xmm4,%xmm15
mulss  %xmm14,%xmm15
mov    -0x18(%rsp),%r12
movss  (%rax,%r12,4),%xmm1
addss  %xmm13,%xmm10
mulss  %xmm5,%xmm1
movss  (%rax,%r9,4),%xmm4
mulss  %xmm6,%xmm4
addss  %xmm3,%xmm15
addss  %xmm1,%xmm4
mulss  %xmm14,%xmm4
movss  (%rax,%rsi,4),%xmm9
addss  %xmm0,%xmm4
mulss  %xmm5,%xmm9
movss  (%rax,%rbx,4),%xmm1
mulss  %xmm6,%xmm1
addps  %xmm2,%xmm8
addss  %xmm9,%xmm1
mulss  %xmm14,%xmm1
addss  %xmm7,%xmm1
movaps 0x10(%rsp),%xmm0
mulss  %xmm0,%xmm15
mulss  %xmm0,%xmm4
mulss  %xmm0,%xmm1
movaps %xmm15,%xmm3
mulss  %xmm4,%xmm3
movaps %xmm15,%xmm12
mulss  %xmm1,%xmm12
movaps %xmm4,%xmm2
movaps %xmm4,%xmm9
addss  %xmm12,%xmm9
subss  %xmm4,%xmm12
mulss  %xmm4,%xmm4
movaps %xmm15,%xmm11
mulss  %xmm15,%xmm11
movaps %xmm11,%xmm7
mulss  %xmm1,%xmm2
movaps %xmm3,%xmm13
addss  %xmm1,%xmm13
subss  %xmm1,%xmm3
addss  %xmm4,%xmm7
mulss  %xmm1,%xmm1
addss  %xmm1,%xmm7
cvtss2sd %xmm7,%xmm7
movsd  0xb28(%rip),%xmm5
movapd %xmm5,%xmm0
subsd  %xmm7,%xmm0
addsd  %xmm5,%xmm7
mulsd  0xb0c(%rip),%xmm0
cvtsd2ss %xmm0,%xmm0
movsd  0xb10(%rip),%xmm5
divsd  %xmm7,%xmm5
addss  %xmm0,%xmm11
addss  %xmm0,%xmm4
addss  %xmm0,%xmm1
unpcklps %xmm4,%xmm13
unpcklps %xmm2,%xmm4
subss  %xmm15,%xmm2
unpcklps %xmm15,%xmm0
mulps  0x20(%rsp),%xmm8
addps  %xmm0,%xmm4
mov    -0x58(%rsp),%rax
movsd  -0x8(%rax),%xmm15
unpcklps %xmm3,%xmm11
movaps %xmm8,%xmm3
addps  %xmm15,%xmm3
shufps $0x1,%xmm12,%xmm4
shufps $0xe2,%xmm12,%xmm4
movaps %xmm3,%xmm7
mulss  %xmm3,%xmm9
shufps $0x0,%xmm3,%xmm3
mulps  %xmm11,%xmm3
mov    -0x58(%rsp),%rax
movss  (%rax),%xmm12
mulss  0x10(%rsp),%xmm10
shufps $0x55,%xmm7,%xmm7
mulps  %xmm7,%xmm13
addps  %xmm13,%xmm3
movaps %xmm10,%xmm0
addss  %xmm12,%xmm0
mulss  %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm0
mulps  %xmm4,%xmm0
mov    -0x30(%rsp),%rax
mov    -0x60(%rsp),%rdx
imul   %eax,%edx
mov    %rdx,-0x60(%rsp)
lea    (%rdx,%rax,1),%ebp
addps  %xmm3,%xmm0
xorps  %xmm3,%xmm3
cvtsd2ss %xmm5,%xmm3
movss  -0x4c(%rsp),%xmm5
mulss  %xmm7,%xmm2
addss  %xmm9,%xmm2
addss  %xmm1,%xmm2
mulss  %xmm3,%xmm2
movaps %xmm3,%xmm9
shufps $0x0,%xmm3,%xmm9
mulps  %xmm0,%xmm9
addss  %xmm10,%xmm2
addps  %xmm8,%xmm9
mulss  %xmm5,%xmm6
movaps %xmm15,%xmm8
addps  %xmm9,%xmm8
movaps %xmm12,%xmm4
addss  %xmm2,%xmm4
mulps  0xa2c(%rip),%xmm8
mulss  0xa20(%rip),%xmm4
movaps %xmm6,%xmm1
mulss  %xmm14,%xmm1
movaps %xmm8,%xmm10
shufps $0x55,%xmm8,%xmm10
movaps %xmm10,%xmm0
movaps %xmm8,%xmm11
mulss  %xmm10,%xmm0
mulss  %xmm8,%xmm11
subss  %xmm0,%xmm11
movaps %xmm8,%xmm0
mulss  %xmm10,%xmm0
movaps %xmm4,%xmm3
unpcklps %xmm0,%xmm11
unpcklps %xmm4,%xmm3
mulps  %xmm8,%xmm3
movlhps %xmm3,%xmm11
mov    -0x10(%rsp),%rdx
lea    0x4(%rbp,%rdx,4),%eax
cltq
mov    -0x70(%rsp),%r10
movups (%r10,%rax,4),%xmm0
movaps %xmm1,%xmm3
shufps $0x0,%xmm1,%xmm3
mulps  %xmm11,%xmm3
addps  %xmm0,%xmm3
mov    -0x70(%rsp),%rdi
movups %xmm3,(%rdi,%rax,4)
subps  %xmm15,%xmm9
movss  -0x50(%rsp),%xmm0
movaps %xmm0,%xmm15
mulss  %xmm9,%xmm15
shufps $0x55,%xmm9,%xmm9
subss  %xmm12,%xmm2
mulss  %xmm0,%xmm2
mulss  %xmm0,%xmm9
movaps %xmm15,%xmm0
mulss  %xmm1,%xmm0
addss  (%r8,%r13,4),%xmm0
movss  %xmm0,(%r8,%r13,4)
movaps %xmm9,%xmm0
mulss  %xmm1,%xmm0
addss  (%r8,%r9,4),%xmm0
movss  %xmm0,(%r8,%r9,4)
movaps %xmm2,%xmm0
mulss  %xmm1,%xmm0
addss  (%r8,%rbx,4),%xmm0
movss  %xmm0,(%r8,%rbx,4)
movaps %xmm8,%xmm0
mulss  %xmm1,%xmm0
addss  (%rcx,%r13,4),%xmm0
movss  %xmm0,(%rcx,%r13,4)
movaps %xmm10,%xmm0
mulss  %xmm1,%xmm0
addss  (%rcx,%r9,4),%xmm0
movss  %xmm0,(%rcx,%r9,4)
mulss  %xmm4,%xmm1
addss  (%rcx,%rbx,4),%xmm1
movss  %xmm1,(%rcx,%rbx,4)
movaps 0x30(%rsp),%xmm3
mulss  %xmm5,%xmm3
lea    0x0(%rbp,%rdx,4),%eax
cltq
mulss  %xmm3,%xmm14
mov    -0x70(%rsp),%rdi
movups (%rdi,%rax,4),%xmm0
movaps %xmm14,%xmm1
shufps $0x0,%xmm14,%xmm1
mulps  %xmm11,%xmm1
addps  %xmm0,%xmm1
mov    -0x70(%rsp),%rdi
movups %xmm1,(%rdi,%rax,4)
mov    -0x58(%rsp),%rdi
movaps %xmm15,%xmm0
mulss  %xmm14,%xmm0
addss  (%r8,%r15,4),%xmm0
movss  %xmm0,(%r8,%r15,4)
movaps %xmm9,%xmm0
mulss  %xmm14,%xmm0
addss  (%r8,%r12,4),%xmm0
movss  %xmm0,(%r8,%r12,4)
movaps %xmm2,%xmm0
mulss  %xmm14,%xmm0
addss  (%r8,%rsi,4),%xmm0
movss  %xmm0,(%r8,%rsi,4)
movaps %xmm8,%xmm0
mulss  %xmm14,%xmm0
addss  (%rcx,%r15,4),%xmm0
movss  %xmm0,(%rcx,%r15,4)
mov    -0x70(%rsp),%r9
movaps %xmm10,%xmm0
mulss  %xmm14,%xmm0
addss  (%rcx,%r12,4),%xmm0
movss  %xmm0,(%rcx,%r12,4)
mulss  %xmm4,%xmm14
addss  (%rcx,%rsi,4),%xmm14
movss  %xmm14,(%rcx,%rsi,4)
mov    -0x78(%rsp),%rsi
mov    -0x60(%rsp),%rbp
lea    0x4(%rbp,%rdx,4),%eax
cltq
movaps 0x40(%rsp),%xmm7
mulss  %xmm7,%xmm6
movups (%r9,%rax,4),%xmm0
movaps %xmm6,%xmm1
shufps $0x0,%xmm6,%xmm1
mulps  %xmm11,%xmm1
addps  %xmm0,%xmm1
movups %xmm1,(%r9,%rax,4)
movaps %xmm15,%xmm0
mulss  %xmm6,%xmm0
mov    -0x48(%rsp),%rax
addss  (%r8,%rax,4),%xmm0
movss  %xmm0,(%r8,%rax,4)
movaps %xmm9,%xmm0
mulss  %xmm6,%xmm0
addss  (%r8,%r11,4),%xmm0
movss  %xmm0,(%r8,%r11,4)
movaps %xmm2,%xmm0
mulss  %xmm6,%xmm0
addss  (%r8,%r14,4),%xmm0
movss  %xmm0,(%r8,%r14,4)
movaps %xmm8,%xmm0
mulss  %xmm6,%xmm0
addss  (%rcx,%rax,4),%xmm0
movss  %xmm0,(%rcx,%rax,4)
movaps %xmm10,%xmm0
mulss  %xmm6,%xmm0
addss  (%rcx,%r11,4),%xmm0
movss  %xmm0,(%rcx,%r11,4)
mulss  %xmm4,%xmm6
addss  (%rcx,%r14,4),%xmm6
movss  %xmm6,(%rcx,%r14,4)
lea    0x0(%rbp,%rdx,4),%eax
mulss  %xmm7,%xmm3
cltq
movaps %xmm3,%xmm0
shufps $0x0,%xmm3,%xmm0
mulps  %xmm11,%xmm0
movups (%r9,%rax,4),%xmm1
addps  %xmm1,%xmm0
movups %xmm0,(%r9,%rax,4)
mov    0x8(%rsp),%rax
mulss  %xmm3,%xmm15
mov    (%rsp),%rdx
addss  (%r8,%rdx,4),%xmm15
movss  %xmm15,(%r8,%rdx,4)
mulss  %xmm3,%xmm9
mov    -0x68(%rsp),%rbp
addss  (%r8,%rbp,4),%xmm9
movss  %xmm9,(%r8,%rbp,4)
mulss  %xmm3,%xmm2
mov    -0x8(%rsp),%rbx
addss  (%r8,%rbx,4),%xmm2
movss  %xmm2,(%r8,%rbx,4)
mulss  %xmm3,%xmm8
addss  (%rcx,%rdx,4),%xmm8
movss  %xmm8,(%rcx,%rdx,4)
mulss  %xmm3,%xmm10
addss  (%rcx,%rbp,4),%xmm10
movss  %xmm10,(%rcx,%rbp,4)
mulss  %xmm4,%xmm3
addss  (%rcx,%rbx,4),%xmm3
movss  %xmm3,(%rcx,%rbx,4)
add    -0x40(%rsp),%rdi
add    $0xffffffffffffffff,%rax
jne    11b0 <cgdcjpost2l+0xb0>
add    $0x58,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @cgdcjpost2l(float* %0, float* %1, float* %2, float* %3, float* %4, float* %5, float %6, float %7, float %8, i32 %9, i32 %10, i32 %11, i32 %12) {
%14 = alloca float*
%15 = alloca float*
%16 = alloca float*
%17 = alloca float*
%18 = alloca float*
%19 = alloca float*
%20 = alloca float
%21 = alloca float
%22 = alloca float
%23 = alloca i32
%24 = alloca i32
%25 = alloca i32
%26 = alloca i32
%27 = alloca i32
%28 = alloca i32
%29 = alloca i32
%30 = alloca i32
%31 = alloca i32
%32 = alloca i32
%33 = alloca i32
%34 = alloca i32
%35 = alloca i32
%36 = alloca i32
%37 = alloca i32
%38 = alloca float
%39 = alloca float
%40 = alloca float
%41 = alloca float
%42 = alloca float
%43 = alloca float
%44 = alloca float
%45 = alloca float
%46 = alloca float
%47 = alloca float
%48 = alloca float
%49 = alloca float
%50 = alloca float
%51 = alloca float
%52 = alloca float
%53 = alloca float
%54 = alloca float
%55 = alloca float
%56 = alloca float
%57 = alloca float
%58 = alloca float
%59 = alloca float
%60 = alloca float
%61 = alloca float
%62 = alloca float
%63 = alloca float
%64 = alloca float
%65 = alloca float
%66 = alloca float
%67 = alloca float
%68 = alloca float
%69 = alloca float
%70 = alloca float
%71 = alloca float
%72 = alloca float
%73 = alloca float
store float* %0, float** %14
store float* %1, float** %15
store float* %2, float** %16
store float* %3, float** %17
store float* %4, float** %18
store float* %5, float** %19
store float %6, float* %20
store float %7, float* %21
store float %8, float* %22
store i32 %9, i32* %23
store i32 %10, i32* %24
store i32 %11, i32* %25
store i32 %12, i32* %26
%74 = load i32, i32* %25
%75 = mul nsw i32 3, %74
store i32 %75, i32* %36
%76 = load i32, i32* %25
%77 = mul nsw i32 4, %76
store i32 %77, i32* %37
%78 = load float, float* %21
%79 = fpext float %78 to double
%80 = fmul double 5.000000e-01, %79
%81 = load float, float* %22
%82 = fpext float %81 to double
%83 = fmul double %80, %82
%84 = fptrunc double %83 to float
store float %84, float* %38
%85 = load float, float* %22
%86 = fpext float %85 to double
%87 = fdiv double 1.000000e+00, %86
%88 = fptrunc double %87 to float
store float %88, float* %39
store i32 0, i32* %27
br label %89
89: ; preds = %1057, %13
%90 = load i32, i32* %27
%91 = load i32, i32* %24
%92 = icmp slt i32 %90, %91
br i1 %92, label %93, label %1060
93: ; preds = %89
%94 = load float*, float** %14
%95 = load i32, i32* %23
%96 = load i32, i32* %27
%97 = mul nsw i32 %95, %96
%98 = sext i32 %97 to i64
%99 = getelementptr inbounds float, float* %94, i64 %98
%100 = load float, float* %99
%101 = fptosi float %100 to i32
store i32 %101, i32* %32
%102 = load float*, float** %14
%103 = load i32, i32* %23
%104 = load i32, i32* %27
%105 = mul nsw i32 %103, %104
%106 = add nsw i32 1, %105
%107 = sext i32 %106 to i64
%108 = getelementptr inbounds float, float* %102, i64 %107
%109 = load float, float* %108
%110 = fptosi float %109 to i32
store i32 %110, i32* %33
%111 = load float*, float** %14
%112 = load i32, i32* %23
%113 = load i32, i32* %27
%114 = mul nsw i32 %112, %113
%115 = sext i32 %114 to i64
%116 = getelementptr inbounds float, float* %111, i64 %115
%117 = load float, float* %116
%118 = load i32, i32* %32
%119 = sitofp i32 %118 to float
%120 = fsub float %117, %119
store float %120, float* %40
%121 = load float*, float** %14
%122 = load i32, i32* %23
%123 = load i32, i32* %27
%124 = mul nsw i32 %122, %123
%125 = add nsw i32 1, %124
%126 = sext i32 %125 to i64
%127 = getelementptr inbounds float, float* %121, i64 %126
%128 = load float, float* %127
%129 = load i32, i32* %33
%130 = sitofp i32 %129 to float
%131 = fsub float %128, %130
store float %131, float* %41
%132 = load i32, i32* %32
%133 = mul nsw i32 3, %132
store i32 %133, i32* %28
%134 = load i32, i32* %36
%135 = load i32, i32* %33
%136 = mul nsw i32 %134, %135
store i32 %136, i32* %29
%137 = load float, float* %40
%138 = fpext float %137 to double
%139 = fsub double 1.000000e+00, %138
%140 = fptrunc double %139 to float
store float %140, float* %42
%141 = load i32, i32* %29
%142 = load i32, i32* %36
%143 = add nsw i32 %141, %142
store i32 %143, i32* %31
%144 = load float, float* %41
%145 = fpext float %144 to double
%146 = fsub double 1.000000e+00, %145
%147 = fptrunc double %146 to float
store float %147, float* %43
%148 = load i32, i32* %28
%149 = add nsw i32 %148, 3
store i32 %149, i32* %30
%150 = load i32, i32* %32
%151 = mul nsw i32 4, %150
store i32 %151, i32* %32
%152 = load i32, i32* %37
%153 = load i32, i32* %33
%154 = mul nsw i32 %152, %153
store i32 %154, i32* %33
%155 = load i32, i32* %33
%156 = load i32, i32* %37
%157 = add nsw i32 %155, %156
store i32 %157, i32* %35
%158 = load i32, i32* %32
%159 = add nsw i32 %158, 4
store i32 %159, i32* %34
%160 = load float, float* %41
%161 = load float, float* %40
%162 = load float*, float** %15
%163 = load i32, i32* %30
%164 = load i32, i32* %31
%165 = add nsw i32 %163, %164
%166 = sext i32 %165 to i64
%167 = getelementptr inbounds float, float* %162, i64 %166
%168 = load float, float* %167
%169 = load float, float* %42
%170 = load float*, float** %15
%171 = load i32, i32* %28
%172 = load i32, i32* %31
%173 = add nsw i32 %171, %172
%174 = sext i32 %173 to i64
%175 = getelementptr inbounds float, float* %170, i64 %174
%176 = load float, float* %175
%177 = fmul float %169, %176
%178 = call float @llvm.fmuladd.f32(float %161, float %168, float %177)
%179 = load float, float* %43
%180 = load float, float* %40
%181 = load float*, float** %15
%182 = load i32, i32* %30
%183 = load i32, i32* %29
%184 = add nsw i32 %182, %183
%185 = sext i32 %184 to i64
%186 = getelementptr inbounds float, float* %181, i64 %185
%187 = load float, float* %186
%188 = load float, float* %42
%189 = load float*, float** %15
%190 = load i32, i32* %28
%191 = load i32, i32* %29
%192 = add nsw i32 %190, %191
%193 = sext i32 %192 to i64
%194 = getelementptr inbounds float, float* %189, i64 %193
%195 = load float, float* %194
%196 = fmul float %188, %195
%197 = call float @llvm.fmuladd.f32(float %180, float %187, float %196)
%198 = fmul float %179, %197
%199 = call float @llvm.fmuladd.f32(float %160, float %178, float %198)
store float %199, float* %44
%200 = load float, float* %41
%201 = load float, float* %40
%202 = load float*, float** %15
%203 = load i32, i32* %30
%204 = add nsw i32 1, %203
%205 = load i32, i32* %31
%206 = add nsw i32 %204, %205
%207 = sext i32 %206 to i64
%208 = getelementptr inbounds float, float* %202, i64 %207
%209 = load float, float* %208
%210 = load float, float* %42
%211 = load float*, float** %15
%212 = load i32, i32* %28
%213 = add nsw i32 1, %212
%214 = load i32, i32* %31
%215 = add nsw i32 %213, %214
%216 = sext i32 %215 to i64
%217 = getelementptr inbounds float, float* %211, i64 %216
%218 = load float, float* %217
%219 = fmul float %210, %218
%220 = call float @llvm.fmuladd.f32(float %201, float %209, float %219)
%221 = load float, float* %43
%222 = load float, float* %40
%223 = load float*, float** %15
%224 = load i32, i32* %30
%225 = add nsw i32 1, %224
%226 = load i32, i32* %29
%227 = add nsw i32 %225, %226
%228 = sext i32 %227 to i64
%229 = getelementptr inbounds float, float* %223, i64 %228
%230 = load float, float* %229
%231 = load float, float* %42
%232 = load float*, float** %15
%233 = load i32, i32* %28
%234 = add nsw i32 1, %233
%235 = load i32, i32* %29
%236 = add nsw i32 %234, %235
%237 = sext i32 %236 to i64
%238 = getelementptr inbounds float, float* %232, i64 %237
%239 = load float, float* %238
%240 = fmul float %231, %239
%241 = call float @llvm.fmuladd.f32(float %222, float %230, float %240)
%242 = fmul float %221, %241
%243 = call float @llvm.fmuladd.f32(float %200, float %220, float %242)
store float %243, float* %45
%244 = load float, float* %41
%245 = load float, float* %40
%246 = load float*, float** %15
%247 = load i32, i32* %30
%248 = add nsw i32 2, %247
%249 = load i32, i32* %31
%250 = add nsw i32 %248, %249
%251 = sext i32 %250 to i64
%252 = getelementptr inbounds float, float* %246, i64 %251
%253 = load float, float* %252
%254 = load float, float* %42
%255 = load float*, float** %15
%256 = load i32, i32* %28
%257 = add nsw i32 2, %256
%258 = load i32, i32* %31
%259 = add nsw i32 %257, %258
%260 = sext i32 %259 to i64
%261 = getelementptr inbounds float, float* %255, i64 %260
%262 = load float, float* %261
%263 = fmul float %254, %262
%264 = call float @llvm.fmuladd.f32(float %245, float %253, float %263)
%265 = load float, float* %43
%266 = load float, float* %40
%267 = load float*, float** %15
%268 = load i32, i32* %30
%269 = add nsw i32 2, %268
%270 = load i32, i32* %29
%271 = add nsw i32 %269, %270
%272 = sext i32 %271 to i64
%273 = getelementptr inbounds float, float* %267, i64 %272
%274 = load float, float* %273
%275 = load float, float* %42
%276 = load float*, float** %15
%277 = load i32, i32* %28
%278 = add nsw i32 2, %277
%279 = load i32, i32* %29
%280 = add nsw i32 %278, %279
%281 = sext i32 %280 to i64
%282 = getelementptr inbounds float, float* %276, i64 %281
%283 = load float, float* %282
%284 = fmul float %275, %283
%285 = call float @llvm.fmuladd.f32(float %266, float %274, float %284)
%286 = fmul float %265, %285
%287 = call float @llvm.fmuladd.f32(float %244, float %264, float %286)
store float %287, float* %46
%288 = load float, float* %41
%289 = load float, float* %40
%290 = load float*, float** %16
%291 = load i32, i32* %30
%292 = load i32, i32* %31
%293 = add nsw i32 %291, %292
%294 = sext i32 %293 to i64
%295 = getelementptr inbounds float, float* %290, i64 %294
%296 = load float, float* %295
%297 = load float, float* %42
%298 = load float*, float** %16
%299 = load i32, i32* %28
%300 = load i32, i32* %31
%301 = add nsw i32 %299, %300
%302 = sext i32 %301 to i64
%303 = getelementptr inbounds float, float* %298, i64 %302
%304 = load float, float* %303
%305 = fmul float %297, %304
%306 = call float @llvm.fmuladd.f32(float %289, float %296, float %305)
%307 = load float, float* %43
%308 = load float, float* %40
%309 = load float*, float** %16
%310 = load i32, i32* %30
%311 = load i32, i32* %29
%312 = add nsw i32 %310, %311
%313 = sext i32 %312 to i64
%314 = getelementptr inbounds float, float* %309, i64 %313
%315 = load float, float* %314
%316 = load float, float* %42
%317 = load float*, float** %16
%318 = load i32, i32* %28
%319 = load i32, i32* %29
%320 = add nsw i32 %318, %319
%321 = sext i32 %320 to i64
%322 = getelementptr inbounds float, float* %317, i64 %321
%323 = load float, float* %322
%324 = fmul float %316, %323
%325 = call float @llvm.fmuladd.f32(float %308, float %315, float %324)
%326 = fmul float %307, %325
%327 = call float @llvm.fmuladd.f32(float %288, float %306, float %326)
store float %327, float* %47
%328 = load float, float* %41
%329 = load float, float* %40
%330 = load float*, float** %16
%331 = load i32, i32* %30
%332 = add nsw i32 1, %331
%333 = load i32, i32* %31
%334 = add nsw i32 %332, %333
%335 = sext i32 %334 to i64
%336 = getelementptr inbounds float, float* %330, i64 %335
%337 = load float, float* %336
%338 = load float, float* %42
%339 = load float*, float** %16
%340 = load i32, i32* %28
%341 = add nsw i32 1, %340
%342 = load i32, i32* %31
%343 = add nsw i32 %341, %342
%344 = sext i32 %343 to i64
%345 = getelementptr inbounds float, float* %339, i64 %344
%346 = load float, float* %345
%347 = fmul float %338, %346
%348 = call float @llvm.fmuladd.f32(float %329, float %337, float %347)
%349 = load float, float* %43
%350 = load float, float* %40
%351 = load float*, float** %16
%352 = load i32, i32* %30
%353 = add nsw i32 1, %352
%354 = load i32, i32* %29
%355 = add nsw i32 %353, %354
%356 = sext i32 %355 to i64
%357 = getelementptr inbounds float, float* %351, i64 %356
%358 = load float, float* %357
%359 = load float, float* %42
%360 = load float*, float** %16
%361 = load i32, i32* %28
%362 = add nsw i32 1, %361
%363 = load i32, i32* %29
%364 = add nsw i32 %362, %363
%365 = sext i32 %364 to i64
%366 = getelementptr inbounds float, float* %360, i64 %365
%367 = load float, float* %366
%368 = fmul float %359, %367
%369 = call float @llvm.fmuladd.f32(float %350, float %358, float %368)
%370 = fmul float %349, %369
%371 = call float @llvm.fmuladd.f32(float %328, float %348, float %370)
store float %371, float* %48
%372 = load float, float* %41
%373 = load float, float* %40
%374 = load float*, float** %16
%375 = load i32, i32* %30
%376 = add nsw i32 2, %375
%377 = load i32, i32* %31
%378 = add nsw i32 %376, %377
%379 = sext i32 %378 to i64
%380 = getelementptr inbounds float, float* %374, i64 %379
%381 = load float, float* %380
%382 = load float, float* %42
%383 = load float*, float** %16
%384 = load i32, i32* %28
%385 = add nsw i32 2, %384
%386 = load i32, i32* %31
%387 = add nsw i32 %385, %386
%388 = sext i32 %387 to i64
%389 = getelementptr inbounds float, float* %383, i64 %388
%390 = load float, float* %389
%391 = fmul float %382, %390
%392 = call float @llvm.fmuladd.f32(float %373, float %381, float %391)
%393 = load float, float* %43
%394 = load float, float* %40
%395 = load float*, float** %16
%396 = load i32, i32* %30
%397 = add nsw i32 2, %396
%398 = load i32, i32* %29
%399 = add nsw i32 %397, %398
%400 = sext i32 %399 to i64
%401 = getelementptr inbounds float, float* %395, i64 %400
%402 = load float, float* %401
%403 = load float, float* %42
%404 = load float*, float** %16
%405 = load i32, i32* %28
%406 = add nsw i32 2, %405
%407 = load i32, i32* %29
%408 = add nsw i32 %406, %407
%409 = sext i32 %408 to i64
%410 = getelementptr inbounds float, float* %404, i64 %409
%411 = load float, float* %410
%412 = fmul float %403, %411
%413 = call float @llvm.fmuladd.f32(float %394, float %402, float %412)
%414 = fmul float %393, %413
%415 = call float @llvm.fmuladd.f32(float %372, float %392, float %414)
store float %415, float* %49
%416 = load float, float* %38
%417 = load float, float* %44
%418 = fmul float %417, %416
store float %418, float* %44
%419 = load float, float* %38
%420 = load float, float* %45
%421 = fmul float %420, %419
store float %421, float* %45
%422 = load float, float* %38
%423 = load float, float* %46
%424 = fmul float %423, %422
store float %424, float* %46
%425 = load float*, float** %14
%426 = load i32, i32* %23
%427 = load i32, i32* %27
%428 = mul nsw i32 %426, %427
%429 = add nsw i32 2, %428
%430 = sext i32 %429 to i64
%431 = getelementptr inbounds float, float* %425, i64 %430
%432 = load float, float* %431
store float %432, float* %67
%433 = load float*, float** %14
%434 = load i32, i32* %23
%435 = load i32, i32* %27
%436 = mul nsw i32 %434, %435
%437 = add nsw i32 3, %436
%438 = sext i32 %437 to i64
%439 = getelementptr inbounds float, float* %433, i64 %438
%440 = load float, float* %439
store float %440, float* %68
%441 = load float*, float** %14
%442 = load i32, i32* %23
%443 = load i32, i32* %27
%444 = mul nsw i32 %442, %443
%445 = add nsw i32 4, %444
%446 = sext i32 %445 to i64
%447 = getelementptr inbounds float, float* %441, i64 %446
%448 = load float, float* %447
store float %448, float* %69
%449 = load float, float* %67
%450 = load float, float* %44
%451 = fadd float %449, %450
store float %451, float* %50
%452 = load float, float* %68
%453 = load float, float* %45
%454 = fadd float %452, %453
store float %454, float* %51
%455 = load float, float* %69
%456 = load float, float* %46
%457 = fadd float %455, %456
store float %457, float* %52
%458 = load float, float* %38
%459 = load float, float* %47
%460 = fmul float %458, %459
store float %460, float* %53
%461 = load float, float* %38
%462 = load float, float* %48
%463 = fmul float %461, %462
store float %463, float* %54
%464 = load float, float* %38
%465 = load float, float* %49
%466 = fmul float %464, %465
store float %466, float* %55
%467 = load float, float* %53
%468 = load float, float* %53
%469 = load float, float* %54
%470 = load float, float* %54
%471 = fmul float %469, %470
%472 = call float @llvm.fmuladd.f32(float %467, float %468, float %471)
%473 = load float, float* %55
%474 = load float, float* %55
%475 = call float @llvm.fmuladd.f32(float %473, float %474, float %472)
store float %475, float* %56
%476 = load float, float* %56
%477 = fpext float %476 to double
%478 = fadd double 1.000000e+00, %477
%479 = fdiv double 2.000000e+00, %478
%480 = fptrunc double %479 to float
store float %480, float* %57
%481 = load float, float* %56
%482 = fpext float %481 to double
%483 = fsub double 1.000000e+00, %482
%484 = fmul double 5.000000e-01, %483
%485 = fptrunc double %484 to float
store float %485, float* %56
%486 = load float, float* %53
%487 = load float, float* %54
%488 = fmul float %486, %487
store float %488, float* %61
%489 = load float, float* %53
%490 = load float, float* %55
%491 = fmul float %489, %490
store float %491, float* %64
%492 = load float, float* %54
%493 = load float, float* %55
%494 = fmul float %492, %493
store float %494, float* %65
%495 = load float, float* %56
%496 = load float, float* %53
%497 = load float, float* %53
%498 = call float @llvm.fmuladd.f32(float %496, float %497, float %495)
store float %498, float* %58
%499 = load float, float* %56
%500 = load float, float* %54
%501 = load float, float* %54
%502 = call float @llvm.fmuladd.f32(float %500, float %501, float %499)
store float %502, float* %62
%503 = load float, float* %56
%504 = load float, float* %55
%505 = load float, float* %55
%506 = call float @llvm.fmuladd.f32(float %504, float %505, float %503)
store float %506, float* %66
%507 = load float, float* %55
%508 = load float, float* %61
%509 = fadd float %507, %508
store float %509, float* %59
%510 = load float, float* %55
%511 = load float, float* %61
%512 = fsub float %511, %510
store float %512, float* %61
%513 = load float, float* %54
%514 = fneg float %513
%515 = load float, float* %64
%516 = fadd float %514, %515
store float %516, float* %60
%517 = load float, float* %54
%518 = load float, float* %64
%519 = fadd float %518, %517
store float %519, float* %64
%520 = load float, float* %53
%521 = load float, float* %65
%522 = fadd float %520, %521
store float %522, float* %63
%523 = load float, float* %53
%524 = load float, float* %65
%525 = fsub float %524, %523
store float %525, float* %65
%526 = load float, float* %58
%527 = load float, float* %50
%528 = load float, float* %59
%529 = load float, float* %51
%530 = fmul float %528, %529
%531 = call float @llvm.fmuladd.f32(float %526, float %527, float %530)
%532 = load float, float* %60
%533 = load float, float* %52
%534 = call float @llvm.fmuladd.f32(float %532, float %533, float %531)
%535 = load float, float* %57
%536 = load float, float* %44
%537 = call float @llvm.fmuladd.f32(float %534, float %535, float %536)
store float %537, float* %44
%538 = load float, float* %61
%539 = load float, float* %50
%540 = load float, float* %62
%541 = load float, float* %51
%542 = fmul float %540, %541
%543 = call float @llvm.fmuladd.f32(float %538, float %539, float %542)
%544 = load float, float* %63
%545 = load float, float* %52
%546 = call float @llvm.fmuladd.f32(float %544, float %545, float %543)
%547 = load float, float* %57
%548 = load float, float* %45
%549 = call float @llvm.fmuladd.f32(float %546, float %547, float %548)
store float %549, float* %45
%550 = load float, float* %64
%551 = load float, float* %50
%552 = load float, float* %65
%553 = load float, float* %51
%554 = fmul float %552, %553
%555 = call float @llvm.fmuladd.f32(float %550, float %551, float %554)
%556 = load float, float* %66
%557 = load float, float* %52
%558 = call float @llvm.fmuladd.f32(float %556, float %557, float %555)
%559 = load float, float* %57
%560 = load float, float* %46
%561 = call float @llvm.fmuladd.f32(float %558, float %559, float %560)
store float %561, float* %46
%562 = load float, float* %20
%563 = load float, float* %42
%564 = fmul float %562, %563
store float %564, float* %42
%565 = load float, float* %20
%566 = load float, float* %40
%567 = fmul float %565, %566
store float %567, float* %40
%568 = load float, float* %44
%569 = load float, float* %67
%570 = fadd float %568, %569
%571 = fpext float %570 to double
%572 = fmul double 5.000000e-01, %571
%573 = fptrunc double %572 to float
store float %573, float* %47
%574 = load float, float* %45
%575 = load float, float* %68
%576 = fadd float %574, %575
%577 = fpext float %576 to double
%578 = fmul double 5.000000e-01, %577
%579 = fptrunc double %578 to float
store float %579, float* %48
%580 = load float, float* %46
%581 = load float, float* %69
%582 = fadd float %580, %581
%583 = fpext float %582 to double
%584 = fmul double 5.000000e-01, %583
%585 = fptrunc double %584 to float
store float %585, float* %49
%586 = load float, float* %39
%587 = load float, float* %44
%588 = load float, float* %67
%589 = fsub float %587, %588
%590 = fmul float %586, %589
store float %590, float* %67
%591 = load float, float* %39
%592 = load float, float* %45
%593 = load float, float* %68
%594 = fsub float %592, %593
%595 = fmul float %591, %594
store float %595, float* %68
%596 = load float, float* %39
%597 = load float, float* %46
%598 = load float, float* %69
%599 = fsub float %597, %598
%600 = fmul float %596, %599
store float %600, float* %69
%601 = load float, float* %40
%602 = load float, float* %41
%603 = fmul float %601, %602
store float %603, float* %44
%604 = load float, float* %42
%605 = load float, float* %41
%606 = fmul float %604, %605
store float %606, float* %45
%607 = load float, float* %47
%608 = load float, float* %47
%609 = load float, float* %48
%610 = load float, float* %48
%611 = fmul float %609, %610
%612 = fneg float %611
%613 = call float @llvm.fmuladd.f32(float %607, float %608, float %612)
store float %613, float* %70
%614 = load float, float* %47
%615 = load float, float* %48
%616 = fmul float %614, %615
store float %616, float* %71
%617 = load float, float* %49
%618 = load float, float* %47
%619 = fmul float %617, %618
store float %619, float* %72
%620 = load float, float* %49
%621 = load float, float* %48
%622 = fmul float %620, %621
store float %622, float* %73
%623 = load float, float* %70
%624 = load float, float* %44
%625 = load float*, float** %19
%626 = load i32, i32* %34
%627 = load i32, i32* %35
%628 = add nsw i32 %626, %627
%629 = sext i32 %628 to i64
%630 = getelementptr inbounds float, float* %625, i64 %629
%631 = load float, float* %630
%632 = call float @llvm.fmuladd.f32(float %623, float %624, float %631)
store float %632, float* %630
%633 = load float, float* %71
%634 = load float, float* %44
%635 = load float*, float** %19
%636 = load i32, i32* %34
%637 = add nsw i32 1, %636
%638 = load i32, i32* %35
%639 = add nsw i32 %637, %638
%640 = sext i32 %639 to i64
%641 = getelementptr inbounds float, float* %635, i64 %640
%642 = load float, float* %641
%643 = call float @llvm.fmuladd.f32(float %633, float %634, float %642)
store float %643, float* %641
%644 = load float, float* %72
%645 = load float, float* %44
%646 = load float*, float** %19
%647 = load i32, i32* %34
%648 = add nsw i32 2, %647
%649 = load i32, i32* %35
%650 = add nsw i32 %648, %649
%651 = sext i32 %650 to i64
%652 = getelementptr inbounds float, float* %646, i64 %651
%653 = load float, float* %652
%654 = call float @llvm.fmuladd.f32(float %644, float %645, float %653)
store float %654, float* %652
%655 = load float, float* %73
%656 = load float, float* %44
%657 = load float*, float** %19
%658 = load i32, i32* %34
%659 = add nsw i32 3, %658
%660 = load i32, i32* %35
%661 = add nsw i32 %659, %660
%662 = sext i32 %661 to i64
%663 = getelementptr inbounds float, float* %657, i64 %662
%664 = load float, float* %663
%665 = call float @llvm.fmuladd.f32(float %655, float %656, float %664)
store float %665, float* %663
%666 = load float, float* %67
%667 = load float, float* %44
%668 = load float*, float** %18
%669 = load i32, i32* %30
%670 = load i32, i32* %31
%671 = add nsw i32 %669, %670
%672 = sext i32 %671 to i64
%673 = getelementptr inbounds float, float* %668, i64 %672
%674 = load float, float* %673
%675 = call float @llvm.fmuladd.f32(float %666, float %667, float %674)
store float %675, float* %673
%676 = load float, float* %68
%677 = load float, float* %44
%678 = load float*, float** %18
%679 = load i32, i32* %30
%680 = add nsw i32 1, %679
%681 = load i32, i32* %31
%682 = add nsw i32 %680, %681
%683 = sext i32 %682 to i64
%684 = getelementptr inbounds float, float* %678, i64 %683
%685 = load float, float* %684
%686 = call float @llvm.fmuladd.f32(float %676, float %677, float %685)
store float %686, float* %684
%687 = load float, float* %69
%688 = load float, float* %44
%689 = load float*, float** %18
%690 = load i32, i32* %30
%691 = add nsw i32 2, %690
%692 = load i32, i32* %31
%693 = add nsw i32 %691, %692
%694 = sext i32 %693 to i64
%695 = getelementptr inbounds float, float* %689, i64 %694
%696 = load float, float* %695
%697 = call float @llvm.fmuladd.f32(float %687, float %688, float %696)
store float %697, float* %695
%698 = load float, float* %47
%699 = load float, float* %44
%700 = load float*, float** %17
%701 = load i32, i32* %30
%702 = load i32, i32* %31
%703 = add nsw i32 %701, %702
%704 = sext i32 %703 to i64
%705 = getelementptr inbounds float, float* %700, i64 %704
%706 = load float, float* %705
%707 = call float @llvm.fmuladd.f32(float %698, float %699, float %706)
store float %707, float* %705
%708 = load float, float* %48
%709 = load float, float* %44
%710 = load float*, float** %17
%711 = load i32, i32* %30
%712 = add nsw i32 1, %711
%713 = load i32, i32* %31
%714 = add nsw i32 %712, %713
%715 = sext i32 %714 to i64
%716 = getelementptr inbounds float, float* %710, i64 %715
%717 = load float, float* %716
%718 = call float @llvm.fmuladd.f32(float %708, float %709, float %717)
store float %718, float* %716
%719 = load float, float* %49
%720 = load float, float* %44
%721 = load float*, float** %17
%722 = load i32, i32* %30
%723 = add nsw i32 2, %722
%724 = load i32, i32* %31
%725 = add nsw i32 %723, %724
%726 = sext i32 %725 to i64
%727 = getelementptr inbounds float, float* %721, i64 %726
%728 = load float, float* %727
%729 = call float @llvm.fmuladd.f32(float %719, float %720, float %728)
store float %729, float* %727
%730 = load float, float* %40
%731 = load float, float* %43
%732 = fmul float %730, %731
store float %732, float* %44
%733 = load float, float* %70
%734 = load float, float* %45
%735 = load float*, float** %19
%736 = load i32, i32* %32
%737 = load i32, i32* %35
%738 = add nsw i32 %736, %737
%739 = sext i32 %738 to i64
%740 = getelementptr inbounds float, float* %735, i64 %739
%741 = load float, float* %740
%742 = call float @llvm.fmuladd.f32(float %733, float %734, float %741)
store float %742, float* %740
%743 = load float, float* %71
%744 = load float, float* %45
%745 = load float*, float** %19
%746 = load i32, i32* %32
%747 = add nsw i32 1, %746
%748 = load i32, i32* %35
%749 = add nsw i32 %747, %748
%750 = sext i32 %749 to i64
%751 = getelementptr inbounds float, float* %745, i64 %750
%752 = load float, float* %751
%753 = call float @llvm.fmuladd.f32(float %743, float %744, float %752)
store float %753, float* %751
%754 = load float, float* %72
%755 = load float, float* %45
%756 = load float*, float** %19
%757 = load i32, i32* %32
%758 = add nsw i32 2, %757
%759 = load i32, i32* %35
%760 = add nsw i32 %758, %759
%761 = sext i32 %760 to i64
%762 = getelementptr inbounds float, float* %756, i64 %761
%763 = load float, float* %762
%764 = call float @llvm.fmuladd.f32(float %754, float %755, float %763)
store float %764, float* %762
%765 = load float, float* %73
%766 = load float, float* %45
%767 = load float*, float** %19
%768 = load i32, i32* %32
%769 = add nsw i32 3, %768
%770 = load i32, i32* %35
%771 = add nsw i32 %769, %770
%772 = sext i32 %771 to i64
%773 = getelementptr inbounds float, float* %767, i64 %772
%774 = load float, float* %773
%775 = call float @llvm.fmuladd.f32(float %765, float %766, float %774)
store float %775, float* %773
%776 = load float, float* %67
%777 = load float, float* %45
%778 = load float*, float** %18
%779 = load i32, i32* %28
%780 = load i32, i32* %31
%781 = add nsw i32 %779, %780
%782 = sext i32 %781 to i64
%783 = getelementptr inbounds float, float* %778, i64 %782
%784 = load float, float* %783
%785 = call float @llvm.fmuladd.f32(float %776, float %777, float %784)
store float %785, float* %783
%786 = load float, float* %68
%787 = load float, float* %45
%788 = load float*, float** %18
%789 = load i32, i32* %28
%790 = add nsw i32 1, %789
%791 = load i32, i32* %31
%792 = add nsw i32 %790, %791
%793 = sext i32 %792 to i64
%794 = getelementptr inbounds float, float* %788, i64 %793
%795 = load float, float* %794
%796 = call float @llvm.fmuladd.f32(float %786, float %787, float %795)
store float %796, float* %794
%797 = load float, float* %69
%798 = load float, float* %45
%799 = load float*, float** %18
%800 = load i32, i32* %28
%801 = add nsw i32 2, %800
%802 = load i32, i32* %31
%803 = add nsw i32 %801, %802
%804 = sext i32 %803 to i64
%805 = getelementptr inbounds float, float* %799, i64 %804
%806 = load float, float* %805
%807 = call float @llvm.fmuladd.f32(float %797, float %798, float %806)
store float %807, float* %805
%808 = load float, float* %47
%809 = load float, float* %45
%810 = load float*, float** %17
%811 = load i32, i32* %28
%812 = load i32, i32* %31
%813 = add nsw i32 %811, %812
%814 = sext i32 %813 to i64
%815 = getelementptr inbounds float, float* %810, i64 %814
%816 = load float, float* %815
%817 = call float @llvm.fmuladd.f32(float %808, float %809, float %816)
store float %817, float* %815
%818 = load float, float* %48
%819 = load float, float* %45
%820 = load float*, float** %17
%821 = load i32, i32* %28
%822 = add nsw i32 1, %821
%823 = load i32, i32* %31
%824 = add nsw i32 %822, %823
%825 = sext i32 %824 to i64
%826 = getelementptr inbounds float, float* %820, i64 %825
%827 = load float, float* %826
%828 = call float @llvm.fmuladd.f32(float %818, float %819, float %827)
store float %828, float* %826
%829 = load float, float* %49
%830 = load float, float* %45
%831 = load float*, float** %17
%832 = load i32, i32* %28
%833 = add nsw i32 2, %832
%834 = load i32, i32* %31
%835 = add nsw i32 %833, %834
%836 = sext i32 %835 to i64
%837 = getelementptr inbounds float, float* %831, i64 %836
%838 = load float, float* %837
%839 = call float @llvm.fmuladd.f32(float %829, float %830, float %838)
store float %839, float* %837
%840 = load float, float* %42
%841 = load float, float* %43
%842 = fmul float %840, %841
store float %842, float* %45
%843 = load float, float* %70
%844 = load float, float* %44
%845 = load float*, float** %19
%846 = load i32, i32* %34
%847 = load i32, i32* %33
%848 = add nsw i32 %846, %847
%849 = sext i32 %848 to i64
%850 = getelementptr inbounds float, float* %845, i64 %849
%851 = load float, float* %850
%852 = call float @llvm.fmuladd.f32(float %843, float %844, float %851)
store float %852, float* %850
%853 = load float, float* %71
%854 = load float, float* %44
%855 = load float*, float** %19
%856 = load i32, i32* %34
%857 = add nsw i32 1, %856
%858 = load i32, i32* %33
%859 = add nsw i32 %857, %858
%860 = sext i32 %859 to i64
%861 = getelementptr inbounds float, float* %855, i64 %860
%862 = load float, float* %861
%863 = call float @llvm.fmuladd.f32(float %853, float %854, float %862)
store float %863, float* %861
%864 = load float, float* %72
%865 = load float, float* %44
%866 = load float*, float** %19
%867 = load i32, i32* %34
%868 = add nsw i32 2, %867
%869 = load i32, i32* %33
%870 = add nsw i32 %868, %869
%871 = sext i32 %870 to i64
%872 = getelementptr inbounds float, float* %866, i64 %871
%873 = load float, float* %872
%874 = call float @llvm.fmuladd.f32(float %864, float %865, float %873)
store float %874, float* %872
%875 = load float, float* %73
%876 = load float, float* %44
%877 = load float*, float** %19
%878 = load i32, i32* %34
%879 = add nsw i32 3, %878
%880 = load i32, i32* %33
%881 = add nsw i32 %879, %880
%882 = sext i32 %881 to i64
%883 = getelementptr inbounds float, float* %877, i64 %882
%884 = load float, float* %883
%885 = call float @llvm.fmuladd.f32(float %875, float %876, float %884)
store float %885, float* %883
%886 = load float, float* %67
%887 = load float, float* %44
%888 = load float*, float** %18
%889 = load i32, i32* %30
%890 = load i32, i32* %29
%891 = add nsw i32 %889, %890
%892 = sext i32 %891 to i64
%893 = getelementptr inbounds float, float* %888, i64 %892
%894 = load float, float* %893
%895 = call float @llvm.fmuladd.f32(float %886, float %887, float %894)
store float %895, float* %893
%896 = load float, float* %68
%897 = load float, float* %44
%898 = load float*, float** %18
%899 = load i32, i32* %30
%900 = add nsw i32 1, %899
%901 = load i32, i32* %29
%902 = add nsw i32 %900, %901
%903 = sext i32 %902 to i64
%904 = getelementptr inbounds float, float* %898, i64 %903
%905 = load float, float* %904
%906 = call float @llvm.fmuladd.f32(float %896, float %897, float %905)
store float %906, float* %904
%907 = load float, float* %69
%908 = load float, float* %44
%909 = load float*, float** %18
%910 = load i32, i32* %30
%911 = add nsw i32 2, %910
%912 = load i32, i32* %29
%913 = add nsw i32 %911, %912
%914 = sext i32 %913 to i64
%915 = getelementptr inbounds float, float* %909, i64 %914
%916 = load float, float* %915
%917 = call float @llvm.fmuladd.f32(float %907, float %908, float %916)
store float %917, float* %915
%918 = load float, float* %47
%919 = load float, float* %44
%920 = load float*, float** %17
%921 = load i32, i32* %30
%922 = load i32, i32* %29
%923 = add nsw i32 %921, %922
%924 = sext i32 %923 to i64
%925 = getelementptr inbounds float, float* %920, i64 %924
%926 = load float, float* %925
%927 = call float @llvm.fmuladd.f32(float %918, float %919, float %926)
store float %927, float* %925
%928 = load float, float* %48
%929 = load float, float* %44
%930 = load float*, float** %17
%931 = load i32, i32* %30
%932 = add nsw i32 1, %931
%933 = load i32, i32* %29
%934 = add nsw i32 %932, %933
%935 = sext i32 %934 to i64
%936 = getelementptr inbounds float, float* %930, i64 %935
%937 = load float, float* %936
%938 = call float @llvm.fmuladd.f32(float %928, float %929, float %937)
store float %938, float* %936
%939 = load float, float* %49
%940 = load float, float* %44
%941 = load float*, float** %17
%942 = load i32, i32* %30
%943 = add nsw i32 2, %942
%944 = load i32, i32* %29
%945 = add nsw i32 %943, %944
%946 = sext i32 %945 to i64
%947 = getelementptr inbounds float, float* %941, i64 %946
%948 = load float, float* %947
%949 = call float @llvm.fmuladd.f32(float %939, float %940, float %948)
store float %949, float* %947
%950 = load float, float* %70
%951 = load float, float* %45
%952 = load float*, float** %19
%953 = load i32, i32* %32
%954 = load i32, i32* %33
%955 = add nsw i32 %953, %954
%956 = sext i32 %955 to i64
%957 = getelementptr inbounds float, float* %952, i64 %956
%958 = load float, float* %957
%959 = call float @llvm.fmuladd.f32(float %950, float %951, float %958)
store float %959, float* %957
%960 = load float, float* %71
%961 = load float, float* %45
%962 = load float*, float** %19
%963 = load i32, i32* %32
%964 = add nsw i32 1, %963
%965 = load i32, i32* %33
%966 = add nsw i32 %964, %965
%967 = sext i32 %966 to i64
%968 = getelementptr inbounds float, float* %962, i64 %967
%969 = load float, float* %968
%970 = call float @llvm.fmuladd.f32(float %960, float %961, float %969)
store float %970, float* %968
%971 = load float, float* %72
%972 = load float, float* %45
%973 = load float*, float** %19
%974 = load i32, i32* %32
%975 = add nsw i32 2, %974
%976 = load i32, i32* %33
%977 = add nsw i32 %975, %976
%978 = sext i32 %977 to i64
%979 = getelementptr inbounds float, float* %973, i64 %978
%980 = load float, float* %979
%981 = call float @llvm.fmuladd.f32(float %971, float %972, float %980)
store float %981, float* %979
%982 = load float, float* %73
%983 = load float, float* %45
%984 = load float*, float** %19
%985 = load i32, i32* %32
%986 = add nsw i32 3, %985
%987 = load i32, i32* %33
%988 = add nsw i32 %986, %987
%989 = sext i32 %988 to i64
%990 = getelementptr inbounds float, float* %984, i64 %989
%991 = load float, float* %990
%992 = call float @llvm.fmuladd.f32(float %982, float %983, float %991)
store float %992, float* %990
%993 = load float, float* %67
%994 = load float, float* %45
%995 = load float*, float** %18
%996 = load i32, i32* %28
%997 = load i32, i32* %29
%998 = add nsw i32 %996, %997
%999 = sext i32 %998 to i64
%1000 = getelementptr inbounds float, float* %995, i64 %999
%1001 = load float, float* %1000
%1002 = call float @llvm.fmuladd.f32(float %993, float %994, float %1001)
store float %1002, float* %1000
%1003 = load float, float* %68
%1004 = load float, float* %45
%1005 = load float*, float** %18
%1006 = load i32, i32* %28
%1007 = add nsw i32 1, %1006
%1008 = load i32, i32* %29
%1009 = add nsw i32 %1007, %1008
%1010 = sext i32 %1009 to i64
%1011 = getelementptr inbounds float, float* %1005, i64 %1010
%1012 = load float, float* %1011
%1013 = call float @llvm.fmuladd.f32(float %1003, float %1004, float %1012)
store float %1013, float* %1011
%1014 = load float, float* %69
%1015 = load float, float* %45
%1016 = load float*, float** %18
%1017 = load i32, i32* %28
%1018 = add nsw i32 2, %1017
%1019 = load i32, i32* %29
%1020 = add nsw i32 %1018, %1019
%1021 = sext i32 %1020 to i64
%1022 = getelementptr inbounds float, float* %1016, i64 %1021
%1023 = load float, float* %1022
%1024 = call float @llvm.fmuladd.f32(float %1014, float %1015, float %1023)
store float %1024, float* %1022
%1025 = load float, float* %47
%1026 = load float, float* %45
%1027 = load float*, float** %17
%1028 = load i32, i32* %28
%1029 = load i32, i32* %29
%1030 = add nsw i32 %1028, %1029
%1031 = sext i32 %1030 to i64
%1032 = getelementptr inbounds float, float* %1027, i64 %1031
%1033 = load float, float* %1032
%1034 = call float @llvm.fmuladd.f32(float %1025, float %1026, float %1033)
store float %1034, float* %1032
%1035 = load float, float* %48
%1036 = load float, float* %45
%1037 = load float*, float** %17
%1038 = load i32, i32* %28
%1039 = add nsw i32 1, %1038
%1040 = load i32, i32* %29
%1041 = add nsw i32 %1039, %1040
%1042 = sext i32 %1041 to i64
%1043 = getelementptr inbounds float, float* %1037, i64 %1042
%1044 = load float, float* %1043
%1045 = call float @llvm.fmuladd.f32(float %1035, float %1036, float %1044)
store float %1045, float* %1043
%1046 = load float, float* %49
%1047 = load float, float* %45
%1048 = load float*, float** %17
%1049 = load i32, i32* %28
%1050 = add nsw i32 2, %1049
%1051 = load i32, i32* %29
%1052 = add nsw i32 %1050, %1051
%1053 = sext i32 %1052 to i64
%1054 = getelementptr inbounds float, float* %1048, i64 %1053
%1055 = load float, float* %1054
%1056 = call float @llvm.fmuladd.f32(float %1046, float %1047, float %1055)
store float %1056, float* %1054
br label %1057
1057: ; preds = %93
%1058 = load i32, i32* %27
%1059 = add nsw i32 %1058, 1
store i32 %1059, i32* %27
br label %89
1060: ; preds = %89
ret void
}

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