matmult(a, b, c) double a[4][4], b[4][4], c[4][4];
{
  double d[4][4];
  register int k, j, i;
  for (i = 0; i < 4; i++)
    for (j = 0; j < 4; j++) {
      d[i][j] = 0.0;
      for (k = 0; k < 4; k++)
        d[i][j] += a[i][k] * b[k][j];
    }
  copytransform(d, c);
}


x86 assembly (clang, -O0):
<matmult>:
push   %rbp
mov    %rsp,%rbp
sub    $0xb0,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
movl   $0x0,-0xac(%rbp)
cmpl   $0x4,-0xac(%rbp)
jge    1240 <matmult+0x130>
movl   $0x0,-0xa8(%rbp)
cmpl   $0x4,-0xa8(%rbp)
jge    1227 <matmult+0x117>
movslq -0xac(%rbp),%rcx
lea    -0xa0(%rbp),%rax
shl    $0x5,%rcx
add    %rcx,%rax
movslq -0xa8(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0xa4(%rbp)
cmpl   $0x4,-0xa4(%rbp)
jge    120e <matmult+0xfe>
mov    -0x10(%rbp),%rax
movslq -0xac(%rbp),%rcx
shl    $0x5,%rcx
add    %rcx,%rax
movslq -0xa4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0xa4(%rbp),%rcx
shl    $0x5,%rcx
add    %rcx,%rax
movslq -0xa8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movslq -0xac(%rbp),%rcx
lea    -0xa0(%rbp),%rax
shl    $0x5,%rcx
add    %rcx,%rax
movslq -0xa8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xa4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa4(%rbp)
jmp    1183 <matmult+0x73>
jmp    1213 <matmult+0x103>
mov    -0xa8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa8(%rbp)
jmp    1148 <matmult+0x38>
jmp    122c <matmult+0x11c>
mov    -0xac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xac(%rbp)
jmp    1131 <matmult+0x21>
lea    -0xa0(%rbp),%rdi
mov    -0x20(%rbp),%rsi
mov    $0x0,%al
call   1030 <copytransform@plt>
mov    -0x4(%rbp),%eax
add    $0xb0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<matmult>:
sub    $0x108,%rsp
movsd  (%rsi),%xmm14
movsd  0x8(%rsi),%xmm0
unpcklpd %xmm14,%xmm14
movsd  0x20(%rsi),%xmm13
unpcklpd %xmm13,%xmm13
movsd  0x40(%rsi),%xmm1
unpcklpd %xmm1,%xmm1
movapd %xmm1,%xmm3
movapd %xmm1,(%rsp)
movsd  0x60(%rsi),%xmm1
unpcklpd %xmm1,%xmm1
movapd %xmm1,%xmm6
movapd %xmm1,0x10(%rsp)
unpcklpd %xmm0,%xmm0
movapd %xmm0,%xmm5
movapd %xmm0,0x20(%rsp)
movsd  0x28(%rsi),%xmm0
unpcklpd %xmm0,%xmm0
movapd %xmm0,%xmm11
movapd %xmm0,0x30(%rsp)
movsd  0x48(%rsi),%xmm0
unpcklpd %xmm0,%xmm0
movapd %xmm0,0x40(%rsp)
movsd  0x68(%rsi),%xmm12
unpcklpd %xmm12,%xmm12
movsd  (%rdi),%xmm15
movsd  0x8(%rdi),%xmm7
movsd  0x10(%rdi),%xmm9
movhpd 0x20(%rdi),%xmm15
movsd  0x18(%rdi),%xmm2
movapd %xmm15,%xmm1
mulpd  %xmm14,%xmm1
xorpd  %xmm4,%xmm4
addpd  %xmm4,%xmm1
xorpd  %xmm8,%xmm8
movhpd 0x28(%rdi),%xmm7
movapd %xmm7,%xmm4
mulpd  %xmm13,%xmm4
addpd  %xmm1,%xmm4
movhpd 0x30(%rdi),%xmm9
movapd %xmm9,%xmm1
mulpd  %xmm3,%xmm1
addpd  %xmm4,%xmm1
movhpd 0x38(%rdi),%xmm2
movapd %xmm2,%xmm10
mulpd  %xmm6,%xmm10
addpd  %xmm1,%xmm10
movapd %xmm15,%xmm1
mulpd  %xmm5,%xmm1
addpd  %xmm8,%xmm1
xorpd  %xmm3,%xmm3
movapd %xmm7,%xmm5
mulpd  %xmm11,%xmm5
addpd  %xmm1,%xmm5
movapd %xmm9,%xmm6
mulpd  %xmm0,%xmm6
addpd  %xmm5,%xmm6
movapd %xmm2,%xmm1
mulpd  %xmm12,%xmm1
addpd  %xmm6,%xmm1
movsd  0x10(%rsi),%xmm5
unpcklpd %xmm5,%xmm5
movsd  0x30(%rsi),%xmm11
unpcklpd %xmm11,%xmm11
movapd %xmm15,%xmm6
mulpd  %xmm5,%xmm6
addpd  %xmm3,%xmm6
movapd %xmm7,%xmm8
mulpd  %xmm11,%xmm8
addpd  %xmm6,%xmm8
movsd  0x50(%rsi),%xmm6
unpcklpd %xmm6,%xmm6
movapd %xmm9,%xmm3
mulpd  %xmm6,%xmm3
addpd  %xmm8,%xmm3
movsd  0x70(%rsi),%xmm8
unpcklpd %xmm8,%xmm8
movapd %xmm2,%xmm0
mulpd  %xmm8,%xmm0
addpd  %xmm3,%xmm0
movsd  0x18(%rsi),%xmm4
unpcklpd %xmm4,%xmm4
movapd %xmm4,0x50(%rsp)
movsd  0x38(%rsi),%xmm3
unpcklpd %xmm3,%xmm3
movapd %xmm3,0x70(%rsp)
mulpd  %xmm4,%xmm15
addpd  0xd3f(%rip),%xmm15
mulpd  %xmm3,%xmm7
addpd  %xmm15,%xmm7
movsd  0x58(%rsi),%xmm15
unpcklpd %xmm15,%xmm15
mulpd  %xmm15,%xmm9
addpd  %xmm7,%xmm9
movsd  0x78(%rsi),%xmm3
unpcklpd %xmm3,%xmm3
movapd %xmm3,0x60(%rsp)
mulpd  %xmm3,%xmm2
addpd  %xmm9,%xmm2
movapd %xmm10,%xmm3
unpcklpd %xmm1,%xmm3
movhlps %xmm10,%xmm1
movapd %xmm0,%xmm4
unpcklpd %xmm2,%xmm4
movhlps %xmm0,%xmm2
movaps %xmm2,0xb0(%rsp)
movaps %xmm1,0xa0(%rsp)
movapd %xmm4,0x90(%rsp)
movapd %xmm3,0x80(%rsp)
movsd  0x40(%rdi),%xmm3
movhpd 0x60(%rdi),%xmm3
mulpd  %xmm3,%xmm14
xorpd  %xmm10,%xmm10
addpd  %xmm10,%xmm14
movsd  0x48(%rdi),%xmm2
movhpd 0x68(%rdi),%xmm2
mulpd  %xmm2,%xmm13
movsd  0x50(%rdi),%xmm0
movhpd 0x70(%rdi),%xmm0
addpd  %xmm14,%xmm13
movapd (%rsp),%xmm1
mulpd  %xmm0,%xmm1
addpd  %xmm13,%xmm1
movapd %xmm1,%xmm7
movsd  0x58(%rdi),%xmm1
movhpd 0x78(%rdi),%xmm1
movapd 0x10(%rsp),%xmm4
mulpd  %xmm1,%xmm4
addpd  %xmm7,%xmm4
movapd %xmm4,%xmm9
movapd 0x20(%rsp),%xmm7
mulpd  %xmm3,%xmm7
addpd  %xmm10,%xmm7
movapd 0x30(%rsp),%xmm4
mulpd  %xmm2,%xmm4
addpd  %xmm7,%xmm4
movapd 0x40(%rsp),%xmm7
mulpd  %xmm0,%xmm7
addpd  %xmm4,%xmm7
mulpd  %xmm1,%xmm12
addpd  %xmm7,%xmm12
mulpd  %xmm3,%xmm5
xorpd  %xmm4,%xmm4
addpd  %xmm4,%xmm5
mulpd  %xmm2,%xmm11
addpd  %xmm5,%xmm11
mulpd  %xmm0,%xmm6
addpd  %xmm11,%xmm6
mulpd  %xmm1,%xmm8
addpd  %xmm6,%xmm8
mulpd  0x50(%rsp),%xmm3
addpd  %xmm4,%xmm3
mulpd  0x70(%rsp),%xmm2
addpd  %xmm3,%xmm2
mulpd  %xmm15,%xmm0
addpd  %xmm2,%xmm0
mulpd  0x60(%rsp),%xmm1
addpd  %xmm0,%xmm1
movapd %xmm9,%xmm0
unpcklpd %xmm12,%xmm0
movhlps %xmm9,%xmm12
movapd %xmm8,%xmm2
unpcklpd %xmm1,%xmm2
movhlps %xmm8,%xmm1
movaps %xmm1,0xf0(%rsp)
movaps %xmm12,0xe0(%rsp)
movapd %xmm2,0xd0(%rsp)
movapd %xmm0,0xc0(%rsp)
lea    0x80(%rsp),%rdi
mov    %rdx,%rsi
xor    %eax,%eax
call   1030 <copytransform@plt>
add    $0x108,%rsp
ret

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

LLVM IR (-O2):
define i32 @matmult([4 x double]* nocapture %0, [4 x double]* nocapture %1, [4 x double]* %2) {
%4 = alloca [4 x [4 x double]]
%5 = bitcast [4 x [4 x double]]* %4 to i8*
%6 = getelementptr inbounds [4 x double], [4 x double]* %1, i64 3, i64 3
%7 = load double, double* %6
%8 = getelementptr inbounds [4 x double], [4 x double]* %1, i64 2, i64 3
%9 = load double, double* %8
%10 = getelementptr inbounds [4 x double], [4 x double]* %1, i64 1, i64 3
%11 = load double, double* %10
%12 = getelementptr inbounds [4 x double], [4 x double]* %1, i64 0, i64 3
%13 = load double, double* %12
%14 = getelementptr inbounds [4 x double], [4 x double]* %1, i64 3, i64 2
%15 = load double, double* %14
%16 = getelementptr inbounds [4 x double], [4 x double]* %1, i64 2, i64 2
%17 = load double, double* %16
%18 = getelementptr inbounds [4 x double], [4 x double]* %1, i64 1, i64 2
%19 = load double, double* %18
%20 = getelementptr inbounds [4 x double], [4 x double]* %1, i64 0, i64 2
%21 = load double, double* %20
%22 = getelementptr inbounds [4 x double], [4 x double]* %1, i64 3, i64 1
%23 = load double, double* %22
%24 = getelementptr inbounds [4 x double], [4 x double]* %1, i64 2, i64 1
%25 = load double, double* %24
%26 = getelementptr inbounds [4 x double], [4 x double]* %1, i64 1, i64 1
%27 = load double, double* %26
%28 = getelementptr inbounds [4 x double], [4 x double]* %1, i64 0, i64 1
%29 = load double, double* %28
%30 = getelementptr inbounds [4 x double], [4 x double]* %1, i64 3, i64 0
%31 = load double, double* %30
%32 = getelementptr inbounds [4 x double], [4 x double]* %1, i64 2, i64 0
%33 = load double, double* %32
%34 = getelementptr inbounds [4 x double], [4 x double]* %1, i64 1, i64 0
%35 = load double, double* %34
%36 = getelementptr inbounds [4 x double], [4 x double]* %1, i64 0, i64 0
%37 = load double, double* %36
%38 = insertelement <2 x double> poison, double %37, i64 0
%39 = shufflevector <2 x double> %38, <2 x double> poison, <2 x i32> zeroinitializer
%40 = insertelement <2 x double> poison, double %35, i64 0
%41 = shufflevector <2 x double> %40, <2 x double> poison, <2 x i32> zeroinitializer
%42 = insertelement <2 x double> poison, double %33, i64 0
%43 = shufflevector <2 x double> %42, <2 x double> poison, <2 x i32> zeroinitializer
%44 = insertelement <2 x double> poison, double %31, i64 0
%45 = shufflevector <2 x double> %44, <2 x double> poison, <2 x i32> zeroinitializer
%46 = insertelement <2 x double> poison, double %29, i64 0
%47 = shufflevector <2 x double> %46, <2 x double> poison, <2 x i32> zeroinitializer
%48 = insertelement <2 x double> poison, double %27, i64 0
%49 = shufflevector <2 x double> %48, <2 x double> poison, <2 x i32> zeroinitializer
%50 = insertelement <2 x double> poison, double %25, i64 0
%51 = shufflevector <2 x double> %50, <2 x double> poison, <2 x i32> zeroinitializer
%52 = insertelement <2 x double> poison, double %23, i64 0
%53 = shufflevector <2 x double> %52, <2 x double> poison, <2 x i32> zeroinitializer
%54 = insertelement <2 x double> poison, double %21, i64 0
%55 = shufflevector <2 x double> %54, <2 x double> poison, <2 x i32> zeroinitializer
%56 = insertelement <2 x double> poison, double %19, i64 0
%57 = shufflevector <2 x double> %56, <2 x double> poison, <2 x i32> zeroinitializer
%58 = insertelement <2 x double> poison, double %17, i64 0
%59 = shufflevector <2 x double> %58, <2 x double> poison, <2 x i32> zeroinitializer
%60 = insertelement <2 x double> poison, double %15, i64 0
%61 = shufflevector <2 x double> %60, <2 x double> poison, <2 x i32> zeroinitializer
%62 = insertelement <2 x double> poison, double %13, i64 0
%63 = shufflevector <2 x double> %62, <2 x double> poison, <2 x i32> zeroinitializer
%64 = insertelement <2 x double> poison, double %11, i64 0
%65 = shufflevector <2 x double> %64, <2 x double> poison, <2 x i32> zeroinitializer
%66 = insertelement <2 x double> poison, double %9, i64 0
%67 = shufflevector <2 x double> %66, <2 x double> poison, <2 x i32> zeroinitializer
%68 = insertelement <2 x double> poison, double %7, i64 0
%69 = shufflevector <2 x double> %68, <2 x double> poison, <2 x i32> zeroinitializer
%70 = getelementptr inbounds [4 x double], [4 x double]* %0, i64 0, i64 0
%71 = getelementptr inbounds [4 x double], [4 x double]* %0, i64 1, i64 0
%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> %75, <2 x double> %39, <2 x double> zeroinitializer)
%77 = getelementptr inbounds [4 x double], [4 x double]* %0, i64 0, i64 1
%78 = getelementptr inbounds [4 x double], [4 x double]* %0, i64 1, i64 1
%79 = load double, double* %77
%80 = load double, double* %78
%81 = insertelement <2 x double> poison, double %79, i64 0
%82 = insertelement <2 x double> %81, double %80, i64 1
%83 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %82, <2 x double> %41, <2 x double> %76)
%84 = getelementptr inbounds [4 x double], [4 x double]* %0, i64 0, i64 2
%85 = getelementptr inbounds [4 x double], [4 x double]* %0, i64 1, i64 2
%86 = load double, double* %84
%87 = load double, double* %85
%88 = insertelement <2 x double> poison, double %86, i64 0
%89 = insertelement <2 x double> %88, double %87, i64 1
%90 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %89, <2 x double> %43, <2 x double> %83)
%91 = getelementptr inbounds [4 x double], [4 x double]* %0, i64 0, i64 3
%92 = getelementptr inbounds [4 x double], [4 x double]* %0, i64 1, i64 3
%93 = load double, double* %91
%94 = load double, double* %92
%95 = insertelement <2 x double> poison, double %93, i64 0
%96 = insertelement <2 x double> %95, double %94, i64 1
%97 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %96, <2 x double> %45, <2 x double> %90)
%98 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %75, <2 x double> %47, <2 x double> zeroinitializer)
%99 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %82, <2 x double> %49, <2 x double> %98)
%100 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %89, <2 x double> %51, <2 x double> %99)
%101 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %96, <2 x double> %53, <2 x double> %100)
%102 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %75, <2 x double> %55, <2 x double> zeroinitializer)
%103 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %82, <2 x double> %57, <2 x double> %102)
%104 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %89, <2 x double> %59, <2 x double> %103)
%105 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %96, <2 x double> %61, <2 x double> %104)
%106 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %75, <2 x double> %63, <2 x double> zeroinitializer)
%107 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %82, <2 x double> %65, <2 x double> %106)
%108 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %89, <2 x double> %67, <2 x double> %107)
%109 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %96, <2 x double> %69, <2 x double> %108)
%110 = bitcast [4 x [4 x double]]* %4 to <8 x double>*
%111 = shufflevector <2 x double> %97, <2 x double> %101, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
%112 = shufflevector <2 x double> %105, <2 x double> %109, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
%113 = shufflevector <4 x double> %111, <4 x double> %112, <8 x i32> <i32 0, i32 2, i32 4, i32 6, i32 1, i32 3, i32 5, i32 7>
store <8 x double> %113, <8 x double>* %110
%114 = getelementptr inbounds [4 x double], [4 x double]* %0, i64 2, i64 0
%115 = getelementptr inbounds [4 x double], [4 x double]* %0, i64 3, i64 0
%116 = load double, double* %114
%117 = load double, double* %115
%118 = insertelement <2 x double> poison, double %116, i64 0
%119 = insertelement <2 x double> %118, double %117, i64 1
%120 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %119, <2 x double> %39, <2 x double> zeroinitializer)
%121 = getelementptr inbounds [4 x double], [4 x double]* %0, i64 2, i64 1
%122 = getelementptr inbounds [4 x double], [4 x double]* %0, i64 3, i64 1
%123 = load double, double* %121
%124 = load double, double* %122
%125 = insertelement <2 x double> poison, double %123, i64 0
%126 = insertelement <2 x double> %125, double %124, i64 1
%127 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %126, <2 x double> %41, <2 x double> %120)
%128 = getelementptr inbounds [4 x double], [4 x double]* %0, i64 2, i64 2
%129 = getelementptr inbounds [4 x double], [4 x double]* %0, i64 3, i64 2
%130 = load double, double* %128
%131 = load double, double* %129
%132 = insertelement <2 x double> poison, double %130, i64 0
%133 = insertelement <2 x double> %132, double %131, i64 1
%134 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %133, <2 x double> %43, <2 x double> %127)
%135 = getelementptr inbounds [4 x double], [4 x double]* %0, i64 2, i64 3
%136 = getelementptr inbounds [4 x double], [4 x double]* %0, i64 3, i64 3
%137 = load double, double* %135
%138 = load double, double* %136
%139 = insertelement <2 x double> poison, double %137, i64 0
%140 = insertelement <2 x double> %139, double %138, i64 1
%141 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %140, <2 x double> %45, <2 x double> %134)
%142 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %119, <2 x double> %47, <2 x double> zeroinitializer)
%143 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %126, <2 x double> %49, <2 x double> %142)
%144 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %133, <2 x double> %51, <2 x double> %143)
%145 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %140, <2 x double> %53, <2 x double> %144)
%146 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %119, <2 x double> %55, <2 x double> zeroinitializer)
%147 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %126, <2 x double> %57, <2 x double> %146)
%148 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %133, <2 x double> %59, <2 x double> %147)
%149 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %140, <2 x double> %61, <2 x double> %148)
%150 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %119, <2 x double> %63, <2 x double> zeroinitializer)
%151 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %126, <2 x double> %65, <2 x double> %150)
%152 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %133, <2 x double> %67, <2 x double> %151)
%153 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %140, <2 x double> %69, <2 x double> %152)
%154 = getelementptr inbounds [4 x [4 x double]], [4 x [4 x double]]* %4, i64 0, i64 2, i64 0
%155 = bitcast double* %154 to <8 x double>*
%156 = shufflevector <2 x double> %141, <2 x double> %145, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
%157 = shufflevector <2 x double> %149, <2 x double> %153, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
%158 = shufflevector <4 x double> %156, <4 x double> %157, <8 x i32> <i32 0, i32 2, i32 4, i32 6, i32 1, i32 3, i32 5, i32 7>
store <8 x double> %158, <8 x double>* %155
%159 = getelementptr inbounds [4 x [4 x double]], [4 x [4 x double]]* %4, i64 0, i64 0
%160 = call i32 ([4 x double]*, [4 x double]*, ...) bitcast (i32 (...)* @copytransform to i32 ([4 x double]*, [4 x double]*, ...)*)([4 x double]* %159, [4 x double]* %2)
ret i32 undef
}