#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*/ glmMultMatrix4f(float *, float const *, float const *);
float glmNormalizeVector3f(float *);
void glmExtractFrustumf(float frustum[6][4], const float view[16],
                        const float proj[16]) {
  float clip[16];
  float t;
  glmMultMatrix4f(clip, proj, view);
  frustum[0][0] = clip[3] - clip[0];
  frustum[0][1] = clip[7] - clip[4];
  frustum[0][2] = clip[11] - clip[8];
  frustum[0][3] = clip[15] - clip[12];
  t = glmNormalizeVector3f(frustum[0]);
  frustum[0][3] /= t;
  frustum[1][0] = clip[3] + clip[0];
  frustum[1][1] = clip[7] + clip[4];
  frustum[1][2] = clip[11] + clip[8];
  frustum[1][3] = clip[15] + clip[12];
  t = glmNormalizeVector3f(frustum[1]);
  frustum[1][3] /= t;
  frustum[2][0] = clip[3] + clip[1];
  frustum[2][1] = clip[7] + clip[5];
  frustum[2][2] = clip[11] + clip[9];
  frustum[2][3] = clip[15] + clip[13];
  t = glmNormalizeVector3f(frustum[2]);
  frustum[2][3] /= t;
  frustum[3][0] = clip[3] - clip[1];
  frustum[3][1] = clip[7] - clip[5];
  frustum[3][2] = clip[11] - clip[9];
  frustum[3][3] = clip[15] - clip[13];
  t = glmNormalizeVector3f(frustum[3]);
  frustum[3][3] /= t;
  frustum[4][0] = clip[3] - clip[2];
  frustum[4][1] = clip[7] - clip[6];
  frustum[4][2] = clip[11] - clip[10];
  frustum[4][3] = clip[15] - clip[14];
  t = glmNormalizeVector3f(frustum[4]);
  frustum[4][3] /= t;
  frustum[5][0] = clip[3] + clip[2];
  frustum[5][1] = clip[7] + clip[6];
  frustum[5][2] = clip[11] + clip[10];
  frustum[5][3] = clip[15] + clip[14];
  t = glmNormalizeVector3f(frustum[5]);
  frustum[5][3] /= t;
}


x86 assembly (clang, -O0):
<glmExtractFrustumf>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
lea    -0x60(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x10(%rbp),%rdx
call   1040 <glmMultMatrix4f@plt>
movss  -0x54(%rbp),%xmm0
subss  -0x60(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x44(%rbp),%xmm0
subss  -0x50(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x34(%rbp),%xmm0
subss  -0x40(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x8(%rax)
movss  -0x24(%rbp),%xmm0
subss  -0x30(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0xc(%rax)
mov    -0x8(%rbp),%rdi
call   1030 <glmNormalizeVector3f@plt>
movss  %xmm0,-0x64(%rbp)
movss  -0x64(%rbp),%xmm1
mov    -0x8(%rbp),%rax
movss  0xc(%rax),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,0xc(%rax)
movss  -0x54(%rbp),%xmm0
addss  -0x60(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x10(%rax)
movss  -0x44(%rbp),%xmm0
addss  -0x50(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x14(%rax)
movss  -0x34(%rbp),%xmm0
addss  -0x40(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x18(%rax)
movss  -0x24(%rbp),%xmm0
addss  -0x30(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x1c(%rax)
mov    -0x8(%rbp),%rdi
add    $0x10,%rdi
call   1030 <glmNormalizeVector3f@plt>
movss  %xmm0,-0x64(%rbp)
movss  -0x64(%rbp),%xmm1
mov    -0x8(%rbp),%rax
movss  0x1c(%rax),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,0x1c(%rax)
movss  -0x54(%rbp),%xmm0
addss  -0x5c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x20(%rax)
movss  -0x44(%rbp),%xmm0
addss  -0x4c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x24(%rax)
movss  -0x34(%rbp),%xmm0
addss  -0x3c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x28(%rax)
movss  -0x24(%rbp),%xmm0
addss  -0x2c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x2c(%rax)
mov    -0x8(%rbp),%rdi
add    $0x20,%rdi
call   1030 <glmNormalizeVector3f@plt>
movss  %xmm0,-0x64(%rbp)
movss  -0x64(%rbp),%xmm1
mov    -0x8(%rbp),%rax
movss  0x2c(%rax),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,0x2c(%rax)
movss  -0x54(%rbp),%xmm0
subss  -0x5c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x30(%rax)
movss  -0x44(%rbp),%xmm0
subss  -0x4c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x34(%rax)
movss  -0x34(%rbp),%xmm0
subss  -0x3c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x38(%rax)
movss  -0x24(%rbp),%xmm0
subss  -0x2c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x3c(%rax)
mov    -0x8(%rbp),%rdi
add    $0x30,%rdi
call   1030 <glmNormalizeVector3f@plt>
movss  %xmm0,-0x64(%rbp)
movss  -0x64(%rbp),%xmm1
mov    -0x8(%rbp),%rax
movss  0x3c(%rax),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,0x3c(%rax)
movss  -0x54(%rbp),%xmm0
subss  -0x58(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x40(%rax)
movss  -0x44(%rbp),%xmm0
subss  -0x48(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x44(%rax)
movss  -0x34(%rbp),%xmm0
subss  -0x38(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x48(%rax)
movss  -0x24(%rbp),%xmm0
subss  -0x28(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x4c(%rax)
mov    -0x8(%rbp),%rdi
add    $0x40,%rdi
call   1030 <glmNormalizeVector3f@plt>
movss  %xmm0,-0x64(%rbp)
movss  -0x64(%rbp),%xmm1
mov    -0x8(%rbp),%rax
movss  0x4c(%rax),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,0x4c(%rax)
movss  -0x54(%rbp),%xmm0
addss  -0x58(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x50(%rax)
movss  -0x44(%rbp),%xmm0
addss  -0x48(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x54(%rax)
movss  -0x34(%rbp),%xmm0
addss  -0x38(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x58(%rax)
movss  -0x24(%rbp),%xmm0
addss  -0x28(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x5c(%rax)
mov    -0x8(%rbp),%rdi
add    $0x50,%rdi
call   1030 <glmNormalizeVector3f@plt>
movss  %xmm0,-0x64(%rbp)
movss  -0x64(%rbp),%xmm1
mov    -0x8(%rbp),%rax
movss  0x5c(%rax),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,0x5c(%rax)
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<glmExtractFrustumf>:
push   %rbx
sub    $0x40,%rsp
mov    %rsi,%rax
mov    %rdi,%rbx
mov    %rsp,%rdi
mov    %rdx,%rsi
mov    %rax,%rdx
call   1040 <glmMultMatrix4f@plt>
movss  0xc(%rsp),%xmm0
subss  (%rsp),%xmm0
movss  %xmm0,(%rbx)
movss  0x1c(%rsp),%xmm0
subss  0x10(%rsp),%xmm0
movss  %xmm0,0x4(%rbx)
movss  0x2c(%rsp),%xmm0
subss  0x20(%rsp),%xmm0
movss  %xmm0,0x8(%rbx)
movss  0x3c(%rsp),%xmm0
subss  0x30(%rsp),%xmm0
movss  %xmm0,0xc(%rbx)
mov    %rbx,%rdi
call   1030 <glmNormalizeVector3f@plt>
movss  0xc(%rbx),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,0xc(%rbx)
movss  0xc(%rsp),%xmm0
addss  (%rsp),%xmm0
lea    0x10(%rbx),%rdi
movss  %xmm0,0x10(%rbx)
movss  0x1c(%rsp),%xmm0
addss  0x10(%rsp),%xmm0
movss  %xmm0,0x14(%rbx)
movss  0x2c(%rsp),%xmm0
addss  0x20(%rsp),%xmm0
movss  %xmm0,0x18(%rbx)
movss  0x3c(%rsp),%xmm0
addss  0x30(%rsp),%xmm0
movss  %xmm0,0x1c(%rbx)
call   1030 <glmNormalizeVector3f@plt>
movss  0x1c(%rbx),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,0x1c(%rbx)
movss  0xc(%rsp),%xmm0
addss  0x4(%rsp),%xmm0
lea    0x20(%rbx),%rdi
movss  %xmm0,0x20(%rbx)
movss  0x1c(%rsp),%xmm0
addss  0x14(%rsp),%xmm0
movss  %xmm0,0x24(%rbx)
movss  0x2c(%rsp),%xmm0
addss  0x24(%rsp),%xmm0
movss  %xmm0,0x28(%rbx)
movss  0x3c(%rsp),%xmm0
addss  0x34(%rsp),%xmm0
movss  %xmm0,0x2c(%rbx)
call   1030 <glmNormalizeVector3f@plt>
movss  0x2c(%rbx),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,0x2c(%rbx)
movss  0xc(%rsp),%xmm0
subss  0x4(%rsp),%xmm0
lea    0x30(%rbx),%rdi
movss  %xmm0,0x30(%rbx)
movss  0x1c(%rsp),%xmm0
subss  0x14(%rsp),%xmm0
movss  %xmm0,0x34(%rbx)
movss  0x2c(%rsp),%xmm0
subss  0x24(%rsp),%xmm0
movss  %xmm0,0x38(%rbx)
movss  0x3c(%rsp),%xmm0
subss  0x34(%rsp),%xmm0
movss  %xmm0,0x3c(%rbx)
call   1030 <glmNormalizeVector3f@plt>
movss  0x3c(%rbx),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,0x3c(%rbx)
movss  0xc(%rsp),%xmm0
subss  0x8(%rsp),%xmm0
lea    0x40(%rbx),%rdi
movss  %xmm0,0x40(%rbx)
movss  0x1c(%rsp),%xmm0
subss  0x18(%rsp),%xmm0
movss  %xmm0,0x44(%rbx)
movss  0x2c(%rsp),%xmm0
subss  0x28(%rsp),%xmm0
movss  %xmm0,0x48(%rbx)
movss  0x3c(%rsp),%xmm0
subss  0x38(%rsp),%xmm0
movss  %xmm0,0x4c(%rbx)
call   1030 <glmNormalizeVector3f@plt>
movss  0x4c(%rbx),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,0x4c(%rbx)
movss  0xc(%rsp),%xmm0
addss  0x8(%rsp),%xmm0
lea    0x50(%rbx),%rdi
movss  %xmm0,0x50(%rbx)
movss  0x1c(%rsp),%xmm0
addss  0x18(%rsp),%xmm0
movss  %xmm0,0x54(%rbx)
movss  0x2c(%rsp),%xmm0
addss  0x28(%rsp),%xmm0
movss  %xmm0,0x58(%rbx)
movss  0x3c(%rsp),%xmm0
addss  0x38(%rsp),%xmm0
movss  %xmm0,0x5c(%rbx)
call   1030 <glmNormalizeVector3f@plt>
movss  0x5c(%rbx),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,0x5c(%rbx)
add    $0x40,%rsp
pop    %rbx
ret

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

LLVM IR (-O2):
define void @glmExtractFrustumf([4 x float]* %0, float* %1, float* %2) {
%4 = alloca [16 x float]
%5 = bitcast [16 x float]* %4 to i8*
%6 = getelementptr inbounds [16 x float], [16 x float]* %4, i64 0, i64 0
%7 = call i32 @glmMultMatrix4f(float* %6, float* %2, float* %1)
%8 = getelementptr inbounds [16 x float], [16 x float]* %4, i64 0, i64 3
%9 = load float, float* %8
%10 = load float, float* %6
%11 = fsub float %9, %10
%12 = getelementptr inbounds [4 x float], [4 x float]* %0, i64 0, i64 0
store float %11, float* %12
%13 = getelementptr inbounds [16 x float], [16 x float]* %4, i64 0, i64 7
%14 = load float, float* %13
%15 = getelementptr inbounds [16 x float], [16 x float]* %4, i64 0, i64 4
%16 = load float, float* %15
%17 = fsub float %14, %16
%18 = getelementptr inbounds [4 x float], [4 x float]* %0, i64 0, i64 1
store float %17, float* %18
%19 = getelementptr inbounds [16 x float], [16 x float]* %4, i64 0, i64 11
%20 = load float, float* %19
%21 = getelementptr inbounds [16 x float], [16 x float]* %4, i64 0, i64 8
%22 = load float, float* %21
%23 = fsub float %20, %22
%24 = getelementptr inbounds [4 x float], [4 x float]* %0, i64 0, i64 2
store float %23, float* %24
%25 = getelementptr inbounds [16 x float], [16 x float]* %4, i64 0, i64 15
%26 = load float, float* %25
%27 = getelementptr inbounds [16 x float], [16 x float]* %4, i64 0, i64 12
%28 = load float, float* %27
%29 = fsub float %26, %28
%30 = getelementptr inbounds [4 x float], [4 x float]* %0, i64 0, i64 3
store float %29, float* %30
%31 = call float @glmNormalizeVector3f(float* %12)
%32 = load float, float* %30
%33 = fdiv float %32, %31
store float %33, float* %30
%34 = load float, float* %8
%35 = load float, float* %6
%36 = fadd float %34, %35
%37 = getelementptr inbounds [4 x float], [4 x float]* %0, i64 1, i64 0
store float %36, float* %37
%38 = load float, float* %13
%39 = load float, float* %15
%40 = fadd float %38, %39
%41 = getelementptr inbounds [4 x float], [4 x float]* %0, i64 1, i64 1
store float %40, float* %41
%42 = load float, float* %19
%43 = load float, float* %21
%44 = fadd float %42, %43
%45 = getelementptr inbounds [4 x float], [4 x float]* %0, i64 1, i64 2
store float %44, float* %45
%46 = load float, float* %25
%47 = load float, float* %27
%48 = fadd float %46, %47
%49 = getelementptr inbounds [4 x float], [4 x float]* %0, i64 1, i64 3
store float %48, float* %49
%50 = call float @glmNormalizeVector3f(float* %37)
%51 = load float, float* %49
%52 = fdiv float %51, %50
store float %52, float* %49
%53 = load float, float* %8
%54 = getelementptr inbounds [16 x float], [16 x float]* %4, i64 0, i64 1
%55 = load float, float* %54
%56 = fadd float %53, %55
%57 = getelementptr inbounds [4 x float], [4 x float]* %0, i64 2, i64 0
store float %56, float* %57
%58 = load float, float* %13
%59 = getelementptr inbounds [16 x float], [16 x float]* %4, i64 0, i64 5
%60 = load float, float* %59
%61 = fadd float %58, %60
%62 = getelementptr inbounds [4 x float], [4 x float]* %0, i64 2, i64 1
store float %61, float* %62
%63 = load float, float* %19
%64 = getelementptr inbounds [16 x float], [16 x float]* %4, i64 0, i64 9
%65 = load float, float* %64
%66 = fadd float %63, %65
%67 = getelementptr inbounds [4 x float], [4 x float]* %0, i64 2, i64 2
store float %66, float* %67
%68 = load float, float* %25
%69 = getelementptr inbounds [16 x float], [16 x float]* %4, i64 0, i64 13
%70 = load float, float* %69
%71 = fadd float %68, %70
%72 = getelementptr inbounds [4 x float], [4 x float]* %0, i64 2, i64 3
store float %71, float* %72
%73 = call float @glmNormalizeVector3f(float* %57)
%74 = load float, float* %72
%75 = fdiv float %74, %73
store float %75, float* %72
%76 = load float, float* %8
%77 = load float, float* %54
%78 = fsub float %76, %77
%79 = getelementptr inbounds [4 x float], [4 x float]* %0, i64 3, i64 0
store float %78, float* %79
%80 = load float, float* %13
%81 = load float, float* %59
%82 = fsub float %80, %81
%83 = getelementptr inbounds [4 x float], [4 x float]* %0, i64 3, i64 1
store float %82, float* %83
%84 = load float, float* %19
%85 = load float, float* %64
%86 = fsub float %84, %85
%87 = getelementptr inbounds [4 x float], [4 x float]* %0, i64 3, i64 2
store float %86, float* %87
%88 = load float, float* %25
%89 = load float, float* %69
%90 = fsub float %88, %89
%91 = getelementptr inbounds [4 x float], [4 x float]* %0, i64 3, i64 3
store float %90, float* %91
%92 = call float @glmNormalizeVector3f(float* %79)
%93 = load float, float* %91
%94 = fdiv float %93, %92
store float %94, float* %91
%95 = load float, float* %8
%96 = getelementptr inbounds [16 x float], [16 x float]* %4, i64 0, i64 2
%97 = load float, float* %96
%98 = fsub float %95, %97
%99 = getelementptr inbounds [4 x float], [4 x float]* %0, i64 4, i64 0
store float %98, float* %99
%100 = load float, float* %13
%101 = getelementptr inbounds [16 x float], [16 x float]* %4, i64 0, i64 6
%102 = load float, float* %101
%103 = fsub float %100, %102
%104 = getelementptr inbounds [4 x float], [4 x float]* %0, i64 4, i64 1
store float %103, float* %104
%105 = load float, float* %19
%106 = getelementptr inbounds [16 x float], [16 x float]* %4, i64 0, i64 10
%107 = load float, float* %106
%108 = fsub float %105, %107
%109 = getelementptr inbounds [4 x float], [4 x float]* %0, i64 4, i64 2
store float %108, float* %109
%110 = load float, float* %25
%111 = getelementptr inbounds [16 x float], [16 x float]* %4, i64 0, i64 14
%112 = load float, float* %111
%113 = fsub float %110, %112
%114 = getelementptr inbounds [4 x float], [4 x float]* %0, i64 4, i64 3
store float %113, float* %114
%115 = call float @glmNormalizeVector3f(float* %99)
%116 = load float, float* %114
%117 = fdiv float %116, %115
store float %117, float* %114
%118 = load float, float* %8
%119 = load float, float* %96
%120 = fadd float %118, %119
%121 = getelementptr inbounds [4 x float], [4 x float]* %0, i64 5, i64 0
store float %120, float* %121
%122 = load float, float* %13
%123 = load float, float* %101
%124 = fadd float %122, %123
%125 = getelementptr inbounds [4 x float], [4 x float]* %0, i64 5, i64 1
store float %124, float* %125
%126 = load float, float* %19
%127 = load float, float* %106
%128 = fadd float %126, %127
%129 = getelementptr inbounds [4 x float], [4 x float]* %0, i64 5, i64 2
store float %128, float* %129
%130 = load float, float* %25
%131 = load float, float* %111
%132 = fadd float %130, %131
%133 = getelementptr inbounds [4 x float], [4 x float]* %0, i64 5, i64 3
store float %132, float* %133
%134 = call float @glmNormalizeVector3f(float* %121)
%135 = load float, float* %133
%136 = fdiv float %135, %134
store float %136, float* %133
ret void
}