#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
double cos(double);
double deg2rad(double);
int /*<<< orphan*/ identity_matrix(double **, int);
double sin(double);
double veclen(double *);
void arb_rotation(double *va, double ang_deg, double **rot_mtx) {
  double c, dc, s, vlen;
  long i;
  vlen = veclen(va);
  if (vlen < 1.0e-7)
    identity_matrix(rot_mtx, 3);
  else {
    for (i = 1; i <= 3; i++)
      va[i] /= vlen;
    ang_deg = deg2rad(ang_deg);
    c = cos(ang_deg);
    s = sin(ang_deg);
    dc = 1 - c;
    rot_mtx[1][1] = c + dc * va[1] * va[1];
    rot_mtx[1][2] = va[1] * va[2] * dc - va[3] * s;
    rot_mtx[1][3] = va[1] * va[3] * dc + va[2] * s;
    rot_mtx[2][1] = va[1] * va[2] * dc + va[3] * s;
    rot_mtx[2][2] = c + dc * va[2] * va[2];
    rot_mtx[2][3] = va[2] * va[3] * dc - va[1] * s;
    rot_mtx[3][1] = va[1] * va[3] * dc - va[2] * s;
    rot_mtx[3][2] = va[2] * va[3] * dc + va[1] * s;
    rot_mtx[3][3] = c + dc * va[3] * va[3];
  }
}


x86 assembly (clang, -O0):
<arb_rotation>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x8(%rbp)
movsd  %xmm0,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    -0x8(%rbp),%rdi
call   1050 <veclen@plt>
movsd  %xmm0,-0x38(%rbp)
movsd  0xe85(%rip),%xmm0
ucomisd -0x38(%rbp),%xmm0
jbe    1199 <arb_rotation+0x49>
mov    -0x18(%rbp),%rdi
mov    $0x3,%esi
call   1070 <identity_matrix@plt>
jmp    144b <arb_rotation+0x2fb>
movq   $0x1,-0x40(%rbp)
cmpq   $0x3,-0x40(%rbp)
jg     11d8 <arb_rotation+0x88>
movsd  -0x38(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    11a1 <arb_rotation+0x51>
movsd  -0x10(%rbp),%xmm0
call   1030 <deg2rad@plt>
movsd  %xmm0,-0x10(%rbp)
movsd  -0x10(%rbp),%xmm0
call   1060 <cos@plt>
movsd  %xmm0,-0x20(%rbp)
movsd  -0x10(%rbp),%xmm0
call   1040 <sin@plt>
movsd  %xmm0,-0x30(%rbp)
movsd  0xdfb(%rip),%xmm0
subsd  -0x20(%rbp),%xmm0
movsd  %xmm0,-0x28(%rbp)
movsd  -0x20(%rbp),%xmm1
movsd  -0x28(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mulsd  0x8(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    0x8(%rax),%rax
movsd  %xmm0,0x8(%rax)
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x8(%rbp),%rax
mulsd  0x10(%rax),%xmm0
movsd  -0x28(%rbp),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x18(%rax),%xmm1
mulsd  -0x30(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    0x8(%rax),%rax
movsd  %xmm0,0x10(%rax)
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x8(%rbp),%rax
mulsd  0x18(%rax),%xmm0
movsd  -0x28(%rbp),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm1
mulsd  -0x30(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    0x8(%rax),%rax
movsd  %xmm0,0x18(%rax)
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x8(%rbp),%rax
mulsd  0x10(%rax),%xmm0
movsd  -0x28(%rbp),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x18(%rax),%xmm1
mulsd  -0x30(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    0x10(%rax),%rax
movsd  %xmm0,0x8(%rax)
movsd  -0x20(%rbp),%xmm1
movsd  -0x28(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mulsd  0x10(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    0x10(%rax),%rax
movsd  %xmm0,0x10(%rax)
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x8(%rbp),%rax
mulsd  0x18(%rax),%xmm0
movsd  -0x28(%rbp),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm1
mulsd  -0x30(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    0x10(%rax),%rax
movsd  %xmm0,0x18(%rax)
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x8(%rbp),%rax
mulsd  0x18(%rax),%xmm0
movsd  -0x28(%rbp),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm1
mulsd  -0x30(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    0x18(%rax),%rax
movsd  %xmm0,0x8(%rax)
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x8(%rbp),%rax
mulsd  0x18(%rax),%xmm0
movsd  -0x28(%rbp),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm1
mulsd  -0x30(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    0x18(%rax),%rax
movsd  %xmm0,0x10(%rax)
movsd  -0x20(%rbp),%xmm1
movsd  -0x28(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mulsd  0x18(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x18(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    0x18(%rax),%rax
movsd  %xmm0,0x18(%rax)
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<arb_rotation>:
push   %r14
push   %rbx
sub    $0x18,%rsp
mov    %rsi,%r14
movsd  %xmm0,0x8(%rsp)
mov    %rdi,%rbx
call   1050 <veclen@plt>
movsd  0xe90(%rip),%xmm1
ucomisd %xmm0,%xmm1
jbe    118a <arb_rotation+0x3a>
mov    %r14,%rdi
mov    $0x3,%esi
add    $0x18,%rsp
pop    %rbx
pop    %r14
jmp    1070 <identity_matrix@plt>
movupd 0x8(%rbx),%xmm1
movapd %xmm0,%xmm2
unpcklpd %xmm0,%xmm2
divpd  %xmm2,%xmm1
movupd %xmm1,0x8(%rbx)
movsd  0x18(%rbx),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x18(%rbx)
movsd  0x8(%rsp),%xmm0
call   1030 <deg2rad@plt>
movsd  %xmm0,0x10(%rsp)
call   1060 <cos@plt>
movsd  %xmm0,0x8(%rsp)
movsd  0x10(%rsp),%xmm0
call   1040 <sin@plt>
movsd  0xe2b(%rip),%xmm1
movsd  0x8(%rsp),%xmm4
subsd  %xmm4,%xmm1
movsd  0x8(%rbx),%xmm2
movapd %xmm1,%xmm3
mulsd  %xmm2,%xmm3
mulsd  %xmm2,%xmm3
addsd  %xmm4,%xmm3
mov    0x8(%r14),%rax
movsd  %xmm3,0x8(%rax)
movsd  0x8(%rbx),%xmm2
mulsd  0x10(%rbx),%xmm2
movsd  0x18(%rbx),%xmm3
mulsd  %xmm0,%xmm3
mulsd  %xmm1,%xmm2
subsd  %xmm3,%xmm2
movsd  %xmm2,0x10(%rax)
movsd  0x8(%rbx),%xmm2
mulsd  0x18(%rbx),%xmm2
movsd  0x10(%rbx),%xmm3
mulsd  %xmm0,%xmm3
mulsd  %xmm1,%xmm2
addsd  %xmm3,%xmm2
movsd  %xmm2,0x18(%rax)
movsd  0x8(%rbx),%xmm2
mulsd  0x10(%rbx),%xmm2
movsd  0x18(%rbx),%xmm3
mulsd  %xmm0,%xmm3
mulsd  %xmm1,%xmm2
addsd  %xmm3,%xmm2
mov    0x10(%r14),%rax
movsd  %xmm2,0x8(%rax)
movsd  0x10(%rbx),%xmm2
movapd %xmm1,%xmm3
mulsd  %xmm2,%xmm3
mulsd  %xmm2,%xmm3
addsd  %xmm4,%xmm3
movsd  %xmm3,0x10(%rax)
movsd  0x10(%rbx),%xmm2
mulsd  0x18(%rbx),%xmm2
movsd  0x8(%rbx),%xmm3
mulsd  %xmm0,%xmm3
mulsd  %xmm1,%xmm2
subsd  %xmm3,%xmm2
movsd  %xmm2,0x18(%rax)
movsd  0x8(%rbx),%xmm2
mulsd  0x18(%rbx),%xmm2
movsd  0x10(%rbx),%xmm3
mulsd  %xmm0,%xmm3
mulsd  %xmm1,%xmm2
subsd  %xmm3,%xmm2
mov    0x18(%r14),%rax
movsd  %xmm2,0x8(%rax)
movsd  0x10(%rbx),%xmm2
mulsd  0x18(%rbx),%xmm2
mulsd  0x8(%rbx),%xmm0
mulsd  %xmm1,%xmm2
addsd  %xmm0,%xmm2
movsd  %xmm2,0x10(%rax)
movsd  0x18(%rbx),%xmm0
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
addsd  %xmm4,%xmm1
movsd  %xmm1,0x18(%rax)
add    $0x18,%rsp
pop    %rbx
pop    %r14
ret

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

LLVM IR (-O2):
define void @arb_rotation(double* %0, double %1, double** %2) {
%4 = tail call double @veclen(double* %0)
%5 = fcmp olt double %4, 0x3E7AD7F29ABCAF48
br i1 %5, label %85, label %6
6: ; preds = %3
%7 = getelementptr inbounds double, double* %0, i64 1
%8 = getelementptr inbounds double, double* %0, i64 2
%9 = bitcast double* %7 to <2 x double>*
%10 = load <2 x double>, <2 x double>* %9
%11 = insertelement <2 x double> poison, double %4, i64 0
%12 = shufflevector <2 x double> %11, <2 x double> poison, <2 x i32> zeroinitializer
%13 = fdiv <2 x double> %10, %12
%14 = bitcast double* %7 to <2 x double>*
store <2 x double> %13, <2 x double>* %14
%15 = getelementptr inbounds double, double* %0, i64 3
%16 = load double, double* %15
%17 = fdiv double %16, %4
store double %17, double* %15
%18 = tail call double @deg2rad(double %1)
%19 = tail call double @cos(double %18)
%20 = tail call double @sin(double %18)
%21 = fsub double 1.000000e+00, %19
%22 = load double, double* %7
%23 = fmul double %21, %22
%24 = tail call double @llvm.fmuladd.f64(double %23, double %22, double %19)
%25 = getelementptr inbounds double*, double** %2, i64 1
%26 = load double*, double** %25
%27 = getelementptr inbounds double, double* %26, i64 1
store double %24, double* %27
%28 = load double, double* %7
%29 = load double, double* %8
%30 = fmul double %28, %29
%31 = load double, double* %15
%32 = fneg double %31
%33 = fmul double %20, %32
%34 = tail call double @llvm.fmuladd.f64(double %30, double %21, double %33)
%35 = getelementptr inbounds double, double* %26, i64 2
store double %34, double* %35
%36 = load double, double* %7
%37 = load double, double* %15
%38 = fmul double %36, %37
%39 = load double, double* %8
%40 = fmul double %20, %39
%41 = tail call double @llvm.fmuladd.f64(double %38, double %21, double %40)
%42 = getelementptr inbounds double, double* %26, i64 3
store double %41, double* %42
%43 = load double, double* %7
%44 = load double, double* %8
%45 = fmul double %43, %44
%46 = load double, double* %15
%47 = fmul double %20, %46
%48 = tail call double @llvm.fmuladd.f64(double %45, double %21, double %47)
%49 = getelementptr inbounds double*, double** %2, i64 2
%50 = load double*, double** %49
%51 = getelementptr inbounds double, double* %50, i64 1
store double %48, double* %51
%52 = load double, double* %8
%53 = fmul double %21, %52
%54 = tail call double @llvm.fmuladd.f64(double %53, double %52, double %19)
%55 = getelementptr inbounds double, double* %50, i64 2
store double %54, double* %55
%56 = load double, double* %8
%57 = load double, double* %15
%58 = fmul double %56, %57
%59 = load double, double* %7
%60 = fneg double %59
%61 = fmul double %20, %60
%62 = tail call double @llvm.fmuladd.f64(double %58, double %21, double %61)
%63 = getelementptr inbounds double, double* %50, i64 3
store double %62, double* %63
%64 = load double, double* %7
%65 = load double, double* %15
%66 = fmul double %64, %65
%67 = load double, double* %8
%68 = fneg double %67
%69 = fmul double %20, %68
%70 = tail call double @llvm.fmuladd.f64(double %66, double %21, double %69)
%71 = getelementptr inbounds double*, double** %2, i64 3
%72 = load double*, double** %71
%73 = getelementptr inbounds double, double* %72, i64 1
store double %70, double* %73
%74 = load double, double* %8
%75 = load double, double* %15
%76 = fmul double %74, %75
%77 = load double, double* %7
%78 = fmul double %20, %77
%79 = tail call double @llvm.fmuladd.f64(double %76, double %21, double %78)
%80 = getelementptr inbounds double, double* %72, i64 2
store double %79, double* %80
%81 = load double, double* %15
%82 = fmul double %21, %81
%83 = tail call double @llvm.fmuladd.f64(double %82, double %81, double %19)
%84 = getelementptr inbounds double, double* %72, i64 3
store double %83, double* %84
br label %87
85: ; preds = %3
%86 = tail call i32 @identity_matrix(double** %2, i32 3)
br label %87
87: ; preds = %6, %85
ret void
}