#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 */
typedef float GLfloat;

/* Variables and functions */
float M_PI;
int /*<<< orphan*/ cos(float);
int /*<<< orphan*/ omul_normalize_vector(float *, float *, float *);
int /*<<< orphan*/ sin(float);
void omul_rotate(GLfloat m[], GLfloat angle, GLfloat x, GLfloat y, GLfloat z) {
  GLfloat rad = (GLfloat)(angle * M_PI / 180.0f);
  GLfloat a_sin = (GLfloat)sin(rad);
  GLfloat a_cos = (GLfloat)cos(rad);
  omul_normalize_vector(&x, &y, &z);
  GLfloat xx = x * x;
  GLfloat xy = x * y;
  GLfloat xz = x * z;
  GLfloat yy = y * y;
  GLfloat yz = y * z;
  GLfloat zz = z * z;
  GLfloat c = (GLfloat)(1.0f - a_cos);
  m[0] = xx * c + a_cos;
  m[1] = xy * c - (z * a_sin);
  m[2] = xz * c + (y * a_sin);
  m[4] = xy * c + (z * a_sin);
  m[5] = yy * c + a_cos;
  m[6] = yz * c - (x * a_sin);
  m[8] = xz * c - (y * a_sin);
  m[9] = yz * c + (x * a_sin);
  m[10] = zz * c + a_cos;
}


x86 assembly (clang, -O0):
<omul_rotate>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%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    0x2e8c(%rip),%rax
mulss  (%rax),%xmm0
movss  0xe9c(%rip),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x1c(%rbp)
movss  -0x1c(%rbp),%xmm0
call   1030 <sin@plt>
cvtsi2ss %eax,%xmm0
movss  %xmm0,-0x20(%rbp)
movss  -0x1c(%rbp),%xmm0
call   1050 <cos@plt>
cvtsi2ss %eax,%xmm0
movss  %xmm0,-0x24(%rbp)
lea    -0x10(%rbp),%rdi
lea    -0x14(%rbp),%rsi
lea    -0x18(%rbp),%rdx
call   1040 <omul_normalize_vector@plt>
movss  -0x10(%rbp),%xmm0
mulss  -0x10(%rbp),%xmm0
movss  %xmm0,-0x28(%rbp)
movss  -0x10(%rbp),%xmm0
mulss  -0x14(%rbp),%xmm0
movss  %xmm0,-0x2c(%rbp)
movss  -0x10(%rbp),%xmm0
mulss  -0x18(%rbp),%xmm0
movss  %xmm0,-0x30(%rbp)
movss  -0x14(%rbp),%xmm0
mulss  -0x14(%rbp),%xmm0
movss  %xmm0,-0x34(%rbp)
movss  -0x14(%rbp),%xmm0
mulss  -0x18(%rbp),%xmm0
movss  %xmm0,-0x38(%rbp)
movss  -0x18(%rbp),%xmm0
mulss  -0x18(%rbp),%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  0xdf6(%rip),%xmm0
subss  -0x24(%rbp),%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x28(%rbp),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x24(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x2c(%rbp),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x18(%rbp),%xmm1
mulss  -0x20(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x30(%rbp),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x14(%rbp),%xmm1
mulss  -0x20(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x8(%rax)
movss  -0x2c(%rbp),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x18(%rbp),%xmm1
mulss  -0x20(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x10(%rax)
movss  -0x34(%rbp),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x24(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x14(%rax)
movss  -0x38(%rbp),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x10(%rbp),%xmm1
mulss  -0x20(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x18(%rax)
movss  -0x30(%rbp),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x14(%rbp),%xmm1
mulss  -0x20(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x20(%rax)
movss  -0x38(%rbp),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x10(%rbp),%xmm1
mulss  -0x20(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x24(%rax)
movss  -0x3c(%rbp),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x24(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x28(%rax)
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<omul_rotate>:
push   %rbx
sub    $0x20,%rsp
mov    %rdi,%rbx
movss  %xmm1,0x18(%rsp)
movss  %xmm2,0x14(%rsp)
movss  %xmm3,0x10(%rsp)
mov    0x2e97(%rip),%rax
mulss  (%rax),%xmm0
divss  0xea3(%rip),%xmm0
movss  %xmm0,0xc(%rsp)
call   1030 <sin@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movss  %xmm0,0x1c(%rsp)
movss  0xc(%rsp),%xmm0
call   1050 <cos@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movss  %xmm0,0xc(%rsp)
lea    0x18(%rsp),%rdi
lea    0x14(%rsp),%rsi
lea    0x10(%rsp),%rdx
call   1040 <omul_normalize_vector@plt>
movss  0x18(%rsp),%xmm7
movaps %xmm7,%xmm0
mulss  %xmm7,%xmm0
movss  0x14(%rsp),%xmm11
movaps %xmm7,%xmm5
mulss  %xmm11,%xmm5
movss  0x10(%rsp),%xmm4
movaps %xmm7,%xmm2
mulss  %xmm4,%xmm2
movaps %xmm11,%xmm6
mulss  %xmm11,%xmm6
movaps %xmm11,%xmm9
mulss  %xmm4,%xmm9
movaps %xmm4,%xmm8
mulss  %xmm4,%xmm8
movss  0xe17(%rip),%xmm3
movss  0xc(%rsp),%xmm10
subss  %xmm10,%xmm3
mulss  %xmm3,%xmm0
addss  %xmm10,%xmm0
movss  %xmm0,(%rbx)
mulss  %xmm3,%xmm5
movss  0x1c(%rsp),%xmm1
mulss  %xmm1,%xmm4
movaps %xmm5,%xmm0
subss  %xmm4,%xmm0
movss  %xmm0,0x4(%rbx)
mulss  %xmm1,%xmm11
mulss  %xmm3,%xmm2
movaps %xmm2,%xmm0
addss  %xmm11,%xmm0
movss  %xmm0,0x8(%rbx)
addss  %xmm5,%xmm4
movss  %xmm4,0x10(%rbx)
mulss  %xmm3,%xmm6
addss  %xmm10,%xmm6
movss  %xmm6,0x14(%rbx)
mulss  %xmm3,%xmm9
mulss  %xmm1,%xmm7
movaps %xmm9,%xmm0
subss  %xmm7,%xmm0
movss  %xmm0,0x18(%rbx)
subss  %xmm11,%xmm2
movss  %xmm2,0x20(%rbx)
addss  %xmm9,%xmm7
movss  %xmm7,0x24(%rbx)
mulss  %xmm8,%xmm3
addss  %xmm10,%xmm3
movss  %xmm3,0x28(%rbx)
add    $0x20,%rsp
pop    %rbx
ret

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

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