#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_RotateAxis(float mat[16], float axis[3], float ang) {
  if (ang != 0.0) {
    float t = ang * 3.14159265358979323846 / 360.0;
    float sin_t2 = sinf(t);
    float cos_t2 = cosf(t);
    float R[4], Rt[4], *v, buf[4];
    R[0] = axis[0] * sin_t2;
    R[1] = axis[1] * sin_t2;
    R[2] = axis[2] * sin_t2;
    R[3] = cos_t2;
    {
      (Rt)[0] = -(R)[0];
      (Rt)[1] = -(R)[1];
      (Rt)[2] = -(R)[2];
      (Rt)[3] = (R)[3];
    };
    v = mat + 0;
    {
      (buf)[0] =
          (R)[3] * (v)[0] + (R)[0] * (v)[3] + (R)[1] * (v)[2] - (R)[2] * (v)[1];
      (buf)[1] =
          (R)[3] * (v)[1] + (R)[1] * (v)[3] + (R)[2] * (v)[0] - (R)[0] * (v)[2];
      (buf)[2] =
          (R)[3] * (v)[2] + (R)[2] * (v)[3] + (R)[0] * (v)[1] - (R)[1] * (v)[0];
      (buf)[3] =
          (R)[3] * (v)[3] - (R)[0] * (v)[0] - (R)[1] * (v)[1] - (R)[2] * (v)[2];
    };
    {
      (v)[0] = (buf)[3] * (Rt)[0] + (buf)[0] * (Rt)[3] + (buf)[1] * (Rt)[2] -
               (buf)[2] * (Rt)[1];
      (v)[1] = (buf)[3] * (Rt)[1] + (buf)[1] * (Rt)[3] + (buf)[2] * (Rt)[0] -
               (buf)[0] * (Rt)[2];
      (v)[2] = (buf)[3] * (Rt)[2] + (buf)[2] * (Rt)[3] + (buf)[0] * (Rt)[1] -
               (buf)[1] * (Rt)[0];
      (v)[3] = (buf)[3] * (Rt)[3] - (buf)[0] * (Rt)[0] - (buf)[1] * (Rt)[1] -
               (buf)[2] * (Rt)[2];
    };
    mat[0 + 3] = 0.0f;
    v = mat + 4;
    {
      (buf)[0] =
          (R)[3] * (v)[0] + (R)[0] * (v)[3] + (R)[1] * (v)[2] - (R)[2] * (v)[1];
      (buf)[1] =
          (R)[3] * (v)[1] + (R)[1] * (v)[3] + (R)[2] * (v)[0] - (R)[0] * (v)[2];
      (buf)[2] =
          (R)[3] * (v)[2] + (R)[2] * (v)[3] + (R)[0] * (v)[1] - (R)[1] * (v)[0];
      (buf)[3] =
          (R)[3] * (v)[3] - (R)[0] * (v)[0] - (R)[1] * (v)[1] - (R)[2] * (v)[2];
    };
    {
      (v)[0] = (buf)[3] * (Rt)[0] + (buf)[0] * (Rt)[3] + (buf)[1] * (Rt)[2] -
               (buf)[2] * (Rt)[1];
      (v)[1] = (buf)[3] * (Rt)[1] + (buf)[1] * (Rt)[3] + (buf)[2] * (Rt)[0] -
               (buf)[0] * (Rt)[2];
      (v)[2] = (buf)[3] * (Rt)[2] + (buf)[2] * (Rt)[3] + (buf)[0] * (Rt)[1] -
               (buf)[1] * (Rt)[0];
      (v)[3] = (buf)[3] * (Rt)[3] - (buf)[0] * (Rt)[0] - (buf)[1] * (Rt)[1] -
               (buf)[2] * (Rt)[2];
    };
    mat[4 + 3] = 0.0f;
    v = mat + 8;
    {
      (buf)[0] =
          (R)[3] * (v)[0] + (R)[0] * (v)[3] + (R)[1] * (v)[2] - (R)[2] * (v)[1];
      (buf)[1] =
          (R)[3] * (v)[1] + (R)[1] * (v)[3] + (R)[2] * (v)[0] - (R)[0] * (v)[2];
      (buf)[2] =
          (R)[3] * (v)[2] + (R)[2] * (v)[3] + (R)[0] * (v)[1] - (R)[1] * (v)[0];
      (buf)[3] =
          (R)[3] * (v)[3] - (R)[0] * (v)[0] - (R)[1] * (v)[1] - (R)[2] * (v)[2];
    };
    {
      (v)[0] = (buf)[3] * (Rt)[0] + (buf)[0] * (Rt)[3] + (buf)[1] * (Rt)[2] -
               (buf)[2] * (Rt)[1];
      (v)[1] = (buf)[3] * (Rt)[1] + (buf)[1] * (Rt)[3] + (buf)[2] * (Rt)[0] -
               (buf)[0] * (Rt)[2];
      (v)[2] = (buf)[3] * (Rt)[2] + (buf)[2] * (Rt)[3] + (buf)[0] * (Rt)[1] -
               (buf)[1] * (Rt)[0];
      (v)[3] = (buf)[3] * (Rt)[3] - (buf)[0] * (Rt)[0] - (buf)[1] * (Rt)[1] -
               (buf)[2] * (Rt)[2];
    };
    mat[8 + 3] = 0.0f;
  }
}


x86 assembly (clang, -O0):
<Mat4_RotateAxis>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movss  %xmm0,-0x14(%rbp)
movss  -0x14(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1156 <Mat4_RotateAxis+0x36>
jp     1156 <Mat4_RotateAxis+0x36>
jmp    1ba0 <Mat4_RotateAxis+0xa80>
movss  -0x14(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xea1(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  0xe8d(%rip),%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x18(%rbp)
movss  -0x18(%rbp),%xmm0
call   1030 <sinf@plt>
movss  %xmm0,-0x1c(%rbp)
movss  -0x18(%rbp),%xmm0
call   1040 <cosf@plt>
movss  %xmm0,-0x20(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
mulss  -0x1c(%rbp),%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
mulss  -0x1c(%rbp),%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
mulss  -0x1c(%rbp),%xmm0
movss  %xmm0,-0x28(%rbp)
movss  -0x20(%rbp),%xmm0
movss  %xmm0,-0x24(%rbp)
movss  -0x30(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x2c(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  -0x28(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x38(%rbp)
movss  -0x24(%rbp),%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x48(%rbp)
movss  -0x24(%rbp),%xmm0
mov    -0x48(%rbp),%rax
movss  (%rax),%xmm2
movss  -0x30(%rbp),%xmm1
mov    -0x48(%rbp),%rax
mulss  0xc(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x2c(%rbp),%xmm1
mov    -0x48(%rbp),%rax
movss  0x8(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x28(%rbp),%xmm0
mov    -0x48(%rbp),%rax
movss  0x4(%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x24(%rbp),%xmm0
mov    -0x48(%rbp),%rax
movss  0x4(%rax),%xmm2
movss  -0x2c(%rbp),%xmm1
mov    -0x48(%rbp),%rax
mulss  0xc(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x28(%rbp),%xmm1
mov    -0x48(%rbp),%rax
movss  (%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x30(%rbp),%xmm0
mov    -0x48(%rbp),%rax
movss  0x8(%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x24(%rbp),%xmm0
mov    -0x48(%rbp),%rax
movss  0x8(%rax),%xmm2
movss  -0x28(%rbp),%xmm1
mov    -0x48(%rbp),%rax
mulss  0xc(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x30(%rbp),%xmm1
mov    -0x48(%rbp),%rax
movss  0x4(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x2c(%rbp),%xmm0
mov    -0x48(%rbp),%rax
movss  (%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x24(%rbp),%xmm0
mov    -0x48(%rbp),%rax
movss  0xc(%rax),%xmm2
movss  -0x30(%rbp),%xmm1
mov    -0x48(%rbp),%rax
mulss  (%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x2c(%rbp),%xmm1
mov    -0x48(%rbp),%rax
movss  0x4(%rax),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x28(%rbp),%xmm0
mov    -0x48(%rbp),%rax
movss  0x8(%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x54(%rbp),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x60(%rbp),%xmm1
mulss  -0x34(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x5c(%rbp),%xmm1
movss  -0x38(%rbp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x58(%rbp),%xmm0
movss  -0x3c(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x54(%rbp),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  -0x34(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x58(%rbp),%xmm1
movss  -0x40(%rbp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x60(%rbp),%xmm0
movss  -0x38(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x54(%rbp),%xmm0
movss  -0x38(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  -0x34(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x60(%rbp),%xmm1
movss  -0x3c(%rbp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x5c(%rbp),%xmm0
movss  -0x40(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,0x8(%rax)
movss  -0x54(%rbp),%xmm0
movss  -0x34(%rbp),%xmm2
movss  -0x60(%rbp),%xmm1
mulss  -0x40(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x5c(%rbp),%xmm1
movss  -0x3c(%rbp),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x58(%rbp),%xmm0
movss  -0x38(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,0xc(%rax)
mov    -0x8(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,0xc(%rax)
mov    -0x8(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x48(%rbp)
movss  -0x24(%rbp),%xmm0
mov    -0x48(%rbp),%rax
movss  (%rax),%xmm2
movss  -0x30(%rbp),%xmm1
mov    -0x48(%rbp),%rax
mulss  0xc(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x2c(%rbp),%xmm1
mov    -0x48(%rbp),%rax
movss  0x8(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x28(%rbp),%xmm0
mov    -0x48(%rbp),%rax
movss  0x4(%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x24(%rbp),%xmm0
mov    -0x48(%rbp),%rax
movss  0x4(%rax),%xmm2
movss  -0x2c(%rbp),%xmm1
mov    -0x48(%rbp),%rax
mulss  0xc(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x28(%rbp),%xmm1
mov    -0x48(%rbp),%rax
movss  (%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x30(%rbp),%xmm0
mov    -0x48(%rbp),%rax
movss  0x8(%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x24(%rbp),%xmm0
mov    -0x48(%rbp),%rax
movss  0x8(%rax),%xmm2
movss  -0x28(%rbp),%xmm1
mov    -0x48(%rbp),%rax
mulss  0xc(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x30(%rbp),%xmm1
mov    -0x48(%rbp),%rax
movss  0x4(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x2c(%rbp),%xmm0
mov    -0x48(%rbp),%rax
movss  (%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x24(%rbp),%xmm0
mov    -0x48(%rbp),%rax
movss  0xc(%rax),%xmm2
movss  -0x30(%rbp),%xmm1
mov    -0x48(%rbp),%rax
mulss  (%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x2c(%rbp),%xmm1
mov    -0x48(%rbp),%rax
movss  0x4(%rax),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x28(%rbp),%xmm0
mov    -0x48(%rbp),%rax
movss  0x8(%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x54(%rbp),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x60(%rbp),%xmm1
mulss  -0x34(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x5c(%rbp),%xmm1
movss  -0x38(%rbp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x58(%rbp),%xmm0
movss  -0x3c(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x54(%rbp),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  -0x34(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x58(%rbp),%xmm1
movss  -0x40(%rbp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x60(%rbp),%xmm0
movss  -0x38(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x54(%rbp),%xmm0
movss  -0x38(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  -0x34(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x60(%rbp),%xmm1
movss  -0x3c(%rbp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x5c(%rbp),%xmm0
movss  -0x40(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,0x8(%rax)
movss  -0x54(%rbp),%xmm0
movss  -0x34(%rbp),%xmm2
movss  -0x60(%rbp),%xmm1
mulss  -0x40(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x5c(%rbp),%xmm1
movss  -0x3c(%rbp),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x58(%rbp),%xmm0
movss  -0x38(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,0xc(%rax)
mov    -0x8(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,0x1c(%rax)
mov    -0x8(%rbp),%rax
add    $0x20,%rax
mov    %rax,-0x48(%rbp)
movss  -0x24(%rbp),%xmm0
mov    -0x48(%rbp),%rax
movss  (%rax),%xmm2
movss  -0x30(%rbp),%xmm1
mov    -0x48(%rbp),%rax
mulss  0xc(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x2c(%rbp),%xmm1
mov    -0x48(%rbp),%rax
movss  0x8(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x28(%rbp),%xmm0
mov    -0x48(%rbp),%rax
movss  0x4(%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x24(%rbp),%xmm0
mov    -0x48(%rbp),%rax
movss  0x4(%rax),%xmm2
movss  -0x2c(%rbp),%xmm1
mov    -0x48(%rbp),%rax
mulss  0xc(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x28(%rbp),%xmm1
mov    -0x48(%rbp),%rax
movss  (%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x30(%rbp),%xmm0
mov    -0x48(%rbp),%rax
movss  0x8(%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x24(%rbp),%xmm0
mov    -0x48(%rbp),%rax
movss  0x8(%rax),%xmm2
movss  -0x28(%rbp),%xmm1
mov    -0x48(%rbp),%rax
mulss  0xc(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x30(%rbp),%xmm1
mov    -0x48(%rbp),%rax
movss  0x4(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x2c(%rbp),%xmm0
mov    -0x48(%rbp),%rax
movss  (%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x24(%rbp),%xmm0
mov    -0x48(%rbp),%rax
movss  0xc(%rax),%xmm2
movss  -0x30(%rbp),%xmm1
mov    -0x48(%rbp),%rax
mulss  (%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x2c(%rbp),%xmm1
mov    -0x48(%rbp),%rax
movss  0x4(%rax),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x28(%rbp),%xmm0
mov    -0x48(%rbp),%rax
movss  0x8(%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x54(%rbp),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x60(%rbp),%xmm1
mulss  -0x34(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x5c(%rbp),%xmm1
movss  -0x38(%rbp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x58(%rbp),%xmm0
movss  -0x3c(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x54(%rbp),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  -0x34(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x58(%rbp),%xmm1
movss  -0x40(%rbp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x60(%rbp),%xmm0
movss  -0x38(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x54(%rbp),%xmm0
movss  -0x38(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  -0x34(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x60(%rbp),%xmm1
movss  -0x3c(%rbp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x5c(%rbp),%xmm0
movss  -0x40(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,0x8(%rax)
movss  -0x54(%rbp),%xmm0
movss  -0x34(%rbp),%xmm2
movss  -0x60(%rbp),%xmm1
mulss  -0x40(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x5c(%rbp),%xmm1
movss  -0x3c(%rbp),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x58(%rbp),%xmm0
movss  -0x38(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,0xc(%rax)
mov    -0x8(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,0x2c(%rax)
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<Mat4_RotateAxis>:
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    112e <Mat4_RotateAxis+0xe>
jnp    156f <Mat4_RotateAxis+0x44f>
push   %r14
push   %rbx
push   %rax
mov    %rsi,%rbx
mov    %rdi,%r14
cvtss2sd %xmm0,%xmm0
mulsd  0xebc(%rip),%xmm0
divsd  0xebc(%rip),%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%rsp)
call   1030 <sinf@plt>
movss  %xmm0,0x4(%rsp)
movss  (%rsp),%xmm0
call   1040 <cosf@plt>
movss  (%rbx),%xmm8
movss  0x4(%rsp),%xmm11
mulss  %xmm11,%xmm8
movss  0x4(%rbx),%xmm9
mulss  %xmm11,%xmm9
mulss  0x8(%rbx),%xmm11
movss  0xc(%r14),%xmm3
movaps %xmm8,%xmm1
mulss  %xmm3,%xmm1
movss  (%r14),%xmm2
movss  0x4(%r14),%xmm10
movaps %xmm0,%xmm5
mulss  %xmm2,%xmm5
addss  %xmm1,%xmm5
movss  0x8(%r14),%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,(%r14)
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(%r14)
mulss  %xmm11,%xmm3
subss  %xmm3,%xmm6
mulss  %xmm9,%xmm4
subss  %xmm4,%xmm6
mulss  %xmm8,%xmm5
addss  %xmm6,%xmm5
movss  %xmm5,0x8(%r14)
movl   $0x0,0xc(%r14)
movss  0x10(%r14),%xmm10
movss  0x1c(%r14),%xmm3
movaps %xmm8,%xmm1
mulss  %xmm3,%xmm1
movaps %xmm0,%xmm2
mulss  %xmm10,%xmm2
addss  %xmm1,%xmm2
movss  0x18(%r14),%xmm7
movaps %xmm9,%xmm4
mulss  %xmm7,%xmm4
addss  %xmm2,%xmm4
movss  0x14(%r14),%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,0x10(%r14)
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(%r14)
mulss  %xmm11,%xmm3
subss  %xmm3,%xmm6
mulss  %xmm9,%xmm4
subss  %xmm4,%xmm6
mulss  %xmm8,%xmm5
addss  %xmm6,%xmm5
movss  %xmm5,0x18(%r14)
movl   $0x0,0x1c(%r14)
movss  0x2c(%r14),%xmm3
movaps %xmm8,%xmm1
mulss  %xmm3,%xmm1
movss  0x20(%r14),%xmm2
movss  0x24(%r14),%xmm10
movaps %xmm0,%xmm5
mulss  %xmm2,%xmm5
addss  %xmm1,%xmm5
movss  0x28(%r14),%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,0x20(%r14)
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(%r14)
mulss  %xmm11,%xmm3
subss  %xmm3,%xmm0
mulss  %xmm9,%xmm4
subss  %xmm4,%xmm0
mulss  %xmm8,%xmm5
addss  %xmm0,%xmm5
movss  %xmm5,0x28(%r14)
movl   $0x0,0x2c(%r14)
add    $0x8,%rsp
pop    %rbx
pop    %r14
ret

LLVM IR (-O0):
define void @Mat4_RotateAxis(float* %0, float* %1, float %2) {
%4 = alloca float*
%5 = alloca float*
%6 = alloca float
%7 = alloca float
%8 = alloca float
%9 = alloca float
%10 = alloca [4 x float]
%11 = alloca [4 x float]
%12 = alloca float*
%13 = alloca [4 x float]
store float* %0, float** %4
store float* %1, float** %5
store float %2, float* %6
%14 = load float, float* %6
%15 = fpext float %14 to double
%16 = fcmp une double %15, 0.000000e+00
br i1 %16, label %17, label %674
17: ; preds = %3
%18 = load float, float* %6
%19 = fpext float %18 to double
%20 = fmul double %19, 0x400921FB54442D18
%21 = fdiv double %20, 3.600000e+02
%22 = fptrunc double %21 to float
store float %22, float* %7
%23 = load float, float* %7
%24 = call float @sinf(float %23)
store float %24, float* %8
%25 = load float, float* %7
%26 = call float @cosf(float %25)
store float %26, float* %9
%27 = load float*, float** %5
%28 = getelementptr inbounds float, float* %27, i64 0
%29 = load float, float* %28
%30 = load float, float* %8
%31 = fmul float %29, %30
%32 = getelementptr inbounds [4 x float], [4 x float]* %10, i64 0, i64 0
store float %31, float* %32
%33 = load float*, float** %5
%34 = getelementptr inbounds float, float* %33, i64 1
%35 = load float, float* %34
%36 = load float, float* %8
%37 = fmul float %35, %36
%38 = getelementptr inbounds [4 x float], [4 x float]* %10, i64 0, i64 1
store float %37, float* %38
%39 = load float*, float** %5
%40 = getelementptr inbounds float, float* %39, i64 2
%41 = load float, float* %40
%42 = load float, float* %8
%43 = fmul float %41, %42
%44 = getelementptr inbounds [4 x float], [4 x float]* %10, i64 0, i64 2
store float %43, float* %44
%45 = load float, float* %9
%46 = getelementptr inbounds [4 x float], [4 x float]* %10, i64 0, i64 3
store float %45, float* %46
%47 = getelementptr inbounds [4 x float], [4 x float]* %10, i64 0, i64 0
%48 = load float, float* %47
%49 = fneg float %48
%50 = getelementptr inbounds [4 x float], [4 x float]* %11, i64 0, i64 0
store float %49, float* %50
%51 = getelementptr inbounds [4 x float], [4 x float]* %10, i64 0, i64 1
%52 = load float, float* %51
%53 = fneg float %52
%54 = getelementptr inbounds [4 x float], [4 x float]* %11, i64 0, i64 1
store float %53, float* %54
%55 = getelementptr inbounds [4 x float], [4 x float]* %10, i64 0, i64 2
%56 = load float, float* %55
%57 = fneg float %56
%58 = getelementptr inbounds [4 x float], [4 x float]* %11, i64 0, i64 2
store float %57, float* %58
%59 = getelementptr inbounds [4 x float], [4 x float]* %10, i64 0, i64 3
%60 = load float, float* %59
%61 = getelementptr inbounds [4 x float], [4 x float]* %11, i64 0, i64 3
store float %60, float* %61
%62 = load float*, float** %4
%63 = getelementptr inbounds float, float* %62, i64 0
store float* %63, float** %12
%64 = getelementptr inbounds [4 x float], [4 x float]* %10, i64 0, i64 3
%65 = load float, float* %64
%66 = load float*, float** %12
%67 = getelementptr inbounds float, float* %66, i64 0
%68 = load float, float* %67
%69 = getelementptr inbounds [4 x float], [4 x float]* %10, i64 0, i64 0
%70 = load float, float* %69
%71 = load float*, float** %12
%72 = getelementptr inbounds float, float* %71, i64 3
%73 = load float, float* %72
%74 = fmul float %70, %73
%75 = call float @llvm.fmuladd.f32(float %65, float %68, float %74)
%76 = getelementptr inbounds [4 x float], [4 x float]* %10, i64 0, i64 1
%77 = load float, float* %76
%78 = load float*, float** %12
%79 = getelementptr inbounds float, float* %78, i64 2
%80 = load float, float* %79
%81 = call float @llvm.fmuladd.f32(float %77, float %80, float %75)
%82 = getelementptr inbounds [4 x float], [4 x float]* %10, i64 0, i64 2
%83 = load float, float* %82
%84 = load float*, float** %12
%85 = getelementptr inbounds float, float* %84, i64 1
%86 = load float, float* %85
%87 = fneg float %83
%88 = call float @llvm.fmuladd.f32(float %87, float %86, float %81)
%89 = getelementptr inbounds [4 x float], [4 x float]* %13, i64 0, i64 0
store float %88, float* %89
%90 = getelementptr inbounds [4 x float], [4 x float]* %10, i64 0, i64 3
%91 = load float, float* %90
%92 = load float*, float** %12
%93 = getelementptr inbounds float, float* %92, i64 1
%94 = load float, float* %93
%95 = getelementptr inbounds [4 x float], [4 x float]* %10, i64 0, i64 1
%96 = load float, float* %95
%97 = load float*, float** %12
%98 = getelementptr inbounds float, float* %97, i64 3
%99 = load float, float* %98
%100 = fmul float %96, %99
%101 = call float @llvm.fmuladd.f32(float %91, float %94, float %100)
%102 = getelementptr inbounds [4 x float], [4 x float]* %10, i64 0, i64 2
%103 = load float, float* %102
%104 = load float*, float** %12
%105 = getelementptr inbounds float, float* %104, i64 0
%106 = load float, float* %105
%107 = call float @llvm.fmuladd.f32(float %103, float %106, float %101)
%108 = getelementptr inbounds [4 x float], [4 x float]* %10, i64 0, i64 0
%109 = load float, float* %108
%110 = load float*, float** %12
%111 = getelementptr inbounds float, float* %110, i64 2
%112 = load float, float* %111
%113 = fneg float %109
%114 = call float @llvm.fmuladd.f32(float %113, float %112, float %107)
%115 = getelementptr inbounds [4 x float], [4 x float]* %13, i64 0, i64 1
store float %114, float* %115
%116 = getelementptr inbounds [4 x float], [4 x float]* %10, i64 0, i64 3
%117 = load float, float* %116
%118 = load float*, float** %12
%119 = getelementptr inbounds float, float* %118, i64 2
%120 = load float, float* %119
%121 = getelementptr inbounds [4 x float], [4 x float]* %10, i64 0, i64 2
%122 = load float, float* %121
%123 = load float*, float** %12
%124 = getelementptr inbounds float, float* %123, i64 3
%125 = load float, float* %124
%126 = fmul float %122, %125
%127 = call float @llvm.fmuladd.f32(float %117, float %120, float %126)
%128 = getelementptr inbounds [4 x float], [4 x float]* %10, i64 0, i64 0
%129 = load float, float* %128
%130 = load float*, float** %12
%131 = getelementptr inbounds float, float* %130, i64 1
%132 = load float, float* %131
%133 = call float @llvm.fmuladd.f32(float %129, float %132, float %127)
%134 = getelementptr inbounds [4 x float], [4 x float]* %10, i64 0, i64 1
%135 = load float, float* %134
%136 = load float*, float** %12
%137 = getelementptr inbounds float, float* %136, i64 0
%138 = load float, float* %137
%139 = fneg float %135
%140 = call float @llvm.fmuladd.f32(float %139, float %138, float %133)
%141 = getelementptr inbounds [4 x float], [4 x float]* %13, i64 0, i64 2
store float %140, float* %141
%142 = getelementptr inbounds [4 x float], [4 x float]* %10, i64 0, i64 3
%143 = load float, float* %142
%144 = load float*, float** %12
%145 = getelementptr inbounds float, float* %144, i64 3
%146 = load float, float* %145
%147 = getelementptr inbounds [4 x float], [4 x float]* %10, i64 0, i64 0
%148 = load float, float* %147
%149 = load float*, float** %12
%150 = getelementptr inbounds float, float* %149, i64 0
%151 = load float, float* %150
%152 = fmul float %148, %151
%153 = fneg float %152
%154 = call float @llvm.fmuladd.f32(float %143, float %146, float %153)
%155 = getelementptr inbounds [4 x float], [4 x float]* %10, i64 0, i64 1
%156 = load float, float* %155
%157 = load float*, float** %12
%158 = getelementptr inbounds float, float* %157, i64 1
%159 = load float, float* %158
%160 = fneg float %156
%161 = call float @llvm.fmuladd.f32(float %160, float %159, float %154)
%162 = getelementptr inbounds [4 x float], [4 x float]* %10, i64 0, i64 2
%163 = load float, float* %162
%164 = load float*, float** %12
%165 = getelementptr inbounds float, float* %164, i64 2
%166 = load float, float* %165
%167 = fneg float %163
%168 = call float @llvm.fmuladd.f32(float %167, float %166, float %161)
%169 = getelementptr inbounds [4 x float], [4 x float]* %13, i64 0, i64 3
store float %168, float* %169
%170 = getelementptr inbounds [4 x float], [4 x float]* %13, i64 0, i64 3
%171 = load float, float* %170
%172 = getelementptr inbounds [4 x float], [4 x float]* %11, i64 0, i64 0
%173 = load float, float* %172
%174 = getelementptr inbounds [4 x float], [4 x float]* %13, i64 0, i64 0
%175 = load float, float* %174
%176 = getelementptr inbounds [4 x float], [4 x float]* %11, i64 0, i64 3
%177 = load float, float* %176
%178 = fmul float %175, %177
%179 = call float @llvm.fmuladd.f32(float %171, float %173, float %178)
%180 = getelementptr inbounds [4 x float], [4 x float]* %13, i64 0, i64 1
%181 = load float, float* %180
%182 = getelementptr inbounds [4 x float], [4 x float]* %11, i64 0, i64 2
%183 = load float, float* %182
%184 = call float @llvm.fmuladd.f32(float %181, float %183, float %179)
%185 = getelementptr inbounds [4 x float], [4 x float]* %13, i64 0, i64 2
%186 = load float, float* %185
%187 = getelementptr inbounds [4 x float], [4 x float]* %11, i64 0, i64 1
%188 = load float, float* %187
%189 = fneg float %186
%190 = call float @llvm.fmuladd.f32(float %189, float %188, float %184)
%191 = load float*, float** %12
%192 = getelementptr inbounds float, float* %191, i64 0
store float %190, float* %192
%193 = getelementptr inbounds [4 x float], [4 x float]* %13, i64 0, i64 3
%194 = load float, float* %193
%195 = getelementptr inbounds [4 x float], [4 x float]* %11, i64 0, i64 1
%196 = load float, float* %195
%197 = getelementptr inbounds [4 x float], [4 x float]* %13, i64 0, i64 1
%198 = load float, float* %197
%199 = getelementptr inbounds [4 x float], [4 x float]* %11, i64 0, i64 3
%200 = load float, float* %199
%201 = fmul float %198, %200
%202 = call float @llvm.fmuladd.f32(float %194, float %196, float %201)
%203 = getelementptr inbounds [4 x float], [4 x float]* %13, i64 0, i64 2
%204 = load float, float* %203
%205 = getelementptr inbounds [4 x float], [4 x float]* %11, i64 0, i64 0
%206 = load float, float* %205
%207 = call float @llvm.fmuladd.f32(float %204, float %206, float %202)
%208 = getelementptr inbounds [4 x float], [4 x float]* %13, i64 0, i64 0
%209 = load float, float* %208
%210 = getelementptr inbounds [4 x float], [4 x float]* %11, i64 0, i64 2
%211 = load float, float* %210
%212 = fneg float %209
%213 = call float @llvm.fmuladd.f32(float %212, float %211, float %207)
%214 = load float*, float** %12
%215 = getelementptr inbounds float, float* %214, i64 1
store float %213, float* %215
%216 = getelementptr inbounds [4 x float], [4 x float]* %13, i64 0, i64 3
%217 = load float, float* %216
%218 = getelementptr inbounds [4 x float], [4 x float]* %11, i64 0, i64 2
%219 = load float, float* %218
%220 = getelementptr inbounds [4 x float], [4 x float]* %13, i64 0, i64 2
%221 = load float, float* %220
%222 = getelementptr inbounds [4 x float], [4 x float]* %11, i64 0, i64 3
%223 = load float, float* %222
%224 = fmul float %221, %223
%225 = call float @llvm.fmuladd.f32(float %217, float %219, float %224)
%226 = getelementptr inbounds [4 x float], [4 x float]* %13, i64 0, i64 0
%227 = load float, float* %226
%228 = getelementptr inbounds [4 x float], [4 x float]* %11, i64 0, i64 1
%229 = load float, float* %228
%230 = call float @llvm.fmuladd.f32(float %227, float %229, float %225)
%231 = getelementptr inbounds [4 x float], [4 x float]* %13, i64 0, i64 1
%232 = load float, float* %231
%233 = getelementptr inbounds [4 x float], [4 x float]* %11, i64 0, i64 0
%234 = load float, float* %233
%235 = fneg float %232
%236 = call float @llvm.fmuladd.f32(float %235, float %234, float %230)
%237 = load float*, float** %12
%238 = getelementptr inbounds float, float* %237, i64 2
store float %236, float* %238
%239 = getelementptr inbounds [4 x float], [4 x float]* %13, i64 0, i64 3
%240 = load float, float* %239
%241 = getelementptr inbounds [4 x float], [4 x float]* %11, i64 0, i64 3
%242 = load float, float* %241
%243 = getelementptr inbounds [4 x float], [4 x float]* %13, i64 0, i64 0
%244 = load float, float* %243
%245 = getelementptr inbounds [4 x float], [4 x float]* %11, i64 0, i64 0
%246 = load float, float* %245
%247 = fmul float %244, %246
%248 = fneg float %247
%249 = call float @llvm.fmuladd.f32(float %240, float %242, float %248)
%250 = getelementptr inbounds [4 x float], [4 x float]* %13, i64 0, i64 1
%251 = load float, float* %250
%252 = getelementptr inbounds [4 x float], [4 x float]* %11, i64 0, i64 1
%253 = load float, float* %252
%254 = fneg float %251
%255 = call float @llvm.fmuladd.f32(float %254, float %253, float %249)
%256 = getelementptr inbounds [4 x float], [4 x float]* %13, i64 0, i64 2
%257 = load float, float* %256
%258 = getelementptr inbounds [4 x float], [4 x float]* %11, i64 0, i64 2
%259 = load float, float* %258
%260 = fneg float %257
%261 = call float @llvm.fmuladd.f32(float %260, float %259, float %255)
%262 = load float*, float** %12
%263 = getelementptr inbounds float, float* %262, i64 3
store float %261, float* %263
%264 = load float*, float** %4
%265 = getelementptr inbounds float, float* %264, i64 3
store float 0.000000e+00, float* %265
%266 = load float*, float** %4
%267 = getelementptr inbounds float, float* %266, i64 4
store float* %267, float** %12
%268 = getelementptr inbounds [4 x float], [4 x float]* %10, i64 0, i64 3
%269 = load float, float* %268
%270 = load float*, float** %12
%271 = getelementptr inbounds float, float* %270, i64 0
%272 = load float, float* %271
%273 = getelementptr inbounds [4 x float], [4 x float]* %10, i64 0, i64 0
%274 = load float, float* %273
%275 = load float*, float** %12
%276 = getelementptr inbounds float, float* %275, i64 3
%277 = load float, float* %276
%278 = fmul float %274, %277
%279 = call float @llvm.fmuladd.f32(float %269, float %272, float %278)
%280 = getelementptr inbounds [4 x float], [4 x float]* %10, i64 0, i64 1
%281 = load float, float* %280
%282 = load float*, float** %12
%283 = getelementptr inbounds float, float* %282, i64 2
%284 = load float, float* %283
%285 = call float @llvm.fmuladd.f32(float %281, float %284, float %279)
%286 = getelementptr inbounds [4 x float], [4 x float]* %10, i64 0, i64 2
%287 = load float, float* %286
%288 = load float*, float** %12
%289 = getelementptr inbounds float, float* %288, i64 1
%290 = load float, float* %289
%291 = fneg float %287
%292 = call float @llvm.fmuladd.f32(float %291, float %290, float %285)
%293 = getelementptr inbounds [4 x float], [4 x float]* %13, i64 0, i64 0
store float %292, float* %293
%294 = getelementptr inbounds [4 x float], [4 x float]* %10, i64 0, i64 3
%295 = load float, float* %294
%296 = load float*, float** %12
%297 = getelementptr inbounds float, float* %296, i64 1
%298 = load float, float* %297
%299 = getelementptr inbounds [4 x float], [4 x float]* %10, i64 0, i64 1
%300 = load float, float* %299
%301 = load float*, float** %12
%302 = getelementptr inbounds float, float* %301, i64 3
%303 = load float, float* %302
%304 = fmul float %300, %303
%305 = call float @llvm.fmuladd.f32(float %295, float %298, float %304)
%306 = getelementptr inbounds [4 x float], [4 x float]* %10, i64 0, i64 2
%307 = load float, float* %306
%308 = load float*, float** %12
%309 = getelementptr inbounds float, float* %308, i64 0
%310 = load float, float* %309
%311 = call float @llvm.fmuladd.f32(float %307, float %310, float %305)
%312 = getelementptr inbounds [4 x float], [4 x float]* %10, i64 0, i64 0
%313 = load float, float* %312
%314 = load float*, float** %12
%315 = getelementptr inbounds float, float* %314, i64 2
%316 = load float, float* %315
%317 = fneg float %313
%318 = call float @llvm.fmuladd.f32(float %317, float %316, float %311)
%319 = getelementptr inbounds [4 x float], [4 x float]* %13, i64 0, i64 1
store float %318, float* %319
%320 = getelementptr inbounds [4 x float], [4 x float]* %10, i64 0, i64 3
%321 = load float, float* %320
%322 = load float*, float** %12
%323 = getelementptr inbounds float, float* %322, i64 2
%324 = load float, float* %323
%325 = getelementptr inbounds [4 x float], [4 x float]* %10, i64 0, i64 2
%326 = load float, float* %325
%327 = load float*, float** %12
%328 = getelementptr inbounds float, float* %327, i64 3
%329 = load float, float* %328
%330 = fmul float %326, %329
%331 = call float @llvm.fmuladd.f32(float %321, float %324, float %330)
%332 = getelementptr inbounds [4 x float], [4 x float]* %10, i64 0, i64 0
%333 = load float, float* %332
%334 = load float*, float** %12
%335 = getelementptr inbounds float, float* %334, i64 1
%336 = load float, float* %335
%337 = call float @llvm.fmuladd.f32(float %333, float %336, float %331)
%338 = getelementptr inbounds [4 x float], [4 x float]* %10, i64 0, i64 1
%339 = load float, float* %338
%340 = load float*, float** %12
%341 = getelementptr inbounds float, float* %340, i64 0
%342 = load float, float* %341
%343 = fneg float %339
%344 = call float @llvm.fmuladd.f32(float %343, float %342, float %337)
%345 = getelementptr inbounds [4 x float], [4 x float]* %13, i64 0, i64 2
store float %344, float* %345
%346 = getelementptr inbounds [4 x float], [4 x float]* %10, i64 0, i64 3
%347 = load float, float* %346
%348 = load float*, float** %12
%349 = getelementptr inbounds float, float* %348, i64 3
%350 = load float, float* %349
%351 = getelementptr inbounds [4 x float], [4 x float]* %10, i64 0, i64 0
%352 = load float, float* %351
%353 = load float*, float** %12
%354 = getelementptr inbounds float, float* %353, i64 0
%355 = load float, float* %354
%356 = fmul float %352, %355
%357 = fneg float %356
%358 = call float @llvm.fmuladd.f32(float %347, float %350, float %357)
%359 = getelementptr inbounds [4 x float], [4 x float]* %10, i64 0, i64 1
%360 = load float, float* %359
%361 = load float*, float** %12
%362 = getelementptr inbounds float, float* %361, i64 1
%363 = load float, float* %362
%364 = fneg float %360
%365 = call float @llvm.fmuladd.f32(float %364, float %363, float %358)
%366 = getelementptr inbounds [4 x float], [4 x float]* %10, i64 0, i64 2
%367 = load float, float* %366
%368 = load float*, float** %12
%369 = getelementptr inbounds float, float* %368, i64 2
%370 = load float, float* %369
%371 = fneg float %367
%372 = call float @llvm.fmuladd.f32(float %371, float %370, float %365)
%373 = getelementptr inbounds [4 x float], [4 x float]* %13, i64 0, i64 3
store float %372, float* %373
%374 = getelementptr inbounds [4 x float], [4 x float]* %13, i64 0, i64 3
%375 = load float, float* %374
%376 = getelementptr inbounds [4 x float], [4 x float]* %11, i64 0, i64 0
%377 = load float, float* %376
%378 = getelementptr inbounds [4 x float], [4 x float]* %13, i64 0, i64 0
%379 = load float, float* %378
%380 = getelementptr inbounds [4 x float], [4 x float]* %11, i64 0, i64 3
%381 = load float, float* %380
%382 = fmul float %379, %381
%383 = call float @llvm.fmuladd.f32(float %375, float %377, float %382)
%384 = getelementptr inbounds [4 x float], [4 x float]* %13, i64 0, i64 1
%385 = load float, float* %384
%386 = getelementptr inbounds [4 x float], [4 x float]* %11, i64 0, i64 2
%387 = load float, float* %386
%388 = call float @llvm.fmuladd.f32(float %385, float %387, float %383)
%389 = getelementptr inbounds [4 x float], [4 x float]* %13, i64 0, i64 2
%390 = load float, float* %389
%391 = getelementptr inbounds [4 x float], [4 x float]* %11, i64 0, i64 1
%392 = load float, float* %391
%393 = fneg float %390
%394 = call float @llvm.fmuladd.f32(float %393, float %392, float %388)
%395 = load float*, float** %12
%396 = getelementptr inbounds float, float* %395, i64 0
store float %394, float* %396
%397 = getelementptr inbounds [4 x float], [4 x float]* %13, i64 0, i64 3
%398 = load float, float* %397
%399 = getelementptr inbounds [4 x float], [4 x float]* %11, i64 0, i64 1
%400 = load float, float* %399
%401 = getelementptr inbounds [4 x float], [4 x float]* %13, i64 0, i64 1
%402 = load float, float* %401
%403 = getelementptr inbounds [4 x float], [4 x float]* %11, i64 0, i64 3
%404 = load float, float* %403
%405 = fmul float %402, %404
%406 = call float @llvm.fmuladd.f32(float %398, float %400, float %405)
%407 = getelementptr inbounds [4 x float], [4 x float]* %13, i64 0, i64 2
%408 = load float, float* %407
%409 = getelementptr inbounds [4 x float], [4 x float]* %11, i64 0, i64 0
%410 = load float, float* %409
%411 = call float @llvm.fmuladd.f32(float %408, float %410, float %406)
%412 = getelementptr inbounds [4 x float], [4 x float]* %13, i64 0, i64 0
%413 = load float, float* %412
%414 = getelementptr inbounds [4 x float], [4 x float]* %11, i64 0, i64 2
%415 = load float, float* %414
%416 = fneg float %413
%417 = call float @llvm.fmuladd.f32(float %416, float %415, float %411)
%418 = load float*, float** %12
%419 = getelementptr inbounds float, float* %418, i64 1
store float %417, float* %419
%420 = getelementptr inbounds [4 x float], [4 x float]* %13, i64 0, i64 3
%421 = load float, float* %420
%422 = getelementptr inbounds [4 x float], [4 x float]* %11, i64 0, i64 2
%423 = load float, float* %422
%424 = getelementptr inbounds [4 x float], [4 x float]* %13, i64 0, i64 2
%425 = load float, float* %424
%426 = getelementptr inbounds [4 x float], [4 x float]* %11, i64 0, i64 3
%427 = load float, float* %426
%428 = fmul float %425, %427
%429 = call float @llvm.fmuladd.f32(float %421, float %423, float %428)
%430 = getelementptr inbounds [4 x float], [4 x float]* %13, i64 0, i64 0
%431 = load float, float* %430
%432 = getelementptr inbounds [4 x float], [4 x float]* %11, i64 0, i64 1
%433 = load float, float* %432
%434 = call float @llvm.fmuladd.f32(float %431, float %433, float %429)
%435 = getelementptr inbounds [4 x float], [4 x float]* %13, i64 0, i64 1
%436 = load float, float* %435
%437 = getelementptr inbounds [4 x float], [4 x float]* %11, i64 0, i64 0
%438 = load float, float* %437
%439 = fneg float %436
%440 = call float @llvm.fmuladd.f32(float %439, float %438, float %434)
%441 = load float*, float** %12
%442 = getelementptr inbounds float, float* %441, i64 2
store float %440, float* %442
%443 = getelementptr inbounds [4 x float], [4 x float]* %13, i64 0, i64 3
%444 = load float, float* %443
%445 = getelementptr inbounds [4 x float], [4 x float]* %11, i64 0, i64 3
%446 = load float, float* %445
%447 = getelementptr inbounds [4 x float], [4 x float]* %13, i64 0, i64 0
%448 = load float, float* %447
%449 = getelementptr inbounds [4 x float], [4 x float]* %11, i64 0, i64 0
%450 = load float, float* %449
%451 = fmul float %448, %450
%452 = fneg float %451
%453 = call float @llvm.fmuladd.f32(float %444, float %446, float %452)
%454 = getelementptr inbounds [4 x float], [4 x float]* %13, i64 0, i64 1
%455 = load float, float* %454
%456 = getelementptr inbounds [4 x float], [4 x float]* %11, i64 0, i64 1
%457 = load float, float* %456
%458 = fneg float %455
%459 = call float @llvm.fmuladd.f32(float %458, float %457, float %453)
%460 = getelementptr inbounds [4 x float], [4 x float]* %13, i64 0, i64 2
%461 = load float, float* %460
%462 = getelementptr inbounds [4 x float], [4 x float]* %11, i64 0, i64 2
%463 = load float, float* %462
%464 = fneg float %461
%465 = call float @llvm.fmuladd.f32(float %464, float %463, float %459)
%466 = load float*, float** %12
%467 = getelementptr inbounds float, float* %466, i64 3
store float %465, float* %467
%468 = load float*, float** %4
%469 = getelementptr inbounds float, float* %468, i64 7
store float 0.000000e+00, float* %469
%470 = load float*, float** %4
%471 = getelementptr inbounds float, float* %470, i64 8
store float* %471, float** %12
%472 = getelementptr inbounds [4 x float], [4 x float]* %10, i64 0, i64 3
%473 = load float, float* %472
%474 = load float*, float** %12
%475 = getelementptr inbounds float, float* %474, i64 0
%476 = load float, float* %475
%477 = getelementptr inbounds [4 x float], [4 x float]* %10, i64 0, i64 0
%478 = load float, float* %477
%479 = load float*, float** %12
%480 = getelementptr inbounds float, float* %479, i64 3
%481 = load float, float* %480
%482 = fmul float %478, %481
%483 = call float @llvm.fmuladd.f32(float %473, float %476, float %482)
%484 = getelementptr inbounds [4 x float], [4 x float]* %10, i64 0, i64 1
%485 = load float, float* %484
%486 = load float*, float** %12
%487 = getelementptr inbounds float, float* %486, i64 2
%488 = load float, float* %487
%489 = call float @llvm.fmuladd.f32(float %485, float %488, float %483)
%490 = getelementptr inbounds [4 x float], [4 x float]* %10, i64 0, i64 2
%491 = load float, float* %490
%492 = load float*, float** %12
%493 = getelementptr inbounds float, float* %492, i64 1
%494 = load float, float* %493
%495 = fneg float %491
%496 = call float @llvm.fmuladd.f32(float %495, float %494, float %489)
%497 = getelementptr inbounds [4 x float], [4 x float]* %13, i64 0, i64 0
store float %496, float* %497
%498 = getelementptr inbounds [4 x float], [4 x float]* %10, i64 0, i64 3
%499 = load float, float* %498
%500 = load float*, float** %12
%501 = getelementptr inbounds float, float* %500, i64 1
%502 = load float, float* %501
%503 = getelementptr inbounds [4 x float], [4 x float]* %10, i64 0, i64 1
%504 = load float, float* %503
%505 = load float*, float** %12
%506 = getelementptr inbounds float, float* %505, i64 3
%507 = load float, float* %506
%508 = fmul float %504, %507
%509 = call float @llvm.fmuladd.f32(float %499, float %502, float %508)
%510 = getelementptr inbounds [4 x float], [4 x float]* %10, i64 0, i64 2
%511 = load float, float* %510
%512 = load float*, float** %12
%513 = getelementptr inbounds float, float* %512, i64 0
%514 = load float, float* %513
%515 = call float @llvm.fmuladd.f32(float %511, float %514, float %509)
%516 = getelementptr inbounds [4 x float], [4 x float]* %10, i64 0, i64 0
%517 = load float, float* %516
%518 = load float*, float** %12
%519 = getelementptr inbounds float, float* %518, i64 2
%520 = load float, float* %519
%521 = fneg float %517
%522 = call float @llvm.fmuladd.f32(float %521, float %520, float %515)
%523 = getelementptr inbounds [4 x float], [4 x float]* %13, i64 0, i64 1
store float %522, float* %523
%524 = getelementptr inbounds [4 x float], [4 x float]* %10, i64 0, i64 3
%525 = load float, float* %524
%526 = load float*, float** %12
%527 = getelementptr inbounds float, float* %526, i64 2
%528 = load float, float* %527
%529 = getelementptr inbounds [4 x float], [4 x float]* %10, i64 0, i64 2
%530 = load float, float* %529
%531 = load float*, float** %12
%532 = getelementptr inbounds float, float* %531, i64 3
%533 = load float, float* %532
%534 = fmul float %530, %533
%535 = call float @llvm.fmuladd.f32(float %525, float %528, float %534)
%536 = getelementptr inbounds [4 x float], [4 x float]* %10, i64 0, i64 0
%537 = load float, float* %536
%538 = load float*, float** %12
%539 = getelementptr inbounds float, float* %538, i64 1
%540 = load float, float* %539
%541 = call float @llvm.fmuladd.f32(float %537, float %540, float %535)
%542 = getelementptr inbounds [4 x float], [4 x float]* %10, i64 0, i64 1
%543 = load float, float* %542
%544 = load float*, float** %12
%545 = getelementptr inbounds float, float* %544, i64 0
%546 = load float, float* %545
%547 = fneg float %543
%548 = call float @llvm.fmuladd.f32(float %547, float %546, float %541)
%549 = getelementptr inbounds [4 x float], [4 x float]* %13, i64 0, i64 2
store float %548, float* %549
%550 = getelementptr inbounds [4 x float], [4 x float]* %10, i64 0, i64 3
%551 = load float, float* %550
%552 = load float*, float** %12
%553 = getelementptr inbounds float, float* %552, i64 3
%554 = load float, float* %553
%555 = getelementptr inbounds [4 x float], [4 x float]* %10, i64 0, i64 0
%556 = load float, float* %555
%557 = load float*, float** %12
%558 = getelementptr inbounds float, float* %557, i64 0
%559 = load float, float* %558
%560 = fmul float %556, %559
%561 = fneg float %560
%562 = call float @llvm.fmuladd.f32(float %551, float %554, float %561)
%563 = getelementptr inbounds [4 x float], [4 x float]* %10, i64 0, i64 1
%564 = load float, float* %563
%565 = load float*, float** %12
%566 = getelementptr inbounds float, float* %565, i64 1
%567 = load float, float* %566
%568 = fneg float %564
%569 = call float @llvm.fmuladd.f32(float %568, float %567, float %562)
%570 = getelementptr inbounds [4 x float], [4 x float]* %10, i64 0, i64 2
%571 = load float, float* %570
%572 = load float*, float** %12
%573 = getelementptr inbounds float, float* %572, i64 2
%574 = load float, float* %573
%575 = fneg float %571
%576 = call float @llvm.fmuladd.f32(float %575, float %574, float %569)
%577 = getelementptr inbounds [4 x float], [4 x float]* %13, i64 0, i64 3
store float %576, float* %577
%578 = getelementptr inbounds [4 x float], [4 x float]* %13, i64 0, i64 3
%579 = load float, float* %578
%580 = getelementptr inbounds [4 x float], [4 x float]* %11, i64 0, i64 0
%581 = load float, float* %580
%582 = getelementptr inbounds [4 x float], [4 x float]* %13, i64 0, i64 0
%583 = load float, float* %582
%584 = getelementptr inbounds [4 x float], [4 x float]* %11, i64 0, i64 3
%585 = load float, float* %584
%586 = fmul float %583, %585
%587 = call float @llvm.fmuladd.f32(float %579, float %581, float %586)
%588 = getelementptr inbounds [4 x float], [4 x float]* %13, i64 0, i64 1
%589 = load float, float* %588
%590 = getelementptr inbounds [4 x float], [4 x float]* %11, i64 0, i64 2
%591 = load float, float* %590
%592 = call float @llvm.fmuladd.f32(float %589, float %591, float %587)
%593 = getelementptr inbounds [4 x float], [4 x float]* %13, i64 0, i64 2
%594 = load float, float* %593
%595 = getelementptr inbounds [4 x float], [4 x float]* %11, i64 0, i64 1
%596 = load float, float* %595
%597 = fneg float %594
%598 = call float @llvm.fmuladd.f32(float %597, float %596, float %592)
%599 = load float*, float** %12
%600 = getelementptr inbounds float, float* %599, i64 0
store float %598, float* %600
%601 = getelementptr inbounds [4 x float], [4 x float]* %13, i64 0, i64 3
%602 = load float, float* %601
%603 = getelementptr inbounds [4 x float], [4 x float]* %11, i64 0, i64 1
%604 = load float, float* %603
%605 = getelementptr inbounds [4 x float], [4 x float]* %13, i64 0, i64 1
%606 = load float, float* %605
%607 = getelementptr inbounds [4 x float], [4 x float]* %11, i64 0, i64 3
%608 = load float, float* %607
%609 = fmul float %606, %608
%610 = call float @llvm.fmuladd.f32(float %602, float %604, float %609)
%611 = getelementptr inbounds [4 x float], [4 x float]* %13, i64 0, i64 2
%612 = load float, float* %611
%613 = getelementptr inbounds [4 x float], [4 x float]* %11, i64 0, i64 0
%614 = load float, float* %613
%615 = call float @llvm.fmuladd.f32(float %612, float %614, float %610)
%616 = getelementptr inbounds [4 x float], [4 x float]* %13, i64 0, i64 0
%617 = load float, float* %616
%618 = getelementptr inbounds [4 x float], [4 x float]* %11, i64 0, i64 2
%619 = load float, float* %618
%620 = fneg float %617
%621 = call float @llvm.fmuladd.f32(float %620, float %619, float %615)
%622 = load float*, float** %12
%623 = getelementptr inbounds float, float* %622, i64 1
store float %621, float* %623
%624 = getelementptr inbounds [4 x float], [4 x float]* %13, i64 0, i64 3
%625 = load float, float* %624
%626 = getelementptr inbounds [4 x float], [4 x float]* %11, i64 0, i64 2
%627 = load float, float* %626
%628 = getelementptr inbounds [4 x float], [4 x float]* %13, i64 0, i64 2
%629 = load float, float* %628
%630 = getelementptr inbounds [4 x float], [4 x float]* %11, i64 0, i64 3
%631 = load float, float* %630
%632 = fmul float %629, %631
%633 = call float @llvm.fmuladd.f32(float %625, float %627, float %632)
%634 = getelementptr inbounds [4 x float], [4 x float]* %13, i64 0, i64 0
%635 = load float, float* %634
%636 = getelementptr inbounds [4 x float], [4 x float]* %11, i64 0, i64 1
%637 = load float, float* %636
%638 = call float @llvm.fmuladd.f32(float %635, float %637, float %633)
%639 = getelementptr inbounds [4 x float], [4 x float]* %13, i64 0, i64 1
%640 = load float, float* %639
%641 = getelementptr inbounds [4 x float], [4 x float]* %11, i64 0, i64 0
%642 = load float, float* %641
%643 = fneg float %640
%644 = call float @llvm.fmuladd.f32(float %643, float %642, float %638)
%645 = load float*, float** %12
%646 = getelementptr inbounds float, float* %645, i64 2
store float %644, float* %646
%647 = getelementptr inbounds [4 x float], [4 x float]* %13, i64 0, i64 3
%648 = load float, float* %647
%649 = getelementptr inbounds [4 x float], [4 x float]* %11, i64 0, i64 3
%650 = load float, float* %649
%651 = getelementptr inbounds [4 x float], [4 x float]* %13, i64 0, i64 0
%652 = load float, float* %651
%653 = getelementptr inbounds [4 x float], [4 x float]* %11, i64 0, i64 0
%654 = load float, float* %653
%655 = fmul float %652, %654
%656 = fneg float %655
%657 = call float @llvm.fmuladd.f32(float %648, float %650, float %656)
%658 = getelementptr inbounds [4 x float], [4 x float]* %13, i64 0, i64 1
%659 = load float, float* %658
%660 = getelementptr inbounds [4 x float], [4 x float]* %11, i64 0, i64 1
%661 = load float, float* %660
%662 = fneg float %659
%663 = call float @llvm.fmuladd.f32(float %662, float %661, float %657)
%664 = getelementptr inbounds [4 x float], [4 x float]* %13, i64 0, i64 2
%665 = load float, float* %664
%666 = getelementptr inbounds [4 x float], [4 x float]* %11, i64 0, i64 2
%667 = load float, float* %666
%668 = fneg float %665
%669 = call float @llvm.fmuladd.f32(float %668, float %667, float %663)
%670 = load float*, float** %12
%671 = getelementptr inbounds float, float* %670, i64 3
store float %669, float* %671
%672 = load float*, float** %4
%673 = getelementptr inbounds float, float* %672, i64 11
store float 0.000000e+00, float* %673
br label %674
674: ; preds = %17, %3
ret void
}

LLVM IR (-O2):
define void @Mat4_RotateAxis(float* nocapture %0, float* nocapture %1, float %2) {
%4 = fcmp une float %2, 0.000000e+00
br i1 %4, label %5, label %130
5: ; preds = %3
%6 = fpext float %2 to double
%7 = fmul double %6, 0x400921FB54442D18
%8 = fdiv double %7, 3.600000e+02
%9 = fptrunc double %8 to float
%10 = tail call float @sinf(float %9)
%11 = tail call float @cosf(float %9)
%12 = load float, float* %1
%13 = fmul float %10, %12
%14 = getelementptr inbounds float, float* %1, i64 1
%15 = load float, float* %14
%16 = fmul float %10, %15
%17 = getelementptr inbounds float, float* %1, i64 2
%18 = load float, float* %17
%19 = fmul float %10, %18
%20 = fneg float %13
%21 = fneg float %16
%22 = fneg float %19
%23 = load float, float* %0
%24 = getelementptr inbounds float, float* %0, i64 3
%25 = load float, float* %24
%26 = fmul float %13, %25
%27 = tail call float @llvm.fmuladd.f32(float %11, float %23, float %26)
%28 = getelementptr inbounds float, float* %0, i64 2
%29 = load float, float* %28
%30 = tail call float @llvm.fmuladd.f32(float %16, float %29, float %27)
%31 = getelementptr inbounds float, float* %0, i64 1
%32 = load float, float* %31
%33 = tail call float @llvm.fmuladd.f32(float %22, float %32, float %30)
%34 = fmul float %16, %25
%35 = tail call float @llvm.fmuladd.f32(float %11, float %32, float %34)
%36 = tail call float @llvm.fmuladd.f32(float %19, float %23, float %35)
%37 = tail call float @llvm.fmuladd.f32(float %20, float %29, float %36)
%38 = fmul float %19, %25
%39 = tail call float @llvm.fmuladd.f32(float %11, float %29, float %38)
%40 = tail call float @llvm.fmuladd.f32(float %13, float %32, float %39)
%41 = tail call float @llvm.fmuladd.f32(float %21, float %23, float %40)
%42 = fmul float %23, %20
%43 = tail call float @llvm.fmuladd.f32(float %11, float %25, float %42)
%44 = tail call float @llvm.fmuladd.f32(float %21, float %32, float %43)
%45 = tail call float @llvm.fmuladd.f32(float %22, float %29, float %44)
%46 = fmul float %11, %33
%47 = tail call float @llvm.fmuladd.f32(float %45, float %20, float %46)
%48 = tail call float @llvm.fmuladd.f32(float %37, float %22, float %47)
%49 = tail call float @llvm.fmuladd.f32(float %41, float %16, float %48)
store float %49, float* %0
%50 = fmul float %11, %37
%51 = tail call float @llvm.fmuladd.f32(float %45, float %21, float %50)
%52 = tail call float @llvm.fmuladd.f32(float %41, float %20, float %51)
%53 = tail call float @llvm.fmuladd.f32(float %33, float %19, float %52)
store float %53, float* %31
%54 = fmul float %11, %41
%55 = tail call float @llvm.fmuladd.f32(float %45, float %22, float %54)
%56 = tail call float @llvm.fmuladd.f32(float %33, float %21, float %55)
%57 = tail call float @llvm.fmuladd.f32(float %37, float %13, float %56)
store float %57, float* %28
store float 0.000000e+00, float* %24
%58 = getelementptr inbounds float, float* %0, i64 4
%59 = load float, float* %58
%60 = getelementptr inbounds float, float* %0, i64 7
%61 = load float, float* %60
%62 = fmul float %13, %61
%63 = tail call float @llvm.fmuladd.f32(float %11, float %59, float %62)
%64 = getelementptr inbounds float, float* %0, i64 6
%65 = load float, float* %64
%66 = tail call float @llvm.fmuladd.f32(float %16, float %65, float %63)
%67 = getelementptr inbounds float, float* %0, i64 5
%68 = load float, float* %67
%69 = tail call float @llvm.fmuladd.f32(float %22, float %68, float %66)
%70 = fmul float %16, %61
%71 = tail call float @llvm.fmuladd.f32(float %11, float %68, float %70)
%72 = tail call float @llvm.fmuladd.f32(float %19, float %59, float %71)
%73 = tail call float @llvm.fmuladd.f32(float %20, float %65, float %72)
%74 = fmul float %19, %61
%75 = tail call float @llvm.fmuladd.f32(float %11, float %65, float %74)
%76 = tail call float @llvm.fmuladd.f32(float %13, float %68, float %75)
%77 = tail call float @llvm.fmuladd.f32(float %21, float %59, float %76)
%78 = fmul float %59, %20
%79 = tail call float @llvm.fmuladd.f32(float %11, float %61, float %78)
%80 = tail call float @llvm.fmuladd.f32(float %21, float %68, float %79)
%81 = tail call float @llvm.fmuladd.f32(float %22, float %65, float %80)
%82 = fmul float %11, %69
%83 = tail call float @llvm.fmuladd.f32(float %81, float %20, float %82)
%84 = tail call float @llvm.fmuladd.f32(float %73, float %22, float %83)
%85 = tail call float @llvm.fmuladd.f32(float %77, float %16, float %84)
store float %85, float* %58
%86 = fmul float %11, %73
%87 = tail call float @llvm.fmuladd.f32(float %81, float %21, float %86)
%88 = tail call float @llvm.fmuladd.f32(float %77, float %20, float %87)
%89 = tail call float @llvm.fmuladd.f32(float %69, float %19, float %88)
store float %89, float* %67
%90 = fmul float %11, %77
%91 = tail call float @llvm.fmuladd.f32(float %81, float %22, float %90)
%92 = tail call float @llvm.fmuladd.f32(float %69, float %21, float %91)
%93 = tail call float @llvm.fmuladd.f32(float %73, float %13, float %92)
store float %93, float* %64
store float 0.000000e+00, float* %60
%94 = getelementptr inbounds float, float* %0, i64 8
%95 = load float, float* %94
%96 = getelementptr inbounds float, float* %0, i64 11
%97 = load float, float* %96
%98 = fmul float %13, %97
%99 = tail call float @llvm.fmuladd.f32(float %11, float %95, float %98)
%100 = getelementptr inbounds float, float* %0, i64 10
%101 = load float, float* %100
%102 = tail call float @llvm.fmuladd.f32(float %16, float %101, float %99)
%103 = getelementptr inbounds float, float* %0, i64 9
%104 = load float, float* %103
%105 = tail call float @llvm.fmuladd.f32(float %22, float %104, float %102)
%106 = fmul float %16, %97
%107 = tail call float @llvm.fmuladd.f32(float %11, float %104, float %106)
%108 = tail call float @llvm.fmuladd.f32(float %19, float %95, float %107)
%109 = tail call float @llvm.fmuladd.f32(float %20, float %101, float %108)
%110 = fmul float %19, %97
%111 = tail call float @llvm.fmuladd.f32(float %11, float %101, float %110)
%112 = tail call float @llvm.fmuladd.f32(float %13, float %104, float %111)
%113 = tail call float @llvm.fmuladd.f32(float %21, float %95, float %112)
%114 = fmul float %95, %20
%115 = tail call float @llvm.fmuladd.f32(float %11, float %97, float %114)
%116 = tail call float @llvm.fmuladd.f32(float %21, float %104, float %115)
%117 = tail call float @llvm.fmuladd.f32(float %22, float %101, float %116)
%118 = fmul float %11, %105
%119 = tail call float @llvm.fmuladd.f32(float %117, float %20, float %118)
%120 = tail call float @llvm.fmuladd.f32(float %109, float %22, float %119)
%121 = tail call float @llvm.fmuladd.f32(float %113, float %16, float %120)
store float %121, float* %94
%122 = fmul float %11, %109
%123 = tail call float @llvm.fmuladd.f32(float %117, float %21, float %122)
%124 = tail call float @llvm.fmuladd.f32(float %113, float %20, float %123)
%125 = tail call float @llvm.fmuladd.f32(float %105, float %19, float %124)
store float %125, float* %103
%126 = fmul float %11, %113
%127 = tail call float @llvm.fmuladd.f32(float %117, float %22, float %126)
%128 = tail call float @llvm.fmuladd.f32(float %105, float %21, float %127)
%129 = tail call float @llvm.fmuladd.f32(float %109, float %13, float %128)
store float %129, float* %100
store float 0.000000e+00, float* %96
br label %130
130: ; preds = %5, %3
ret void
}