#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
void php_mul_vfmf_vf(const size_t rows, const size_t cols, const float *vec,
                     const float *mat, float *res) {
  const float *end_inp = vec + rows;
  size_t i = 0;
  size_t last_b8_col;
  last_b8_col = cols & ~(7);
  for (; i != last_b8_col; i += 8) {
    const float *inp = vec;
    const float *colp = mat;
    float csum0 = 0.0;
    float csum1 = 0.0;
    float csum2 = 0.0;
    float csum3 = 0.0;
    float csum4 = 0.0;
    float csum5 = 0.0;
    float csum6 = 0.0;
    float csum7 = 0.0;
    while (inp != end_inp) {
      const float velem = *inp++;
      csum0 += velem * colp[0];
      csum1 += velem * colp[1];
      csum2 += velem * colp[2];
      csum3 += velem * colp[3];
      csum4 += velem * colp[4];
      csum5 += velem * colp[5];
      csum6 += velem * colp[6];
      csum7 += velem * colp[7];
      colp += cols;
    }
    res[0] = csum0;
    res[1] = csum1;
    res[2] = csum2;
    res[3] = csum3;
    res[4] = csum4;
    res[5] = csum5;
    res[6] = csum6;
    res[7] = csum7;
    res += 8;
    mat += 8;
  }
  if (cols & 4) {
    const float *inp = vec;
    const float *colp = mat;
    float csum0 = 0.0;
    float csum1 = 0.0;
    float csum2 = 0.0;
    float csum3 = 0.0;
    while (inp != end_inp) {
      const float velem = *inp++;
      csum0 += velem * colp[0];
      csum1 += velem * colp[1];
      csum2 += velem * colp[2];
      csum3 += velem * colp[3];
      colp += cols;
    }
    res[0] = csum0;
    res[1] = csum1;
    res[2] = csum2;
    res[3] = csum3;
    res += 4;
    mat += 4;
  }
  if (cols & 2) {
    const float *inp = vec;
    const float *colp = mat;
    float csum0 = 0.0;
    float csum1 = 0.0;
    while (inp != end_inp) {
      const float velem = *inp++;
      csum0 += velem * colp[0];
      csum1 += velem * colp[1];
      colp += cols;
    }
    res[0] = csum0;
    res[1] = csum1;
    res += 2;
    mat += 2;
  }
  if (cols & 1) {
    const float *inp = vec;
    const float *colp = mat;
    float csum0 = 0.0;
    while (inp != end_inp) {
      const float velem = *inp++;
      csum0 += velem * colp[0];
      colp += cols;
    }
    res[0] = csum0;
    res += 1;
    mat += 1;
  }
}


x86 assembly (clang, -O0):
<php_mul_vfmf_vf>:
push   %rbp
mov    %rsp,%rbp
sub    $0x58,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x8(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
movq   $0x0,-0x38(%rbp)
mov    -0x10(%rbp),%rax
and    $0xfffffffffffffff8,%rax
mov    %rax,-0x40(%rbp)
mov    -0x38(%rbp),%rax
cmp    -0x40(%rbp),%rax
je     1373 <php_mul_vfmf_vf+0x273>
mov    -0x18(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x50(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x54(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x58(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x5c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x60(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x64(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x68(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x6c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x70(%rbp)
mov    -0x48(%rbp),%rax
cmp    -0x30(%rbp),%rax
je     12db <php_mul_vfmf_vf+0x1db>
mov    -0x48(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x48(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x74(%rbp),%xmm0
mov    -0x50(%rbp),%rax
movss  (%rax),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x74(%rbp),%xmm0
mov    -0x50(%rbp),%rax
movss  0x4(%rax),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x74(%rbp),%xmm0
mov    -0x50(%rbp),%rax
movss  0x8(%rax),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x74(%rbp),%xmm0
mov    -0x50(%rbp),%rax
movss  0xc(%rax),%xmm2
movss  -0x60(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x74(%rbp),%xmm0
mov    -0x50(%rbp),%rax
movss  0x10(%rax),%xmm2
movss  -0x64(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x74(%rbp),%xmm0
mov    -0x50(%rbp),%rax
movss  0x14(%rax),%xmm2
movss  -0x68(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
movss  -0x74(%rbp),%xmm0
mov    -0x50(%rbp),%rax
movss  0x18(%rax),%xmm2
movss  -0x6c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x6c(%rbp)
movss  -0x74(%rbp),%xmm0
mov    -0x50(%rbp),%rax
movss  0x1c(%rax),%xmm2
movss  -0x70(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x70(%rbp)
mov    -0x10(%rbp),%rax
shl    $0x2,%rax
add    -0x50(%rbp),%rax
mov    %rax,-0x50(%rbp)
jmp    11a1 <php_mul_vfmf_vf+0xa1>
movss  -0x54(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x58(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x5c(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,0x8(%rax)
movss  -0x60(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,0xc(%rax)
movss  -0x64(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,0x10(%rax)
movss  -0x68(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,0x14(%rax)
movss  -0x6c(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,0x18(%rax)
movss  -0x70(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,0x1c(%rax)
mov    -0x28(%rbp),%rax
add    $0x20,%rax
mov    %rax,-0x28(%rbp)
mov    -0x20(%rbp),%rax
add    $0x20,%rax
mov    %rax,-0x20(%rbp)
mov    -0x38(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x38(%rbp)
jmp    1143 <php_mul_vfmf_vf+0x43>
mov    -0x10(%rbp),%rax
and    $0x4,%rax
cmp    $0x0,%rax
je     1512 <php_mul_vfmf_vf+0x412>
mov    -0x18(%rbp),%rax
mov    %rax,-0x80(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x88(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0x90(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0x94(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0x98(%rbp)
ff
mov    -0x80(%rbp),%rax
cmp    -0x30(%rbp),%rax
je     14b7 <php_mul_vfmf_vf+0x3b7>
mov    -0x80(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x80(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0x9c(%rbp)
ff
movss  -0x9c(%rbp),%xmm0
ff
mov    -0x88(%rbp),%rax
movss  (%rax),%xmm2
movss  -0x8c(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
movss  -0x9c(%rbp),%xmm0
ff
mov    -0x88(%rbp),%rax
movss  0x4(%rax),%xmm2
movss  -0x90(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x90(%rbp)
ff
movss  -0x9c(%rbp),%xmm0
ff
mov    -0x88(%rbp),%rax
movss  0x8(%rax),%xmm2
movss  -0x94(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x94(%rbp)
ff
movss  -0x9c(%rbp),%xmm0
ff
mov    -0x88(%rbp),%rax
movss  0xc(%rax),%xmm2
movss  -0x98(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x98(%rbp)
ff
mov    -0x10(%rbp),%rax
shl    $0x2,%rax
add    -0x88(%rbp),%rax
mov    %rax,-0x88(%rbp)
jmp    13c4 <php_mul_vfmf_vf+0x2c4>
movss  -0x8c(%rbp),%xmm0
ff
mov    -0x28(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x90(%rbp),%xmm0
ff
mov    -0x28(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x94(%rbp),%xmm0
ff
mov    -0x28(%rbp),%rax
movss  %xmm0,0x8(%rax)
movss  -0x98(%rbp),%xmm0
ff
mov    -0x28(%rbp),%rax
movss  %xmm0,0xc(%rax)
mov    -0x28(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x28(%rbp)
mov    -0x20(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x20(%rbp)
mov    -0x10(%rbp),%rax
and    $0x2,%rax
cmp    $0x0,%rax
je     162d <php_mul_vfmf_vf+0x52d>
mov    -0x18(%rbp),%rax
mov    %rax,-0xa8(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0xb0(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0xb4(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0xb8(%rbp)
ff
mov    -0xa8(%rbp),%rax
cmp    -0x30(%rbp),%rax
je     15f4 <php_mul_vfmf_vf+0x4f4>
mov    -0xa8(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0xa8(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0xbc(%rbp)
ff
movss  -0xbc(%rbp),%xmm0
ff
mov    -0xb0(%rbp),%rax
movss  (%rax),%xmm2
movss  -0xb4(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xb4(%rbp)
ff
movss  -0xbc(%rbp),%xmm0
ff
mov    -0xb0(%rbp),%rax
movss  0x4(%rax),%xmm2
movss  -0xb8(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xb8(%rbp)
ff
mov    -0x10(%rbp),%rax
shl    $0x2,%rax
add    -0xb0(%rbp),%rax
mov    %rax,-0xb0(%rbp)
jmp    1550 <php_mul_vfmf_vf+0x450>
movss  -0xb4(%rbp),%xmm0
ff
mov    -0x28(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0xb8(%rbp),%xmm0
ff
mov    -0x28(%rbp),%rax
movss  %xmm0,0x4(%rax)
mov    -0x28(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x20(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x20(%rbp)
mov    -0x10(%rbp),%rax
and    $0x1,%rax
cmp    $0x0,%rax
je     1700 <php_mul_vfmf_vf+0x600>
mov    -0x18(%rbp),%rax
mov    %rax,-0xc8(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0xd0(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0xd4(%rbp)
ff
mov    -0xc8(%rbp),%rax
cmp    -0x30(%rbp),%rax
je     16d8 <php_mul_vfmf_vf+0x5d8>
mov    -0xc8(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0xc8(%rbp)
movss  (%rax),%xmm0
movss  %xmm0,-0xd8(%rbp)
ff
movss  -0xd8(%rbp),%xmm0
ff
mov    -0xd0(%rbp),%rax
movss  (%rax),%xmm2
movss  -0xd4(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xd4(%rbp)
ff
mov    -0x10(%rbp),%rax
shl    $0x2,%rax
add    -0xd0(%rbp),%rax
mov    %rax,-0xd0(%rbp)
jmp    1660 <php_mul_vfmf_vf+0x560>
movss  -0xd4(%rbp),%xmm0
ff
mov    -0x28(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x28(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x28(%rbp)
mov    -0x20(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x20(%rbp)
add    $0x58,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<php_mul_vfmf_vf>:
push   %r15
push   %r14
push   %rbx
mov    %rsi,%r9
and    $0xfffffffffffffff8,%r9
je     11ac <php_mul_vfmf_vf+0xac>
lea    0x0(,%rdi,4),%r11
lea    0x10(%rcx),%r10
lea    0x0(,%rsi,4),%r15
xor    %r14d,%r14d
jmp    1154 <php_mul_vfmf_vf+0x54>
nopl   0x0(%rax,%rax,1)
xorps  %xmm0,%xmm0
xorps  %xmm1,%xmm1
movups %xmm0,(%r8)
movups %xmm1,0x10(%r8)
add    $0x20,%r8
add    $0x20,%rcx
add    $0x8,%r14
add    $0x20,%r10
cmp    %r9,%r14
je     11ac <php_mul_vfmf_vf+0xac>
test   %rdi,%rdi
je     1130 <php_mul_vfmf_vf+0x30>
xorps  %xmm4,%xmm4
mov    %r10,%rbx
xor    %eax,%eax
xorps  %xmm5,%xmm5
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movaps %xmm5,%xmm3
movaps %xmm4,%xmm2
movups -0x10(%rbx),%xmm0
movups (%rbx),%xmm5
movss  (%rdx,%rax,1),%xmm1
shufps $0x0,%xmm1,%xmm1
mulps  %xmm1,%xmm0
movaps %xmm0,%xmm4
addps  %xmm2,%xmm4
mulps  %xmm5,%xmm1
movaps %xmm1,%xmm5
addps  %xmm3,%xmm5
add    $0x4,%rax
add    %r15,%rbx
cmp    %rax,%r11
jne    1170 <php_mul_vfmf_vf+0x70>
addps  %xmm3,%xmm1
addps  %xmm2,%xmm0
jmp    1136 <php_mul_vfmf_vf+0x36>
test   $0x4,%sil
jne    11c7 <php_mul_vfmf_vf+0xc7>
test   $0x2,%sil
jne    122e <php_mul_vfmf_vf+0x12e>
test   $0x1,%sil
jne    129a <php_mul_vfmf_vf+0x19a>
jmp    12d3 <php_mul_vfmf_vf+0x1d3>
test   %rdi,%rdi
je     1219 <php_mul_vfmf_vf+0x119>
lea    0x0(,%rsi,4),%r9
lea    0x0(,%rdi,4),%r10
xorps  %xmm2,%xmm2
xor    %eax,%eax
mov    %rcx,%rbx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movaps %xmm2,%xmm1
movups (%rbx),%xmm2
movss  (%rdx,%rax,1),%xmm0
shufps $0x0,%xmm0,%xmm0
mulps  %xmm2,%xmm0
movaps %xmm0,%xmm2
addps  %xmm1,%xmm2
add    %r9,%rbx
add    $0x4,%rax
cmp    %rax,%r10
jne    11f0 <php_mul_vfmf_vf+0xf0>
addps  %xmm1,%xmm0
jmp    121c <php_mul_vfmf_vf+0x11c>
xorps  %xmm0,%xmm0
movups %xmm0,(%r8)
add    $0x10,%r8
add    $0x10,%rcx
test   $0x2,%sil
je     11b8 <php_mul_vfmf_vf+0xb8>
test   %rdi,%rdi
je     127a <php_mul_vfmf_vf+0x17a>
lea    0x0(,%rsi,4),%r9
lea    0x0(,%rdi,4),%r10
xorps  %xmm2,%xmm2
xor    %eax,%eax
mov    %rcx,%rbx
nopl   0x0(%rax,%rax,1)
movaps %xmm2,%xmm1
movsd  (%rbx),%xmm2
movss  (%rdx,%rax,1),%xmm0
shufps $0x0,%xmm0,%xmm0
mulps  %xmm2,%xmm0
movaps %xmm0,%xmm2
addps  %xmm1,%xmm2
add    %r9,%rbx
add    $0x4,%rax
cmp    %rax,%r10
jne    1250 <php_mul_vfmf_vf+0x150>
addps  %xmm1,%xmm0
jmp    127d <php_mul_vfmf_vf+0x17d>
xorps  %xmm0,%xmm0
movss  %xmm0,(%r8)
shufps $0x55,%xmm0,%xmm0
movss  %xmm0,0x4(%r8)
add    $0x8,%r8
add    $0x8,%rcx
test   $0x1,%sil
je     12d3 <php_mul_vfmf_vf+0x1d3>
test   %rdi,%rdi
je     12cb <php_mul_vfmf_vf+0x1cb>
shl    $0x2,%rsi
shl    $0x2,%rdi
xorps  %xmm0,%xmm0
xor    %eax,%eax
nopl   0x0(%rax)
movss  (%rdx,%rax,1),%xmm1
mulss  (%rcx),%xmm1
addss  %xmm1,%xmm0
add    %rsi,%rcx
add    $0x4,%rax
cmp    %rax,%rdi
jne    12b0 <php_mul_vfmf_vf+0x1b0>
jmp    12ce <php_mul_vfmf_vf+0x1ce>
xorps  %xmm0,%xmm0
movss  %xmm0,(%r8)
pop    %rbx
pop    %r14
pop    %r15
ret

LLVM IR (-O0):
define void @php_mul_vfmf_vf(i64 %0, i64 %1, float* %2, float* %3, float* %4) {
%6 = alloca i64
%7 = alloca i64
%8 = alloca float*
%9 = alloca float*
%10 = alloca float*
%11 = alloca float*
%12 = alloca i64
%13 = alloca i64
%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*
%34 = alloca float
%35 = alloca float
%36 = alloca float
%37 = alloca float*
%38 = alloca float*
%39 = alloca float
%40 = alloca float
store i64 %0, i64* %6
store i64 %1, i64* %7
store float* %2, float** %8
store float* %3, float** %9
store float* %4, float** %10
%41 = load float*, float** %8
%42 = load i64, i64* %6
%43 = getelementptr inbounds float, float* %41, i64 %42
store float* %43, float** %11
store i64 0, i64* %12
%44 = load i64, i64* %7
%45 = and i64 %44, -8
store i64 %45, i64* %13
br label %46
46: ; preds = %141, %5
%47 = load i64, i64* %12
%48 = load i64, i64* %13
%49 = icmp ne i64 %47, %48
br i1 %49, label %50, label %144
50: ; preds = %46
%51 = load float*, float** %8
store float* %51, float** %14
%52 = load float*, float** %9
store float* %52, float** %15
store float 0.000000e+00, float* %16
store float 0.000000e+00, float* %17
store float 0.000000e+00, float* %18
store float 0.000000e+00, float* %19
store float 0.000000e+00, float* %20
store float 0.000000e+00, float* %21
store float 0.000000e+00, float* %22
store float 0.000000e+00, float* %23
br label %53
53: ; preds = %57, %50
%54 = load float*, float** %14
%55 = load float*, float** %11
%56 = icmp ne float* %54, %55
br i1 %56, label %57, label %112
57: ; preds = %53
%58 = load float*, float** %14
%59 = getelementptr inbounds float, float* %58, i32 1
store float* %59, float** %14
%60 = load float, float* %58
store float %60, float* %24
%61 = load float, float* %24
%62 = load float*, float** %15
%63 = getelementptr inbounds float, float* %62, i64 0
%64 = load float, float* %63
%65 = load float, float* %16
%66 = call float @llvm.fmuladd.f32(float %61, float %64, float %65)
store float %66, float* %16
%67 = load float, float* %24
%68 = load float*, float** %15
%69 = getelementptr inbounds float, float* %68, i64 1
%70 = load float, float* %69
%71 = load float, float* %17
%72 = call float @llvm.fmuladd.f32(float %67, float %70, float %71)
store float %72, float* %17
%73 = load float, float* %24
%74 = load float*, float** %15
%75 = getelementptr inbounds float, float* %74, i64 2
%76 = load float, float* %75
%77 = load float, float* %18
%78 = call float @llvm.fmuladd.f32(float %73, float %76, float %77)
store float %78, float* %18
%79 = load float, float* %24
%80 = load float*, float** %15
%81 = getelementptr inbounds float, float* %80, i64 3
%82 = load float, float* %81
%83 = load float, float* %19
%84 = call float @llvm.fmuladd.f32(float %79, float %82, float %83)
store float %84, float* %19
%85 = load float, float* %24
%86 = load float*, float** %15
%87 = getelementptr inbounds float, float* %86, i64 4
%88 = load float, float* %87
%89 = load float, float* %20
%90 = call float @llvm.fmuladd.f32(float %85, float %88, float %89)
store float %90, float* %20
%91 = load float, float* %24
%92 = load float*, float** %15
%93 = getelementptr inbounds float, float* %92, i64 5
%94 = load float, float* %93
%95 = load float, float* %21
%96 = call float @llvm.fmuladd.f32(float %91, float %94, float %95)
store float %96, float* %21
%97 = load float, float* %24
%98 = load float*, float** %15
%99 = getelementptr inbounds float, float* %98, i64 6
%100 = load float, float* %99
%101 = load float, float* %22
%102 = call float @llvm.fmuladd.f32(float %97, float %100, float %101)
store float %102, float* %22
%103 = load float, float* %24
%104 = load float*, float** %15
%105 = getelementptr inbounds float, float* %104, i64 7
%106 = load float, float* %105
%107 = load float, float* %23
%108 = call float @llvm.fmuladd.f32(float %103, float %106, float %107)
store float %108, float* %23
%109 = load i64, i64* %7
%110 = load float*, float** %15
%111 = getelementptr inbounds float, float* %110, i64 %109
store float* %111, float** %15
br label %53
112: ; preds = %53
%113 = load float, float* %16
%114 = load float*, float** %10
%115 = getelementptr inbounds float, float* %114, i64 0
store float %113, float* %115
%116 = load float, float* %17
%117 = load float*, float** %10
%118 = getelementptr inbounds float, float* %117, i64 1
store float %116, float* %118
%119 = load float, float* %18
%120 = load float*, float** %10
%121 = getelementptr inbounds float, float* %120, i64 2
store float %119, float* %121
%122 = load float, float* %19
%123 = load float*, float** %10
%124 = getelementptr inbounds float, float* %123, i64 3
store float %122, float* %124
%125 = load float, float* %20
%126 = load float*, float** %10
%127 = getelementptr inbounds float, float* %126, i64 4
store float %125, float* %127
%128 = load float, float* %21
%129 = load float*, float** %10
%130 = getelementptr inbounds float, float* %129, i64 5
store float %128, float* %130
%131 = load float, float* %22
%132 = load float*, float** %10
%133 = getelementptr inbounds float, float* %132, i64 6
store float %131, float* %133
%134 = load float, float* %23
%135 = load float*, float** %10
%136 = getelementptr inbounds float, float* %135, i64 7
store float %134, float* %136
%137 = load float*, float** %10
%138 = getelementptr inbounds float, float* %137, i64 8
store float* %138, float** %10
%139 = load float*, float** %9
%140 = getelementptr inbounds float, float* %139, i64 8
store float* %140, float** %9
br label %141
141: ; preds = %112
%142 = load i64, i64* %12
%143 = add i64 %142, 8
store i64 %143, i64* %12
br label %46
144: ; preds = %46
%145 = load i64, i64* %7
%146 = and i64 %145, 4
%147 = icmp ne i64 %146, 0
br i1 %147, label %148, label %203
148: ; preds = %144
%149 = load float*, float** %8
store float* %149, float** %25
%150 = load float*, float** %9
store float* %150, float** %26
store float 0.000000e+00, float* %27
store float 0.000000e+00, float* %28
store float 0.000000e+00, float* %29
store float 0.000000e+00, float* %30
br label %151
151: ; preds = %155, %148
%152 = load float*, float** %25
%153 = load float*, float** %11
%154 = icmp ne float* %152, %153
br i1 %154, label %155, label %186
155: ; preds = %151
%156 = load float*, float** %25
%157 = getelementptr inbounds float, float* %156, i32 1
store float* %157, float** %25
%158 = load float, float* %156
store float %158, float* %31
%159 = load float, float* %31
%160 = load float*, float** %26
%161 = getelementptr inbounds float, float* %160, i64 0
%162 = load float, float* %161
%163 = load float, float* %27
%164 = call float @llvm.fmuladd.f32(float %159, float %162, float %163)
store float %164, float* %27
%165 = load float, float* %31
%166 = load float*, float** %26
%167 = getelementptr inbounds float, float* %166, i64 1
%168 = load float, float* %167
%169 = load float, float* %28
%170 = call float @llvm.fmuladd.f32(float %165, float %168, float %169)
store float %170, float* %28
%171 = load float, float* %31
%172 = load float*, float** %26
%173 = getelementptr inbounds float, float* %172, i64 2
%174 = load float, float* %173
%175 = load float, float* %29
%176 = call float @llvm.fmuladd.f32(float %171, float %174, float %175)
store float %176, float* %29
%177 = load float, float* %31
%178 = load float*, float** %26
%179 = getelementptr inbounds float, float* %178, i64 3
%180 = load float, float* %179
%181 = load float, float* %30
%182 = call float @llvm.fmuladd.f32(float %177, float %180, float %181)
store float %182, float* %30
%183 = load i64, i64* %7
%184 = load float*, float** %26
%185 = getelementptr inbounds float, float* %184, i64 %183
store float* %185, float** %26
br label %151
186: ; preds = %151
%187 = load float, float* %27
%188 = load float*, float** %10
%189 = getelementptr inbounds float, float* %188, i64 0
store float %187, float* %189
%190 = load float, float* %28
%191 = load float*, float** %10
%192 = getelementptr inbounds float, float* %191, i64 1
store float %190, float* %192
%193 = load float, float* %29
%194 = load float*, float** %10
%195 = getelementptr inbounds float, float* %194, i64 2
store float %193, float* %195
%196 = load float, float* %30
%197 = load float*, float** %10
%198 = getelementptr inbounds float, float* %197, i64 3
store float %196, float* %198
%199 = load float*, float** %10
%200 = getelementptr inbounds float, float* %199, i64 4
store float* %200, float** %10
%201 = load float*, float** %9
%202 = getelementptr inbounds float, float* %201, i64 4
store float* %202, float** %9
br label %203
203: ; preds = %186, %144
%204 = load i64, i64* %7
%205 = and i64 %204, 2
%206 = icmp ne i64 %205, 0
br i1 %206, label %207, label %244
207: ; preds = %203
%208 = load float*, float** %8
store float* %208, float** %32
%209 = load float*, float** %9
store float* %209, float** %33
store float 0.000000e+00, float* %34
store float 0.000000e+00, float* %35
br label %210
210: ; preds = %214, %207
%211 = load float*, float** %32
%212 = load float*, float** %11
%213 = icmp ne float* %211, %212
br i1 %213, label %214, label %233
214: ; preds = %210
%215 = load float*, float** %32
%216 = getelementptr inbounds float, float* %215, i32 1
store float* %216, float** %32
%217 = load float, float* %215
store float %217, float* %36
%218 = load float, float* %36
%219 = load float*, float** %33
%220 = getelementptr inbounds float, float* %219, i64 0
%221 = load float, float* %220
%222 = load float, float* %34
%223 = call float @llvm.fmuladd.f32(float %218, float %221, float %222)
store float %223, float* %34
%224 = load float, float* %36
%225 = load float*, float** %33
%226 = getelementptr inbounds float, float* %225, i64 1
%227 = load float, float* %226
%228 = load float, float* %35
%229 = call float @llvm.fmuladd.f32(float %224, float %227, float %228)
store float %229, float* %35
%230 = load i64, i64* %7
%231 = load float*, float** %33
%232 = getelementptr inbounds float, float* %231, i64 %230
store float* %232, float** %33
br label %210
233: ; preds = %210
%234 = load float, float* %34
%235 = load float*, float** %10
%236 = getelementptr inbounds float, float* %235, i64 0
store float %234, float* %236
%237 = load float, float* %35
%238 = load float*, float** %10
%239 = getelementptr inbounds float, float* %238, i64 1
store float %237, float* %239
%240 = load float*, float** %10
%241 = getelementptr inbounds float, float* %240, i64 2
store float* %241, float** %10
%242 = load float*, float** %9
%243 = getelementptr inbounds float, float* %242, i64 2
store float* %243, float** %9
br label %244
244: ; preds = %233, %203
%245 = load i64, i64* %7
%246 = and i64 %245, 1
%247 = icmp ne i64 %246, 0
br i1 %247, label %248, label %276
248: ; preds = %244
%249 = load float*, float** %8
store float* %249, float** %37
%250 = load float*, float** %9
store float* %250, float** %38
store float 0.000000e+00, float* %39
br label %251
251: ; preds = %255, %248
%252 = load float*, float** %37
%253 = load float*, float** %11
%254 = icmp ne float* %252, %253
br i1 %254, label %255, label %268
255: ; preds = %251
%256 = load float*, float** %37
%257 = getelementptr inbounds float, float* %256, i32 1
store float* %257, float** %37
%258 = load float, float* %256
store float %258, float* %40
%259 = load float, float* %40
%260 = load float*, float** %38
%261 = getelementptr inbounds float, float* %260, i64 0
%262 = load float, float* %261
%263 = load float, float* %39
%264 = call float @llvm.fmuladd.f32(float %259, float %262, float %263)
store float %264, float* %39
%265 = load i64, i64* %7
%266 = load float*, float** %38
%267 = getelementptr inbounds float, float* %266, i64 %265
store float* %267, float** %38
br label %251
268: ; preds = %251
%269 = load float, float* %39
%270 = load float*, float** %10
%271 = getelementptr inbounds float, float* %270, i64 0
store float %269, float* %271
%272 = load float*, float** %10
%273 = getelementptr inbounds float, float* %272, i64 1
store float* %273, float** %10
%274 = load float*, float** %9
%275 = getelementptr inbounds float, float* %274, i64 1
store float* %275, float** %9
br label %276
276: ; preds = %268, %244
ret void
}

LLVM IR (-O2):
define void @php_mul_vfmf_vf(i64 %0, i64 %1, float* %2, float* nocapture %3, float* nocapture writeonly %4) {
%6 = getelementptr inbounds float, float* %2, i64 %0
%7 = and i64 %1, -8
%8 = icmp eq i64 %7, 0
br i1 %8, label %46, label %9
9: ; preds = %5
%10 = icmp eq i64 %0, 0
br label %11
11: ; preds = %9, %36
%12 = phi float* [ %3, %9 ], [ %43, %36 ]
%13 = phi float* [ %4, %9 ], [ %42, %36 ]
%14 = phi i64 [ 0, %9 ], [ %44, %36 ]
br i1 %10, label %36, label %15
15: ; preds = %11, %15
%16 = phi float* [ %20, %15 ], [ %2, %11 ]
%17 = phi float* [ %31, %15 ], [ %12, %11 ]
%18 = phi <4 x float> [ %26, %15 ], [ zeroinitializer, %11 ]
%19 = phi <4 x float> [ %30, %15 ], [ zeroinitializer, %11 ]
%20 = getelementptr inbounds float, float* %16, i64 1
%21 = load float, float* %16
%22 = bitcast float* %17 to <4 x float>*
%23 = load <4 x float>, <4 x float>* %22
%24 = insertelement <4 x float> poison, float %21, i64 0
%25 = shufflevector <4 x float> %24, <4 x float> poison, <4 x i32> zeroinitializer
%26 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %25, <4 x float> %23, <4 x float> %18)
%27 = getelementptr inbounds float, float* %17, i64 4
%28 = bitcast float* %27 to <4 x float>*
%29 = load <4 x float>, <4 x float>* %28
%30 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %25, <4 x float> %29, <4 x float> %19)
%31 = getelementptr inbounds float, float* %17, i64 %1
%32 = icmp eq float* %20, %6
br i1 %32, label %33, label %15
33: ; preds = %15
%34 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %25, <4 x float> %29, <4 x float> %19)
%35 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %25, <4 x float> %23, <4 x float> %18)
br label %36
36: ; preds = %33, %11
%37 = phi <4 x float> [ zeroinitializer, %11 ], [ %35, %33 ]
%38 = phi <4 x float> [ zeroinitializer, %11 ], [ %34, %33 ]
%39 = bitcast float* %13 to <4 x float>*
store <4 x float> %37, <4 x float>* %39
%40 = getelementptr inbounds float, float* %13, i64 4
%41 = bitcast float* %40 to <4 x float>*
store <4 x float> %38, <4 x float>* %41
%42 = getelementptr inbounds float, float* %13, i64 8
%43 = getelementptr inbounds float, float* %12, i64 8
%44 = add i64 %14, 8
%45 = icmp eq i64 %44, %7
br i1 %45, label %46, label %11
46: ; preds = %36, %5
%47 = phi float* [ %4, %5 ], [ %42, %36 ]
%48 = phi float* [ %3, %5 ], [ %43, %36 ]
%49 = and i64 %1, 4
%50 = icmp eq i64 %49, 0
br i1 %50, label %73, label %51
51: ; preds = %46
%52 = icmp eq i64 %0, 0
br i1 %52, label %68, label %53
53: ; preds = %51, %53
%54 = phi float* [ %64, %53 ], [ %48, %51 ]
%55 = phi float* [ %57, %53 ], [ %2, %51 ]
%56 = phi <4 x float> [ %63, %53 ], [ zeroinitializer, %51 ]
%57 = getelementptr inbounds float, float* %55, i64 1
%58 = load float, float* %55
%59 = bitcast float* %54 to <4 x float>*
%60 = load <4 x float>, <4 x float>* %59
%61 = insertelement <4 x float> poison, float %58, i64 0
%62 = shufflevector <4 x float> %61, <4 x float> poison, <4 x i32> zeroinitializer
%63 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %62, <4 x float> %60, <4 x float> %56)
%64 = getelementptr inbounds float, float* %54, i64 %1
%65 = icmp eq float* %57, %6
br i1 %65, label %66, label %53
66: ; preds = %53
%67 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %62, <4 x float> %60, <4 x float> %56)
br label %68
68: ; preds = %66, %51
%69 = phi <4 x float> [ zeroinitializer, %51 ], [ %67, %66 ]
%70 = bitcast float* %47 to <4 x float>*
store <4 x float> %69, <4 x float>* %70
%71 = getelementptr inbounds float, float* %47, i64 4
%72 = getelementptr inbounds float, float* %48, i64 4
br label %73
73: ; preds = %68, %46
%74 = phi float* [ %71, %68 ], [ %47, %46 ]
%75 = phi float* [ %72, %68 ], [ %48, %46 ]
%76 = and i64 %1, 2
%77 = icmp eq i64 %76, 0
br i1 %77, label %102, label %78
78: ; preds = %73
%79 = icmp eq i64 %0, 0
br i1 %79, label %95, label %80
80: ; preds = %78, %80
%81 = phi float* [ %91, %80 ], [ %75, %78 ]
%82 = phi float* [ %84, %80 ], [ %2, %78 ]
%83 = phi <2 x float> [ %90, %80 ], [ zeroinitializer, %78 ]
%84 = getelementptr inbounds float, float* %82, i64 1
%85 = load float, float* %82
%86 = bitcast float* %81 to <2 x float>*
%87 = load <2 x float>, <2 x float>* %86
%88 = insertelement <2 x float> poison, float %85, i64 0
%89 = shufflevector <2 x float> %88, <2 x float> poison, <2 x i32> zeroinitializer
%90 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %89, <2 x float> %87, <2 x float> %83)
%91 = getelementptr inbounds float, float* %81, i64 %1
%92 = icmp eq float* %84, %6
br i1 %92, label %93, label %80
93: ; preds = %80
%94 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %89, <2 x float> %87, <2 x float> %83)
br label %95
95: ; preds = %93, %78
%96 = phi <2 x float> [ zeroinitializer, %78 ], [ %94, %93 ]
%97 = extractelement <2 x float> %96, i64 0
store float %97, float* %74
%98 = getelementptr inbounds float, float* %74, i64 1
%99 = extractelement <2 x float> %96, i64 1
store float %99, float* %98
%100 = getelementptr inbounds float, float* %74, i64 2
%101 = getelementptr inbounds float, float* %75, i64 2
br label %102
102: ; preds = %95, %73
%103 = phi float* [ %100, %95 ], [ %74, %73 ]
%104 = phi float* [ %101, %95 ], [ %75, %73 ]
%105 = and i64 %1, 1
%106 = icmp eq i64 %105, 0
br i1 %106, label %121, label %107
107: ; preds = %102
%108 = icmp eq i64 %0, 0
br i1 %108, label %119, label %109
109: ; preds = %107, %109
%110 = phi float [ %116, %109 ], [ 0.000000e+00, %107 ]
%111 = phi float* [ %117, %109 ], [ %104, %107 ]
%112 = phi float* [ %113, %109 ], [ %2, %107 ]
%113 = getelementptr inbounds float, float* %112, i64 1
%114 = load float, float* %112
%115 = load float, float* %111
%116 = tail call float @llvm.fmuladd.f32(float %114, float %115, float %110)
%117 = getelementptr inbounds float, float* %111, i64 %1
%118 = icmp eq float* %113, %6
br i1 %118, label %119, label %109
119: ; preds = %109, %107
%120 = phi float [ 0.000000e+00, %107 ], [ %116, %109 ]
store float %120, float* %103
br label %121
121: ; preds = %119, %102
ret void
}