#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 */
float cosf(float);
float sinf(float);
void Mat4_SetAnglesZXY(float mat[16], float ang[3]) {
  float R[4], Rt[4], temp[4];
  float sin_t2, cos_t2, t;
  sin_t2 = 0.0;
  cos_t2 = 1.0;
  if (ang[0] != 0.0) {
    t = ang[0] * 3.14159265358979323846 / 180.0f;
    sin_t2 = sinf(t);
    cos_t2 = cosf(t);
  }
  mat[0] = cos_t2;
  mat[1] = sin_t2;
  mat[2] = 0.0;
  mat[3] = 0.0;
  mat[4] = -sin_t2;
  mat[5] = cos_t2;
  mat[6] = 0.0;
  mat[7] = 0.0;
  mat[8] = 0.0;
  mat[9] = 0.0;
  mat[10] = 1.0;
  mat[11] = 0.0;
  if (ang[1] != 0.0) {
    t = ang[1] * 3.14159265358979323846 / 360.0f;
    sin_t2 = sinf(t);
    cos_t2 = cosf(t);
    R[3] = cos_t2;
    R[0] = mat[0] * sin_t2;
    R[1] = mat[1] * sin_t2;
    R[2] = mat[2] * sin_t2;
    {
      (Rt)[0] = -(R)[0];
      (Rt)[1] = -(R)[1];
      (Rt)[2] = -(R)[2];
      (Rt)[3] = (R)[3];
    };
    {
      (temp)[0] = (R)[3] * (mat + 4)[0] + (R)[0] * (mat + 4)[3] +
                  (R)[1] * (mat + 4)[2] - (R)[2] * (mat + 4)[1];
      (temp)[1] = (R)[3] * (mat + 4)[1] + (R)[1] * (mat + 4)[3] +
                  (R)[2] * (mat + 4)[0] - (R)[0] * (mat + 4)[2];
      (temp)[2] = (R)[3] * (mat + 4)[2] + (R)[2] * (mat + 4)[3] +
                  (R)[0] * (mat + 4)[1] - (R)[1] * (mat + 4)[0];
      (temp)[3] = (R)[3] * (mat + 4)[3] - (R)[0] * (mat + 4)[0] -
                  (R)[1] * (mat + 4)[1] - (R)[2] * (mat + 4)[2];
    };
    {
      (mat + 4)[0] = (temp)[3] * (Rt)[0] + (temp)[0] * (Rt)[3] +
                     (temp)[1] * (Rt)[2] - (temp)[2] * (Rt)[1];
      (mat + 4)[1] = (temp)[3] * (Rt)[1] + (temp)[1] * (Rt)[3] +
                     (temp)[2] * (Rt)[0] - (temp)[0] * (Rt)[2];
      (mat + 4)[2] = (temp)[3] * (Rt)[2] + (temp)[2] * (Rt)[3] +
                     (temp)[0] * (Rt)[1] - (temp)[1] * (Rt)[0];
      (mat + 4)[3] = (temp)[3] * (Rt)[3] - (temp)[0] * (Rt)[0] -
                     (temp)[1] * (Rt)[1] - (temp)[2] * (Rt)[2];
    };
    {
      (temp)[0] = (R)[3] * (mat + 8)[0] + (R)[0] * (mat + 8)[3] +
                  (R)[1] * (mat + 8)[2] - (R)[2] * (mat + 8)[1];
      (temp)[1] = (R)[3] * (mat + 8)[1] + (R)[1] * (mat + 8)[3] +
                  (R)[2] * (mat + 8)[0] - (R)[0] * (mat + 8)[2];
      (temp)[2] = (R)[3] * (mat + 8)[2] + (R)[2] * (mat + 8)[3] +
                  (R)[0] * (mat + 8)[1] - (R)[1] * (mat + 8)[0];
      (temp)[3] = (R)[3] * (mat + 8)[3] - (R)[0] * (mat + 8)[0] -
                  (R)[1] * (mat + 8)[1] - (R)[2] * (mat + 8)[2];
    };
    {
      (mat + 8)[0] = (temp)[3] * (Rt)[0] + (temp)[0] * (Rt)[3] +
                     (temp)[1] * (Rt)[2] - (temp)[2] * (Rt)[1];
      (mat + 8)[1] = (temp)[3] * (Rt)[1] + (temp)[1] * (Rt)[3] +
                     (temp)[2] * (Rt)[0] - (temp)[0] * (Rt)[2];
      (mat + 8)[2] = (temp)[3] * (Rt)[2] + (temp)[2] * (Rt)[3] +
                     (temp)[0] * (Rt)[1] - (temp)[1] * (Rt)[0];
      (mat + 8)[3] = (temp)[3] * (Rt)[3] - (temp)[0] * (Rt)[0] -
                     (temp)[1] * (Rt)[1] - (temp)[2] * (Rt)[2];
    };
    mat[7] = 0.0;
    mat[11] = 0.0;
  }
  if (ang[2] != 0.0) {
    t = ang[2] * 3.14159265358979323846 / 360.0f;
    sin_t2 = sinf(t);
    cos_t2 = cosf(t);
    R[3] = cos_t2;
    R[0] = mat[4] * sin_t2;
    R[1] = mat[5] * sin_t2;
    R[2] = mat[6] * sin_t2;
    {
      (Rt)[0] = -(R)[0];
      (Rt)[1] = -(R)[1];
      (Rt)[2] = -(R)[2];
      (Rt)[3] = (R)[3];
    };
    {
      (temp)[0] = (R)[3] * (mat + 0)[0] + (R)[0] * (mat + 0)[3] +
                  (R)[1] * (mat + 0)[2] - (R)[2] * (mat + 0)[1];
      (temp)[1] = (R)[3] * (mat + 0)[1] + (R)[1] * (mat + 0)[3] +
                  (R)[2] * (mat + 0)[0] - (R)[0] * (mat + 0)[2];
      (temp)[2] = (R)[3] * (mat + 0)[2] + (R)[2] * (mat + 0)[3] +
                  (R)[0] * (mat + 0)[1] - (R)[1] * (mat + 0)[0];
      (temp)[3] = (R)[3] * (mat + 0)[3] - (R)[0] * (mat + 0)[0] -
                  (R)[1] * (mat + 0)[1] - (R)[2] * (mat + 0)[2];
    };
    {
      (mat + 0)[0] = (temp)[3] * (Rt)[0] + (temp)[0] * (Rt)[3] +
                     (temp)[1] * (Rt)[2] - (temp)[2] * (Rt)[1];
      (mat + 0)[1] = (temp)[3] * (Rt)[1] + (temp)[1] * (Rt)[3] +
                     (temp)[2] * (Rt)[0] - (temp)[0] * (Rt)[2];
      (mat + 0)[2] = (temp)[3] * (Rt)[2] + (temp)[2] * (Rt)[3] +
                     (temp)[0] * (Rt)[1] - (temp)[1] * (Rt)[0];
      (mat + 0)[3] = (temp)[3] * (Rt)[3] - (temp)[0] * (Rt)[0] -
                     (temp)[1] * (Rt)[1] - (temp)[2] * (Rt)[2];
    };
    {
      (temp)[0] = (R)[3] * (mat + 8)[0] + (R)[0] * (mat + 8)[3] +
                  (R)[1] * (mat + 8)[2] - (R)[2] * (mat + 8)[1];
      (temp)[1] = (R)[3] * (mat + 8)[1] + (R)[1] * (mat + 8)[3] +
                  (R)[2] * (mat + 8)[0] - (R)[0] * (mat + 8)[2];
      (temp)[2] = (R)[3] * (mat + 8)[2] + (R)[2] * (mat + 8)[3] +
                  (R)[0] * (mat + 8)[1] - (R)[1] * (mat + 8)[0];
      (temp)[3] = (R)[3] * (mat + 8)[3] - (R)[0] * (mat + 8)[0] -
                  (R)[1] * (mat + 8)[1] - (R)[2] * (mat + 8)[2];
    };
    {
      (mat + 8)[0] = (temp)[3] * (Rt)[0] + (temp)[0] * (Rt)[3] +
                     (temp)[1] * (Rt)[2] - (temp)[2] * (Rt)[1];
      (mat + 8)[1] = (temp)[3] * (Rt)[1] + (temp)[1] * (Rt)[3] +
                     (temp)[2] * (Rt)[0] - (temp)[0] * (Rt)[2];
      (mat + 8)[2] = (temp)[3] * (Rt)[2] + (temp)[2] * (Rt)[3] +
                     (temp)[0] * (Rt)[1] - (temp)[1] * (Rt)[0];
      (mat + 8)[3] = (temp)[3] * (Rt)[3] - (temp)[0] * (Rt)[0] -
                     (temp)[1] * (Rt)[1] - (temp)[2] * (Rt)[2];
    };
    mat[3] = 0.0;
    mat[11] = 0.0;
  }
}


x86 assembly (clang, -O0):
<Mat4_SetAnglesZXY>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x44(%rbp)
movss  0x1ec0(%rip),%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1169 <Mat4_SetAnglesZXY+0x49>
jp     1169 <Mat4_SetAnglesZXY+0x49>
jmp    11b4 <Mat4_SetAnglesZXY+0x94>
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x1e93(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  0x1e7f(%rip),%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x4c(%rbp),%xmm0
call   1030 <sinf@plt>
movss  %xmm0,-0x44(%rbp)
movss  -0x4c(%rbp),%xmm0
call   1040 <cosf@plt>
movss  %xmm0,-0x48(%rbp)
movss  -0x48(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x44(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x4(%rax)
mov    -0x8(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,0x8(%rax)
mov    -0x8(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,0xc(%rax)
movss  -0x44(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x10(%rax)
movss  -0x48(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x14(%rax)
mov    -0x8(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,0x18(%rax)
mov    -0x8(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,0x1c(%rax)
mov    -0x8(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,0x20(%rax)
mov    -0x8(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,0x24(%rax)
mov    -0x8(%rbp),%rax
movss  0x1db4(%rip),%xmm0
movss  %xmm0,0x28(%rax)
mov    -0x8(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,0x2c(%rax)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1282 <Mat4_SetAnglesZXY+0x162>
jp     1282 <Mat4_SetAnglesZXY+0x162>
jmp    199f <Mat4_SetAnglesZXY+0x87f>
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x1d79(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  0x1d75(%rip),%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x4c(%rbp),%xmm0
call   1030 <sinf@plt>
movss  %xmm0,-0x44(%rbp)
movss  -0x4c(%rbp),%xmm0
call   1040 <cosf@plt>
movss  %xmm0,-0x48(%rbp)
movss  -0x48(%rbp),%xmm0
movss  %xmm0,-0x14(%rbp)
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
mulss  -0x44(%rbp),%xmm0
movss  %xmm0,-0x20(%rbp)
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm0
mulss  -0x44(%rbp),%xmm0
movss  %xmm0,-0x1c(%rbp)
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm0
mulss  -0x44(%rbp),%xmm0
movss  %xmm0,-0x18(%rbp)
movss  -0x20(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x30(%rbp)
movss  -0x1c(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x2c(%rbp)
movss  -0x18(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x28(%rbp)
movss  -0x14(%rbp),%xmm0
movss  %xmm0,-0x24(%rbp)
movss  -0x14(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  0x10(%rax),%xmm2
movss  -0x20(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mulss  0x1c(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x1c(%rbp),%xmm1
mov    -0x8(%rbp),%rax
movss  0x18(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x18(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  0x14(%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x14(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  0x14(%rax),%xmm2
movss  -0x1c(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mulss  0x1c(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x18(%rbp),%xmm1
mov    -0x8(%rbp),%rax
movss  0x10(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x20(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  0x18(%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  -0x14(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  0x18(%rax),%xmm2
movss  -0x18(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mulss  0x1c(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x20(%rbp),%xmm1
mov    -0x8(%rbp),%rax
movss  0x14(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x1c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  0x10(%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x38(%rbp)
movss  -0x14(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  0x1c(%rax),%xmm2
movss  -0x20(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mulss  0x10(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x1c(%rbp),%xmm1
mov    -0x8(%rbp),%rax
movss  0x14(%rax),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x18(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  0x18(%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x34(%rbp)
movss  -0x34(%rbp),%xmm0
movss  -0x30(%rbp),%xmm2
movss  -0x40(%rbp),%xmm1
mulss  -0x24(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x3c(%rbp),%xmm1
movss  -0x28(%rbp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x38(%rbp),%xmm0
movss  -0x2c(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x10(%rax)
movss  -0x34(%rbp),%xmm0
movss  -0x2c(%rbp),%xmm2
movss  -0x3c(%rbp),%xmm1
mulss  -0x24(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x38(%rbp),%xmm1
movss  -0x30(%rbp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x40(%rbp),%xmm0
movss  -0x28(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x14(%rax)
movss  -0x34(%rbp),%xmm0
movss  -0x28(%rbp),%xmm2
movss  -0x38(%rbp),%xmm1
mulss  -0x24(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x40(%rbp),%xmm1
movss  -0x2c(%rbp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x3c(%rbp),%xmm0
movss  -0x30(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x18(%rax)
movss  -0x34(%rbp),%xmm0
movss  -0x24(%rbp),%xmm2
movss  -0x40(%rbp),%xmm1
mulss  -0x30(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x3c(%rbp),%xmm1
movss  -0x2c(%rbp),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x38(%rbp),%xmm0
movss  -0x28(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x1c(%rax)
movss  -0x14(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  0x20(%rax),%xmm2
movss  -0x20(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mulss  0x2c(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x1c(%rbp),%xmm1
mov    -0x8(%rbp),%rax
movss  0x28(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x18(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  0x24(%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x14(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  0x24(%rax),%xmm2
movss  -0x1c(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mulss  0x2c(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x18(%rbp),%xmm1
mov    -0x8(%rbp),%rax
movss  0x20(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x20(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  0x28(%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  -0x14(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  0x28(%rax),%xmm2
movss  -0x18(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mulss  0x2c(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x20(%rbp),%xmm1
mov    -0x8(%rbp),%rax
movss  0x24(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x1c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  0x20(%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x38(%rbp)
movss  -0x14(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  0x2c(%rax),%xmm2
movss  -0x20(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mulss  0x20(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x1c(%rbp),%xmm1
mov    -0x8(%rbp),%rax
movss  0x24(%rax),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x18(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  0x28(%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x34(%rbp)
movss  -0x34(%rbp),%xmm0
movss  -0x30(%rbp),%xmm2
movss  -0x40(%rbp),%xmm1
mulss  -0x24(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x3c(%rbp),%xmm1
movss  -0x28(%rbp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x38(%rbp),%xmm0
movss  -0x2c(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x20(%rax)
movss  -0x34(%rbp),%xmm0
movss  -0x2c(%rbp),%xmm2
movss  -0x3c(%rbp),%xmm1
mulss  -0x24(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x38(%rbp),%xmm1
movss  -0x30(%rbp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x40(%rbp),%xmm0
movss  -0x28(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x24(%rax)
movss  -0x34(%rbp),%xmm0
movss  -0x28(%rbp),%xmm2
movss  -0x38(%rbp),%xmm1
mulss  -0x24(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x40(%rbp),%xmm1
movss  -0x2c(%rbp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x3c(%rbp),%xmm0
movss  -0x30(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x28(%rax)
movss  -0x34(%rbp),%xmm0
movss  -0x24(%rbp),%xmm2
movss  -0x40(%rbp),%xmm1
mulss  -0x30(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x3c(%rbp),%xmm1
movss  -0x2c(%rbp),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x38(%rbp),%xmm0
movss  -0x28(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x2c(%rax)
mov    -0x8(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,0x1c(%rax)
mov    -0x8(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,0x2c(%rax)
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    19c4 <Mat4_SetAnglesZXY+0x8a4>
jp     19c4 <Mat4_SetAnglesZXY+0x8a4>
jmp    20dd <Mat4_SetAnglesZXY+0xfbd>
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x1637(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  0x1633(%rip),%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x4c(%rbp),%xmm0
call   1030 <sinf@plt>
movss  %xmm0,-0x44(%rbp)
movss  -0x4c(%rbp),%xmm0
call   1040 <cosf@plt>
movss  %xmm0,-0x48(%rbp)
movss  -0x48(%rbp),%xmm0
movss  %xmm0,-0x14(%rbp)
mov    -0x8(%rbp),%rax
movss  0x10(%rax),%xmm0
mulss  -0x44(%rbp),%xmm0
movss  %xmm0,-0x20(%rbp)
mov    -0x8(%rbp),%rax
movss  0x14(%rax),%xmm0
mulss  -0x44(%rbp),%xmm0
movss  %xmm0,-0x1c(%rbp)
mov    -0x8(%rbp),%rax
movss  0x18(%rax),%xmm0
mulss  -0x44(%rbp),%xmm0
movss  %xmm0,-0x18(%rbp)
movss  -0x20(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x30(%rbp)
movss  -0x1c(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x2c(%rbp)
movss  -0x18(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x28(%rbp)
movss  -0x14(%rbp),%xmm0
movss  %xmm0,-0x24(%rbp)
movss  -0x14(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm2
movss  -0x20(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mulss  0xc(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x1c(%rbp),%xmm1
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x18(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x14(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm2
movss  -0x1c(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mulss  0xc(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x18(%rbp),%xmm1
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x20(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  -0x14(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm2
movss  -0x18(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mulss  0xc(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x20(%rbp),%xmm1
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x1c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x38(%rbp)
movss  -0x14(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  0xc(%rax),%xmm2
movss  -0x20(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mulss  (%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x1c(%rbp),%xmm1
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x18(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x34(%rbp)
movss  -0x34(%rbp),%xmm0
movss  -0x30(%rbp),%xmm2
movss  -0x40(%rbp),%xmm1
mulss  -0x24(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x3c(%rbp),%xmm1
movss  -0x28(%rbp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x38(%rbp),%xmm0
movss  -0x2c(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x34(%rbp),%xmm0
movss  -0x2c(%rbp),%xmm2
movss  -0x3c(%rbp),%xmm1
mulss  -0x24(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x38(%rbp),%xmm1
movss  -0x30(%rbp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x40(%rbp),%xmm0
movss  -0x28(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x34(%rbp),%xmm0
movss  -0x28(%rbp),%xmm2
movss  -0x38(%rbp),%xmm1
mulss  -0x24(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x40(%rbp),%xmm1
movss  -0x2c(%rbp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x3c(%rbp),%xmm0
movss  -0x30(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x8(%rax)
movss  -0x34(%rbp),%xmm0
movss  -0x24(%rbp),%xmm2
movss  -0x40(%rbp),%xmm1
mulss  -0x30(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x3c(%rbp),%xmm1
movss  -0x2c(%rbp),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x38(%rbp),%xmm0
movss  -0x28(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0xc(%rax)
movss  -0x14(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  0x20(%rax),%xmm2
movss  -0x20(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mulss  0x2c(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x1c(%rbp),%xmm1
mov    -0x8(%rbp),%rax
movss  0x28(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x18(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  0x24(%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x14(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  0x24(%rax),%xmm2
movss  -0x1c(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mulss  0x2c(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x18(%rbp),%xmm1
mov    -0x8(%rbp),%rax
movss  0x20(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x20(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  0x28(%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  -0x14(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  0x28(%rax),%xmm2
movss  -0x18(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mulss  0x2c(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x20(%rbp),%xmm1
mov    -0x8(%rbp),%rax
movss  0x24(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x1c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  0x20(%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x38(%rbp)
movss  -0x14(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  0x2c(%rax),%xmm2
movss  -0x20(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mulss  0x20(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x1c(%rbp),%xmm1
mov    -0x8(%rbp),%rax
movss  0x24(%rax),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x18(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  0x28(%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x34(%rbp)
movss  -0x34(%rbp),%xmm0
movss  -0x30(%rbp),%xmm2
movss  -0x40(%rbp),%xmm1
mulss  -0x24(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x3c(%rbp),%xmm1
movss  -0x28(%rbp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x38(%rbp),%xmm0
movss  -0x2c(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x20(%rax)
movss  -0x34(%rbp),%xmm0
movss  -0x2c(%rbp),%xmm2
movss  -0x3c(%rbp),%xmm1
mulss  -0x24(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x38(%rbp),%xmm1
movss  -0x30(%rbp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x40(%rbp),%xmm0
movss  -0x28(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x24(%rax)
movss  -0x34(%rbp),%xmm0
movss  -0x28(%rbp),%xmm2
movss  -0x38(%rbp),%xmm1
mulss  -0x24(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x40(%rbp),%xmm1
movss  -0x2c(%rbp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x3c(%rbp),%xmm0
movss  -0x30(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x28(%rax)
movss  -0x34(%rbp),%xmm0
movss  -0x24(%rbp),%xmm2
movss  -0x40(%rbp),%xmm1
mulss  -0x30(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x3c(%rbp),%xmm1
movss  -0x2c(%rbp),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x38(%rbp),%xmm0
movss  -0x28(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x2c(%rax)
mov    -0x8(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,0xc(%rax)
mov    -0x8(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,0x2c(%rax)
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<Mat4_SetAnglesZXY>:
push   %r14
push   %rbx
sub    $0x28,%rsp
mov    %rsi,%r14
mov    %rdi,%rbx
movss  (%rsi),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    113b <Mat4_SetAnglesZXY+0x1b>
jnp    1178 <Mat4_SetAnglesZXY+0x58>
cvtss2sd %xmm0,%xmm0
mulsd  0xec1(%rip),%xmm0
divsd  0xec1(%rip),%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0xc(%rsp)
call   1030 <sinf@plt>
movaps %xmm0,0x10(%rsp)
movss  0xc(%rsp),%xmm0
call   1040 <cosf@plt>
movaps 0x10(%rsp),%xmm2
xorps  %xmm1,%xmm1
jmp    1183 <Mat4_SetAnglesZXY+0x63>
movss  0xe80(%rip),%xmm0
xorps  %xmm2,%xmm2
movss  %xmm0,(%rbx)
movss  %xmm2,0x4(%rbx)
movq   $0x0,0x8(%rbx)
xorps  0xe85(%rip),%xmm2
movss  %xmm2,0x10(%rbx)
movss  %xmm0,0x14(%rbx)
xorps  %xmm0,%xmm0
movups %xmm0,0x18(%rbx)
movq   $0x3f800000,0x28(%rbx)
3f
movss  0x4(%r14),%xmm0
ucomiss %xmm1,%xmm0
jne    11c5 <Mat4_SetAnglesZXY+0xa5>
jnp    14a0 <Mat4_SetAnglesZXY+0x380>
cvtss2sd %xmm0,%xmm0
mulsd  0xe37(%rip),%xmm0
divsd  0xe3f(%rip),%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0x10(%rsp)
call   1030 <sinf@plt>
movss  %xmm0,0xc(%rsp)
movss  0x10(%rsp),%xmm0
call   1040 <cosf@plt>
movss  (%rbx),%xmm8
movss  0xc(%rsp),%xmm11
mulss  %xmm11,%xmm8
movss  0x4(%rbx),%xmm9
mulss  %xmm11,%xmm9
mulss  0x8(%rbx),%xmm11
movss  0x1c(%rbx),%xmm3
movaps %xmm8,%xmm1
mulss  %xmm3,%xmm1
movss  0x10(%rbx),%xmm2
movss  0x14(%rbx),%xmm10
movaps %xmm0,%xmm5
mulss  %xmm2,%xmm5
addss  %xmm1,%xmm5
movss  0x18(%rbx),%xmm7
movaps %xmm9,%xmm4
mulss  %xmm7,%xmm4
addss  %xmm5,%xmm4
movaps %xmm11,%xmm1
mulss  %xmm10,%xmm1
subss  %xmm1,%xmm4
movaps %xmm9,%xmm1
mulss  %xmm3,%xmm1
movaps %xmm0,%xmm6
mulss  %xmm10,%xmm6
addss  %xmm1,%xmm6
movaps %xmm11,%xmm5
mulss  %xmm2,%xmm5
addss  %xmm6,%xmm5
movaps %xmm8,%xmm1
mulss  %xmm7,%xmm1
subss  %xmm1,%xmm5
movaps %xmm11,%xmm1
mulss  %xmm3,%xmm1
movaps %xmm0,%xmm6
mulss  %xmm7,%xmm6
addss  %xmm1,%xmm6
movaps %xmm8,%xmm1
mulss  %xmm10,%xmm1
addss  %xmm6,%xmm1
movaps %xmm9,%xmm6
mulss  %xmm2,%xmm6
subss  %xmm6,%xmm1
mulss  %xmm8,%xmm2
mulss  %xmm0,%xmm3
subss  %xmm2,%xmm3
mulss  %xmm9,%xmm10
subss  %xmm10,%xmm3
mulss  %xmm11,%xmm7
subss  %xmm7,%xmm3
movaps %xmm0,%xmm2
mulss  %xmm4,%xmm2
movaps %xmm3,%xmm6
mulss  %xmm8,%xmm6
subss  %xmm6,%xmm2
movaps %xmm5,%xmm6
mulss  %xmm11,%xmm6
subss  %xmm6,%xmm2
movaps %xmm1,%xmm6
mulss  %xmm9,%xmm6
addss  %xmm2,%xmm6
movss  %xmm6,0x10(%rbx)
movaps %xmm0,%xmm2
mulss  %xmm5,%xmm2
movaps %xmm3,%xmm6
mulss  %xmm9,%xmm6
subss  %xmm6,%xmm2
movaps %xmm0,%xmm6
mulss  %xmm1,%xmm6
mulss  %xmm8,%xmm1
subss  %xmm1,%xmm2
movaps %xmm4,%xmm1
mulss  %xmm11,%xmm1
addss  %xmm2,%xmm1
movss  %xmm1,0x14(%rbx)
mulss  %xmm11,%xmm3
subss  %xmm3,%xmm6
mulss  %xmm9,%xmm4
subss  %xmm4,%xmm6
mulss  %xmm8,%xmm5
addss  %xmm6,%xmm5
movss  %xmm5,0x18(%rbx)
movss  0x20(%rbx),%xmm10
movss  0x2c(%rbx),%xmm3
movaps %xmm8,%xmm1
mulss  %xmm3,%xmm1
movaps %xmm0,%xmm2
mulss  %xmm10,%xmm2
addss  %xmm1,%xmm2
movss  0x28(%rbx),%xmm7
movaps %xmm9,%xmm4
mulss  %xmm7,%xmm4
addss  %xmm2,%xmm4
movss  0x24(%rbx),%xmm2
movaps %xmm11,%xmm1
mulss  %xmm2,%xmm1
subss  %xmm1,%xmm4
movaps %xmm9,%xmm1
mulss  %xmm3,%xmm1
movaps %xmm0,%xmm6
mulss  %xmm2,%xmm6
addss  %xmm1,%xmm6
movaps %xmm11,%xmm5
mulss  %xmm10,%xmm5
addss  %xmm6,%xmm5
movaps %xmm8,%xmm1
mulss  %xmm7,%xmm1
subss  %xmm1,%xmm5
movaps %xmm11,%xmm1
mulss  %xmm3,%xmm1
movaps %xmm0,%xmm6
mulss  %xmm7,%xmm6
addss  %xmm1,%xmm6
movaps %xmm8,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm6,%xmm1
movaps %xmm9,%xmm6
mulss  %xmm10,%xmm6
subss  %xmm6,%xmm1
mulss  %xmm8,%xmm10
mulss  %xmm0,%xmm3
subss  %xmm10,%xmm3
mulss  %xmm9,%xmm2
subss  %xmm2,%xmm3
mulss  %xmm11,%xmm7
subss  %xmm7,%xmm3
movaps %xmm0,%xmm2
mulss  %xmm4,%xmm2
movaps %xmm3,%xmm6
mulss  %xmm8,%xmm6
subss  %xmm6,%xmm2
movaps %xmm5,%xmm6
mulss  %xmm11,%xmm6
subss  %xmm6,%xmm2
movaps %xmm1,%xmm6
mulss  %xmm9,%xmm6
addss  %xmm2,%xmm6
movss  %xmm6,0x20(%rbx)
movaps %xmm0,%xmm2
mulss  %xmm5,%xmm2
movaps %xmm3,%xmm6
mulss  %xmm9,%xmm6
subss  %xmm6,%xmm2
mulss  %xmm1,%xmm0
mulss  %xmm8,%xmm1
subss  %xmm1,%xmm2
movaps %xmm4,%xmm1
mulss  %xmm11,%xmm1
addss  %xmm2,%xmm1
movss  %xmm1,0x24(%rbx)
mulss  %xmm11,%xmm3
subss  %xmm3,%xmm0
mulss  %xmm9,%xmm4
subss  %xmm4,%xmm0
mulss  %xmm8,%xmm5
addss  %xmm0,%xmm5
movss  %xmm5,0x28(%rbx)
movl   $0x0,0x1c(%rbx)
movl   $0x0,0x2c(%rbx)
movss  0x8(%r14),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    14b4 <Mat4_SetAnglesZXY+0x394>
jnp    178e <Mat4_SetAnglesZXY+0x66e>
cvtss2sd %xmm0,%xmm0
mulsd  0xb48(%rip),%xmm0
divsd  0xb50(%rip),%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0x10(%rsp)
call   1030 <sinf@plt>
movss  %xmm0,0xc(%rsp)
movss  0x10(%rsp),%xmm0
call   1040 <cosf@plt>
movss  0x10(%rbx),%xmm8
movss  0xc(%rsp),%xmm11
mulss  %xmm11,%xmm8
movss  0x14(%rbx),%xmm9
mulss  %xmm11,%xmm9
mulss  0x18(%rbx),%xmm11
movss  0xc(%rbx),%xmm3
movaps %xmm8,%xmm1
mulss  %xmm3,%xmm1
movss  (%rbx),%xmm2
movss  0x4(%rbx),%xmm10
movaps %xmm0,%xmm5
mulss  %xmm2,%xmm5
addss  %xmm1,%xmm5
movss  0x8(%rbx),%xmm7
movaps %xmm9,%xmm4
mulss  %xmm7,%xmm4
addss  %xmm5,%xmm4
movaps %xmm11,%xmm1
mulss  %xmm10,%xmm1
subss  %xmm1,%xmm4
movaps %xmm9,%xmm1
mulss  %xmm3,%xmm1
movaps %xmm0,%xmm6
mulss  %xmm10,%xmm6
addss  %xmm1,%xmm6
movaps %xmm11,%xmm5
mulss  %xmm2,%xmm5
addss  %xmm6,%xmm5
movaps %xmm8,%xmm1
mulss  %xmm7,%xmm1
subss  %xmm1,%xmm5
movaps %xmm11,%xmm1
mulss  %xmm3,%xmm1
movaps %xmm0,%xmm6
mulss  %xmm7,%xmm6
addss  %xmm1,%xmm6
movaps %xmm8,%xmm1
mulss  %xmm10,%xmm1
addss  %xmm6,%xmm1
movaps %xmm9,%xmm6
mulss  %xmm2,%xmm6
subss  %xmm6,%xmm1
mulss  %xmm8,%xmm2
mulss  %xmm0,%xmm3
subss  %xmm2,%xmm3
mulss  %xmm9,%xmm10
subss  %xmm10,%xmm3
mulss  %xmm11,%xmm7
subss  %xmm7,%xmm3
movaps %xmm0,%xmm2
mulss  %xmm4,%xmm2
movaps %xmm3,%xmm6
mulss  %xmm8,%xmm6
subss  %xmm6,%xmm2
movaps %xmm5,%xmm6
mulss  %xmm11,%xmm6
subss  %xmm6,%xmm2
movaps %xmm1,%xmm6
mulss  %xmm9,%xmm6
addss  %xmm2,%xmm6
movss  %xmm6,(%rbx)
movaps %xmm0,%xmm2
mulss  %xmm5,%xmm2
movaps %xmm3,%xmm6
mulss  %xmm9,%xmm6
subss  %xmm6,%xmm2
movaps %xmm0,%xmm6
mulss  %xmm1,%xmm6
mulss  %xmm8,%xmm1
subss  %xmm1,%xmm2
movaps %xmm4,%xmm1
mulss  %xmm11,%xmm1
addss  %xmm2,%xmm1
movss  %xmm1,0x4(%rbx)
mulss  %xmm11,%xmm3
subss  %xmm3,%xmm6
mulss  %xmm9,%xmm4
subss  %xmm4,%xmm6
mulss  %xmm8,%xmm5
addss  %xmm6,%xmm5
movss  %xmm5,0x8(%rbx)
movss  0x20(%rbx),%xmm10
movss  0x2c(%rbx),%xmm3
movaps %xmm8,%xmm1
mulss  %xmm3,%xmm1
movaps %xmm0,%xmm2
mulss  %xmm10,%xmm2
addss  %xmm1,%xmm2
movss  0x28(%rbx),%xmm7
movaps %xmm9,%xmm4
mulss  %xmm7,%xmm4
addss  %xmm2,%xmm4
movss  0x24(%rbx),%xmm2
movaps %xmm11,%xmm1
mulss  %xmm2,%xmm1
subss  %xmm1,%xmm4
movaps %xmm9,%xmm1
mulss  %xmm3,%xmm1
movaps %xmm0,%xmm6
mulss  %xmm2,%xmm6
addss  %xmm1,%xmm6
movaps %xmm11,%xmm5
mulss  %xmm10,%xmm5
addss  %xmm6,%xmm5
movaps %xmm8,%xmm1
mulss  %xmm7,%xmm1
subss  %xmm1,%xmm5
movaps %xmm11,%xmm1
mulss  %xmm3,%xmm1
movaps %xmm0,%xmm6
mulss  %xmm7,%xmm6
addss  %xmm1,%xmm6
movaps %xmm8,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm6,%xmm1
movaps %xmm9,%xmm6
mulss  %xmm10,%xmm6
subss  %xmm6,%xmm1
mulss  %xmm8,%xmm10
mulss  %xmm0,%xmm3
subss  %xmm10,%xmm3
mulss  %xmm9,%xmm2
subss  %xmm2,%xmm3
mulss  %xmm11,%xmm7
subss  %xmm7,%xmm3
movaps %xmm0,%xmm2
mulss  %xmm4,%xmm2
movaps %xmm3,%xmm6
mulss  %xmm8,%xmm6
subss  %xmm6,%xmm2
movaps %xmm5,%xmm6
mulss  %xmm11,%xmm6
subss  %xmm6,%xmm2
movaps %xmm1,%xmm6
mulss  %xmm9,%xmm6
addss  %xmm2,%xmm6
movss  %xmm6,0x20(%rbx)
movaps %xmm0,%xmm2
mulss  %xmm5,%xmm2
movaps %xmm3,%xmm6
mulss  %xmm9,%xmm6
subss  %xmm6,%xmm2
mulss  %xmm1,%xmm0
mulss  %xmm8,%xmm1
subss  %xmm1,%xmm2
movaps %xmm4,%xmm1
mulss  %xmm11,%xmm1
addss  %xmm2,%xmm1
movss  %xmm1,0x24(%rbx)
mulss  %xmm11,%xmm3
subss  %xmm3,%xmm0
mulss  %xmm9,%xmm4
subss  %xmm4,%xmm0
mulss  %xmm8,%xmm5
addss  %xmm0,%xmm5
movss  %xmm5,0x28(%rbx)
movl   $0x0,0xc(%rbx)
movl   $0x0,0x2c(%rbx)
add    $0x28,%rsp
pop    %rbx
pop    %r14
ret

LLVM IR (-O0):
define void @Mat4_SetAnglesZXY(float* %0, float* %1) {
%3 = alloca float*
%4 = alloca float*
%5 = alloca [4 x float]
%6 = alloca [4 x float]
%7 = alloca [4 x float]
%8 = alloca float
%9 = alloca float
%10 = alloca float
store float* %0, float** %3
store float* %1, float** %4
store float 0.000000e+00, float* %8
store float 1.000000e+00, float* %9
%11 = load float*, float** %4
%12 = getelementptr inbounds float, float* %11, i64 0
%13 = load float, float* %12
%14 = fpext float %13 to double
%15 = fcmp une double %14, 0.000000e+00
br i1 %15, label %16, label %28
16: ; preds = %2
%17 = load float*, float** %4
%18 = getelementptr inbounds float, float* %17, i64 0
%19 = load float, float* %18
%20 = fpext float %19 to double
%21 = fmul double %20, 0x400921FB54442D18
%22 = fdiv double %21, 1.800000e+02
%23 = fptrunc double %22 to float
store float %23, float* %10
%24 = load float, float* %10
%25 = call float @sinf(float %24)
store float %25, float* %8
%26 = load float, float* %10
%27 = call float @cosf(float %26)
store float %27, float* %9
br label %28
28: ; preds = %16, %2
%29 = load float, float* %9
%30 = load float*, float** %3
%31 = getelementptr inbounds float, float* %30, i64 0
store float %29, float* %31
%32 = load float, float* %8
%33 = load float*, float** %3
%34 = getelementptr inbounds float, float* %33, i64 1
store float %32, float* %34
%35 = load float*, float** %3
%36 = getelementptr inbounds float, float* %35, i64 2
store float 0.000000e+00, float* %36
%37 = load float*, float** %3
%38 = getelementptr inbounds float, float* %37, i64 3
store float 0.000000e+00, float* %38
%39 = load float, float* %8
%40 = fneg float %39
%41 = load float*, float** %3
%42 = getelementptr inbounds float, float* %41, i64 4
store float %40, float* %42
%43 = load float, float* %9
%44 = load float*, float** %3
%45 = getelementptr inbounds float, float* %44, i64 5
store float %43, float* %45
%46 = load float*, float** %3
%47 = getelementptr inbounds float, float* %46, i64 6
store float 0.000000e+00, float* %47
%48 = load float*, float** %3
%49 = getelementptr inbounds float, float* %48, i64 7
store float 0.000000e+00, float* %49
%50 = load float*, float** %3
%51 = getelementptr inbounds float, float* %50, i64 8
store float 0.000000e+00, float* %51
%52 = load float*, float** %3
%53 = getelementptr inbounds float, float* %52, i64 9
store float 0.000000e+00, float* %53
%54 = load float*, float** %3
%55 = getelementptr inbounds float, float* %54, i64 10
store float 1.000000e+00, float* %55
%56 = load float*, float** %3
%57 = getelementptr inbounds float, float* %56, i64 11
store float 0.000000e+00, float* %57
%58 = load float*, float** %4
%59 = getelementptr inbounds float, float* %58, i64 1
%60 = load float, float* %59
%61 = fpext float %60 to double
%62 = fcmp une double %61, 0.000000e+00
br i1 %62, label %63, label %554
63: ; preds = %28
%64 = load float*, float** %4
%65 = getelementptr inbounds float, float* %64, i64 1
%66 = load float, float* %65
%67 = fpext float %66 to double
%68 = fmul double %67, 0x400921FB54442D18
%69 = fdiv double %68, 3.600000e+02
%70 = fptrunc double %69 to float
store float %70, float* %10
%71 = load float, float* %10
%72 = call float @sinf(float %71)
store float %72, float* %8
%73 = load float, float* %10
%74 = call float @cosf(float %73)
store float %74, float* %9
%75 = load float, float* %9
%76 = getelementptr inbounds [4 x float], [4 x float]* %5, i64 0, i64 3
store float %75, float* %76
%77 = load float*, float** %3
%78 = getelementptr inbounds float, float* %77, i64 0
%79 = load float, float* %78
%80 = load float, float* %8
%81 = fmul float %79, %80
%82 = getelementptr inbounds [4 x float], [4 x float]* %5, i64 0, i64 0
store float %81, float* %82
%83 = load float*, float** %3
%84 = getelementptr inbounds float, float* %83, i64 1
%85 = load float, float* %84
%86 = load float, float* %8
%87 = fmul float %85, %86
%88 = getelementptr inbounds [4 x float], [4 x float]* %5, i64 0, i64 1
store float %87, float* %88
%89 = load float*, float** %3
%90 = getelementptr inbounds float, float* %89, i64 2
%91 = load float, float* %90
%92 = load float, float* %8
%93 = fmul float %91, %92
%94 = getelementptr inbounds [4 x float], [4 x float]* %5, i64 0, i64 2
store float %93, float* %94
%95 = getelementptr inbounds [4 x float], [4 x float]* %5, i64 0, i64 0
%96 = load float, float* %95
%97 = fneg float %96
%98 = getelementptr inbounds [4 x float], [4 x float]* %6, i64 0, i64 0
store float %97, float* %98
%99 = getelementptr inbounds [4 x float], [4 x float]* %5, i64 0, i64 1
%100 = load float, float* %99
%101 = fneg float %100
%102 = getelementptr inbounds [4 x float], [4 x float]* %6, i64 0, i64 1
store float %101, float* %102
%103 = getelementptr inbounds [4 x float], [4 x float]* %5, i64 0, i64 2
%104 = load float, float* %103
%105 = fneg float %104
%106 = getelementptr inbounds [4 x float], [4 x float]* %6, i64 0, i64 2
store float %105, float* %106
%107 = getelementptr inbounds [4 x float], [4 x float]* %5, i64 0, i64 3
%108 = load float, float* %107
%109 = getelementptr inbounds [4 x float], [4 x float]* %6, i64 0, i64 3
store float %108, float* %109
%110 = getelementptr inbounds [4 x float], [4 x float]* %5, i64 0, i64 3
%111 = load float, float* %110
%112 = load float*, float** %3
%113 = getelementptr inbounds float, float* %112, i64 4
%114 = getelementptr inbounds float, float* %113, i64 0
%115 = load float, float* %114
%116 = getelementptr inbounds [4 x float], [4 x float]* %5, i64 0, i64 0
%117 = load float, float* %116
%118 = load float*, float** %3
%119 = getelementptr inbounds float, float* %118, i64 4
%120 = getelementptr inbounds float, float* %119, i64 3
%121 = load float, float* %120
%122 = fmul float %117, %121
%123 = call float @llvm.fmuladd.f32(float %111, float %115, float %122)
%124 = getelementptr inbounds [4 x float], [4 x float]* %5, i64 0, i64 1
%125 = load float, float* %124
%126 = load float*, float** %3
%127 = getelementptr inbounds float, float* %126, i64 4
%128 = getelementptr inbounds float, float* %127, i64 2
%129 = load float, float* %128
%130 = call float @llvm.fmuladd.f32(float %125, float %129, float %123)
%131 = getelementptr inbounds [4 x float], [4 x float]* %5, i64 0, i64 2
%132 = load float, float* %131
%133 = load float*, float** %3
%134 = getelementptr inbounds float, float* %133, i64 4
%135 = getelementptr inbounds float, float* %134, i64 1
%136 = load float, float* %135
%137 = fneg float %132
%138 = call float @llvm.fmuladd.f32(float %137, float %136, float %130)
%139 = getelementptr inbounds [4 x float], [4 x float]* %7, i64 0, i64 0
store float %138, float* %139
%140 = getelementptr inbounds [4 x float], [4 x float]* %5, i64 0, i64 3
%141 = load float, float* %140
%142 = load float*, float** %3
%143 = getelementptr inbounds float, float* %142, i64 4
%144 = getelementptr inbounds float, float* %143, i64 1
%145 = load float, float* %144
%146 = getelementptr inbounds [4 x float], [4 x float]* %5, i64 0, i64 1
%147 = load float, float* %146
%148 = load float*, float** %3
%149 = getelementptr inbounds float, float* %148, i64 4
%150 = getelementptr inbounds float, float* %149, i64 3
%151 = load float, float* %150
%152 = fmul float %147, %151
%153 = call float @llvm.fmuladd.f32(float %141, float %145, float %152)
%154 = getelementptr inbounds [4 x float], [4 x float]* %5, i64 0, i64 2
%155 = load float, float* %154
%156 = load float*, float** %3
%157 = getelementptr inbounds float, float* %156, i64 4
%158 = getelementptr inbounds float, float* %157, i64 0
%159 = load float, float* %158
%160 = call float @llvm.fmuladd.f32(float %155, float %159, float %153)
%161 = getelementptr inbounds [4 x float], [4 x float]* %5, i64 0, i64 0
%162 = load float, float* %161
%163 = load float*, float** %3
%164 = getelementptr inbounds float, float* %163, i64 4
%165 = getelementptr inbounds float, float* %164, i64 2
%166 = load float, float* %165
%167 = fneg float %162
%168 = call float @llvm.fmuladd.f32(float %167, float %166, float %160)
%169 = getelementptr inbounds [4 x float], [4 x float]* %7, i64 0, i64 1
store float %168, float* %169
%170 = getelementptr inbounds [4 x float], [4 x float]* %5, i64 0, i64 3
%171 = load float, float* %170
%172 = load float*, float** %3
%173 = getelementptr inbounds float, float* %172, i64 4
%174 = getelementptr inbounds float, float* %173, i64 2
%175 = load float, float* %174
%176 = getelementptr inbounds [4 x float], [4 x float]* %5, i64 0, i64 2
%177 = load float, float* %176
%178 = load float*, float** %3
%179 = getelementptr inbounds float, float* %178, i64 4
%180 = getelementptr inbounds float, float* %179, i64 3
%181 = load float, float* %180
%182 = fmul float %177, %181
%183 = call float @llvm.fmuladd.f32(float %171, float %175, float %182)
%184 = getelementptr inbounds [4 x float], [4 x float]* %5, i64 0, i64 0
%185 = load float, float* %184
%186 = load float*, float** %3
%187 = getelementptr inbounds float, float* %186, i64 4
%188 = getelementptr inbounds float, float* %187, i64 1
%189 = load float, float* %188
%190 = call float @llvm.fmuladd.f32(float %185, float %189, float %183)
%191 = getelementptr inbounds [4 x float], [4 x float]* %5, i64 0, i64 1
%192 = load float, float* %191
%193 = load float*, float** %3
%194 = getelementptr inbounds float, float* %193, i64 4
%195 = getelementptr inbounds float, float* %194, i64 0
%196 = load float, float* %195
%197 = fneg float %192
%198 = call float @llvm.fmuladd.f32(float %197, float %196, float %190)
%199 = getelementptr inbounds [4 x float], [4 x float]* %7, i64 0, i64 2
store float %198, float* %199
%200 = getelementptr inbounds [4 x float], [4 x float]* %5, i64 0, i64 3
%201 = load float, float* %200
%202 = load float*, float** %3
%203 = getelementptr inbounds float, float* %202, i64 4
%204 = getelementptr inbounds float, float* %203, i64 3
%205 = load float, float* %204
%206 = getelementptr inbounds [4 x float], [4 x float]* %5, i64 0, i64 0
%207 = load float, float* %206
%208 = load float*, float** %3
%209 = getelementptr inbounds float, float* %208, i64 4
%210 = getelementptr inbounds float, float* %209, i64 0
%211 = load float, float* %210
%212 = fmul float %207, %211
%213 = fneg float %212
%214 = call float @llvm.fmuladd.f32(float %201, float %205, float %213)
%215 = getelementptr inbounds [4 x float], [4 x float]* %5, i64 0, i64 1
%216 = load float, float* %215
%217 = load float*, float** %3
%218 = getelementptr inbounds float, float* %217, i64 4
%219 = getelementptr inbounds float, float* %218, i64 1
%220 = load float, float* %219
%221 = fneg float %216
%222 = call float @llvm.fmuladd.f32(float %221, float %220, float %214)
%223 = getelementptr inbounds [4 x float], [4 x float]* %5, i64 0, i64 2
%224 = load float, float* %223
%225 = load float*, float** %3
%226 = getelementptr inbounds float, float* %225, i64 4
%227 = getelementptr inbounds float, float* %226, i64 2
%228 = load float, float* %227
%229 = fneg float %224
%230 = call float @llvm.fmuladd.f32(float %229, float %228, float %222)
%231 = getelementptr inbounds [4 x float], [4 x float]* %7, i64 0, i64 3
store float %230, float* %231
%232 = getelementptr inbounds [4 x float], [4 x float]* %7, i64 0, i64 3
%233 = load float, float* %232
%234 = getelementptr inbounds [4 x float], [4 x float]* %6, i64 0, i64 0
%235 = load float, float* %234
%236 = getelementptr inbounds [4 x float], [4 x float]* %7, i64 0, i64 0
%237 = load float, float* %236
%238 = getelementptr inbounds [4 x float], [4 x float]* %6, i64 0, i64 3
%239 = load float, float* %238
%240 = fmul float %237, %239
%241 = call float @llvm.fmuladd.f32(float %233, float %235, float %240)
%242 = getelementptr inbounds [4 x float], [4 x float]* %7, i64 0, i64 1
%243 = load float, float* %242
%244 = getelementptr inbounds [4 x float], [4 x float]* %6, i64 0, i64 2
%245 = load float, float* %244
%246 = call float @llvm.fmuladd.f32(float %243, float %245, float %241)
%247 = getelementptr inbounds [4 x float], [4 x float]* %7, i64 0, i64 2
%248 = load float, float* %247
%249 = getelementptr inbounds [4 x float], [4 x float]* %6, i64 0, i64 1
%250 = load float, float* %249
%251 = fneg float %248
%252 = call float @llvm.fmuladd.f32(float %251, float %250, float %246)
%253 = load float*, float** %3
%254 = getelementptr inbounds float, float* %253, i64 4
%255 = getelementptr inbounds float, float* %254, i64 0
store float %252, float* %255
%256 = getelementptr inbounds [4 x float], [4 x float]* %7, i64 0, i64 3
%257 = load float, float* %256
%258 = getelementptr inbounds [4 x float], [4 x float]* %6, i64 0, i64 1
%259 = load float, float* %258
%260 = getelementptr inbounds [4 x float], [4 x float]* %7, i64 0, i64 1
%261 = load float, float* %260
%262 = getelementptr inbounds [4 x float], [4 x float]* %6, i64 0, i64 3
%263 = load float, float* %262
%264 = fmul float %261, %263
%265 = call float @llvm.fmuladd.f32(float %257, float %259, float %264)
%266 = getelementptr inbounds [4 x float], [4 x float]* %7, i64 0, i64 2
%267 = load float, float* %266
%268 = getelementptr inbounds [4 x float], [4 x float]* %6, i64 0, i64 0
%269 = load float, float* %268
%270 = call float @llvm.fmuladd.f32(float %267, float %269, float %265)
%271 = getelementptr inbounds [4 x float], [4 x float]* %7, i64 0, i64 0
%272 = load float, float* %271
%273 = getelementptr inbounds [4 x float], [4 x float]* %6, i64 0, i64 2
%274 = load float, float* %273
%275 = fneg float %272
%276 = call float @llvm.fmuladd.f32(float %275, float %274, float %270)
%277 = load float*, float** %3
%278 = getelementptr inbounds float, float* %277, i64 4
%279 = getelementptr inbounds float, float* %278, i64 1
store float %276, float* %279
%280 = getelementptr inbounds [4 x float], [4 x float]* %7, i64 0, i64 3
%281 = load float, float* %280
%282 = getelementptr inbounds [4 x float], [4 x float]* %6, i64 0, i64 2
%283 = load float, float* %282
%284 = getelementptr inbounds [4 x float], [4 x float]* %7, i64 0, i64 2
%285 = load float, float* %284
%286 = getelementptr inbounds [4 x float], [4 x float]* %6, i64 0, i64 3
%287 = load float, float* %286
%288 = fmul float %285, %287
%289 = call float @llvm.fmuladd.f32(float %281, float %283, float %288)
%290 = getelementptr inbounds [4 x float], [4 x float]* %7, i64 0, i64 0
%291 = load float, float* %290
%292 = getelementptr inbounds [4 x float], [4 x float]* %6, i64 0, i64 1
%293 = load float, float* %292
%294 = call float @llvm.fmuladd.f32(float %291, float %293, float %289)
%295 = getelementptr inbounds [4 x float], [4 x float]* %7, i64 0, i64 1
%296 = load float, float* %295
%297 = getelementptr inbounds [4 x float], [4 x float]* %6, i64 0, i64 0
%298 = load float, float* %297
%299 = fneg float %296
%300 = call float @llvm.fmuladd.f32(float %299, float %298, float %294)
%301 = load float*, float** %3
%302 = getelementptr inbounds float, float* %301, i64 4
%303 = getelementptr inbounds float, float* %302, i64 2
store float %300, float* %303
%304 = getelementptr inbounds [4 x float], [4 x float]* %7, i64 0, i64 3
%305 = load float, float* %304
%306 = getelementptr inbounds [4 x float], [4 x float]* %6, i64 0, i64 3
%307 = load float, float* %306
%308 = getelementptr inbounds [4 x float], [4 x float]* %7, i64 0, i64 0
%309 = load float, float* %308
%310 = getelementptr inbounds [4 x float], [4 x float]* %6, i64 0, i64 0
%311 = load float, float* %310
%312 = fmul float %309, %311
%313 = fneg float %312
%314 = call float @llvm.fmuladd.f32(float %305, float %307, float %313)
%315 = getelementptr inbounds [4 x float], [4 x float]* %7, i64 0, i64 1
%316 = load float, float* %315
%317 = getelementptr inbounds [4 x float], [4 x float]* %6, i64 0, i64 1
%318 = load float, float* %317
%319 = fneg float %316
%320 = call float @llvm.fmuladd.f32(float %319, float %318, float %314)
%321 = getelementptr inbounds [4 x float], [4 x float]* %7, i64 0, i64 2
%322 = load float, float* %321
%323 = getelementptr inbounds [4 x float], [4 x float]* %6, i64 0, i64 2
%324 = load float, float* %323
%325 = fneg float %322
%326 = call float @llvm.fmuladd.f32(float %325, float %324, float %320)
%327 = load float*, float** %3
%328 = getelementptr inbounds float, float* %327, i64 4
%329 = getelementptr inbounds float, float* %328, i64 3
store float %326, float* %329
%330 = getelementptr inbounds [4 x float], [4 x float]* %5, i64 0, i64 3
%331 = load float, float* %330
%332 = load float*, float** %3
%333 = getelementptr inbounds float, float* %332, i64 8
%334 = getelementptr inbounds float, float* %333, i64 0
%335 = load float, float* %334
%336 = getelementptr inbounds [4 x float], [4 x float]* %5, i64 0, i64 0
%337 = load float, float* %336
%338 = load float*, float** %3
%339 = getelementptr inbounds float, float* %338, i64 8
%340 = getelementptr inbounds float, float* %339, i64 3
%341 = load float, float* %340
%342 = fmul float %337, %341
%343 = call float @llvm.fmuladd.f32(float %331, float %335, float %342)
%344 = getelementptr inbounds [4 x float], [4 x float]* %5, i64 0, i64 1
%345 = load float, float* %344
%346 = load float*, float** %3
%347 = getelementptr inbounds float, float* %346, i64 8
%348 = getelementptr inbounds float, float* %347, i64 2
%349 = load float, float* %348
%350 = call float @llvm.fmuladd.f32(float %345, float %349, float %343)
%351 = getelementptr inbounds [4 x float], [4 x float]* %5, i64 0, i64 2
%352 = load float, float* %351
%353 = load float*, float** %3
%354 = getelementptr inbounds float, float* %353, i64 8
%355 = getelementptr inbounds float, float* %354, i64 1
%356 = load float, float* %355
%357 = fneg float %352
%358 = call float @llvm.fmuladd.f32(float %357, float %356, float %350)
%359 = getelementptr inbounds [4 x float], [4 x float]* %7, i64 0, i64 0
store float %358, float* %359
%360 = getelementptr inbounds [4 x float], [4 x float]* %5, i64 0, i64 3
%361 = load float, float* %360
%362 = load float*, float** %3
%363 = getelementptr inbounds float, float* %362, i64 8
%364 = getelementptr inbounds float, float* %363, i64 1
%365 = load float, float* %364
%366 = getelementptr inbounds [4 x float], [4 x float]* %5, i64 0, i64 1
%367 = load float, float* %366
%368 = load float*, float** %3
%369 = getelementptr inbounds float, float* %368, i64 8
%370 = getelementptr inbounds float, float* %369, i64 3
%371 = load float, float* %370
%372 = fmul float %367, %371
%373 = call float @llvm.fmuladd.f32(float %361, float %365, float %372)
%374 = getelementptr inbounds [4 x float], [4 x float]* %5, i64 0, i64 2
%375 = load float, float* %374
%376 = load float*, float** %3
%377 = getelementptr inbounds float, float* %376, i64 8
%378 = getelementptr inbounds float, float* %377, i64 0
%379 = load float, float* %378
%380 = call float @llvm.fmuladd.f32(float %375, float %379, float %373)
%381 = getelementptr inbounds [4 x float], [4 x float]* %5, i64 0, i64 0
%382 = load float, float* %381
%383 = load float*, float** %3
%384 = getelementptr inbounds float, float* %383, i64 8
%385 = getelementptr inbounds float, float* %384, i64 2
%386 = load float, float* %385
%387 = fneg float %382
%388 = call float @llvm.fmuladd.f32(float %387, float %386, float %380)
%389 = getelementptr inbounds [4 x float], [4 x float]* %7, i64 0, i64 1
store float %388, float* %389
%390 = getelementptr inbounds [4 x float], [4 x float]* %5, i64 0, i64 3
%391 = load float, float* %390
%392 = load float*, float** %3
%393 = getelementptr inbounds float, float* %392, i64 8
%394 = getelementptr inbounds float, float* %393, i64 2
%395 = load float, float* %394
%396 = getelementptr inbounds [4 x float], [4 x float]* %5, i64 0, i64 2
%397 = load float, float* %396
%398 = load float*, float** %3
%399 = getelementptr inbounds float, float* %398, i64 8
%400 = getelementptr inbounds float, float* %399, i64 3
%401 = load float, float* %400
%402 = fmul float %397, %401
%403 = call float @llvm.fmuladd.f32(float %391, float %395, float %402)
%404 = getelementptr inbounds [4 x float], [4 x float]* %5, i64 0, i64 0
%405 = load float, float* %404
%406 = load float*, float** %3
%407 = getelementptr inbounds float, float* %406, i64 8
%408 = getelementptr inbounds float, float* %407, i64 1
%409 = load float, float* %408
%410 = call float @llvm.fmuladd.f32(float %405, float %409, float %403)
%411 = getelementptr inbounds [4 x float], [4 x float]* %5, i64 0, i64 1
%412 = load float, float* %411
%413 = load float*, float** %3
%414 = getelementptr inbounds float, float* %413, i64 8
%415 = getelementptr inbounds float, float* %414, i64 0
%416 = load float, float* %415
%417 = fneg float %412
%418 = call float @llvm.fmuladd.f32(float %417, float %416, float %410)
%419 = getelementptr inbounds [4 x float], [4 x float]* %7, i64 0, i64 2
store float %418, float* %419
%420 = getelementptr inbounds [4 x float], [4 x float]* %5, i64 0, i64 3
%421 = load float, float* %420
%422 = load float*, float** %3
%423 = getelementptr inbounds float, float* %422, i64 8
%424 = getelementptr inbounds float, float* %423, i64 3
%425 = load float, float* %424
%426 = getelementptr inbounds [4 x float], [4 x float]* %5, i64 0, i64 0
%427 = load float, float* %426
%428 = load float*, float** %3
%429 = getelementptr inbounds float, float* %428, i64 8
%430 = getelementptr inbounds float, float* %429, i64 0
%431 = load float, float* %430
%432 = fmul float %427, %431
%433 = fneg float %432
%434 = call float @llvm.fmuladd.f32(float %421, float %425, float %433)
%435 = getelementptr inbounds [4 x float], [4 x float]* %5, i64 0, i64 1
%436 = load float, float* %435
%437 = load float*, float** %3
%438 = getelementptr inbounds float, float* %437, i64 8
%439 = getelementptr inbounds float, float* %438, i64 1
%440 = load float, float* %439
%441 = fneg float %436
%442 = call float @llvm.fmuladd.f32(float %441, float %440, float %434)
%443 = getelementptr inbounds [4 x float], [4 x float]* %5, i64 0, i64 2
%444 = load float, float* %443
%445 = load float*, float** %3
%446 = getelementptr inbounds float, float* %445, i64 8
%447 = getelementptr inbounds float, float* %446, i64 2
%448 = load float, float* %447
%449 = fneg float %444
%450 = call float @llvm.fmuladd.f32(float %449, float %448, float %442)
%451 = getelementptr inbounds [4 x float], [4 x float]* %7, i64 0, i64 3
store float %450, float* %451
%452 = getelementptr inbounds [4 x float], [4 x float]* %7, i64 0, i64 3
%453 = load float, float* %452
%454 = getelementptr inbounds [4 x float], [4 x float]* %6, i64 0, i64 0
%455 = load float, float* %454
%456 = getelementptr inbounds [4 x float], [4 x float]* %7, i64 0, i64 0
%457 = load float, float* %456
%458 = getelementptr inbounds [4 x float], [4 x float]* %6, i64 0, i64 3
%459 = load float, float* %458
%460 = fmul float %457, %459
%461 = call float @llvm.fmuladd.f32(float %453, float %455, float %460)
%462 = getelementptr inbounds [4 x float], [4 x float]* %7, i64 0, i64 1
%463 = load float, float* %462
%464 = getelementptr inbounds [4 x float], [4 x float]* %6, i64 0, i64 2
%465 = load float, float* %464
%466 = call float @llvm.fmuladd.f32(float %463, float %465, float %461)
%467 = getelementptr inbounds [4 x float], [4 x float]* %7, i64 0, i64 2
%468 = load float, float* %467
%469 = getelementptr inbounds [4 x float], [4 x float]* %6, i64 0, i64 1
%470 = load float, float* %469
%471 = fneg float %468
%472 = call float @llvm.fmuladd.f32(float %471, float %470, float %466)
%473 = load float*, float** %3
%474 = getelementptr inbounds float, float* %473, i64 8
%475 = getelementptr inbounds float, float* %474, i64 0
store float %472, float* %475
%476 = getelementptr inbounds [4 x float], [4 x float]* %7, i64 0, i64 3
%477 = load float, float* %476
%478 = getelementptr inbounds [4 x float], [4 x float]* %6, i64 0, i64 1
%479 = load float, float* %478
%480 = getelementptr inbounds [4 x float], [4 x float]* %7, i64 0, i64 1
%481 = load float, float* %480
%482 = getelementptr inbounds [4 x float], [4 x float]* %6, i64 0, i64 3
%483 = load float, float* %482
%484 = fmul float %481, %483
%485 = call float @llvm.fmuladd.f32(float %477, float %479, float %484)
%486 = getelementptr inbounds [4 x float], [4 x float]* %7, i64 0, i64 2
%487 = load float, float* %486
%488 = getelementptr inbounds [4 x float], [4 x float]* %6, i64 0, i64 0
%489 = load float, float* %488
%490 = call float @llvm.fmuladd.f32(float %487, float %489, float %485)
%491 = getelementptr inbounds [4 x float], [4 x float]* %7, i64 0, i64 0
%492 = load float, float* %491
%493 = getelementptr inbounds [4 x float], [4 x float]* %6, i64 0, i64 2
%494 = load float, float* %493
%495 = fneg float %492
%496 = call float @llvm.fmuladd.f32(float %495, float %494, float %490)
%497 = load float*, float** %3
%498 = getelementptr inbounds float, float* %497, i64 8
%499 = getelementptr inbounds float, float* %498, i64 1
store float %496, float* %499
%500 = getelementptr inbounds [4 x float], [4 x float]* %7, i64 0, i64 3
%501 = load float, float* %500
%502 = getelementptr inbounds [4 x float], [4 x float]* %6, i64 0, i64 2
%503 = load float, float* %502
%504 = getelementptr inbounds [4 x float], [4 x float]* %7, i64 0, i64 2
%505 = load float, float* %504
%506 = getelementptr inbounds [4 x float], [4 x float]* %6, i64 0, i64 3
%507 = load float, float* %506
%508 = fmul float %505, %507
%509 = call float @llvm.fmuladd.f32(float %501, float %503, float %508)
%510 = getelementptr inbounds [4 x float], [4 x float]* %7, i64 0, i64 0
%511 = load float, float* %510
%512 = getelementptr inbounds [4 x float], [4 x float]* %6, i64 0, i64 1
%513 = load float, float* %512
%514 = call float @llvm.fmuladd.f32(float %511, float %513, float %509)
%515 = getelementptr inbounds [4 x float], [4 x float]* %7, i64 0, i64 1
%516 = load float, float* %515
%517 = getelementptr inbounds [4 x float], [4 x float]* %6, i64 0, i64 0
%518 = load float, float* %517
%519 = fneg float %516
%520 = call float @llvm.fmuladd.f32(float %519, float %518, float %514)
%521 = load float*, float** %3
%522 = getelementptr inbounds float, float* %521, i64 8
%523 = getelementptr inbounds float, float* %522, i64 2
store float %520, float* %523
%524 = getelementptr inbounds [4 x float], [4 x float]* %7, i64 0, i64 3
%525 = load float, float* %524
%526 = getelementptr inbounds [4 x float], [4 x float]* %6, i64 0, i64 3
%527 = load float, float* %526
%528 = getelementptr inbounds [4 x float], [4 x float]* %7, i64 0, i64 0
%529 = load float, float* %528
%530 = getelementptr inbounds [4 x float], [4 x float]* %6, i64 0, i64 0
%531 = load float, float* %530
%532 = fmul float %529, %531
%533 = fneg float %532
%534 = call float @llvm.fmuladd.f32(float %525, float %527, float %533)
%535 = getelementptr inbounds [4 x float], [4 x float]* %7, i64 0, i64 1
%536 = load float, float* %535
%537 = getelementptr inbounds [4 x float], [4 x float]* %6, i64 0, i64 1
%538 = load float, float* %537
%539 = fneg float %536
%540 = call float @llvm.fmuladd.f32(float %539, float %538, float %534)
%541 = getelementptr inbounds [4 x float], [4 x float]* %7, i64 0, i64 2
%542 = load float, float* %541
%543 = getelementptr inbounds [4 x float], [4 x float]* %6, i64 0, i64 2
%544 = load float, float* %543
%545 = fneg float %542
%546 = call float @llvm.fmuladd.f32(float %545, float %544, float %540)
%547 = load float*, float** %3
%548 = getelementptr inbounds float, float* %547, i64 8
%549 = getelementptr inbounds float, float* %548, i64 3
store float %546, float* %549
%550 = load float*, float** %3
%551 = getelementptr inbounds float, float* %550, i64 7
store float 0.000000e+00, float* %551
%552 = load float*, float** %3
%553 = getelementptr inbounds float, float* %552, i64 11
store float 0.000000e+00, float* %553
br label %554
554: ; preds = %63, %28
%555 = load float*, float** %4
%556 = getelementptr inbounds float, float* %555, i64 2
%557 = load float, float* %556
%558 = fpext float %557 to double
%559 = fcmp une double %558, 0.000000e+00
br i1 %559, label %560, label %1051
560: ; preds = %554
%561 = load float*, float** %4
%562 = getelementptr inbounds float, float* %561, i64 2
%563 = load float, float* %562
%564 = fpext float %563 to double
%565 = fmul double %564, 0x400921FB54442D18
%566 = fdiv double %565, 3.600000e+02
%567 = fptrunc double %566 to float
store float %567, float* %10
%568 = load float, float* %10
%569 = call float @sinf(float %568)
store float %569, float* %8
%570 = load float, float* %10
%571 = call float @cosf(float %570)
store float %571, float* %9
%572 = load float, float* %9
%573 = getelementptr inbounds [4 x float], [4 x float]* %5, i64 0, i64 3
store float %572, float* %573
%574 = load float*, float** %3
%575 = getelementptr inbounds float, float* %574, i64 4
%576 = load float, float* %575
%577 = load float, float* %8
%578 = fmul float %576, %577
%579 = getelementptr inbounds [4 x float], [4 x float]* %5, i64 0, i64 0
store float %578, float* %579
%580 = load float*, float** %3
%581 = getelementptr inbounds float, float* %580, i64 5
%582 = load float, float* %581
%583 = load float, float* %8
%584 = fmul float %582, %583
%585 = getelementptr inbounds [4 x float], [4 x float]* %5, i64 0, i64 1
store float %584, float* %585
%586 = load float*, float** %3
%587 = getelementptr inbounds float, float* %586, i64 6
%588 = load float, float* %587
%589 = load float, float* %8
%590 = fmul float %588, %589
%591 = getelementptr inbounds [4 x float], [4 x float]* %5, i64 0, i64 2
store float %590, float* %591
%592 = getelementptr inbounds [4 x float], [4 x float]* %5, i64 0, i64 0
%593 = load float, float* %592
%594 = fneg float %593
%595 = getelementptr inbounds [4 x float], [4 x float]* %6, i64 0, i64 0
store float %594, float* %595
%596 = getelementptr inbounds [4 x float], [4 x float]* %5, i64 0, i64 1
%597 = load float, float* %596
%598 = fneg float %597
%599 = getelementptr inbounds [4 x float], [4 x float]* %6, i64 0, i64 1
store float %598, float* %599
%600 = getelementptr inbounds [4 x float], [4 x float]* %5, i64 0, i64 2
%601 = load float, float* %600
%602 = fneg float %601
%603 = getelementptr inbounds [4 x float], [4 x float]* %6, i64 0, i64 2
store float %602, float* %603
%604 = getelementptr inbounds [4 x float], [4 x float]* %5, i64 0, i64 3
%605 = load float, float* %604
%606 = getelementptr inbounds [4 x float], [4 x float]* %6, i64 0, i64 3
store float %605, float* %606
%607 = getelementptr inbounds [4 x float], [4 x float]* %5, i64 0, i64 3
%608 = load float, float* %607
%609 = load float*, float** %3
%610 = getelementptr inbounds float, float* %609, i64 0
%611 = getelementptr inbounds float, float* %610, i64 0
%612 = load float, float* %611
%613 = getelementptr inbounds [4 x float], [4 x float]* %5, i64 0, i64 0
%614 = load float, float* %613
%615 = load float*, float** %3
%616 = getelementptr inbounds float, float* %615, i64 0
%617 = getelementptr inbounds float, float* %616, i64 3
%618 = load float, float* %617
%619 = fmul float %614, %618
%620 = call float @llvm.fmuladd.f32(float %608, float %612, float %619)
%621 = getelementptr inbounds [4 x float], [4 x float]* %5, i64 0, i64 1
%622 = load float, float* %621
%623 = load float*, float** %3
%624 = getelementptr inbounds float, float* %623, i64 0
%625 = getelementptr inbounds float, float* %624, i64 2
%626 = load float, float* %625
%627 = call float @llvm.fmuladd.f32(float %622, float %626, float %620)
%628 = getelementptr inbounds [4 x float], [4 x float]* %5, i64 0, i64 2
%629 = load float, float* %628
%630 = load float*, float** %3
%631 = getelementptr inbounds float, float* %630, i64 0
%632 = getelementptr inbounds float, float* %631, i64 1
%633 = load float, float* %632
%634 = fneg float %629
%635 = call float @llvm.fmuladd.f32(float %634, float %633, float %627)
%636 = getelementptr inbounds [4 x float], [4 x float]* %7, i64 0, i64 0
store float %635, float* %636
%637 = getelementptr inbounds [4 x float], [4 x float]* %5, i64 0, i64 3
%638 = load float, float* %637
%639 = load float*, float** %3
%640 = getelementptr inbounds float, float* %639, i64 0
%641 = getelementptr inbounds float, float* %640, i64 1
%642 = load float, float* %641
%643 = getelementptr inbounds [4 x float], [4 x float]* %5, i64 0, i64 1
%644 = load float, float* %643
%645 = load float*, float** %3
%646 = getelementptr inbounds float, float* %645, i64 0
%647 = getelementptr inbounds float, float* %646, i64 3
%648 = load float, float* %647
%649 = fmul float %644, %648
%650 = call float @llvm.fmuladd.f32(float %638, float %642, float %649)
%651 = getelementptr inbounds [4 x float], [4 x float]* %5, i64 0, i64 2
%652 = load float, float* %651
%653 = load float*, float** %3
%654 = getelementptr inbounds float, float* %653, i64 0
%655 = getelementptr inbounds float, float* %654, i64 0
%656 = load float, float* %655
%657 = call float @llvm.fmuladd.f32(float %652, float %656, float %650)
%658 = getelementptr inbounds [4 x float], [4 x float]* %5, i64 0, i64 0
%659 = load float, float* %658
%660 = load float*, float** %3
%661 = getelementptr inbounds float, float* %660, i64 0
%662 = getelementptr inbounds float, float* %661, i64 2
%663 = load float, float* %662
%664 = fneg float %659
%665 = call float @llvm.fmuladd.f32(float %664, float %663, float %657)
%666 = getelementptr inbounds [4 x float], [4 x float]* %7, i64 0, i64 1
store float %665, float* %666
%667 = getelementptr inbounds [4 x float], [4 x float]* %5, i64 0, i64 3
%668 = load float, float* %667
%669 = load float*, float** %3
%670 = getelementptr inbounds float, float* %669, i64 0
%671 = getelementptr inbounds float, float* %670, i64 2
%672 = load float, float* %671
%673 = getelementptr inbounds [4 x float], [4 x float]* %5, i64 0, i64 2
%674 = load float, float* %673
%675 = load float*, float** %3
%676 = getelementptr inbounds float, float* %675, i64 0
%677 = getelementptr inbounds float, float* %676, i64 3
%678 = load float, float* %677
%679 = fmul float %674, %678
%680 = call float @llvm.fmuladd.f32(float %668, float %672, float %679)
%681 = getelementptr inbounds [4 x float], [4 x float]* %5, i64 0, i64 0
%682 = load float, float* %681
%683 = load float*, float** %3
%684 = getelementptr inbounds float, float* %683, i64 0
%685 = getelementptr inbounds float, float* %684, i64 1
%686 = load float, float* %685
%687 = call float @llvm.fmuladd.f32(float %682, float %686, float %680)
%688 = getelementptr inbounds [4 x float], [4 x float]* %5, i64 0, i64 1
%689 = load float, float* %688
%690 = load float*, float** %3
%691 = getelementptr inbounds float, float* %690, i64 0
%692 = getelementptr inbounds float, float* %691, i64 0
%693 = load float, float* %692
%694 = fneg float %689
%695 = call float @llvm.fmuladd.f32(float %694, float %693, float %687)
%696 = getelementptr inbounds [4 x float], [4 x float]* %7, i64 0, i64 2
store float %695, float* %696
%697 = getelementptr inbounds [4 x float], [4 x float]* %5, i64 0, i64 3
%698 = load float, float* %697
%699 = load float*, float** %3
%700 = getelementptr inbounds float, float* %699, i64 0
%701 = getelementptr inbounds float, float* %700, i64 3
%702 = load float, float* %701
%703 = getelementptr inbounds [4 x float], [4 x float]* %5, i64 0, i64 0
%704 = load float, float* %703
%705 = load float*, float** %3
%706 = getelementptr inbounds float, float* %705, i64 0
%707 = getelementptr inbounds float, float* %706, i64 0
%708 = load float, float* %707
%709 = fmul float %704, %708
%710 = fneg float %709
%711 = call float @llvm.fmuladd.f32(float %698, float %702, float %710)
%712 = getelementptr inbounds [4 x float], [4 x float]* %5, i64 0, i64 1
%713 = load float, float* %712
%714 = load float*, float** %3
%715 = getelementptr inbounds float, float* %714, i64 0
%716 = getelementptr inbounds float, float* %715, i64 1
%717 = load float, float* %716
%718 = fneg float %713
%719 = call float @llvm.fmuladd.f32(float %718, float %717, float %711)
%720 = getelementptr inbounds [4 x float], [4 x float]* %5, i64 0, i64 2
%721 = load float, float* %720
%722 = load float*, float** %3
%723 = getelementptr inbounds float, float* %722, i64 0
%724 = getelementptr inbounds float, float* %723, i64 2
%725 = load float, float* %724
%726 = fneg float %721
%727 = call float @llvm.fmuladd.f32(float %726, float %725, float %719)
%728 = getelementptr inbounds [4 x float], [4 x float]* %7, i64 0, i64 3
store float %727, float* %728
%729 = getelementptr inbounds [4 x float], [4 x float]* %7, i64 0, i64 3
%730 = load float, float* %729
%731 = getelementptr inbounds [4 x float], [4 x float]* %6, i64 0, i64 0
%732 = load float, float* %731
%733 = getelementptr inbounds [4 x float], [4 x float]* %7, i64 0, i64 0
%734 = load float, float* %733
%735 = getelementptr inbounds [4 x float], [4 x float]* %6, i64 0, i64 3
%736 = load float, float* %735
%737 = fmul float %734, %736
%738 = call float @llvm.fmuladd.f32(float %730, float %732, float %737)
%739 = getelementptr inbounds [4 x float], [4 x float]* %7, i64 0, i64 1
%740 = load float, float* %739
%741 = getelementptr inbounds [4 x float], [4 x float]* %6, i64 0, i64 2
%742 = load float, float* %741
%743 = call float @llvm.fmuladd.f32(float %740, float %742, float %738)
%744 = getelementptr inbounds [4 x float], [4 x float]* %7, i64 0, i64 2
%745 = load float, float* %744
%746 = getelementptr inbounds [4 x float], [4 x float]* %6, i64 0, i64 1
%747 = load float, float* %746
%748 = fneg float %745
%749 = call float @llvm.fmuladd.f32(float %748, float %747, float %743)
%750 = load float*, float** %3
%751 = getelementptr inbounds float, float* %750, i64 0
%752 = getelementptr inbounds float, float* %751, i64 0
store float %749, float* %752
%753 = getelementptr inbounds [4 x float], [4 x float]* %7, i64 0, i64 3
%754 = load float, float* %753
%755 = getelementptr inbounds [4 x float], [4 x float]* %6, i64 0, i64 1
%756 = load float, float* %755
%757 = getelementptr inbounds [4 x float], [4 x float]* %7, i64 0, i64 1
%758 = load float, float* %757
%759 = getelementptr inbounds [4 x float], [4 x float]* %6, i64 0, i64 3
%760 = load float, float* %759
%761 = fmul float %758, %760
%762 = call float @llvm.fmuladd.f32(float %754, float %756, float %761)
%763 = getelementptr inbounds [4 x float], [4 x float]* %7, i64 0, i64 2
%764 = load float, float* %763
%765 = getelementptr inbounds [4 x float], [4 x float]* %6, i64 0, i64 0
%766 = load float, float* %765
%767 = call float @llvm.fmuladd.f32(float %764, float %766, float %762)
%768 = getelementptr inbounds [4 x float], [4 x float]* %7, i64 0, i64 0
%769 = load float, float* %768
%770 = getelementptr inbounds [4 x float], [4 x float]* %6, i64 0, i64 2
%771 = load float, float* %770
%772 = fneg float %769
%773 = call float @llvm.fmuladd.f32(float %772, float %771, float %767)
%774 = load float*, float** %3
%775 = getelementptr inbounds float, float* %774, i64 0
%776 = getelementptr inbounds float, float* %775, i64 1
store float %773, float* %776
%777 = getelementptr inbounds [4 x float], [4 x float]* %7, i64 0, i64 3
%778 = load float, float* %777
%779 = getelementptr inbounds [4 x float], [4 x float]* %6, i64 0, i64 2
%780 = load float, float* %779
%781 = getelementptr inbounds [4 x float], [4 x float]* %7, i64 0, i64 2
%782 = load float, float* %781
%783 = getelementptr inbounds [4 x float], [4 x float]* %6, i64 0, i64 3
%784 = load float, float* %783
%785 = fmul float %782, %784
%786 = call float @llvm.fmuladd.f32(float %778, float %780, float %785)
%787 = getelementptr inbounds [4 x float], [4 x float]* %7, i64 0, i64 0
%788 = load float, float* %787
%789 = getelementptr inbounds [4 x float], [4 x float]* %6, i64 0, i64 1
%790 = load float, float* %789
%791 = call float @llvm.fmuladd.f32(float %788, float %790, float %786)
%792 = getelementptr inbounds [4 x float], [4 x float]* %7, i64 0, i64 1
%793 = load float, float* %792
%794 = getelementptr inbounds [4 x float], [4 x float]* %6, i64 0, i64 0
%795 = load float, float* %794
%796 = fneg float %793
%797 = call float @llvm.fmuladd.f32(float %796, float %795, float %791)
%798 = load float*, float** %3
%799 = getelementptr inbounds float, float* %798, i64 0
%800 = getelementptr inbounds float, float* %799, i64 2
store float %797, float* %800
%801 = getelementptr inbounds [4 x float], [4 x float]* %7, i64 0, i64 3
%802 = load float, float* %801
%803 = getelementptr inbounds [4 x float], [4 x float]* %6, i64 0, i64 3
%804 = load float, float* %803
%805 = getelementptr inbounds [4 x float], [4 x float]* %7, i64 0, i64 0
%806 = load float, float* %805
%807 = getelementptr inbounds [4 x float], [4 x float]* %6, i64 0, i64 0
%808 = load float, float* %807
%809 = fmul float %806, %808
%810 = fneg float %809
%811 = call float @llvm.fmuladd.f32(float %802, float %804, float %810)
%812 = getelementptr inbounds [4 x float], [4 x float]* %7, i64 0, i64 1
%813 = load float, float* %812
%814 = getelementptr inbounds [4 x float], [4 x float]* %6, i64 0, i64 1
%815 = load float, float* %814
%816 = fneg float %813
%817 = call float @llvm.fmuladd.f32(float %816, float %815, float %811)
%818 = getelementptr inbounds [4 x float], [4 x float]* %7, i64 0, i64 2
%819 = load float, float* %818
%820 = getelementptr inbounds [4 x float], [4 x float]* %6, i64 0, i64 2
%821 = load float, float* %820
%822 = fneg float %819
%823 = call float @llvm.fmuladd.f32(float %822, float %821, float %817)
%824 = load float*, float** %3
%825 = getelementptr inbounds float, float* %824, i64 0
%826 = getelementptr inbounds float, float* %825, i64 3
store float %823, float* %826
%827 = getelementptr inbounds [4 x float], [4 x float]* %5, i64 0, i64 3
%828 = load float, float* %827
%829 = load float*, float** %3
%830 = getelementptr inbounds float, float* %829, i64 8
%831 = getelementptr inbounds float, float* %830, i64 0
%832 = load float, float* %831
%833 = getelementptr inbounds [4 x float], [4 x float]* %5, i64 0, i64 0
%834 = load float, float* %833
%835 = load float*, float** %3
%836 = getelementptr inbounds float, float* %835, i64 8
%837 = getelementptr inbounds float, float* %836, i64 3
%838 = load float, float* %837
%839 = fmul float %834, %838
%840 = call float @llvm.fmuladd.f32(float %828, float %832, float %839)
%841 = getelementptr inbounds [4 x float], [4 x float]* %5, i64 0, i64 1
%842 = load float, float* %841
%843 = load float*, float** %3
%844 = getelementptr inbounds float, float* %843, i64 8
%845 = getelementptr inbounds float, float* %844, i64 2
%846 = load float, float* %845
%847 = call float @llvm.fmuladd.f32(float %842, float %846, float %840)
%848 = getelementptr inbounds [4 x float], [4 x float]* %5, i64 0, i64 2
%849 = load float, float* %848
%850 = load float*, float** %3
%851 = getelementptr inbounds float, float* %850, i64 8
%852 = getelementptr inbounds float, float* %851, i64 1
%853 = load float, float* %852
%854 = fneg float %849
%855 = call float @llvm.fmuladd.f32(float %854, float %853, float %847)
%856 = getelementptr inbounds [4 x float], [4 x float]* %7, i64 0, i64 0
store float %855, float* %856
%857 = getelementptr inbounds [4 x float], [4 x float]* %5, i64 0, i64 3
%858 = load float, float* %857
%859 = load float*, float** %3
%860 = getelementptr inbounds float, float* %859, i64 8
%861 = getelementptr inbounds float, float* %860, i64 1
%862 = load float, float* %861
%863 = getelementptr inbounds [4 x float], [4 x float]* %5, i64 0, i64 1
%864 = load float, float* %863
%865 = load float*, float** %3
%866 = getelementptr inbounds float, float* %865, i64 8
%867 = getelementptr inbounds float, float* %866, i64 3
%868 = load float, float* %867
%869 = fmul float %864, %868
%870 = call float @llvm.fmuladd.f32(float %858, float %862, float %869)
%871 = getelementptr inbounds [4 x float], [4 x float]* %5, i64 0, i64 2
%872 = load float, float* %871
%873 = load float*, float** %3
%874 = getelementptr inbounds float, float* %873, i64 8
%875 = getelementptr inbounds float, float* %874, i64 0
%876 = load float, float* %875
%877 = call float @llvm.fmuladd.f32(float %872, float %876, float %870)
%878 = getelementptr inbounds [4 x float], [4 x float]* %5, i64 0, i64 0
%879 = load float, float* %878
%880 = load float*, float** %3
%881 = getelementptr inbounds float, float* %880, i64 8
%882 = getelementptr inbounds float, float* %881, i64 2
%883 = load float, float* %882
%884 = fneg float %879
%885 = call float @llvm.fmuladd.f32(float %884, float %883, float %877)
%886 = getelementptr inbounds [4 x float], [4 x float]* %7, i64 0, i64 1
store float %885, float* %886
%887 = getelementptr inbounds [4 x float], [4 x float]* %5, i64 0, i64 3
%888 = load float, float* %887
%889 = load float*, float** %3
%890 = getelementptr inbounds float, float* %889, i64 8
%891 = getelementptr inbounds float, float* %890, i64 2
%892 = load float, float* %891
%893 = getelementptr inbounds [4 x float], [4 x float]* %5, i64 0, i64 2
%894 = load float, float* %893
%895 = load float*, float** %3
%896 = getelementptr inbounds float, float* %895, i64 8
%897 = getelementptr inbounds float, float* %896, i64 3
%898 = load float, float* %897
%899 = fmul float %894, %898
%900 = call float @llvm.fmuladd.f32(float %888, float %892, float %899)
%901 = getelementptr inbounds [4 x float], [4 x float]* %5, i64 0, i64 0
%902 = load float, float* %901
%903 = load float*, float** %3
%904 = getelementptr inbounds float, float* %903, i64 8
%905 = getelementptr inbounds float, float* %904, i64 1
%906 = load float, float* %905
%907 = call float @llvm.fmuladd.f32(float %902, float %906, float %900)
%908 = getelementptr inbounds [4 x float], [4 x float]* %5, i64 0, i64 1
%909 = load float, float* %908
%910 = load float*, float** %3
%911 = getelementptr inbounds float, float* %910, i64 8
%912 = getelementptr inbounds float, float* %911, i64 0
%913 = load float, float* %912
%914 = fneg float %909
%915 = call float @llvm.fmuladd.f32(float %914, float %913, float %907)
%916 = getelementptr inbounds [4 x float], [4 x float]* %7, i64 0, i64 2
store float %915, float* %916
%917 = getelementptr inbounds [4 x float], [4 x float]* %5, i64 0, i64 3
%918 = load float, float* %917
%919 = load float*, float** %3
%920 = getelementptr inbounds float, float* %919, i64 8
%921 = getelementptr inbounds float, float* %920, i64 3
%922 = load float, float* %921
%923 = getelementptr inbounds [4 x float], [4 x float]* %5, i64 0, i64 0
%924 = load float, float* %923
%925 = load float*, float** %3
%926 = getelementptr inbounds float, float* %925, i64 8
%927 = getelementptr inbounds float, float* %926, i64 0
%928 = load float, float* %927
%929 = fmul float %924, %928
%930 = fneg float %929
%931 = call float @llvm.fmuladd.f32(float %918, float %922, float %930)
%932 = getelementptr inbounds [4 x float], [4 x float]* %5, i64 0, i64 1
%933 = load float, float* %932
%934 = load float*, float** %3
%935 = getelementptr inbounds float, float* %934, i64 8
%936 = getelementptr inbounds float, float* %935, i64 1
%937 = load float, float* %936
%938 = fneg float %933
%939 = call float @llvm.fmuladd.f32(float %938, float %937, float %931)
%940 = getelementptr inbounds [4 x float], [4 x float]* %5, i64 0, i64 2
%941 = load float, float* %940
%942 = load float*, float** %3
%943 = getelementptr inbounds float, float* %942, i64 8
%944 = getelementptr inbounds float, float* %943, i64 2
%945 = load float, float* %944
%946 = fneg float %941
%947 = call float @llvm.fmuladd.f32(float %946, float %945, float %939)
%948 = getelementptr inbounds [4 x float], [4 x float]* %7, i64 0, i64 3
store float %947, float* %948
%949 = getelementptr inbounds [4 x float], [4 x float]* %7, i64 0, i64 3
%950 = load float, float* %949
%951 = getelementptr inbounds [4 x float], [4 x float]* %6, i64 0, i64 0
%952 = load float, float* %951
%953 = getelementptr inbounds [4 x float], [4 x float]* %7, i64 0, i64 0
%954 = load float, float* %953
%955 = getelementptr inbounds [4 x float], [4 x float]* %6, i64 0, i64 3
%956 = load float, float* %955
%957 = fmul float %954, %956
%958 = call float @llvm.fmuladd.f32(float %950, float %952, float %957)
%959 = getelementptr inbounds [4 x float], [4 x float]* %7, i64 0, i64 1
%960 = load float, float* %959
%961 = getelementptr inbounds [4 x float], [4 x float]* %6, i64 0, i64 2
%962 = load float, float* %961
%963 = call float @llvm.fmuladd.f32(float %960, float %962, float %958)
%964 = getelementptr inbounds [4 x float], [4 x float]* %7, i64 0, i64 2
%965 = load float, float* %964
%966 = getelementptr inbounds [4 x float], [4 x float]* %6, i64 0, i64 1
%967 = load float, float* %966
%968 = fneg float %965
%969 = call float @llvm.fmuladd.f32(float %968, float %967, float %963)
%970 = load float*, float** %3
%971 = getelementptr inbounds float, float* %970, i64 8
%972 = getelementptr inbounds float, float* %971, i64 0
store float %969, float* %972
%973 = getelementptr inbounds [4 x float], [4 x float]* %7, i64 0, i64 3
%974 = load float, float* %973
%975 = getelementptr inbounds [4 x float], [4 x float]* %6, i64 0, i64 1
%976 = load float, float* %975
%977 = getelementptr inbounds [4 x float], [4 x float]* %7, i64 0, i64 1
%978 = load float, float* %977
%979 = getelementptr inbounds [4 x float], [4 x float]* %6, i64 0, i64 3
%980 = load float, float* %979
%981 = fmul float %978, %980
%982 = call float @llvm.fmuladd.f32(float %974, float %976, float %981)
%983 = getelementptr inbounds [4 x float], [4 x float]* %7, i64 0, i64 2
%984 = load float, float* %983
%985 = getelementptr inbounds [4 x float], [4 x float]* %6, i64 0, i64 0
%986 = load float, float* %985
%987 = call float @llvm.fmuladd.f32(float %984, float %986, float %982)
%988 = getelementptr inbounds [4 x float], [4 x float]* %7, i64 0, i64 0
%989 = load float, float* %988
%990 = getelementptr inbounds [4 x float], [4 x float]* %6, i64 0, i64 2
%991 = load float, float* %990
%992 = fneg float %989
%993 = call float @llvm.fmuladd.f32(float %992, float %991, float %987)
%994 = load float*, float** %3
%995 = getelementptr inbounds float, float* %994, i64 8
%996 = getelementptr inbounds float, float* %995, i64 1
store float %993, float* %996
%997 = getelementptr inbounds [4 x float], [4 x float]* %7, i64 0, i64 3
%998 = load float, float* %997
%999 = getelementptr inbounds [4 x float], [4 x float]* %6, i64 0, i64 2
%1000 = load float, float* %999
%1001 = getelementptr inbounds [4 x float], [4 x float]* %7, i64 0, i64 2
%1002 = load float, float* %1001
%1003 = getelementptr inbounds [4 x float], [4 x float]* %6, i64 0, i64 3
%1004 = load float, float* %1003
%1005 = fmul float %1002, %1004
%1006 = call float @llvm.fmuladd.f32(float %998, float %1000, float %1005)
%1007 = getelementptr inbounds [4 x float], [4 x float]* %7, i64 0, i64 0
%1008 = load float, float* %1007
%1009 = getelementptr inbounds [4 x float], [4 x float]* %6, i64 0, i64 1
%1010 = load float, float* %1009
%1011 = call float @llvm.fmuladd.f32(float %1008, float %1010, float %1006)
%1012 = getelementptr inbounds [4 x float], [4 x float]* %7, i64 0, i64 1
%1013 = load float, float* %1012
%1014 = getelementptr inbounds [4 x float], [4 x float]* %6, i64 0, i64 0
%1015 = load float, float* %1014
%1016 = fneg float %1013
%1017 = call float @llvm.fmuladd.f32(float %1016, float %1015, float %1011)
%1018 = load float*, float** %3
%1019 = getelementptr inbounds float, float* %1018, i64 8
%1020 = getelementptr inbounds float, float* %1019, i64 2
store float %1017, float* %1020
%1021 = getelementptr inbounds [4 x float], [4 x float]* %7, i64 0, i64 3
%1022 = load float, float* %1021
%1023 = getelementptr inbounds [4 x float], [4 x float]* %6, i64 0, i64 3
%1024 = load float, float* %1023
%1025 = getelementptr inbounds [4 x float], [4 x float]* %7, i64 0, i64 0
%1026 = load float, float* %1025
%1027 = getelementptr inbounds [4 x float], [4 x float]* %6, i64 0, i64 0
%1028 = load float, float* %1027
%1029 = fmul float %1026, %1028
%1030 = fneg float %1029
%1031 = call float @llvm.fmuladd.f32(float %1022, float %1024, float %1030)
%1032 = getelementptr inbounds [4 x float], [4 x float]* %7, i64 0, i64 1
%1033 = load float, float* %1032
%1034 = getelementptr inbounds [4 x float], [4 x float]* %6, i64 0, i64 1
%1035 = load float, float* %1034
%1036 = fneg float %1033
%1037 = call float @llvm.fmuladd.f32(float %1036, float %1035, float %1031)
%1038 = getelementptr inbounds [4 x float], [4 x float]* %7, i64 0, i64 2
%1039 = load float, float* %1038
%1040 = getelementptr inbounds [4 x float], [4 x float]* %6, i64 0, i64 2
%1041 = load float, float* %1040
%1042 = fneg float %1039
%1043 = call float @llvm.fmuladd.f32(float %1042, float %1041, float %1037)
%1044 = load float*, float** %3
%1045 = getelementptr inbounds float, float* %1044, i64 8
%1046 = getelementptr inbounds float, float* %1045, i64 3
store float %1043, float* %1046
%1047 = load float*, float** %3
%1048 = getelementptr inbounds float, float* %1047, i64 3
store float 0.000000e+00, float* %1048
%1049 = load float*, float** %3
%1050 = getelementptr inbounds float, float* %1049, i64 11
store float 0.000000e+00, float* %1050
br label %1051
1051: ; preds = %560, %554
ret void
}

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