void mat4_rotate(const float m[4][4], float a, float x, float y, float z,
                 float out[4][4]) {
  if (a == 0.0) {
    mat4_copy(m, out);
    return;
  }
  float tmp[4][4];
  float s = sin(a);
  float c = cos(a);
  mat4_set_identity(tmp);
  if (x == 1.0 && y == 0.0 && z == 0.0) {
    tmp[1][1] = c;
    tmp[2][2] = c;
    tmp[2][1] = -s;
    tmp[1][2] = s;
  } else if (x == 0.0 && y == 1.0 && z == 0.0) {
    tmp[0][0] = c;
    tmp[2][2] = c;
    tmp[2][0] = s;
    tmp[0][2] = -s;
  } else if (x == 0.0 && y == 0.0 && z == 1.0) {
    tmp[0][0] = c;
    tmp[1][1] = c;
    tmp[1][0] = -s;
    tmp[0][1] = s;
  } else {
    float quat[4];
    quat_from_axis(quat, a, x, y, z);
    quat_to_mat4(quat, tmp);
  }
  mat4_mul(m, tmp, out);
}


x86 assembly (clang, -O0):
<mat4_rotate>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
mov    %rdi,-0x8(%rbp)
movss  %xmm0,-0xc(%rbp)
movss  %xmm1,-0x10(%rbp)
movss  %xmm2,-0x14(%rbp)
movss  %xmm3,-0x18(%rbp)
mov    %rsi,-0x20(%rbp)
movss  -0xc(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    11c7 <mat4_rotate+0x57>
jp     11c7 <mat4_rotate+0x57>
mov    -0x8(%rbp),%rdi
mov    -0x20(%rbp),%rsi
mov    $0x0,%al
call   1070 <mat4_copy@plt>
jmp    1414 <mat4_rotate+0x2a4>
movss  -0xc(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
call   1060 <sin@plt>
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0xc(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
call   1090 <cos@plt>
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x68(%rbp)
lea    -0x60(%rbp),%rdi
mov    $0x0,%al
call   1080 <mat4_set_identity@plt>
movss  -0x10(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xdef(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    1293 <mat4_rotate+0x123>
jp     1293 <mat4_rotate+0x123>
movss  -0x14(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1293 <mat4_rotate+0x123>
jp     1293 <mat4_rotate+0x123>
movss  -0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1293 <mat4_rotate+0x123>
jp     1293 <mat4_rotate+0x123>
movss  -0x68(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x68(%rbp),%xmm0
movss  %xmm0,-0x38(%rbp)
movss  -0x64(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  -0x64(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
jmp    1401 <mat4_rotate+0x291>
movss  -0x10(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1326 <mat4_rotate+0x1b6>
jp     1326 <mat4_rotate+0x1b6>
movss  -0x14(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xd40(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    1326 <mat4_rotate+0x1b6>
jp     1326 <mat4_rotate+0x1b6>
movss  -0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1326 <mat4_rotate+0x1b6>
jp     1326 <mat4_rotate+0x1b6>
movss  -0x68(%rbp),%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x68(%rbp),%xmm0
movss  %xmm0,-0x38(%rbp)
movss  -0x64(%rbp),%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x64(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x58(%rbp)
jmp    13fc <mat4_rotate+0x28c>
movss  -0x10(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    13b9 <mat4_rotate+0x249>
jp     13b9 <mat4_rotate+0x249>
movss  -0x14(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    13b9 <mat4_rotate+0x249>
jp     13b9 <mat4_rotate+0x249>
movss  -0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xc91(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    13b9 <mat4_rotate+0x249>
jp     13b9 <mat4_rotate+0x249>
movss  -0x68(%rbp),%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x68(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x64(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x64(%rbp),%xmm0
movss  %xmm0,-0x5c(%rbp)
jmp    13f7 <mat4_rotate+0x287>
lea    -0x80(%rbp),%rdi
movss  -0xc(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  -0x10(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
movss  -0x14(%rbp),%xmm2
cvtss2sd %xmm2,%xmm2
movss  -0x18(%rbp),%xmm3
cvtss2sd %xmm3,%xmm3
mov    $0x4,%al
call   1050 <quat_from_axis@plt>
lea    -0x80(%rbp),%rdi
lea    -0x60(%rbp),%rsi
mov    $0x0,%al
call   1030 <quat_to_mat4@plt>
jmp    13fc <mat4_rotate+0x28c>
jmp    1401 <mat4_rotate+0x291>
mov    -0x8(%rbp),%rdi
lea    -0x60(%rbp),%rsi
mov    -0x20(%rbp),%rdx
mov    $0x0,%al
call   1040 <mat4_mul@plt>
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<mat4_rotate>:
push   %r15
push   %r14
push   %rbx
sub    $0x80,%rsp
mov    %rsi,%r14
mov    %rdi,%rbx
xorps  %xmm4,%xmm4
ucomiss %xmm4,%xmm0
jne    11a5 <mat4_rotate+0x35>
jp     11a5 <mat4_rotate+0x35>
mov    %rbx,%rdi
mov    %r14,%rsi
xor    %eax,%eax
add    $0x80,%rsp
pop    %rbx
pop    %r14
pop    %r15
jmp    1070 <mat4_copy@plt>
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,0x18(%rsp)
movss  %xmm3,0x14(%rsp)
movss  %xmm2,0x10(%rsp)
movss  %xmm1,0xc(%rsp)
call   1060 <sin@plt>
cvtsd2ss %xmm0,%xmm0
movaps %xmm0,0x20(%rsp)
movsd  0x18(%rsp),%xmm0
call   1090 <cos@plt>
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0x8(%rsp)
lea    0x30(%rsp),%rdi
xor    %eax,%eax
call   1080 <mat4_set_identity@plt>
movss  0xc(%rsp),%xmm4
movss  0x10(%rsp),%xmm2
movss  0x14(%rsp),%xmm3
ucomiss 0xdf7(%rip),%xmm4
jne    1250 <mat4_rotate+0xe0>
jp     1250 <mat4_rotate+0xe0>
xorps  %xmm0,%xmm0
ucomiss %xmm0,%xmm2
jne    1250 <mat4_rotate+0xe0>
jp     1250 <mat4_rotate+0xe0>
ucomiss %xmm0,%xmm3
jne    1250 <mat4_rotate+0xe0>
jp     1250 <mat4_rotate+0xe0>
movss  0x8(%rsp),%xmm0
movss  %xmm0,0x44(%rsp)
movss  %xmm0,0x58(%rsp)
movaps 0xdd9(%rip),%xmm0
movaps 0x20(%rsp),%xmm1
xorps  %xmm1,%xmm0
movss  %xmm0,0x54(%rsp)
movss  %xmm1,0x48(%rsp)
jmp    1319 <mat4_rotate+0x1a9>
xorps  %xmm0,%xmm0
ucomiss %xmm0,%xmm4
jne    129b <mat4_rotate+0x12b>
jp     129b <mat4_rotate+0x12b>
ucomiss 0xd9f(%rip),%xmm2
jne    129b <mat4_rotate+0x12b>
jp     129b <mat4_rotate+0x12b>
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm3
jne    129b <mat4_rotate+0x12b>
jp     129b <mat4_rotate+0x12b>
movss  0x8(%rsp),%xmm0
movss  %xmm0,0x30(%rsp)
movss  %xmm0,0x58(%rsp)
movaps 0x20(%rsp),%xmm0
movss  %xmm0,0x50(%rsp)
xorps  0xd7d(%rip),%xmm0
movss  %xmm0,0x38(%rsp)
jmp    1319 <mat4_rotate+0x1a9>
ucomiss %xmm0,%xmm4
jne    12e6 <mat4_rotate+0x176>
jp     12e6 <mat4_rotate+0x176>
xorps  %xmm0,%xmm0
ucomiss %xmm0,%xmm2
jne    12e6 <mat4_rotate+0x176>
jp     12e6 <mat4_rotate+0x176>
ucomiss 0xd4d(%rip),%xmm3
jne    12e6 <mat4_rotate+0x176>
jp     12e6 <mat4_rotate+0x176>
movss  0x8(%rsp),%xmm0
movss  %xmm0,0x30(%rsp)
movss  %xmm0,0x44(%rsp)
movaps 0xd40(%rip),%xmm0
movaps 0x20(%rsp),%xmm1
xorps  %xmm1,%xmm0
movss  %xmm0,0x40(%rsp)
movss  %xmm1,0x34(%rsp)
jmp    1319 <mat4_rotate+0x1a9>
xorps  %xmm1,%xmm1
cvtss2sd %xmm4,%xmm1
cvtss2sd %xmm2,%xmm2
cvtss2sd %xmm3,%xmm3
lea    0x70(%rsp),%r15
mov    %r15,%rdi
movsd  0x18(%rsp),%xmm0
mov    $0x4,%al
call   1050 <quat_from_axis@plt>
lea    0x30(%rsp),%rsi
mov    %r15,%rdi
xor    %eax,%eax
call   1030 <quat_to_mat4@plt>
lea    0x30(%rsp),%rsi
mov    %rbx,%rdi
mov    %r14,%rdx
xor    %eax,%eax
call   1040 <mat4_mul@plt>
add    $0x80,%rsp
pop    %rbx
pop    %r14
pop    %r15
ret

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

LLVM IR (-O2):
define void @mat4_rotate([4 x float]* %0, float %1, float %2, float %3, float %4, [4 x float]* %5) {
%7 = alloca [4 x [4 x float]]
%8 = alloca [4 x float]
%9 = fpext float %1 to double
%10 = fcmp oeq float %1, 0.000000e+00
br i1 %10, label %11, label %13
11: ; preds = %6
%12 = tail call i32 ([4 x float]*, [4 x float]*, ...) bitcast (i32 (...)* @mat4_copy to i32 ([4 x float]*, [4 x float]*, ...)*)([4 x float]* %0, [4 x float]* %5)
br label %63
13: ; preds = %6
%14 = bitcast [4 x [4 x float]]* %7 to i8*
%15 = tail call double @sin(double %9)
%16 = fptrunc double %15 to float
%17 = tail call double @cos(double %9)
%18 = fptrunc double %17 to float
%19 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %7, i64 0, i64 0
%20 = call i32 ([4 x float]*, ...) bitcast (i32 (...)* @mat4_set_identity to i32 ([4 x float]*, ...)*)([4 x float]* %19)
%21 = fpext float %2 to double
%22 = fcmp oeq float %2, 1.000000e+00
%23 = fcmp oeq float %3, 0.000000e+00
%24 = and i1 %22, %23
%25 = fcmp oeq float %4, 0.000000e+00
%26 = and i1 %24, %25
br i1 %26, label %27, label %33
27: ; preds = %13
%28 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %7, i64 0, i64 1, i64 1
store float %18, float* %28
%29 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %7, i64 0, i64 2, i64 2
store float %18, float* %29
%30 = fneg float %16
%31 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %7, i64 0, i64 2, i64 1
store float %30, float* %31
%32 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %7, i64 0, i64 1, i64 2
store float %16, float* %32
br label %61
33: ; preds = %13
%34 = fcmp oeq float %2, 0.000000e+00
%35 = fcmp oeq float %3, 1.000000e+00
%36 = and i1 %34, %35
%37 = and i1 %36, %25
br i1 %37, label %38, label %44
38: ; preds = %33
%39 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %7, i64 0, i64 0, i64 0
store float %18, float* %39
%40 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %7, i64 0, i64 2, i64 2
store float %18, float* %40
%41 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %7, i64 0, i64 2, i64 0
store float %16, float* %41
%42 = fneg float %16
%43 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %7, i64 0, i64 0, i64 2
store float %42, float* %43
br label %61
44: ; preds = %33
%45 = and i1 %34, %23
%46 = fcmp oeq float %4, 1.000000e+00
%47 = and i1 %45, %46
br i1 %47, label %48, label %54
48: ; preds = %44
%49 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %7, i64 0, i64 0, i64 0
store float %18, float* %49
%50 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %7, i64 0, i64 1, i64 1
store float %18, float* %50
%51 = fneg float %16
%52 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %7, i64 0, i64 1, i64 0
store float %51, float* %52
%53 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* %7, i64 0, i64 0, i64 1
store float %16, float* %53
br label %61
54: ; preds = %44
%55 = bitcast [4 x float]* %8 to i8*
%56 = getelementptr inbounds [4 x float], [4 x float]* %8, i64 0, i64 0
%57 = fpext float %3 to double
%58 = fpext float %4 to double
%59 = call i32 (float*, double, double, double, double, ...) bitcast (i32 (...)* @quat_from_axis to i32 (float*, double, double, double, double, ...)*)(float* %56, double %9, double %21, double %57, double %58)
%60 = call i32 (float*, [4 x float]*, ...) bitcast (i32 (...)* @quat_to_mat4 to i32 (float*, [4 x float]*, ...)*)(float* %56, [4 x float]* %19)
br label %61
61: ; preds = %38, %54, %48, %27
%62 = call i32 ([4 x float]*, [4 x float]*, [4 x float]*, ...) bitcast (i32 (...)* @mat4_mul to i32 ([4 x float]*, [4 x float]*, [4 x float]*, ...)*)([4 x float]* %0, [4 x float]* %19, [4 x float]* %5)
br label %63
63: ; preds = %61, %11
ret void
}