#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);
float sqrtf(float);
void mat4_rotate(float *dst, float rad, float *axis) {
  float x = axis[0], y = axis[1], z = axis[2];
  float len = sqrtf(x * x + y * y + z * z);
  float s, c, t;
  float a00, a01, a02, a03;
  float a10, a11, a12, a13;
  float a20, a21, a22, a23;
  float b00, b01, b02;
  float b10, b11, b12;
  float b20, b21, b22;
  if (len < 0.000001) {
    return;
  }
  len = 1 / len;
  x *= len;
  y *= len;
  z *= len;
  s = sinf(rad);
  c = cosf(rad);
  t = 1 - c;
  a00 = dst[0];
  a01 = dst[1];
  a02 = dst[2];
  a03 = dst[3];
  a10 = dst[4];
  a11 = dst[5];
  a12 = dst[6];
  a13 = dst[7];
  a20 = dst[8];
  a21 = dst[9];
  a22 = dst[10];
  a23 = dst[11];
  b00 = x * x * t + c;
  b01 = y * x * t + z * s;
  b02 = z * x * t - y * s;
  b10 = x * y * t - z * s;
  b11 = y * y * t + c;
  b12 = z * y * t + x * s;
  b20 = x * z * t + y * s;
  b21 = y * z * t - x * s;
  b22 = z * z * t + c;
  dst[0] = a00 * b00 + a10 * b01 + a20 * b02;
  dst[1] = a01 * b00 + a11 * b01 + a21 * b02;
  dst[2] = a02 * b00 + a12 * b01 + a22 * b02;
  dst[3] = a03 * b00 + a13 * b01 + a23 * b02;
  dst[4] = a00 * b10 + a10 * b11 + a20 * b12;
  dst[5] = a01 * b10 + a11 * b11 + a21 * b12;
  dst[6] = a02 * b10 + a12 * b11 + a22 * b12;
  dst[7] = a03 * b10 + a13 * b11 + a23 * b12;
  dst[8] = a00 * b20 + a10 * b21 + a20 * b22;
  dst[9] = a01 * b20 + a11 * b21 + a21 * b22;
  dst[10] = a02 * b20 + a12 * b21 + a22 * b22;
  dst[11] = a03 * b20 + a13 * b21 + a23 * b22;
}


x86 assembly (clang, -O0):
<mat4_rotate>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
mov    %rdi,-0x8(%rbp)
movss  %xmm0,-0xc(%rbp)
mov    %rsi,-0x18(%rbp)
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x1c(%rbp)
mov    -0x18(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x20(%rbp)
mov    -0x18(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x24(%rbp)
movss  -0x1c(%rbp),%xmm1
movss  -0x1c(%rbp),%xmm2
movss  -0x20(%rbp),%xmm0
mulss  -0x20(%rbp),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x24(%rbp),%xmm0
movss  -0x24(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
call   1050 <sqrtf@plt>
movss  %xmm0,-0x28(%rbp)
movss  -0x28(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xe46(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    11c9 <mat4_rotate+0x99>
jmp    16fe <mat4_rotate+0x5ce>
movss  0xe37(%rip),%xmm0
divss  -0x28(%rbp),%xmm0
movss  %xmm0,-0x28(%rbp)
movss  -0x28(%rbp),%xmm0
mulss  -0x1c(%rbp),%xmm0
movss  %xmm0,-0x1c(%rbp)
movss  -0x28(%rbp),%xmm0
mulss  -0x20(%rbp),%xmm0
movss  %xmm0,-0x20(%rbp)
movss  -0x28(%rbp),%xmm0
mulss  -0x24(%rbp),%xmm0
movss  %xmm0,-0x24(%rbp)
movss  -0xc(%rbp),%xmm0
call   1030 <sinf@plt>
movss  %xmm0,-0x2c(%rbp)
movss  -0xc(%rbp),%xmm0
call   1040 <cosf@plt>
movss  %xmm0,-0x30(%rbp)
movss  0xdda(%rip),%xmm0
subss  -0x30(%rbp),%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x8(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x8(%rbp),%rax
movss  0x10(%rax),%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x8(%rbp),%rax
movss  0x14(%rax),%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x8(%rbp),%rax
movss  0x18(%rax),%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x8(%rbp),%rax
movss  0x1c(%rax),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x8(%rbp),%rax
movss  0x20(%rax),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x8(%rbp),%rax
movss  0x24(%rax),%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x8(%rbp),%rax
movss  0x28(%rax),%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x8(%rbp),%rax
movss  0x2c(%rax),%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x1c(%rbp),%xmm0
mulss  -0x1c(%rbp),%xmm0
movss  -0x34(%rbp),%xmm2
movss  -0x30(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
movss  -0x20(%rbp),%xmm0
mulss  -0x1c(%rbp),%xmm0
movss  -0x34(%rbp),%xmm2
movss  -0x24(%rbp),%xmm1
mulss  -0x2c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x6c(%rbp)
movss  -0x24(%rbp),%xmm0
mulss  -0x1c(%rbp),%xmm0
movss  -0x34(%rbp),%xmm2
movss  -0x20(%rbp),%xmm1
mulss  -0x2c(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x70(%rbp)
movss  -0x1c(%rbp),%xmm0
mulss  -0x20(%rbp),%xmm0
movss  -0x34(%rbp),%xmm2
movss  -0x24(%rbp),%xmm1
mulss  -0x2c(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x20(%rbp),%xmm0
mulss  -0x20(%rbp),%xmm0
movss  -0x34(%rbp),%xmm2
movss  -0x30(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x78(%rbp)
movss  -0x24(%rbp),%xmm0
mulss  -0x20(%rbp),%xmm0
movss  -0x34(%rbp),%xmm2
movss  -0x1c(%rbp),%xmm1
mulss  -0x2c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x7c(%rbp)
movss  -0x1c(%rbp),%xmm0
mulss  -0x24(%rbp),%xmm0
movss  -0x34(%rbp),%xmm2
movss  -0x20(%rbp),%xmm1
mulss  -0x2c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x80(%rbp)
movss  -0x20(%rbp),%xmm0
mulss  -0x24(%rbp),%xmm0
movss  -0x34(%rbp),%xmm2
movss  -0x1c(%rbp),%xmm1
mulss  -0x2c(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x24(%rbp),%xmm0
mulss  -0x24(%rbp),%xmm0
movss  -0x34(%rbp),%xmm2
movss  -0x30(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x88(%rbp)
ff
movss  -0x38(%rbp),%xmm1
movss  -0x68(%rbp),%xmm2
movss  -0x48(%rbp),%xmm0
mulss  -0x6c(%rbp),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x58(%rbp),%xmm0
movss  -0x70(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x3c(%rbp),%xmm1
movss  -0x68(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm0
mulss  -0x6c(%rbp),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x5c(%rbp),%xmm0
movss  -0x70(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x40(%rbp),%xmm1
movss  -0x68(%rbp),%xmm2
movss  -0x50(%rbp),%xmm0
mulss  -0x6c(%rbp),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x60(%rbp),%xmm0
movss  -0x70(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x8(%rax)
movss  -0x44(%rbp),%xmm1
movss  -0x68(%rbp),%xmm2
movss  -0x54(%rbp),%xmm0
mulss  -0x6c(%rbp),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x64(%rbp),%xmm0
movss  -0x70(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0xc(%rax)
movss  -0x38(%rbp),%xmm1
movss  -0x74(%rbp),%xmm2
movss  -0x48(%rbp),%xmm0
mulss  -0x78(%rbp),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x58(%rbp),%xmm0
movss  -0x7c(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x10(%rax)
movss  -0x3c(%rbp),%xmm1
movss  -0x74(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm0
mulss  -0x78(%rbp),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x5c(%rbp),%xmm0
movss  -0x7c(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x14(%rax)
movss  -0x40(%rbp),%xmm1
movss  -0x74(%rbp),%xmm2
movss  -0x50(%rbp),%xmm0
mulss  -0x78(%rbp),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x60(%rbp),%xmm0
movss  -0x7c(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x18(%rax)
movss  -0x44(%rbp),%xmm1
movss  -0x74(%rbp),%xmm2
movss  -0x54(%rbp),%xmm0
mulss  -0x78(%rbp),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x64(%rbp),%xmm0
movss  -0x7c(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x1c(%rax)
movss  -0x38(%rbp),%xmm1
movss  -0x80(%rbp),%xmm2
movss  -0x48(%rbp),%xmm0
mulss  -0x84(%rbp),%xmm0
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x58(%rbp),%xmm0
movss  -0x88(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x20(%rax)
movss  -0x3c(%rbp),%xmm1
movss  -0x80(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm0
mulss  -0x84(%rbp),%xmm0
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x5c(%rbp),%xmm0
movss  -0x88(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x24(%rax)
movss  -0x40(%rbp),%xmm1
movss  -0x80(%rbp),%xmm2
movss  -0x50(%rbp),%xmm0
mulss  -0x84(%rbp),%xmm0
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x60(%rbp),%xmm0
movss  -0x88(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x28(%rax)
movss  -0x44(%rbp),%xmm1
movss  -0x80(%rbp),%xmm2
movss  -0x54(%rbp),%xmm0
mulss  -0x84(%rbp),%xmm0
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x64(%rbp),%xmm0
movss  -0x88(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x2c(%rax)
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<mat4_rotate>:
push   %rbx
sub    $0x40,%rsp
movss  %xmm0,0x10(%rsp)
mov    %rdi,%rbx
movss  (%rsi),%xmm1
movss  0x4(%rsi),%xmm0
movss  0x8(%rsi),%xmm2
movaps %xmm0,0x20(%rsp)
mulss  %xmm0,%xmm0
movss  %xmm1,0x8(%rsp)
mulss  %xmm1,%xmm1
addss  %xmm0,%xmm1
movaps %xmm2,0x30(%rsp)
movaps %xmm2,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jb     1181 <mat4_rotate+0x51>
sqrtss %xmm0,%xmm0
jmp    1186 <mat4_rotate+0x56>
call   1050 <sqrtf@plt>
xorps  %xmm1,%xmm1
cvtss2sd %xmm0,%xmm1
movsd  0xe6b(%rip),%xmm2
ucomisd %xmm1,%xmm2
ja     1335 <mat4_rotate+0x205>
movss  0xe61(%rip),%xmm1
divss  %xmm0,%xmm1
movss  0x8(%rsp),%xmm0
mulss  %xmm1,%xmm0
movss  %xmm0,0x8(%rsp)
movaps 0x20(%rsp),%xmm0
mulss  %xmm1,%xmm0
movaps %xmm0,0x20(%rsp)
movaps 0x30(%rsp),%xmm0
mulss  %xmm1,%xmm0
movaps %xmm0,0x30(%rsp)
movss  0x10(%rsp),%xmm0
call   1030 <sinf@plt>
movss  %xmm0,0xc(%rsp)
movss  0x10(%rsp),%xmm0
call   1040 <cosf@plt>
movss  0xe0d(%rip),%xmm6
subss  %xmm0,%xmm6
movups (%rbx),%xmm9
movups 0x10(%rbx),%xmm10
movups 0x20(%rbx),%xmm1
movaps %xmm1,0x10(%rsp)
movss  0x8(%rsp),%xmm2
movaps %xmm2,%xmm7
mulss  %xmm2,%xmm7
mulss  %xmm6,%xmm7
addss  %xmm0,%xmm7
movaps 0x20(%rsp),%xmm1
movaps %xmm1,%xmm5
mulss  %xmm2,%xmm5
movaps %xmm2,%xmm14
movaps 0x30(%rsp),%xmm4
movaps %xmm4,%xmm2
movss  0xc(%rsp),%xmm8
mulss  %xmm8,%xmm2
mulss  %xmm6,%xmm5
movaps %xmm5,%xmm12
addss  %xmm2,%xmm12
movaps %xmm4,%xmm3
movaps %xmm4,%xmm15
mulss  %xmm14,%xmm3
movaps %xmm1,%xmm11
mulss  %xmm8,%xmm11
mulss  %xmm6,%xmm3
movaps %xmm3,%xmm4
subss  %xmm11,%xmm4
subss  %xmm2,%xmm5
movaps %xmm15,%xmm2
mulss  %xmm1,%xmm2
mulss  %xmm1,%xmm1
mulss  %xmm6,%xmm1
addss  %xmm0,%xmm1
movaps %xmm1,%xmm13
movaps %xmm14,%xmm1
mulss  %xmm8,%xmm1
mulss  %xmm6,%xmm2
movaps %xmm6,%xmm14
movaps %xmm2,%xmm6
addss  %xmm1,%xmm6
addss  %xmm11,%xmm3
subss  %xmm1,%xmm2
movaps %xmm15,%xmm1
mulss  %xmm15,%xmm1
mulss  %xmm14,%xmm1
addss  %xmm0,%xmm1
movaps %xmm1,%xmm0
shufps $0x0,%xmm12,%xmm12
mulps  %xmm10,%xmm12
shufps $0x0,%xmm7,%xmm7
mulps  %xmm9,%xmm7
addps  %xmm12,%xmm7
shufps $0x0,%xmm4,%xmm4
movaps 0x10(%rsp),%xmm1
mulps  %xmm1,%xmm4
addps  %xmm7,%xmm4
movups %xmm4,(%rbx)
shufps $0x0,%xmm13,%xmm13
mulps  %xmm10,%xmm13
shufps $0x0,%xmm5,%xmm5
mulps  %xmm9,%xmm5
addps  %xmm13,%xmm5
shufps $0x0,%xmm6,%xmm6
mulps  %xmm1,%xmm6
addps  %xmm5,%xmm6
movups %xmm6,0x10(%rbx)
shufps $0x0,%xmm2,%xmm2
mulps  %xmm10,%xmm2
shufps $0x0,%xmm3,%xmm3
mulps  %xmm9,%xmm3
addps  %xmm2,%xmm3
shufps $0x0,%xmm0,%xmm0
mulps  %xmm1,%xmm0
addps  %xmm3,%xmm0
movups %xmm0,0x20(%rbx)
add    $0x40,%rsp
pop    %rbx
ret

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

LLVM IR (-O2):
define void @mat4_rotate(float* nocapture %0, float %1, float* nocapture %2) {
%4 = load float, float* %2
%5 = getelementptr inbounds float, float* %2, i64 1
%6 = load float, float* %5
%7 = getelementptr inbounds float, float* %2, i64 2
%8 = load float, float* %7
%9 = fmul float %6, %6
%10 = tail call float @llvm.fmuladd.f32(float %4, float %4, float %9)
%11 = tail call float @llvm.fmuladd.f32(float %8, float %8, float %10)
%12 = tail call float @sqrtf(float %11)
%13 = fpext float %12 to double
%14 = fcmp olt double %13, 0x3EB0C6F7A0B5ED8D
br i1 %14, label %82, label %15
15: ; preds = %3
%16 = fdiv float 1.000000e+00, %12
%17 = fmul float %4, %16
%18 = fmul float %6, %16
%19 = fmul float %8, %16
%20 = tail call float @sinf(float %1)
%21 = tail call float @cosf(float %1)
%22 = fsub float 1.000000e+00, %21
%23 = bitcast float* %0 to <4 x float>*
%24 = load <4 x float>, <4 x float>* %23
%25 = getelementptr inbounds float, float* %0, i64 4
%26 = bitcast float* %25 to <4 x float>*
%27 = load <4 x float>, <4 x float>* %26
%28 = getelementptr inbounds float, float* %0, i64 8
%29 = bitcast float* %28 to <4 x float>*
%30 = load <4 x float>, <4 x float>* %29
%31 = fmul float %17, %17
%32 = tail call float @llvm.fmuladd.f32(float %31, float %22, float %21)
%33 = fmul float %18, %17
%34 = fmul float %19, %20
%35 = tail call float @llvm.fmuladd.f32(float %33, float %22, float %34)
%36 = fmul float %19, %17
%37 = fmul float %18, %20
%38 = fneg float %37
%39 = tail call float @llvm.fmuladd.f32(float %36, float %22, float %38)
%40 = fneg float %34
%41 = tail call float @llvm.fmuladd.f32(float %33, float %22, float %40)
%42 = fmul float %18, %18
%43 = tail call float @llvm.fmuladd.f32(float %42, float %22, float %21)
%44 = fmul float %19, %18
%45 = fmul float %17, %20
%46 = tail call float @llvm.fmuladd.f32(float %44, float %22, float %45)
%47 = tail call float @llvm.fmuladd.f32(float %36, float %22, float %37)
%48 = fneg float %45
%49 = tail call float @llvm.fmuladd.f32(float %44, float %22, float %48)
%50 = fmul float %19, %19
%51 = tail call float @llvm.fmuladd.f32(float %50, float %22, float %21)
%52 = insertelement <4 x float> poison, float %35, i64 0
%53 = shufflevector <4 x float> %52, <4 x float> poison, <4 x i32> zeroinitializer
%54 = fmul <4 x float> %53, %27
%55 = insertelement <4 x float> poison, float %32, i64 0
%56 = shufflevector <4 x float> %55, <4 x float> poison, <4 x i32> zeroinitializer
%57 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %24, <4 x float> %56, <4 x float> %54)
%58 = insertelement <4 x float> poison, float %39, i64 0
%59 = shufflevector <4 x float> %58, <4 x float> poison, <4 x i32> zeroinitializer
%60 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %30, <4 x float> %59, <4 x float> %57)
%61 = bitcast float* %0 to <4 x float>*
store <4 x float> %60, <4 x float>* %61
%62 = insertelement <4 x float> poison, float %43, i64 0
%63 = shufflevector <4 x float> %62, <4 x float> poison, <4 x i32> zeroinitializer
%64 = fmul <4 x float> %63, %27
%65 = insertelement <4 x float> poison, float %41, i64 0
%66 = shufflevector <4 x float> %65, <4 x float> poison, <4 x i32> zeroinitializer
%67 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %24, <4 x float> %66, <4 x float> %64)
%68 = insertelement <4 x float> poison, float %46, i64 0
%69 = shufflevector <4 x float> %68, <4 x float> poison, <4 x i32> zeroinitializer
%70 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %30, <4 x float> %69, <4 x float> %67)
%71 = bitcast float* %25 to <4 x float>*
store <4 x float> %70, <4 x float>* %71
%72 = insertelement <4 x float> poison, float %49, i64 0
%73 = shufflevector <4 x float> %72, <4 x float> poison, <4 x i32> zeroinitializer
%74 = fmul <4 x float> %73, %27
%75 = insertelement <4 x float> poison, float %47, i64 0
%76 = shufflevector <4 x float> %75, <4 x float> poison, <4 x i32> zeroinitializer
%77 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %24, <4 x float> %76, <4 x float> %74)
%78 = insertelement <4 x float> poison, float %51, i64 0
%79 = shufflevector <4 x float> %78, <4 x float> poison, <4 x i32> zeroinitializer
%80 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %30, <4 x float> %79, <4 x float> %77)
%81 = bitcast float* %28 to <4 x float>*
store <4 x float> %80, <4 x float>* %81
br label %82
82: ; preds = %3, %15
ret void
}