void cvprod(float *a, float *b, float *out, long N) {
  long OutCnt;
  float A0R;
  float A0I;
  float A1R;
  float A1I;
  float A2R;
  float A2I;
  float A3R;
  float A3I;
  float B0R;
  float B0I;
  float B1R;
  float B1I;
  float B2R;
  float B2I;
  float B3R;
  float B3I;
  float T0R;
  float T0I;
  float T1R;
  float T1I;
  float T2R;
  float T2I;
  float T3R;
  float T3I;
  if (N >= 4) {
    A0R = *a;
    B0R = *b;
    A0I = *(a + 1);
    B0I = *(b + 1);
    A1R = *(a + 2);
    B1R = *(b + 2);
    A1I = *(a + 3);
    B1I = *(b + 3);
    A2R = *(a + 4);
    B2R = *(b + 4);
    A2I = *(a + 5);
    B2I = *(b + 5);
    A3R = *(a + 6);
    B3R = *(b + 6);
    A3I = *(a + 7);
    B3I = *(b + 7);
    T0R = A0R * B0R;
    T0I = (A0R * B0I);
    T1R = A1R * B1R;
    T1I = (A1R * B1I);
    T2R = A2R * B2R;
    T2I = (A2R * B2I);
    T3R = A3R * B3R;
    T3I = (A3R * B3I);
    T0R -= (A0I * B0I);
    T0I = A0I * B0R + T0I;
    T1R -= (A1I * B1I);
    T1I = A1I * B1R + T1I;
    T2R -= (A2I * B2I);
    T2I = A2I * B2R + T2I;
    T3R -= (A3I * B3I);
    T3I = A3I * B3R + T3I;
    for (OutCnt = N / 4 - 1; OutCnt > 0; OutCnt--) {
      a += 8;
      b += 8;
      A0R = *a;
      B0R = *b;
      A0I = *(a + 1);
      B0I = *(b + 1);
      A1R = *(a + 2);
      B1R = *(b + 2);
      A1I = *(a + 3);
      B1I = *(b + 3);
      A2R = *(a + 4);
      B2R = *(b + 4);
      A2I = *(a + 5);
      B2I = *(b + 5);
      A3R = *(a + 6);
      B3R = *(b + 6);
      A3I = *(a + 7);
      B3I = *(b + 7);
      *out = T0R;
      *(out + 1) = T0I;
      *(out + 2) = T1R;
      *(out + 3) = T1I;
      *(out + 4) = T2R;
      *(out + 5) = T2I;
      *(out + 6) = T3R;
      *(out + 7) = T3I;
      T0R = A0R * B0R;
      T0I = (A0R * B0I);
      T1R = A1R * B1R;
      T1I = (A1R * B1I);
      T2R = A2R * B2R;
      T2I = (A2R * B2I);
      T3R = A3R * B3R;
      T3I = (A3R * B3I);
      T0R -= (A0I * B0I);
      T0I = A0I * B0R + T0I;
      T1R -= (A1I * B1I);
      T1I = A1I * B1R + T1I;
      T2R -= (A2I * B2I);
      T2I = A2I * B2R + T2I;
      T3R -= (A3I * B3I);
      T3I = A3I * B3R + T3I;
      out += 8;
    }
    a += 8;
    b += 8;
    *out = T0R;
    *(out + 1) = T0I;
    *(out + 2) = T1R;
    *(out + 3) = T1I;
    *(out + 4) = T2R;
    *(out + 5) = T2I;
    *(out + 6) = T3R;
    *(out + 7) = T3I;
    out += 8;
  }
  for (OutCnt = N % 4; OutCnt > 0; OutCnt--) {
    A0R = *a++;
    B0R = *b++;
    A0I = *a++;
    B0I = *b++;
    T0R = A0R * B0R;
    T0I = (A0R * B0I);
    T0R -= (A0I * B0I);
    T0I = A0I * B0R + T0I;
    *out++ = T0R;
    *out++ = T0I;
  }
}


x86 assembly (clang, -O0):
<cvprod>:
push   %rbp
mov    %rsp,%rbp
push   %rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
cmpq   $0x4,-0x20(%rbp)
jl     177c <cvprod+0x67c>
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x8(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x8(%rbp),%rax
movss  0x10(%rax),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x10(%rax),%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x8(%rbp),%rax
movss  0x14(%rax),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movss  0x14(%rax),%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x8(%rbp),%rax
movss  0x18(%rax),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x10(%rbp),%rax
movss  0x18(%rax),%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x8(%rbp),%rax
movss  0x1c(%rax),%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movss  0x1c(%rax),%xmm0
movss  %xmm0,-0x68(%rbp)
movss  -0x2c(%rbp),%xmm0
mulss  -0x4c(%rbp),%xmm0
movss  %xmm0,-0x6c(%rbp)
movss  -0x2c(%rbp),%xmm0
mulss  -0x50(%rbp),%xmm0
movss  %xmm0,-0x70(%rbp)
movss  -0x34(%rbp),%xmm0
mulss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x34(%rbp),%xmm0
mulss  -0x58(%rbp),%xmm0
movss  %xmm0,-0x78(%rbp)
movss  -0x3c(%rbp),%xmm0
mulss  -0x5c(%rbp),%xmm0
movss  %xmm0,-0x7c(%rbp)
movss  -0x3c(%rbp),%xmm0
mulss  -0x60(%rbp),%xmm0
movss  %xmm0,-0x80(%rbp)
movss  -0x44(%rbp),%xmm0
mulss  -0x64(%rbp),%xmm0
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x44(%rbp),%xmm0
mulss  -0x68(%rbp),%xmm0
movss  %xmm0,-0x88(%rbp)
ff
movss  -0x30(%rbp),%xmm0
movss  -0x50(%rbp),%xmm2
movss  -0x6c(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x6c(%rbp)
movss  -0x30(%rbp),%xmm0
movss  -0x4c(%rbp),%xmm2
movss  -0x70(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x70(%rbp)
movss  -0x38(%rbp),%xmm0
movss  -0x58(%rbp),%xmm2
movss  -0x74(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x38(%rbp),%xmm0
movss  -0x54(%rbp),%xmm2
movss  -0x78(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x78(%rbp)
movss  -0x40(%rbp),%xmm0
movss  -0x60(%rbp),%xmm2
movss  -0x7c(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x7c(%rbp)
movss  -0x40(%rbp),%xmm0
movss  -0x5c(%rbp),%xmm2
movss  -0x80(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x80(%rbp)
movss  -0x48(%rbp),%xmm0
movss  -0x68(%rbp),%xmm2
movss  -0x84(%rbp),%xmm1
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x48(%rbp),%xmm0
movss  -0x64(%rbp),%xmm2
movss  -0x88(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x88(%rbp)
ff
mov    -0x20(%rbp),%rax
mov    $0x4,%ecx
cqto
idiv   %rcx
sub    $0x1,%rax
mov    %rax,-0x28(%rbp)
cmpq   $0x0,-0x28(%rbp)
jle    16e3 <cvprod+0x5e3>
mov    -0x8(%rbp),%rax
add    $0x20,%rax
mov    %rax,-0x8(%rbp)
mov    -0x10(%rbp),%rax
add    $0x20,%rax
mov    %rax,-0x10(%rbp)
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x8(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x8(%rbp),%rax
movss  0x10(%rax),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x10(%rax),%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x8(%rbp),%rax
movss  0x14(%rax),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movss  0x14(%rax),%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x8(%rbp),%rax
movss  0x18(%rax),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x10(%rbp),%rax
movss  0x18(%rax),%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x8(%rbp),%rax
movss  0x1c(%rax),%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movss  0x1c(%rax),%xmm0
movss  %xmm0,-0x68(%rbp)
movss  -0x6c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x70(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x74(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movss  %xmm0,0x8(%rax)
movss  -0x78(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movss  %xmm0,0xc(%rax)
movss  -0x7c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movss  %xmm0,0x10(%rax)
movss  -0x80(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movss  %xmm0,0x14(%rax)
movss  -0x84(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movss  %xmm0,0x18(%rax)
movss  -0x88(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movss  %xmm0,0x1c(%rax)
movss  -0x2c(%rbp),%xmm0
mulss  -0x4c(%rbp),%xmm0
movss  %xmm0,-0x6c(%rbp)
movss  -0x2c(%rbp),%xmm0
mulss  -0x50(%rbp),%xmm0
movss  %xmm0,-0x70(%rbp)
movss  -0x34(%rbp),%xmm0
mulss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x34(%rbp),%xmm0
mulss  -0x58(%rbp),%xmm0
movss  %xmm0,-0x78(%rbp)
movss  -0x3c(%rbp),%xmm0
mulss  -0x5c(%rbp),%xmm0
movss  %xmm0,-0x7c(%rbp)
movss  -0x3c(%rbp),%xmm0
mulss  -0x60(%rbp),%xmm0
movss  %xmm0,-0x80(%rbp)
movss  -0x44(%rbp),%xmm0
mulss  -0x64(%rbp),%xmm0
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x44(%rbp),%xmm0
mulss  -0x68(%rbp),%xmm0
movss  %xmm0,-0x88(%rbp)
ff
movss  -0x30(%rbp),%xmm0
movss  -0x50(%rbp),%xmm2
movss  -0x6c(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x6c(%rbp)
movss  -0x30(%rbp),%xmm0
movss  -0x4c(%rbp),%xmm2
movss  -0x70(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x70(%rbp)
movss  -0x38(%rbp),%xmm0
movss  -0x58(%rbp),%xmm2
movss  -0x74(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x38(%rbp),%xmm0
movss  -0x54(%rbp),%xmm2
movss  -0x78(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x78(%rbp)
movss  -0x40(%rbp),%xmm0
movss  -0x60(%rbp),%xmm2
movss  -0x7c(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x7c(%rbp)
movss  -0x40(%rbp),%xmm0
movss  -0x5c(%rbp),%xmm2
movss  -0x80(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x80(%rbp)
movss  -0x48(%rbp),%xmm0
movss  -0x68(%rbp),%xmm2
movss  -0x84(%rbp),%xmm1
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x48(%rbp),%xmm0
movss  -0x64(%rbp),%xmm2
movss  -0x88(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x88(%rbp)
ff
mov    -0x18(%rbp),%rax
add    $0x20,%rax
mov    %rax,-0x18(%rbp)
mov    -0x28(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x28(%rbp)
jmp    13b2 <cvprod+0x2b2>
mov    -0x8(%rbp),%rax
add    $0x20,%rax
mov    %rax,-0x8(%rbp)
mov    -0x10(%rbp),%rax
add    $0x20,%rax
mov    %rax,-0x10(%rbp)
movss  -0x6c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x70(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x74(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movss  %xmm0,0x8(%rax)
movss  -0x78(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movss  %xmm0,0xc(%rax)
movss  -0x7c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movss  %xmm0,0x10(%rax)
movss  -0x80(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movss  %xmm0,0x14(%rax)
movss  -0x84(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movss  %xmm0,0x18(%rax)
movss  -0x88(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movss  %xmm0,0x1c(%rax)
mov    -0x18(%rbp),%rax
add    $0x20,%rax
mov    %rax,-0x18(%rbp)
mov    -0x20(%rbp),%rax
mov    $0x4,%ecx
cqto
idiv   %rcx
mov    %rdx,-0x28(%rbp)
cmpq   $0x0,-0x28(%rbp)
jle    189d <cvprod+0x79d>
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x8(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x10(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x8(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x10(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x2c(%rbp),%xmm0
mulss  -0x4c(%rbp),%xmm0
movss  %xmm0,-0x6c(%rbp)
movss  -0x2c(%rbp),%xmm0
mulss  -0x50(%rbp),%xmm0
movss  %xmm0,-0x70(%rbp)
movss  -0x30(%rbp),%xmm0
movss  -0x50(%rbp),%xmm2
movss  -0x6c(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x6c(%rbp)
movss  -0x30(%rbp),%xmm0
movss  -0x4c(%rbp),%xmm2
movss  -0x70(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x70(%rbp)
movss  -0x6c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x18(%rbp)
movss  %xmm0,(%rax)
movss  -0x70(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x18(%rbp)
movss  %xmm0,(%rax)
mov    -0x28(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x28(%rbp)
jmp    178e <cvprod+0x68e>
add    $0x8,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<cvprod>:
cmp    $0x4,%rcx
jl     126e <cvprod+0x16e>
movups (%rsi),%xmm2
movups 0x10(%rsi),%xmm3
movss  (%rdi),%xmm5
movss  0x4(%rdi),%xmm8
movss  0x8(%rdi),%xmm0
shufps $0x0,%xmm0,%xmm5
movss  0xc(%rdi),%xmm6
mulps  %xmm2,%xmm5
shufps $0xb1,%xmm2,%xmm2
movss  0x18(%rdi),%xmm0
movss  0x10(%rdi),%xmm4
shufps $0x0,%xmm0,%xmm4
mulps  %xmm3,%xmm4
shufps $0xb1,%xmm3,%xmm3
movaps 0xeb3(%rip),%xmm9
movaps %xmm8,%xmm0
xorps  %xmm9,%xmm0
movaps %xmm6,%xmm7
xorps  %xmm9,%xmm7
unpcklps %xmm6,%xmm7
unpcklps %xmm8,%xmm0
movlhps %xmm7,%xmm0
mulps  %xmm2,%xmm0
addps  %xmm5,%xmm0
movss  0x14(%rdi),%xmm5
movaps %xmm5,%xmm2
xorps  %xmm9,%xmm2
movss  0x1c(%rdi),%xmm6
movaps %xmm6,%xmm7
xorps  %xmm9,%xmm7
unpcklps %xmm6,%xmm7
unpcklps %xmm5,%xmm2
movlhps %xmm7,%xmm2
mulps  %xmm3,%xmm2
addps  %xmm4,%xmm2
cmp    $0x8,%rcx
jb     125b <cvprod+0x15b>
mov    %rcx,%rax
shr    $0x2,%rax
add    $0x1,%rax
nopl   0x0(%rax,%rax,1)
movss  0x38(%rdi),%xmm8
movss  0x30(%rdi),%xmm3
movss  0x20(%rdi),%xmm5
movss  0x24(%rdi),%xmm6
movss  0x28(%rdi),%xmm12
movss  0x2c(%rdi),%xmm1
movss  0x3c(%rdi),%xmm11
movss  0x34(%rdi),%xmm10
add    $0x20,%rdi
movups 0x20(%rsi),%xmm4
movups 0x30(%rsi),%xmm7
lea    0x20(%rsi),%rsi
shufps $0x0,%xmm12,%xmm5
mulps  %xmm4,%xmm5
shufps $0xb1,%xmm4,%xmm4
shufps $0x0,%xmm8,%xmm3
mulps  %xmm7,%xmm3
shufps $0xb1,%xmm7,%xmm7
movups %xmm0,(%rdx)
movups %xmm2,0x10(%rdx)
movaps %xmm6,%xmm0
xorps  %xmm9,%xmm0
movaps %xmm1,%xmm2
xorps  %xmm9,%xmm2
unpcklps %xmm1,%xmm2
unpcklps %xmm6,%xmm0
movlhps %xmm2,%xmm0
mulps  %xmm4,%xmm0
addps  %xmm5,%xmm0
movaps %xmm10,%xmm2
xorps  %xmm9,%xmm2
movaps %xmm11,%xmm1
xorps  %xmm9,%xmm1
unpcklps %xmm11,%xmm1
unpcklps %xmm10,%xmm2
movlhps %xmm1,%xmm2
mulps  %xmm7,%xmm2
addps  %xmm3,%xmm2
add    $0x20,%rdx
add    $0xffffffffffffffff,%rax
cmp    $0x2,%rax
ja     11b0 <cvprod+0xb0>
add    $0x20,%rdi
add    $0x20,%rsi
movups %xmm0,(%rdx)
movups %xmm2,0x10(%rdx)
add    $0x20,%rdx
lea    0x3(%rcx),%rax
test   %rcx,%rcx
cmovns %rcx,%rax
and    $0xfffffffffffffffc,%rax
sub    %rax,%rcx
test   %rcx,%rcx
jle    137a <cvprod+0x27a>
cmp    $0x4,%rcx
jb     1329 <cvprod+0x229>
lea    (%rdx,%rcx,8),%rax
lea    (%rdi,%rcx,8),%r8
lea    (%rsi,%rcx,8),%r9
cmp    %r8,%rdx
setb   %r10b
cmp    %rax,%rdi
setb   %r11b
cmp    %r9,%rdx
setb   %r9b
cmp    %rax,%rsi
setb   %r8b
test   %r11b,%r10b
jne    1329 <cvprod+0x229>
and    %r8b,%r9b
jne    1329 <cvprod+0x229>
mov    %rcx,%rax
and    $0xfffffffffffffffc,%rax
movups (%rdi),%xmm0
movups 0x10(%rdi),%xmm1
movaps %xmm0,%xmm2
shufps $0x88,%xmm1,%xmm2
shufps $0xdd,%xmm1,%xmm0
movups (%rsi),%xmm1
movups 0x10(%rsi),%xmm3
movaps %xmm1,%xmm4
shufps $0x88,%xmm3,%xmm4
shufps $0xdd,%xmm3,%xmm1
movaps %xmm2,%xmm3
mulps  %xmm4,%xmm3
mulps  %xmm1,%xmm2
mulps  %xmm0,%xmm1
subps  %xmm1,%xmm3
mulps  %xmm0,%xmm4
addps  %xmm2,%xmm4
movaps %xmm3,%xmm0
unpcklps %xmm4,%xmm0
unpckhps %xmm4,%xmm3
movups %xmm3,0x10(%rdx)
movups %xmm0,(%rdx)
cmp    %rax,%rcx
je     137a <cvprod+0x27a>
lea    (%rsi,%rax,8),%rsi
lea    (%rdx,%rax,8),%rdx
lea    (%rdi,%rax,8),%rdi
and    $0x3,%ecx
add    $0x1,%rcx
xor    %eax,%eax
nop
movss  (%rdi,%rax,1),%xmm0
movss  0x4(%rdi,%rax,1),%xmm1
movss  (%rsi,%rax,1),%xmm2
movss  0x4(%rsi,%rax,1),%xmm3
movaps %xmm0,%xmm4
mulss  %xmm2,%xmm4
mulss  %xmm3,%xmm0
mulss  %xmm1,%xmm3
subss  %xmm3,%xmm4
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  %xmm4,(%rdx,%rax,1)
movss  %xmm1,0x4(%rdx,%rax,1)
add    $0xffffffffffffffff,%rcx
add    $0x8,%rax
cmp    $0x1,%rcx
ja     1330 <cvprod+0x230>
ret

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

LLVM IR (-O2):
define void @cvprod(float* nocapture %0, float* nocapture %1, float* nocapture writeonly %2, i64 %3) {
%5 = icmp sgt i64 %3, 3
br i1 %5, label %6, label %125
6: ; preds = %4
%7 = load float, float* %0
%8 = getelementptr inbounds float, float* %0, i64 1
%9 = load float, float* %8
%10 = getelementptr inbounds float, float* %0, i64 2
%11 = load float, float* %10
%12 = getelementptr inbounds float, float* %0, i64 3
%13 = load float, float* %12
%14 = bitcast float* %1 to <4 x float>*
%15 = load <4 x float>, <4 x float>* %14
%16 = shufflevector <4 x float> %15, <4 x float> poison, <4 x i32> <i32 1, i32 0, i32 3, i32 2>
%17 = getelementptr inbounds float, float* %0, i64 4
%18 = load float, float* %17
%19 = getelementptr inbounds float, float* %1, i64 4
%20 = getelementptr inbounds float, float* %0, i64 5
%21 = load float, float* %20
%22 = getelementptr inbounds float, float* %0, i64 6
%23 = load float, float* %22
%24 = getelementptr inbounds float, float* %0, i64 7
%25 = load float, float* %24
%26 = bitcast float* %19 to <4 x float>*
%27 = load <4 x float>, <4 x float>* %26
%28 = shufflevector <4 x float> %27, <4 x float> poison, <4 x i32> <i32 1, i32 0, i32 3, i32 2>
%29 = insertelement <4 x float> poison, float %7, i64 0
%30 = insertelement <4 x float> %29, float %11, i64 1
%31 = shufflevector <4 x float> %30, <4 x float> poison, <4 x i32> <i32 0, i32 0, i32 1, i32 1>
%32 = fmul <4 x float> %31, %15
%33 = insertelement <4 x float> poison, float %18, i64 0
%34 = insertelement <4 x float> %33, float %23, i64 1
%35 = shufflevector <4 x float> %34, <4 x float> poison, <4 x i32> <i32 0, i32 0, i32 1, i32 1>
%36 = fmul <4 x float> %35, %27
%37 = fneg float %9
%38 = fneg float %13
%39 = insertelement <4 x float> poison, float %37, i64 0
%40 = insertelement <4 x float> %39, float %9, i64 1
%41 = insertelement <4 x float> %40, float %38, i64 2
%42 = insertelement <4 x float> %41, float %13, i64 3
%43 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %42, <4 x float> %16, <4 x float> %32)
%44 = fneg float %21
%45 = fneg float %25
%46 = insertelement <4 x float> poison, float %44, i64 0
%47 = insertelement <4 x float> %46, float %21, i64 1
%48 = insertelement <4 x float> %47, float %45, i64 2
%49 = insertelement <4 x float> %48, float %25, i64 3
%50 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %49, <4 x float> %28, <4 x float> %36)
%51 = icmp ugt i64 %3, 7
br i1 %51, label %52, label %113
52: ; preds = %6
%53 = lshr i64 %3, 2
br label %54
54: ; preds = %52, %54
%55 = phi i64 [ %61, %54 ], [ %53, %52 ]
%56 = phi float* [ %62, %54 ], [ %0, %52 ]
%57 = phi float* [ %111, %54 ], [ %2, %52 ]
%58 = phi float* [ %63, %54 ], [ %1, %52 ]
%59 = phi <4 x float> [ %103, %54 ], [ %43, %52 ]
%60 = phi <4 x float> [ %110, %54 ], [ %50, %52 ]
%61 = add nsw i64 %55, -1
%62 = getelementptr inbounds float, float* %56, i64 8
%63 = getelementptr inbounds float, float* %58, i64 8
%64 = load float, float* %62
%65 = getelementptr inbounds float, float* %56, i64 9
%66 = load float, float* %65
%67 = getelementptr inbounds float, float* %56, i64 10
%68 = load float, float* %67
%69 = getelementptr inbounds float, float* %56, i64 11
%70 = load float, float* %69
%71 = bitcast float* %63 to <4 x float>*
%72 = load <4 x float>, <4 x float>* %71
%73 = shufflevector <4 x float> %72, <4 x float> poison, <4 x i32> <i32 1, i32 0, i32 3, i32 2>
%74 = getelementptr inbounds float, float* %56, i64 12
%75 = load float, float* %74
%76 = getelementptr inbounds float, float* %58, i64 12
%77 = getelementptr inbounds float, float* %56, i64 13
%78 = load float, float* %77
%79 = getelementptr inbounds float, float* %56, i64 14
%80 = load float, float* %79
%81 = getelementptr inbounds float, float* %56, i64 15
%82 = load float, float* %81
%83 = bitcast float* %76 to <4 x float>*
%84 = load <4 x float>, <4 x float>* %83
%85 = shufflevector <4 x float> %84, <4 x float> poison, <4 x i32> <i32 1, i32 0, i32 3, i32 2>
%86 = bitcast float* %57 to <4 x float>*
store <4 x float> %59, <4 x float>* %86
%87 = getelementptr inbounds float, float* %57, i64 4
%88 = bitcast float* %87 to <4 x float>*
store <4 x float> %60, <4 x float>* %88
%89 = insertelement <4 x float> poison, float %64, i64 0
%90 = insertelement <4 x float> %89, float %68, i64 1
%91 = shufflevector <4 x float> %90, <4 x float> poison, <4 x i32> <i32 0, i32 0, i32 1, i32 1>
%92 = fmul <4 x float> %91, %72
%93 = insertelement <4 x float> poison, float %75, i64 0
%94 = insertelement <4 x float> %93, float %80, i64 1
%95 = shufflevector <4 x float> %94, <4 x float> poison, <4 x i32> <i32 0, i32 0, i32 1, i32 1>
%96 = fmul <4 x float> %95, %84
%97 = fneg float %66
%98 = fneg float %70
%99 = insertelement <4 x float> poison, float %97, i64 0
%100 = insertelement <4 x float> %99, float %66, i64 1
%101 = insertelement <4 x float> %100, float %98, i64 2
%102 = insertelement <4 x float> %101, float %70, i64 3
%103 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %102, <4 x float> %73, <4 x float> %92)
%104 = fneg float %78
%105 = fneg float %82
%106 = insertelement <4 x float> poison, float %104, i64 0
%107 = insertelement <4 x float> %106, float %78, i64 1
%108 = insertelement <4 x float> %107, float %105, i64 2
%109 = insertelement <4 x float> %108, float %82, i64 3
%110 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %109, <4 x float> %85, <4 x float> %96)
%111 = getelementptr inbounds float, float* %57, i64 8
%112 = icmp ugt i64 %55, 2
br i1 %112, label %54, label %113
113: ; preds = %54, %6
%114 = phi float* [ %1, %6 ], [ %63, %54 ]
%115 = phi float* [ %2, %6 ], [ %111, %54 ]
%116 = phi float* [ %0, %6 ], [ %62, %54 ]
%117 = phi <4 x float> [ %43, %6 ], [ %103, %54 ]
%118 = phi <4 x float> [ %50, %6 ], [ %110, %54 ]
%119 = getelementptr inbounds float, float* %116, i64 8
%120 = getelementptr inbounds float, float* %114, i64 8
%121 = bitcast float* %115 to <4 x float>*
store <4 x float> %117, <4 x float>* %121
%122 = getelementptr inbounds float, float* %115, i64 4
%123 = bitcast float* %122 to <4 x float>*
store <4 x float> %118, <4 x float>* %123
%124 = getelementptr inbounds float, float* %115, i64 8
br label %125
125: ; preds = %113, %4
%126 = phi float* [ %120, %113 ], [ %1, %4 ]
%127 = phi float* [ %124, %113 ], [ %2, %4 ]
%128 = phi float* [ %119, %113 ], [ %0, %4 ]
%129 = srem i64 %3, 4
%130 = icmp sgt i64 %129, 0
br i1 %130, label %131, label %197
131: ; preds = %125
%132 = icmp ult i64 %129, 4
br i1 %132, label %170, label %133
133: ; preds = %131
%134 = shl nsw i64 %129, 1
%135 = getelementptr float, float* %127, i64 %134
%136 = getelementptr float, float* %128, i64 %134
%137 = getelementptr float, float* %126, i64 %134
%138 = icmp ult float* %127, %136
%139 = icmp ult float* %128, %135
%140 = and i1 %138, %139
%141 = icmp ult float* %127, %137
%142 = icmp ult float* %126, %135
%143 = and i1 %141, %142
%144 = or i1 %140, %143
br i1 %144, label %170, label %145
145: ; preds = %133
%146 = and i64 %129, -4
%147 = shl nsw i64 %146, 1
%148 = getelementptr float, float* %126, i64 %147
%149 = shl nsw i64 %146, 1
%150 = getelementptr float, float* %127, i64 %149
%151 = shl nsw i64 %146, 1
%152 = getelementptr float, float* %128, i64 %151
%153 = and i64 %129, 3
%154 = bitcast float* %128 to <8 x float>*
%155 = load <8 x float>, <8 x float>* %154
%156 = shufflevector <8 x float> %155, <8 x float> poison, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
%157 = shufflevector <8 x float> %155, <8 x float> poison, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
%158 = bitcast float* %126 to <8 x float>*
%159 = load <8 x float>, <8 x float>* %158
%160 = shufflevector <8 x float> %159, <8 x float> poison, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
%161 = shufflevector <8 x float> %159, <8 x float> poison, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
%162 = fmul <4 x float> %156, %160
%163 = fmul <4 x float> %156, %161
%164 = fneg <4 x float> %157
%165 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %164, <4 x float> %161, <4 x float> %162)
%166 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %157, <4 x float> %160, <4 x float> %163)
%167 = bitcast float* %127 to <8 x float>*
%168 = shufflevector <4 x float> %165, <4 x float> %166, <8 x i32> <i32 0, i32 4, i32 1, i32 5, i32 2, i32 6, i32 3, i32 7>
store <8 x float> %168, <8 x float>* %167
%169 = icmp eq i64 %129, %146
br i1 %169, label %197, label %170
170: ; preds = %133, %131, %145
%171 = phi i64 [ %129, %133 ], [ %129, %131 ], [ %153, %145 ]
%172 = phi float* [ %128, %133 ], [ %128, %131 ], [ %152, %145 ]
%173 = phi float* [ %127, %133 ], [ %127, %131 ], [ %150, %145 ]
%174 = phi float* [ %126, %133 ], [ %126, %131 ], [ %148, %145 ]
br label %175
175: ; preds = %170, %175
%176 = phi i64 [ %195, %175 ], [ %171, %170 ]
%177 = phi float* [ %184, %175 ], [ %172, %170 ]
%178 = phi float* [ %194, %175 ], [ %173, %170 ]
%179 = phi float* [ %186, %175 ], [ %174, %170 ]
%180 = getelementptr inbounds float, float* %177, i64 1
%181 = load float, float* %177
%182 = getelementptr inbounds float, float* %179, i64 1
%183 = load float, float* %179
%184 = getelementptr inbounds float, float* %177, i64 2
%185 = load float, float* %180
%186 = getelementptr inbounds float, float* %179, i64 2
%187 = load float, float* %182
%188 = fmul float %181, %183
%189 = fmul float %181, %187
%190 = fneg float %185
%191 = tail call float @llvm.fmuladd.f32(float %190, float %187, float %188)
%192 = tail call float @llvm.fmuladd.f32(float %185, float %183, float %189)
%193 = getelementptr inbounds float, float* %178, i64 1
store float %191, float* %178
%194 = getelementptr inbounds float, float* %178, i64 2
store float %192, float* %193
%195 = add nsw i64 %176, -1
%196 = icmp ugt i64 %176, 1
br i1 %196, label %175, label %197
197: ; preds = %175, %145, %125
ret void
}