void mul(double v[], const double x[], const double y[]) {
  int a, i, b, j;
  int c, k;
  for (a = 0; a < 3; a++)
    for (i = 0; i < 2; i++) {
      for (b = 0; b < 3; b++)
        for (j = 0; j < 2; j++) {
          double vr = 0;
          double vi = 0;
          for (c = 0; c < 3; c++)
            for (k = 0; k < 2; k++) {
              vr += (&((x)[2 * ((k) + 2 * ((c) + 3 * ((i) + 2 * (a))))]))[0] *
                    (&((y)[2 * ((j) + 2 * ((b) + 3 * ((k) + 2 * (c))))]))[0];
              vr -= (&((x)[2 * ((k) + 2 * ((c) + 3 * ((i) + 2 * (a))))]))[1] *
                    (&((y)[2 * ((j) + 2 * ((b) + 3 * ((k) + 2 * (c))))]))[1];
              vi += (&((x)[2 * ((k) + 2 * ((c) + 3 * ((i) + 2 * (a))))]))[0] *
                    (&((y)[2 * ((j) + 2 * ((b) + 3 * ((k) + 2 * (c))))]))[1];
              vi += (&((x)[2 * ((k) + 2 * ((c) + 3 * ((i) + 2 * (a))))]))[1] *
                    (&((y)[2 * ((j) + 2 * ((b) + 3 * ((k) + 2 * (c))))]))[0];
            }
          (&((v)[2 * ((j) + 2 * ((b) + 3 * ((i) + 2 * (a))))]))[0] = vr;
          (&((v)[2 * ((j) + 2 * ((b) + 3 * ((i) + 2 * (a))))]))[1] = vi;
        }
    }
}


x86 assembly (clang, -O0):
<mul>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
movl   $0x0,-0x1c(%rbp)
cmpl   $0x3,-0x1c(%rbp)
jge    1400 <mul+0x300>
movl   $0x0,-0x20(%rbp)
cmpl   $0x2,-0x20(%rbp)
jge    13ed <mul+0x2ed>
movl   $0x0,-0x24(%rbp)
cmpl   $0x3,-0x24(%rbp)
jge    13da <mul+0x2da>
movl   $0x0,-0x28(%rbp)
cmpl   $0x2,-0x28(%rbp)
jge    13c7 <mul+0x2c7>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x38(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x40(%rbp)
movl   $0x0,-0x2c(%rbp)
cmpl   $0x3,-0x2c(%rbp)
jge    135a <mul+0x25a>
movl   $0x0,-0x30(%rbp)
cmpl   $0x2,-0x30(%rbp)
jge    1347 <mul+0x247>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
mov    -0x2c(%rbp),%edx
mov    -0x20(%rbp),%esi
mov    -0x1c(%rbp),%edi
shl    $0x1,%edi
add    %edi,%esi
imul   $0x3,%esi,%esi
add    %esi,%edx
shl    $0x1,%edx
add    %edx,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
mov    -0x24(%rbp),%edx
mov    -0x30(%rbp),%esi
mov    -0x2c(%rbp),%edi
shl    $0x1,%edi
add    %edi,%esi
imul   $0x3,%esi,%esi
add    %esi,%edx
shl    $0x1,%edx
add    %edx,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x38(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
mov    -0x2c(%rbp),%edx
mov    -0x20(%rbp),%esi
mov    -0x1c(%rbp),%edi
shl    $0x1,%edi
add    %edi,%esi
imul   $0x3,%esi,%esi
add    %esi,%edx
shl    $0x1,%edx
add    %edx,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
mov    -0x24(%rbp),%edx
mov    -0x30(%rbp),%esi
mov    -0x2c(%rbp),%edi
shl    $0x1,%edi
add    %edi,%esi
imul   $0x3,%esi,%esi
add    %esi,%edx
shl    $0x1,%edx
add    %edx,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  0x8(%rax,%rcx,8),%xmm2
movsd  -0x38(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
mov    -0x2c(%rbp),%edx
mov    -0x20(%rbp),%esi
mov    -0x1c(%rbp),%edi
shl    $0x1,%edi
add    %edi,%esi
imul   $0x3,%esi,%esi
add    %esi,%edx
shl    $0x1,%edx
add    %edx,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
mov    -0x24(%rbp),%edx
mov    -0x30(%rbp),%esi
mov    -0x2c(%rbp),%edi
shl    $0x1,%edi
add    %edi,%esi
imul   $0x3,%esi,%esi
add    %esi,%edx
shl    $0x1,%edx
add    %edx,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  0x8(%rax,%rcx,8),%xmm2
movsd  -0x40(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
mov    -0x2c(%rbp),%edx
mov    -0x20(%rbp),%esi
mov    -0x1c(%rbp),%edi
shl    $0x1,%edi
add    %edi,%esi
imul   $0x3,%esi,%esi
add    %esi,%edx
shl    $0x1,%edx
add    %edx,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
mov    -0x24(%rbp),%edx
mov    -0x30(%rbp),%esi
mov    -0x2c(%rbp),%edi
shl    $0x1,%edi
add    %edi,%esi
imul   $0x3,%esi,%esi
add    %esi,%edx
shl    $0x1,%edx
add    %edx,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x40(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    117c <mul+0x7c>
jmp    134c <mul+0x24c>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    116b <mul+0x6b>
movsd  -0x38(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
mov    -0x24(%rbp),%edx
mov    -0x20(%rbp),%esi
mov    -0x1c(%rbp),%edi
shl    $0x1,%edi
add    %edi,%esi
imul   $0x3,%esi,%esi
add    %esi,%edx
shl    $0x1,%edx
add    %edx,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x40(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
mov    -0x24(%rbp),%edx
mov    -0x20(%rbp),%esi
mov    -0x1c(%rbp),%edi
shl    $0x1,%edi
add    %edi,%esi
imul   $0x3,%esi,%esi
add    %esi,%edx
shl    $0x1,%edx
add    %edx,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,0x8(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    114a <mul+0x4a>
jmp    13cc <mul+0x2cc>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1139 <mul+0x39>
jmp    13df <mul+0x2df>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1128 <mul+0x28>
jmp    13f2 <mul+0x2f2>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1117 <mul+0x17>
pop    %rbp
ret

x86 assembly (clang, -O2):
<mul>:
push   %rbx
xor    %r8d,%r8d
movapd 0xef4(%rip),%xmm0
xorpd  %xmm8,%xmm8
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    (%r8,%r8,1),%r9
mov    $0x1,%r10b
xor    %eax,%eax
nopl   0x0(%rax)
or     %r9,%rax
shl    $0x2,%rax
lea    (%rax,%rax,2),%rcx
mov    %rcx,%rax
or     $0x2,%rax
lea    (%rdi,%rcx,8),%r11
mov    $0xffffffffffffffa0,%rbx
nopl   (%rax)
movsd  (%rsi,%rcx,8),%xmm4
movsd  0x8(%rsi,%rcx,8),%xmm5
movapd %xmm5,%xmm6
xorpd  %xmm0,%xmm6
unpcklpd %xmm4,%xmm4
movupd 0x60(%rdx,%rbx,1),%xmm7
movupd 0xc0(%rdx,%rbx,1),%xmm1
movupd 0x120(%rdx,%rbx,1),%xmm3
movupd 0x180(%rdx,%rbx,1),%xmm2
mulpd  %xmm7,%xmm4
addpd  %xmm8,%xmm4
unpcklpd %xmm5,%xmm6
shufpd $0x1,%xmm7,%xmm7
mulpd  %xmm6,%xmm7
addpd  %xmm4,%xmm7
movsd  (%rsi,%rax,8),%xmm4
movsd  0x8(%rsi,%rax,8),%xmm5
movapd %xmm5,%xmm6
xorpd  %xmm0,%xmm6
unpcklpd %xmm4,%xmm4
mulpd  %xmm1,%xmm4
shufpd $0x1,%xmm1,%xmm1
addpd  %xmm7,%xmm4
unpcklpd %xmm5,%xmm6
mulpd  %xmm1,%xmm6
addpd  %xmm4,%xmm6
movsd  0x20(%rsi,%rcx,8),%xmm1
movsd  0x28(%rsi,%rcx,8),%xmm4
movapd %xmm4,%xmm5
xorpd  %xmm0,%xmm5
unpcklpd %xmm1,%xmm1
mulpd  %xmm3,%xmm1
shufpd $0x1,%xmm3,%xmm3
addpd  %xmm6,%xmm1
unpcklpd %xmm4,%xmm5
mulpd  %xmm3,%xmm5
addpd  %xmm1,%xmm5
movsd  0x30(%rsi,%rcx,8),%xmm1
movsd  0x38(%rsi,%rcx,8),%xmm3
movapd %xmm3,%xmm4
xorpd  %xmm0,%xmm4
unpcklpd %xmm1,%xmm1
mulpd  %xmm2,%xmm1
shufpd $0x1,%xmm2,%xmm2
addpd  %xmm5,%xmm1
unpcklpd %xmm3,%xmm4
mulpd  %xmm2,%xmm4
addpd  %xmm1,%xmm4
movupd 0x1e0(%rdx,%rbx,1),%xmm1
movsd  0x40(%rsi,%rcx,8),%xmm2
movsd  0x48(%rsi,%rcx,8),%xmm3
movapd %xmm3,%xmm5
xorpd  %xmm0,%xmm5
unpcklpd %xmm2,%xmm2
mulpd  %xmm1,%xmm2
shufpd $0x1,%xmm1,%xmm1
addpd  %xmm4,%xmm2
unpcklpd %xmm3,%xmm5
mulpd  %xmm1,%xmm5
addpd  %xmm2,%xmm5
movupd 0x240(%rdx,%rbx,1),%xmm1
movsd  0x50(%rsi,%rcx,8),%xmm2
movsd  0x58(%rsi,%rcx,8),%xmm3
movapd %xmm3,%xmm4
xorpd  %xmm0,%xmm4
unpcklpd %xmm2,%xmm2
mulpd  %xmm1,%xmm2
shufpd $0x1,%xmm1,%xmm1
addpd  %xmm5,%xmm2
unpcklpd %xmm3,%xmm4
mulpd  %xmm1,%xmm4
addpd  %xmm2,%xmm4
movupd %xmm4,0x60(%r11,%rbx,1)
movsd  (%rsi,%rcx,8),%xmm1
movsd  0x8(%rsi,%rcx,8),%xmm4
movapd %xmm4,%xmm5
xorpd  %xmm0,%xmm5
unpcklpd %xmm1,%xmm1
movupd 0x70(%rdx,%rbx,1),%xmm6
movupd 0xd0(%rdx,%rbx,1),%xmm7
movupd 0x130(%rdx,%rbx,1),%xmm3
movupd 0x190(%rdx,%rbx,1),%xmm2
mulpd  %xmm6,%xmm1
addpd  %xmm8,%xmm1
unpcklpd %xmm4,%xmm5
shufpd $0x1,%xmm6,%xmm6
mulpd  %xmm5,%xmm6
addpd  %xmm1,%xmm6
movsd  (%rsi,%rax,8),%xmm1
movsd  0x8(%rsi,%rax,8),%xmm4
movapd %xmm4,%xmm5
xorpd  %xmm0,%xmm5
unpcklpd %xmm1,%xmm1
mulpd  %xmm7,%xmm1
shufpd $0x1,%xmm7,%xmm7
addpd  %xmm6,%xmm1
unpcklpd %xmm4,%xmm5
mulpd  %xmm7,%xmm5
addpd  %xmm1,%xmm5
movsd  0x20(%rsi,%rcx,8),%xmm1
movsd  0x28(%rsi,%rcx,8),%xmm4
movapd %xmm4,%xmm6
xorpd  %xmm0,%xmm6
unpcklpd %xmm1,%xmm1
mulpd  %xmm3,%xmm1
shufpd $0x1,%xmm3,%xmm3
addpd  %xmm5,%xmm1
unpcklpd %xmm4,%xmm6
mulpd  %xmm3,%xmm6
addpd  %xmm1,%xmm6
movsd  0x30(%rsi,%rcx,8),%xmm1
movsd  0x38(%rsi,%rcx,8),%xmm3
movapd %xmm3,%xmm4
xorpd  %xmm0,%xmm4
unpcklpd %xmm1,%xmm1
mulpd  %xmm2,%xmm1
shufpd $0x1,%xmm2,%xmm2
addpd  %xmm6,%xmm1
unpcklpd %xmm3,%xmm4
mulpd  %xmm2,%xmm4
addpd  %xmm1,%xmm4
movupd 0x1f0(%rdx,%rbx,1),%xmm1
movsd  0x40(%rsi,%rcx,8),%xmm2
movsd  0x48(%rsi,%rcx,8),%xmm3
movapd %xmm3,%xmm5
xorpd  %xmm0,%xmm5
unpcklpd %xmm2,%xmm2
mulpd  %xmm1,%xmm2
shufpd $0x1,%xmm1,%xmm1
addpd  %xmm4,%xmm2
unpcklpd %xmm3,%xmm5
mulpd  %xmm1,%xmm5
addpd  %xmm2,%xmm5
movupd 0x250(%rdx,%rbx,1),%xmm1
movsd  0x50(%rsi,%rcx,8),%xmm2
movsd  0x58(%rsi,%rcx,8),%xmm3
movapd %xmm3,%xmm4
xorpd  %xmm0,%xmm4
unpcklpd %xmm2,%xmm2
mulpd  %xmm1,%xmm2
shufpd $0x1,%xmm1,%xmm1
addpd  %xmm5,%xmm2
unpcklpd %xmm3,%xmm4
mulpd  %xmm1,%xmm4
addpd  %xmm2,%xmm4
movupd %xmm4,0x70(%r11,%rbx,1)
add    $0x20,%rbx
jne    1150 <mul+0x50>
mov    $0x1,%eax
test   $0x1,%r10b
mov    $0x0,%r10d
jne    1130 <mul+0x30>
add    $0x1,%r8
cmp    $0x3,%r8
jne    1120 <mul+0x20>
pop    %rbx
ret

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

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