#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 */
scalar_t__ fabsf(float);
int /*<<< orphan*/ mtxLoadIdentity(float *);
int /*<<< orphan*/ mtxTranspose(float *, float const *);
void mtxInvert(float *mtx, const float *src) {
  float tmp[16];
  float val, val2, val_inv, zero, one;
  int i, j, i4, i8, i12, ind;
  mtxTranspose(tmp, src);
  mtxLoadIdentity(mtx);
  for (i = 0; i != 4; i++) {
    val = tmp[(i << 2) + i];
    ind = i;
    i4 = i + 4;
    i8 = i + 8;
    i12 = i + 12;
    for (j = i + 1; j != 4; j++) {
      if (fabsf(tmp[(i << 2) + j]) > fabsf(val)) {
        ind = j;
        val = tmp[(i << 2) + j];
      }
    }
    if (ind != i) {
      val2 = mtx[i];
      mtx[i] = mtx[ind];
      mtx[ind] = val2;
      val2 = tmp[i];
      tmp[i] = tmp[ind];
      tmp[ind] = val2;
      ind += 4;
      val2 = mtx[i4];
      mtx[i4] = mtx[ind];
      mtx[ind] = val2;
      val2 = tmp[i4];
      tmp[i4] = tmp[ind];
      tmp[ind] = val2;
      ind += 4;
      val2 = mtx[i8];
      mtx[i8] = mtx[ind];
      mtx[ind] = val2;
      val2 = tmp[i8];
      tmp[i8] = tmp[ind];
      tmp[ind] = val2;
      ind += 4;
      val2 = mtx[i12];
      mtx[i12] = mtx[ind];
      mtx[ind] = val2;
      val2 = tmp[i12];
      tmp[i12] = tmp[ind];
      tmp[ind] = val2;
    }
    if (val == zero) {
      mtxLoadIdentity(mtx);
      return;
    }
    val_inv = one / val;
    tmp[i] *= val_inv;
    mtx[i] *= val_inv;
    tmp[i4] *= val_inv;
    mtx[i4] *= val_inv;
    tmp[i8] *= val_inv;
    mtx[i8] *= val_inv;
    tmp[i12] *= val_inv;
    mtx[i12] *= val_inv;
    if (i != 0) {
      val = tmp[i << 2];
      tmp[0] -= tmp[i] * val;
      mtx[0] -= mtx[i] * val;
      tmp[4] -= tmp[i4] * val;
      mtx[4] -= mtx[i4] * val;
      tmp[8] -= tmp[i8] * val;
      mtx[8] -= mtx[i8] * val;
      tmp[12] -= tmp[i12] * val;
      mtx[12] -= mtx[i12] * val;
    }
    if (i != 1) {
      val = tmp[(i << 2) + 1];
      tmp[1] -= tmp[i] * val;
      mtx[1] -= mtx[i] * val;
      tmp[5] -= tmp[i4] * val;
      mtx[5] -= mtx[i4] * val;
      tmp[9] -= tmp[i8] * val;
      mtx[9] -= mtx[i8] * val;
      tmp[13] -= tmp[i12] * val;
      mtx[13] -= mtx[i12] * val;
    }
    if (i != 2) {
      val = tmp[(i << 2) + 2];
      tmp[2] -= tmp[i] * val;
      mtx[2] -= mtx[i] * val;
      tmp[6] -= tmp[i4] * val;
      mtx[6] -= mtx[i4] * val;
      tmp[10] -= tmp[i8] * val;
      mtx[10] -= mtx[i8] * val;
      tmp[14] -= tmp[i12] * val;
      mtx[14] -= mtx[i12] * val;
    }
    if (i != 3) {
      val = tmp[(i << 2) + 3];
      tmp[3] -= tmp[i] * val;
      mtx[3] -= mtx[i] * val;
      tmp[7] -= tmp[i4] * val;
      mtx[7] -= mtx[i4] * val;
      tmp[11] -= tmp[i8] * val;
      mtx[11] -= mtx[i8] * val;
      tmp[15] -= tmp[i12] * val;
      mtx[15] -= mtx[i12] * val;
    }
  }
}


x86 assembly (clang, -O0):
<mtxInvert>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
lea    -0x50(%rbp),%rdi
mov    -0x10(%rbp),%rsi
call   1040 <mtxTranspose@plt>
mov    -0x8(%rbp),%rdi
call   1050 <mtxLoadIdentity@plt>
movl   $0x0,-0x68(%rbp)
cmpl   $0x4,-0x68(%rbp)
je     1bb4 <mtxInvert+0xa84>
mov    -0x68(%rbp),%eax
shl    $0x2,%eax
add    -0x68(%rbp),%eax
cltq
movss  -0x50(%rbp,%rax,4),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x68(%rbp),%eax
mov    %eax,-0x7c(%rbp)
mov    -0x68(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x70(%rbp)
mov    -0x68(%rbp),%eax
add    $0x8,%eax
mov    %eax,-0x74(%rbp)
mov    -0x68(%rbp),%eax
add    $0xc,%eax
mov    %eax,-0x78(%rbp)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
cmpl   $0x4,-0x6c(%rbp)
je     121d <mtxInvert+0xed>
mov    -0x68(%rbp),%eax
shl    $0x2,%eax
add    -0x6c(%rbp),%eax
cltq
movss  -0x50(%rbp,%rax,4),%xmm0
call   1030 <fabsf@plt>
mov    %rax,-0x88(%rbp)
movss  -0x54(%rbp),%xmm0
call   1030 <fabsf@plt>
mov    %rax,%rcx
mov    -0x88(%rbp),%rax
cmp    %rcx,%rax
jle    120a <mtxInvert+0xda>
mov    -0x6c(%rbp),%eax
mov    %eax,-0x7c(%rbp)
mov    -0x68(%rbp),%eax
shl    $0x2,%eax
add    -0x6c(%rbp),%eax
cltq
movss  -0x50(%rbp,%rax,4),%xmm0
movss  %xmm0,-0x54(%rbp)
jmp    120f <mtxInvert+0xdf>
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    11aa <mtxInvert+0x7a>
mov    -0x7c(%rbp),%eax
cmp    -0x68(%rbp),%eax
je     1404 <mtxInvert+0x2d4>
mov    -0x8(%rbp),%rax
movslq -0x68(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x7c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x68(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x58(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x7c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movslq -0x68(%rbp),%rax
movss  -0x50(%rbp,%rax,4),%xmm0
movss  %xmm0,-0x58(%rbp)
movslq -0x7c(%rbp),%rax
movss  -0x50(%rbp,%rax,4),%xmm0
movslq -0x68(%rbp),%rax
movss  %xmm0,-0x50(%rbp,%rax,4)
movss  -0x58(%rbp),%xmm0
movslq -0x7c(%rbp),%rax
movss  %xmm0,-0x50(%rbp,%rax,4)
mov    -0x7c(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x7c(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x70(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x7c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x70(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x58(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x7c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movslq -0x70(%rbp),%rax
movss  -0x50(%rbp,%rax,4),%xmm0
movss  %xmm0,-0x58(%rbp)
movslq -0x7c(%rbp),%rax
movss  -0x50(%rbp,%rax,4),%xmm0
movslq -0x70(%rbp),%rax
movss  %xmm0,-0x50(%rbp,%rax,4)
movss  -0x58(%rbp),%xmm0
movslq -0x7c(%rbp),%rax
movss  %xmm0,-0x50(%rbp,%rax,4)
mov    -0x7c(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x7c(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x74(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x7c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x74(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x58(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x7c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movslq -0x74(%rbp),%rax
movss  -0x50(%rbp,%rax,4),%xmm0
movss  %xmm0,-0x58(%rbp)
movslq -0x7c(%rbp),%rax
movss  -0x50(%rbp,%rax,4),%xmm0
movslq -0x74(%rbp),%rax
movss  %xmm0,-0x50(%rbp,%rax,4)
movss  -0x58(%rbp),%xmm0
movslq -0x7c(%rbp),%rax
movss  %xmm0,-0x50(%rbp,%rax,4)
mov    -0x7c(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x7c(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x78(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x7c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x78(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x58(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x7c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movslq -0x78(%rbp),%rax
movss  -0x50(%rbp,%rax,4),%xmm0
movss  %xmm0,-0x58(%rbp)
movslq -0x7c(%rbp),%rax
movss  -0x50(%rbp,%rax,4),%xmm0
movslq -0x78(%rbp),%rax
movss  %xmm0,-0x50(%rbp,%rax,4)
movss  -0x58(%rbp),%xmm0
movslq -0x7c(%rbp),%rax
movss  %xmm0,-0x50(%rbp,%rax,4)
movss  -0x54(%rbp),%xmm0
ucomiss -0x60(%rbp),%xmm0
jne    1427 <mtxInvert+0x2f7>
jp     1427 <mtxInvert+0x2f7>
mov    -0x8(%rbp),%rdi
call   1050 <mtxLoadIdentity@plt>
jmp    1bb4 <mtxInvert+0xa84>
movss  -0x64(%rbp),%xmm0
divss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x5c(%rbp),%xmm0
movslq -0x68(%rbp),%rax
mulss  -0x50(%rbp,%rax,4),%xmm0
movss  %xmm0,-0x50(%rbp,%rax,4)
movss  -0x5c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x68(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0x5c(%rbp),%xmm0
movslq -0x70(%rbp),%rax
mulss  -0x50(%rbp,%rax,4),%xmm0
movss  %xmm0,-0x50(%rbp,%rax,4)
movss  -0x5c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x70(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0x5c(%rbp),%xmm0
movslq -0x74(%rbp),%rax
mulss  -0x50(%rbp,%rax,4),%xmm0
movss  %xmm0,-0x50(%rbp,%rax,4)
movss  -0x5c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x74(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0x5c(%rbp),%xmm0
movslq -0x78(%rbp),%rax
mulss  -0x50(%rbp,%rax,4),%xmm0
movss  %xmm0,-0x50(%rbp,%rax,4)
movss  -0x5c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x78(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
cmpl   $0x0,-0x68(%rbp)
je     1691 <mtxInvert+0x561>
mov    -0x68(%rbp),%eax
shl    $0x2,%eax
cltq
movss  -0x50(%rbp,%rax,4),%xmm0
movss  %xmm0,-0x54(%rbp)
movslq -0x68(%rbp),%rax
movss  -0x50(%rbp,%rax,4),%xmm0
movss  -0x54(%rbp),%xmm2
movss  -0x50(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x68(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x54(%rbp),%xmm2
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm1
movd   %xmm0,%ecx
xor    $0x80000000,%ecx
movd   %ecx,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax)
movslq -0x70(%rbp),%rax
movss  -0x50(%rbp,%rax,4),%xmm0
movss  -0x54(%rbp),%xmm2
movss  -0x40(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x70(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x54(%rbp),%xmm2
mov    -0x8(%rbp),%rax
movss  0x10(%rax),%xmm1
movd   %xmm0,%ecx
xor    $0x80000000,%ecx
movd   %ecx,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,0x10(%rax)
movslq -0x74(%rbp),%rax
movss  -0x50(%rbp,%rax,4),%xmm0
movss  -0x54(%rbp),%xmm2
movss  -0x30(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x74(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x54(%rbp),%xmm2
mov    -0x8(%rbp),%rax
movss  0x20(%rax),%xmm1
movd   %xmm0,%ecx
xor    $0x80000000,%ecx
movd   %ecx,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,0x20(%rax)
movslq -0x78(%rbp),%rax
movss  -0x50(%rbp,%rax,4),%xmm0
movss  -0x54(%rbp),%xmm2
movss  -0x20(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x20(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x78(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x54(%rbp),%xmm2
mov    -0x8(%rbp),%rax
movss  0x30(%rax),%xmm1
movd   %xmm0,%ecx
xor    $0x80000000,%ecx
movd   %ecx,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,0x30(%rax)
cmpl   $0x1,-0x68(%rbp)
je     1841 <mtxInvert+0x711>
mov    -0x68(%rbp),%eax
shl    $0x2,%eax
add    $0x1,%eax
cltq
movss  -0x50(%rbp,%rax,4),%xmm0
movss  %xmm0,-0x54(%rbp)
movslq -0x68(%rbp),%rax
movss  -0x50(%rbp,%rax,4),%xmm0
movss  -0x54(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x68(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x54(%rbp),%xmm2
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm1
movd   %xmm0,%ecx
xor    $0x80000000,%ecx
movd   %ecx,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,0x4(%rax)
movslq -0x70(%rbp),%rax
movss  -0x50(%rbp,%rax,4),%xmm0
movss  -0x54(%rbp),%xmm2
movss  -0x3c(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x70(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x54(%rbp),%xmm2
mov    -0x8(%rbp),%rax
movss  0x14(%rax),%xmm1
movd   %xmm0,%ecx
xor    $0x80000000,%ecx
movd   %ecx,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,0x14(%rax)
movslq -0x74(%rbp),%rax
movss  -0x50(%rbp,%rax,4),%xmm0
movss  -0x54(%rbp),%xmm2
movss  -0x2c(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x74(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x54(%rbp),%xmm2
mov    -0x8(%rbp),%rax
movss  0x24(%rax),%xmm1
movd   %xmm0,%ecx
xor    $0x80000000,%ecx
movd   %ecx,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,0x24(%rax)
movslq -0x78(%rbp),%rax
movss  -0x50(%rbp,%rax,4),%xmm0
movss  -0x54(%rbp),%xmm2
movss  -0x1c(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x1c(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x78(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x54(%rbp),%xmm2
mov    -0x8(%rbp),%rax
movss  0x34(%rax),%xmm1
movd   %xmm0,%ecx
xor    $0x80000000,%ecx
movd   %ecx,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,0x34(%rax)
cmpl   $0x2,-0x68(%rbp)
je     19f1 <mtxInvert+0x8c1>
mov    -0x68(%rbp),%eax
shl    $0x2,%eax
add    $0x2,%eax
cltq
movss  -0x50(%rbp,%rax,4),%xmm0
movss  %xmm0,-0x54(%rbp)
movslq -0x68(%rbp),%rax
movss  -0x50(%rbp,%rax,4),%xmm0
movss  -0x54(%rbp),%xmm2
movss  -0x48(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x68(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x54(%rbp),%xmm2
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm1
movd   %xmm0,%ecx
xor    $0x80000000,%ecx
movd   %ecx,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,0x8(%rax)
movslq -0x70(%rbp),%rax
movss  -0x50(%rbp,%rax,4),%xmm0
movss  -0x54(%rbp),%xmm2
movss  -0x38(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x70(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x54(%rbp),%xmm2
mov    -0x8(%rbp),%rax
movss  0x18(%rax),%xmm1
movd   %xmm0,%ecx
xor    $0x80000000,%ecx
movd   %ecx,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,0x18(%rax)
movslq -0x74(%rbp),%rax
movss  -0x50(%rbp,%rax,4),%xmm0
movss  -0x54(%rbp),%xmm2
movss  -0x28(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x28(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x74(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x54(%rbp),%xmm2
mov    -0x8(%rbp),%rax
movss  0x28(%rax),%xmm1
movd   %xmm0,%ecx
xor    $0x80000000,%ecx
movd   %ecx,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,0x28(%rax)
movslq -0x78(%rbp),%rax
movss  -0x50(%rbp,%rax,4),%xmm0
movss  -0x54(%rbp),%xmm2
movss  -0x18(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x18(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x78(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x54(%rbp),%xmm2
mov    -0x8(%rbp),%rax
movss  0x38(%rax),%xmm1
movd   %xmm0,%ecx
xor    $0x80000000,%ecx
movd   %ecx,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,0x38(%rax)
cmpl   $0x3,-0x68(%rbp)
je     1ba1 <mtxInvert+0xa71>
mov    -0x68(%rbp),%eax
shl    $0x2,%eax
add    $0x3,%eax
cltq
movss  -0x50(%rbp,%rax,4),%xmm0
movss  %xmm0,-0x54(%rbp)
movslq -0x68(%rbp),%rax
movss  -0x50(%rbp,%rax,4),%xmm0
movss  -0x54(%rbp),%xmm2
movss  -0x44(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x68(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x54(%rbp),%xmm2
mov    -0x8(%rbp),%rax
movss  0xc(%rax),%xmm1
movd   %xmm0,%ecx
xor    $0x80000000,%ecx
movd   %ecx,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,0xc(%rax)
movslq -0x70(%rbp),%rax
movss  -0x50(%rbp,%rax,4),%xmm0
movss  -0x54(%rbp),%xmm2
movss  -0x34(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x70(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x54(%rbp),%xmm2
mov    -0x8(%rbp),%rax
movss  0x1c(%rax),%xmm1
movd   %xmm0,%ecx
xor    $0x80000000,%ecx
movd   %ecx,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,0x1c(%rax)
movslq -0x74(%rbp),%rax
movss  -0x50(%rbp,%rax,4),%xmm0
movss  -0x54(%rbp),%xmm2
movss  -0x24(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x24(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x74(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x54(%rbp),%xmm2
mov    -0x8(%rbp),%rax
movss  0x2c(%rax),%xmm1
movd   %xmm0,%ecx
xor    $0x80000000,%ecx
movd   %ecx,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,0x2c(%rax)
movslq -0x78(%rbp),%rax
movss  -0x50(%rbp,%rax,4),%xmm0
movss  -0x54(%rbp),%xmm2
movss  -0x14(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x14(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x78(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x54(%rbp),%xmm2
mov    -0x8(%rbp),%rax
movss  0x3c(%rax),%xmm1
movd   %xmm0,%ecx
xor    $0x80000000,%ecx
movd   %ecx,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,0x3c(%rax)
jmp    1ba6 <mtxInvert+0xa76>
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    1160 <mtxInvert+0x30>
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<mtxInvert>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x58,%rsp
mov    %rdi,%r15
mov    %rsp,%r14
mov    %r14,%rdi
call   1040 <mtxTranspose@plt>
mov    %r15,%rdi
call   1050 <mtxLoadIdentity@plt>
xor    %r12d,%r12d
jmp    1255 <mtxInvert+0x125>
nopl   0x0(%rax)
shl    $0x2,%rax
or     $0xc,%rax
movss  (%rsp,%rax,1),%xmm0
movss  0xc(%rsp),%xmm1
movss  (%rsp,%r12,4),%xmm2
mulss  %xmm0,%xmm2
subss  %xmm2,%xmm1
movss  %xmm1,0xc(%rsp)
movss  0xc(%r15),%xmm1
movss  (%r15,%r12,4),%xmm2
mulss  %xmm0,%xmm2
subss  %xmm2,%xmm1
movss  %xmm1,0xc(%r15)
movss  0x1c(%rsp),%xmm1
movss  0x10(%rsp,%r12,4),%xmm2
mulss  %xmm0,%xmm2
subss  %xmm2,%xmm1
movss  %xmm1,0x1c(%rsp)
movss  0x1c(%r15),%xmm1
movss  0x10(%r15,%r12,4),%xmm2
mulss  %xmm0,%xmm2
subss  %xmm2,%xmm1
movss  %xmm1,0x1c(%r15)
movss  0x2c(%rsp),%xmm1
movss  0x20(%rsp,%r12,4),%xmm2
mulss  %xmm0,%xmm2
subss  %xmm2,%xmm1
movss  %xmm1,0x2c(%rsp)
movss  0x2c(%r15),%xmm1
movss  0x20(%r15,%r12,4),%xmm2
mulss  %xmm0,%xmm2
subss  %xmm2,%xmm1
movss  %xmm1,0x2c(%r15)
movss  0x3c(%rsp),%xmm1
movss  0x30(%rsp,%r12,4),%xmm2
mulss  %xmm0,%xmm2
subss  %xmm2,%xmm1
movss  %xmm1,0x3c(%rsp)
movss  0x3c(%r15),%xmm1
mulss  0x30(%r15,%r12,4),%xmm0
subss  %xmm0,%xmm1
movss  %xmm1,0x3c(%r15)
add    $0x14,%r14
mov    0x50(%rsp),%rax
mov    %rax,%r12
cmp    $0x4,%rax
je     1626 <mtxInvert+0x4f6>
lea    0x1(%r12),%rax
mov    $0x3,%ebp
mov    %rax,0x50(%rsp)
cmp    $0x4,%rax
jne    15c0 <mtxInvert+0x490>
mov    %ebp,%eax
cmp    %rax,%r12
je     1331 <mtxInvert+0x201>
movss  (%r15,%r12,4),%xmm0
movslq %ebp,%rax
movss  (%r15,%rax,4),%xmm1
movss  %xmm1,(%r15,%r12,4)
movss  %xmm0,(%r15,%rax,4)
movss  (%rsp,%r12,4),%xmm0
movss  (%rsp,%rax,4),%xmm1
movss  %xmm1,(%rsp,%r12,4)
movss  %xmm0,(%rsp,%rax,4)
movss  0x10(%r15,%r12,4),%xmm0
movss  0x10(%r15,%rax,4),%xmm1
movss  %xmm1,0x10(%r15,%r12,4)
movss  %xmm0,0x10(%r15,%rax,4)
movss  0x10(%rsp,%r12,4),%xmm0
movss  0x10(%rsp,%rax,4),%xmm1
movss  %xmm1,0x10(%rsp,%r12,4)
movss  %xmm0,0x10(%rsp,%rax,4)
movss  0x20(%r15,%r12,4),%xmm0
movss  0x20(%r15,%rax,4),%xmm1
movss  %xmm1,0x20(%r15,%r12,4)
movss  %xmm0,0x20(%r15,%rax,4)
movss  0x20(%rsp,%r12,4),%xmm0
movss  0x20(%rsp,%rax,4),%xmm1
movss  %xmm1,0x20(%rsp,%r12,4)
movss  %xmm0,0x20(%rsp,%rax,4)
movss  0x30(%r15,%r12,4),%xmm0
movss  %xmm0,0x30(%r15,%rax,4)
movss  0x30(%rsp,%r12,4),%xmm0
movss  %xmm0,0x30(%rsp,%rax,4)
lea    0x0(,%r12,4),%rax
movl   $0x7fc00000,(%rsp,%r12,4)
7f
movl   $0x7fc00000,(%r15,%r12,4)
7f
movl   $0x7fc00000,0x10(%rsp,%r12,4)
c0 7f
movl   $0x7fc00000,0x10(%r15,%r12,4)
c0 7f
movl   $0x7fc00000,0x20(%rsp,%r12,4)
c0 7f
movl   $0x7fc00000,0x20(%r15,%r12,4)
c0 7f
movl   $0x7fc00000,0x30(%rsp,%r12,4)
c0 7f
movl   $0x7fc00000,0x30(%r15,%r12,4)
c0 7f
movss  0xc79(%rip),%xmm2
movaps %xmm2,%xmm1
test   %r12,%r12
je     13e3 <mtxInvert+0x2b3>
movl   $0xffc00000,(%rsp)
movl   $0xffc00000,(%r15)
movl   $0xffc00000,0x10(%rsp)
ff
movl   $0xffc00000,0x10(%r15)
ff
movl   $0xffc00000,0x20(%rsp)
ff
movl   $0xffc00000,0x20(%r15)
ff
movl   $0xffc00000,0x30(%rsp)
ff
movl   $0xffc00000,0x30(%r15)
ff
cmp    $0x1,%r12
je     14c4 <mtxInvert+0x394>
movss  (%rsp,%r12,4),%xmm2
movss  (%r15,%r12,4),%xmm1
lea    0x0(,%rax,4),%rcx
or     $0x4,%rcx
movss  (%rsp,%rcx,1),%xmm0
movss  0x4(%rsp),%xmm3
mulss  %xmm0,%xmm2
subss  %xmm2,%xmm3
movss  %xmm3,0x4(%rsp)
movss  0x4(%r15),%xmm2
mulss  %xmm0,%xmm1
subss  %xmm1,%xmm2
movss  %xmm2,0x4(%r15)
movss  0x14(%rsp),%xmm1
movss  0x10(%rsp,%r12,4),%xmm2
mulss  %xmm0,%xmm2
subss  %xmm2,%xmm1
movss  %xmm1,0x14(%rsp)
movss  0x14(%r15),%xmm1
movss  0x10(%r15,%r12,4),%xmm2
mulss  %xmm0,%xmm2
subss  %xmm2,%xmm1
movss  %xmm1,0x14(%r15)
movss  0x24(%rsp),%xmm1
movss  0x20(%rsp,%r12,4),%xmm2
mulss  %xmm0,%xmm2
subss  %xmm2,%xmm1
movss  %xmm1,0x24(%rsp)
movss  0x24(%r15),%xmm1
movss  0x20(%r15,%r12,4),%xmm2
mulss  %xmm0,%xmm2
subss  %xmm2,%xmm1
movss  %xmm1,0x24(%r15)
movss  0x34(%rsp),%xmm1
movss  0x30(%rsp,%r12,4),%xmm2
mulss  %xmm0,%xmm2
subss  %xmm2,%xmm1
movss  %xmm1,0x34(%rsp)
mulss  0x30(%r15,%r12,4),%xmm0
movss  0x34(%r15),%xmm1
subss  %xmm0,%xmm1
movss  %xmm1,0x34(%r15)
cmp    $0x2,%r12
je     1160 <mtxInvert+0x30>
lea    0x0(,%rax,4),%rcx
or     $0x8,%rcx
movss  (%rsp,%rcx,1),%xmm0
movss  0x8(%rsp),%xmm1
movss  (%rsp,%r12,4),%xmm2
mulss  %xmm0,%xmm2
subss  %xmm2,%xmm1
movss  %xmm1,0x8(%rsp)
movss  0x8(%r15),%xmm1
movss  (%r15,%r12,4),%xmm2
mulss  %xmm0,%xmm2
subss  %xmm2,%xmm1
movss  %xmm1,0x8(%r15)
movss  0x18(%rsp),%xmm1
movss  0x10(%rsp,%r12,4),%xmm2
mulss  %xmm0,%xmm2
subss  %xmm2,%xmm1
movss  %xmm1,0x18(%rsp)
movss  0x18(%r15),%xmm1
movss  0x10(%r15,%r12,4),%xmm2
mulss  %xmm0,%xmm2
subss  %xmm2,%xmm1
movss  %xmm1,0x18(%r15)
movss  0x28(%rsp),%xmm1
movss  0x20(%rsp,%r12,4),%xmm2
mulss  %xmm0,%xmm2
subss  %xmm2,%xmm1
movss  %xmm1,0x28(%rsp)
movss  0x28(%r15),%xmm1
movss  0x20(%r15,%r12,4),%xmm2
mulss  %xmm0,%xmm2
subss  %xmm2,%xmm1
movss  %xmm1,0x28(%r15)
movss  0x38(%rsp),%xmm1
movss  0x30(%rsp,%r12,4),%xmm2
mulss  %xmm0,%xmm2
subss  %xmm2,%xmm1
movss  %xmm1,0x38(%rsp)
mulss  0x30(%r15,%r12,4),%xmm0
movss  0x38(%r15),%xmm1
subss  %xmm0,%xmm1
movss  %xmm1,0x38(%r15)
cmp    $0x3,%r12
jne    1160 <mtxInvert+0x30>
jmp    123f <mtxInvert+0x10f>
cs nopw 0x0(%rax,%rax,1)
lea    (%r12,%r12,4),%rax
movss  (%rsp,%rax,4),%xmm0
movss  %xmm0,0x4c(%rsp)
mov    $0x1,%r13d
mov    %r12d,%ebp
jmp    15f6 <mtxInvert+0x4c6>
nopw   0x0(%rax,%rax,1)
lea    (%r12,%r13,1),%rax
add    $0x1,%rax
add    $0x1,%r13
cmp    $0x4,%rax
je     126e <mtxInvert+0x13e>
movss  (%r14,%r13,4),%xmm0
call   1030 <fabsf@plt>
mov    %rax,%rbx
movss  0x4c(%rsp),%xmm0
call   1030 <fabsf@plt>
cmp    %rax,%rbx
jle    15e0 <mtxInvert+0x4b0>
movss  (%r14,%r13,4),%xmm0
movss  %xmm0,0x4c(%rsp)
lea    (%r12,%r13,1),%ebp
jmp    15e0 <mtxInvert+0x4b0>
add    $0x58,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @mtxInvert(float* %0, float* %1) {
%3 = alloca [16 x float]
%4 = bitcast [16 x float]* %3 to i8*
%5 = getelementptr inbounds [16 x float], [16 x float]* %3, i64 0, i64 0
%6 = call i32 @mtxTranspose(float* %5, float* %1)
%7 = call i32 @mtxLoadIdentity(float* %0)
%8 = getelementptr inbounds [16 x float], [16 x float]* %3, i64 0, i64 4
%9 = getelementptr inbounds float, float* %0, i64 4
%10 = getelementptr inbounds [16 x float], [16 x float]* %3, i64 0, i64 8
%11 = getelementptr inbounds float, float* %0, i64 8
%12 = getelementptr inbounds [16 x float], [16 x float]* %3, i64 0, i64 12
%13 = getelementptr inbounds float, float* %0, i64 12
%14 = getelementptr inbounds [16 x float], [16 x float]* %3, i64 0, i64 1
%15 = getelementptr inbounds float, float* %0, i64 1
%16 = getelementptr inbounds [16 x float], [16 x float]* %3, i64 0, i64 5
%17 = getelementptr inbounds float, float* %0, i64 5
%18 = getelementptr inbounds [16 x float], [16 x float]* %3, i64 0, i64 9
%19 = getelementptr inbounds float, float* %0, i64 9
%20 = getelementptr inbounds [16 x float], [16 x float]* %3, i64 0, i64 13
%21 = getelementptr inbounds float, float* %0, i64 13
%22 = getelementptr inbounds [16 x float], [16 x float]* %3, i64 0, i64 2
%23 = getelementptr inbounds float, float* %0, i64 2
%24 = getelementptr inbounds [16 x float], [16 x float]* %3, i64 0, i64 6
%25 = getelementptr inbounds float, float* %0, i64 6
%26 = getelementptr inbounds [16 x float], [16 x float]* %3, i64 0, i64 10
%27 = getelementptr inbounds float, float* %0, i64 10
%28 = getelementptr inbounds [16 x float], [16 x float]* %3, i64 0, i64 14
%29 = getelementptr inbounds float, float* %0, i64 14
%30 = getelementptr inbounds [16 x float], [16 x float]* %3, i64 0, i64 3
%31 = getelementptr inbounds float, float* %0, i64 3
%32 = getelementptr inbounds [16 x float], [16 x float]* %3, i64 0, i64 7
%33 = getelementptr inbounds float, float* %0, i64 7
%34 = getelementptr inbounds [16 x float], [16 x float]* %3, i64 0, i64 11
%35 = getelementptr inbounds float, float* %0, i64 11
%36 = getelementptr inbounds [16 x float], [16 x float]* %3, i64 0, i64 15
%37 = getelementptr inbounds float, float* %0, i64 15
br label %38
38: ; preds = %2, %237
%39 = phi i64 [ 0, %2 ], [ %45, %237 ]
%40 = phi i64 [ 1, %2 ], [ %238, %237 ]
%41 = shl i64 %39, 2
%42 = add nuw nsw i64 %39, 4
%43 = add nuw nsw i64 %39, 8
%44 = add nuw nsw i64 %39, 12
%45 = add nuw nsw i64 %39, 1
%46 = icmp eq i64 %45, 4
br i1 %46, label %70, label %47
47: ; preds = %38
%48 = trunc i64 %39 to i32
%49 = mul nuw nsw i64 %39, 5
%50 = getelementptr inbounds [16 x float], [16 x float]* %3, i64 0, i64 %49
%51 = load float, float* %50
br label %52
52: ; preds = %47, %65
%53 = phi i64 [ %40, %47 ], [ %68, %65 ]
%54 = phi i32 [ %48, %47 ], [ %67, %65 ]
%55 = phi float [ %51, %47 ], [ %66, %65 ]
%56 = add nuw nsw i64 %53, %41
%57 = getelementptr inbounds [16 x float], [16 x float]* %3, i64 0, i64 %56
%58 = load float, float* %57
%59 = call i64 @fabsf(float %58)
%60 = call i64 @fabsf(float %55)
%61 = icmp sgt i64 %59, %60
br i1 %61, label %62, label %65
62: ; preds = %52
%63 = load float, float* %57
%64 = trunc i64 %53 to i32
br label %65
65: ; preds = %52, %62
%66 = phi float [ %63, %62 ], [ %55, %52 ]
%67 = phi i32 [ %64, %62 ], [ %54, %52 ]
%68 = add nuw nsw i64 %53, 1
%69 = icmp eq i64 %68, 4
br i1 %69, label %70, label %52
70: ; preds = %65, %38
%71 = phi i32 [ 3, %38 ], [ %67, %65 ]
%72 = zext i32 %71 to i64
%73 = icmp eq i64 %39, %72
br i1 %73, label %112, label %74
74: ; preds = %70
%75 = getelementptr inbounds float, float* %0, i64 %39
%76 = load float, float* %75
%77 = sext i32 %71 to i64
%78 = getelementptr inbounds float, float* %0, i64 %77
%79 = load float, float* %78
store float %79, float* %75
store float %76, float* %78
%80 = getelementptr inbounds [16 x float], [16 x float]* %3, i64 0, i64 %39
%81 = load float, float* %80
%82 = getelementptr inbounds [16 x float], [16 x float]* %3, i64 0, i64 %77
%83 = load float, float* %82
store float %83, float* %80
store float %81, float* %82
%84 = add nsw i32 %71, 4
%85 = getelementptr inbounds float, float* %0, i64 %42
%86 = load float, float* %85
%87 = sext i32 %84 to i64
%88 = getelementptr inbounds float, float* %0, i64 %87
%89 = load float, float* %88
store float %89, float* %85
store float %86, float* %88
%90 = getelementptr inbounds [16 x float], [16 x float]* %3, i64 0, i64 %42
%91 = load float, float* %90
%92 = getelementptr inbounds [16 x float], [16 x float]* %3, i64 0, i64 %87
%93 = load float, float* %92
store float %93, float* %90
store float %91, float* %92
%94 = add nsw i32 %71, 8
%95 = getelementptr inbounds float, float* %0, i64 %43
%96 = load float, float* %95
%97 = sext i32 %94 to i64
%98 = getelementptr inbounds float, float* %0, i64 %97
%99 = load float, float* %98
store float %99, float* %95
store float %96, float* %98
%100 = getelementptr inbounds [16 x float], [16 x float]* %3, i64 0, i64 %43
%101 = load float, float* %100
%102 = getelementptr inbounds [16 x float], [16 x float]* %3, i64 0, i64 %97
%103 = load float, float* %102
store float %103, float* %100
store float %101, float* %102
%104 = add nsw i32 %71, 12
%105 = getelementptr inbounds float, float* %0, i64 %44
%106 = load float, float* %105
%107 = sext i32 %104 to i64
%108 = getelementptr inbounds float, float* %0, i64 %107
store float %106, float* %108
%109 = getelementptr inbounds [16 x float], [16 x float]* %3, i64 0, i64 %44
%110 = load float, float* %109
%111 = getelementptr inbounds [16 x float], [16 x float]* %3, i64 0, i64 %107
store float %110, float* %111
br label %112
112: ; preds = %70, %74
%113 = getelementptr inbounds [16 x float], [16 x float]* %3, i64 0, i64 %39
store float 0x7FF8000000000000, float* %113
%114 = getelementptr inbounds float, float* %0, i64 %39
store float 0x7FF8000000000000, float* %114
%115 = getelementptr inbounds [16 x float], [16 x float]* %3, i64 0, i64 %42
store float 0x7FF8000000000000, float* %115
%116 = getelementptr inbounds float, float* %0, i64 %42
store float 0x7FF8000000000000, float* %116
%117 = getelementptr inbounds [16 x float], [16 x float]* %3, i64 0, i64 %43
store float 0x7FF8000000000000, float* %117
%118 = getelementptr inbounds float, float* %0, i64 %43
store float 0x7FF8000000000000, float* %118
%119 = getelementptr inbounds [16 x float], [16 x float]* %3, i64 0, i64 %44
store float 0x7FF8000000000000, float* %119
%120 = getelementptr inbounds float, float* %0, i64 %44
store float 0x7FF8000000000000, float* %120
%121 = icmp eq i64 %39, 0
br i1 %121, label %127, label %122
122: ; preds = %112
store float 0xFFF8000000000000, float* %5
store float 0xFFF8000000000000, float* %0
store float 0xFFF8000000000000, float* %8
store float 0xFFF8000000000000, float* %9
store float 0xFFF8000000000000, float* %10
store float 0xFFF8000000000000, float* %11
store float 0xFFF8000000000000, float* %12
store float 0xFFF8000000000000, float* %13
%123 = icmp eq i64 %39, 1
br i1 %123, label %164, label %124
124: ; preds = %122
%125 = load float, float* %113
%126 = load float, float* %114
br label %127
127: ; preds = %124, %112
%128 = phi float [ %126, %124 ], [ 0x7FF8000000000000, %112 ]
%129 = phi float [ %125, %124 ], [ 0x7FF8000000000000, %112 ]
%130 = or i64 %41, 1
%131 = getelementptr inbounds [16 x float], [16 x float]* %3, i64 0, i64 %130
%132 = load float, float* %131
%133 = load float, float* %14
%134 = fneg float %129
%135 = call float @llvm.fmuladd.f32(float %134, float %132, float %133)
store float %135, float* %14
%136 = load float, float* %15
%137 = fneg float %128
%138 = call float @llvm.fmuladd.f32(float %137, float %132, float %136)
store float %138, float* %15
%139 = load float, float* %115
%140 = load float, float* %16
%141 = fneg float %139
%142 = call float @llvm.fmuladd.f32(float %141, float %132, float %140)
store float %142, float* %16
%143 = load float, float* %116
%144 = load float, float* %17
%145 = fneg float %143
%146 = call float @llvm.fmuladd.f32(float %145, float %132, float %144)
store float %146, float* %17
%147 = load float, float* %117
%148 = load float, float* %18
%149 = fneg float %147
%150 = call float @llvm.fmuladd.f32(float %149, float %132, float %148)
store float %150, float* %18
%151 = load float, float* %118
%152 = load float, float* %19
%153 = fneg float %151
%154 = call float @llvm.fmuladd.f32(float %153, float %132, float %152)
store float %154, float* %19
%155 = load float, float* %119
%156 = load float, float* %20
%157 = fneg float %155
%158 = call float @llvm.fmuladd.f32(float %157, float %132, float %156)
store float %158, float* %20
%159 = load float, float* %120
%160 = load float, float* %21
%161 = fneg float %159
%162 = call float @llvm.fmuladd.f32(float %161, float %132, float %160)
store float %162, float* %21
%163 = icmp eq i64 %39, 2
br i1 %163, label %201, label %164
164: ; preds = %127, %122
%165 = or i64 %41, 2
%166 = getelementptr inbounds [16 x float], [16 x float]* %3, i64 0, i64 %165
%167 = load float, float* %166
%168 = load float, float* %113
%169 = load float, float* %22
%170 = fneg float %168
%171 = call float @llvm.fmuladd.f32(float %170, float %167, float %169)
store float %171, float* %22
%172 = load float, float* %114
%173 = load float, float* %23
%174 = fneg float %172
%175 = call float @llvm.fmuladd.f32(float %174, float %167, float %173)
store float %175, float* %23
%176 = load float, float* %115
%177 = load float, float* %24
%178 = fneg float %176
%179 = call float @llvm.fmuladd.f32(float %178, float %167, float %177)
store float %179, float* %24
%180 = load float, float* %116
%181 = load float, float* %25
%182 = fneg float %180
%183 = call float @llvm.fmuladd.f32(float %182, float %167, float %181)
store float %183, float* %25
%184 = load float, float* %117
%185 = load float, float* %26
%186 = fneg float %184
%187 = call float @llvm.fmuladd.f32(float %186, float %167, float %185)
store float %187, float* %26
%188 = load float, float* %118
%189 = load float, float* %27
%190 = fneg float %188
%191 = call float @llvm.fmuladd.f32(float %190, float %167, float %189)
store float %191, float* %27
%192 = load float, float* %119
%193 = load float, float* %28
%194 = fneg float %192
%195 = call float @llvm.fmuladd.f32(float %194, float %167, float %193)
store float %195, float* %28
%196 = load float, float* %120
%197 = load float, float* %29
%198 = fneg float %196
%199 = call float @llvm.fmuladd.f32(float %198, float %167, float %197)
store float %199, float* %29
%200 = icmp eq i64 %39, 3
br i1 %200, label %237, label %201
201: ; preds = %127, %164
%202 = or i64 %41, 3
%203 = getelementptr inbounds [16 x float], [16 x float]* %3, i64 0, i64 %202
%204 = load float, float* %203
%205 = load float, float* %113
%206 = load float, float* %30
%207 = fneg float %205
%208 = call float @llvm.fmuladd.f32(float %207, float %204, float %206)
store float %208, float* %30
%209 = load float, float* %114
%210 = load float, float* %31
%211 = fneg float %209
%212 = call float @llvm.fmuladd.f32(float %211, float %204, float %210)
store float %212, float* %31
%213 = load float, float* %115
%214 = load float, float* %32
%215 = fneg float %213
%216 = call float @llvm.fmuladd.f32(float %215, float %204, float %214)
store float %216, float* %32
%217 = load float, float* %116
%218 = load float, float* %33
%219 = fneg float %217
%220 = call float @llvm.fmuladd.f32(float %219, float %204, float %218)
store float %220, float* %33
%221 = load float, float* %117
%222 = load float, float* %34
%223 = fneg float %221
%224 = call float @llvm.fmuladd.f32(float %223, float %204, float %222)
store float %224, float* %34
%225 = load float, float* %118
%226 = load float, float* %35
%227 = fneg float %225
%228 = call float @llvm.fmuladd.f32(float %227, float %204, float %226)
store float %228, float* %35
%229 = load float, float* %119
%230 = load float, float* %36
%231 = fneg float %229
%232 = call float @llvm.fmuladd.f32(float %231, float %204, float %230)
store float %232, float* %36
%233 = load float, float* %120
%234 = load float, float* %37
%235 = fneg float %233
%236 = call float @llvm.fmuladd.f32(float %235, float %204, float %234)
store float %236, float* %37
br label %237
237: ; preds = %164, %201
%238 = add nuw nsw i64 %40, 1
br i1 %46, label %239, label %38
239: ; preds = %237
ret void
}