#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 */
int /*<<< orphan*/ matrix_translate(float *, float, float, float);
float sqrt(float);
void matrix_look_at(GLfloat m[], GLfloat eye_x, GLfloat eye_y, GLfloat eye_z,
                    GLfloat center_x, GLfloat center_y, GLfloat center_z,
                    GLfloat up_x, GLfloat up_y, GLfloat up_z) {
  GLfloat forward_x = center_x - eye_x;
  GLfloat forward_y = center_y - eye_y;
  GLfloat forward_z = center_z - eye_z;
  GLfloat norm_fw = 1.0f / sqrt(forward_x * forward_x + forward_y * forward_y +
                                forward_z * forward_z);
  forward_x *= norm_fw;
  forward_y *= norm_fw;
  forward_z *= norm_fw;
  GLfloat side_x_cp = forward_y * up_z - forward_z * up_y;
  GLfloat side_y_cp = forward_z * up_x - forward_x * up_z;
  GLfloat side_z_cp = forward_x * up_y - forward_y * up_x;
  GLfloat norm_s = 1.0f / sqrt(side_x_cp * side_x_cp + side_y_cp * side_y_cp +
                               side_z_cp * side_z_cp);
  side_x_cp *= norm_s;
  side_y_cp *= norm_s;
  side_z_cp *= norm_s;
  GLfloat ux = side_y_cp * forward_z - side_z_cp * forward_y;
  GLfloat uy = side_z_cp * forward_x - side_x_cp * forward_z;
  GLfloat uz = side_x_cp * forward_y - side_y_cp * forward_x;
  m[0] = side_x_cp;
  m[1] = ux;
  m[2] = -forward_x;
  m[3] = 0;
  m[4] = side_y_cp;
  m[5] = uy;
  m[6] = -forward_y;
  m[7] = 0;
  m[8] = side_z_cp;
  m[9] = uz;
  m[10] = -forward_z;
  m[11] = 0;
  m[12] = 0;
  m[13] = 0;
  m[14] = 0;
  m[15] = 1.0f;
  matrix_translate(m, -eye_x, -eye_y, -eye_z);
}


x86 assembly (clang, -O0):
<matrix_look_at>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
movss  0x10(%rbp),%xmm8
mov    %rdi,-0x8(%rbp)
movss  %xmm0,-0xc(%rbp)
movss  %xmm1,-0x10(%rbp)
movss  %xmm2,-0x14(%rbp)
movss  %xmm3,-0x18(%rbp)
movss  %xmm4,-0x1c(%rbp)
movss  %xmm5,-0x20(%rbp)
movss  %xmm6,-0x24(%rbp)
movss  %xmm7,-0x28(%rbp)
movss  -0x18(%rbp),%xmm0
subss  -0xc(%rbp),%xmm0
movss  %xmm0,-0x2c(%rbp)
movss  -0x1c(%rbp),%xmm0
subss  -0x10(%rbp),%xmm0
movss  %xmm0,-0x30(%rbp)
movss  -0x20(%rbp),%xmm0
subss  -0x14(%rbp),%xmm0
movss  %xmm0,-0x34(%rbp)
movss  -0x2c(%rbp),%xmm1
movss  -0x2c(%rbp),%xmm2
movss  -0x30(%rbp),%xmm0
mulss  -0x30(%rbp),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x34(%rbp),%xmm0
movss  -0x34(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
call   1030 <sqrt@plt>
movaps %xmm0,%xmm1
movss  0xe3b(%rip),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,-0x38(%rbp)
movss  -0x38(%rbp),%xmm0
mulss  -0x2c(%rbp),%xmm0
movss  %xmm0,-0x2c(%rbp)
movss  -0x38(%rbp),%xmm0
mulss  -0x30(%rbp),%xmm0
movss  %xmm0,-0x30(%rbp)
movss  -0x38(%rbp),%xmm0
mulss  -0x34(%rbp),%xmm0
movss  %xmm0,-0x34(%rbp)
movss  -0x30(%rbp),%xmm0
movss  0x10(%rbp),%xmm2
movss  -0x34(%rbp),%xmm1
mulss  -0x28(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  -0x34(%rbp),%xmm0
movss  -0x24(%rbp),%xmm2
movss  -0x2c(%rbp),%xmm1
mulss  0x10(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x2c(%rbp),%xmm0
movss  -0x28(%rbp),%xmm2
movss  -0x30(%rbp),%xmm1
mulss  -0x24(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x3c(%rbp),%xmm1
movss  -0x3c(%rbp),%xmm2
movss  -0x40(%rbp),%xmm0
mulss  -0x40(%rbp),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x44(%rbp),%xmm0
movss  -0x44(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
call   1030 <sqrt@plt>
movaps %xmm0,%xmm1
movss  0xd3d(%rip),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x48(%rbp),%xmm0
mulss  -0x3c(%rbp),%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  -0x48(%rbp),%xmm0
mulss  -0x40(%rbp),%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x48(%rbp),%xmm0
mulss  -0x44(%rbp),%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x40(%rbp),%xmm0
movss  -0x34(%rbp),%xmm2
movss  -0x44(%rbp),%xmm1
mulss  -0x30(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x44(%rbp),%xmm0
movss  -0x2c(%rbp),%xmm2
movss  -0x3c(%rbp),%xmm1
mulss  -0x34(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x3c(%rbp),%xmm0
movss  -0x30(%rbp),%xmm2
movss  -0x40(%rbp),%xmm1
mulss  -0x2c(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x3c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x4c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x2c(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x8(%rax)
mov    -0x8(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,0xc(%rax)
movss  -0x40(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x10(%rax)
movss  -0x50(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x14(%rax)
movss  -0x30(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x18(%rax)
mov    -0x8(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,0x1c(%rax)
movss  -0x44(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x20(%rax)
movss  -0x54(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x24(%rax)
movss  -0x34(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%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  0xb85(%rip),%xmm0
movss  %xmm0,0x3c(%rax)
mov    -0x8(%rbp),%rdi
movss  -0xc(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  -0x10(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
movss  -0x14(%rbp),%xmm2
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm2
call   1040 <matrix_translate@plt>
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<matrix_look_at>:
push   %rbx
sub    $0xc0,%rsp
mov    %rdi,%rbx
movss  0xd0(%rsp),%xmm14
movaps %xmm0,0x90(%rsp)
subss  %xmm0,%xmm3
movaps %xmm1,0xa0(%rsp)
subss  %xmm1,%xmm4
movaps %xmm2,0xb0(%rsp)
subss  %xmm2,%xmm5
movaps %xmm4,%xmm0
mulss  %xmm4,%xmm0
movaps %xmm3,%xmm1
mulss  %xmm3,%xmm1
addss  %xmm0,%xmm1
movaps %xmm5,%xmm0
mulss  %xmm5,%xmm0
addss  %xmm1,%xmm0
xorps  %xmm2,%xmm2
ucomiss %xmm2,%xmm0
jb     1184 <matrix_look_at+0x64>
sqrtss %xmm0,%xmm0
jmp    11d0 <matrix_look_at+0xb0>
movaps %xmm3,0x50(%rsp)
movaps %xmm5,0x40(%rsp)
movaps %xmm4,0x30(%rsp)
movss  %xmm7,0xc(%rsp)
movss  %xmm6,0x20(%rsp)
movss  %xmm14,0x10(%rsp)
call   1030 <sqrt@plt>
movss  0x10(%rsp),%xmm14
xorps  %xmm2,%xmm2
movss  0x20(%rsp),%xmm6
movss  0xc(%rsp),%xmm7
movaps 0x30(%rsp),%xmm4
movaps 0x40(%rsp),%xmm5
movaps 0x50(%rsp),%xmm3
movss  0xe27(%rip),%xmm8
movaps %xmm8,%xmm1
divss  %xmm0,%xmm1
mulss  %xmm1,%xmm3
mulss  %xmm1,%xmm4
mulss  %xmm1,%xmm5
movaps 0xe1b(%rip),%xmm10
movaps %xmm5,%xmm9
xorps  %xmm10,%xmm9
movaps %xmm5,%xmm0
mulss  %xmm7,%xmm0
movaps %xmm4,%xmm11
mulss  %xmm14,%xmm11
subss  %xmm0,%xmm11
movaps %xmm3,%xmm12
xorps  %xmm10,%xmm12
mulss  %xmm3,%xmm14
movaps %xmm5,%xmm13
mulss  %xmm6,%xmm13
subss  %xmm14,%xmm13
movaps %xmm4,%xmm14
xorps  %xmm10,%xmm14
mulss  %xmm4,%xmm6
mulss  %xmm3,%xmm7
subss  %xmm6,%xmm7
movaps %xmm13,%xmm0
mulss  %xmm13,%xmm0
movaps %xmm11,%xmm1
mulss  %xmm11,%xmm1
addss  %xmm0,%xmm1
movaps %xmm7,%xmm0
mulss  %xmm7,%xmm0
addss  %xmm1,%xmm0
ucomiss %xmm2,%xmm0
jb     1270 <matrix_look_at+0x150>
sqrtss %xmm0,%xmm0
jmp    12f2 <matrix_look_at+0x1d2>
movaps %xmm3,0x50(%rsp)
movaps %xmm5,0x40(%rsp)
movaps %xmm4,0x30(%rsp)
movss  %xmm7,0xc(%rsp)
movaps %xmm9,0x20(%rsp)
movaps %xmm11,0x10(%rsp)
movaps %xmm12,0x80(%rsp)
movaps %xmm13,0x70(%rsp)
movaps %xmm14,0x60(%rsp)
call   1030 <sqrt@plt>
movaps 0x60(%rsp),%xmm14
movaps 0x70(%rsp),%xmm13
movaps 0x80(%rsp),%xmm12
movaps 0x10(%rsp),%xmm11
movaps 0x20(%rsp),%xmm9
movss  0xd2b(%rip),%xmm8
movaps 0xd33(%rip),%xmm10
movss  0xc(%rsp),%xmm7
movaps 0x30(%rsp),%xmm4
movaps 0x40(%rsp),%xmm5
movaps 0x50(%rsp),%xmm3
divss  %xmm0,%xmm8
mulss  %xmm8,%xmm11
mulss  %xmm8,%xmm13
mulss  %xmm7,%xmm8
movaps %xmm11,%xmm0
mulss  %xmm4,%xmm0
mulss  %xmm8,%xmm4
movaps %xmm13,%xmm1
mulss  %xmm5,%xmm1
subss  %xmm4,%xmm1
mulss  %xmm11,%xmm5
movaps %xmm8,%xmm2
mulss  %xmm3,%xmm2
subss  %xmm5,%xmm2
mulss  %xmm13,%xmm3
subss  %xmm3,%xmm0
movss  %xmm11,(%rbx)
movss  %xmm1,0x4(%rbx)
movss  %xmm12,0x8(%rbx)
movl   $0x0,0xc(%rbx)
movss  %xmm13,0x10(%rbx)
movss  %xmm2,0x14(%rbx)
movss  %xmm14,0x18(%rbx)
movl   $0x0,0x1c(%rbx)
movss  %xmm8,0x20(%rbx)
movss  %xmm0,0x24(%rbx)
movss  %xmm9,0x28(%rbx)
xorps  %xmm0,%xmm0
movups %xmm0,0x2c(%rbx)
movl   $0x3f800000,0x3c(%rbx)
movaps 0x90(%rsp),%xmm0
xorps  %xmm10,%xmm0
movaps 0xa0(%rsp),%xmm1
xorps  %xmm10,%xmm1
movaps 0xb0(%rsp),%xmm2
xorps  %xmm10,%xmm2
mov    %rbx,%rdi
add    $0xc0,%rsp
pop    %rbx
jmp    1040 <matrix_translate@plt>

LLVM IR (-O0):
define void @matrix_look_at(float* %0, float %1, float %2, float %3, float %4, float %5, float %6, float %7, float %8, float %9) {
%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
%28 = alloca float
%29 = alloca float
%30 = alloca float
%31 = alloca float
store float* %0, float** %11
store float %1, float* %12
store float %2, float* %13
store float %3, float* %14
store float %4, float* %15
store float %5, float* %16
store float %6, float* %17
store float %7, float* %18
store float %8, float* %19
store float %9, float* %20
%32 = load float, float* %15
%33 = load float, float* %12
%34 = fsub float %32, %33
store float %34, float* %21
%35 = load float, float* %16
%36 = load float, float* %13
%37 = fsub float %35, %36
store float %37, float* %22
%38 = load float, float* %17
%39 = load float, float* %14
%40 = fsub float %38, %39
store float %40, float* %23
%41 = load float, float* %21
%42 = load float, float* %21
%43 = load float, float* %22
%44 = load float, float* %22
%45 = fmul float %43, %44
%46 = call float @llvm.fmuladd.f32(float %41, float %42, float %45)
%47 = load float, float* %23
%48 = load float, float* %23
%49 = call float @llvm.fmuladd.f32(float %47, float %48, float %46)
%50 = call float @sqrt(float %49)
%51 = fdiv float 1.000000e+00, %50
store float %51, float* %24
%52 = load float, float* %24
%53 = load float, float* %21
%54 = fmul float %53, %52
store float %54, float* %21
%55 = load float, float* %24
%56 = load float, float* %22
%57 = fmul float %56, %55
store float %57, float* %22
%58 = load float, float* %24
%59 = load float, float* %23
%60 = fmul float %59, %58
store float %60, float* %23
%61 = load float, float* %22
%62 = load float, float* %20
%63 = load float, float* %23
%64 = load float, float* %19
%65 = fmul float %63, %64
%66 = fneg float %65
%67 = call float @llvm.fmuladd.f32(float %61, float %62, float %66)
store float %67, float* %25
%68 = load float, float* %23
%69 = load float, float* %18
%70 = load float, float* %21
%71 = load float, float* %20
%72 = fmul float %70, %71
%73 = fneg float %72
%74 = call float @llvm.fmuladd.f32(float %68, float %69, float %73)
store float %74, float* %26
%75 = load float, float* %21
%76 = load float, float* %19
%77 = load float, float* %22
%78 = load float, float* %18
%79 = fmul float %77, %78
%80 = fneg float %79
%81 = call float @llvm.fmuladd.f32(float %75, float %76, float %80)
store float %81, float* %27
%82 = load float, float* %25
%83 = load float, float* %25
%84 = load float, float* %26
%85 = load float, float* %26
%86 = fmul float %84, %85
%87 = call float @llvm.fmuladd.f32(float %82, float %83, float %86)
%88 = load float, float* %27
%89 = load float, float* %27
%90 = call float @llvm.fmuladd.f32(float %88, float %89, float %87)
%91 = call float @sqrt(float %90)
%92 = fdiv float 1.000000e+00, %91
store float %92, float* %28
%93 = load float, float* %28
%94 = load float, float* %25
%95 = fmul float %94, %93
store float %95, float* %25
%96 = load float, float* %28
%97 = load float, float* %26
%98 = fmul float %97, %96
store float %98, float* %26
%99 = load float, float* %28
%100 = load float, float* %27
%101 = fmul float %100, %99
store float %101, float* %27
%102 = load float, float* %26
%103 = load float, float* %23
%104 = load float, float* %27
%105 = load float, float* %22
%106 = fmul float %104, %105
%107 = fneg float %106
%108 = call float @llvm.fmuladd.f32(float %102, float %103, float %107)
store float %108, float* %29
%109 = load float, float* %27
%110 = load float, float* %21
%111 = load float, float* %25
%112 = load float, float* %23
%113 = fmul float %111, %112
%114 = fneg float %113
%115 = call float @llvm.fmuladd.f32(float %109, float %110, float %114)
store float %115, float* %30
%116 = load float, float* %25
%117 = load float, float* %22
%118 = load float, float* %26
%119 = load float, float* %21
%120 = fmul float %118, %119
%121 = fneg float %120
%122 = call float @llvm.fmuladd.f32(float %116, float %117, float %121)
store float %122, float* %31
%123 = load float, float* %25
%124 = load float*, float** %11
%125 = getelementptr inbounds float, float* %124, i64 0
store float %123, float* %125
%126 = load float, float* %29
%127 = load float*, float** %11
%128 = getelementptr inbounds float, float* %127, i64 1
store float %126, float* %128
%129 = load float, float* %21
%130 = fneg float %129
%131 = load float*, float** %11
%132 = getelementptr inbounds float, float* %131, i64 2
store float %130, float* %132
%133 = load float*, float** %11
%134 = getelementptr inbounds float, float* %133, i64 3
store float 0.000000e+00, float* %134
%135 = load float, float* %26
%136 = load float*, float** %11
%137 = getelementptr inbounds float, float* %136, i64 4
store float %135, float* %137
%138 = load float, float* %30
%139 = load float*, float** %11
%140 = getelementptr inbounds float, float* %139, i64 5
store float %138, float* %140
%141 = load float, float* %22
%142 = fneg float %141
%143 = load float*, float** %11
%144 = getelementptr inbounds float, float* %143, i64 6
store float %142, float* %144
%145 = load float*, float** %11
%146 = getelementptr inbounds float, float* %145, i64 7
store float 0.000000e+00, float* %146
%147 = load float, float* %27
%148 = load float*, float** %11
%149 = getelementptr inbounds float, float* %148, i64 8
store float %147, float* %149
%150 = load float, float* %31
%151 = load float*, float** %11
%152 = getelementptr inbounds float, float* %151, i64 9
store float %150, float* %152
%153 = load float, float* %23
%154 = fneg float %153
%155 = load float*, float** %11
%156 = getelementptr inbounds float, float* %155, i64 10
store float %154, float* %156
%157 = load float*, float** %11
%158 = getelementptr inbounds float, float* %157, i64 11
store float 0.000000e+00, float* %158
%159 = load float*, float** %11
%160 = getelementptr inbounds float, float* %159, i64 12
store float 0.000000e+00, float* %160
%161 = load float*, float** %11
%162 = getelementptr inbounds float, float* %161, i64 13
store float 0.000000e+00, float* %162
%163 = load float*, float** %11
%164 = getelementptr inbounds float, float* %163, i64 14
store float 0.000000e+00, float* %164
%165 = load float*, float** %11
%166 = getelementptr inbounds float, float* %165, i64 15
store float 1.000000e+00, float* %166
%167 = load float*, float** %11
%168 = load float, float* %12
%169 = fneg float %168
%170 = load float, float* %13
%171 = fneg float %170
%172 = load float, float* %14
%173 = fneg float %172
%174 = call i32 @matrix_translate(float* %167, float %169, float %171, float %173)
ret void
}

LLVM IR (-O2):
define void @matrix_look_at(float* %0, float %1, float %2, float %3, float %4, float %5, float %6, float %7, float %8, float %9) {
%11 = fsub float %4, %1
%12 = fsub float %5, %2
%13 = fsub float %6, %3
%14 = fmul float %12, %12
%15 = tail call float @llvm.fmuladd.f32(float %11, float %11, float %14)
%16 = tail call float @llvm.fmuladd.f32(float %13, float %13, float %15)
%17 = tail call float @sqrt(float %16)
%18 = fdiv float 1.000000e+00, %17
%19 = fmul float %11, %18
%20 = fmul float %12, %18
%21 = fmul float %13, %18
%22 = fneg float %21
%23 = fmul float %22, %8
%24 = tail call float @llvm.fmuladd.f32(float %20, float %9, float %23)
%25 = fneg float %19
%26 = fmul float %25, %9
%27 = tail call float @llvm.fmuladd.f32(float %21, float %7, float %26)
%28 = fneg float %20
%29 = fmul float %28, %7
%30 = tail call float @llvm.fmuladd.f32(float %19, float %8, float %29)
%31 = fmul float %27, %27
%32 = tail call float @llvm.fmuladd.f32(float %24, float %24, float %31)
%33 = tail call float @llvm.fmuladd.f32(float %30, float %30, float %32)
%34 = tail call float @sqrt(float %33)
%35 = fdiv float 1.000000e+00, %34
%36 = fmul float %35, %24
%37 = fmul float %35, %27
%38 = fmul float %35, %30
%39 = fneg float %38
%40 = fmul float %20, %39
%41 = tail call float @llvm.fmuladd.f32(float %37, float %21, float %40)
%42 = fneg float %36
%43 = fmul float %21, %42
%44 = tail call float @llvm.fmuladd.f32(float %38, float %19, float %43)
%45 = fneg float %37
%46 = fmul float %19, %45
%47 = tail call float @llvm.fmuladd.f32(float %36, float %20, float %46)
store float %36, float* %0
%48 = getelementptr inbounds float, float* %0, i64 1
store float %41, float* %48
%49 = getelementptr inbounds float, float* %0, i64 2
store float %25, float* %49
%50 = getelementptr inbounds float, float* %0, i64 3
store float 0.000000e+00, float* %50
%51 = getelementptr inbounds float, float* %0, i64 4
store float %37, float* %51
%52 = getelementptr inbounds float, float* %0, i64 5
store float %44, float* %52
%53 = getelementptr inbounds float, float* %0, i64 6
store float %28, float* %53
%54 = getelementptr inbounds float, float* %0, i64 7
store float 0.000000e+00, float* %54
%55 = getelementptr inbounds float, float* %0, i64 8
store float %38, float* %55
%56 = getelementptr inbounds float, float* %0, i64 9
store float %47, float* %56
%57 = getelementptr inbounds float, float* %0, i64 10
store float %22, float* %57
%58 = getelementptr inbounds float, float* %0, i64 11
%59 = getelementptr inbounds float, float* %0, i64 15
%60 = bitcast float* %58 to i8*
store float 1.000000e+00, float* %59
%61 = fneg float %1
%62 = fneg float %2
%63 = fneg float %3
%64 = tail call i32 @matrix_translate(float* %0, float %61, float %62, float %63)
ret void
}