#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 */
double sqrt(float);
int get_cross_vec(float *res, float *dir, float *up) {
  float fudge[3];
  {
    res[0] = dir[1] * up[2] - dir[2] * up[1];
    res[1] = -dir[0] * up[2] + dir[2] * up[0];
    res[2] = dir[0] * up[1] - dir[1] * up[0];
  };
  if (sqrt(res[0] * res[0] + res[1] * res[1] + res[2] * res[2]) != 0.0)
    return 1;
  if (dir[0] != 0.0) {
    fudge[0] = dir[0] * 0.99999;
    fudge[1] = sqrt((dir[0] * dir[0]) - (fudge[0] * fudge[0]));
    fudge[2] = 0.0;
  } else if (dir[1] != 0.0) {
    fudge[1] = dir[1] * 0.99999;
    fudge[0] = sqrt((dir[1] * dir[1]) - (fudge[1] * fudge[1]));
    fudge[2] = 0.0;
  } else {
    fudge[2] = dir[2] * 0.99999;
    fudge[1] = sqrt((dir[2] * dir[2]) - (fudge[2] * fudge[2]));
    fudge[0] = 0.0;
  }
  {
    res[0] = fudge[1] * up[2] - fudge[2] * up[1];
    res[1] = -fudge[0] * up[2] + fudge[2] * up[0];
    res[2] = fudge[0] * up[1] - fudge[1] * up[0];
  };
  return 0;
}


x86 assembly (clang, -O0):
<get_cross_vec>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x18(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x20(%rbp),%rax
movss  0x8(%rax),%xmm2
mov    -0x18(%rbp),%rax
movss  0x8(%rax),%xmm1
mov    -0x20(%rbp),%rax
mulss  0x4(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x20(%rbp),%rax
movss  0x8(%rax),%xmm2
mov    -0x18(%rbp),%rax
movss  0x8(%rax),%xmm1
mov    -0x20(%rbp),%rax
mulss  (%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x4(%rax)
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x20(%rbp),%rax
movss  0x4(%rax),%xmm2
mov    -0x18(%rbp),%rax
movss  0x4(%rax),%xmm1
mov    -0x20(%rbp),%rax
mulss  (%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x8(%rax)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm1
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulss  0x4(%rax),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
call   1030 <sqrt@plt>
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1246 <get_cross_vec+0x136>
jp     1246 <get_cross_vec+0x136>
jmp    1252 <get_cross_vec+0x142>
movl   $0x1,-0x4(%rbp)
jmp    1494 <get_cross_vec+0x384>
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1276 <get_cross_vec+0x166>
jp     1276 <get_cross_vec+0x166>
jmp    12e1 <get_cross_vec+0x1d1>
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xd76(%rip),%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm2
movss  -0x2c(%rbp),%xmm1
mulss  -0x2c(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
call   1030 <sqrt@plt>
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x28(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x24(%rbp)
jmp    13e2 <get_cross_vec+0x2d2>
mov    -0x18(%rbp),%rax
movss  0x4(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1306 <get_cross_vec+0x1f6>
jp     1306 <get_cross_vec+0x1f6>
jmp    1374 <get_cross_vec+0x264>
mov    -0x18(%rbp),%rax
movss  0x4(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xce5(%rip),%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x4(%rax),%xmm2
movss  -0x28(%rbp),%xmm1
mulss  -0x28(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
call   1030 <sqrt@plt>
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x2c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x24(%rbp)
jmp    13dd <get_cross_vec+0x2cd>
mov    -0x18(%rbp),%rax
movss  0x8(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xc77(%rip),%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x24(%rbp)
mov    -0x18(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x8(%rax),%xmm2
movss  -0x24(%rbp),%xmm1
mulss  -0x24(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
call   1030 <sqrt@plt>
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x28(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x2c(%rbp)
jmp    13e2 <get_cross_vec+0x2d2>
movss  -0x28(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  0x8(%rax),%xmm2
movss  -0x24(%rbp),%xmm1
mov    -0x20(%rbp),%rax
mulss  0x4(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x2c(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x20(%rbp),%rax
movss  0x8(%rax),%xmm2
movss  -0x24(%rbp),%xmm1
mov    -0x20(%rbp),%rax
mulss  (%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x2c(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  0x4(%rax),%xmm2
movss  -0x28(%rbp),%xmm1
mov    -0x20(%rbp),%rax
mulss  (%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x8(%rax)
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<get_cross_vec>:
push   %r15
push   %r14
push   %rbx
sub    $0x10,%rsp
mov    %rdx,%r15
mov    %rsi,%rbx
mov    %rdi,%r14
movss  0x4(%rsi),%xmm1
movss  0x4(%rdx),%xmm0
mulss  0x8(%rsi),%xmm0
mulss  0x8(%rdx),%xmm1
subss  %xmm0,%xmm1
movss  %xmm1,(%rdi)
movss  (%rsi),%xmm0
movss  0x8(%rsi),%xmm2
mulss  (%rdx),%xmm2
mulss  0x8(%rdx),%xmm0
subss  %xmm0,%xmm2
movss  %xmm2,0x4(%rdi)
movss  (%rsi),%xmm0
movss  (%rdx),%xmm3
mulss  0x4(%rsi),%xmm3
mulss  0x4(%rdx),%xmm0
subss  %xmm3,%xmm0
movss  %xmm0,0x8(%rdi)
mulss  %xmm2,%xmm2
mulss  %xmm1,%xmm1
addss  %xmm2,%xmm1
mulss  %xmm0,%xmm0
addss  %xmm1,%xmm0
call   1030 <sqrt@plt>
mov    $0x1,%eax
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    12c3 <get_cross_vec+0x1b3>
jp     12c3 <get_cross_vec+0x1b3>
movss  (%rbx),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    11b3 <get_cross_vec+0xa3>
jnp    11f2 <get_cross_vec+0xe2>
xorps  %xmm1,%xmm1
cvtss2sd %xmm0,%xmm1
mulsd  0xe3e(%rip),%xmm1
cvtsd2ss %xmm1,%xmm1
movss  %xmm1,0xc(%rsp)
mulss  %xmm1,%xmm1
mulss  %xmm0,%xmm0
subss  %xmm1,%xmm0
call   1030 <sqrt@plt>
movss  0xc(%rsp),%xmm4
xorps  %xmm2,%xmm2
xorps  %xmm3,%xmm3
cvtsd2ss %xmm0,%xmm3
jmp    1276 <get_cross_vec+0x166>
movss  0x4(%rbx),%xmm0
ucomiss %xmm1,%xmm0
jne    11fe <get_cross_vec+0xee>
jnp    1237 <get_cross_vec+0x127>
xorps  %xmm1,%xmm1
cvtss2sd %xmm0,%xmm1
mulsd  0xdf3(%rip),%xmm1
cvtsd2ss %xmm1,%xmm1
movss  %xmm1,0xc(%rsp)
mulss  %xmm1,%xmm1
mulss  %xmm0,%xmm0
subss  %xmm1,%xmm0
call   1030 <sqrt@plt>
movss  0xc(%rsp),%xmm3
cvtsd2ss %xmm0,%xmm4
xorps  %xmm2,%xmm2
jmp    1276 <get_cross_vec+0x166>
movss  0x8(%rbx),%xmm0
xorps  %xmm1,%xmm1
cvtss2sd %xmm0,%xmm1
mulsd  0xdb5(%rip),%xmm1
cvtsd2ss %xmm1,%xmm1
movss  %xmm1,0xc(%rsp)
mulss  %xmm1,%xmm1
mulss  %xmm0,%xmm0
subss  %xmm1,%xmm0
call   1030 <sqrt@plt>
movss  0xc(%rsp),%xmm2
xorps  %xmm3,%xmm3
cvtsd2ss %xmm0,%xmm3
xorps  %xmm4,%xmm4
movss  0x4(%r15),%xmm0
mulss  %xmm2,%xmm0
movss  0x8(%r15),%xmm1
mulss  %xmm3,%xmm1
subss  %xmm0,%xmm1
movss  %xmm1,(%r14)
mulss  (%r15),%xmm2
movss  0x8(%r15),%xmm0
mulss  %xmm4,%xmm0
subss  %xmm0,%xmm2
movss  %xmm2,0x4(%r14)
mulss  (%r15),%xmm3
mulss  0x4(%r15),%xmm4
subss  %xmm3,%xmm4
movss  %xmm4,0x8(%r14)
xor    %eax,%eax
add    $0x10,%rsp
pop    %rbx
pop    %r14
pop    %r15
ret

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

LLVM IR (-O2):
define i32 @get_cross_vec(float* nocapture %0, float* nocapture %1, float* nocapture %2) {
%4 = getelementptr inbounds float, float* %1, i64 1
%5 = load float, float* %4
%6 = getelementptr inbounds float, float* %2, i64 2
%7 = load float, float* %6
%8 = getelementptr inbounds float, float* %1, i64 2
%9 = load float, float* %8
%10 = getelementptr inbounds float, float* %2, i64 1
%11 = load float, float* %10
%12 = fneg float %9
%13 = fmul float %11, %12
%14 = tail call float @llvm.fmuladd.f32(float %5, float %7, float %13)
store float %14, float* %0
%15 = load float, float* %1
%16 = fneg float %15
%17 = load float, float* %6
%18 = load float, float* %8
%19 = load float, float* %2
%20 = fmul float %18, %19
%21 = tail call float @llvm.fmuladd.f32(float %16, float %17, float %20)
%22 = getelementptr inbounds float, float* %0, i64 1
store float %21, float* %22
%23 = load float, float* %1
%24 = load float, float* %10
%25 = load float, float* %4
%26 = load float, float* %2
%27 = fneg float %25
%28 = fmul float %26, %27
%29 = tail call float @llvm.fmuladd.f32(float %23, float %24, float %28)
%30 = getelementptr inbounds float, float* %0, i64 2
store float %29, float* %30
%31 = fmul float %21, %21
%32 = tail call float @llvm.fmuladd.f32(float %14, float %14, float %31)
%33 = tail call float @llvm.fmuladd.f32(float %29, float %29, float %32)
%34 = tail call double @sqrt(float %33)
%35 = fcmp une double %34, 0.000000e+00
br i1 %35, label %89, label %36
36: ; preds = %3
%37 = load float, float* %1
%38 = fcmp une float %37, 0.000000e+00
br i1 %38, label %39, label %48
39: ; preds = %36
%40 = fpext float %37 to double
%41 = fmul double %40, 9.999900e-01
%42 = fptrunc double %41 to float
%43 = fneg float %42
%44 = fmul float %43, %42
%45 = tail call float @llvm.fmuladd.f32(float %37, float %37, float %44)
%46 = tail call double @sqrt(float %45)
%47 = fptrunc double %46 to float
br label %70
48: ; preds = %36
%49 = load float, float* %4
%50 = fcmp une float %49, 0.000000e+00
br i1 %50, label %51, label %60
51: ; preds = %48
%52 = fpext float %49 to double
%53 = fmul double %52, 9.999900e-01
%54 = fptrunc double %53 to float
%55 = fneg float %54
%56 = fmul float %55, %54
%57 = tail call float @llvm.fmuladd.f32(float %49, float %49, float %56)
%58 = tail call double @sqrt(float %57)
%59 = fptrunc double %58 to float
br label %70
60: ; preds = %48
%61 = load float, float* %8
%62 = fpext float %61 to double
%63 = fmul double %62, 9.999900e-01
%64 = fptrunc double %63 to float
%65 = fneg float %64
%66 = fmul float %65, %64
%67 = tail call float @llvm.fmuladd.f32(float %61, float %61, float %66)
%68 = tail call double @sqrt(float %67)
%69 = fptrunc double %68 to float
br label %70
70: ; preds = %51, %60, %39
%71 = phi float [ 0.000000e+00, %39 ], [ 0.000000e+00, %51 ], [ %64, %60 ]
%72 = phi float [ %47, %39 ], [ %54, %51 ], [ %69, %60 ]
%73 = phi float [ %42, %39 ], [ %59, %51 ], [ 0.000000e+00, %60 ]
%74 = load float, float* %6
%75 = load float, float* %10
%76 = fneg float %71
%77 = fmul float %75, %76
%78 = tail call float @llvm.fmuladd.f32(float %72, float %74, float %77)
store float %78, float* %0
%79 = fneg float %73
%80 = load float, float* %6
%81 = load float, float* %2
%82 = fmul float %71, %81
%83 = tail call float @llvm.fmuladd.f32(float %79, float %80, float %82)
store float %83, float* %22
%84 = load float, float* %10
%85 = load float, float* %2
%86 = fneg float %72
%87 = fmul float %85, %86
%88 = tail call float @llvm.fmuladd.f32(float %73, float %84, float %87)
store float %88, float* %30
br label %89
89: ; preds = %3, %70
%90 = phi i32 [ 0, %70 ], [ 1, %3 ]
ret i32 %90
}