void update(float **dR, float **R, float *dV, float *V) {
  int i, j, k;
  float rtemp[3][3], vtemp[3];
  for (i = 0; i < 3; ++i) {
    vtemp[i] = 0;
    for (j = 0; j < 3; ++j) {
      rtemp[i][j] = 0;
      vtemp[i] += dR[i][j] * V[j];
      for (k = 0; k < 3; ++k)
        rtemp[i][j] += dR[i][k] * R[k][j];
    }
  }
  for (i = 0; i < 3; ++i) {
    V[i] = vtemp[i] + dV[i];
    for (j = 0; j < 3; ++j)
      R[i][j] = rtemp[i][j];
  }
}


x86 assembly (clang, -O0):
<update>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
cmpl   $0x3,-0x24(%rbp)
jge    122c <update+0x12c>
movslq -0x24(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,-0x5c(%rbp,%rax,4)
movl   $0x0,-0x28(%rbp)
cmpl   $0x3,-0x28(%rbp)
jge    1219 <update+0x119>
movslq -0x24(%rbp),%rcx
lea    -0x50(%rbp),%rax
imul   $0xc,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movslq -0x24(%rbp),%rax
movss  -0x5c(%rbp,%rax,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp,%rax,4)
movl   $0x0,-0x2c(%rbp)
cmpl   $0x3,-0x2c(%rbp)
jge    1206 <update+0x106>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movslq -0x24(%rbp),%rcx
lea    -0x50(%rbp),%rax
imul   $0xc,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    119f <update+0x9f>
jmp    120b <update+0x10b>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1139 <update+0x39>
jmp    121e <update+0x11e>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    111b <update+0x1b>
movl   $0x0,-0x24(%rbp)
cmpl   $0x3,-0x24(%rbp)
jge    12c0 <update+0x1c0>
movslq -0x24(%rbp),%rax
movss  -0x5c(%rbp,%rax,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movl   $0x0,-0x28(%rbp)
cmpl   $0x3,-0x28(%rbp)
jge    12ad <update+0x1ad>
movslq -0x24(%rbp),%rcx
lea    -0x50(%rbp),%rax
imul   $0xc,%rcx,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1268 <update+0x168>
jmp    12b2 <update+0x1b2>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1233 <update+0x133>
pop    %rbp
ret

x86 assembly (clang, -O2):
<update>:
mov    (%rsi),%rax
mov    0x8(%rsi),%r8
mov    0x10(%rsi),%r9
movss  (%rcx),%xmm14
movss  0x4(%rcx),%xmm12
movss  %xmm12,-0x44(%rsp)
movss  0x8(%rcx),%xmm0
movss  %xmm0,-0x40(%rsp)
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x3c(%rsp)
movss  0x8(%r8),%xmm0
movss  %xmm0,-0x48(%rsp)
movss  0x8(%r9),%xmm13
movss  (%rax),%xmm8
movss  0x4(%rax),%xmm15
movss  (%r8),%xmm9
movss  (%r9),%xmm11
mov    (%rdi),%rsi
movss  (%rsi),%xmm1
movss  0x4(%rsi),%xmm4
movaps %xmm1,%xmm0
mulss  %xmm8,%xmm0
xorps  %xmm2,%xmm2
addss  %xmm2,%xmm0
movaps %xmm4,%xmm2
mulss  %xmm9,%xmm2
addss  %xmm0,%xmm2
movss  0x8(%rsi),%xmm6
movaps %xmm6,%xmm0
mulss  %xmm11,%xmm0
addss  %xmm2,%xmm0
movss  0x4(%r8),%xmm7
movss  0x4(%r9),%xmm10
movss  %xmm0,-0x38(%rsp)
movaps %xmm1,%xmm0
mulss  %xmm15,%xmm0
xorps  %xmm2,%xmm2
addss  %xmm2,%xmm0
movaps %xmm4,%xmm5
mulss  %xmm7,%xmm5
addss  %xmm0,%xmm5
movaps %xmm6,%xmm0
mulss  %xmm10,%xmm0
addss  %xmm5,%xmm0
movaps %xmm1,%xmm5
mulss  %xmm14,%xmm5
addss  %xmm2,%xmm5
movaps %xmm4,%xmm3
mulss  %xmm12,%xmm3
addss  %xmm5,%xmm3
movss  %xmm0,-0x34(%rsp)
movss  -0x3c(%rsp),%xmm12
mulss  %xmm12,%xmm1
addss  %xmm2,%xmm1
mulss  -0x48(%rsp),%xmm4
addss  %xmm1,%xmm4
movaps %xmm6,%xmm0
mulss  %xmm13,%xmm0
addss  %xmm4,%xmm0
mulss  -0x40(%rsp),%xmm6
addss  %xmm3,%xmm6
movss  %xmm0,-0x30(%rsp)
movss  %xmm6,-0xc(%rsp)
mov    0x8(%rdi),%rsi
movss  (%rsi),%xmm2
movaps %xmm2,%xmm3
mulss  %xmm8,%xmm3
xorps  %xmm0,%xmm0
addss  %xmm0,%xmm3
movss  0x4(%rsi),%xmm1
movaps %xmm1,%xmm4
mulss  %xmm9,%xmm4
addss  %xmm3,%xmm4
movss  0x8(%rsi),%xmm5
movaps %xmm5,%xmm3
mulss  %xmm11,%xmm3
addss  %xmm4,%xmm3
movss  %xmm3,-0x2c(%rsp)
movaps %xmm2,%xmm3
mulss  %xmm15,%xmm3
addss  %xmm0,%xmm3
movaps %xmm1,%xmm4
mulss  %xmm7,%xmm4
addss  %xmm3,%xmm4
movaps %xmm5,%xmm3
mulss  %xmm10,%xmm3
addss  %xmm4,%xmm3
movaps %xmm2,%xmm4
mulss  %xmm14,%xmm4
addss  %xmm0,%xmm4
movaps %xmm1,%xmm0
mulss  -0x44(%rsp),%xmm0
addss  %xmm4,%xmm0
movss  %xmm3,-0x28(%rsp)
mulss  %xmm12,%xmm2
addss  0xd4e(%rip),%xmm2
movss  -0x48(%rsp),%xmm4
mulss  %xmm4,%xmm1
addss  %xmm2,%xmm1
movaps %xmm5,%xmm2
mulss  %xmm13,%xmm2
addss  %xmm1,%xmm2
movss  -0x40(%rsp),%xmm3
mulss  %xmm3,%xmm5
addss  %xmm0,%xmm5
movss  %xmm2,-0x24(%rsp)
movss  %xmm5,-0x8(%rsp)
mov    0x10(%rdi),%rsi
movss  (%rsi),%xmm1
movss  0x4(%rsi),%xmm5
mulss  %xmm1,%xmm8
xorps  %xmm2,%xmm2
addss  %xmm2,%xmm8
mulss  %xmm5,%xmm9
addss  %xmm8,%xmm9
movss  0x8(%rsi),%xmm0
mulss  %xmm0,%xmm11
addss  %xmm9,%xmm11
movss  %xmm11,-0x20(%rsp)
mulss  %xmm1,%xmm15
addss  %xmm2,%xmm15
mulss  %xmm5,%xmm7
addss  %xmm15,%xmm7
mulss  %xmm0,%xmm10
addss  %xmm7,%xmm10
mulss  %xmm1,%xmm14
addss  %xmm2,%xmm14
xorps  %xmm7,%xmm7
movss  -0x44(%rsp),%xmm2
mulss  %xmm5,%xmm2
addss  %xmm14,%xmm2
movss  %xmm10,-0x1c(%rsp)
mulss  %xmm12,%xmm1
addss  %xmm7,%xmm1
mulss  %xmm4,%xmm5
addss  %xmm1,%xmm5
mulss  %xmm0,%xmm13
addss  %xmm5,%xmm13
mulss  %xmm3,%xmm0
addss  %xmm2,%xmm0
movss  %xmm13,-0x18(%rsp)
movss  %xmm0,-0x4(%rsp)
addss  (%rdx),%xmm6
movss  %xmm6,(%rcx)
mov    -0x30(%rsp),%esi
mov    %esi,0x8(%rax)
mov    -0x38(%rsp),%rsi
mov    %rsi,(%rax)
movss  -0x8(%rsp),%xmm0
addss  0x4(%rdx),%xmm0
movss  %xmm0,0x4(%rcx)
mov    -0x24(%rsp),%eax
mov    %eax,0x8(%r8)
mov    -0x2c(%rsp),%rax
mov    %rax,(%r8)
movss  -0x4(%rsp),%xmm0
addss  0x8(%rdx),%xmm0
movss  %xmm0,0x8(%rcx)
mov    -0x18(%rsp),%eax
mov    %eax,0x8(%r9)
mov    -0x20(%rsp),%rax
mov    %rax,(%r9)
ret

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

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