#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 */
double cos(float);
int /*<<< orphan*/ glMultMatrixf(float *);
double sin(float);
scalar_t__ sqrt(float);
void myRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z) {
  GLfloat u[3], v[3], w[3], t[3];
  float length = (float)sqrt(x * x + y * y + z * z);
  w[0] = x / length;
  w[1] = y / length;
  w[2] = z / length;
  t[0] = w[0] < w[1] && w[0] < w[2] ? 1 : w[0];
  t[1] = w[1] < w[0] && w[1] < w[2] ? 1 : w[1];
  t[2] = w[2] <= w[0] && w[2] <= w[1] ? 1 : w[2];
  u[0] = t[1] * w[2] - t[2] * w[1];
  u[1] = t[2] * w[0] - t[0] * w[2];
  u[2] = t[0] * w[1] - t[1] * w[0];
  length = (float)sqrt(u[0] * u[0] + u[1] * u[1] + u[2] * u[2]);
  u[0] /= length;
  u[1] /= length;
  u[2] /= length;
  v[0] = w[1] * u[2] - w[2] * u[1];
  v[1] = w[2] * u[0] - w[0] * u[2];
  v[2] = w[0] * u[1] - w[1] * u[0];
  GLfloat A[16] = {u[0], u[1], u[2], 0.0, v[0], v[1], v[2], 0.0,
                   w[0], w[1], w[2], 0.0, 0.0,  0.0,  0.0,  1.0};
  angle = (float)(angle * (3.14159265358979323846 / 180));
  GLfloat B[16] = {cos(angle), sin(angle), 0.0, 0.0, -sin(angle), cos(angle),
                   0.0,        0.0,        0.0, 0.0, 1.0,         0.0,
                   0.0,        0.0,        0.0, 1.0};
  GLfloat C[16] = {u[0], v[0], w[0], 0.0, u[1], v[1], w[1], 0.0,
                   u[2], v[2], w[2], 0.0, 0.0,  0.0,  0.0,  1.0};
  glMultMatrixf(A);
  glMultMatrixf(B);
  glMultMatrixf(C);
}


x86 assembly (clang, -O0):
<myRotatef>:
push   %rbp
mov    %rsp,%rbp
sub    $0x120,%rsp
movss  %xmm0,-0x4(%rbp)
movss  %xmm1,-0x8(%rbp)
movss  %xmm2,-0xc(%rbp)
movss  %xmm3,-0x10(%rbp)
movss  -0x8(%rbp),%xmm1
movss  -0x8(%rbp),%xmm2
movss  -0xc(%rbp),%xmm0
mulss  -0xc(%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>
cvtsi2ss %rax,%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x8(%rbp),%xmm0
divss  -0x44(%rbp),%xmm0
movss  %xmm0,-0x34(%rbp)
movss  -0xc(%rbp),%xmm0
divss  -0x44(%rbp),%xmm0
movss  %xmm0,-0x30(%rbp)
movss  -0x10(%rbp),%xmm0
divss  -0x44(%rbp),%xmm0
movss  %xmm0,-0x2c(%rbp)
movss  -0x34(%rbp),%xmm1
movss  -0x30(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    1204 <myRotatef+0xc4>
movss  -0x34(%rbp),%xmm1
movss  -0x2c(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    1204 <myRotatef+0xc4>
movss  0xe09(%rip),%xmm0
movss  %xmm0,-0x114(%rbp)
ff
jmp    1211 <myRotatef+0xd1>
movss  -0x34(%rbp),%xmm0
movss  %xmm0,-0x114(%rbp)
ff
movss  -0x114(%rbp),%xmm0
ff
movss  %xmm0,-0x40(%rbp)
movss  -0x30(%rbp),%xmm1
movss  -0x34(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    1259 <myRotatef+0x119>
movss  -0x30(%rbp),%xmm1
movss  -0x2c(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    1259 <myRotatef+0x119>
movss  0xdb4(%rip),%xmm0
movss  %xmm0,-0x118(%rbp)
ff
jmp    1266 <myRotatef+0x126>
movss  -0x30(%rbp),%xmm0
movss  %xmm0,-0x118(%rbp)
ff
movss  -0x118(%rbp),%xmm0
ff
movss  %xmm0,-0x3c(%rbp)
movss  -0x2c(%rbp),%xmm1
movss  -0x34(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jb     12ae <myRotatef+0x16e>
movss  -0x2c(%rbp),%xmm1
movss  -0x30(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jb     12ae <myRotatef+0x16e>
movss  0xd5f(%rip),%xmm0
movss  %xmm0,-0x11c(%rbp)
ff
jmp    12bb <myRotatef+0x17b>
movss  -0x2c(%rbp),%xmm0
movss  %xmm0,-0x11c(%rbp)
ff
movss  -0x11c(%rbp),%xmm0
ff
movss  %xmm0,-0x38(%rbp)
movss  -0x3c(%rbp),%xmm0
movss  -0x2c(%rbp),%xmm2
movss  -0x38(%rbp),%xmm1
mulss  -0x30(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x1c(%rbp)
movss  -0x38(%rbp),%xmm0
movss  -0x34(%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,-0x18(%rbp)
movss  -0x40(%rbp),%xmm0
movss  -0x30(%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,-0x14(%rbp)
movss  -0x1c(%rbp),%xmm1
movss  -0x1c(%rbp),%xmm2
movss  -0x18(%rbp),%xmm0
mulss  -0x18(%rbp),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x14(%rbp),%xmm0
movss  -0x14(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
call   1060 <sqrt@plt>
cvtsi2ss %rax,%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x44(%rbp),%xmm1
movss  -0x1c(%rbp),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,-0x1c(%rbp)
movss  -0x44(%rbp),%xmm1
movss  -0x18(%rbp),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,-0x18(%rbp)
movss  -0x44(%rbp),%xmm1
movss  -0x14(%rbp),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,-0x14(%rbp)
movss  -0x30(%rbp),%xmm0
movss  -0x14(%rbp),%xmm2
movss  -0x2c(%rbp),%xmm1
mulss  -0x18(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x28(%rbp)
movss  -0x2c(%rbp),%xmm0
movss  -0x1c(%rbp),%xmm2
movss  -0x34(%rbp),%xmm1
mulss  -0x14(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x24(%rbp)
movss  -0x34(%rbp),%xmm0
movss  -0x18(%rbp),%xmm2
movss  -0x30(%rbp),%xmm1
mulss  -0x1c(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x20(%rbp)
movss  -0x1c(%rbp),%xmm0
movss  %xmm0,-0x90(%rbp)
ff
movss  -0x18(%rbp),%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
movss  -0x14(%rbp),%xmm0
movss  %xmm0,-0x88(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x28(%rbp),%xmm0
movss  %xmm0,-0x80(%rbp)
movss  -0x24(%rbp),%xmm0
movss  %xmm0,-0x7c(%rbp)
movss  -0x20(%rbp),%xmm0
movss  %xmm0,-0x78(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x34(%rbp),%xmm0
movss  %xmm0,-0x70(%rbp)
movss  -0x30(%rbp),%xmm0
movss  %xmm0,-0x6c(%rbp)
movss  -0x2c(%rbp),%xmm0
movss  %xmm0,-0x68(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x64(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x60(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x5c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x58(%rbp)
movss  0xb10(%rip),%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x4(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xb02(%rip),%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x4(%rbp)
movss  -0x4(%rbp),%xmm0
call   1050 <cos@plt>
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0xd0(%rbp)
ff
movss  -0x4(%rbp),%xmm0
call   1030 <sin@plt>
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0xcc(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0xc8(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0xc4(%rbp)
ff
movss  -0x4(%rbp),%xmm0
call   1030 <sin@plt>
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0xc0(%rbp)
ff
movss  -0x4(%rbp),%xmm0
call   1050 <cos@plt>
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0xbc(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0xb8(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0xb4(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0xb0(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0xac(%rbp)
ff
movss  0xa34(%rip),%xmm0
movss  %xmm0,-0xa8(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0xa4(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0xa0(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0x9c(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0x98(%rbp)
ff
movss  0x9f8(%rip),%xmm0
movss  %xmm0,-0x94(%rbp)
ff
movss  -0x1c(%rbp),%xmm0
movss  %xmm0,-0x110(%rbp)
ff
movss  -0x28(%rbp),%xmm0
movss  %xmm0,-0x10c(%rbp)
ff
movss  -0x34(%rbp),%xmm0
movss  %xmm0,-0x108(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0x104(%rbp)
ff
movss  -0x18(%rbp),%xmm0
movss  %xmm0,-0x100(%rbp)
ff
movss  -0x24(%rbp),%xmm0
movss  %xmm0,-0xfc(%rbp)
ff
movss  -0x30(%rbp),%xmm0
movss  %xmm0,-0xf8(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0xf4(%rbp)
ff
movss  -0x14(%rbp),%xmm0
movss  %xmm0,-0xf0(%rbp)
ff
movss  -0x20(%rbp),%xmm0
movss  %xmm0,-0xec(%rbp)
ff
movss  -0x2c(%rbp),%xmm0
movss  %xmm0,-0xe8(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0xe4(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0xe0(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0xdc(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0xd8(%rbp)
ff
movss  0x931(%rip),%xmm0
movss  %xmm0,-0xd4(%rbp)
ff
lea    -0x90(%rbp),%rdi
call   1040 <glMultMatrixf@plt>
lea    -0xd0(%rbp),%rdi
call   1040 <glMultMatrixf@plt>
lea    -0x110(%rbp),%rdi
call   1040 <glMultMatrixf@plt>
add    $0x120,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<myRotatef>:
sub    $0x168,%rsp
movaps %xmm3,0x30(%rsp)
movaps %xmm2,0x10(%rsp)
movaps %xmm1,0x20(%rsp)
movss  %xmm0,0xc(%rsp)
movaps %xmm2,%xmm0
mulss  %xmm2,%xmm0
movaps %xmm1,%xmm2
mulss  %xmm1,%xmm2
addss  %xmm0,%xmm2
movaps %xmm3,%xmm0
mulss  %xmm3,%xmm0
addss  %xmm2,%xmm0
call   1060 <sqrt@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
movaps 0x20(%rsp),%xmm3
divss  %xmm0,%xmm3
movaps 0x30(%rsp),%xmm2
unpcklps 0x10(%rsp),%xmm2
shufps $0x0,%xmm0,%xmm0
divps  %xmm0,%xmm2
movaps %xmm2,%xmm4
shufps $0x55,%xmm2,%xmm4
movaps %xmm3,%xmm1
cmpltss %xmm2,%xmm1
movaps %xmm2,%xmm5
movss  0xe46(%rip),%xmm0
movaps %xmm1,%xmm2
andps  %xmm0,%xmm2
andnps %xmm3,%xmm1
orps   %xmm2,%xmm1
movaps %xmm3,%xmm2
cmpltss %xmm4,%xmm2
andps  %xmm2,%xmm1
andnps %xmm3,%xmm2
movaps %xmm3,%xmm7
orps   %xmm1,%xmm2
movaps %xmm2,%xmm3
movaps %xmm4,%xmm1
cmpltss %xmm5,%xmm1
movaps %xmm1,%xmm2
andps  %xmm0,%xmm2
andnps %xmm4,%xmm1
orps   %xmm2,%xmm1
movaps %xmm4,%xmm2
cmpltss %xmm7,%xmm2
andps  %xmm2,%xmm1
andnps %xmm4,%xmm2
orps   %xmm1,%xmm2
movaps %xmm2,%xmm6
movaps %xmm5,%xmm1
cmpnless %xmm4,%xmm1
movaps %xmm1,%xmm2
movaps %xmm5,0x30(%rsp)
andps  %xmm5,%xmm2
andnps %xmm0,%xmm1
orps   %xmm2,%xmm1
movaps %xmm5,%xmm2
movaps %xmm7,0x20(%rsp)
cmpnless %xmm7,%xmm2
movaps %xmm2,%xmm0
andnps %xmm1,%xmm0
andps  %xmm5,%xmm2
orps   %xmm0,%xmm2
movaps %xmm4,%xmm0
movaps %xmm4,0xe0(%rsp)
mulss  %xmm2,%xmm0
movaps %xmm7,%xmm1
mulss  %xmm6,%xmm1
mulss  %xmm5,%xmm6
subss  %xmm0,%xmm6
movaps %xmm6,0x40(%rsp)
movaps %xmm5,%xmm0
mulss  %xmm3,%xmm0
mulss  %xmm7,%xmm2
subss  %xmm0,%xmm2
movaps %xmm2,0x50(%rsp)
mulss  %xmm4,%xmm3
subss  %xmm1,%xmm3
movaps %xmm3,0x10(%rsp)
movaps %xmm2,%xmm0
mulss  %xmm2,%xmm0
movaps %xmm6,%xmm1
mulss  %xmm6,%xmm1
addss  %xmm0,%xmm1
movaps %xmm3,%xmm0
mulss  %xmm3,%xmm0
addss  %xmm1,%xmm0
call   1060 <sqrt@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
movaps 0x40(%rsp),%xmm4
divss  %xmm0,%xmm4
movaps %xmm4,0x40(%rsp)
movaps 0x50(%rsp),%xmm1
divss  %xmm0,%xmm1
movaps 0x10(%rsp),%xmm5
divss  %xmm0,%xmm5
movaps %xmm1,%xmm0
movaps %xmm1,%xmm8
movaps 0x30(%rsp),%xmm3
mulss  %xmm3,%xmm0
movaps %xmm4,%xmm1
movaps 0xe0(%rsp),%xmm7
mulss  %xmm7,%xmm1
movaps %xmm7,%xmm2
mulss  %xmm5,%xmm2
subss  %xmm0,%xmm2
movaps %xmm2,%xmm9
movaps %xmm2,0x130(%rsp)
movaps %xmm5,%xmm0
movaps %xmm5,0x10(%rsp)
movaps 0x20(%rsp),%xmm2
mulss  %xmm2,%xmm0
movaps %xmm3,%xmm6
mulss  %xmm4,%xmm6
subss  %xmm0,%xmm6
movaps %xmm6,0x140(%rsp)
movaps %xmm2,%xmm0
movaps %xmm8,0x50(%rsp)
mulss  %xmm8,%xmm0
subss  %xmm1,%xmm0
movaps %xmm0,0x150(%rsp)
movss  %xmm4,0xa0(%rsp)
movss  %xmm8,0xa4(%rsp)
movss  %xmm5,0xa8(%rsp)
movl   $0x0,0xac(%rsp)
movss  %xmm9,0xb0(%rsp)
movss  %xmm6,0xb4(%rsp)
movss  %xmm0,0xb8(%rsp)
movl   $0x0,0xbc(%rsp)
movss  %xmm2,0xc0(%rsp)
movss  %xmm7,0xc4(%rsp)
movss  %xmm3,0xc8(%rsp)
xorps  %xmm0,%xmm0
movups %xmm0,0xcc(%rsp)
movl   $0x3f800000,0xdc(%rsp)
movss  0xc(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mulsd  0xc3e(%rip),%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0xc(%rsp)
call   1050 <cos@plt>
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0xf0(%rsp)
movss  0xc(%rsp),%xmm0
call   1030 <sin@plt>
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0xf4(%rsp)
movq   $0x0,0xf8(%rsp)
movss  0xc(%rsp),%xmm0
call   1030 <sin@plt>
cvtsd2ss %xmm0,%xmm0
xorps  0xbf0(%rip),%xmm0
movss  %xmm0,0x100(%rsp)
movss  0xc(%rsp),%xmm0
call   1050 <cos@plt>
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0x104(%rsp)
xorps  %xmm0,%xmm0
movups %xmm0,0x108(%rsp)
movl   $0x3f800000,0x118(%rsp)
movups %xmm0,0x11c(%rsp)
xorps  %xmm1,%xmm1
movl   $0x3f800000,0x12c(%rsp)
movaps 0x40(%rsp),%xmm0
movss  %xmm0,0x60(%rsp)
movaps 0x130(%rsp),%xmm0
movss  %xmm0,0x64(%rsp)
movaps 0x20(%rsp),%xmm0
movss  %xmm0,0x68(%rsp)
movl   $0x0,0x6c(%rsp)
movaps 0x50(%rsp),%xmm0
movss  %xmm0,0x70(%rsp)
movaps 0x140(%rsp),%xmm0
movss  %xmm0,0x74(%rsp)
movaps 0xe0(%rsp),%xmm0
movss  %xmm0,0x78(%rsp)
movl   $0x0,0x7c(%rsp)
movaps 0x10(%rsp),%xmm0
movss  %xmm0,0x80(%rsp)
movaps 0x150(%rsp),%xmm0
movss  %xmm0,0x84(%rsp)
movaps 0x30(%rsp),%xmm0
movss  %xmm0,0x88(%rsp)
movups %xmm1,0x8c(%rsp)
movl   $0x3f800000,0x9c(%rsp)
lea    0xa0(%rsp),%rdi
call   1040 <glMultMatrixf@plt>
lea    0xf0(%rsp),%rdi
call   1040 <glMultMatrixf@plt>
lea    0x60(%rsp),%rdi
call   1040 <glMultMatrixf@plt>
add    $0x168,%rsp
ret

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

LLVM IR (-O2):
define void @myRotatef(float %0, float %1, float %2, float %3) {
%5 = alloca [16 x float]
%6 = alloca [16 x float]
%7 = alloca [16 x float]
%8 = fmul float %2, %2
%9 = tail call float @llvm.fmuladd.f32(float %1, float %1, float %8)
%10 = tail call float @llvm.fmuladd.f32(float %3, float %3, float %9)
%11 = tail call i64 @sqrt(float %10)
%12 = sitofp i64 %11 to float
%13 = fdiv float %1, %12
%14 = insertelement <2 x float> poison, float %3, i64 0
%15 = insertelement <2 x float> %14, float %2, i64 1
%16 = insertelement <2 x float> poison, float %12, i64 0
%17 = shufflevector <2 x float> %16, <2 x float> poison, <2 x i32> zeroinitializer
%18 = fdiv <2 x float> %15, %17
%19 = extractelement <2 x float> %18, i64 1
%20 = fcmp olt float %13, %19
%21 = extractelement <2 x float> %18, i64 0
%22 = fcmp olt float %13, %21
%23 = and i1 %20, %22
%24 = select i1 %23, float 1.000000e+00, float %13
%25 = fcmp olt float %19, %13
%26 = fcmp olt float %19, %21
%27 = and i1 %25, %26
%28 = select i1 %27, float 1.000000e+00, float %19
%29 = fcmp ugt float %21, %13
%30 = fcmp ugt float %21, %19
%31 = or i1 %29, %30
%32 = select i1 %31, float %21, float 1.000000e+00
%33 = fneg float %32
%34 = fmul float %19, %33
%35 = tail call float @llvm.fmuladd.f32(float %28, float %21, float %34)
%36 = fneg float %24
%37 = fmul float %21, %36
%38 = tail call float @llvm.fmuladd.f32(float %32, float %13, float %37)
%39 = fneg float %28
%40 = fmul float %13, %39
%41 = tail call float @llvm.fmuladd.f32(float %24, float %19, float %40)
%42 = fmul float %38, %38
%43 = tail call float @llvm.fmuladd.f32(float %35, float %35, float %42)
%44 = tail call float @llvm.fmuladd.f32(float %41, float %41, float %43)
%45 = tail call i64 @sqrt(float %44)
%46 = sitofp i64 %45 to float
%47 = fdiv float %35, %46
%48 = fdiv float %38, %46
%49 = fdiv float %41, %46
%50 = fneg float %21
%51 = fmul float %48, %50
%52 = tail call float @llvm.fmuladd.f32(float %19, float %49, float %51)
%53 = fneg float %13
%54 = fmul float %49, %53
%55 = tail call float @llvm.fmuladd.f32(float %21, float %47, float %54)
%56 = fneg float %19
%57 = fmul float %47, %56
%58 = tail call float @llvm.fmuladd.f32(float %13, float %48, float %57)
%59 = bitcast [16 x float]* %5 to i8*
%60 = getelementptr inbounds [16 x float], [16 x float]* %5, i64 0, i64 0
store float %47, float* %60
%61 = getelementptr inbounds [16 x float], [16 x float]* %5, i64 0, i64 1
store float %48, float* %61
%62 = getelementptr inbounds [16 x float], [16 x float]* %5, i64 0, i64 2
store float %49, float* %62
%63 = getelementptr inbounds [16 x float], [16 x float]* %5, i64 0, i64 3
store float 0.000000e+00, float* %63
%64 = getelementptr inbounds [16 x float], [16 x float]* %5, i64 0, i64 4
store float %52, float* %64
%65 = getelementptr inbounds [16 x float], [16 x float]* %5, i64 0, i64 5
store float %55, float* %65
%66 = getelementptr inbounds [16 x float], [16 x float]* %5, i64 0, i64 6
store float %58, float* %66
%67 = getelementptr inbounds [16 x float], [16 x float]* %5, i64 0, i64 7
store float 0.000000e+00, float* %67
%68 = getelementptr inbounds [16 x float], [16 x float]* %5, i64 0, i64 8
store float %13, float* %68
%69 = getelementptr inbounds [16 x float], [16 x float]* %5, i64 0, i64 9
store float %19, float* %69
%70 = getelementptr inbounds [16 x float], [16 x float]* %5, i64 0, i64 10
store float %21, float* %70
%71 = getelementptr inbounds [16 x float], [16 x float]* %5, i64 0, i64 11
%72 = getelementptr inbounds [16 x float], [16 x float]* %5, i64 0, i64 15
%73 = bitcast float* %71 to i8*
store float 1.000000e+00, float* %72
%74 = fpext float %0 to double
%75 = fmul double %74, 0x3F91DF46A2529D39
%76 = fptrunc double %75 to float
%77 = bitcast [16 x float]* %6 to i8*
%78 = getelementptr inbounds [16 x float], [16 x float]* %6, i64 0, i64 0
%79 = tail call double @cos(float %76)
%80 = fptrunc double %79 to float
store float %80, float* %78
%81 = getelementptr inbounds [16 x float], [16 x float]* %6, i64 0, i64 1
%82 = tail call double @sin(float %76)
%83 = fptrunc double %82 to float
store float %83, float* %81
%84 = getelementptr inbounds [16 x float], [16 x float]* %6, i64 0, i64 2
store float 0.000000e+00, float* %84
%85 = getelementptr inbounds [16 x float], [16 x float]* %6, i64 0, i64 3
store float 0.000000e+00, float* %85
%86 = getelementptr inbounds [16 x float], [16 x float]* %6, i64 0, i64 4
%87 = tail call double @sin(float %76)
%88 = fptrunc double %87 to float
%89 = fneg float %88
store float %89, float* %86
%90 = getelementptr inbounds [16 x float], [16 x float]* %6, i64 0, i64 5
%91 = tail call double @cos(float %76)
%92 = fptrunc double %91 to float
store float %92, float* %90
%93 = getelementptr inbounds [16 x float], [16 x float]* %6, i64 0, i64 6
%94 = getelementptr inbounds [16 x float], [16 x float]* %6, i64 0, i64 10
%95 = bitcast float* %93 to i8*
store float 1.000000e+00, float* %94
%96 = getelementptr inbounds [16 x float], [16 x float]* %6, i64 0, i64 11
%97 = getelementptr inbounds [16 x float], [16 x float]* %6, i64 0, i64 15
%98 = bitcast float* %96 to i8*
store float 1.000000e+00, float* %97
%99 = bitcast [16 x float]* %7 to i8*
%100 = getelementptr inbounds [16 x float], [16 x float]* %7, i64 0, i64 0
store float %47, float* %100
%101 = getelementptr inbounds [16 x float], [16 x float]* %7, i64 0, i64 1
store float %52, float* %101
%102 = getelementptr inbounds [16 x float], [16 x float]* %7, i64 0, i64 2
store float %13, float* %102
%103 = getelementptr inbounds [16 x float], [16 x float]* %7, i64 0, i64 3
store float 0.000000e+00, float* %103
%104 = getelementptr inbounds [16 x float], [16 x float]* %7, i64 0, i64 4
store float %48, float* %104
%105 = getelementptr inbounds [16 x float], [16 x float]* %7, i64 0, i64 5
store float %55, float* %105
%106 = getelementptr inbounds [16 x float], [16 x float]* %7, i64 0, i64 6
store float %19, float* %106
%107 = getelementptr inbounds [16 x float], [16 x float]* %7, i64 0, i64 7
store float 0.000000e+00, float* %107
%108 = getelementptr inbounds [16 x float], [16 x float]* %7, i64 0, i64 8
store float %49, float* %108
%109 = getelementptr inbounds [16 x float], [16 x float]* %7, i64 0, i64 9
store float %58, float* %109
%110 = getelementptr inbounds [16 x float], [16 x float]* %7, i64 0, i64 10
store float %21, float* %110
%111 = getelementptr inbounds [16 x float], [16 x float]* %7, i64 0, i64 11
%112 = getelementptr inbounds [16 x float], [16 x float]* %7, i64 0, i64 15
%113 = bitcast float* %111 to i8*
store float 1.000000e+00, float* %112
%114 = call i32 @glMultMatrixf(float* %60)
%115 = call i32 @glMultMatrixf(float* %78)
%116 = call i32 @glMultMatrixf(float* %100)
ret void
}