#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 M_PI;
float cosf(float);
float sinf(float);
float sqrtf(float);
void mtxLoadRotate(float *mtx, float deg, float xAxis, float yAxis,
                   float zAxis) {
  float rad = deg * M_PI / 180.0f;
  float sin_a = sinf(rad);
  float cos_a = cosf(rad);
  float magnitude = sqrtf(xAxis * xAxis + yAxis * yAxis + zAxis * zAxis);
  float p = 1.0f / magnitude;
  float cos_am = 1.0f - cos_a;
  float xp = xAxis * p;
  float yp = yAxis * p;
  float zp = zAxis * p;
  float xx = xp * xp;
  float yy = yp * yp;
  float zz = zp * zp;
  float xy = xp * yp * cos_am;
  float yz = yp * zp * cos_am;
  float zx = zp * xp * cos_am;
  xp *= sin_a;
  yp *= sin_a;
  zp *= sin_a;
  float m0 = xx + cos_a * (1.0f - xx);
  float m1 = xy + zp;
  float m2 = zx - yp;
  float m4 = xy - zp;
  float m5 = yy + cos_a * (1.0f - yy);
  float m6 = yz + xp;
  float m8 = zx + yp;
  float m9 = yz - xp;
  float m10 = zz + cos_a * (1.0f - zz);
  float c1 = mtx[0];
  float c2 = mtx[4];
  float c3 = mtx[8];
  mtx[0] = c1 * m0 + c2 * m1 + c3 * m2;
  mtx[4] = c1 * m4 + c2 * m5 + c3 * m6;
  mtx[8] = c1 * m8 + c2 * m9 + c3 * m10;
  c1 = mtx[1];
  c2 = mtx[5];
  c3 = mtx[9];
  mtx[1] = c1 * m0 + c2 * m1 + c3 * m2;
  mtx[5] = c1 * m4 + c2 * m5 + c3 * m6;
  mtx[9] = c1 * m8 + c2 * m9 + c3 * m10;
  c1 = mtx[2];
  c2 = mtx[6];
  c3 = mtx[10];
  mtx[2] = c1 * m0 + c2 * m1 + c3 * m2;
  mtx[6] = c1 * m4 + c2 * m5 + c3 * m6;
  mtx[10] = c1 * m8 + c2 * m9 + c3 * m10;
  c1 = mtx[3];
  c2 = mtx[7];
  c3 = mtx[11];
  mtx[3] = c1 * m0 + c2 * m1 + c3 * m2;
  mtx[7] = c1 * m4 + c2 * m5 + c3 * m6;
  mtx[11] = c1 * m8 + c2 * m9 + c3 * m10;
  mtx[12] = mtx[13] = mtx[14] = 0.0;
  mtx[15] = 1.0f;
}


x86 assembly (clang, -O0):
<mtxLoadRotate>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
mov    %rdi,-0x8(%rbp)
movss  %xmm0,-0xc(%rbp)
movss  %xmm1,-0x10(%rbp)
movss  %xmm2,-0x14(%rbp)
movss  %xmm3,-0x18(%rbp)
movss  -0xc(%rbp),%xmm0
mov    0x2e89(%rip),%rax
mulss  (%rax),%xmm0
movss  0xe99(%rip),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x1c(%rbp)
movss  -0x1c(%rbp),%xmm0
call   1030 <sinf@plt>
movss  %xmm0,-0x20(%rbp)
movss  -0x1c(%rbp),%xmm0
call   1040 <cosf@plt>
movss  %xmm0,-0x24(%rbp)
movss  -0x10(%rbp),%xmm1
movss  -0x10(%rbp),%xmm2
movss  -0x14(%rbp),%xmm0
mulss  -0x14(%rbp),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x18(%rbp),%xmm0
movss  -0x18(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
call   1050 <sqrtf@plt>
movss  %xmm0,-0x28(%rbp)
movss  0xe2e(%rip),%xmm0
divss  -0x28(%rbp),%xmm0
movss  %xmm0,-0x2c(%rbp)
movss  0xe1c(%rip),%xmm0
subss  -0x24(%rbp),%xmm0
movss  %xmm0,-0x30(%rbp)
movss  -0x10(%rbp),%xmm0
mulss  -0x2c(%rbp),%xmm0
movss  %xmm0,-0x34(%rbp)
movss  -0x14(%rbp),%xmm0
mulss  -0x2c(%rbp),%xmm0
movss  %xmm0,-0x38(%rbp)
movss  -0x18(%rbp),%xmm0
mulss  -0x2c(%rbp),%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  -0x34(%rbp),%xmm0
mulss  -0x34(%rbp),%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x38(%rbp),%xmm0
mulss  -0x38(%rbp),%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x3c(%rbp),%xmm0
mulss  -0x3c(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x34(%rbp),%xmm0
mulss  -0x38(%rbp),%xmm0
mulss  -0x30(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x38(%rbp),%xmm0
mulss  -0x3c(%rbp),%xmm0
mulss  -0x30(%rbp),%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x3c(%rbp),%xmm0
mulss  -0x34(%rbp),%xmm0
mulss  -0x30(%rbp),%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x20(%rbp),%xmm0
mulss  -0x34(%rbp),%xmm0
movss  %xmm0,-0x34(%rbp)
movss  -0x20(%rbp),%xmm0
mulss  -0x38(%rbp),%xmm0
movss  %xmm0,-0x38(%rbp)
movss  -0x20(%rbp),%xmm0
mulss  -0x3c(%rbp),%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  -0x40(%rbp),%xmm1
movss  -0x24(%rbp),%xmm0
movss  0xd3d(%rip),%xmm2
subss  -0x40(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x4c(%rbp),%xmm0
addss  -0x3c(%rbp),%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x54(%rbp),%xmm0
subss  -0x38(%rbp),%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x4c(%rbp),%xmm0
subss  -0x3c(%rbp),%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x44(%rbp),%xmm1
movss  -0x24(%rbp),%xmm0
movss  0xcec(%rip),%xmm2
subss  -0x44(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
movss  -0x50(%rbp),%xmm0
addss  -0x34(%rbp),%xmm0
movss  %xmm0,-0x6c(%rbp)
movss  -0x54(%rbp),%xmm0
addss  -0x38(%rbp),%xmm0
movss  %xmm0,-0x70(%rbp)
movss  -0x50(%rbp),%xmm0
subss  -0x34(%rbp),%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x48(%rbp),%xmm1
movss  -0x24(%rbp),%xmm0
movss  0xc9b(%rip),%xmm2
subss  -0x48(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x78(%rbp)
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x7c(%rbp)
mov    -0x8(%rbp),%rax
movss  0x10(%rax),%xmm0
movss  %xmm0,-0x80(%rbp)
mov    -0x8(%rbp),%rax
movss  0x20(%rax),%xmm0
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x7c(%rbp),%xmm1
movss  -0x58(%rbp),%xmm2
movss  -0x80(%rbp),%xmm0
mulss  -0x5c(%rbp),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x84(%rbp),%xmm0
ff
movss  -0x60(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x7c(%rbp),%xmm1
movss  -0x64(%rbp),%xmm2
movss  -0x80(%rbp),%xmm0
mulss  -0x68(%rbp),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x84(%rbp),%xmm0
ff
movss  -0x6c(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x10(%rax)
movss  -0x7c(%rbp),%xmm1
movss  -0x70(%rbp),%xmm2
movss  -0x80(%rbp),%xmm0
mulss  -0x74(%rbp),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x84(%rbp),%xmm0
ff
movss  -0x78(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x20(%rax)
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x7c(%rbp)
mov    -0x8(%rbp),%rax
movss  0x14(%rax),%xmm0
movss  %xmm0,-0x80(%rbp)
mov    -0x8(%rbp),%rax
movss  0x24(%rax),%xmm0
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x7c(%rbp),%xmm1
movss  -0x58(%rbp),%xmm2
movss  -0x80(%rbp),%xmm0
mulss  -0x5c(%rbp),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x84(%rbp),%xmm0
ff
movss  -0x60(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x7c(%rbp),%xmm1
movss  -0x64(%rbp),%xmm2
movss  -0x80(%rbp),%xmm0
mulss  -0x68(%rbp),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x84(%rbp),%xmm0
ff
movss  -0x6c(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x14(%rax)
movss  -0x7c(%rbp),%xmm1
movss  -0x70(%rbp),%xmm2
movss  -0x80(%rbp),%xmm0
mulss  -0x74(%rbp),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x84(%rbp),%xmm0
ff
movss  -0x78(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x24(%rax)
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x7c(%rbp)
mov    -0x8(%rbp),%rax
movss  0x18(%rax),%xmm0
movss  %xmm0,-0x80(%rbp)
mov    -0x8(%rbp),%rax
movss  0x28(%rax),%xmm0
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x7c(%rbp),%xmm1
movss  -0x58(%rbp),%xmm2
movss  -0x80(%rbp),%xmm0
mulss  -0x5c(%rbp),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x84(%rbp),%xmm0
ff
movss  -0x60(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x8(%rax)
movss  -0x7c(%rbp),%xmm1
movss  -0x64(%rbp),%xmm2
movss  -0x80(%rbp),%xmm0
mulss  -0x68(%rbp),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x84(%rbp),%xmm0
ff
movss  -0x6c(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x18(%rax)
movss  -0x7c(%rbp),%xmm1
movss  -0x70(%rbp),%xmm2
movss  -0x80(%rbp),%xmm0
mulss  -0x74(%rbp),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x84(%rbp),%xmm0
ff
movss  -0x78(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x28(%rax)
mov    -0x8(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  %xmm0,-0x7c(%rbp)
mov    -0x8(%rbp),%rax
movss  0x1c(%rax),%xmm0
movss  %xmm0,-0x80(%rbp)
mov    -0x8(%rbp),%rax
movss  0x2c(%rax),%xmm0
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x7c(%rbp),%xmm1
movss  -0x58(%rbp),%xmm2
movss  -0x80(%rbp),%xmm0
mulss  -0x5c(%rbp),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x84(%rbp),%xmm0
ff
movss  -0x60(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0xc(%rax)
movss  -0x7c(%rbp),%xmm1
movss  -0x64(%rbp),%xmm2
movss  -0x80(%rbp),%xmm0
mulss  -0x68(%rbp),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x84(%rbp),%xmm0
ff
movss  -0x6c(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x1c(%rax)
movss  -0x7c(%rbp),%xmm1
movss  -0x70(%rbp),%xmm2
movss  -0x80(%rbp),%xmm0
mulss  -0x74(%rbp),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x84(%rbp),%xmm0
ff
movss  -0x78(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x2c(%rax)
mov    -0x8(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,0x38(%rax)
mov    -0x8(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,0x34(%rax)
mov    -0x8(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,0x30(%rax)
mov    -0x8(%rbp),%rax
movss  0x8ef(%rip),%xmm0
movss  %xmm0,0x3c(%rax)
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<mtxLoadRotate>:
push   %rbx
sub    $0x20,%rsp
movss  %xmm3,0x4(%rsp)
movaps %xmm2,0x10(%rsp)
movss  %xmm1,0x8(%rsp)
mov    %rdi,%rbx
mov    0x2e98(%rip),%rax
mulss  (%rax),%xmm0
divss  0xea4(%rip),%xmm0
movss  %xmm0,(%rsp)
call   1030 <sinf@plt>
movss  %xmm0,0xc(%rsp)
movss  (%rsp),%xmm0
call   1040 <cosf@plt>
movaps %xmm0,%xmm13
movaps 0x10(%rsp),%xmm0
mulss  %xmm0,%xmm0
movss  0x8(%rsp),%xmm1
mulss  %xmm1,%xmm1
addss  %xmm0,%xmm1
movss  0x4(%rsp),%xmm0
mulss  %xmm0,%xmm0
addss  %xmm1,%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jb     11ad <mtxLoadRotate+0x7d>
sqrtss %xmm0,%xmm0
jmp    11be <mtxLoadRotate+0x8e>
movss  %xmm13,(%rsp)
call   1050 <sqrtf@plt>
movss  (%rsp),%xmm13
movss  0xe3d(%rip),%xmm11
movaps %xmm11,%xmm5
divss  %xmm0,%xmm5
movaps %xmm11,%xmm0
subss  %xmm13,%xmm0
movss  0x8(%rsp),%xmm12
mulss  %xmm5,%xmm12
movaps 0x10(%rsp),%xmm1
mulss  %xmm5,%xmm1
mulss  0x4(%rsp),%xmm5
movaps %xmm12,%xmm3
mulss  %xmm12,%xmm3
movaps %xmm1,%xmm9
mulss  %xmm1,%xmm9
movaps %xmm5,%xmm8
mulss  %xmm5,%xmm8
movaps %xmm12,%xmm2
mulss  %xmm1,%xmm2
mulss  %xmm0,%xmm2
movss  0xc(%rsp),%xmm4
movaps %xmm4,%xmm10
mulss  %xmm1,%xmm10
mulss  %xmm5,%xmm1
mulss  %xmm0,%xmm1
movaps %xmm5,%xmm7
mulss  %xmm12,%xmm7
mulss  %xmm0,%xmm7
mulss  %xmm4,%xmm12
mulss  %xmm4,%xmm5
movaps %xmm11,%xmm4
subss  %xmm3,%xmm4
mulss  %xmm13,%xmm4
addss  %xmm3,%xmm4
movaps %xmm5,%xmm3
addss  %xmm2,%xmm3
movaps %xmm7,%xmm0
subss  %xmm10,%xmm0
subss  %xmm5,%xmm2
movaps %xmm11,%xmm6
subss  %xmm9,%xmm6
mulss  %xmm13,%xmm6
addss  %xmm9,%xmm6
movaps %xmm12,%xmm5
addss  %xmm1,%xmm5
addss  %xmm10,%xmm7
subss  %xmm12,%xmm1
subss  %xmm8,%xmm11
mulss  %xmm13,%xmm11
addss  %xmm8,%xmm11
movups (%rbx),%xmm9
movups 0x10(%rbx),%xmm10
movups 0x20(%rbx),%xmm8
shufps $0x0,%xmm3,%xmm3
mulps  %xmm10,%xmm3
shufps $0x0,%xmm4,%xmm4
mulps  %xmm9,%xmm4
addps  %xmm3,%xmm4
shufps $0x0,%xmm0,%xmm0
mulps  %xmm8,%xmm0
addps  %xmm4,%xmm0
movups %xmm0,(%rbx)
shufps $0x0,%xmm6,%xmm6
mulps  %xmm10,%xmm6
shufps $0x0,%xmm2,%xmm2
mulps  %xmm9,%xmm2
addps  %xmm6,%xmm2
shufps $0x0,%xmm5,%xmm5
mulps  %xmm8,%xmm5
addps  %xmm2,%xmm5
movups %xmm5,0x10(%rbx)
shufps $0x0,%xmm1,%xmm1
mulps  %xmm10,%xmm1
shufps $0x0,%xmm7,%xmm7
mulps  %xmm9,%xmm7
addps  %xmm1,%xmm7
shufps $0x0,%xmm11,%xmm11
mulps  %xmm8,%xmm11
addps  %xmm7,%xmm11
movups %xmm11,0x20(%rbx)
movaps 0xcf5(%rip),%xmm0
movups %xmm0,0x30(%rbx)
add    $0x20,%rsp
pop    %rbx
ret

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

LLVM IR (-O2):
@M_PI = global float 0.000000e+00
define void @mtxLoadRotate(float* nocapture %0, float %1, float %2, float %3, float %4) {
%6 = load float, float* @M_PI
%7 = fmul float %6, %1
%8 = fdiv float %7, 1.800000e+02
%9 = tail call float @sinf(float %8)
%10 = tail call float @cosf(float %8)
%11 = fmul float %3, %3
%12 = tail call float @llvm.fmuladd.f32(float %2, float %2, float %11)
%13 = tail call float @llvm.fmuladd.f32(float %4, float %4, float %12)
%14 = tail call float @sqrtf(float %13)
%15 = fdiv float 1.000000e+00, %14
%16 = fsub float 1.000000e+00, %10
%17 = fmul float %15, %2
%18 = fmul float %15, %3
%19 = fmul float %15, %4
%20 = fmul float %17, %17
%21 = fmul float %18, %18
%22 = fmul float %19, %19
%23 = fmul float %17, %18
%24 = fmul float %16, %23
%25 = fmul float %18, %19
%26 = fmul float %16, %25
%27 = fmul float %19, %17
%28 = fmul float %16, %27
%29 = fmul float %9, %17
%30 = fmul float %9, %18
%31 = fmul float %9, %19
%32 = fsub float 1.000000e+00, %20
%33 = tail call float @llvm.fmuladd.f32(float %10, float %32, float %20)
%34 = fadd float %31, %24
%35 = fsub float %28, %30
%36 = fsub float %24, %31
%37 = fsub float 1.000000e+00, %21
%38 = tail call float @llvm.fmuladd.f32(float %10, float %37, float %21)
%39 = fadd float %29, %26
%40 = fadd float %30, %28
%41 = fsub float %26, %29
%42 = fsub float 1.000000e+00, %22
%43 = tail call float @llvm.fmuladd.f32(float %10, float %42, float %22)
%44 = getelementptr inbounds float, float* %0, i64 4
%45 = getelementptr inbounds float, float* %0, i64 8
%46 = bitcast float* %44 to <4 x float>*
%47 = load <4 x float>, <4 x float>* %46
%48 = bitcast float* %0 to <4 x float>*
%49 = load <4 x float>, <4 x float>* %48
%50 = bitcast float* %45 to <4 x float>*
%51 = load <4 x float>, <4 x float>* %50
%52 = insertelement <4 x float> poison, float %34, i64 0
%53 = shufflevector <4 x float> %52, <4 x float> poison, <4 x i32> zeroinitializer
%54 = fmul <4 x float> %47, %53
%55 = insertelement <4 x float> poison, float %33, i64 0
%56 = shufflevector <4 x float> %55, <4 x float> poison, <4 x i32> zeroinitializer
%57 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %49, <4 x float> %56, <4 x float> %54)
%58 = insertelement <4 x float> poison, float %35, i64 0
%59 = shufflevector <4 x float> %58, <4 x float> poison, <4 x i32> zeroinitializer
%60 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %51, <4 x float> %59, <4 x float> %57)
%61 = bitcast float* %0 to <4 x float>*
store <4 x float> %60, <4 x float>* %61
%62 = insertelement <4 x float> poison, float %38, i64 0
%63 = shufflevector <4 x float> %62, <4 x float> poison, <4 x i32> zeroinitializer
%64 = fmul <4 x float> %47, %63
%65 = insertelement <4 x float> poison, float %36, i64 0
%66 = shufflevector <4 x float> %65, <4 x float> poison, <4 x i32> zeroinitializer
%67 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %49, <4 x float> %66, <4 x float> %64)
%68 = insertelement <4 x float> poison, float %39, i64 0
%69 = shufflevector <4 x float> %68, <4 x float> poison, <4 x i32> zeroinitializer
%70 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %51, <4 x float> %69, <4 x float> %67)
%71 = bitcast float* %44 to <4 x float>*
store <4 x float> %70, <4 x float>* %71
%72 = insertelement <4 x float> poison, float %41, i64 0
%73 = shufflevector <4 x float> %72, <4 x float> poison, <4 x i32> zeroinitializer
%74 = fmul <4 x float> %47, %73
%75 = insertelement <4 x float> poison, float %40, i64 0
%76 = shufflevector <4 x float> %75, <4 x float> poison, <4 x i32> zeroinitializer
%77 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %49, <4 x float> %76, <4 x float> %74)
%78 = insertelement <4 x float> poison, float %43, i64 0
%79 = shufflevector <4 x float> %78, <4 x float> poison, <4 x i32> zeroinitializer
%80 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %51, <4 x float> %79, <4 x float> %77)
%81 = bitcast float* %45 to <4 x float>*
store <4 x float> %80, <4 x float>* %81
%82 = getelementptr inbounds float, float* %0, i64 12
%83 = bitcast float* %82 to <4 x float>*
store <4 x float> <float 0.000000e+00, float 0.000000e+00, float 0.000000e+00, float 1.000000e+00>, <4 x float>* %83
ret void
}