void postmultiplyMatrix4x4(double mx[16], double my[16]) {
  double tx[16];
  int c, r;
  int i;
  double f;
  for (c = 0; c < 4; c++) {
    for (r = 0; r < 4; r++) {
      f = 0.0;
      for (i = 0; i < 4; i++) {
        f += my[i * 4 + r] * mx[c * 4 + i];
      }
      tx[c * 4 + r] = f;
    }
  }
  for (i = 0; i < 16; i++) {
    mx[i] = tx[i];
  }
}


x86 assembly (clang, -O0):
<postmultiplyMatrix4x4>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movl   $0x0,-0x94(%rbp)
cmpl   $0x4,-0x94(%rbp)
jge    1211 <postmultiplyMatrix4x4+0x111>
movl   $0x0,-0x98(%rbp)
cmpl   $0x4,-0x98(%rbp)
jge    11f8 <postmultiplyMatrix4x4+0xf8>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movl   $0x0,-0x9c(%rbp)
cmpl   $0x4,-0x9c(%rbp)
jge    11c2 <postmultiplyMatrix4x4+0xc2>
mov    -0x10(%rbp),%rax
mov    -0x9c(%rbp),%ecx
shl    $0x2,%ecx
add    -0x98(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x94(%rbp),%ecx
shl    $0x2,%ecx
add    -0x9c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0xa8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x9c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c(%rbp)
jmp    1153 <postmultiplyMatrix4x4+0x53>
movsd  -0xa8(%rbp),%xmm0
ff
mov    -0x94(%rbp),%eax
shl    $0x2,%eax
add    -0x98(%rbp),%eax
cltq
movsd  %xmm0,-0x90(%rbp,%rax,8)
ff ff
mov    -0x98(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x98(%rbp)
jmp    1131 <postmultiplyMatrix4x4+0x31>
jmp    11fd <postmultiplyMatrix4x4+0xfd>
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    111a <postmultiplyMatrix4x4+0x1a>
movl   $0x0,-0x9c(%rbp)
cmpl   $0x10,-0x9c(%rbp)
jge    125c <postmultiplyMatrix4x4+0x15c>
movslq -0x9c(%rbp),%rax
movsd  -0x90(%rbp,%rax,8),%xmm0
ff ff
mov    -0x8(%rbp),%rax
movslq -0x9c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x9c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c(%rbp)
jmp    121b <postmultiplyMatrix4x4+0x11b>
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<postmultiplyMatrix4x4>:
sub    $0x78,%rsp
movsd  (%rsi),%xmm1
movsd  0x8(%rsi),%xmm0
unpcklpd %xmm1,%xmm1
movapd %xmm1,%xmm7
movapd %xmm1,-0x20(%rsp)
movsd  0x20(%rsi),%xmm14
unpcklpd %xmm14,%xmm14
movsd  0x40(%rsi),%xmm15
unpcklpd %xmm15,%xmm15
movsd  0x60(%rsi),%xmm12
unpcklpd %xmm12,%xmm12
unpcklpd %xmm0,%xmm0
movapd %xmm0,%xmm6
movapd %xmm0,-0x60(%rsp)
movsd  0x28(%rsi),%xmm0
unpcklpd %xmm0,%xmm0
movapd %xmm0,%xmm5
movapd %xmm0,-0x50(%rsp)
movsd  0x48(%rsi),%xmm0
unpcklpd %xmm0,%xmm0
movapd %xmm0,%xmm10
movapd %xmm0,-0x40(%rsp)
movsd  0x68(%rsi),%xmm0
unpcklpd %xmm0,%xmm0
movapd %xmm0,%xmm9
movapd %xmm0,-0x30(%rsp)
movupd (%rdi),%xmm13
movupd 0x10(%rdi),%xmm0
movupd 0x20(%rdi),%xmm1
movupd 0x30(%rdi),%xmm4
movapd %xmm13,%xmm2
unpcklpd %xmm1,%xmm2
unpckhpd %xmm1,%xmm13
movapd %xmm0,%xmm3
unpcklpd %xmm4,%xmm3
unpckhpd %xmm4,%xmm0
movapd %xmm7,%xmm1
mulpd  %xmm2,%xmm1
xorpd  %xmm4,%xmm4
addpd  %xmm4,%xmm1
xorpd  %xmm7,%xmm7
movapd %xmm14,%xmm4
mulpd  %xmm13,%xmm4
addpd  %xmm1,%xmm4
movapd %xmm15,%xmm1
mulpd  %xmm3,%xmm1
addpd  %xmm4,%xmm1
movapd %xmm12,%xmm8
mulpd  %xmm0,%xmm8
addpd  %xmm1,%xmm8
movapd %xmm6,%xmm1
mulpd  %xmm2,%xmm1
addpd  %xmm7,%xmm1
xorpd  %xmm6,%xmm6
movapd %xmm5,%xmm4
mulpd  %xmm13,%xmm4
addpd  %xmm1,%xmm4
movapd %xmm10,%xmm5
mulpd  %xmm3,%xmm5
addpd  %xmm4,%xmm5
movapd %xmm9,%xmm1
mulpd  %xmm0,%xmm1
addpd  %xmm5,%xmm1
movsd  0x10(%rsi),%xmm10
unpcklpd %xmm10,%xmm10
movsd  0x30(%rsi),%xmm11
unpcklpd %xmm11,%xmm11
movapd %xmm10,%xmm4
mulpd  %xmm2,%xmm4
addpd  %xmm6,%xmm4
movapd %xmm11,%xmm7
mulpd  %xmm13,%xmm7
addpd  %xmm4,%xmm7
movsd  0x50(%rsi),%xmm9
unpcklpd %xmm9,%xmm9
movapd %xmm9,%xmm6
mulpd  %xmm3,%xmm6
addpd  %xmm7,%xmm6
movsd  0x70(%rsi),%xmm5
unpcklpd %xmm5,%xmm5
movapd %xmm5,%xmm7
mulpd  %xmm0,%xmm7
addpd  %xmm6,%xmm7
movsd  0x18(%rsi),%xmm4
unpcklpd %xmm4,%xmm4
movsd  0x38(%rsi),%xmm6
unpcklpd %xmm6,%xmm6
movapd %xmm6,-0x70(%rsp)
mulpd  %xmm4,%xmm2
addpd  0xd56(%rip),%xmm2
mulpd  %xmm6,%xmm13
addpd  %xmm2,%xmm13
movsd  0x58(%rsi),%xmm2
unpcklpd %xmm2,%xmm2
movapd %xmm2,-0x80(%rsp)
mulpd  %xmm2,%xmm3
addpd  %xmm13,%xmm3
movsd  0x78(%rsi),%xmm13
unpcklpd %xmm13,%xmm13
mulpd  %xmm13,%xmm0
addpd  %xmm3,%xmm0
movapd %xmm8,%xmm2
unpcklpd %xmm1,%xmm2
movhlps %xmm8,%xmm1
movapd %xmm7,%xmm3
unpcklpd %xmm0,%xmm3
movhlps %xmm7,%xmm0
movaps %xmm0,0x20(%rsp)
movaps %xmm1,0x10(%rsp)
movapd %xmm3,(%rsp)
movapd %xmm2,-0x10(%rsp)
movupd 0x40(%rdi),%xmm1
movupd 0x60(%rdi),%xmm0
movapd %xmm1,%xmm2
unpcklpd %xmm0,%xmm2
unpckhpd %xmm0,%xmm1
movupd 0x50(%rdi),%xmm0
movupd 0x70(%rdi),%xmm6
movapd %xmm0,%xmm3
unpcklpd %xmm6,%xmm3
unpckhpd %xmm6,%xmm0
movapd -0x20(%rsp),%xmm6
mulpd  %xmm2,%xmm6
xorpd  %xmm7,%xmm7
addpd  %xmm7,%xmm6
mulpd  %xmm1,%xmm14
addpd  %xmm6,%xmm14
mulpd  %xmm3,%xmm15
addpd  %xmm14,%xmm15
mulpd  %xmm0,%xmm12
addpd  %xmm15,%xmm12
movapd -0x60(%rsp),%xmm6
mulpd  %xmm2,%xmm6
addpd  %xmm7,%xmm6
xorpd  %xmm8,%xmm8
movapd -0x50(%rsp),%xmm7
mulpd  %xmm1,%xmm7
addpd  %xmm6,%xmm7
movapd -0x40(%rsp),%xmm6
mulpd  %xmm3,%xmm6
addpd  %xmm7,%xmm6
movapd %xmm6,%xmm7
movapd -0x30(%rsp),%xmm6
mulpd  %xmm0,%xmm6
addpd  %xmm7,%xmm6
mulpd  %xmm2,%xmm10
addpd  %xmm8,%xmm10
mulpd  %xmm1,%xmm11
addpd  %xmm10,%xmm11
mulpd  %xmm3,%xmm9
addpd  %xmm11,%xmm9
mulpd  %xmm0,%xmm5
addpd  %xmm9,%xmm5
mulpd  %xmm4,%xmm2
addpd  %xmm8,%xmm2
mulpd  -0x70(%rsp),%xmm1
addpd  %xmm2,%xmm1
mulpd  -0x80(%rsp),%xmm3
addpd  %xmm1,%xmm3
mulpd  %xmm13,%xmm0
addpd  %xmm3,%xmm0
movapd %xmm5,%xmm1
unpckhpd %xmm0,%xmm1
unpcklpd %xmm0,%xmm5
movapd %xmm12,%xmm0
unpckhpd %xmm6,%xmm0
unpcklpd %xmm6,%xmm12
movapd %xmm12,0x30(%rsp)
movapd %xmm5,0x40(%rsp)
movapd %xmm0,0x50(%rsp)
movapd %xmm1,0x60(%rsp)
movaps 0x20(%rsp),%xmm0
movups %xmm0,0x30(%rdi)
movaps 0x10(%rsp),%xmm0
movups %xmm0,0x20(%rdi)
movaps (%rsp),%xmm0
movups %xmm0,0x10(%rdi)
movaps -0x10(%rsp),%xmm0
movups %xmm0,(%rdi)
movaps 0x60(%rsp),%xmm0
movups %xmm0,0x70(%rdi)
movaps 0x50(%rsp),%xmm0
movups %xmm0,0x60(%rdi)
movaps 0x40(%rsp),%xmm0
movups %xmm0,0x50(%rdi)
movaps 0x30(%rsp),%xmm0
movups %xmm0,0x40(%rdi)
add    $0x78,%rsp
ret

LLVM IR (-O0):
define void @postmultiplyMatrix4x4(double* %0, double* %1) {
%3 = alloca double*
%4 = alloca double*
%5 = alloca [16 x double]
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca double
store double* %0, double** %3
store double* %1, double** %4
store i32 0, i32* %6
br label %10
10: ; preds = %55, %2
%11 = load i32, i32* %6
%12 = icmp slt i32 %11, 4
br i1 %12, label %13, label %58
13: ; preds = %10
store i32 0, i32* %7
br label %14
14: ; preds = %51, %13
%15 = load i32, i32* %7
%16 = icmp slt i32 %15, 4
br i1 %16, label %17, label %54
17: ; preds = %14
store double 0.000000e+00, double* %9
store i32 0, i32* %8
br label %18
18: ; preds = %40, %17
%19 = load i32, i32* %8
%20 = icmp slt i32 %19, 4
br i1 %20, label %21, label %43
21: ; preds = %18
%22 = load double*, double** %4
%23 = load i32, i32* %8
%24 = mul nsw i32 %23, 4
%25 = load i32, i32* %7
%26 = add nsw i32 %24, %25
%27 = sext i32 %26 to i64
%28 = getelementptr inbounds double, double* %22, i64 %27
%29 = load double, double* %28
%30 = load double*, double** %3
%31 = load i32, i32* %6
%32 = mul nsw i32 %31, 4
%33 = load i32, i32* %8
%34 = add nsw i32 %32, %33
%35 = sext i32 %34 to i64
%36 = getelementptr inbounds double, double* %30, i64 %35
%37 = load double, double* %36
%38 = load double, double* %9
%39 = call double @llvm.fmuladd.f64(double %29, double %37, double %38)
store double %39, double* %9
br label %40
40: ; preds = %21
%41 = load i32, i32* %8
%42 = add nsw i32 %41, 1
store i32 %42, i32* %8
br label %18
43: ; preds = %18
%44 = load double, double* %9
%45 = load i32, i32* %6
%46 = mul nsw i32 %45, 4
%47 = load i32, i32* %7
%48 = add nsw i32 %46, %47
%49 = sext i32 %48 to i64
%50 = getelementptr inbounds [16 x double], [16 x double]* %5, i64 0, i64 %49
store double %44, double* %50
br label %51
51: ; preds = %43
%52 = load i32, i32* %7
%53 = add nsw i32 %52, 1
store i32 %53, i32* %7
br label %14
54: ; preds = %14
br label %55
55: ; preds = %54
%56 = load i32, i32* %6
%57 = add nsw i32 %56, 1
store i32 %57, i32* %6
br label %10
58: ; preds = %10
store i32 0, i32* %8
br label %59
59: ; preds = %71, %58
%60 = load i32, i32* %8
%61 = icmp slt i32 %60, 16
br i1 %61, label %62, label %74
62: ; preds = %59
%63 = load i32, i32* %8
%64 = sext i32 %63 to i64
%65 = getelementptr inbounds [16 x double], [16 x double]* %5, i64 0, i64 %64
%66 = load double, double* %65
%67 = load double*, double** %3
%68 = load i32, i32* %8
%69 = sext i32 %68 to i64
%70 = getelementptr inbounds double, double* %67, i64 %69
store double %66, double* %70
br label %71
71: ; preds = %62
%72 = load i32, i32* %8
%73 = add nsw i32 %72, 1
store i32 %73, i32* %8
br label %59
74: ; preds = %59
ret void
}

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