multiplyMatricies(float a[4][4], float b[4][4], float c[4][4]) {
  int x, y;
  float temp[4][4];
  for (y = 0; y < 4; y++) {
    for (x = 0; x < 4; x++) {
      temp[y][x] = b[y][0] * a[0][x] + b[y][1] * a[1][x] + b[y][2] * a[2][x] +
                   b[y][3] * a[3][x];
    }
  }
  for (y = 0; y < 4; y++) {
    for (x = 0; x < 4; x++) {
      c[y][x] = temp[y][x];
    }
  }
}


x86 assembly (clang, -O0):
<multiplyMatricies>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
movl   $0x0,-0x28(%rbp)
cmpl   $0x4,-0x28(%rbp)
jge    1209 <multiplyMatricies+0x109>
movl   $0x0,-0x24(%rbp)
cmpl   $0x4,-0x24(%rbp)
jge    11f6 <multiplyMatricies+0xf6>
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movss  (%rax),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movss  0x4(%rax),%xmm1
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
mulss  0x10(%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movss  0x8(%rax),%xmm1
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  0x20(%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movss  0xc(%rax),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  0x30(%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movslq -0x28(%rbp),%rcx
lea    -0x70(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1128 <multiplyMatricies+0x28>
jmp    11fb <multiplyMatricies+0xfb>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1117 <multiplyMatricies+0x17>
movl   $0x0,-0x28(%rbp)
cmpl   $0x4,-0x28(%rbp)
jge    127c <multiplyMatricies+0x17c>
movl   $0x0,-0x24(%rbp)
cmpl   $0x4,-0x24(%rbp)
jge    1269 <multiplyMatricies+0x169>
movslq -0x28(%rbp),%rcx
lea    -0x70(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1221 <multiplyMatricies+0x121>
jmp    126e <multiplyMatricies+0x16e>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1210 <multiplyMatricies+0x110>
mov    -0x4(%rbp),%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<multiplyMatricies>:
movss  (%rdi),%xmm2
movss  0x4(%rdi),%xmm0
movss  0x30(%rsi),%xmm1
movss  0x20(%rsi),%xmm4
unpcklps %xmm1,%xmm4
movss  0x10(%rsi),%xmm1
movss  (%rsi),%xmm3
unpcklps %xmm1,%xmm3
movlhps %xmm4,%xmm3
movss  0x4(%rsi),%xmm5
movss  0x8(%rsi),%xmm4
movss  0xc(%rsi),%xmm1
movss  0x34(%rsi),%xmm6
movss  0x24(%rsi),%xmm7
unpcklps %xmm6,%xmm7
movss  0x14(%rsi),%xmm6
unpcklps %xmm6,%xmm5
movlhps %xmm7,%xmm5
movss  0x38(%rsi),%xmm6
movss  0x28(%rsi),%xmm7
unpcklps %xmm6,%xmm7
movss  0x18(%rsi),%xmm6
unpcklps %xmm6,%xmm4
movlhps %xmm7,%xmm4
movss  0x3c(%rsi),%xmm6
movss  0x2c(%rsi),%xmm7
unpcklps %xmm6,%xmm7
movss  0x1c(%rsi),%xmm6
unpcklps %xmm6,%xmm1
movss  0x8(%rdi),%xmm6
shufps $0x0,%xmm6,%xmm6
shufps $0x0,%xmm0,%xmm0
shufps $0x0,%xmm2,%xmm2
movlhps %xmm7,%xmm1
movss  0x10(%rdi),%xmm7
shufps $0x0,%xmm7,%xmm7
mulps  %xmm5,%xmm7
mulps  %xmm3,%xmm2
addps  %xmm7,%xmm2
movss  0x20(%rdi),%xmm7
shufps $0x0,%xmm7,%xmm7
mulps  %xmm4,%xmm7
addps  %xmm2,%xmm7
movss  0x30(%rdi),%xmm2
shufps $0x0,%xmm2,%xmm2
mulps  %xmm1,%xmm2
addps  %xmm7,%xmm2
movss  0x14(%rdi),%xmm7
shufps $0x0,%xmm7,%xmm7
mulps  %xmm5,%xmm7
mulps  %xmm3,%xmm0
addps  %xmm7,%xmm0
movss  0x24(%rdi),%xmm7
shufps $0x0,%xmm7,%xmm7
mulps  %xmm4,%xmm7
addps  %xmm0,%xmm7
movss  0x34(%rdi),%xmm0
shufps $0x0,%xmm0,%xmm0
mulps  %xmm1,%xmm0
addps  %xmm7,%xmm0
movss  0x18(%rdi),%xmm7
shufps $0x0,%xmm7,%xmm7
mulps  %xmm5,%xmm7
mulps  %xmm3,%xmm6
addps  %xmm7,%xmm6
movss  0x28(%rdi),%xmm7
shufps $0x0,%xmm7,%xmm7
mulps  %xmm4,%xmm7
addps  %xmm6,%xmm7
movss  0x38(%rdi),%xmm6
shufps $0x0,%xmm6,%xmm6
mulps  %xmm1,%xmm6
addps  %xmm7,%xmm6
movss  0x1c(%rdi),%xmm7
shufps $0x0,%xmm7,%xmm7
mulps  %xmm7,%xmm5
movss  0xc(%rdi),%xmm7
shufps $0x0,%xmm7,%xmm7
mulps  %xmm7,%xmm3
movss  0x3c(%rdi),%xmm7
shufps $0x0,%xmm7,%xmm7
addps  %xmm5,%xmm3
movss  0x2c(%rdi),%xmm5
shufps $0x0,%xmm5,%xmm5
mulps  %xmm5,%xmm4
addps  %xmm3,%xmm4
mulps  %xmm7,%xmm1
addps  %xmm4,%xmm1
movaps %xmm1,%xmm3
movlhps %xmm6,%xmm3
movaps %xmm2,%xmm4
unpcklps %xmm0,%xmm4
shufps $0x24,%xmm3,%xmm4
movaps %xmm6,%xmm3
unpcklps %xmm1,%xmm3
movaps %xmm0,%xmm5
shufps $0x11,%xmm2,%xmm5
shufps $0xe2,%xmm3,%xmm5
movaps %xmm1,%xmm3
unpckhpd %xmm6,%xmm3
movaps %xmm2,%xmm7
unpckhps %xmm0,%xmm7
shufps $0x24,%xmm3,%xmm7
unpckhps %xmm1,%xmm6
shufps $0x33,%xmm2,%xmm0
shufps $0xe2,%xmm6,%xmm0
movaps %xmm0,-0x18(%rsp)
movaps %xmm7,-0x28(%rsp)
movaps %xmm5,-0x38(%rsp)
movaps %xmm4,-0x48(%rsp)
movaps -0x18(%rsp),%xmm0
movups %xmm0,0x30(%rdx)
movaps -0x28(%rsp),%xmm0
movups %xmm0,0x20(%rdx)
movaps -0x38(%rsp),%xmm0
movups %xmm0,0x10(%rdx)
movaps -0x48(%rsp),%xmm0
movups %xmm0,(%rdx)
ret

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

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