#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 */
float cos(float);
float sin(float);
void Calc_3dMat4Rot2(float pos[3], float vec[3], float th_rad,
                     float matA[4][4]) {
  float value_sin;
  float value_cos;
  value_sin = sin(th_rad);
  value_cos = cos(th_rad);
  matA[0][0] = vec[0] * vec[0] + (1.0 - (vec[0] * vec[0])) * value_cos;
  matA[0][1] = vec[0] * vec[1] * (1.0 - value_cos) + vec[2] * value_sin;
  matA[0][2] = vec[0] * vec[2] * (1.0 - value_cos) - vec[1] * value_sin;
  matA[0][3] = 0.0;
  matA[1][0] = vec[0] * vec[1] * (1.0 - value_cos) - vec[2] * value_sin;
  matA[1][1] = vec[1] * vec[1] + (1.0 - vec[1] * vec[1]) * value_cos;
  matA[1][2] = vec[1] * vec[2] * (1.0 - value_cos) + vec[0] * value_sin;
  matA[1][3] = 0.0;
  matA[2][0] = vec[0] * vec[2] * (1.0 - value_cos) + vec[1] * value_sin;
  matA[2][1] = vec[1] * vec[2] * (1.0 - value_cos) - vec[0] * value_sin;
  matA[2][2] = vec[2] * vec[2] + (1.0 - vec[2] * vec[2]) * value_cos;
  matA[2][3] = 0.0;
  matA[3][0] =
      pos[0] - pos[0] * matA[0][0] - pos[1] * matA[1][0] - pos[2] * matA[2][0];
  matA[3][1] =
      pos[1] - pos[0] * matA[0][1] - pos[1] * matA[1][1] - pos[2] * matA[2][1];
  matA[3][2] =
      pos[2] - pos[0] * matA[0][2] - pos[1] * matA[1][2] - pos[2] * matA[2][2];
  matA[3][3] = 1.0;
}


x86 assembly (clang, -O0):
<Calc_3dMat4Rot2>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movss  %xmm0,-0x14(%rbp)
mov    %rdx,-0x20(%rbp)
movss  -0x14(%rbp),%xmm0
call   1030 <sin@plt>
movss  %xmm0,-0x24(%rbp)
movss  -0x14(%rbp),%xmm0
call   1040 <cos@plt>
movss  %xmm0,-0x28(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x10(%rbp),%rax
mulss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x10(%rbp),%rax
mulss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm2
movsd  0xe81(%rip),%xmm0
subsd  %xmm2,%xmm0
movss  -0x28(%rbp),%xmm2
cvtss2sd %xmm2,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x10(%rbp),%rax
mulss  0x4(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
movss  -0x28(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
movsd  0xe3a(%rip),%xmm2
subsd  %xmm1,%xmm2
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm1
mulss  -0x24(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,0x4(%rax)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x10(%rbp),%rax
mulss  0x8(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
movss  -0x28(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
movsd  0xde9(%rip),%xmm2
subsd  %xmm1,%xmm2
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm1
mulss  -0x24(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,0x8(%rax)
mov    -0x20(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,0xc(%rax)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x10(%rbp),%rax
mulss  0x4(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
movss  -0x28(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
movsd  0xd75(%rip),%xmm2
subsd  %xmm1,%xmm2
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm1
mulss  -0x24(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,0x10(%rax)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulss  0x4(%rax),%xmm0
cvtss2sd %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulss  0x4(%rax),%xmm0
cvtss2sd %xmm0,%xmm2
movsd  0xcff(%rip),%xmm0
subsd  %xmm2,%xmm0
movss  -0x28(%rbp),%xmm2
cvtss2sd %xmm2,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,0x14(%rax)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulss  0x8(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
movss  -0x28(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
movsd  0xcb6(%rip),%xmm2
subsd  %xmm1,%xmm2
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm1
mulss  -0x24(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,0x18(%rax)
mov    -0x20(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,0x1c(%rax)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x10(%rbp),%rax
mulss  0x8(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
movss  -0x28(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
movsd  0xc5a(%rip),%xmm2
subsd  %xmm1,%xmm2
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm1
mulss  -0x24(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,0x20(%rax)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulss  0x8(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
movss  -0x28(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
movsd  0xc08(%rip),%xmm2
subsd  %xmm1,%xmm2
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm1
mulss  -0x24(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,0x24(%rax)
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulss  0x8(%rax),%xmm0
cvtss2sd %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulss  0x8(%rax),%xmm0
cvtss2sd %xmm0,%xmm2
movsd  0xb93(%rip),%xmm0
subsd  %xmm2,%xmm0
movss  -0x28(%rbp),%xmm2
cvtss2sd %xmm2,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,0x28(%rax)
mov    -0x20(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,0x2c(%rax)
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm1
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm1
mov    -0x20(%rbp),%rax
movss  0x10(%rax),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x20(%rbp),%rax
movss  0x20(%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,0x30(%rax)
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm1
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x20(%rbp),%rax
movss  0x4(%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm1
mov    -0x20(%rbp),%rax
movss  0x14(%rax),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x20(%rbp),%rax
movss  0x24(%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,0x34(%rax)
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm1
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x20(%rbp),%rax
movss  0x8(%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm1
mov    -0x20(%rbp),%rax
movss  0x18(%rax),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x20(%rbp),%rax
movss  0x28(%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,0x38(%rax)
mov    -0x20(%rbp),%rax
movss  0x9c1(%rip),%xmm0
movss  %xmm0,0x3c(%rax)
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<Calc_3dMat4Rot2>:
push   %r15
push   %r14
push   %rbx
sub    $0x10,%rsp
mov    %rdx,%r15
movss  %xmm0,0x8(%rsp)
mov    %rsi,%rbx
mov    %rdi,%r14
call   1030 <sin@plt>
movss  %xmm0,0xc(%rsp)
movss  0x8(%rsp),%xmm0
call   1040 <cos@plt>
movss  (%rbx),%xmm1
mulss  %xmm1,%xmm1
cvtss2sd %xmm1,%xmm2
movsd  0xe9e(%rip),%xmm1
movapd %xmm1,%xmm3
subsd  %xmm2,%xmm3
cvtss2sd %xmm0,%xmm12
mulsd  %xmm12,%xmm3
addsd  %xmm2,%xmm3
cvtsd2ss %xmm3,%xmm9
movss  %xmm9,(%r15)
movss  (%rbx),%xmm0
mulss  0x4(%rbx),%xmm0
cvtss2sd %xmm0,%xmm0
movapd %xmm1,%xmm5
subsd  %xmm12,%xmm5
movss  0x8(%rbx),%xmm2
movss  0xc(%rsp),%xmm4
mulss  %xmm4,%xmm2
cvtss2sd %xmm2,%xmm2
mulsd  %xmm5,%xmm0
addsd  %xmm2,%xmm0
cvtsd2ss %xmm0,%xmm10
movss  %xmm10,0x4(%r15)
movss  (%rbx),%xmm0
mulss  0x8(%rbx),%xmm0
cvtss2sd %xmm0,%xmm0
movss  0x4(%rbx),%xmm3
mulss  %xmm4,%xmm3
cvtss2sd %xmm3,%xmm3
mulsd  %xmm5,%xmm0
subsd  %xmm3,%xmm0
cvtsd2ss %xmm0,%xmm11
movss  %xmm11,0x8(%r15)
movl   $0x0,0xc(%r15)
movss  (%rbx),%xmm0
mulss  0x4(%rbx),%xmm0
cvtss2sd %xmm0,%xmm0
movss  0x8(%rbx),%xmm6
mulss  %xmm4,%xmm6
cvtss2sd %xmm6,%xmm6
mulsd  %xmm5,%xmm0
subsd  %xmm6,%xmm0
xorps  %xmm6,%xmm6
cvtsd2ss %xmm0,%xmm6
movss  %xmm6,0x10(%r15)
movss  0x4(%rbx),%xmm0
mulss  %xmm0,%xmm0
cvtss2sd %xmm0,%xmm0
movapd %xmm1,%xmm7
subsd  %xmm0,%xmm7
mulsd  %xmm12,%xmm7
addsd  %xmm0,%xmm7
cvtsd2ss %xmm7,%xmm8
movss  %xmm8,0x14(%r15)
movss  0x4(%rbx),%xmm0
mulss  0x8(%rbx),%xmm0
cvtss2sd %xmm0,%xmm0
movss  (%rbx),%xmm7
mulss  %xmm4,%xmm7
cvtss2sd %xmm7,%xmm7
mulsd  %xmm5,%xmm0
addsd  %xmm7,%xmm0
xorps  %xmm7,%xmm7
cvtsd2ss %xmm0,%xmm7
movss  %xmm7,0x18(%r15)
movl   $0x0,0x1c(%r15)
movss  (%rbx),%xmm0
mulss  0x8(%rbx),%xmm0
cvtss2sd %xmm0,%xmm0
movss  0x4(%rbx),%xmm2
mulss  %xmm4,%xmm2
cvtss2sd %xmm2,%xmm2
mulsd  %xmm5,%xmm0
addsd  %xmm2,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0x20(%r15)
movss  0x4(%rbx),%xmm2
mulss  0x8(%rbx),%xmm2
mulss  (%rbx),%xmm4
cvtss2sd %xmm2,%xmm2
xorps  %xmm3,%xmm3
cvtss2sd %xmm4,%xmm3
mulsd  %xmm5,%xmm2
subsd  %xmm3,%xmm2
cvtsd2ss %xmm2,%xmm5
movss  %xmm5,0x24(%r15)
movss  0x8(%rbx),%xmm2
mulss  %xmm2,%xmm2
cvtss2sd %xmm2,%xmm2
subsd  %xmm2,%xmm1
mulsd  %xmm12,%xmm1
addsd  %xmm2,%xmm1
cvtsd2ss %xmm1,%xmm1
movss  %xmm1,0x28(%r15)
movl   $0x0,0x2c(%r15)
movss  (%r14),%xmm2
mulss  %xmm2,%xmm9
subss  %xmm9,%xmm2
mulss  0x4(%r14),%xmm6
mulss  0x8(%r14),%xmm0
subss  %xmm6,%xmm2
subss  %xmm0,%xmm2
movss  %xmm2,0x30(%r15)
movss  0x4(%r14),%xmm0
mulss  (%r14),%xmm10
movaps %xmm0,%xmm2
subss  %xmm10,%xmm2
mulss  %xmm8,%xmm0
subss  %xmm0,%xmm2
mulss  0x8(%r14),%xmm5
subss  %xmm5,%xmm2
movss  %xmm2,0x34(%r15)
movss  0x8(%r14),%xmm0
mulss  (%r14),%xmm11
movaps %xmm0,%xmm2
subss  %xmm11,%xmm2
mulss  0x4(%r14),%xmm7
subss  %xmm7,%xmm2
mulss  %xmm1,%xmm0
subss  %xmm0,%xmm2
movss  %xmm2,0x38(%r15)
movl   $0x3f800000,0x3c(%r15)
3f
add    $0x10,%rsp
pop    %rbx
pop    %r14
pop    %r15
ret

LLVM IR (-O0):
define void @Calc_3dMat4Rot2(float* %0, float* %1, float %2, [4 x float]* %3) {
%5 = alloca float*
%6 = alloca float*
%7 = alloca float
%8 = alloca [4 x float]*
%9 = alloca float
%10 = alloca float
store float* %0, float** %5
store float* %1, float** %6
store float %2, float* %7
store [4 x float]* %3, [4 x float]** %8
%11 = load float, float* %7
%12 = call float @sin(float %11)
store float %12, float* %9
%13 = load float, float* %7
%14 = call float @cos(float %13)
store float %14, float* %10
%15 = load float*, float** %6
%16 = getelementptr inbounds float, float* %15, i64 0
%17 = load float, float* %16
%18 = load float*, float** %6
%19 = getelementptr inbounds float, float* %18, i64 0
%20 = load float, float* %19
%21 = fmul float %17, %20
%22 = fpext float %21 to double
%23 = load float*, float** %6
%24 = getelementptr inbounds float, float* %23, i64 0
%25 = load float, float* %24
%26 = load float*, float** %6
%27 = getelementptr inbounds float, float* %26, i64 0
%28 = load float, float* %27
%29 = fmul float %25, %28
%30 = fpext float %29 to double
%31 = fsub double 1.000000e+00, %30
%32 = load float, float* %10
%33 = fpext float %32 to double
%34 = call double @llvm.fmuladd.f64(double %31, double %33, double %22)
%35 = fptrunc double %34 to float
%36 = load [4 x float]*, [4 x float]** %8
%37 = getelementptr inbounds [4 x float], [4 x float]* %36, i64 0
%38 = getelementptr inbounds [4 x float], [4 x float]* %37, i64 0, i64 0
store float %35, float* %38
%39 = load float*, float** %6
%40 = getelementptr inbounds float, float* %39, i64 0
%41 = load float, float* %40
%42 = load float*, float** %6
%43 = getelementptr inbounds float, float* %42, i64 1
%44 = load float, float* %43
%45 = fmul float %41, %44
%46 = fpext float %45 to double
%47 = load float, float* %10
%48 = fpext float %47 to double
%49 = fsub double 1.000000e+00, %48
%50 = load float*, float** %6
%51 = getelementptr inbounds float, float* %50, i64 2
%52 = load float, float* %51
%53 = load float, float* %9
%54 = fmul float %52, %53
%55 = fpext float %54 to double
%56 = call double @llvm.fmuladd.f64(double %46, double %49, double %55)
%57 = fptrunc double %56 to float
%58 = load [4 x float]*, [4 x float]** %8
%59 = getelementptr inbounds [4 x float], [4 x float]* %58, i64 0
%60 = getelementptr inbounds [4 x float], [4 x float]* %59, i64 0, i64 1
store float %57, float* %60
%61 = load float*, float** %6
%62 = getelementptr inbounds float, float* %61, i64 0
%63 = load float, float* %62
%64 = load float*, float** %6
%65 = getelementptr inbounds float, float* %64, i64 2
%66 = load float, float* %65
%67 = fmul float %63, %66
%68 = fpext float %67 to double
%69 = load float, float* %10
%70 = fpext float %69 to double
%71 = fsub double 1.000000e+00, %70
%72 = load float*, float** %6
%73 = getelementptr inbounds float, float* %72, i64 1
%74 = load float, float* %73
%75 = load float, float* %9
%76 = fmul float %74, %75
%77 = fpext float %76 to double
%78 = fneg double %77
%79 = call double @llvm.fmuladd.f64(double %68, double %71, double %78)
%80 = fptrunc double %79 to float
%81 = load [4 x float]*, [4 x float]** %8
%82 = getelementptr inbounds [4 x float], [4 x float]* %81, i64 0
%83 = getelementptr inbounds [4 x float], [4 x float]* %82, i64 0, i64 2
store float %80, float* %83
%84 = load [4 x float]*, [4 x float]** %8
%85 = getelementptr inbounds [4 x float], [4 x float]* %84, i64 0
%86 = getelementptr inbounds [4 x float], [4 x float]* %85, i64 0, i64 3
store float 0.000000e+00, float* %86
%87 = load float*, float** %6
%88 = getelementptr inbounds float, float* %87, i64 0
%89 = load float, float* %88
%90 = load float*, float** %6
%91 = getelementptr inbounds float, float* %90, i64 1
%92 = load float, float* %91
%93 = fmul float %89, %92
%94 = fpext float %93 to double
%95 = load float, float* %10
%96 = fpext float %95 to double
%97 = fsub double 1.000000e+00, %96
%98 = load float*, float** %6
%99 = getelementptr inbounds float, float* %98, i64 2
%100 = load float, float* %99
%101 = load float, float* %9
%102 = fmul float %100, %101
%103 = fpext float %102 to double
%104 = fneg double %103
%105 = call double @llvm.fmuladd.f64(double %94, double %97, double %104)
%106 = fptrunc double %105 to float
%107 = load [4 x float]*, [4 x float]** %8
%108 = getelementptr inbounds [4 x float], [4 x float]* %107, i64 1
%109 = getelementptr inbounds [4 x float], [4 x float]* %108, i64 0, i64 0
store float %106, float* %109
%110 = load float*, float** %6
%111 = getelementptr inbounds float, float* %110, i64 1
%112 = load float, float* %111
%113 = load float*, float** %6
%114 = getelementptr inbounds float, float* %113, i64 1
%115 = load float, float* %114
%116 = fmul float %112, %115
%117 = fpext float %116 to double
%118 = load float*, float** %6
%119 = getelementptr inbounds float, float* %118, i64 1
%120 = load float, float* %119
%121 = load float*, float** %6
%122 = getelementptr inbounds float, float* %121, i64 1
%123 = load float, float* %122
%124 = fmul float %120, %123
%125 = fpext float %124 to double
%126 = fsub double 1.000000e+00, %125
%127 = load float, float* %10
%128 = fpext float %127 to double
%129 = call double @llvm.fmuladd.f64(double %126, double %128, double %117)
%130 = fptrunc double %129 to float
%131 = load [4 x float]*, [4 x float]** %8
%132 = getelementptr inbounds [4 x float], [4 x float]* %131, i64 1
%133 = getelementptr inbounds [4 x float], [4 x float]* %132, i64 0, i64 1
store float %130, float* %133
%134 = load float*, float** %6
%135 = getelementptr inbounds float, float* %134, i64 1
%136 = load float, float* %135
%137 = load float*, float** %6
%138 = getelementptr inbounds float, float* %137, i64 2
%139 = load float, float* %138
%140 = fmul float %136, %139
%141 = fpext float %140 to double
%142 = load float, float* %10
%143 = fpext float %142 to double
%144 = fsub double 1.000000e+00, %143
%145 = load float*, float** %6
%146 = getelementptr inbounds float, float* %145, i64 0
%147 = load float, float* %146
%148 = load float, float* %9
%149 = fmul float %147, %148
%150 = fpext float %149 to double
%151 = call double @llvm.fmuladd.f64(double %141, double %144, double %150)
%152 = fptrunc double %151 to float
%153 = load [4 x float]*, [4 x float]** %8
%154 = getelementptr inbounds [4 x float], [4 x float]* %153, i64 1
%155 = getelementptr inbounds [4 x float], [4 x float]* %154, i64 0, i64 2
store float %152, float* %155
%156 = load [4 x float]*, [4 x float]** %8
%157 = getelementptr inbounds [4 x float], [4 x float]* %156, i64 1
%158 = getelementptr inbounds [4 x float], [4 x float]* %157, i64 0, i64 3
store float 0.000000e+00, float* %158
%159 = load float*, float** %6
%160 = getelementptr inbounds float, float* %159, i64 0
%161 = load float, float* %160
%162 = load float*, float** %6
%163 = getelementptr inbounds float, float* %162, i64 2
%164 = load float, float* %163
%165 = fmul float %161, %164
%166 = fpext float %165 to double
%167 = load float, float* %10
%168 = fpext float %167 to double
%169 = fsub double 1.000000e+00, %168
%170 = load float*, float** %6
%171 = getelementptr inbounds float, float* %170, i64 1
%172 = load float, float* %171
%173 = load float, float* %9
%174 = fmul float %172, %173
%175 = fpext float %174 to double
%176 = call double @llvm.fmuladd.f64(double %166, double %169, double %175)
%177 = fptrunc double %176 to float
%178 = load [4 x float]*, [4 x float]** %8
%179 = getelementptr inbounds [4 x float], [4 x float]* %178, i64 2
%180 = getelementptr inbounds [4 x float], [4 x float]* %179, i64 0, i64 0
store float %177, float* %180
%181 = load float*, float** %6
%182 = getelementptr inbounds float, float* %181, i64 1
%183 = load float, float* %182
%184 = load float*, float** %6
%185 = getelementptr inbounds float, float* %184, i64 2
%186 = load float, float* %185
%187 = fmul float %183, %186
%188 = fpext float %187 to double
%189 = load float, float* %10
%190 = fpext float %189 to double
%191 = fsub double 1.000000e+00, %190
%192 = load float*, float** %6
%193 = getelementptr inbounds float, float* %192, i64 0
%194 = load float, float* %193
%195 = load float, float* %9
%196 = fmul float %194, %195
%197 = fpext float %196 to double
%198 = fneg double %197
%199 = call double @llvm.fmuladd.f64(double %188, double %191, double %198)
%200 = fptrunc double %199 to float
%201 = load [4 x float]*, [4 x float]** %8
%202 = getelementptr inbounds [4 x float], [4 x float]* %201, i64 2
%203 = getelementptr inbounds [4 x float], [4 x float]* %202, i64 0, i64 1
store float %200, float* %203
%204 = load float*, float** %6
%205 = getelementptr inbounds float, float* %204, i64 2
%206 = load float, float* %205
%207 = load float*, float** %6
%208 = getelementptr inbounds float, float* %207, i64 2
%209 = load float, float* %208
%210 = fmul float %206, %209
%211 = fpext float %210 to double
%212 = load float*, float** %6
%213 = getelementptr inbounds float, float* %212, i64 2
%214 = load float, float* %213
%215 = load float*, float** %6
%216 = getelementptr inbounds float, float* %215, i64 2
%217 = load float, float* %216
%218 = fmul float %214, %217
%219 = fpext float %218 to double
%220 = fsub double 1.000000e+00, %219
%221 = load float, float* %10
%222 = fpext float %221 to double
%223 = call double @llvm.fmuladd.f64(double %220, double %222, double %211)
%224 = fptrunc double %223 to float
%225 = load [4 x float]*, [4 x float]** %8
%226 = getelementptr inbounds [4 x float], [4 x float]* %225, i64 2
%227 = getelementptr inbounds [4 x float], [4 x float]* %226, i64 0, i64 2
store float %224, float* %227
%228 = load [4 x float]*, [4 x float]** %8
%229 = getelementptr inbounds [4 x float], [4 x float]* %228, i64 2
%230 = getelementptr inbounds [4 x float], [4 x float]* %229, i64 0, i64 3
store float 0.000000e+00, float* %230
%231 = load float*, float** %5
%232 = getelementptr inbounds float, float* %231, i64 0
%233 = load float, float* %232
%234 = load float*, float** %5
%235 = getelementptr inbounds float, float* %234, i64 0
%236 = load float, float* %235
%237 = load [4 x float]*, [4 x float]** %8
%238 = getelementptr inbounds [4 x float], [4 x float]* %237, i64 0
%239 = getelementptr inbounds [4 x float], [4 x float]* %238, i64 0, i64 0
%240 = load float, float* %239
%241 = fneg float %236
%242 = call float @llvm.fmuladd.f32(float %241, float %240, float %233)
%243 = load float*, float** %5
%244 = getelementptr inbounds float, float* %243, i64 1
%245 = load float, float* %244
%246 = load [4 x float]*, [4 x float]** %8
%247 = getelementptr inbounds [4 x float], [4 x float]* %246, i64 1
%248 = getelementptr inbounds [4 x float], [4 x float]* %247, i64 0, i64 0
%249 = load float, float* %248
%250 = fneg float %245
%251 = call float @llvm.fmuladd.f32(float %250, float %249, float %242)
%252 = load float*, float** %5
%253 = getelementptr inbounds float, float* %252, i64 2
%254 = load float, float* %253
%255 = load [4 x float]*, [4 x float]** %8
%256 = getelementptr inbounds [4 x float], [4 x float]* %255, i64 2
%257 = getelementptr inbounds [4 x float], [4 x float]* %256, i64 0, i64 0
%258 = load float, float* %257
%259 = fneg float %254
%260 = call float @llvm.fmuladd.f32(float %259, float %258, float %251)
%261 = load [4 x float]*, [4 x float]** %8
%262 = getelementptr inbounds [4 x float], [4 x float]* %261, i64 3
%263 = getelementptr inbounds [4 x float], [4 x float]* %262, i64 0, i64 0
store float %260, float* %263
%264 = load float*, float** %5
%265 = getelementptr inbounds float, float* %264, i64 1
%266 = load float, float* %265
%267 = load float*, float** %5
%268 = getelementptr inbounds float, float* %267, i64 0
%269 = load float, float* %268
%270 = load [4 x float]*, [4 x float]** %8
%271 = getelementptr inbounds [4 x float], [4 x float]* %270, i64 0
%272 = getelementptr inbounds [4 x float], [4 x float]* %271, i64 0, i64 1
%273 = load float, float* %272
%274 = fneg float %269
%275 = call float @llvm.fmuladd.f32(float %274, float %273, float %266)
%276 = load float*, float** %5
%277 = getelementptr inbounds float, float* %276, i64 1
%278 = load float, float* %277
%279 = load [4 x float]*, [4 x float]** %8
%280 = getelementptr inbounds [4 x float], [4 x float]* %279, i64 1
%281 = getelementptr inbounds [4 x float], [4 x float]* %280, i64 0, i64 1
%282 = load float, float* %281
%283 = fneg float %278
%284 = call float @llvm.fmuladd.f32(float %283, float %282, float %275)
%285 = load float*, float** %5
%286 = getelementptr inbounds float, float* %285, i64 2
%287 = load float, float* %286
%288 = load [4 x float]*, [4 x float]** %8
%289 = getelementptr inbounds [4 x float], [4 x float]* %288, i64 2
%290 = getelementptr inbounds [4 x float], [4 x float]* %289, i64 0, i64 1
%291 = load float, float* %290
%292 = fneg float %287
%293 = call float @llvm.fmuladd.f32(float %292, float %291, float %284)
%294 = load [4 x float]*, [4 x float]** %8
%295 = getelementptr inbounds [4 x float], [4 x float]* %294, i64 3
%296 = getelementptr inbounds [4 x float], [4 x float]* %295, i64 0, i64 1
store float %293, float* %296
%297 = load float*, float** %5
%298 = getelementptr inbounds float, float* %297, i64 2
%299 = load float, float* %298
%300 = load float*, float** %5
%301 = getelementptr inbounds float, float* %300, i64 0
%302 = load float, float* %301
%303 = load [4 x float]*, [4 x float]** %8
%304 = getelementptr inbounds [4 x float], [4 x float]* %303, i64 0
%305 = getelementptr inbounds [4 x float], [4 x float]* %304, i64 0, i64 2
%306 = load float, float* %305
%307 = fneg float %302
%308 = call float @llvm.fmuladd.f32(float %307, float %306, float %299)
%309 = load float*, float** %5
%310 = getelementptr inbounds float, float* %309, i64 1
%311 = load float, float* %310
%312 = load [4 x float]*, [4 x float]** %8
%313 = getelementptr inbounds [4 x float], [4 x float]* %312, i64 1
%314 = getelementptr inbounds [4 x float], [4 x float]* %313, i64 0, i64 2
%315 = load float, float* %314
%316 = fneg float %311
%317 = call float @llvm.fmuladd.f32(float %316, float %315, float %308)
%318 = load float*, float** %5
%319 = getelementptr inbounds float, float* %318, i64 2
%320 = load float, float* %319
%321 = load [4 x float]*, [4 x float]** %8
%322 = getelementptr inbounds [4 x float], [4 x float]* %321, i64 2
%323 = getelementptr inbounds [4 x float], [4 x float]* %322, i64 0, i64 2
%324 = load float, float* %323
%325 = fneg float %320
%326 = call float @llvm.fmuladd.f32(float %325, float %324, float %317)
%327 = load [4 x float]*, [4 x float]** %8
%328 = getelementptr inbounds [4 x float], [4 x float]* %327, i64 3
%329 = getelementptr inbounds [4 x float], [4 x float]* %328, i64 0, i64 2
store float %326, float* %329
%330 = load [4 x float]*, [4 x float]** %8
%331 = getelementptr inbounds [4 x float], [4 x float]* %330, i64 3
%332 = getelementptr inbounds [4 x float], [4 x float]* %331, i64 0, i64 3
store float 1.000000e+00, float* %332
ret void
}

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