#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 */
scalar_t__ cos(double);
scalar_t__ sin(double);
int /*<<< orphan*/ v_nrm(float *, float const *);
void m_rot(float *M, const float *v, float a) {
  float u[3];
  float U[16];
  float S[16];
  const float s = ((float)sin((double)a));
  const float c = ((float)cos((double)a));
  v_nrm(u, v);
  U[0] = u[0] * u[0];
  U[4] = u[0] * u[1];
  U[8] = u[0] * u[2];
  U[1] = u[1] * u[0];
  U[5] = u[1] * u[1];
  U[9] = u[1] * u[2];
  U[2] = u[2] * u[0];
  U[6] = u[2] * u[1];
  U[10] = u[2] * u[2];
  S[0] = 0.f;
  S[4] = -u[2];
  S[8] = u[1];
  S[1] = u[2];
  S[5] = 0.f;
  S[9] = -u[0];
  S[2] = -u[1];
  S[6] = u[0];
  S[10] = 0.f;
  M[0] = U[0] + c * (1.f - U[0]) + s * S[0];
  M[1] = U[1] + c * (0.f - U[1]) + s * S[1];
  M[2] = U[2] + c * (0.f - U[2]) + s * S[2];
  M[3] = 0.f;
  M[4] = U[4] + c * (0.f - U[4]) + s * S[4];
  M[5] = U[5] + c * (1.f - U[5]) + s * S[5];
  M[6] = U[6] + c * (0.f - U[6]) + s * S[6];
  M[7] = 0.f;
  M[8] = U[8] + c * (0.f - U[8]) + s * S[8];
  M[9] = U[9] + c * (0.f - U[9]) + s * S[9];
  M[10] = U[10] + c * (1.f - U[10]) + s * S[10];
  M[11] = 0.f;
  M[12] = 0.f;
  M[13] = 0.f;
  M[14] = 0.f;
  M[15] = 1.f;
}


x86 assembly (clang, -O0):
<m_rot>:
push   %rbp
mov    %rsp,%rbp
sub    $0xb0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movss  %xmm0,-0x14(%rbp)
movss  -0x14(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
call   1040 <sin@plt>
cvtsi2ss %rax,%xmm0
movss  %xmm0,-0xa4(%rbp)
ff
movss  -0x14(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
call   1050 <cos@plt>
cvtsi2ss %rax,%xmm0
movss  %xmm0,-0xa8(%rbp)
ff
lea    -0x20(%rbp),%rdi
mov    -0x10(%rbp),%rsi
call   1030 <v_nrm@plt>
movss  -0x20(%rbp),%xmm0
mulss  -0x20(%rbp),%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x20(%rbp),%xmm0
mulss  -0x1c(%rbp),%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x20(%rbp),%xmm0
mulss  -0x18(%rbp),%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x1c(%rbp),%xmm0
mulss  -0x20(%rbp),%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x1c(%rbp),%xmm0
mulss  -0x1c(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x1c(%rbp),%xmm0
mulss  -0x18(%rbp),%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  -0x18(%rbp),%xmm0
mulss  -0x20(%rbp),%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x18(%rbp),%xmm0
mulss  -0x1c(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x18(%rbp),%xmm0
mulss  -0x18(%rbp),%xmm0
movss  %xmm0,-0x38(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0xa0(%rbp)
ff
movss  -0x18(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x90(%rbp)
ff
movss  -0x1c(%rbp),%xmm0
movss  %xmm0,-0x80(%rbp)
movss  -0x18(%rbp),%xmm0
movss  %xmm0,-0x9c(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
movss  -0x20(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x7c(%rbp)
movss  -0x1c(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x98(%rbp)
ff
movss  -0x20(%rbp),%xmm0
movss  %xmm0,-0x88(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0x78(%rbp)
movss  -0x60(%rbp),%xmm0
movss  -0xa8(%rbp),%xmm1
ff
movss  0xd4c(%rip),%xmm2
subss  -0x60(%rbp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0xa4(%rbp),%xmm0
ff
movss  -0xa0(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x5c(%rbp),%xmm0
movss  -0xa8(%rbp),%xmm1
ff
xorps  %xmm2,%xmm2
subss  -0x5c(%rbp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0xa4(%rbp),%xmm0
ff
movss  -0x9c(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x58(%rbp),%xmm0
movss  -0xa8(%rbp),%xmm1
ff
xorps  %xmm2,%xmm2
subss  -0x58(%rbp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0xa4(%rbp),%xmm0
ff
movss  -0x98(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x8(%rax)
mov    -0x8(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,0xc(%rax)
movss  -0x50(%rbp),%xmm0
movss  -0xa8(%rbp),%xmm1
ff
xorps  %xmm2,%xmm2
subss  -0x50(%rbp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0xa4(%rbp),%xmm0
ff
movss  -0x90(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x10(%rax)
movss  -0x4c(%rbp),%xmm0
movss  -0xa8(%rbp),%xmm1
ff
movss  0xc44(%rip),%xmm2
subss  -0x4c(%rbp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0xa4(%rbp),%xmm0
ff
movss  -0x8c(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x14(%rax)
movss  -0x48(%rbp),%xmm0
movss  -0xa8(%rbp),%xmm1
ff
xorps  %xmm2,%xmm2
subss  -0x48(%rbp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0xa4(%rbp),%xmm0
ff
movss  -0x88(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x18(%rax)
mov    -0x8(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,0x1c(%rax)
movss  -0x40(%rbp),%xmm0
movss  -0xa8(%rbp),%xmm1
ff
xorps  %xmm2,%xmm2
subss  -0x40(%rbp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0xa4(%rbp),%xmm0
ff
movss  -0x80(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x20(%rax)
movss  -0x3c(%rbp),%xmm0
movss  -0xa8(%rbp),%xmm1
ff
xorps  %xmm2,%xmm2
subss  -0x3c(%rbp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0xa4(%rbp),%xmm0
ff
movss  -0x7c(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x24(%rax)
movss  -0x38(%rbp),%xmm0
movss  -0xa8(%rbp),%xmm1
ff
movss  0xb41(%rip),%xmm2
subss  -0x38(%rbp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0xa4(%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
xorps  %xmm0,%xmm0
movss  %xmm0,0x2c(%rax)
mov    -0x8(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,0x30(%rax)
mov    -0x8(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,0x34(%rax)
mov    -0x8(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,0x38(%rax)
mov    -0x8(%rbp),%rax
movss  0xada(%rip),%xmm0
movss  %xmm0,0x3c(%rax)
add    $0xb0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<m_rot>:
push   %r14
push   %rbx
sub    $0x18,%rsp
mov    %rsi,%r14
mov    %rdi,%rbx
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,(%rsp)
call   1040 <sin@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
movss  %xmm0,0x8(%rsp)
movsd  (%rsp),%xmm0
call   1050 <cos@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
movss  %xmm0,(%rsp)
lea    0xc(%rsp),%rdi
mov    %r14,%rsi
call   1030 <v_nrm@plt>
movss  0xc(%rsp),%xmm7
movss  0x10(%rsp),%xmm0
movaps %xmm7,%xmm1
mulss  %xmm0,%xmm1
movss  0x14(%rsp),%xmm3
movaps %xmm7,%xmm6
mulss  %xmm3,%xmm6
movaps %xmm0,%xmm10
movaps %xmm0,%xmm9
mulss  %xmm3,%xmm9
movaps %xmm3,%xmm8
movss  0x8(%rsp),%xmm5
movaps %xmm5,%xmm11
mulss  %xmm5,%xmm3
movaps %xmm5,%xmm12
mulss  %xmm5,%xmm0
mulss  %xmm7,%xmm12
mulss  %xmm7,%xmm7
mulss  %xmm10,%xmm10
mulss  %xmm8,%xmm8
movss  0xe21(%rip),%xmm4
movaps %xmm4,%xmm2
subss  %xmm7,%xmm2
movss  (%rsp),%xmm5
mulss  %xmm5,%xmm2
addss  %xmm7,%xmm2
xorps  %xmm7,%xmm7
mulss  %xmm7,%xmm11
addss  %xmm11,%xmm2
movss  %xmm2,(%rbx)
xorps  %xmm2,%xmm2
subss  %xmm1,%xmm2
mulss  %xmm5,%xmm2
addss  %xmm1,%xmm2
movaps %xmm3,%xmm1
addss  %xmm2,%xmm1
movss  %xmm1,0x4(%rbx)
xorps  %xmm1,%xmm1
subss  %xmm6,%xmm1
mulss  %xmm5,%xmm1
addss  %xmm6,%xmm1
movaps %xmm1,%xmm6
subss  %xmm0,%xmm6
movss  %xmm6,0x8(%rbx)
movl   $0x0,0xc(%rbx)
subss  %xmm3,%xmm2
movss  %xmm2,0x10(%rbx)
movaps %xmm4,%xmm2
subss  %xmm10,%xmm2
mulss  %xmm5,%xmm2
addss  %xmm10,%xmm2
addss  %xmm11,%xmm2
movss  %xmm2,0x14(%rbx)
subss  %xmm9,%xmm7
mulss  %xmm5,%xmm7
addss  %xmm9,%xmm7
movaps %xmm12,%xmm2
addss  %xmm7,%xmm2
movss  %xmm2,0x18(%rbx)
movl   $0x0,0x1c(%rbx)
addss  %xmm1,%xmm0
movss  %xmm0,0x20(%rbx)
subss  %xmm12,%xmm7
movss  %xmm7,0x24(%rbx)
subss  %xmm8,%xmm4
mulss  %xmm5,%xmm4
addss  %xmm8,%xmm4
addss  %xmm11,%xmm4
movss  %xmm4,0x28(%rbx)
xorps  %xmm0,%xmm0
movups %xmm0,0x2c(%rbx)
movl   $0x3f800000,0x3c(%rbx)
add    $0x18,%rsp
pop    %rbx
pop    %r14
ret

LLVM IR (-O0):
define void @m_rot(float* %0, float* %1, float %2) {
%4 = alloca float*
%5 = alloca float*
%6 = alloca float
%7 = alloca [3 x float]
%8 = alloca [16 x float]
%9 = alloca [16 x float]
%10 = alloca float
%11 = alloca float
store float* %0, float** %4
store float* %1, float** %5
store float %2, float* %6
%12 = load float, float* %6
%13 = fpext float %12 to double
%14 = call i64 @sin(double %13)
%15 = sitofp i64 %14 to float
store float %15, float* %10
%16 = load float, float* %6
%17 = fpext float %16 to double
%18 = call i64 @cos(double %17)
%19 = sitofp i64 %18 to float
store float %19, float* %11
%20 = getelementptr inbounds [3 x float], [3 x float]* %7, i64 0, i64 0
%21 = load float*, float** %5
%22 = call i32 @v_nrm(float* %20, float* %21)
%23 = getelementptr inbounds [3 x float], [3 x float]* %7, i64 0, i64 0
%24 = load float, float* %23
%25 = getelementptr inbounds [3 x float], [3 x float]* %7, i64 0, i64 0
%26 = load float, float* %25
%27 = fmul float %24, %26
%28 = getelementptr inbounds [16 x float], [16 x float]* %8, i64 0, i64 0
store float %27, float* %28
%29 = getelementptr inbounds [3 x float], [3 x float]* %7, i64 0, i64 0
%30 = load float, float* %29
%31 = getelementptr inbounds [3 x float], [3 x float]* %7, i64 0, i64 1
%32 = load float, float* %31
%33 = fmul float %30, %32
%34 = getelementptr inbounds [16 x float], [16 x float]* %8, i64 0, i64 4
store float %33, float* %34
%35 = getelementptr inbounds [3 x float], [3 x float]* %7, i64 0, i64 0
%36 = load float, float* %35
%37 = getelementptr inbounds [3 x float], [3 x float]* %7, i64 0, i64 2
%38 = load float, float* %37
%39 = fmul float %36, %38
%40 = getelementptr inbounds [16 x float], [16 x float]* %8, i64 0, i64 8
store float %39, float* %40
%41 = getelementptr inbounds [3 x float], [3 x float]* %7, i64 0, i64 1
%42 = load float, float* %41
%43 = getelementptr inbounds [3 x float], [3 x float]* %7, i64 0, i64 0
%44 = load float, float* %43
%45 = fmul float %42, %44
%46 = getelementptr inbounds [16 x float], [16 x float]* %8, i64 0, i64 1
store float %45, float* %46
%47 = getelementptr inbounds [3 x float], [3 x float]* %7, i64 0, i64 1
%48 = load float, float* %47
%49 = getelementptr inbounds [3 x float], [3 x float]* %7, i64 0, i64 1
%50 = load float, float* %49
%51 = fmul float %48, %50
%52 = getelementptr inbounds [16 x float], [16 x float]* %8, i64 0, i64 5
store float %51, float* %52
%53 = getelementptr inbounds [3 x float], [3 x float]* %7, i64 0, i64 1
%54 = load float, float* %53
%55 = getelementptr inbounds [3 x float], [3 x float]* %7, i64 0, i64 2
%56 = load float, float* %55
%57 = fmul float %54, %56
%58 = getelementptr inbounds [16 x float], [16 x float]* %8, i64 0, i64 9
store float %57, float* %58
%59 = getelementptr inbounds [3 x float], [3 x float]* %7, i64 0, i64 2
%60 = load float, float* %59
%61 = getelementptr inbounds [3 x float], [3 x float]* %7, i64 0, i64 0
%62 = load float, float* %61
%63 = fmul float %60, %62
%64 = getelementptr inbounds [16 x float], [16 x float]* %8, i64 0, i64 2
store float %63, float* %64
%65 = getelementptr inbounds [3 x float], [3 x float]* %7, i64 0, i64 2
%66 = load float, float* %65
%67 = getelementptr inbounds [3 x float], [3 x float]* %7, i64 0, i64 1
%68 = load float, float* %67
%69 = fmul float %66, %68
%70 = getelementptr inbounds [16 x float], [16 x float]* %8, i64 0, i64 6
store float %69, float* %70
%71 = getelementptr inbounds [3 x float], [3 x float]* %7, i64 0, i64 2
%72 = load float, float* %71
%73 = getelementptr inbounds [3 x float], [3 x float]* %7, i64 0, i64 2
%74 = load float, float* %73
%75 = fmul float %72, %74
%76 = getelementptr inbounds [16 x float], [16 x float]* %8, i64 0, i64 10
store float %75, float* %76
%77 = getelementptr inbounds [16 x float], [16 x float]* %9, i64 0, i64 0
store float 0.000000e+00, float* %77
%78 = getelementptr inbounds [3 x float], [3 x float]* %7, i64 0, i64 2
%79 = load float, float* %78
%80 = fneg float %79
%81 = getelementptr inbounds [16 x float], [16 x float]* %9, i64 0, i64 4
store float %80, float* %81
%82 = getelementptr inbounds [3 x float], [3 x float]* %7, i64 0, i64 1
%83 = load float, float* %82
%84 = getelementptr inbounds [16 x float], [16 x float]* %9, i64 0, i64 8
store float %83, float* %84
%85 = getelementptr inbounds [3 x float], [3 x float]* %7, i64 0, i64 2
%86 = load float, float* %85
%87 = getelementptr inbounds [16 x float], [16 x float]* %9, i64 0, i64 1
store float %86, float* %87
%88 = getelementptr inbounds [16 x float], [16 x float]* %9, i64 0, i64 5
store float 0.000000e+00, float* %88
%89 = getelementptr inbounds [3 x float], [3 x float]* %7, i64 0, i64 0
%90 = load float, float* %89
%91 = fneg float %90
%92 = getelementptr inbounds [16 x float], [16 x float]* %9, i64 0, i64 9
store float %91, float* %92
%93 = getelementptr inbounds [3 x float], [3 x float]* %7, i64 0, i64 1
%94 = load float, float* %93
%95 = fneg float %94
%96 = getelementptr inbounds [16 x float], [16 x float]* %9, i64 0, i64 2
store float %95, float* %96
%97 = getelementptr inbounds [3 x float], [3 x float]* %7, i64 0, i64 0
%98 = load float, float* %97
%99 = getelementptr inbounds [16 x float], [16 x float]* %9, i64 0, i64 6
store float %98, float* %99
%100 = getelementptr inbounds [16 x float], [16 x float]* %9, i64 0, i64 10
store float 0.000000e+00, float* %100
%101 = getelementptr inbounds [16 x float], [16 x float]* %8, i64 0, i64 0
%102 = load float, float* %101
%103 = load float, float* %11
%104 = getelementptr inbounds [16 x float], [16 x float]* %8, i64 0, i64 0
%105 = load float, float* %104
%106 = fsub float 1.000000e+00, %105
%107 = call float @llvm.fmuladd.f32(float %103, float %106, float %102)
%108 = load float, float* %10
%109 = getelementptr inbounds [16 x float], [16 x float]* %9, i64 0, i64 0
%110 = load float, float* %109
%111 = call float @llvm.fmuladd.f32(float %108, float %110, float %107)
%112 = load float*, float** %4
%113 = getelementptr inbounds float, float* %112, i64 0
store float %111, float* %113
%114 = getelementptr inbounds [16 x float], [16 x float]* %8, i64 0, i64 1
%115 = load float, float* %114
%116 = load float, float* %11
%117 = getelementptr inbounds [16 x float], [16 x float]* %8, i64 0, i64 1
%118 = load float, float* %117
%119 = fsub float 0.000000e+00, %118
%120 = call float @llvm.fmuladd.f32(float %116, float %119, float %115)
%121 = load float, float* %10
%122 = getelementptr inbounds [16 x float], [16 x float]* %9, i64 0, i64 1
%123 = load float, float* %122
%124 = call float @llvm.fmuladd.f32(float %121, float %123, float %120)
%125 = load float*, float** %4
%126 = getelementptr inbounds float, float* %125, i64 1
store float %124, float* %126
%127 = getelementptr inbounds [16 x float], [16 x float]* %8, i64 0, i64 2
%128 = load float, float* %127
%129 = load float, float* %11
%130 = getelementptr inbounds [16 x float], [16 x float]* %8, i64 0, i64 2
%131 = load float, float* %130
%132 = fsub float 0.000000e+00, %131
%133 = call float @llvm.fmuladd.f32(float %129, float %132, float %128)
%134 = load float, float* %10
%135 = getelementptr inbounds [16 x float], [16 x float]* %9, i64 0, i64 2
%136 = load float, float* %135
%137 = call float @llvm.fmuladd.f32(float %134, float %136, float %133)
%138 = load float*, float** %4
%139 = getelementptr inbounds float, float* %138, i64 2
store float %137, float* %139
%140 = load float*, float** %4
%141 = getelementptr inbounds float, float* %140, i64 3
store float 0.000000e+00, float* %141
%142 = getelementptr inbounds [16 x float], [16 x float]* %8, i64 0, i64 4
%143 = load float, float* %142
%144 = load float, float* %11
%145 = getelementptr inbounds [16 x float], [16 x float]* %8, i64 0, i64 4
%146 = load float, float* %145
%147 = fsub float 0.000000e+00, %146
%148 = call float @llvm.fmuladd.f32(float %144, float %147, float %143)
%149 = load float, float* %10
%150 = getelementptr inbounds [16 x float], [16 x float]* %9, i64 0, i64 4
%151 = load float, float* %150
%152 = call float @llvm.fmuladd.f32(float %149, float %151, float %148)
%153 = load float*, float** %4
%154 = getelementptr inbounds float, float* %153, i64 4
store float %152, float* %154
%155 = getelementptr inbounds [16 x float], [16 x float]* %8, i64 0, i64 5
%156 = load float, float* %155
%157 = load float, float* %11
%158 = getelementptr inbounds [16 x float], [16 x float]* %8, i64 0, i64 5
%159 = load float, float* %158
%160 = fsub float 1.000000e+00, %159
%161 = call float @llvm.fmuladd.f32(float %157, float %160, float %156)
%162 = load float, float* %10
%163 = getelementptr inbounds [16 x float], [16 x float]* %9, i64 0, i64 5
%164 = load float, float* %163
%165 = call float @llvm.fmuladd.f32(float %162, float %164, float %161)
%166 = load float*, float** %4
%167 = getelementptr inbounds float, float* %166, i64 5
store float %165, float* %167
%168 = getelementptr inbounds [16 x float], [16 x float]* %8, i64 0, i64 6
%169 = load float, float* %168
%170 = load float, float* %11
%171 = getelementptr inbounds [16 x float], [16 x float]* %8, i64 0, i64 6
%172 = load float, float* %171
%173 = fsub float 0.000000e+00, %172
%174 = call float @llvm.fmuladd.f32(float %170, float %173, float %169)
%175 = load float, float* %10
%176 = getelementptr inbounds [16 x float], [16 x float]* %9, i64 0, i64 6
%177 = load float, float* %176
%178 = call float @llvm.fmuladd.f32(float %175, float %177, float %174)
%179 = load float*, float** %4
%180 = getelementptr inbounds float, float* %179, i64 6
store float %178, float* %180
%181 = load float*, float** %4
%182 = getelementptr inbounds float, float* %181, i64 7
store float 0.000000e+00, float* %182
%183 = getelementptr inbounds [16 x float], [16 x float]* %8, i64 0, i64 8
%184 = load float, float* %183
%185 = load float, float* %11
%186 = getelementptr inbounds [16 x float], [16 x float]* %8, i64 0, i64 8
%187 = load float, float* %186
%188 = fsub float 0.000000e+00, %187
%189 = call float @llvm.fmuladd.f32(float %185, float %188, float %184)
%190 = load float, float* %10
%191 = getelementptr inbounds [16 x float], [16 x float]* %9, i64 0, i64 8
%192 = load float, float* %191
%193 = call float @llvm.fmuladd.f32(float %190, float %192, float %189)
%194 = load float*, float** %4
%195 = getelementptr inbounds float, float* %194, i64 8
store float %193, float* %195
%196 = getelementptr inbounds [16 x float], [16 x float]* %8, i64 0, i64 9
%197 = load float, float* %196
%198 = load float, float* %11
%199 = getelementptr inbounds [16 x float], [16 x float]* %8, i64 0, i64 9
%200 = load float, float* %199
%201 = fsub float 0.000000e+00, %200
%202 = call float @llvm.fmuladd.f32(float %198, float %201, float %197)
%203 = load float, float* %10
%204 = getelementptr inbounds [16 x float], [16 x float]* %9, i64 0, i64 9
%205 = load float, float* %204
%206 = call float @llvm.fmuladd.f32(float %203, float %205, float %202)
%207 = load float*, float** %4
%208 = getelementptr inbounds float, float* %207, i64 9
store float %206, float* %208
%209 = getelementptr inbounds [16 x float], [16 x float]* %8, i64 0, i64 10
%210 = load float, float* %209
%211 = load float, float* %11
%212 = getelementptr inbounds [16 x float], [16 x float]* %8, i64 0, i64 10
%213 = load float, float* %212
%214 = fsub float 1.000000e+00, %213
%215 = call float @llvm.fmuladd.f32(float %211, float %214, float %210)
%216 = load float, float* %10
%217 = getelementptr inbounds [16 x float], [16 x float]* %9, i64 0, i64 10
%218 = load float, float* %217
%219 = call float @llvm.fmuladd.f32(float %216, float %218, float %215)
%220 = load float*, float** %4
%221 = getelementptr inbounds float, float* %220, i64 10
store float %219, float* %221
%222 = load float*, float** %4
%223 = getelementptr inbounds float, float* %222, i64 11
store float 0.000000e+00, float* %223
%224 = load float*, float** %4
%225 = getelementptr inbounds float, float* %224, i64 12
store float 0.000000e+00, float* %225
%226 = load float*, float** %4
%227 = getelementptr inbounds float, float* %226, i64 13
store float 0.000000e+00, float* %227
%228 = load float*, float** %4
%229 = getelementptr inbounds float, float* %228, i64 14
store float 0.000000e+00, float* %229
%230 = load float*, float** %4
%231 = getelementptr inbounds float, float* %230, i64 15
store float 1.000000e+00, float* %231
ret void
}

LLVM IR (-O2):
define void @m_rot(float* nocapture writeonly %0, float* %1, float %2) {
%4 = alloca [3 x float]
%5 = bitcast [3 x float]* %4 to i8*
%6 = fpext float %2 to double
%7 = tail call i64 @sin(double %6)
%8 = sitofp i64 %7 to float
%9 = tail call i64 @cos(double %6)
%10 = sitofp i64 %9 to float
%11 = getelementptr inbounds [3 x float], [3 x float]* %4, i64 0, i64 0
%12 = call i32 @v_nrm(float* %11, float* %1)
%13 = load float, float* %11
%14 = fmul float %13, %13
%15 = getelementptr inbounds [3 x float], [3 x float]* %4, i64 0, i64 1
%16 = load float, float* %15
%17 = fmul float %13, %16
%18 = getelementptr inbounds [3 x float], [3 x float]* %4, i64 0, i64 2
%19 = load float, float* %18
%20 = fmul float %13, %19
%21 = fmul float %16, %16
%22 = fmul float %16, %19
%23 = fmul float %19, %19
%24 = fneg float %19
%25 = fneg float %13
%26 = fneg float %16
%27 = fsub float 1.000000e+00, %14
%28 = call float @llvm.fmuladd.f32(float %10, float %27, float %14)
%29 = call float @llvm.fmuladd.f32(float %8, float 0.000000e+00, float %28)
store float %29, float* %0
%30 = fsub float 0.000000e+00, %17
%31 = call float @llvm.fmuladd.f32(float %10, float %30, float %17)
%32 = call float @llvm.fmuladd.f32(float %8, float %19, float %31)
%33 = getelementptr inbounds float, float* %0, i64 1
store float %32, float* %33
%34 = fsub float 0.000000e+00, %20
%35 = call float @llvm.fmuladd.f32(float %10, float %34, float %20)
%36 = call float @llvm.fmuladd.f32(float %8, float %26, float %35)
%37 = getelementptr inbounds float, float* %0, i64 2
store float %36, float* %37
%38 = getelementptr inbounds float, float* %0, i64 3
store float 0.000000e+00, float* %38
%39 = call float @llvm.fmuladd.f32(float %8, float %24, float %31)
%40 = getelementptr inbounds float, float* %0, i64 4
store float %39, float* %40
%41 = fsub float 1.000000e+00, %21
%42 = call float @llvm.fmuladd.f32(float %10, float %41, float %21)
%43 = call float @llvm.fmuladd.f32(float %8, float 0.000000e+00, float %42)
%44 = getelementptr inbounds float, float* %0, i64 5
store float %43, float* %44
%45 = fsub float 0.000000e+00, %22
%46 = call float @llvm.fmuladd.f32(float %10, float %45, float %22)
%47 = call float @llvm.fmuladd.f32(float %8, float %13, float %46)
%48 = getelementptr inbounds float, float* %0, i64 6
store float %47, float* %48
%49 = getelementptr inbounds float, float* %0, i64 7
store float 0.000000e+00, float* %49
%50 = call float @llvm.fmuladd.f32(float %8, float %16, float %35)
%51 = getelementptr inbounds float, float* %0, i64 8
store float %50, float* %51
%52 = call float @llvm.fmuladd.f32(float %8, float %25, float %46)
%53 = getelementptr inbounds float, float* %0, i64 9
store float %52, float* %53
%54 = fsub float 1.000000e+00, %23
%55 = call float @llvm.fmuladd.f32(float %10, float %54, float %23)
%56 = call float @llvm.fmuladd.f32(float %8, float 0.000000e+00, float %55)
%57 = getelementptr inbounds float, float* %0, i64 10
store float %56, float* %57
%58 = getelementptr inbounds float, float* %0, i64 11
%59 = getelementptr inbounds float, float* %0, i64 15
%60 = bitcast float* %58 to i8*
store float 1.000000e+00, float* %59
ret void
}