void cgbpush23l(float part[], float fxy[], float bxy[], float qbm, float dt,
                float dtc, float *ek, int idimp, int nop, int nx, int ny,
                int nxv, int nyv, int ipbc) {
  int j, nn, mm, np, mp, nxv3;
  float qtmh, edgelx, edgely, edgerx, edgery, dxp, dyp, amx, amy;
  float dx, dy, dz, ox, oy, oz, acx, acy, acz, omxt, omyt, omzt, omt;
  float anorm, rot1, rot2, rot3, rot4, rot5, rot6, rot7, rot8, rot9;
  double sum1;
  nxv3 = 3 * nxv;
  qtmh = 0.5 * qbm * dt;
  sum1 = 0.0;
  edgelx = 0.0;
  edgely = 0.0;
  edgerx = (float)nx;
  edgery = (float)ny;
  if (ipbc == 2) {
    edgelx = 1.0;
    edgely = 1.0;
    edgerx = (float)(nx - 1);
    edgery = (float)(ny - 1);
  } else if (ipbc == 3) {
    edgelx = 1.0;
    edgerx = (float)(nx - 1);
  }
  for (j = 0; j < nop; j++) {
    nn = part[idimp * j];
    mm = part[1 + idimp * j];
    dxp = part[idimp * j] - (float)nn;
    dyp = part[1 + idimp * j] - (float)mm;
    nn = 3 * nn;
    mm = nxv3 * mm;
    amx = 1.0 - dxp;
    mp = mm + nxv3;
    amy = 1.0 - dyp;
    np = nn + 3;
    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;
    acx = part[2 + idimp * j] + dx;
    acy = part[3 + idimp * j] + dy;
    acz = part[4 + idimp * j] + dz;
    sum1 += (acx * acx + acy * acy + acz * acz);
    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;
    part[2 + idimp * j] = dx;
    part[3 + idimp * j] = dy;
    part[4 + idimp * j] = dz;
    dx = part[idimp * j] + dx * dtc;
    dy = part[1 + idimp * j] + dy * dtc;
    if (ipbc == 1) {
      if (dx < edgelx)
        dx += edgerx;
      if (dx >= edgerx)
        dx -= edgerx;
      if (dy < edgely)
        dy += edgery;
      if (dy >= edgery)
        dy -= edgery;
    } else if (ipbc == 2) {
      if ((dx < edgelx) || (dx >= edgerx)) {
        dx = part[idimp * j];
        part[2 + idimp * j] = -part[2 + idimp * j];
      }
      if ((dy < edgely) || (dy >= edgery)) {
        dy = part[1 + idimp * j];
        part[3 + idimp * j] = -part[3 + idimp * j];
      }
    } else if (ipbc == 3) {
      if ((dx < edgelx) || (dx >= edgerx)) {
        dx = part[idimp * j];
        part[2 + idimp * j] = -part[2 + idimp * j];
      }
      if (dy < edgely)
        dy += edgery;
      if (dy >= edgery)
        dy -= edgery;
    }
    part[idimp * j] = dx;
    part[1 + idimp * j] = dy;
  }
  *ek += 0.5 * sum1;
  return;
}


x86 assembly (clang, -O0):
<cgbpush23l>:
push   %rbp
mov    %rsp,%rbp
sub    $0x58,%rsp
mov    0x30(%rbp),%eax
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)
movss  %xmm0,-0x1c(%rbp)
movss  %xmm1,-0x20(%rbp)
movss  %xmm2,-0x24(%rbp)
mov    %rcx,-0x30(%rbp)
mov    %r8d,-0x34(%rbp)
mov    %r9d,-0x38(%rbp)
imul   $0x3,0x20(%rbp),%eax
mov    %eax,-0x50(%rbp)
movss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xeaa(%rip),%xmm0
mulsd  %xmm1,%xmm0
movss  -0x20(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x54(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0x58(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x5c(%rbp)
cvtsi2ssl 0x10(%rbp),%xmm0
movss  %xmm0,-0x60(%rbp)
cvtsi2ssl 0x18(%rbp),%xmm0
movss  %xmm0,-0x64(%rbp)
cmpl   $0x2,0x30(%rbp)
jne    11e6 <cgbpush23l+0xe6>
movss  0xe67(%rip),%xmm0
movss  %xmm0,-0x58(%rbp)
movss  0xe5a(%rip),%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    0x10(%rbp),%eax
sub    $0x1,%eax
cvtsi2ss %eax,%xmm0
movss  %xmm0,-0x60(%rbp)
mov    0x18(%rbp),%eax
sub    $0x1,%eax
cvtsi2ss %eax,%xmm0
movss  %xmm0,-0x64(%rbp)
jmp    1211 <cgbpush23l+0x111>
cmpl   $0x3,0x30(%rbp)
jne    120c <cgbpush23l+0x10c>
movss  0xe20(%rip),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    0x10(%rbp),%eax
sub    $0x1,%eax
cvtsi2ss %eax,%xmm0
movss  %xmm0,-0x60(%rbp)
jmp    1211 <cgbpush23l+0x111>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    1de6 <cgbpush23l+0xce6>
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x3c(%rbp),%ecx
movslq %ecx,%rcx
cvttss2si (%rax,%rcx,4),%eax
mov    %eax,-0x40(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
cvttss2si (%rax,%rcx,4),%eax
mov    %eax,-0x44(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtsi2ssl -0x40(%rbp),%xmm1
subss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
cvtsi2ssl -0x44(%rbp),%xmm1
subss  %xmm1,%xmm0
movss  %xmm0,-0x6c(%rbp)
imul   $0x3,-0x40(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x50(%rbp),%eax
imul   -0x44(%rbp),%eax
mov    %eax,-0x44(%rbp)
movss  -0x68(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xd4e(%rip),%xmm0
subsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x70(%rbp)
mov    -0x44(%rbp),%eax
add    -0x50(%rbp),%eax
mov    %eax,-0x4c(%rbp)
movss  -0x6c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xd27(%rip),%xmm0
subsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x74(%rbp)
mov    -0x40(%rbp),%eax
add    $0x3,%eax
mov    %eax,-0x48(%rbp)
movss  -0x6c(%rbp),%xmm0
movss  -0x68(%rbp),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%ecx
add    -0x4c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm3
movss  -0x70(%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  -0x74(%rbp),%xmm1
movss  -0x68(%rbp),%xmm3
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm5
movss  -0x70(%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,-0x78(%rbp)
movss  -0x6c(%rbp),%xmm0
movss  -0x68(%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  -0x70(%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  -0x74(%rbp),%xmm1
movss  -0x68(%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  -0x70(%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,-0x7c(%rbp)
movss  -0x6c(%rbp),%xmm0
movss  -0x68(%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  -0x70(%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  -0x74(%rbp),%xmm1
movss  -0x68(%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  -0x70(%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,-0x80(%rbp)
movss  -0x6c(%rbp),%xmm0
movss  -0x68(%rbp),%xmm2
mov    -0x18(%rbp),%rax
mov    -0x48(%rbp),%ecx
add    -0x4c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm3
movss  -0x70(%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  -0x74(%rbp),%xmm1
movss  -0x68(%rbp),%xmm3
mov    -0x18(%rbp),%rax
mov    -0x48(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm5
movss  -0x70(%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,-0x84(%rbp)
ff
movss  -0x6c(%rbp),%xmm0
movss  -0x68(%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  -0x70(%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  -0x74(%rbp),%xmm1
movss  -0x68(%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  -0x70(%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,-0x88(%rbp)
ff
movss  -0x6c(%rbp),%xmm0
movss  -0x68(%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  -0x70(%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  -0x74(%rbp),%xmm1
movss  -0x68(%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  -0x70(%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,-0x8c(%rbp)
ff
movss  -0x54(%rbp),%xmm0
mulss  -0x78(%rbp),%xmm0
movss  %xmm0,-0x78(%rbp)
movss  -0x54(%rbp),%xmm0
mulss  -0x7c(%rbp),%xmm0
movss  %xmm0,-0x7c(%rbp)
movss  -0x54(%rbp),%xmm0
mulss  -0x80(%rbp),%xmm0
movss  %xmm0,-0x80(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x3c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
addss  -0x78(%rbp),%xmm0
movss  %xmm0,-0x90(%rbp)
ff
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x3c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
addss  -0x7c(%rbp),%xmm0
movss  %xmm0,-0x94(%rbp)
ff
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x3c(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
addss  -0x80(%rbp),%xmm0
movss  %xmm0,-0x98(%rbp)
ff
movss  -0x90(%rbp),%xmm1
ff
movss  -0x90(%rbp),%xmm2
ff
movss  -0x94(%rbp),%xmm0
ff
mulss  -0x94(%rbp),%xmm0
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x98(%rbp),%xmm0
ff
movss  -0x98(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
addsd  -0xd8(%rbp),%xmm0
ff
movsd  %xmm0,-0xd8(%rbp)
ff
movss  -0x54(%rbp),%xmm0
mulss  -0x84(%rbp),%xmm0
ff
movss  %xmm0,-0x9c(%rbp)
ff
movss  -0x54(%rbp),%xmm0
mulss  -0x88(%rbp),%xmm0
ff
movss  %xmm0,-0xa0(%rbp)
ff
movss  -0x54(%rbp),%xmm0
mulss  -0x8c(%rbp),%xmm0
ff
movss  %xmm0,-0xa4(%rbp)
ff
movss  -0x9c(%rbp),%xmm1
ff
movss  -0x9c(%rbp),%xmm2
ff
movss  -0xa0(%rbp),%xmm0
ff
mulss  -0xa0(%rbp),%xmm0
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0xa4(%rbp),%xmm0
ff
movss  -0xa4(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xa8(%rbp)
ff
movss  -0xa8(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movsd  0x829(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  0x825(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0xac(%rbp)
ff
movss  -0xa8(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movsd  0x7f9(%rip),%xmm1
subsd  %xmm0,%xmm1
movsd  0x7e5(%rip),%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0xa8(%rbp)
ff
movss  -0x9c(%rbp),%xmm0
ff
mulss  -0xa0(%rbp),%xmm0
ff
movss  %xmm0,-0xbc(%rbp)
ff
movss  -0x9c(%rbp),%xmm0
ff
mulss  -0xa4(%rbp),%xmm0
ff
movss  %xmm0,-0xc8(%rbp)
ff
movss  -0xa0(%rbp),%xmm0
ff
mulss  -0xa4(%rbp),%xmm0
ff
movss  %xmm0,-0xcc(%rbp)
ff
movss  -0xa8(%rbp),%xmm1
ff
movss  -0x9c(%rbp),%xmm0
ff
movss  -0x9c(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xb0(%rbp)
ff
movss  -0xa8(%rbp),%xmm1
ff
movss  -0xa0(%rbp),%xmm0
ff
movss  -0xa0(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xc0(%rbp)
ff
movss  -0xa8(%rbp),%xmm1
ff
movss  -0xa4(%rbp),%xmm0
ff
movss  -0xa4(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xd0(%rbp)
ff
movss  -0xa4(%rbp),%xmm0
ff
addss  -0xbc(%rbp),%xmm0
ff
movss  %xmm0,-0xb4(%rbp)
ff
movss  -0xa4(%rbp),%xmm1
ff
movss  -0xbc(%rbp),%xmm0
ff
subss  %xmm1,%xmm0
movss  %xmm0,-0xbc(%rbp)
ff
movss  -0xa0(%rbp),%xmm0
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
addss  -0xc8(%rbp),%xmm0
ff
movss  %xmm0,-0xb8(%rbp)
ff
movss  -0xa0(%rbp),%xmm0
ff
addss  -0xc8(%rbp),%xmm0
ff
movss  %xmm0,-0xc8(%rbp)
ff
movss  -0x9c(%rbp),%xmm0
ff
addss  -0xcc(%rbp),%xmm0
ff
movss  %xmm0,-0xc4(%rbp)
ff
movss  -0x9c(%rbp),%xmm1
ff
movss  -0xcc(%rbp),%xmm0
ff
subss  %xmm1,%xmm0
movss  %xmm0,-0xcc(%rbp)
ff
movss  -0xb0(%rbp),%xmm1
ff
movss  -0x90(%rbp),%xmm2
ff
movss  -0xb4(%rbp),%xmm0
ff
mulss  -0x94(%rbp),%xmm0
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0xb8(%rbp),%xmm0
ff
movss  -0x98(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0xac(%rbp),%xmm2
ff
movss  -0x78(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x78(%rbp)
movss  -0xbc(%rbp),%xmm1
ff
movss  -0x90(%rbp),%xmm2
ff
movss  -0xc0(%rbp),%xmm0
ff
mulss  -0x94(%rbp),%xmm0
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0xc4(%rbp),%xmm0
ff
movss  -0x98(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0xac(%rbp),%xmm2
ff
movss  -0x7c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x7c(%rbp)
movss  -0xc8(%rbp),%xmm1
ff
movss  -0x90(%rbp),%xmm2
ff
movss  -0xcc(%rbp),%xmm0
ff
mulss  -0x94(%rbp),%xmm0
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0xd0(%rbp),%xmm0
ff
movss  -0x98(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0xac(%rbp),%xmm2
ff
movss  -0x80(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x80(%rbp)
movss  -0x78(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x3c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x7c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x3c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x80(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x3c(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x78(%rbp),%xmm0
movss  -0x24(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x78(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x7c(%rbp),%xmm0
movss  -0x24(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x7c(%rbp)
cmpl   $0x1,0x30(%rbp)
jne    1bdd <cgbpush23l+0xadd>
movss  -0x78(%rbp),%xmm1
movss  -0x58(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    1b72 <cgbpush23l+0xa72>
movss  -0x60(%rbp),%xmm0
addss  -0x78(%rbp),%xmm0
movss  %xmm0,-0x78(%rbp)
movss  -0x78(%rbp),%xmm0
ucomiss -0x60(%rbp),%xmm0
jb     1b94 <cgbpush23l+0xa94>
movss  -0x60(%rbp),%xmm1
movss  -0x78(%rbp),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,-0x78(%rbp)
movss  -0x7c(%rbp),%xmm1
movss  -0x5c(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    1bb6 <cgbpush23l+0xab6>
movss  -0x64(%rbp),%xmm0
addss  -0x7c(%rbp),%xmm0
movss  %xmm0,-0x7c(%rbp)
movss  -0x7c(%rbp),%xmm0
ucomiss -0x64(%rbp),%xmm0
jb     1bd8 <cgbpush23l+0xad8>
movss  -0x64(%rbp),%xmm1
movss  -0x7c(%rbp),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,-0x7c(%rbp)
jmp    1da5 <cgbpush23l+0xca5>
cmpl   $0x2,0x30(%rbp)
jne    1cd5 <cgbpush23l+0xbd5>
movss  -0x78(%rbp),%xmm1
movss  -0x58(%rbp),%xmm0
ucomiss %xmm1,%xmm0
ja     1c09 <cgbpush23l+0xb09>
movss  -0x78(%rbp),%xmm0
ucomiss -0x60(%rbp),%xmm0
jb     1c5a <cgbpush23l+0xb5a>
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x78(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x3c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x3c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x7c(%rbp),%xmm1
movss  -0x5c(%rbp),%xmm0
ucomiss %xmm1,%xmm0
ja     1c7c <cgbpush23l+0xb7c>
movss  -0x7c(%rbp),%xmm0
ucomiss -0x64(%rbp),%xmm0
jb     1cd0 <cgbpush23l+0xbd0>
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x7c(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x3c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x3c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    1da0 <cgbpush23l+0xca0>
cmpl   $0x3,0x30(%rbp)
jne    1d9b <cgbpush23l+0xc9b>
movss  -0x78(%rbp),%xmm1
movss  -0x58(%rbp),%xmm0
ucomiss %xmm1,%xmm0
ja     1d01 <cgbpush23l+0xc01>
movss  -0x78(%rbp),%xmm0
ucomiss -0x60(%rbp),%xmm0
jb     1d52 <cgbpush23l+0xc52>
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x78(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x3c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x3c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x7c(%rbp),%xmm1
movss  -0x5c(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    1d74 <cgbpush23l+0xc74>
movss  -0x64(%rbp),%xmm0
addss  -0x7c(%rbp),%xmm0
movss  %xmm0,-0x7c(%rbp)
movss  -0x7c(%rbp),%xmm0
ucomiss -0x64(%rbp),%xmm0
jb     1d96 <cgbpush23l+0xc96>
movss  -0x64(%rbp),%xmm1
movss  -0x7c(%rbp),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,-0x7c(%rbp)
jmp    1d9b <cgbpush23l+0xc9b>
jmp    1da0 <cgbpush23l+0xca0>
jmp    1da5 <cgbpush23l+0xca5>
movss  -0x78(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x7c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1218 <cgbpush23l+0x118>
movsd  -0xd8(%rbp),%xmm0
ff
mov    -0x30(%rbp),%rax
movss  (%rax),%xmm1
cvtss2sd %xmm1,%xmm1
movsd  0x1fe(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%rax)
add    $0x58,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<cgbpush23l>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
mov    %rcx,-0x28(%rsp)
movaps %xmm2,-0x40(%rsp)
mov    0xa0(%rsp),%ebx
mov    0x88(%rsp),%eax
mov    0x80(%rsp),%ecx
cmp    $0x2,%ebx
jne    1190 <cgbpush23l+0x90>
movd   %eax,%xmm2
movd   %ecx,%xmm3
punpckldq %xmm2,%xmm3
pcmpeqd %xmm2,%xmm2
paddd  %xmm3,%xmm2
movdqa 0xed2(%rip),%xmm3
movdqa %xmm3,-0x60(%rsp)
test   %r9d,%r9d
jg     11c7 <cgbpush23l+0xc7>
pxor   %xmm2,%xmm2
mov    -0x28(%rsp),%rax
movss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mulsd  0xe8e(%rip),%xmm2
addsd  %xmm0,%xmm2
xorps  %xmm0,%xmm0
cvtsd2ss %xmm2,%xmm0
movss  %xmm0,(%rax)
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %ebp,%ebp
cmp    $0x3,%ebx
sete   %bpl
je     11a0 <cgbpush23l+0xa0>
xorps  %xmm2,%xmm2
jmp    11a8 <cgbpush23l+0xa8>
movss  0xe70(%rip),%xmm2
sub    %ebp,%ecx
xorps  %xmm3,%xmm3
movss  %xmm2,%xmm3
movaps %xmm3,-0x60(%rsp)
movd   %ecx,%xmm2
movd   %eax,%xmm3
punpckldq %xmm3,%xmm2
test   %r9d,%r9d
jle    1159 <cgbpush23l+0x59>
cvtss2sd %xmm0,%xmm0
mov    0x90(%rsp),%eax
mulsd  0xe26(%rip),%xmm0
cvtss2sd %xmm1,%xmm1
mulsd  %xmm0,%xmm1
lea    (%rax,%rax,2),%eax
mov    %rax,-0x18(%rsp)
xorps  %xmm0,%xmm0
cvtsd2ss %xmm1,%xmm0
cvtdq2ps %xmm2,%xmm1
movslq %r8d,%rax
mov    %r9d,%ecx
movaps %xmm0,0x20(%rsp)
shufps $0x0,%xmm0,%xmm0
movaps %xmm0,0x10(%rsp)
movaps -0x40(%rsp),%xmm0
shufps $0x0,%xmm0,%xmm0
movaps %xmm0,-0x40(%rsp)
movaps -0x60(%rsp),%xmm0
shufps $0x55,%xmm0,%xmm0
movaps %xmm0,(%rsp)
movaps %xmm1,-0x50(%rsp)
shufps $0x55,%xmm1,%xmm1
movaps %xmm1,-0x10(%rsp)
add    $0x10,%rdi
shl    $0x2,%rax
mov    %rax,-0x20(%rsp)
xorps  %xmm2,%xmm2
jmp    1297 <cgbpush23l+0x197>
movss  -0xc(%rdi),%xmm5
xorps  0xde1(%rip),%xmm2
movss  %xmm2,-0x4(%rdi)
movsd  -0x78(%rsp),%xmm2
mulss  %xmm13,%xmm13
mulss  %xmm7,%xmm7
addss  %xmm13,%xmm7
mulss  %xmm12,%xmm12
addss  %xmm7,%xmm12
xorps  %xmm1,%xmm1
cvtss2sd %xmm12,%xmm1
addsd  %xmm1,%xmm2
movss  %xmm0,-0x10(%rdi)
movss  %xmm5,-0xc(%rdi)
add    -0x20(%rsp),%rdi
add    $0xffffffffffffffff,%rcx
je     115d <cgbpush23l+0x5d>
movsd  %xmm2,-0x78(%rsp)
mov    %rcx,-0x70(%rsp)
movsd  -0x10(%rdi),%xmm0
cvttss2si %xmm0,%r8d
movaps %xmm0,%xmm14
movaps %xmm0,%xmm1
shufps $0x55,%xmm0,%xmm14
cvttss2si %xmm14,%ebp
lea    (%r8,%r8,2),%r10d
mov    -0x18(%rsp),%rax
imul   %eax,%ebp
lea    (%rax,%rbp,1),%ecx
lea    (%r8,%r8,2),%eax
add    $0x3,%eax
add    %ecx,%eax
lea    (%rcx,%r10,1),%r12d
lea    (%r10,%rbp,1),%ebx
mov    %ebx,-0x64(%rsp)
lea    (%r8,%r8,2),%r13d
add    $0x4,%r13d
add    %ecx,%r13d
lea    (%r8,%r8,2),%ebx
add    $0x1,%ebx
add    %ecx,%ebx
lea    (%r8,%r8,2),%r14d
add    $0x5,%r14d
add    %ecx,%r14d
lea    (%r8,%r8,2),%r15d
add    $0x2,%r15d
add    %ecx,%r15d
lea    (%r10,%rbp,1),%r9d
add    $0x3,%r9d
lea    0x4(%rbp,%r10,1),%r8d
lea    0x1(%rbp,%r10,1),%r11d
lea    0x5(%rbp,%r10,1),%ecx
lea    0x2(%rbp,%r10,1),%r10d
movslq %r12d,%rbp
movss  (%rsi,%rbp,4),%xmm0
movss  (%rdx,%rbp,4),%xmm12
cltq
movss  (%rsi,%rax,4),%xmm10
movss  (%rdx,%rax,4),%xmm5
movslq -0x64(%rsp),%rax
movss  (%rsi,%rax,4),%xmm15
movss  (%rdx,%rax,4),%xmm11
movslq %r9d,%rax
movss  (%rsi,%rax,4),%xmm6
movss  (%rdx,%rax,4),%xmm2
movslq %ebx,%rax
movss  (%rsi,%rax,4),%xmm9
movss  (%rdx,%rax,4),%xmm13
movslq %r13d,%rax
movss  (%rsi,%rax,4),%xmm4
movss  (%rdx,%rax,4),%xmm7
movaps %xmm1,%xmm3
movaps %xmm1,0x30(%rsp)
cvttps2dq %xmm1,%xmm1
cvtdq2ps %xmm1,%xmm8
movaps %xmm3,%xmm1
subss  %xmm8,%xmm1
cvttps2dq %xmm14,%xmm3
cvtdq2ps %xmm3,%xmm3
subss  %xmm3,%xmm14
movss  0xc6e(%rip),%xmm8
subss  %xmm1,%xmm8
unpcklps %xmm9,%xmm0
movaps %xmm8,%xmm9
shufps $0x0,%xmm8,%xmm9
mulps  %xmm9,%xmm0
unpcklps %xmm4,%xmm10
movaps %xmm1,%xmm3
shufps $0x0,%xmm1,%xmm3
mulps  %xmm3,%xmm10
addps  %xmm0,%xmm10
movslq %r11d,%rax
movss  (%rsi,%rax,4),%xmm0
unpcklps %xmm0,%xmm15
movss  (%rdx,%rax,4),%xmm0
movslq %r8d,%rax
mulps  %xmm9,%xmm15
movss  (%rsi,%rax,4),%xmm4
unpcklps %xmm4,%xmm6
mulps  %xmm3,%xmm6
addps  %xmm15,%xmm6
movslq %r15d,%rbp
movss  (%rsi,%rbp,4),%xmm9
movslq %ecx,%rcx
movslq %r10d,%rbx
mov    0xa0(%rsp),%r8d
movss  (%rsi,%rbx,4),%xmm4
mulss  %xmm8,%xmm4
movss  (%rsi,%rcx,4),%xmm15
mulss  %xmm1,%xmm15
addss  %xmm4,%xmm15
movss  (%rdx,%rbp,4),%xmm3
mulss  %xmm8,%xmm9
mulss  %xmm8,%xmm12
mulss  %xmm8,%xmm11
mulss  %xmm8,%xmm13
mulss  %xmm8,%xmm0
mulss  %xmm8,%xmm3
mulss  (%rdx,%rbx,4),%xmm8
mulss  %xmm1,%xmm2
addss  %xmm11,%xmm2
movss  (%rdx,%rax,4),%xmm4
movslq %r14d,%rax
mulss  %xmm1,%xmm4
addss  %xmm0,%xmm4
movss  (%rsi,%rax,4),%xmm11
mulss  %xmm1,%xmm11
mulss  %xmm1,%xmm5
mulss  %xmm1,%xmm7
movss  (%rdx,%rax,4),%xmm0
mulss  %xmm1,%xmm0
mulss  (%rdx,%rcx,4),%xmm1
addss  %xmm8,%xmm1
movss  0xb7c(%rip),%xmm8
subss  %xmm14,%xmm8
mulss  %xmm8,%xmm15
mulss  %xmm8,%xmm2
mulss  %xmm8,%xmm4
mulss  %xmm8,%xmm1
shufps $0x0,%xmm8,%xmm8
mulps  %xmm6,%xmm8
addss  %xmm9,%xmm11
mulss  %xmm14,%xmm11
addss  %xmm12,%xmm5
mulss  %xmm14,%xmm5
addss  %xmm13,%xmm7
mulss  %xmm14,%xmm7
addss  %xmm3,%xmm0
mulss  %xmm14,%xmm0
shufps $0x0,%xmm14,%xmm14
mulps  %xmm10,%xmm14
addps  %xmm8,%xmm14
addss  %xmm15,%xmm11
addss  %xmm2,%xmm5
addss  %xmm4,%xmm7
addss  %xmm1,%xmm0
movaps 0x20(%rsp),%xmm12
mulss  %xmm12,%xmm5
mulss  %xmm12,%xmm7
mulss  %xmm12,%xmm0
movaps %xmm5,%xmm8
mulss  %xmm7,%xmm8
movaps %xmm5,%xmm10
mulss  %xmm0,%xmm10
movaps %xmm7,%xmm9
movaps %xmm7,%xmm4
addss  %xmm10,%xmm4
subss  %xmm7,%xmm10
mulss  %xmm7,%xmm7
movaps %xmm5,%xmm6
mulss  %xmm5,%xmm6
movaps %xmm6,%xmm3
addss  %xmm7,%xmm3
mulss  %xmm0,%xmm9
movaps %xmm8,%xmm1
addss  %xmm0,%xmm1
subss  %xmm0,%xmm8
mulss  %xmm0,%xmm0
addss  %xmm0,%xmm3
cvtss2sd %xmm3,%xmm3
movsd  0xa94(%rip),%xmm13
movapd %xmm13,%xmm2
subsd  %xmm3,%xmm2
addsd  %xmm13,%xmm3
movsd  0xa85(%rip),%xmm15
mulsd  0xa6d(%rip),%xmm2
cvtsd2ss %xmm2,%xmm2
divsd  %xmm3,%xmm15
addss  %xmm2,%xmm6
addss  %xmm2,%xmm7
addss  %xmm2,%xmm0
unpcklps %xmm7,%xmm1
unpcklps %xmm9,%xmm2
subss  %xmm5,%xmm9
unpcklps %xmm5,%xmm3
mulps  0x10(%rsp),%xmm14
mulss  %xmm12,%xmm11
unpcklps %xmm8,%xmm6
movss  -0x8(%rdi),%xmm7
addps  %xmm3,%xmm2
movaps %xmm14,%xmm13
shufps $0x55,%xmm14,%xmm13
addss  -0x4(%rdi),%xmm13
addss  %xmm14,%xmm7
shufps $0x1,%xmm10,%xmm2
shufps $0xe2,%xmm10,%xmm2
movaps %xmm13,%xmm3
shufps $0x0,%xmm13,%xmm3
mulps  %xmm1,%xmm3
movaps %xmm7,%xmm1
shufps $0x0,%xmm7,%xmm1
mulps  %xmm6,%xmm1
movss  (%rdi),%xmm12
addss  %xmm11,%xmm12
addps  %xmm3,%xmm1
movaps %xmm12,%xmm3
shufps $0x0,%xmm12,%xmm3
mulps  %xmm2,%xmm3
addps  %xmm1,%xmm3
mulss  %xmm13,%xmm9
mulss  %xmm7,%xmm4
addss  %xmm9,%xmm4
mulss  %xmm12,%xmm0
addss  %xmm4,%xmm0
xorps  %xmm1,%xmm1
cvtsd2ss %xmm15,%xmm1
mulss  %xmm1,%xmm0
shufps $0x0,%xmm1,%xmm1
mulps  %xmm3,%xmm1
addps  %xmm14,%xmm1
movaps 0x30(%rsp),%xmm4
addss  %xmm11,%xmm0
movss  %xmm1,-0x8(%rdi)
movaps %xmm1,%xmm2
shufps $0x55,%xmm1,%xmm2
movss  %xmm2,-0x4(%rdi)
movss  %xmm0,(%rdi)
movaps %xmm1,%xmm3
mulps  -0x40(%rsp),%xmm3
addps  %xmm4,%xmm3
cmp    $0x1,%r8d
jne    16e0 <cgbpush23l+0x5e0>
movaps %xmm3,%xmm5
cmpltps -0x60(%rsp),%xmm5
movaps -0x50(%rsp),%xmm1
movaps %xmm1,%xmm0
andps  %xmm5,%xmm0
andnps 0x9a9(%rip),%xmm5
orps   %xmm0,%xmm5
addps  %xmm3,%xmm5
movaps %xmm1,%xmm0
cmpnleps %xmm5,%xmm0
unpcklps %xmm0,%xmm0
movmskpd %xmm0,%eax
xorps  %xmm1,%xmm1
test   $0x1,%al
jne    16b7 <cgbpush23l+0x5b7>
movaps -0x50(%rsp),%xmm1
movaps %xmm5,%xmm0
subss  %xmm1,%xmm0
test   $0x2,%al
mov    -0x70(%rsp),%rcx
movsd  -0x78(%rsp),%xmm2
je     1740 <cgbpush23l+0x640>
shufps $0x55,%xmm5,%xmm5
jmp    125a <cgbpush23l+0x15a>
cs nopw 0x0(%rax,%rax,1)
cmp    $0x2,%r8d
jne    1750 <cgbpush23l+0x650>
movaps -0x60(%rsp),%xmm0
ucomiss %xmm3,%xmm0
ja     16fa <cgbpush23l+0x5fa>
ucomiss -0x50(%rsp),%xmm3
movaps %xmm3,%xmm0
jb     1709 <cgbpush23l+0x609>
xorps  0x92f(%rip),%xmm1
movss  %xmm1,-0x8(%rdi)
movaps %xmm4,%xmm0
shufps $0x55,%xmm3,%xmm3
movaps (%rsp),%xmm1
ucomiss %xmm3,%xmm1
mov    -0x70(%rsp),%rcx
ja     1243 <cgbpush23l+0x143>
ucomiss -0x10(%rsp),%xmm3
jae    1243 <cgbpush23l+0x143>
movaps %xmm3,%xmm5
jmp    1254 <cgbpush23l+0x154>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
subps  -0x50(%rsp),%xmm5
shufps $0x55,%xmm5,%xmm5
jmp    125a <cgbpush23l+0x15a>
xchg   %ax,%ax
movaps %xmm3,%xmm0
shufps $0x55,%xmm3,%xmm0
cmp    $0x3,%r8d
jne    17b9 <cgbpush23l+0x6b9>
movaps -0x60(%rsp),%xmm2
ucomiss %xmm3,%xmm2
ja     176e <cgbpush23l+0x66e>
ucomiss -0x50(%rsp),%xmm3
jb     177d <cgbpush23l+0x67d>
xorps  0x8bb(%rip),%xmm1
movss  %xmm1,-0x8(%rdi)
movaps %xmm4,%xmm3
movaps %xmm0,%xmm5
cmpltss (%rsp),%xmm5
movaps %xmm5,%xmm1
movaps -0x10(%rsp),%xmm2
andps  %xmm2,%xmm1
movss  0x883(%rip),%xmm4
andnps %xmm4,%xmm5
orps   %xmm1,%xmm5
addss  %xmm0,%xmm5
ucomiss %xmm2,%xmm5
mov    -0x70(%rsp),%rcx
jb     17b1 <cgbpush23l+0x6b1>
subss  %xmm2,%xmm5
movaps %xmm3,%xmm0
jmp    1254 <cgbpush23l+0x154>
movaps %xmm0,%xmm5
movaps %xmm3,%xmm0
mov    -0x70(%rsp),%rcx
jmp    1254 <cgbpush23l+0x154>

LLVM IR (-O0):
define void @cgbpush23l(float* %0, float* %1, float* %2, float %3, float %4, float %5, float* %6, i32 %7, i32 %8, i32 %9, i32 %10, i32 %11, i32 %12, i32 %13) {
%15 = alloca float*
%16 = alloca float*
%17 = alloca float*
%18 = alloca float
%19 = alloca float
%20 = alloca float
%21 = alloca float*
%22 = alloca i32
%23 = alloca i32
%24 = alloca 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 float
%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 double
store float* %0, float** %15
store float* %1, float** %16
store float* %2, float** %17
store float %3, float* %18
store float %4, float* %19
store float %5, float* %20
store float* %6, float** %21
store i32 %7, i32* %22
store i32 %8, i32* %23
store i32 %9, i32* %24
store i32 %10, i32* %25
store i32 %11, i32* %26
store i32 %12, i32* %27
store i32 %13, i32* %28
%68 = load i32, i32* %26
%69 = mul nsw i32 3, %68
store i32 %69, i32* %34
%70 = load float, float* %18
%71 = fpext float %70 to double
%72 = fmul double 5.000000e-01, %71
%73 = load float, float* %19
%74 = fpext float %73 to double
%75 = fmul double %72, %74
%76 = fptrunc double %75 to float
store float %76, float* %35
store double 0.000000e+00, double* %67
store float 0.000000e+00, float* %36
store float 0.000000e+00, float* %37
%77 = load i32, i32* %24
%78 = sitofp i32 %77 to float
store float %78, float* %38
%79 = load i32, i32* %25
%80 = sitofp i32 %79 to float
store float %80, float* %39
%81 = load i32, i32* %28
%82 = icmp eq i32 %81, 2
br i1 %82, label %83, label %90
83: ; preds = %14
store float 1.000000e+00, float* %36
store float 1.000000e+00, float* %37
%84 = load i32, i32* %24
%85 = sub nsw i32 %84, 1
%86 = sitofp i32 %85 to float
store float %86, float* %38
%87 = load i32, i32* %25
%88 = sub nsw i32 %87, 1
%89 = sitofp i32 %88 to float
store float %89, float* %39
br label %98
90: ; preds = %14
%91 = load i32, i32* %28
%92 = icmp eq i32 %91, 3
br i1 %92, label %93, label %97
93: ; preds = %90
store float 1.000000e+00, float* %36
%94 = load i32, i32* %24
%95 = sub nsw i32 %94, 1
%96 = sitofp i32 %95 to float
store float %96, float* %38
br label %97
97: ; preds = %93, %90
br label %98
98: ; preds = %97, %83
store i32 0, i32* %29
br label %99
99: ; preds = %790, %98
%100 = load i32, i32* %29
%101 = load i32, i32* %23
%102 = icmp slt i32 %100, %101
br i1 %102, label %103, label %793
103: ; preds = %99
%104 = load float*, float** %15
%105 = load i32, i32* %22
%106 = load i32, i32* %29
%107 = mul nsw i32 %105, %106
%108 = sext i32 %107 to i64
%109 = getelementptr inbounds float, float* %104, i64 %108
%110 = load float, float* %109
%111 = fptosi float %110 to i32
store i32 %111, i32* %30
%112 = load float*, float** %15
%113 = load i32, i32* %22
%114 = load i32, i32* %29
%115 = mul nsw i32 %113, %114
%116 = add nsw i32 1, %115
%117 = sext i32 %116 to i64
%118 = getelementptr inbounds float, float* %112, i64 %117
%119 = load float, float* %118
%120 = fptosi float %119 to i32
store i32 %120, i32* %31
%121 = load float*, float** %15
%122 = load i32, i32* %22
%123 = load i32, i32* %29
%124 = mul nsw i32 %122, %123
%125 = sext i32 %124 to i64
%126 = getelementptr inbounds float, float* %121, i64 %125
%127 = load float, float* %126
%128 = load i32, i32* %30
%129 = sitofp i32 %128 to float
%130 = fsub float %127, %129
store float %130, float* %40
%131 = load float*, float** %15
%132 = load i32, i32* %22
%133 = load i32, i32* %29
%134 = mul nsw i32 %132, %133
%135 = add nsw i32 1, %134
%136 = sext i32 %135 to i64
%137 = getelementptr inbounds float, float* %131, i64 %136
%138 = load float, float* %137
%139 = load i32, i32* %31
%140 = sitofp i32 %139 to float
%141 = fsub float %138, %140
store float %141, float* %41
%142 = load i32, i32* %30
%143 = mul nsw i32 3, %142
store i32 %143, i32* %30
%144 = load i32, i32* %34
%145 = load i32, i32* %31
%146 = mul nsw i32 %144, %145
store i32 %146, i32* %31
%147 = load float, float* %40
%148 = fpext float %147 to double
%149 = fsub double 1.000000e+00, %148
%150 = fptrunc double %149 to float
store float %150, float* %42
%151 = load i32, i32* %31
%152 = load i32, i32* %34
%153 = add nsw i32 %151, %152
store i32 %153, i32* %33
%154 = load float, float* %41
%155 = fpext float %154 to double
%156 = fsub double 1.000000e+00, %155
%157 = fptrunc double %156 to float
store float %157, float* %43
%158 = load i32, i32* %30
%159 = add nsw i32 %158, 3
store i32 %159, i32* %32
%160 = load float, float* %41
%161 = load float, float* %40
%162 = load float*, float** %16
%163 = load i32, i32* %32
%164 = load i32, i32* %33
%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** %16
%171 = load i32, i32* %30
%172 = load i32, i32* %33
%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** %16
%182 = load i32, i32* %32
%183 = load i32, i32* %31
%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** %16
%190 = load i32, i32* %30
%191 = load i32, i32* %31
%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** %16
%203 = load i32, i32* %32
%204 = add nsw i32 1, %203
%205 = load i32, i32* %33
%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** %16
%212 = load i32, i32* %30
%213 = add nsw i32 1, %212
%214 = load i32, i32* %33
%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** %16
%224 = load i32, i32* %32
%225 = add nsw i32 1, %224
%226 = load i32, i32* %31
%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** %16
%233 = load i32, i32* %30
%234 = add nsw i32 1, %233
%235 = load i32, i32* %31
%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** %16
%247 = load i32, i32* %32
%248 = add nsw i32 2, %247
%249 = load i32, i32* %33
%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** %16
%256 = load i32, i32* %30
%257 = add nsw i32 2, %256
%258 = load i32, i32* %33
%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** %16
%268 = load i32, i32* %32
%269 = add nsw i32 2, %268
%270 = load i32, i32* %31
%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** %16
%277 = load i32, i32* %30
%278 = add nsw i32 2, %277
%279 = load i32, i32* %31
%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** %17
%291 = load i32, i32* %32
%292 = load i32, i32* %33
%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** %17
%299 = load i32, i32* %30
%300 = load i32, i32* %33
%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** %17
%310 = load i32, i32* %32
%311 = load i32, i32* %31
%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** %17
%318 = load i32, i32* %30
%319 = load i32, i32* %31
%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** %17
%331 = load i32, i32* %32
%332 = add nsw i32 1, %331
%333 = load i32, i32* %33
%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** %17
%340 = load i32, i32* %30
%341 = add nsw i32 1, %340
%342 = load i32, i32* %33
%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** %17
%352 = load i32, i32* %32
%353 = add nsw i32 1, %352
%354 = load i32, i32* %31
%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** %17
%361 = load i32, i32* %30
%362 = add nsw i32 1, %361
%363 = load i32, i32* %31
%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** %17
%375 = load i32, i32* %32
%376 = add nsw i32 2, %375
%377 = load i32, i32* %33
%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** %17
%384 = load i32, i32* %30
%385 = add nsw i32 2, %384
%386 = load i32, i32* %33
%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** %17
%396 = load i32, i32* %32
%397 = add nsw i32 2, %396
%398 = load i32, i32* %31
%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** %17
%405 = load i32, i32* %30
%406 = add nsw i32 2, %405
%407 = load i32, i32* %31
%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* %35
%417 = load float, float* %44
%418 = fmul float %417, %416
store float %418, float* %44
%419 = load float, float* %35
%420 = load float, float* %45
%421 = fmul float %420, %419
store float %421, float* %45
%422 = load float, float* %35
%423 = load float, float* %46
%424 = fmul float %423, %422
store float %424, float* %46
%425 = load float*, float** %15
%426 = load i32, i32* %22
%427 = load i32, i32* %29
%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
%433 = load float, float* %44
%434 = fadd float %432, %433
store float %434, float* %50
%435 = load float*, float** %15
%436 = load i32, i32* %22
%437 = load i32, i32* %29
%438 = mul nsw i32 %436, %437
%439 = add nsw i32 3, %438
%440 = sext i32 %439 to i64
%441 = getelementptr inbounds float, float* %435, i64 %440
%442 = load float, float* %441
%443 = load float, float* %45
%444 = fadd float %442, %443
store float %444, float* %51
%445 = load float*, float** %15
%446 = load i32, i32* %22
%447 = load i32, i32* %29
%448 = mul nsw i32 %446, %447
%449 = add nsw i32 4, %448
%450 = sext i32 %449 to i64
%451 = getelementptr inbounds float, float* %445, i64 %450
%452 = load float, float* %451
%453 = load float, float* %46
%454 = fadd float %452, %453
store float %454, float* %52
%455 = load float, float* %50
%456 = load float, float* %50
%457 = load float, float* %51
%458 = load float, float* %51
%459 = fmul float %457, %458
%460 = call float @llvm.fmuladd.f32(float %455, float %456, float %459)
%461 = load float, float* %52
%462 = load float, float* %52
%463 = call float @llvm.fmuladd.f32(float %461, float %462, float %460)
%464 = fpext float %463 to double
%465 = load double, double* %67
%466 = fadd double %465, %464
store double %466, double* %67
%467 = load float, float* %35
%468 = load float, float* %47
%469 = fmul float %467, %468
store float %469, float* %53
%470 = load float, float* %35
%471 = load float, float* %48
%472 = fmul float %470, %471
store float %472, float* %54
%473 = load float, float* %35
%474 = load float, float* %49
%475 = fmul float %473, %474
store float %475, float* %55
%476 = load float, float* %53
%477 = load float, float* %53
%478 = load float, float* %54
%479 = load float, float* %54
%480 = fmul float %478, %479
%481 = call float @llvm.fmuladd.f32(float %476, float %477, float %480)
%482 = load float, float* %55
%483 = load float, float* %55
%484 = call float @llvm.fmuladd.f32(float %482, float %483, float %481)
store float %484, float* %56
%485 = load float, float* %56
%486 = fpext float %485 to double
%487 = fadd double 1.000000e+00, %486
%488 = fdiv double 2.000000e+00, %487
%489 = fptrunc double %488 to float
store float %489, float* %57
%490 = load float, float* %56
%491 = fpext float %490 to double
%492 = fsub double 1.000000e+00, %491
%493 = fmul double 5.000000e-01, %492
%494 = fptrunc double %493 to float
store float %494, float* %56
%495 = load float, float* %53
%496 = load float, float* %54
%497 = fmul float %495, %496
store float %497, float* %61
%498 = load float, float* %53
%499 = load float, float* %55
%500 = fmul float %498, %499
store float %500, float* %64
%501 = load float, float* %54
%502 = load float, float* %55
%503 = fmul float %501, %502
store float %503, float* %65
%504 = load float, float* %56
%505 = load float, float* %53
%506 = load float, float* %53
%507 = call float @llvm.fmuladd.f32(float %505, float %506, float %504)
store float %507, float* %58
%508 = load float, float* %56
%509 = load float, float* %54
%510 = load float, float* %54
%511 = call float @llvm.fmuladd.f32(float %509, float %510, float %508)
store float %511, float* %62
%512 = load float, float* %56
%513 = load float, float* %55
%514 = load float, float* %55
%515 = call float @llvm.fmuladd.f32(float %513, float %514, float %512)
store float %515, float* %66
%516 = load float, float* %55
%517 = load float, float* %61
%518 = fadd float %516, %517
store float %518, float* %59
%519 = load float, float* %55
%520 = load float, float* %61
%521 = fsub float %520, %519
store float %521, float* %61
%522 = load float, float* %54
%523 = fneg float %522
%524 = load float, float* %64
%525 = fadd float %523, %524
store float %525, float* %60
%526 = load float, float* %54
%527 = load float, float* %64
%528 = fadd float %527, %526
store float %528, float* %64
%529 = load float, float* %53
%530 = load float, float* %65
%531 = fadd float %529, %530
store float %531, float* %63
%532 = load float, float* %53
%533 = load float, float* %65
%534 = fsub float %533, %532
store float %534, float* %65
%535 = load float, float* %58
%536 = load float, float* %50
%537 = load float, float* %59
%538 = load float, float* %51
%539 = fmul float %537, %538
%540 = call float @llvm.fmuladd.f32(float %535, float %536, float %539)
%541 = load float, float* %60
%542 = load float, float* %52
%543 = call float @llvm.fmuladd.f32(float %541, float %542, float %540)
%544 = load float, float* %57
%545 = load float, float* %44
%546 = call float @llvm.fmuladd.f32(float %543, float %544, float %545)
store float %546, float* %44
%547 = load float, float* %61
%548 = load float, float* %50
%549 = load float, float* %62
%550 = load float, float* %51
%551 = fmul float %549, %550
%552 = call float @llvm.fmuladd.f32(float %547, float %548, float %551)
%553 = load float, float* %63
%554 = load float, float* %52
%555 = call float @llvm.fmuladd.f32(float %553, float %554, float %552)
%556 = load float, float* %57
%557 = load float, float* %45
%558 = call float @llvm.fmuladd.f32(float %555, float %556, float %557)
store float %558, float* %45
%559 = load float, float* %64
%560 = load float, float* %50
%561 = load float, float* %65
%562 = load float, float* %51
%563 = fmul float %561, %562
%564 = call float @llvm.fmuladd.f32(float %559, float %560, float %563)
%565 = load float, float* %66
%566 = load float, float* %52
%567 = call float @llvm.fmuladd.f32(float %565, float %566, float %564)
%568 = load float, float* %57
%569 = load float, float* %46
%570 = call float @llvm.fmuladd.f32(float %567, float %568, float %569)
store float %570, float* %46
%571 = load float, float* %44
%572 = load float*, float** %15
%573 = load i32, i32* %22
%574 = load i32, i32* %29
%575 = mul nsw i32 %573, %574
%576 = add nsw i32 2, %575
%577 = sext i32 %576 to i64
%578 = getelementptr inbounds float, float* %572, i64 %577
store float %571, float* %578
%579 = load float, float* %45
%580 = load float*, float** %15
%581 = load i32, i32* %22
%582 = load i32, i32* %29
%583 = mul nsw i32 %581, %582
%584 = add nsw i32 3, %583
%585 = sext i32 %584 to i64
%586 = getelementptr inbounds float, float* %580, i64 %585
store float %579, float* %586
%587 = load float, float* %46
%588 = load float*, float** %15
%589 = load i32, i32* %22
%590 = load i32, i32* %29
%591 = mul nsw i32 %589, %590
%592 = add nsw i32 4, %591
%593 = sext i32 %592 to i64
%594 = getelementptr inbounds float, float* %588, i64 %593
store float %587, float* %594
%595 = load float*, float** %15
%596 = load i32, i32* %22
%597 = load i32, i32* %29
%598 = mul nsw i32 %596, %597
%599 = sext i32 %598 to i64
%600 = getelementptr inbounds float, float* %595, i64 %599
%601 = load float, float* %600
%602 = load float, float* %44
%603 = load float, float* %20
%604 = call float @llvm.fmuladd.f32(float %602, float %603, float %601)
store float %604, float* %44
%605 = load float*, float** %15
%606 = load i32, i32* %22
%607 = load i32, i32* %29
%608 = mul nsw i32 %606, %607
%609 = add nsw i32 1, %608
%610 = sext i32 %609 to i64
%611 = getelementptr inbounds float, float* %605, i64 %610
%612 = load float, float* %611
%613 = load float, float* %45
%614 = load float, float* %20
%615 = call float @llvm.fmuladd.f32(float %613, float %614, float %612)
store float %615, float* %45
%616 = load i32, i32* %28
%617 = icmp eq i32 %616, 1
br i1 %617, label %618, label %651
618: ; preds = %103
%619 = load float, float* %44
%620 = load float, float* %36
%621 = fcmp olt float %619, %620
br i1 %621, label %622, label %626
622: ; preds = %618
%623 = load float, float* %38
%624 = load float, float* %44
%625 = fadd float %624, %623
store float %625, float* %44
br label %626
626: ; preds = %622, %618
%627 = load float, float* %44
%628 = load float, float* %38
%629 = fcmp oge float %627, %628
br i1 %629, label %630, label %634
630: ; preds = %626
%631 = load float, float* %38
%632 = load float, float* %44
%633 = fsub float %632, %631
store float %633, float* %44
br label %634
634: ; preds = %630, %626
%635 = load float, float* %45
%636 = load float, float* %37
%637 = fcmp olt float %635, %636
br i1 %637, label %638, label %642
638: ; preds = %634
%639 = load float, float* %39
%640 = load float, float* %45
%641 = fadd float %640, %639
store float %641, float* %45
br label %642
642: ; preds = %638, %634
%643 = load float, float* %45
%644 = load float, float* %39
%645 = fcmp oge float %643, %644
br i1 %645, label %646, label %650
646: ; preds = %642
%647 = load float, float* %39
%648 = load float, float* %45
%649 = fsub float %648, %647
store float %649, float* %45
br label %650
650: ; preds = %646, %642
br label %774
651: ; preds = %103
%652 = load i32, i32* %28
%653 = icmp eq i32 %652, 2
br i1 %653, label %654, label %720
654: ; preds = %651
%655 = load float, float* %44
%656 = load float, float* %36
%657 = fcmp olt float %655, %656
br i1 %657, label %662, label %658
658: ; preds = %654
%659 = load float, float* %44
%660 = load float, float* %38
%661 = fcmp oge float %659, %660
br i1 %661, label %662, label %686
662: ; preds = %658, %654
%663 = load float*, float** %15
%664 = load i32, i32* %22
%665 = load i32, i32* %29
%666 = mul nsw i32 %664, %665
%667 = sext i32 %666 to i64
%668 = getelementptr inbounds float, float* %663, i64 %667
%669 = load float, float* %668
store float %669, float* %44
%670 = load float*, float** %15
%671 = load i32, i32* %22
%672 = load i32, i32* %29
%673 = mul nsw i32 %671, %672
%674 = add nsw i32 2, %673
%675 = sext i32 %674 to i64
%676 = getelementptr inbounds float, float* %670, i64 %675
%677 = load float, float* %676
%678 = fneg float %677
%679 = load float*, float** %15
%680 = load i32, i32* %22
%681 = load i32, i32* %29
%682 = mul nsw i32 %680, %681
%683 = add nsw i32 2, %682
%684 = sext i32 %683 to i64
%685 = getelementptr inbounds float, float* %679, i64 %684
store float %678, float* %685
br label %686
686: ; preds = %662, %658
%687 = load float, float* %45
%688 = load float, float* %37
%689 = fcmp olt float %687, %688
br i1 %689, label %694, label %690
690: ; preds = %686
%691 = load float, float* %45
%692 = load float, float* %39
%693 = fcmp oge float %691, %692
br i1 %693, label %694, label %719
694: ; preds = %690, %686
%695 = load float*, float** %15
%696 = load i32, i32* %22
%697 = load i32, i32* %29
%698 = mul nsw i32 %696, %697
%699 = add nsw i32 1, %698
%700 = sext i32 %699 to i64
%701 = getelementptr inbounds float, float* %695, i64 %700
%702 = load float, float* %701
store float %702, float* %45
%703 = load float*, float** %15
%704 = load i32, i32* %22
%705 = load i32, i32* %29
%706 = mul nsw i32 %704, %705
%707 = add nsw i32 3, %706
%708 = sext i32 %707 to i64
%709 = getelementptr inbounds float, float* %703, i64 %708
%710 = load float, float* %709
%711 = fneg float %710
%712 = load float*, float** %15
%713 = load i32, i32* %22
%714 = load i32, i32* %29
%715 = mul nsw i32 %713, %714
%716 = add nsw i32 3, %715
%717 = sext i32 %716 to i64
%718 = getelementptr inbounds float, float* %712, i64 %717
store float %711, float* %718
br label %719
719: ; preds = %694, %690
br label %773
720: ; preds = %651
%721 = load i32, i32* %28
%722 = icmp eq i32 %721, 3
br i1 %722, label %723, label %772
723: ; preds = %720
%724 = load float, float* %44
%725 = load float, float* %36
%726 = fcmp olt float %724, %725
br i1 %726, label %731, label %727
727: ; preds = %723
%728 = load float, float* %44
%729 = load float, float* %38
%730 = fcmp oge float %728, %729
br i1 %730, label %731, label %755
731: ; preds = %727, %723
%732 = load float*, float** %15
%733 = load i32, i32* %22
%734 = load i32, i32* %29
%735 = mul nsw i32 %733, %734
%736 = sext i32 %735 to i64
%737 = getelementptr inbounds float, float* %732, i64 %736
%738 = load float, float* %737
store float %738, float* %44
%739 = load float*, float** %15
%740 = load i32, i32* %22
%741 = load i32, i32* %29
%742 = mul nsw i32 %740, %741
%743 = add nsw i32 2, %742
%744 = sext i32 %743 to i64
%745 = getelementptr inbounds float, float* %739, i64 %744
%746 = load float, float* %745
%747 = fneg float %746
%748 = load float*, float** %15
%749 = load i32, i32* %22
%750 = load i32, i32* %29
%751 = mul nsw i32 %749, %750
%752 = add nsw i32 2, %751
%753 = sext i32 %752 to i64
%754 = getelementptr inbounds float, float* %748, i64 %753
store float %747, float* %754
br label %755
755: ; preds = %731, %727
%756 = load float, float* %45
%757 = load float, float* %37
%758 = fcmp olt float %756, %757
br i1 %758, label %759, label %763
759: ; preds = %755
%760 = load float, float* %39
%761 = load float, float* %45
%762 = fadd float %761, %760
store float %762, float* %45
br label %763
763: ; preds = %759, %755
%764 = load float, float* %45
%765 = load float, float* %39
%766 = fcmp oge float %764, %765
br i1 %766, label %767, label %771
767: ; preds = %763
%768 = load float, float* %39
%769 = load float, float* %45
%770 = fsub float %769, %768
store float %770, float* %45
br label %771
771: ; preds = %767, %763
br label %772
772: ; preds = %771, %720
br label %773
773: ; preds = %772, %719
br label %774
774: ; preds = %773, %650
%775 = load float, float* %44
%776 = load float*, float** %15
%777 = load i32, i32* %22
%778 = load i32, i32* %29
%779 = mul nsw i32 %777, %778
%780 = sext i32 %779 to i64
%781 = getelementptr inbounds float, float* %776, i64 %780
store float %775, float* %781
%782 = load float, float* %45
%783 = load float*, float** %15
%784 = load i32, i32* %22
%785 = load i32, i32* %29
%786 = mul nsw i32 %784, %785
%787 = add nsw i32 1, %786
%788 = sext i32 %787 to i64
%789 = getelementptr inbounds float, float* %783, i64 %788
store float %782, float* %789
br label %790
790: ; preds = %774
%791 = load i32, i32* %29
%792 = add nsw i32 %791, 1
store i32 %792, i32* %29
br label %99
793: ; preds = %99
%794 = load double, double* %67
%795 = load float*, float** %21
%796 = load float, float* %795
%797 = fpext float %796 to double
%798 = call double @llvm.fmuladd.f64(double 5.000000e-01, double %794, double %797)
%799 = fptrunc double %798 to float
store float %799, float* %795
ret void
}

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