void cvprod(float *a, float *b, float *out, int N) {
  int 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
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
cmpl   $0x4,-0x1c(%rbp)
jl     1740 <cvprod+0x640>
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x24(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x28(%rbp)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x8(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x8(%rbp),%rax
movss  0x10(%rax),%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x10(%rbp),%rax
movss  0x10(%rax),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x8(%rbp),%rax
movss  0x14(%rax),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x10(%rbp),%rax
movss  0x14(%rax),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x8(%rbp),%rax
movss  0x18(%rax),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x18(%rax),%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x8(%rbp),%rax
movss  0x1c(%rax),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movss  0x1c(%rax),%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x24(%rbp),%xmm0
mulss  -0x44(%rbp),%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x24(%rbp),%xmm0
mulss  -0x48(%rbp),%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  -0x28(%rbp),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x64(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x28(%rbp),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x68(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x68(%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  -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)
mov    -0x1c(%rbp),%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
sub    $0x1,%eax
mov    %eax,-0x20(%rbp)
cmpl   $0x0,-0x20(%rbp)
jle    16ad <cvprod+0x5ad>
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,-0x24(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x28(%rbp)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x8(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x8(%rbp),%rax
movss  0x10(%rax),%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x10(%rbp),%rax
movss  0x10(%rax),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x8(%rbp),%rax
movss  0x14(%rax),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x10(%rbp),%rax
movss  0x14(%rax),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x8(%rbp),%rax
movss  0x18(%rax),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x18(%rax),%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x8(%rbp),%rax
movss  0x1c(%rax),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movss  0x1c(%rax),%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x64(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x68(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x6c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movss  %xmm0,0x8(%rax)
movss  -0x70(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movss  %xmm0,0xc(%rax)
movss  -0x74(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movss  %xmm0,0x10(%rax)
movss  -0x78(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movss  %xmm0,0x14(%rax)
movss  -0x7c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movss  %xmm0,0x18(%rax)
movss  -0x80(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movss  %xmm0,0x1c(%rax)
movss  -0x24(%rbp),%xmm0
mulss  -0x44(%rbp),%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x24(%rbp),%xmm0
mulss  -0x48(%rbp),%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  -0x28(%rbp),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x64(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x28(%rbp),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x68(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x68(%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  -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)
mov    -0x18(%rbp),%rax
add    $0x20,%rax
mov    %rax,-0x18(%rbp)
mov    -0x20(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x20(%rbp)
jmp    1398 <cvprod+0x298>
mov    -0x8(%rbp),%rax
add    $0x20,%rax
mov    %rax,-0x8(%rbp)
mov    -0x10(%rbp),%rax
add    $0x20,%rax
mov    %rax,-0x10(%rbp)
movss  -0x64(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x68(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x6c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movss  %xmm0,0x8(%rax)
movss  -0x70(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movss  %xmm0,0xc(%rax)
movss  -0x74(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movss  %xmm0,0x10(%rax)
movss  -0x78(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movss  %xmm0,0x14(%rax)
movss  -0x7c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movss  %xmm0,0x18(%rax)
movss  -0x80(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movss  %xmm0,0x1c(%rax)
mov    -0x18(%rbp),%rax
add    $0x20,%rax
mov    %rax,-0x18(%rbp)
mov    -0x1c(%rbp),%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
mov    %edx,-0x20(%rbp)
cmpl   $0x0,-0x20(%rbp)
jle    1859 <cvprod+0x759>
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x8(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0x24(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x10(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x8(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0x28(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x10(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x24(%rbp),%xmm0
mulss  -0x44(%rbp),%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x24(%rbp),%xmm0
mulss  -0x48(%rbp),%xmm0
movss  %xmm0,-0x68(%rbp)
movss  -0x28(%rbp),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x64(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x28(%rbp),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x68(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
movss  -0x64(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x18(%rbp)
movss  %xmm0,(%rax)
movss  -0x68(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x18(%rbp)
movss  %xmm0,(%rax)
mov    -0x20(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x20(%rbp)
jmp    174e <cvprod+0x64e>
pop    %rbp
ret

x86 assembly (clang, -O2):
<cvprod>:
push   %rbx
cmp    $0x4,%ecx
jl     126c <cvprod+0x16c>
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,%ecx
jb     1259 <cvprod+0x159>
mov    %ecx,%eax
shr    $0x2,%eax
add    $0x1,%eax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
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    $0xffffffff,%eax
cmp    $0x2,%eax
ja     11b0 <cvprod+0xb0>
add    $0x20,%rdi
add    $0x20,%rsi
movups %xmm0,(%rdx)
movups %xmm2,0x10(%rdx)
add    $0x20,%rdx
lea    0x3(%rcx),%eax
test   %ecx,%ecx
cmovns %ecx,%eax
and    $0xfffffffc,%eax
sub    %eax,%ecx
test   %ecx,%ecx
jle    13ac <cvprod+0x2ac>
lea    -0x1(%rcx),%r10d
cmp    $0x3,%r10d
jb     134f <cvprod+0x24f>
lea    (%rdx,%r10,8),%rbx
add    $0x8,%rbx
lea    (%rdi,%r10,8),%rax
add    $0x8,%rax
lea    (%rsi,%r10,8),%r8
add    $0x8,%r8
cmp    %rax,%rdx
setb   %r9b
cmp    %rbx,%rdi
setb   %r11b
cmp    %r8,%rdx
setb   %al
cmp    %rbx,%rsi
setb   %bl
test   %r11b,%r9b
jne    134f <cvprod+0x24f>
and    %bl,%al
jne    134f <cvprod+0x24f>
add    $0x1,%r10
mov    %r10,%r11
and    $0xfffffffffffffffc,%r11
sub    %r11d,%ecx
lea    (%rdi,%r11,8),%r8
lea    (%rdx,%r11,8),%r9
lea    (%rsi,%r11,8),%rax
xor    %ebx,%ebx
xchg   %ax,%ax
movups (%rdi,%rbx,8),%xmm0
movups 0x10(%rdi,%rbx,8),%xmm1
movaps %xmm0,%xmm2
shufps $0x88,%xmm1,%xmm2
shufps $0xdd,%xmm1,%xmm0
movups (%rsi,%rbx,8),%xmm1
movups 0x10(%rsi,%rbx,8),%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,%rbx,8)
movups %xmm0,(%rdx,%rbx,8)
add    $0x4,%rbx
cmp    %rbx,%r11
jne    12f0 <cvprod+0x1f0>
cmp    %r11,%r10
jne    1358 <cvprod+0x258>
jmp    13ac <cvprod+0x2ac>
mov    %rdi,%r8
mov    %rdx,%r9
mov    %rsi,%rax
add    $0x1,%ecx
xor    %edx,%edx
nopl   (%rax)
movss  (%r8,%rdx,1),%xmm0
movss  0x4(%r8,%rdx,1),%xmm1
movss  (%rax,%rdx,1),%xmm2
movss  0x4(%rax,%rdx,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,(%r9,%rdx,1)
movss  %xmm1,0x4(%r9,%rdx,1)
add    $0xffffffff,%ecx
add    $0x8,%rdx
cmp    $0x1,%ecx
ja     1360 <cvprod+0x260>
pop    %rbx
ret

LLVM IR (-O0):
define void @cvprod(float* %0, float* %1, float* %2, i32 %3) {
%5 = alloca float*
%6 = alloca float*
%7 = alloca float*
%8 = alloca i32
%9 = alloca i32
%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 i32 %3, i32* %8
%34 = load i32, i32* %8
%35 = icmp sge i32 %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 i32, i32* %8
%144 = sdiv i32 %143, 4
%145 = sub nsw i32 %144, 1
store i32 %145, i32* %9
br label %146
146: ; preds = %285, %36
%147 = load i32, i32* %9
%148 = icmp sgt i32 %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 i32, i32* %9
%287 = add nsw i32 %286, -1
store i32 %287, i32* %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 i32, i32* %8
%320 = srem i32 %319, 4
store i32 %320, i32* %9
br label %321
321: ; preds = %358, %318
%322 = load i32, i32* %9
%323 = icmp sgt i32 %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 i32, i32* %9
%360 = add nsw i32 %359, -1
store i32 %360, i32* %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, i32 %3) {
%5 = icmp sgt i32 %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 i32 %3, 7
br i1 %51, label %52, label %113
52: ; preds = %6
%53 = lshr i32 %3, 2
br label %54
54: ; preds = %52, %54
%55 = phi i32 [ %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 i32 %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 i32 %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 i32 %3, 4
%130 = icmp sgt i32 %129, 0
br i1 %130, label %131, label %215
131: ; preds = %125
%132 = add nsw i32 %129, -1
%133 = zext i32 %132 to i64
%134 = add nuw nsw i64 %133, 1
%135 = icmp ult i32 %132, 3
br i1 %135, label %188, label %136
136: ; preds = %131
%137 = add nsw i32 %129, -1
%138 = zext i32 %137 to i64
%139 = shl nuw nsw i64 %138, 1
%140 = add nuw nsw i64 %139, 2
%141 = getelementptr float, float* %127, i64 %140
%142 = getelementptr float, float* %128, i64 %140
%143 = getelementptr float, float* %126, i64 %140
%144 = icmp ult float* %127, %142
%145 = icmp ult float* %128, %141
%146 = and i1 %144, %145
%147 = icmp ult float* %127, %143
%148 = icmp ult float* %126, %141
%149 = and i1 %147, %148
%150 = or i1 %146, %149
br i1 %150, label %188, label %151
151: ; preds = %136
%152 = and i64 %134, 8589934588
%153 = trunc i64 %152 to i32
%154 = sub i32 %129, %153
%155 = shl nuw nsw i64 %152, 1
%156 = getelementptr float, float* %128, i64 %155
%157 = shl nuw nsw i64 %152, 1
%158 = getelementptr float, float* %127, i64 %157
%159 = shl nuw nsw i64 %152, 1
%160 = getelementptr float, float* %126, i64 %159
br label %161
161: ; preds = %161, %151
%162 = phi i64 [ 0, %151 ], [ %184, %161 ]
%163 = shl i64 %162, 1
%164 = getelementptr float, float* %128, i64 %163
%165 = shl i64 %162, 1
%166 = shl i64 %162, 1
%167 = getelementptr float, float* %126, i64 %166
%168 = bitcast float* %164 to <8 x float>*
%169 = load <8 x float>, <8 x float>* %168
%170 = shufflevector <8 x float> %169, <8 x float> poison, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
%171 = shufflevector <8 x float> %169, <8 x float> poison, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
%172 = bitcast float* %167 to <8 x float>*
%173 = load <8 x float>, <8 x float>* %172
%174 = shufflevector <8 x float> %173, <8 x float> poison, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
%175 = shufflevector <8 x float> %173, <8 x float> poison, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
%176 = fmul <4 x float> %170, %174
%177 = fmul <4 x float> %170, %175
%178 = fneg <4 x float> %171
%179 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %178, <4 x float> %175, <4 x float> %176)
%180 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %171, <4 x float> %174, <4 x float> %177)
%181 = getelementptr inbounds float, float* %127, i64 %165
%182 = bitcast float* %181 to <8 x float>*
%183 = shufflevector <4 x float> %179, <4 x float> %180, <8 x i32> <i32 0, i32 4, i32 1, i32 5, i32 2, i32 6, i32 3, i32 7>
store <8 x float> %183, <8 x float>* %182
%184 = add nuw i64 %162, 4
%185 = icmp eq i64 %184, %152
br i1 %185, label %186, label %161
186: ; preds = %161
%187 = icmp eq i64 %134, %152
br i1 %187, label %215, label %188
188: ; preds = %136, %131, %186
%189 = phi i32 [ %129, %136 ], [ %129, %131 ], [ %154, %186 ]
%190 = phi float* [ %128, %136 ], [ %128, %131 ], [ %156, %186 ]
%191 = phi float* [ %127, %136 ], [ %127, %131 ], [ %158, %186 ]
%192 = phi float* [ %126, %136 ], [ %126, %131 ], [ %160, %186 ]
br label %193
193: ; preds = %188, %193
%194 = phi i32 [ %213, %193 ], [ %189, %188 ]
%195 = phi float* [ %202, %193 ], [ %190, %188 ]
%196 = phi float* [ %212, %193 ], [ %191, %188 ]
%197 = phi float* [ %204, %193 ], [ %192, %188 ]
%198 = getelementptr inbounds float, float* %195, i64 1
%199 = load float, float* %195
%200 = getelementptr inbounds float, float* %197, i64 1
%201 = load float, float* %197
%202 = getelementptr inbounds float, float* %195, i64 2
%203 = load float, float* %198
%204 = getelementptr inbounds float, float* %197, i64 2
%205 = load float, float* %200
%206 = fmul float %199, %201
%207 = fmul float %199, %205
%208 = fneg float %203
%209 = tail call float @llvm.fmuladd.f32(float %208, float %205, float %206)
%210 = tail call float @llvm.fmuladd.f32(float %203, float %201, float %207)
%211 = getelementptr inbounds float, float* %196, i64 1
store float %209, float* %196
%212 = getelementptr inbounds float, float* %196, i64 2
store float %210, float* %211
%213 = add nsw i32 %194, -1
%214 = icmp ugt i32 %194, 1
br i1 %214, label %193, label %215
215: ; preds = %193, %186, %125
ret void
}