void cgdjpost2l(float part[], float fxy[], float bxy[], 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;
    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;
    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;
    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;
  }
  return;
}


x86 assembly (clang, -O0):
<cgdjpost2l>:
push   %rbp
mov    %rsp,%rbp
sub    $0x78,%rsp
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)
movss  %xmm0,-0x2c(%rbp)
movss  %xmm1,-0x30(%rbp)
movss  %xmm2,-0x34(%rbp)
mov    %r9d,-0x38(%rbp)
imul   $0x3,0x18(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    0x18(%rbp),%eax
shl    $0x2,%eax
mov    %eax,-0x64(%rbp)
movss  -0x30(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x1eaf(%rip),%xmm0
mulsd  %xmm1,%xmm0
movss  -0x34(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x68(%rbp)
movss  -0x34(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x1e7c(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x6c(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    214d <cgdjpost2l+0x104d>
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%ecx
imul   -0x3c(%rbp),%ecx
movslq %ecx,%rcx
cvttss2si (%rax,%rcx,4),%eax
mov    %eax,-0x50(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%ecx
imul   -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
cvttss2si (%rax,%rcx,4),%eax
mov    %eax,-0x54(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%ecx
imul   -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtsi2ssl -0x50(%rbp),%xmm1
subss  %xmm1,%xmm0
movss  %xmm0,-0x70(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%ecx
imul   -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtsi2ssl -0x54(%rbp),%xmm1
subss  %xmm1,%xmm0
movss  %xmm0,-0x74(%rbp)
imul   $0x3,-0x50(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x60(%rbp),%eax
imul   -0x54(%rbp),%eax
mov    %eax,-0x44(%rbp)
movss  -0x70(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x1dc6(%rip),%xmm0
subsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x78(%rbp)
mov    -0x44(%rbp),%eax
add    -0x60(%rbp),%eax
mov    %eax,-0x4c(%rbp)
movss  -0x74(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x1d9f(%rip),%xmm0
subsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x7c(%rbp)
mov    -0x40(%rbp),%eax
add    $0x3,%eax
mov    %eax,-0x48(%rbp)
mov    -0x50(%rbp),%eax
shl    $0x2,%eax
mov    %eax,-0x50(%rbp)
mov    -0x64(%rbp),%eax
imul   -0x54(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%eax
add    -0x64(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x50(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x58(%rbp)
movss  -0x74(%rbp),%xmm0
movss  -0x70(%rbp),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%ecx
add    -0x4c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm3
movss  -0x78(%rbp),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    -0x4c(%rbp),%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm1
mulss  %xmm3,%xmm2
addss  %xmm1,%xmm2
movss  -0x7c(%rbp),%xmm1
movss  -0x70(%rbp),%xmm3
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm5
movss  -0x78(%rbp),%xmm4
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    -0x44(%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,-0x80(%rbp)
movss  -0x74(%rbp),%xmm0
movss  -0x70(%rbp),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%ecx
add    $0x1,%ecx
add    -0x4c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm3
movss  -0x78(%rbp),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    $0x1,%ecx
add    -0x4c(%rbp),%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm1
mulss  %xmm3,%xmm2
addss  %xmm1,%xmm2
movss  -0x7c(%rbp),%xmm1
movss  -0x70(%rbp),%xmm3
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%ecx
add    $0x1,%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm5
movss  -0x78(%rbp),%xmm4
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    $0x1,%ecx
add    -0x44(%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  -0x74(%rbp),%xmm0
movss  -0x70(%rbp),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%ecx
add    $0x2,%ecx
add    -0x4c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm3
movss  -0x78(%rbp),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    $0x2,%ecx
add    -0x4c(%rbp),%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm1
mulss  %xmm3,%xmm2
addss  %xmm1,%xmm2
movss  -0x7c(%rbp),%xmm1
movss  -0x70(%rbp),%xmm3
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%ecx
add    $0x2,%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm5
movss  -0x78(%rbp),%xmm4
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    $0x2,%ecx
add    -0x44(%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  -0x74(%rbp),%xmm0
movss  -0x70(%rbp),%xmm2
mov    -0x18(%rbp),%rax
mov    -0x48(%rbp),%ecx
add    -0x4c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm3
movss  -0x78(%rbp),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    -0x4c(%rbp),%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm1
mulss  %xmm3,%xmm2
addss  %xmm1,%xmm2
movss  -0x7c(%rbp),%xmm1
movss  -0x70(%rbp),%xmm3
mov    -0x18(%rbp),%rax
mov    -0x48(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm5
movss  -0x78(%rbp),%xmm4
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    -0x44(%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  -0x74(%rbp),%xmm0
movss  -0x70(%rbp),%xmm2
mov    -0x18(%rbp),%rax
mov    -0x48(%rbp),%ecx
add    $0x1,%ecx
add    -0x4c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm3
movss  -0x78(%rbp),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    $0x1,%ecx
add    -0x4c(%rbp),%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm1
mulss  %xmm3,%xmm2
addss  %xmm1,%xmm2
movss  -0x7c(%rbp),%xmm1
movss  -0x70(%rbp),%xmm3
mov    -0x18(%rbp),%rax
mov    -0x48(%rbp),%ecx
add    $0x1,%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm5
movss  -0x78(%rbp),%xmm4
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    $0x1,%ecx
add    -0x44(%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  -0x74(%rbp),%xmm0
movss  -0x70(%rbp),%xmm2
mov    -0x18(%rbp),%rax
mov    -0x48(%rbp),%ecx
add    $0x2,%ecx
add    -0x4c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm3
movss  -0x78(%rbp),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    $0x2,%ecx
add    -0x4c(%rbp),%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm1
mulss  %xmm3,%xmm2
addss  %xmm1,%xmm2
movss  -0x7c(%rbp),%xmm1
movss  -0x70(%rbp),%xmm3
mov    -0x18(%rbp),%rax
mov    -0x48(%rbp),%ecx
add    $0x2,%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm5
movss  -0x78(%rbp),%xmm4
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    $0x2,%ecx
add    -0x44(%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  -0x68(%rbp),%xmm0
mulss  -0x80(%rbp),%xmm0
movss  %xmm0,-0x80(%rbp)
movss  -0x68(%rbp),%xmm0
mulss  -0x84(%rbp),%xmm0
ff
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x68(%rbp),%xmm0
mulss  -0x88(%rbp),%xmm0
ff
movss  %xmm0,-0x88(%rbp)
ff
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%ecx
imul   -0x3c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0xdc(%rbp)
ff
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%ecx
imul   -0x3c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0xe0(%rbp)
ff
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%ecx
imul   -0x3c(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0xe4(%rbp)
ff
movss  -0xdc(%rbp),%xmm0
ff
addss  -0x80(%rbp),%xmm0
movss  %xmm0,-0x98(%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  -0x68(%rbp),%xmm0
mulss  -0x8c(%rbp),%xmm0
ff
movss  %xmm0,-0xa4(%rbp)
ff
movss  -0x68(%rbp),%xmm0
mulss  -0x90(%rbp),%xmm0
ff
movss  %xmm0,-0xa8(%rbp)
ff
movss  -0x68(%rbp),%xmm0
mulss  -0x94(%rbp),%xmm0
ff
movss  %xmm0,-0xac(%rbp)
ff
movss  -0xa4(%rbp),%xmm1
ff
movss  -0xa4(%rbp),%xmm2
ff
movss  -0xa8(%rbp),%xmm0
ff
mulss  -0xa8(%rbp),%xmm0
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0xac(%rbp),%xmm0
ff
movss  -0xac(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xb0(%rbp)
ff
movss  -0xb0(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movsd  0x1888(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0x188c(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0xb4(%rbp)
ff
movss  -0xb0(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movsd  0x1858(%rip),%xmm1
subsd  %xmm0,%xmm1
movsd  0x1854(%rip),%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0xb0(%rbp)
ff
movss  -0xa4(%rbp),%xmm0
ff
mulss  -0xa8(%rbp),%xmm0
ff
movss  %xmm0,-0xc4(%rbp)
ff
movss  -0xa4(%rbp),%xmm0
ff
mulss  -0xac(%rbp),%xmm0
ff
movss  %xmm0,-0xd0(%rbp)
ff
movss  -0xa8(%rbp),%xmm0
ff
mulss  -0xac(%rbp),%xmm0
ff
movss  %xmm0,-0xd4(%rbp)
ff
movss  -0xb0(%rbp),%xmm1
ff
movss  -0xa4(%rbp),%xmm0
ff
movss  -0xa4(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xb8(%rbp)
ff
movss  -0xb0(%rbp),%xmm1
ff
movss  -0xa8(%rbp),%xmm0
ff
movss  -0xa8(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xc8(%rbp)
ff
movss  -0xb0(%rbp),%xmm1
ff
movss  -0xac(%rbp),%xmm0
ff
movss  -0xac(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xd8(%rbp)
ff
movss  -0xac(%rbp),%xmm0
ff
addss  -0xc4(%rbp),%xmm0
ff
movss  %xmm0,-0xbc(%rbp)
ff
movss  -0xac(%rbp),%xmm1
ff
movss  -0xc4(%rbp),%xmm0
ff
subss  %xmm1,%xmm0
movss  %xmm0,-0xc4(%rbp)
ff
movss  -0xa8(%rbp),%xmm0
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
addss  -0xd0(%rbp),%xmm0
ff
movss  %xmm0,-0xc0(%rbp)
ff
movss  -0xa8(%rbp),%xmm0
ff
addss  -0xd0(%rbp),%xmm0
ff
movss  %xmm0,-0xd0(%rbp)
ff
movss  -0xa4(%rbp),%xmm0
ff
addss  -0xd4(%rbp),%xmm0
ff
movss  %xmm0,-0xcc(%rbp)
ff
movss  -0xa4(%rbp),%xmm1
ff
movss  -0xd4(%rbp),%xmm0
ff
subss  %xmm1,%xmm0
movss  %xmm0,-0xd4(%rbp)
ff
movss  -0xb8(%rbp),%xmm1
ff
movss  -0x98(%rbp),%xmm2
ff
movss  -0xbc(%rbp),%xmm0
ff
mulss  -0x9c(%rbp),%xmm0
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0xc0(%rbp),%xmm0
ff
movss  -0xa0(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0xb4(%rbp),%xmm2
ff
movss  -0x80(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x80(%rbp)
movss  -0xc4(%rbp),%xmm1
ff
movss  -0x98(%rbp),%xmm2
ff
movss  -0xc8(%rbp),%xmm0
ff
mulss  -0x9c(%rbp),%xmm0
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0xcc(%rbp),%xmm0
ff
movss  -0xa0(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0xb4(%rbp),%xmm2
ff
movss  -0x84(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x84(%rbp)
ff
movss  -0xd0(%rbp),%xmm1
ff
movss  -0x98(%rbp),%xmm2
ff
movss  -0xd4(%rbp),%xmm0
ff
mulss  -0x9c(%rbp),%xmm0
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0xd8(%rbp),%xmm0
ff
movss  -0xa0(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0xb4(%rbp),%xmm2
ff
movss  -0x88(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x88(%rbp)
ff
movss  -0x2c(%rbp),%xmm0
mulss  -0x78(%rbp),%xmm0
movss  %xmm0,-0x78(%rbp)
movss  -0x2c(%rbp),%xmm0
mulss  -0x70(%rbp),%xmm0
movss  %xmm0,-0x70(%rbp)
movss  -0x80(%rbp),%xmm0
addss  -0xdc(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm1
movsd  0x158e(%rip),%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
movss  -0x84(%rbp),%xmm0
ff
addss  -0xe0(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm1
movsd  0x1562(%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  0x1536(%rip),%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x94(%rbp)
ff
movss  -0x6c(%rbp),%xmm0
movss  -0x80(%rbp),%xmm1
subss  -0xdc(%rbp),%xmm1
ff
mulss  %xmm1,%xmm0
movss  %xmm0,-0xdc(%rbp)
ff
movss  -0x6c(%rbp),%xmm0
movss  -0x84(%rbp),%xmm1
ff
subss  -0xe0(%rbp),%xmm1
ff
mulss  %xmm1,%xmm0
movss  %xmm0,-0xe0(%rbp)
ff
movss  -0x6c(%rbp),%xmm0
movss  -0x88(%rbp),%xmm1
ff
subss  -0xe4(%rbp),%xmm1
ff
mulss  %xmm1,%xmm0
movss  %xmm0,-0xe4(%rbp)
ff
movss  -0x70(%rbp),%xmm0
mulss  -0x74(%rbp),%xmm0
movss  %xmm0,-0x80(%rbp)
movss  -0x78(%rbp),%xmm0
mulss  -0x74(%rbp),%xmm0
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x8c(%rbp),%xmm0
ff
movss  -0x8c(%rbp),%xmm2
ff
movss  -0x90(%rbp),%xmm1
ff
mulss  -0x90(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xe8(%rbp)
ff
movss  -0x8c(%rbp),%xmm0
ff
mulss  -0x90(%rbp),%xmm0
ff
movss  %xmm0,-0xec(%rbp)
ff
movss  -0x94(%rbp),%xmm0
ff
mulss  -0x8c(%rbp),%xmm0
ff
movss  %xmm0,-0xf0(%rbp)
ff
movss  -0x94(%rbp),%xmm0
ff
mulss  -0x90(%rbp),%xmm0
ff
movss  %xmm0,-0xf4(%rbp)
ff
movss  -0xe8(%rbp),%xmm0
ff
movss  -0x80(%rbp),%xmm2
mov    -0x28(%rbp),%rax
mov    -0x58(%rbp),%ecx
add    -0x5c(%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  -0x80(%rbp),%xmm2
mov    -0x28(%rbp),%rax
mov    -0x58(%rbp),%ecx
add    $0x1,%ecx
add    -0x5c(%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  -0x80(%rbp),%xmm2
mov    -0x28(%rbp),%rax
mov    -0x58(%rbp),%ecx
add    $0x2,%ecx
add    -0x5c(%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  -0x80(%rbp),%xmm2
mov    -0x28(%rbp),%rax
mov    -0x58(%rbp),%ecx
add    $0x3,%ecx
add    -0x5c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0xdc(%rbp),%xmm0
ff
movss  -0x80(%rbp),%xmm2
mov    -0x20(%rbp),%rax
mov    -0x48(%rbp),%ecx
add    -0x4c(%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  -0x80(%rbp),%xmm2
mov    -0x20(%rbp),%rax
mov    -0x48(%rbp),%ecx
add    $0x1,%ecx
add    -0x4c(%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  -0x80(%rbp),%xmm2
mov    -0x20(%rbp),%rax
mov    -0x48(%rbp),%ecx
add    $0x2,%ecx
add    -0x4c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0x70(%rbp),%xmm0
mulss  -0x7c(%rbp),%xmm0
movss  %xmm0,-0x80(%rbp)
movss  -0xe8(%rbp),%xmm0
ff
movss  -0x84(%rbp),%xmm2
ff
mov    -0x28(%rbp),%rax
mov    -0x50(%rbp),%ecx
add    -0x5c(%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  -0x84(%rbp),%xmm2
ff
mov    -0x28(%rbp),%rax
mov    -0x50(%rbp),%ecx
add    $0x1,%ecx
add    -0x5c(%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    -0x28(%rbp),%rax
mov    -0x50(%rbp),%ecx
add    $0x2,%ecx
add    -0x5c(%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    -0x28(%rbp),%rax
mov    -0x50(%rbp),%ecx
add    $0x3,%ecx
add    -0x5c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0xdc(%rbp),%xmm0
ff
movss  -0x84(%rbp),%xmm2
ff
mov    -0x20(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    -0x4c(%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    -0x20(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    $0x1,%ecx
add    -0x4c(%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    -0x20(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    $0x2,%ecx
add    -0x4c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0x78(%rbp),%xmm0
mulss  -0x7c(%rbp),%xmm0
movss  %xmm0,-0x84(%rbp)
ff
movss  -0xe8(%rbp),%xmm0
ff
movss  -0x80(%rbp),%xmm2
mov    -0x28(%rbp),%rax
mov    -0x58(%rbp),%ecx
add    -0x54(%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  -0x80(%rbp),%xmm2
mov    -0x28(%rbp),%rax
mov    -0x58(%rbp),%ecx
add    $0x1,%ecx
add    -0x54(%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  -0x80(%rbp),%xmm2
mov    -0x28(%rbp),%rax
mov    -0x58(%rbp),%ecx
add    $0x2,%ecx
add    -0x54(%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  -0x80(%rbp),%xmm2
mov    -0x28(%rbp),%rax
mov    -0x58(%rbp),%ecx
add    $0x3,%ecx
add    -0x54(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0xdc(%rbp),%xmm0
ff
movss  -0x80(%rbp),%xmm2
mov    -0x20(%rbp),%rax
mov    -0x48(%rbp),%ecx
add    -0x44(%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  -0x80(%rbp),%xmm2
mov    -0x20(%rbp),%rax
mov    -0x48(%rbp),%ecx
add    $0x1,%ecx
add    -0x44(%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  -0x80(%rbp),%xmm2
mov    -0x20(%rbp),%rax
mov    -0x48(%rbp),%ecx
add    $0x2,%ecx
add    -0x44(%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    -0x50(%rbp),%ecx
add    -0x54(%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  -0x84(%rbp),%xmm2
ff
mov    -0x28(%rbp),%rax
mov    -0x50(%rbp),%ecx
add    $0x1,%ecx
add    -0x54(%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    -0x28(%rbp),%rax
mov    -0x50(%rbp),%ecx
add    $0x2,%ecx
add    -0x54(%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    -0x28(%rbp),%rax
mov    -0x50(%rbp),%ecx
add    $0x3,%ecx
add    -0x54(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0xdc(%rbp),%xmm0
ff
movss  -0x84(%rbp),%xmm2
ff
mov    -0x20(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    -0x44(%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    -0x20(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    $0x1,%ecx
add    -0x44(%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    -0x20(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    $0x2,%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1198 <cgdjpost2l+0x98>
add    $0x78,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<cgdjpost2l>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
mov    %r9d,%eax
mov    %rcx,%r9
mov    0x80(%rsp),%ecx
test   %ecx,%ecx
jle    17d9 <cgdjpost2l+0x6d9>
movaps %xmm0,%xmm4
mov    0x88(%rsp),%ebp
lea    0x0(%rbp,%rbp,2),%ebx
mov    %rbx,-0x50(%rsp)
shl    $0x2,%ebp
mov    %rbp,-0x48(%rsp)
cvtss2sd %xmm1,%xmm1
mulsd  0xeb6(%rip),%xmm1
cvtss2sd %xmm2,%xmm3
mulsd  %xmm1,%xmm3
xorps  %xmm0,%xmm0
cvtsd2ss %xmm3,%xmm0
movss  0xeb7(%rip),%xmm1
divss  %xmm2,%xmm1
movss  %xmm1,-0x78(%rsp)
movslq %eax,%rbp
mov    %ecx,%eax
movaps %xmm0,(%rsp)
shufps $0x0,%xmm0,%xmm0
movaps %xmm0,-0x10(%rsp)
add    $0x10,%rdi
shl    $0x2,%rbp
mov    %rbp,-0x58(%rsp)
movss  %xmm4,-0x74(%rsp)
mov    %rdx,-0x60(%rsp)
cs nopw 0x0(%rax,%rax,1)
nop
mov    %rax,-0x18(%rsp)
mov    %rdi,-0x80(%rsp)
movss  -0xc(%rdi),%xmm3
movss  -0x10(%rdi),%xmm6
cvttss2si %xmm3,%edx
mov    %rdx,-0x28(%rsp)
cvttss2si %xmm6,%edi
cvttps2dq %xmm6,%xmm1
cvtdq2ps %xmm1,%xmm1
subss  %xmm1,%xmm6
cvttps2dq %xmm3,%xmm1
cvtdq2ps %xmm1,%xmm1
lea    (%rdi,%rdi,2),%r12d
mov    -0x50(%rsp),%rax
mov    %eax,%ebp
subss  %xmm1,%xmm3
imul   %edx,%ebp
movss  0xe2b(%rip),%xmm0
movaps %xmm0,%xmm15
subss  %xmm6,%xmm15
lea    (%rax,%rbp,1),%r11d
subss  %xmm3,%xmm0
lea    (%rdi,%rdi,2),%r10d
add    $0x3,%r10d
add    %r11d,%r10d
lea    (%r12,%rbp,1),%r14d
add    $0x3,%r14d
lea    (%r11,%r12,1),%eax
movslq %r14d,%rcx
mov    %rcx,-0x68(%rsp)
lea    0x4(%rbp,%r12,1),%r15d
lea    0x1(%rbp,%r12,1),%r14d
movslq %r10d,%r10
lea    (%r12,%rbp,1),%edx
add    $0x5,%edx
lea    (%r12,%rbp,1),%ebx
add    $0x2,%ebx
add    %r12d,%ebp
movslq %eax,%r12
movslq %ebp,%rcx
lea    (%rdi,%rdi,2),%ebp
add    $0x4,%ebp
add    %r11d,%ebp
movslq %ebp,%r13
lea    (%rdi,%rdi,2),%ebp
add    $0x1,%ebp
add    %r11d,%ebp
movslq %ebp,%rbp
mov    %rbp,-0x70(%rsp)
movss  (%rsi,%rbp,4),%xmm5
movss  (%rsi,%r12,4),%xmm13
movaps %xmm6,%xmm12
shufps $0x0,%xmm6,%xmm12
movss  (%rsi,%r13,4),%xmm9
movss  (%rsi,%r10,4),%xmm8
movaps %xmm15,%xmm1
movslq %r15d,%r15
movslq %r14d,%r14
movss  (%rsi,%rcx,4),%xmm2
mov    %rcx,%rax
mov    %rcx,-0x20(%rsp)
shufps $0x0,%xmm15,%xmm1
movss  (%rsi,%r14,4),%xmm7
mov    %r14,-0x30(%rsp)
unpcklps %xmm7,%xmm2
movss  (%rsi,%r15,4),%xmm7
unpcklps %xmm5,%xmm13
mov    -0x68(%rsp),%rcx
movss  (%rsi,%rcx,4),%xmm10
unpcklps %xmm7,%xmm10
movaps %xmm3,%xmm4
shufps $0x0,%xmm3,%xmm4
unpcklps %xmm9,%xmm8
lea    (%rdi,%rdi,2),%ebp
add    $0x5,%ebp
add    %r11d,%ebp
movslq %ebp,%rbp
mov    %rbp,-0x40(%rsp)
mulps  %xmm1,%xmm2
lea    (%rdi,%rdi,2),%ebp
add    $0x2,%ebp
add    %r11d,%ebp
movslq %ebp,%r11
mulps  %xmm12,%xmm10
movss  (%rsi,%r11,4),%xmm11
mulss  %xmm15,%xmm11
movslq %edx,%rbp
mov    -0x60(%rsp),%rdx
mulps  %xmm1,%xmm13
movslq %ebx,%rbx
movss  (%rsi,%rbx,4),%xmm7
mov    %rbx,-0x38(%rsp)
mulss  %xmm15,%xmm7
mulps  %xmm12,%xmm8
movss  (%rsi,%rbp,4),%xmm1
mulss  %xmm6,%xmm1
addss  %xmm7,%xmm1
addps  %xmm2,%xmm10
movss  (%rdx,%rax,4),%xmm2
mulss  %xmm15,%xmm2
movss  (%rdx,%rcx,4),%xmm14
addps  %xmm13,%xmm8
mulss  %xmm6,%xmm14
addss  %xmm2,%xmm14
movss  (%rdx,%r14,4),%xmm7
mulss  %xmm0,%xmm1
mulss  %xmm15,%xmm7
movss  (%rdx,%r15,4),%xmm13
mulss  %xmm6,%xmm13
mulss  %xmm0,%xmm14
movaps %xmm0,%xmm2
movaps %xmm0,0x30(%rsp)
addss  %xmm7,%xmm13
movss  (%rdx,%rbx,4),%xmm7
mulss  %xmm15,%xmm7
mulss  %xmm0,%xmm13
movss  (%rdx,%rbp,4),%xmm0
mov    %rbp,%r14
mulss  %xmm6,%xmm0
addss  %xmm7,%xmm0
mulss  %xmm2,%xmm0
movaps %xmm2,%xmm7
mov    -0x40(%rsp),%rcx
movss  (%rsi,%rcx,4),%xmm9
mulss  %xmm6,%xmm9
addss  %xmm11,%xmm9
shufps $0x0,%xmm2,%xmm7
movaps %xmm3,0x20(%rsp)
mulss  %xmm3,%xmm9
movss  (%rdx,%r12,4),%xmm2
mulss  %xmm15,%xmm2
mulps  %xmm10,%xmm7
movss  (%rdx,%r10,4),%xmm12
mulss  %xmm6,%xmm12
addss  %xmm2,%xmm12
mulps  %xmm8,%xmm4
mulss  %xmm3,%xmm12
mov    -0x70(%rsp),%rax
movss  (%rdx,%rax,4),%xmm2
mulss  %xmm15,%xmm2
addss  %xmm1,%xmm9
movss  (%rdx,%r13,4),%xmm1
mulss  %xmm6,%xmm1
addss  %xmm2,%xmm1
addss  %xmm14,%xmm12
mulss  %xmm3,%xmm1
movss  (%rdx,%r11,4),%xmm2
mulss  %xmm15,%xmm2
addss  %xmm13,%xmm1
movss  (%rdx,%rcx,4),%xmm8
mulss  %xmm6,%xmm8
addss  %xmm2,%xmm8
addps  %xmm7,%xmm4
movaps %xmm4,0x10(%rsp)
mulss  %xmm3,%xmm8
addss  %xmm0,%xmm8
movaps (%rsp),%xmm5
mulss  %xmm5,%xmm12
mulss  %xmm5,%xmm1
mulss  %xmm5,%xmm8
movaps %xmm12,%xmm14
mulss  %xmm1,%xmm14
movaps %xmm12,%xmm13
mulss  %xmm8,%xmm13
movaps %xmm1,%xmm3
movaps %xmm1,%xmm10
addss  %xmm13,%xmm10
subss  %xmm1,%xmm13
mulss  %xmm1,%xmm1
movaps %xmm12,%xmm11
mulss  %xmm8,%xmm3
mulss  %xmm12,%xmm11
movaps %xmm14,%xmm7
movaps %xmm11,%xmm0
addss  %xmm8,%xmm7
subss  %xmm8,%xmm14
mulss  %xmm8,%xmm8
addss  %xmm1,%xmm0
addss  %xmm8,%xmm0
xorps  %xmm2,%xmm2
cvtss2sd %xmm0,%xmm2
movsd  0xb4c(%rip),%xmm4
movapd %xmm4,%xmm0
subsd  %xmm2,%xmm0
addsd  %xmm4,%xmm2
movsd  0xb40(%rip),%xmm4
divsd  %xmm2,%xmm4
mulsd  0xb24(%rip),%xmm0
cvtsd2ss %xmm0,%xmm0
addss  %xmm0,%xmm11
addss  %xmm0,%xmm1
addss  %xmm0,%xmm8
unpcklps %xmm1,%xmm7
unpcklps %xmm3,%xmm0
subss  %xmm12,%xmm3
unpcklps %xmm12,%xmm2
movaps 0x10(%rsp),%xmm1
mulps  -0x10(%rsp),%xmm1
mulss  %xmm5,%xmm9
addps  %xmm2,%xmm0
mov    -0x80(%rsp),%rax
movsd  -0x8(%rax),%xmm12
unpcklps %xmm14,%xmm11
movaps %xmm1,%xmm2
movaps %xmm1,%xmm5
addps  %xmm12,%xmm2
shufps $0x1,%xmm13,%xmm0
shufps $0xe2,%xmm13,%xmm0
movaps %xmm2,%xmm1
mulss  %xmm2,%xmm10
shufps $0x0,%xmm2,%xmm2
mulps  %xmm11,%xmm2
mov    -0x80(%rsp),%rax
movss  (%rax),%xmm11
shufps $0x55,%xmm1,%xmm1
mulps  %xmm1,%xmm7
addps  %xmm7,%xmm2
movaps %xmm9,%xmm7
addss  %xmm11,%xmm7
mulss  %xmm7,%xmm8
shufps $0x0,%xmm7,%xmm7
mulps  %xmm0,%xmm7
mulss  %xmm1,%xmm3
addps  %xmm2,%xmm7
addss  %xmm10,%xmm3
mov    -0x48(%rsp),%rax
mov    -0x28(%rsp),%rbx
imul   %eax,%ebx
xorps  %xmm0,%xmm0
cvtsd2ss %xmm4,%xmm0
movss  -0x74(%rsp),%xmm4
lea    (%rbx,%rax,1),%ebp
addss  %xmm8,%xmm3
mulss  %xmm0,%xmm3
movaps %xmm0,%xmm8
shufps $0x0,%xmm0,%xmm8
mulps  %xmm7,%xmm8
addss  %xmm9,%xmm3
mulss  %xmm4,%xmm6
movaps %xmm12,%xmm10
addps  %xmm5,%xmm8
addps  %xmm8,%xmm10
movaps %xmm11,%xmm5
addss  %xmm3,%xmm5
mulss  0xa4d(%rip),%xmm5
mulps  0xa49(%rip),%xmm10
movaps %xmm10,%xmm0
movaps %xmm10,%xmm9
unpcklps %xmm5,%xmm5
mulps  %xmm10,%xmm5
shufps $0x55,%xmm10,%xmm10
mulss  %xmm10,%xmm0
mulss  %xmm10,%xmm10
mulss  %xmm9,%xmm9
subss  %xmm10,%xmm9
movaps %xmm6,%xmm2
movaps 0x20(%rsp),%xmm7
mulss  %xmm7,%xmm2
unpcklps %xmm0,%xmm9
lea    0x4(%rbp,%rdi,4),%eax
cltq
movlhps %xmm5,%xmm9
movups (%r8,%rax,4),%xmm0
movaps %xmm2,%xmm1
shufps $0x0,%xmm2,%xmm1
mulps  %xmm9,%xmm1
addps  %xmm0,%xmm1
movups %xmm1,(%r8,%rax,4)
subps  %xmm12,%xmm8
movss  -0x78(%rsp),%xmm5
movaps %xmm5,%xmm1
mulss  %xmm8,%xmm1
movaps %xmm1,%xmm0
mulss  %xmm2,%xmm0
addss  (%r9,%r10,4),%xmm0
movss  %xmm0,(%r9,%r10,4)
shufps $0x55,%xmm8,%xmm8
mulss  %xmm5,%xmm8
movaps %xmm8,%xmm0
mulss  %xmm2,%xmm0
addss  (%r9,%r13,4),%xmm0
movss  %xmm0,(%r9,%r13,4)
subss  %xmm11,%xmm3
mulss  %xmm5,%xmm3
mulss  %xmm3,%xmm2
mov    %rcx,%rax
addss  (%r9,%rcx,4),%xmm2
movss  %xmm2,(%r9,%rcx,4)
mulss  %xmm4,%xmm15
lea    0x0(%rbp,%rdi,4),%eax
cltq
movaps %xmm7,%xmm5
mulss  %xmm15,%xmm5
movups (%r8,%rax,4),%xmm0
movaps %xmm5,%xmm2
shufps $0x0,%xmm5,%xmm2
mulps  %xmm9,%xmm2
addps  %xmm0,%xmm2
movups %xmm2,(%r8,%rax,4)
movaps %xmm1,%xmm0
mulss  %xmm5,%xmm0
addss  (%r9,%r12,4),%xmm0
movss  %xmm0,(%r9,%r12,4)
movaps %xmm8,%xmm0
mulss  %xmm5,%xmm0
mov    -0x70(%rsp),%rax
addss  (%r9,%rax,4),%xmm0
movss  %xmm0,(%r9,%rax,4)
mulss  %xmm3,%xmm5
addss  (%r9,%r11,4),%xmm5
movss  %xmm5,(%r9,%r11,4)
lea    0x4(%rbx,%rdi,4),%eax
cltq
movaps 0x30(%rsp),%xmm5
mulss  %xmm5,%xmm6
movups (%r8,%rax,4),%xmm0
movaps %xmm6,%xmm2
shufps $0x0,%xmm6,%xmm2
mulps  %xmm9,%xmm2
addps  %xmm0,%xmm2
movups %xmm2,(%r8,%rax,4)
movaps %xmm1,%xmm0
mulss  %xmm6,%xmm0
mov    -0x68(%rsp),%rax
addss  (%r9,%rax,4),%xmm0
movss  %xmm0,(%r9,%rax,4)
movaps %xmm8,%xmm0
mulss  %xmm6,%xmm0
addss  (%r9,%r15,4),%xmm0
movss  %xmm0,(%r9,%r15,4)
mulss  %xmm3,%xmm6
addss  (%r9,%r14,4),%xmm6
movss  %xmm6,(%r9,%r14,4)
lea    (%rbx,%rdi,4),%eax
mov    -0x80(%rsp),%rdi
mulss  %xmm5,%xmm15
cltq
movaps %xmm15,%xmm0
shufps $0x0,%xmm15,%xmm0
mulps  %xmm9,%xmm0
movups (%r8,%rax,4),%xmm2
addps  %xmm2,%xmm0
movups %xmm0,(%r8,%rax,4)
mov    -0x18(%rsp),%rax
mulss  %xmm15,%xmm1
mov    -0x20(%rsp),%rbp
addss  (%r9,%rbp,4),%xmm1
movss  %xmm1,(%r9,%rbp,4)
mulss  %xmm15,%xmm8
mov    -0x30(%rsp),%rcx
addss  (%r9,%rcx,4),%xmm8
movss  %xmm8,(%r9,%rcx,4)
mulss  %xmm3,%xmm15
mov    -0x38(%rsp),%rcx
addss  (%r9,%rcx,4),%xmm15
movss  %xmm15,(%r9,%rcx,4)
add    -0x58(%rsp),%rdi
add    $0xffffffffffffffff,%rax
jne    11a0 <cgdjpost2l+0xa0>
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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