void __mltadd__(dp1, dp2, s, len) register double *dp1, *dp2;
register double s;
register int len;
{
  register int i;
  register int j, k;
  i = len >> 3;
  j = 0;
  k = len & 7;
  while (i--) {
    dp1[j] += s * dp2[j];
    j++;
    dp1[j] += s * dp2[j];
    j++;
    dp1[j] += s * dp2[j];
    j++;
    dp1[j] += s * dp2[j];
    j++;
    dp1[j] += s * dp2[j];
    j++;
    dp1[j] += s * dp2[j];
    j++;
    dp1[j] += s * dp2[j];
    j++;
    dp1[j] += s * dp2[j];
    j++;
  }
  switch (k) {
  case 7:
    dp1[j] += s * dp2[j];
    j++;
  case 6:
    dp1[j] += s * dp2[j];
    j++;
  case 5:
    dp1[j] += s * dp2[j];
    j++;
  case 4:
    dp1[j] += s * dp2[j];
    j++;
  case 3:
    dp1[j] += s * dp2[j];
    j++;
  case 2:
    dp1[j] += s * dp2[j];
    j++;
  case 1:
    dp1[j] += s * dp2[j];
    j++;
  }
}


x86 assembly (clang, -O0):
<__mltadd__>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movsd  %xmm0,-0x18(%rbp)
mov    %edx,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
sar    $0x3,%eax
mov    %eax,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x1c(%rbp),%eax
and    $0x7,%eax
mov    %eax,-0x28(%rbp)
mov    -0x20(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x20(%rbp)
cmp    $0x0,%eax
je     12ee <__mltadd__+0x1ee>
movsd  -0x18(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
movsd  -0x18(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
movsd  -0x18(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
movsd  -0x18(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
movsd  -0x18(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
movsd  -0x18(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
movsd  -0x18(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
movsd  -0x18(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    112d <__mltadd__+0x2d>
mov    -0x28(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,%ecx
mov    %rcx,-0x30(%rbp)
sub    $0x6,%eax
ja     148a <__mltadd__+0x38a>
mov    -0x30(%rbp),%rax
lea    0xcf2(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
movsd  -0x18(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
movsd  -0x18(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
movsd  -0x18(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
movsd  -0x18(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
movsd  -0x18(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
movsd  -0x18(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
movsd  -0x18(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
pop    %rbp
ret

x86 assembly (clang, -O2):
<__mltadd__>:
mov    %edx,%r10d
and    $0x7,%r10d
xor    %eax,%eax
cmp    $0x8,%edx
jb     120d <__mltadd__+0x10d>
sar    $0x3,%edx
mov    %edx,%r8d
add    $0xffffffff,%r8d
je     1146 <__mltadd__+0x46>
mov    %r8,%rax
shl    $0x6,%rax
lea    (%rsi,%rax,1),%rcx
add    $0x40,%rcx
cmp    %rdi,%rcx
jbe    12cd <__mltadd__+0x1cd>
add    %rdi,%rax
add    $0x40,%rax
cmp    %rsi,%rax
jbe    12cd <__mltadd__+0x1cd>
xor    %eax,%eax
mov    %rax,%rcx
nopl   0x0(%rax,%rax,1)
movsd  (%rsi,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rdi,%rcx,8),%xmm1
movsd  %xmm1,(%rdi,%rcx,8)
movsd  0x8(%rsi,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x8(%rdi,%rcx,8),%xmm1
movsd  %xmm1,0x8(%rdi,%rcx,8)
movsd  0x10(%rsi,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x10(%rdi,%rcx,8),%xmm1
movsd  %xmm1,0x10(%rdi,%rcx,8)
movsd  0x18(%rsi,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x18(%rdi,%rcx,8),%xmm1
movsd  %xmm1,0x18(%rdi,%rcx,8)
movsd  0x20(%rsi,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x20(%rdi,%rcx,8),%xmm1
movsd  %xmm1,0x20(%rdi,%rcx,8)
movsd  0x28(%rsi,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x28(%rdi,%rcx,8),%xmm1
movsd  %xmm1,0x28(%rdi,%rcx,8)
movsd  0x30(%rsi,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x30(%rdi,%rcx,8),%xmm1
lea    0x8(%rcx),%rax
movsd  %xmm1,0x30(%rdi,%rcx,8)
movsd  0x38(%rsi,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x38(%rdi,%rcx,8),%xmm1
movsd  %xmm1,0x38(%rdi,%rcx,8)
mov    %rax,%rcx
add    $0xffffffff,%edx
jne    1150 <__mltadd__+0x50>
add    $0xffffffff,%r10d
cmp    $0x6,%r10d
ja     12cc <__mltadd__+0x1cc>
lea    0xdde(%rip),%rcx
movslq (%rcx,%r10,4),%rdx
add    %rcx,%rdx
jmp    *%rdx
mov    %eax,%ecx
movsd  (%rsi,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rdi,%rcx,8),%xmm1
movsd  %xmm1,(%rdi,%rcx,8)
or     $0x1,%eax
cltq
movsd  (%rsi,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rdi,%rax,8),%xmm1
movsd  %xmm1,(%rdi,%rax,8)
add    $0x1,%eax
cltq
movsd  (%rsi,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rdi,%rax,8),%xmm1
movsd  %xmm1,(%rdi,%rax,8)
add    $0x1,%eax
cltq
movsd  (%rsi,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rdi,%rax,8),%xmm1
movsd  %xmm1,(%rdi,%rax,8)
add    $0x1,%eax
cltq
movsd  (%rsi,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rdi,%rax,8),%xmm1
movsd  %xmm1,(%rdi,%rax,8)
add    $0x1,%eax
cltq
movsd  (%rsi,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rdi,%rax,8),%xmm1
movsd  %xmm1,(%rdi,%rax,8)
add    $0x1,%eax
cltq
mulsd  (%rsi,%rax,8),%xmm0
addsd  (%rdi,%rax,8),%xmm0
movsd  %xmm0,(%rdi,%rax,8)
ret
add    $0x1,%r8
mov    %r8,%r9
and    $0xfffffffffffffffe,%r9
lea    0x0(,%r9,8),%rax
sub    %r9d,%edx
movapd %xmm0,%xmm8
unpcklpd %xmm0,%xmm8
xor    %ecx,%ecx
mov    %r9,%r11
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%rsi,%rcx,1),%xmm10
movsd  0x8(%rsi,%rcx,1),%xmm12
movsd  0x10(%rsi,%rcx,1),%xmm11
movsd  0x18(%rsi,%rcx,1),%xmm3
movhpd 0x40(%rsi,%rcx,1),%xmm10
movsd  (%rdi,%rcx,1),%xmm6
movsd  0x8(%rdi,%rcx,1),%xmm7
movsd  0x10(%rdi,%rcx,1),%xmm1
movsd  0x18(%rdi,%rcx,1),%xmm9
movhpd 0x40(%rdi,%rcx,1),%xmm6
mulpd  %xmm8,%xmm10
addpd  %xmm6,%xmm10
movhpd 0x48(%rsi,%rcx,1),%xmm12
movhpd 0x48(%rdi,%rcx,1),%xmm7
mulpd  %xmm8,%xmm12
addpd  %xmm7,%xmm12
movhpd 0x50(%rsi,%rcx,1),%xmm11
movhpd 0x50(%rdi,%rcx,1),%xmm1
mulpd  %xmm8,%xmm11
addpd  %xmm1,%xmm11
movhpd 0x58(%rsi,%rcx,1),%xmm3
movhpd 0x58(%rdi,%rcx,1),%xmm9
mulpd  %xmm8,%xmm3
movsd  0x20(%rsi,%rcx,1),%xmm6
movhpd 0x60(%rsi,%rcx,1),%xmm6
addpd  %xmm9,%xmm3
movsd  0x20(%rdi,%rcx,1),%xmm1
movhpd 0x60(%rdi,%rcx,1),%xmm1
mulpd  %xmm8,%xmm6
movsd  0x28(%rsi,%rcx,1),%xmm7
movhpd 0x68(%rsi,%rcx,1),%xmm7
addpd  %xmm1,%xmm6
movsd  0x28(%rdi,%rcx,1),%xmm4
movhpd 0x68(%rdi,%rcx,1),%xmm4
mulpd  %xmm8,%xmm7
movsd  0x30(%rsi,%rcx,1),%xmm1
movhpd 0x70(%rsi,%rcx,1),%xmm1
addpd  %xmm4,%xmm7
movsd  0x30(%rdi,%rcx,1),%xmm4
movhpd 0x70(%rdi,%rcx,1),%xmm4
mulpd  %xmm8,%xmm1
movsd  0x38(%rsi,%rcx,1),%xmm5
movhpd 0x78(%rsi,%rcx,1),%xmm5
addpd  %xmm4,%xmm1
movsd  0x38(%rdi,%rcx,1),%xmm4
movhpd 0x78(%rdi,%rcx,1),%xmm4
mulpd  %xmm8,%xmm5
addpd  %xmm4,%xmm5
movapd %xmm10,%xmm9
unpcklpd %xmm12,%xmm9
movapd %xmm11,%xmm13
unpcklpd %xmm3,%xmm13
movapd %xmm6,%xmm2
unpcklpd %xmm7,%xmm2
movapd %xmm1,%xmm4
unpcklpd %xmm5,%xmm4
movhlps %xmm10,%xmm12
movhlps %xmm11,%xmm3
movhlps %xmm6,%xmm7
movhlps %xmm1,%xmm5
movups %xmm5,0x70(%rdi,%rcx,1)
movups %xmm7,0x60(%rdi,%rcx,1)
movups %xmm3,0x50(%rdi,%rcx,1)
movups %xmm12,0x40(%rdi,%rcx,1)
movupd %xmm4,0x30(%rdi,%rcx,1)
movupd %xmm2,0x20(%rdi,%rcx,1)
movupd %xmm13,0x10(%rdi,%rcx,1)
movupd %xmm9,(%rdi,%rcx,1)
sub    $0xffffffffffffff80,%rcx
add    $0xfffffffffffffffe,%r11
jne    1300 <__mltadd__+0x200>
cmp    %r9,%r8
je     120d <__mltadd__+0x10d>
jmp    1148 <__mltadd__+0x48>

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

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