#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 */
int /*<<< orphan*/ ThreeByOne_OneByThree(float *, float *, float *);
scalar_t__ calloc(int, int);
int /*<<< orphan*/ free(float *);
float sqrt(float);
float *LookAtReplacement(float eyeX, float eyeY, float eyeZ, float centerX,
                         float centerY, float centerZ, float upX, float upY,
                         float upZ) {
  float *r;
  float *f;
  float *up;
  float *s;
  float *ss;
  float *u;
  float upn, fn, sn;
  r = (float *)calloc(sizeof(float), 16);
  f = (float *)calloc(sizeof(float), 3);
  up = (float *)calloc(sizeof(float), 3);
  s = (float *)calloc(sizeof(float), 3);
  ss = (float *)calloc(sizeof(float), 3);
  u = (float *)calloc(sizeof(float), 3);
  f[0] = centerX - eyeX;
  f[1] = centerY - eyeY;
  f[2] = centerZ - eyeZ;
  fn = sqrt((f[0] * f[0]) + (f[1] * f[1]) + (f[2] * f[2]));
  f[0] = f[0] / fn;
  f[1] = f[1] / fn;
  f[2] = f[2] / fn;
  upn = sqrt((upX * upX) + (upY * upY) + (upZ * upZ));
  up[0] = upX / upn;
  up[1] = upY / upn;
  up[2] = upZ / upn;
  ThreeByOne_OneByThree(f, up, s);
  sn = sqrt((s[0] * s[0]) + (s[1] * s[1]) + (s[2] * s[2]));
  ss[0] = s[0] / sn;
  ss[1] = s[1] / sn;
  ss[2] = s[2] / sn;
  ThreeByOne_OneByThree(ss, f, u);
  free(up);
  free(ss);
  r[0] = s[0];
  r[1] = u[0];
  r[2] = -1.0 * f[0];
  r[3] = 0.0;
  r[4] = s[1];
  r[5] = u[1];
  r[6] = -1.0 * f[1];
  r[7] = 0.0;
  r[8] = s[2];
  r[9] = u[2];
  r[10] = -1.0 * f[2];
  r[11] = 0.0;
  r[12] = 0.0;
  r[13] = 0.0;
  r[14] = 0.0;
  r[15] = 1.0;
  free(f);
  free(u);
  free(s);
  return r;
}


x86 assembly (clang, -O0):
<LookAtReplacement>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
movss  0x10(%rbp),%xmm8
movss  %xmm0,-0x4(%rbp)
movss  %xmm1,-0x8(%rbp)
movss  %xmm2,-0xc(%rbp)
movss  %xmm3,-0x10(%rbp)
movss  %xmm4,-0x14(%rbp)
movss  %xmm5,-0x18(%rbp)
movss  %xmm6,-0x1c(%rbp)
movss  %xmm7,-0x20(%rbp)
mov    $0x4,%edi
mov    $0x10,%esi
call   1040 <calloc@plt>
mov    %rax,-0x28(%rbp)
mov    $0x4,%edi
mov    $0x3,%esi
call   1040 <calloc@plt>
mov    %rax,-0x30(%rbp)
mov    $0x4,%edi
mov    $0x3,%esi
call   1040 <calloc@plt>
mov    %rax,-0x38(%rbp)
mov    $0x4,%edi
mov    $0x3,%esi
call   1040 <calloc@plt>
mov    %rax,-0x40(%rbp)
mov    $0x4,%edi
mov    $0x3,%esi
call   1040 <calloc@plt>
mov    %rax,-0x48(%rbp)
mov    $0x4,%edi
mov    $0x3,%esi
call   1040 <calloc@plt>
mov    %rax,-0x50(%rbp)
movss  -0x10(%rbp),%xmm0
subss  -0x4(%rbp),%xmm0
mov    -0x30(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x14(%rbp),%xmm0
subss  -0x8(%rbp),%xmm0
mov    -0x30(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x18(%rbp),%xmm0
subss  -0xc(%rbp),%xmm0
mov    -0x30(%rbp),%rax
movss  %xmm0,0x8(%rax)
mov    -0x30(%rbp),%rax
movss  (%rax),%xmm1
mov    -0x30(%rbp),%rax
movss  (%rax),%xmm2
mov    -0x30(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x30(%rbp),%rax
mulss  0x4(%rax),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x30(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x30(%rbp),%rax
movss  0x8(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
call   1060 <sqrt@plt>
movss  %xmm0,-0x58(%rbp)
mov    -0x30(%rbp),%rax
movss  (%rax),%xmm0
divss  -0x58(%rbp),%xmm0
mov    -0x30(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x30(%rbp),%rax
movss  0x4(%rax),%xmm0
divss  -0x58(%rbp),%xmm0
mov    -0x30(%rbp),%rax
movss  %xmm0,0x4(%rax)
mov    -0x30(%rbp),%rax
movss  0x8(%rax),%xmm0
divss  -0x58(%rbp),%xmm0
mov    -0x30(%rbp),%rax
movss  %xmm0,0x8(%rax)
movss  -0x1c(%rbp),%xmm1
movss  -0x1c(%rbp),%xmm2
movss  -0x20(%rbp),%xmm0
mulss  -0x20(%rbp),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  0x10(%rbp),%xmm0
movss  0x10(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
call   1060 <sqrt@plt>
movss  %xmm0,-0x54(%rbp)
movss  -0x1c(%rbp),%xmm0
divss  -0x54(%rbp),%xmm0
mov    -0x38(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x20(%rbp),%xmm0
divss  -0x54(%rbp),%xmm0
mov    -0x38(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  0x10(%rbp),%xmm0
divss  -0x54(%rbp),%xmm0
mov    -0x38(%rbp),%rax
movss  %xmm0,0x8(%rax)
mov    -0x30(%rbp),%rdi
mov    -0x38(%rbp),%rsi
mov    -0x40(%rbp),%rdx
call   1050 <ThreeByOne_OneByThree@plt>
mov    -0x40(%rbp),%rax
movss  (%rax),%xmm1
mov    -0x40(%rbp),%rax
movss  (%rax),%xmm2
mov    -0x40(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x40(%rbp),%rax
mulss  0x4(%rax),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x40(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x40(%rbp),%rax
movss  0x8(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
call   1060 <sqrt@plt>
movss  %xmm0,-0x5c(%rbp)
mov    -0x40(%rbp),%rax
movss  (%rax),%xmm0
divss  -0x5c(%rbp),%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x40(%rbp),%rax
movss  0x4(%rax),%xmm0
divss  -0x5c(%rbp),%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,0x4(%rax)
mov    -0x40(%rbp),%rax
movss  0x8(%rax),%xmm0
divss  -0x5c(%rbp),%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,0x8(%rax)
mov    -0x48(%rbp),%rdi
mov    -0x30(%rbp),%rsi
mov    -0x50(%rbp),%rdx
call   1050 <ThreeByOne_OneByThree@plt>
mov    -0x38(%rbp),%rdi
call   1030 <free@plt>
mov    -0x48(%rbp),%rdi
call   1030 <free@plt>
mov    -0x40(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x50(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,0x4(%rax)
mov    -0x30(%rbp),%rax
movss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xbed(%rip),%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,0x8(%rax)
mov    -0x28(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,0xc(%rax)
mov    -0x40(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,0x10(%rax)
mov    -0x50(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,0x14(%rax)
mov    -0x30(%rbp),%rax
movss  0x4(%rax),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xb97(%rip),%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,0x18(%rax)
mov    -0x28(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,0x1c(%rax)
mov    -0x40(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,0x20(%rax)
mov    -0x50(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,0x24(%rax)
mov    -0x30(%rbp),%rax
movss  0x8(%rax),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xb41(%rip),%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,0x28(%rax)
mov    -0x28(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,0x2c(%rax)
mov    -0x28(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,0x30(%rax)
mov    -0x28(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,0x34(%rax)
mov    -0x28(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,0x38(%rax)
mov    -0x28(%rbp),%rax
movss  0xaec(%rip),%xmm0
movss  %xmm0,0x3c(%rax)
mov    -0x30(%rbp),%rdi
call   1030 <free@plt>
mov    -0x50(%rbp),%rdi
call   1030 <free@plt>
mov    -0x40(%rbp),%rdi
call   1030 <free@plt>
mov    -0x28(%rbp),%rax
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<LookAtReplacement>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
movss  %xmm7,0xc(%rsp)
movss  %xmm6,0x8(%rsp)
movss  %xmm5,0x14(%rsp)
movss  %xmm4,0x20(%rsp)
movss  %xmm3,0x18(%rsp)
movss  %xmm2,0x24(%rsp)
movss  %xmm1,0x1c(%rsp)
movss  %xmm0,0x10(%rsp)
mov    $0x4,%edi
mov    $0x10,%esi
call   1040 <calloc@plt>
mov    %rax,%r14
mov    $0x4,%edi
mov    $0x3,%esi
call   1040 <calloc@plt>
mov    %rax,%rbx
mov    $0x4,%edi
mov    $0x3,%esi
call   1040 <calloc@plt>
mov    %rax,%r13
mov    $0x4,%edi
mov    $0x3,%esi
call   1040 <calloc@plt>
mov    %rax,%r15
mov    $0x4,%edi
mov    $0x3,%esi
call   1040 <calloc@plt>
mov    %rax,%rbp
mov    $0x4,%edi
mov    $0x3,%esi
call   1040 <calloc@plt>
movss  0x14(%rsp),%xmm0
mov    %rax,%r12
movss  0x18(%rsp),%xmm1
subss  0x10(%rsp),%xmm1
movss  %xmm1,(%rbx)
movss  0x20(%rsp),%xmm2
subss  0x1c(%rsp),%xmm2
movss  %xmm2,0x4(%rbx)
subss  0x24(%rsp),%xmm0
movss  %xmm0,0x8(%rbx)
mulss  %xmm2,%xmm2
mulss  %xmm1,%xmm1
addss  %xmm2,%xmm1
mulss  %xmm0,%xmm0
addss  %xmm1,%xmm0
xorps  %xmm3,%xmm3
ucomiss %xmm3,%xmm0
jb     123e <LookAtReplacement+0xfe>
sqrtss %xmm0,%xmm0
jmp    1246 <LookAtReplacement+0x106>
call   1060 <sqrt@plt>
xorps  %xmm3,%xmm3
movss  (%rbx),%xmm1
movss  0x4(%rbx),%xmm2
divss  %xmm0,%xmm1
movss  %xmm1,(%rbx)
divss  %xmm0,%xmm2
movss  %xmm2,0x4(%rbx)
movss  0x8(%rbx),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,0x8(%rbx)
movss  0xc(%rsp),%xmm0
mulss  %xmm0,%xmm0
movss  0x8(%rsp),%xmm1
mulss  %xmm1,%xmm1
addss  %xmm0,%xmm1
movss  0x60(%rsp),%xmm0
mulss  %xmm0,%xmm0
addss  %xmm1,%xmm0
ucomiss %xmm3,%xmm0
jb     129f <LookAtReplacement+0x15f>
sqrtss %xmm0,%xmm0
jmp    12a4 <LookAtReplacement+0x164>
call   1060 <sqrt@plt>
movss  0x8(%rsp),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,0x0(%r13)
movss  0xc(%rsp),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,0x4(%r13)
movss  0x60(%rsp),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,0x8(%r13)
mov    %rbx,%rdi
mov    %r13,%rsi
mov    %r15,%rdx
call   1050 <ThreeByOne_OneByThree@plt>
movss  (%r15),%xmm1
movss  0x4(%r15),%xmm0
mulss  %xmm0,%xmm0
mulss  %xmm1,%xmm1
addss  %xmm0,%xmm1
movss  0x8(%r15),%xmm0
mulss  %xmm0,%xmm0
addss  %xmm1,%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jb     1315 <LookAtReplacement+0x1d5>
sqrtss %xmm0,%xmm0
jmp    131a <LookAtReplacement+0x1da>
call   1060 <sqrt@plt>
movss  (%r15),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,0x0(%rbp)
movss  0x4(%r15),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,0x4(%rbp)
movss  0x8(%r15),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,0x8(%rbp)
mov    %rbp,%rdi
mov    %rbx,%rsi
mov    %r12,%rdx
call   1050 <ThreeByOne_OneByThree@plt>
mov    %r13,%rdi
call   1030 <free@plt>
mov    %rbp,%rdi
call   1030 <free@plt>
movss  (%r15),%xmm0
movss  %xmm0,(%r14)
movss  (%r12),%xmm0
movss  %xmm0,0x4(%r14)
movss  (%rbx),%xmm0
movaps 0xc7b(%rip),%xmm1
xorps  %xmm1,%xmm0
movss  %xmm0,0x8(%r14)
movl   $0x0,0xc(%r14)
movss  0x4(%r15),%xmm0
movss  %xmm0,0x10(%r14)
movss  0x4(%r12),%xmm0
movss  %xmm0,0x14(%r14)
movss  0x4(%rbx),%xmm0
xorps  %xmm1,%xmm0
movss  %xmm0,0x18(%r14)
movl   $0x0,0x1c(%r14)
movss  0x8(%r15),%xmm0
movss  %xmm0,0x20(%r14)
movss  0x8(%r12),%xmm0
movss  %xmm0,0x24(%r14)
movss  0x8(%rbx),%xmm0
xorps  %xmm1,%xmm0
movss  %xmm0,0x28(%r14)
xorps  %xmm0,%xmm0
movups %xmm0,0x2c(%r14)
movl   $0x3f800000,0x3c(%r14)
3f
mov    %rbx,%rdi
call   1030 <free@plt>
mov    %r12,%rdi
call   1030 <free@plt>
mov    %r15,%rdi
call   1030 <free@plt>
mov    %r14,%rax
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define float* @LookAtReplacement(float %0, float %1, float %2, float %3, float %4, float %5, float %6, float %7, float %8) {
%10 = tail call i64 @calloc(i32 4, i32 16)
%11 = inttoptr i64 %10 to float*
%12 = tail call i64 @calloc(i32 4, i32 3)
%13 = inttoptr i64 %12 to float*
%14 = tail call i64 @calloc(i32 4, i32 3)
%15 = inttoptr i64 %14 to float*
%16 = tail call i64 @calloc(i32 4, i32 3)
%17 = inttoptr i64 %16 to float*
%18 = tail call i64 @calloc(i32 4, i32 3)
%19 = inttoptr i64 %18 to float*
%20 = tail call i64 @calloc(i32 4, i32 3)
%21 = inttoptr i64 %20 to float*
%22 = fsub float %3, %0
store float %22, float* %13
%23 = fsub float %4, %1
%24 = getelementptr inbounds float, float* %13, i64 1
store float %23, float* %24
%25 = fsub float %5, %2
%26 = getelementptr inbounds float, float* %13, i64 2
store float %25, float* %26
%27 = fmul float %23, %23
%28 = tail call float @llvm.fmuladd.f32(float %22, float %22, float %27)
%29 = tail call float @llvm.fmuladd.f32(float %25, float %25, float %28)
%30 = tail call float @sqrt(float %29)
%31 = load float, float* %13
%32 = fdiv float %31, %30
store float %32, float* %13
%33 = load float, float* %24
%34 = fdiv float %33, %30
store float %34, float* %24
%35 = load float, float* %26
%36 = fdiv float %35, %30
store float %36, float* %26
%37 = fmul float %7, %7
%38 = tail call float @llvm.fmuladd.f32(float %6, float %6, float %37)
%39 = tail call float @llvm.fmuladd.f32(float %8, float %8, float %38)
%40 = tail call float @sqrt(float %39)
%41 = fdiv float %6, %40
store float %41, float* %15
%42 = fdiv float %7, %40
%43 = getelementptr inbounds float, float* %15, i64 1
store float %42, float* %43
%44 = fdiv float %8, %40
%45 = getelementptr inbounds float, float* %15, i64 2
store float %44, float* %45
%46 = tail call i32 @ThreeByOne_OneByThree(float* %13, float* %15, float* %17)
%47 = load float, float* %17
%48 = getelementptr inbounds float, float* %17, i64 1
%49 = load float, float* %48
%50 = fmul float %49, %49
%51 = tail call float @llvm.fmuladd.f32(float %47, float %47, float %50)
%52 = getelementptr inbounds float, float* %17, i64 2
%53 = load float, float* %52
%54 = tail call float @llvm.fmuladd.f32(float %53, float %53, float %51)
%55 = tail call float @sqrt(float %54)
%56 = load float, float* %17
%57 = fdiv float %56, %55
store float %57, float* %19
%58 = load float, float* %48
%59 = fdiv float %58, %55
%60 = getelementptr inbounds float, float* %19, i64 1
store float %59, float* %60
%61 = load float, float* %52
%62 = fdiv float %61, %55
%63 = getelementptr inbounds float, float* %19, i64 2
store float %62, float* %63
%64 = tail call i32 @ThreeByOne_OneByThree(float* %19, float* %13, float* %21)
%65 = tail call i32 @free(float* %15)
%66 = tail call i32 @free(float* %19)
%67 = load float, float* %17
store float %67, float* %11
%68 = load float, float* %21
%69 = getelementptr inbounds float, float* %11, i64 1
store float %68, float* %69
%70 = load float, float* %13
%71 = fneg float %70
%72 = getelementptr inbounds float, float* %11, i64 2
store float %71, float* %72
%73 = getelementptr inbounds float, float* %11, i64 3
store float 0.000000e+00, float* %73
%74 = load float, float* %48
%75 = getelementptr inbounds float, float* %11, i64 4
store float %74, float* %75
%76 = getelementptr inbounds float, float* %21, i64 1
%77 = load float, float* %76
%78 = getelementptr inbounds float, float* %11, i64 5
store float %77, float* %78
%79 = load float, float* %24
%80 = fneg float %79
%81 = getelementptr inbounds float, float* %11, i64 6
store float %80, float* %81
%82 = getelementptr inbounds float, float* %11, i64 7
store float 0.000000e+00, float* %82
%83 = load float, float* %52
%84 = getelementptr inbounds float, float* %11, i64 8
store float %83, float* %84
%85 = getelementptr inbounds float, float* %21, i64 2
%86 = load float, float* %85
%87 = getelementptr inbounds float, float* %11, i64 9
store float %86, float* %87
%88 = load float, float* %26
%89 = fneg float %88
%90 = getelementptr inbounds float, float* %11, i64 10
store float %89, float* %90
%91 = getelementptr inbounds float, float* %11, i64 11
%92 = getelementptr inbounds float, float* %11, i64 15
%93 = bitcast float* %91 to i8*
store float 1.000000e+00, float* %92
%94 = tail call i32 @free(float* %13)
%95 = tail call i32 @free(float* %21)
%96 = tail call i32 @free(float* %17)
ret float* %11
}