void VectorRotY(float *vIn, float inc) {
  float alpha;
  float modZX;
  float mod;
  mod = (float)sqrt((vIn[0]) * (vIn[0]) + (vIn[1]) * (vIn[1]) +
                    (vIn[2]) * (vIn[2]));
  if (mod < 0.0001f)
    return;
  vIn[0] = vIn[0] / mod;
  vIn[1] = vIn[1] / mod;
  vIn[2] = vIn[2] / mod;
  if (fabs(vIn[1]) > sin(3.14159265359f / 2.0 - 0.00872665f))
    return;
  modZX = (float)sqrt(vIn[0] * vIn[0] + vIn[2] * vIn[2]);
  alpha = (float)acos(vIn[2] / modZX);
  if (vIn[0] < 0.0f)
    alpha = 2.0f * 3.14159265359f - alpha;
  alpha += inc;
  vIn[0] = (float)sin(alpha) * modZX;
  vIn[2] = (float)cos(alpha) * modZX;
  vIn[0] = vIn[0] * mod;
  vIn[1] = vIn[1] * mod;
  vIn[2] = vIn[2] * mod;
}


x86 assembly (clang, -O0):
<VectorRotY>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %rdi,-0x8(%rbp)
movss  %xmm0,-0xc(%rbp)
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm1
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm2
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x8(%rbp),%rax
mulss  0x4(%rax),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
call   1060 <sqrt@plt>
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x18(%rbp)
movss  0xe51(%rip),%xmm0
ucomiss -0x18(%rbp),%xmm0
jbe    11be <VectorRotY+0x7e>
jmp    1351 <VectorRotY+0x211>
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
divss  -0x18(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm0
divss  -0x18(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x4(%rax)
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm0
divss  -0x18(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x8(%rax)
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
movaps 0xdfb(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x20(%rbp)
movsd  0xde2(%rip),%xmm0
call   1040 <sin@plt>
movaps %xmm0,%xmm1
movsd  -0x20(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    1242 <VectorRotY+0x102>
jmp    1351 <VectorRotY+0x211>
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm2
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm1
mov    -0x8(%rbp),%rax
mulss  0x8(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
call   1060 <sqrt@plt>
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x14(%rbp)
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm0
divss  -0x14(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
call   1030 <acos@plt>
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x10(%rbp)
mov    -0x8(%rbp),%rax
xorps  %xmm0,%xmm0
ucomiss (%rax),%xmm0
jbe    12c0 <VectorRotY+0x180>
movss  0xd4e(%rip),%xmm0
subss  -0x10(%rbp),%xmm0
movss  %xmm0,-0x10(%rbp)
movss  -0xc(%rbp),%xmm0
addss  -0x10(%rbp),%xmm0
movss  %xmm0,-0x10(%rbp)
movss  -0x10(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
call   1040 <sin@plt>
cvtsd2ss %xmm0,%xmm0
mulss  -0x14(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x10(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
call   1050 <cos@plt>
cvtsd2ss %xmm0,%xmm0
mulss  -0x14(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x8(%rax)
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
mulss  -0x18(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm0
mulss  -0x18(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x4(%rax)
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm0
mulss  -0x18(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x8(%rax)
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<VectorRotY>:
push   %rbx
sub    $0x20,%rsp
movss  %xmm0,0x10(%rsp)
mov    %rdi,%rbx
movss  (%rdi),%xmm1
movss  0x4(%rdi),%xmm0
mulss  %xmm0,%xmm0
mulss  %xmm1,%xmm1
addss  %xmm0,%xmm1
movss  0x8(%rdi),%xmm0
mulss  %xmm0,%xmm0
addss  %xmm1,%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jb     117e <VectorRotY+0x3e>
sqrtss %xmm0,%xmm3
jmp    1186 <VectorRotY+0x46>
call   1050 <sqrtf@plt>
movaps %xmm0,%xmm3
movss  0xe72(%rip),%xmm0
ucomiss %xmm3,%xmm0
ja     12a2 <VectorRotY+0x162>
movss  (%rbx),%xmm0
movss  0x4(%rbx),%xmm2
divss  %xmm3,%xmm0
movss  %xmm0,(%rbx)
divss  %xmm3,%xmm2
movss  %xmm2,0x4(%rbx)
movss  0x8(%rbx),%xmm1
divss  %xmm3,%xmm1
movss  %xmm1,0x8(%rbx)
andps  0xe4a(%rip),%xmm2
cvtss2sd %xmm2,%xmm2
ucomisd 0xe4e(%rip),%xmm2
ja     12a2 <VectorRotY+0x162>
movss  %xmm3,0x1c(%rsp)
mulss  %xmm1,%xmm1
mulss  %xmm0,%xmm0
addss  %xmm1,%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jb     11f8 <VectorRotY+0xb8>
sqrtss %xmm0,%xmm0
jmp    11fd <VectorRotY+0xbd>
call   1050 <sqrtf@plt>
movss  %xmm0,0xc(%rsp)
movss  0x8(%rbx),%xmm1
divss  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtss2sd %xmm1,%xmm0
call   1030 <acos@plt>
cvtsd2ss %xmm0,%xmm0
movss  (%rbx),%xmm1
movss  0xddc(%rip),%xmm2
subss  %xmm0,%xmm2
cmpltss 0xdd3(%rip),%xmm1
andps  %xmm1,%xmm2
andnps %xmm0,%xmm1
orps   %xmm2,%xmm1
addss  0x10(%rsp),%xmm1
xorps  %xmm0,%xmm0
cvtss2sd %xmm1,%xmm0
movsd  %xmm0,0x10(%rsp)
call   1040 <sin@plt>
cvtsd2ss %xmm0,%xmm0
mulss  0xc(%rsp),%xmm0
movss  %xmm0,(%rbx)
movsd  0x10(%rsp),%xmm0
call   1060 <cos@plt>
cvtsd2ss %xmm0,%xmm0
mulss  0xc(%rsp),%xmm0
movss  (%rbx),%xmm1
movss  0x1c(%rsp),%xmm2
mulss  %xmm2,%xmm1
movss  %xmm1,(%rbx)
movss  0x4(%rbx),%xmm1
mulss  %xmm2,%xmm1
movss  %xmm1,0x4(%rbx)
mulss  %xmm2,%xmm0
movss  %xmm0,0x8(%rbx)
add    $0x20,%rsp
pop    %rbx
ret

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

LLVM IR (-O2):
define void @VectorRotY(float* nocapture %0, float %1) {
%3 = load float, float* %0
%4 = getelementptr inbounds float, float* %0, i64 1
%5 = load float, float* %4
%6 = fmul float %5, %5
%7 = tail call float @llvm.fmuladd.f32(float %3, float %3, float %6)
%8 = getelementptr inbounds float, float* %0, i64 2
%9 = load float, float* %8
%10 = tail call float @llvm.fmuladd.f32(float %9, float %9, float %7)
%11 = tail call float @sqrtf(float %10)
%12 = fcmp olt float %11, 0x3F1A36E2E0000000
br i1 %12, label %49, label %13
13: ; preds = %2
%14 = load float, float* %0
%15 = fdiv float %14, %11
store float %15, float* %0
%16 = load float, float* %4
%17 = fdiv float %16, %11
store float %17, float* %4
%18 = load float, float* %8
%19 = fdiv float %18, %11
store float %19, float* %8
%20 = tail call float @llvm.fabs.f32(float %17)
%21 = fpext float %20 to double
%22 = fcmp ogt double %21, 0x3FEFFFB025C9D3C4
br i1 %22, label %49, label %23
23: ; preds = %13
%24 = fmul float %19, %19
%25 = tail call float @llvm.fmuladd.f32(float %15, float %15, float %24)
%26 = tail call float @sqrtf(float %25)
%27 = load float, float* %8
%28 = fdiv float %27, %26
%29 = fpext float %28 to double
%30 = tail call double @acos(double %29)
%31 = fptrunc double %30 to float
%32 = load float, float* %0
%33 = fcmp olt float %32, 0.000000e+00
%34 = fsub float 0x401921FB60000000, %31
%35 = select i1 %33, float %34, float %31
%36 = fadd float %35, %1
%37 = fpext float %36 to double
%38 = tail call double @sin(double %37)
%39 = fptrunc double %38 to float
%40 = fmul float %26, %39
store float %40, float* %0
%41 = tail call double @cos(double %37)
%42 = fptrunc double %41 to float
%43 = fmul float %26, %42
%44 = load float, float* %0
%45 = fmul float %11, %44
store float %45, float* %0
%46 = load float, float* %4
%47 = fmul float %11, %46
store float %47, float* %4
%48 = fmul float %11, %43
store float %48, float* %8
br label %49
49: ; preds = %13, %2, %23
ret void
}