#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 */
int /*<<< orphan*/ nsvg__xformIdentity(float *);
void nsvg__xformInverse(float *inv, float *t) {
  double det = (double)t[0] * t[3] - (double)t[2] * t[1];
  double invdet = 1.0 / det;
  if (det > -1e-6 && det < -1e-6) {
    nsvg__xformIdentity(t);
    return;
  }
  inv[0] = (float)(t[3] * invdet);
  inv[2] = (float)(-t[2] * invdet);
  inv[4] = (float)(((double)t[2] * t[5] - (double)t[3] * t[4]) * invdet);
  inv[1] = (float)(-t[1] * invdet);
  inv[3] = (float)(t[0] * invdet);
  inv[5] = (float)(((double)t[1] * t[4] - (double)t[0] * t[5]) * invdet);
}


x86 assembly (clang, -O0):
<nsvg__xformInverse>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm1
cvtss2sd %xmm1,%xmm2
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm1
cvtss2sd %xmm1,%xmm1
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm3
cvtss2sd %xmm3,%xmm3
mulsd  %xmm3,%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x18(%rbp)
movsd  0xe85(%rip),%xmm0
divsd  -0x18(%rbp),%xmm0
movsd  %xmm0,-0x20(%rbp)
movsd  -0x18(%rbp),%xmm0
movsd  0xe66(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    11c5 <nsvg__xformInverse+0xb5>
movsd  0xe54(%rip),%xmm0
ucomisd -0x18(%rbp),%xmm0
jbe    11c5 <nsvg__xformInverse+0xb5>
mov    -0x10(%rbp),%rdi
call   1030 <nsvg__xformIdentity@plt>
jmp    132a <nsvg__xformInverse+0x21a>
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mulsd  -0x20(%rbp),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
cvtss2sd %xmm0,%xmm0
mulsd  -0x20(%rbp),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x8(%rax)
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x10(%rbp),%rax
movss  0x14(%rax),%xmm1
cvtss2sd %xmm1,%xmm2
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm1
cvtss2sd %xmm1,%xmm1
mov    -0x10(%rbp),%rax
movss  0x10(%rax),%xmm3
cvtss2sd %xmm3,%xmm3
mulsd  %xmm3,%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mulsd  -0x20(%rbp),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x10(%rax)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
cvtss2sd %xmm0,%xmm0
mulsd  -0x20(%rbp),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x4(%rax)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mulsd  -0x20(%rbp),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0xc(%rax)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x10(%rbp),%rax
movss  0x10(%rax),%xmm1
cvtss2sd %xmm1,%xmm2
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm1
cvtss2sd %xmm1,%xmm1
mov    -0x10(%rbp),%rax
movss  0x14(%rax),%xmm3
cvtss2sd %xmm3,%xmm3
mulsd  %xmm3,%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mulsd  -0x20(%rbp),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x14(%rax)
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<nsvg__xformInverse>:
movss  (%rsi),%xmm0
movss  0x4(%rsi),%xmm1
cvtss2sd %xmm0,%xmm2
movss  0xc(%rsi),%xmm0
cvtss2sd %xmm0,%xmm3
movss  0x8(%rsi),%xmm0
cvtss2sd %xmm0,%xmm0
cvtss2sd %xmm1,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm3,%xmm2
subsd  %xmm1,%xmm2
movsd  0xec9(%rip),%xmm0
divsd  %xmm2,%xmm0
mulsd  %xmm0,%xmm3
xorps  %xmm1,%xmm1
cvtsd2ss %xmm3,%xmm1
movss  %xmm1,(%rdi)
movss  0x8(%rsi),%xmm1
movaps 0xeba(%rip),%xmm2
xorps  %xmm2,%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm0,%xmm1
cvtsd2ss %xmm1,%xmm1
movss  %xmm1,0x8(%rdi)
movss  0x8(%rsi),%xmm1
movss  0xc(%rsi),%xmm3
cvtss2sd %xmm1,%xmm1
movss  0x14(%rsi),%xmm4
cvtss2sd %xmm4,%xmm4
mulsd  %xmm1,%xmm4
xorps  %xmm1,%xmm1
cvtss2sd %xmm3,%xmm1
movss  0x10(%rsi),%xmm3
cvtss2sd %xmm3,%xmm3
mulsd  %xmm1,%xmm3
subsd  %xmm3,%xmm4
mulsd  %xmm0,%xmm4
xorps  %xmm1,%xmm1
cvtsd2ss %xmm4,%xmm1
movss  %xmm1,0x10(%rdi)
movss  0x4(%rsi),%xmm1
xorps  %xmm2,%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm0,%xmm1
cvtsd2ss %xmm1,%xmm1
movss  %xmm1,0x4(%rdi)
movss  (%rsi),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm0,%xmm1
cvtsd2ss %xmm1,%xmm1
movss  %xmm1,0xc(%rdi)
movss  (%rsi),%xmm1
movss  0x4(%rsi),%xmm2
cvtss2sd %xmm2,%xmm2
movss  0x10(%rsi),%xmm3
cvtss2sd %xmm3,%xmm3
mulsd  %xmm2,%xmm3
cvtss2sd %xmm1,%xmm1
movss  0x14(%rsi),%xmm2
cvtss2sd %xmm2,%xmm2
mulsd  %xmm1,%xmm2
subsd  %xmm2,%xmm3
mulsd  %xmm0,%xmm3
xorps  %xmm0,%xmm0
cvtsd2ss %xmm3,%xmm0
movss  %xmm0,0x14(%rdi)
ret

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

LLVM IR (-O2):
define void @nsvg__xformInverse(float* nocapture writeonly %0, float* nocapture %1) {
%3 = load float, float* %1
%4 = fpext float %3 to double
%5 = getelementptr inbounds float, float* %1, i64 3
%6 = load float, float* %5
%7 = fpext float %6 to double
%8 = getelementptr inbounds float, float* %1, i64 2
%9 = load float, float* %8
%10 = fpext float %9 to double
%11 = getelementptr inbounds float, float* %1, i64 1
%12 = load float, float* %11
%13 = fpext float %12 to double
%14 = fneg double %10
%15 = fmul double %14, %13
%16 = tail call double @llvm.fmuladd.f64(double %4, double %7, double %15)
%17 = fdiv double 1.000000e+00, %16
%18 = fmul double %17, %7
%19 = fptrunc double %18 to float
store float %19, float* %0
%20 = load float, float* %8
%21 = fneg float %20
%22 = fpext float %21 to double
%23 = fmul double %17, %22
%24 = fptrunc double %23 to float
%25 = getelementptr inbounds float, float* %0, i64 2
store float %24, float* %25
%26 = load float, float* %8
%27 = fpext float %26 to double
%28 = getelementptr inbounds float, float* %1, i64 5
%29 = load float, float* %28
%30 = fpext float %29 to double
%31 = load float, float* %5
%32 = fpext float %31 to double
%33 = getelementptr inbounds float, float* %1, i64 4
%34 = load float, float* %33
%35 = fpext float %34 to double
%36 = fneg double %32
%37 = fmul double %36, %35
%38 = tail call double @llvm.fmuladd.f64(double %27, double %30, double %37)
%39 = fmul double %17, %38
%40 = fptrunc double %39 to float
%41 = getelementptr inbounds float, float* %0, i64 4
store float %40, float* %41
%42 = load float, float* %11
%43 = fneg float %42
%44 = fpext float %43 to double
%45 = fmul double %17, %44
%46 = fptrunc double %45 to float
%47 = getelementptr inbounds float, float* %0, i64 1
store float %46, float* %47
%48 = load float, float* %1
%49 = fpext float %48 to double
%50 = fmul double %17, %49
%51 = fptrunc double %50 to float
%52 = getelementptr inbounds float, float* %0, i64 3
store float %51, float* %52
%53 = load float, float* %11
%54 = fpext float %53 to double
%55 = load float, float* %33
%56 = fpext float %55 to double
%57 = load float, float* %1
%58 = fpext float %57 to double
%59 = load float, float* %28
%60 = fpext float %59 to double
%61 = fneg double %58
%62 = fmul double %61, %60
%63 = tail call double @llvm.fmuladd.f64(double %54, double %56, double %62)
%64 = fmul double %17, %63
%65 = fptrunc double %64 to float
%66 = getelementptr inbounds float, float* %0, i64 5
store float %65, float* %66
ret void
}