#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__ sincosf(float, float *, float *);
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];
  float s, c;
  ((void)sincosf((float)a, (float *)&s, (float *)&c));
  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
lea    -0xa4(%rbp),%rdi
lea    -0xa8(%rbp),%rsi
call   1040 <sincosf@plt>
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  0xd7a(%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  0xc72(%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  0xb6f(%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  0xb08(%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
lea    0x8(%rsp),%rdi
lea    0x4(%rsp),%rsi
call   1040 <sincosf@plt>
lea    0xc(%rsp),%rdi
mov    %r14,%rsi
call   1030 <v_nrm@plt>
movss  0xc(%rsp),%xmm6
movss  0x10(%rsp),%xmm0
movaps %xmm6,%xmm12
mulss  %xmm0,%xmm12
movss  0x14(%rsp),%xmm14
movaps %xmm6,%xmm11
mulss  %xmm14,%xmm11
movaps %xmm0,%xmm10
movaps %xmm0,%xmm9
mulss  %xmm14,%xmm9
movaps %xmm14,%xmm8
movss  0x8(%rsp),%xmm7
movaps %xmm7,%xmm13
mulss  %xmm7,%xmm14
mulss  %xmm7,%xmm0
mulss  %xmm6,%xmm7
mulss  %xmm6,%xmm6
mulss  %xmm10,%xmm10
mulss  %xmm8,%xmm8
movss  0x4(%rsp),%xmm4
movss  0xe4e(%rip),%xmm2
movaps %xmm2,%xmm5
subss  %xmm6,%xmm5
mulss  %xmm4,%xmm5
addss  %xmm6,%xmm5
xorps  %xmm6,%xmm6
mulss  %xmm6,%xmm13
addss  %xmm13,%xmm5
movss  %xmm5,(%rbx)
xorps  %xmm5,%xmm5
subss  %xmm12,%xmm5
mulss  %xmm4,%xmm5
addss  %xmm12,%xmm5
movaps %xmm14,%xmm3
addss  %xmm5,%xmm3
movss  %xmm3,0x4(%rbx)
xorps  %xmm1,%xmm1
subss  %xmm11,%xmm1
mulss  %xmm4,%xmm1
addss  %xmm11,%xmm1
movaps %xmm1,%xmm3
subss  %xmm0,%xmm3
movss  %xmm3,0x8(%rbx)
movl   $0x0,0xc(%rbx)
subss  %xmm14,%xmm5
movss  %xmm5,0x10(%rbx)
movaps %xmm2,%xmm3
subss  %xmm10,%xmm3
mulss  %xmm4,%xmm3
addss  %xmm10,%xmm3
addss  %xmm13,%xmm3
movss  %xmm3,0x14(%rbx)
subss  %xmm9,%xmm6
mulss  %xmm4,%xmm6
addss  %xmm9,%xmm6
movaps %xmm7,%xmm3
addss  %xmm6,%xmm3
movss  %xmm3,0x18(%rbx)
movl   $0x0,0x1c(%rbx)
addss  %xmm1,%xmm0
movss  %xmm0,0x20(%rbx)
subss  %xmm7,%xmm6
movss  %xmm6,0x24(%rbx)
subss  %xmm8,%xmm2
mulss  %xmm4,%xmm2
addss  %xmm8,%xmm2
addss  %xmm13,%xmm2
movss  %xmm2,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 = call i64 @sincosf(float %12, float* %10, float* %11)
%14 = getelementptr inbounds [3 x float], [3 x float]* %7, i64 0, i64 0
%15 = load float*, float** %5
%16 = call i32 @v_nrm(float* %14, float* %15)
%17 = getelementptr inbounds [3 x float], [3 x float]* %7, i64 0, i64 0
%18 = load float, float* %17
%19 = getelementptr inbounds [3 x float], [3 x float]* %7, i64 0, i64 0
%20 = load float, float* %19
%21 = fmul float %18, %20
%22 = getelementptr inbounds [16 x float], [16 x float]* %8, i64 0, i64 0
store float %21, float* %22
%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 1
%26 = load float, float* %25
%27 = fmul float %24, %26
%28 = getelementptr inbounds [16 x float], [16 x float]* %8, i64 0, i64 4
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 2
%32 = load float, float* %31
%33 = fmul float %30, %32
%34 = getelementptr inbounds [16 x float], [16 x float]* %8, i64 0, i64 8
store float %33, float* %34
%35 = getelementptr inbounds [3 x float], [3 x float]* %7, i64 0, i64 1
%36 = load float, float* %35
%37 = getelementptr inbounds [3 x float], [3 x float]* %7, i64 0, i64 0
%38 = load float, float* %37
%39 = fmul float %36, %38
%40 = getelementptr inbounds [16 x float], [16 x float]* %8, i64 0, i64 1
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 1
%44 = load float, float* %43
%45 = fmul float %42, %44
%46 = getelementptr inbounds [16 x float], [16 x float]* %8, i64 0, i64 5
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 2
%50 = load float, float* %49
%51 = fmul float %48, %50
%52 = getelementptr inbounds [16 x float], [16 x float]* %8, i64 0, i64 9
store float %51, float* %52
%53 = getelementptr inbounds [3 x float], [3 x float]* %7, i64 0, i64 2
%54 = load float, float* %53
%55 = getelementptr inbounds [3 x float], [3 x float]* %7, i64 0, i64 0
%56 = load float, float* %55
%57 = fmul float %54, %56
%58 = getelementptr inbounds [16 x float], [16 x float]* %8, i64 0, i64 2
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 1
%62 = load float, float* %61
%63 = fmul float %60, %62
%64 = getelementptr inbounds [16 x float], [16 x float]* %8, i64 0, i64 6
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 2
%68 = load float, float* %67
%69 = fmul float %66, %68
%70 = getelementptr inbounds [16 x float], [16 x float]* %8, i64 0, i64 10
store float %69, float* %70
%71 = getelementptr inbounds [16 x float], [16 x float]* %9, i64 0, i64 0
store float 0.000000e+00, float* %71
%72 = getelementptr inbounds [3 x float], [3 x float]* %7, i64 0, i64 2
%73 = load float, float* %72
%74 = fneg float %73
%75 = getelementptr inbounds [16 x float], [16 x float]* %9, i64 0, i64 4
store float %74, float* %75
%76 = getelementptr inbounds [3 x float], [3 x float]* %7, i64 0, i64 1
%77 = load float, float* %76
%78 = getelementptr inbounds [16 x float], [16 x float]* %9, i64 0, i64 8
store float %77, float* %78
%79 = getelementptr inbounds [3 x float], [3 x float]* %7, i64 0, i64 2
%80 = load float, float* %79
%81 = getelementptr inbounds [16 x float], [16 x float]* %9, i64 0, i64 1
store float %80, float* %81
%82 = getelementptr inbounds [16 x float], [16 x float]* %9, i64 0, i64 5
store float 0.000000e+00, float* %82
%83 = getelementptr inbounds [3 x float], [3 x float]* %7, i64 0, i64 0
%84 = load float, float* %83
%85 = fneg float %84
%86 = getelementptr inbounds [16 x float], [16 x float]* %9, i64 0, i64 9
store float %85, float* %86
%87 = getelementptr inbounds [3 x float], [3 x float]* %7, i64 0, i64 1
%88 = load float, float* %87
%89 = fneg float %88
%90 = getelementptr inbounds [16 x float], [16 x float]* %9, i64 0, i64 2
store float %89, float* %90
%91 = getelementptr inbounds [3 x float], [3 x float]* %7, i64 0, i64 0
%92 = load float, float* %91
%93 = getelementptr inbounds [16 x float], [16 x float]* %9, i64 0, i64 6
store float %92, float* %93
%94 = getelementptr inbounds [16 x float], [16 x float]* %9, i64 0, i64 10
store float 0.000000e+00, float* %94
%95 = getelementptr inbounds [16 x float], [16 x float]* %8, i64 0, i64 0
%96 = load float, float* %95
%97 = load float, float* %11
%98 = getelementptr inbounds [16 x float], [16 x float]* %8, i64 0, i64 0
%99 = load float, float* %98
%100 = fsub float 1.000000e+00, %99
%101 = call float @llvm.fmuladd.f32(float %97, float %100, float %96)
%102 = load float, float* %10
%103 = getelementptr inbounds [16 x float], [16 x float]* %9, i64 0, i64 0
%104 = load float, float* %103
%105 = call float @llvm.fmuladd.f32(float %102, float %104, float %101)
%106 = load float*, float** %4
%107 = getelementptr inbounds float, float* %106, i64 0
store float %105, float* %107
%108 = getelementptr inbounds [16 x float], [16 x float]* %8, i64 0, i64 1
%109 = load float, float* %108
%110 = load float, float* %11
%111 = getelementptr inbounds [16 x float], [16 x float]* %8, i64 0, i64 1
%112 = load float, float* %111
%113 = fsub float 0.000000e+00, %112
%114 = call float @llvm.fmuladd.f32(float %110, float %113, float %109)
%115 = load float, float* %10
%116 = getelementptr inbounds [16 x float], [16 x float]* %9, i64 0, i64 1
%117 = load float, float* %116
%118 = call float @llvm.fmuladd.f32(float %115, float %117, float %114)
%119 = load float*, float** %4
%120 = getelementptr inbounds float, float* %119, i64 1
store float %118, float* %120
%121 = getelementptr inbounds [16 x float], [16 x float]* %8, i64 0, i64 2
%122 = load float, float* %121
%123 = load float, float* %11
%124 = getelementptr inbounds [16 x float], [16 x float]* %8, i64 0, i64 2
%125 = load float, float* %124
%126 = fsub float 0.000000e+00, %125
%127 = call float @llvm.fmuladd.f32(float %123, float %126, float %122)
%128 = load float, float* %10
%129 = getelementptr inbounds [16 x float], [16 x float]* %9, i64 0, i64 2
%130 = load float, float* %129
%131 = call float @llvm.fmuladd.f32(float %128, float %130, float %127)
%132 = load float*, float** %4
%133 = getelementptr inbounds float, float* %132, i64 2
store float %131, float* %133
%134 = load float*, float** %4
%135 = getelementptr inbounds float, float* %134, i64 3
store float 0.000000e+00, float* %135
%136 = getelementptr inbounds [16 x float], [16 x float]* %8, i64 0, i64 4
%137 = load float, float* %136
%138 = load float, float* %11
%139 = getelementptr inbounds [16 x float], [16 x float]* %8, i64 0, i64 4
%140 = load float, float* %139
%141 = fsub float 0.000000e+00, %140
%142 = call float @llvm.fmuladd.f32(float %138, float %141, float %137)
%143 = load float, float* %10
%144 = getelementptr inbounds [16 x float], [16 x float]* %9, i64 0, i64 4
%145 = load float, float* %144
%146 = call float @llvm.fmuladd.f32(float %143, float %145, float %142)
%147 = load float*, float** %4
%148 = getelementptr inbounds float, float* %147, i64 4
store float %146, float* %148
%149 = getelementptr inbounds [16 x float], [16 x float]* %8, i64 0, i64 5
%150 = load float, float* %149
%151 = load float, float* %11
%152 = getelementptr inbounds [16 x float], [16 x float]* %8, i64 0, i64 5
%153 = load float, float* %152
%154 = fsub float 1.000000e+00, %153
%155 = call float @llvm.fmuladd.f32(float %151, float %154, float %150)
%156 = load float, float* %10
%157 = getelementptr inbounds [16 x float], [16 x float]* %9, i64 0, i64 5
%158 = load float, float* %157
%159 = call float @llvm.fmuladd.f32(float %156, float %158, float %155)
%160 = load float*, float** %4
%161 = getelementptr inbounds float, float* %160, i64 5
store float %159, float* %161
%162 = getelementptr inbounds [16 x float], [16 x float]* %8, i64 0, i64 6
%163 = load float, float* %162
%164 = load float, float* %11
%165 = getelementptr inbounds [16 x float], [16 x float]* %8, i64 0, i64 6
%166 = load float, float* %165
%167 = fsub float 0.000000e+00, %166
%168 = call float @llvm.fmuladd.f32(float %164, float %167, float %163)
%169 = load float, float* %10
%170 = getelementptr inbounds [16 x float], [16 x float]* %9, i64 0, i64 6
%171 = load float, float* %170
%172 = call float @llvm.fmuladd.f32(float %169, float %171, float %168)
%173 = load float*, float** %4
%174 = getelementptr inbounds float, float* %173, i64 6
store float %172, float* %174
%175 = load float*, float** %4
%176 = getelementptr inbounds float, float* %175, i64 7
store float 0.000000e+00, float* %176
%177 = getelementptr inbounds [16 x float], [16 x float]* %8, i64 0, i64 8
%178 = load float, float* %177
%179 = load float, float* %11
%180 = getelementptr inbounds [16 x float], [16 x float]* %8, i64 0, i64 8
%181 = load float, float* %180
%182 = fsub float 0.000000e+00, %181
%183 = call float @llvm.fmuladd.f32(float %179, float %182, float %178)
%184 = load float, float* %10
%185 = getelementptr inbounds [16 x float], [16 x float]* %9, i64 0, i64 8
%186 = load float, float* %185
%187 = call float @llvm.fmuladd.f32(float %184, float %186, float %183)
%188 = load float*, float** %4
%189 = getelementptr inbounds float, float* %188, i64 8
store float %187, float* %189
%190 = getelementptr inbounds [16 x float], [16 x float]* %8, i64 0, i64 9
%191 = load float, float* %190
%192 = load float, float* %11
%193 = getelementptr inbounds [16 x float], [16 x float]* %8, i64 0, i64 9
%194 = load float, float* %193
%195 = fsub float 0.000000e+00, %194
%196 = call float @llvm.fmuladd.f32(float %192, float %195, float %191)
%197 = load float, float* %10
%198 = getelementptr inbounds [16 x float], [16 x float]* %9, i64 0, i64 9
%199 = load float, float* %198
%200 = call float @llvm.fmuladd.f32(float %197, float %199, float %196)
%201 = load float*, float** %4
%202 = getelementptr inbounds float, float* %201, i64 9
store float %200, float* %202
%203 = getelementptr inbounds [16 x float], [16 x float]* %8, i64 0, i64 10
%204 = load float, float* %203
%205 = load float, float* %11
%206 = getelementptr inbounds [16 x float], [16 x float]* %8, i64 0, i64 10
%207 = load float, float* %206
%208 = fsub float 1.000000e+00, %207
%209 = call float @llvm.fmuladd.f32(float %205, float %208, float %204)
%210 = load float, float* %10
%211 = getelementptr inbounds [16 x float], [16 x float]* %9, i64 0, i64 10
%212 = load float, float* %211
%213 = call float @llvm.fmuladd.f32(float %210, float %212, float %209)
%214 = load float*, float** %4
%215 = getelementptr inbounds float, float* %214, i64 10
store float %213, float* %215
%216 = load float*, float** %4
%217 = getelementptr inbounds float, float* %216, i64 11
store float 0.000000e+00, float* %217
%218 = load float*, float** %4
%219 = getelementptr inbounds float, float* %218, i64 12
store float 0.000000e+00, float* %219
%220 = load float*, float** %4
%221 = getelementptr inbounds float, float* %220, i64 13
store float 0.000000e+00, float* %221
%222 = load float*, float** %4
%223 = getelementptr inbounds float, float* %222, i64 14
store float 0.000000e+00, float* %223
%224 = load float*, float** %4
%225 = getelementptr inbounds float, float* %224, i64 15
store float 1.000000e+00, float* %225
ret void
}

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