#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 */
typedef size_t int8_t;

/* Variables and functions */
float fabsf(float);
int /*<<< orphan*/ fmatrixAeqI(float **, size_t);
void fmatrixAeqInvA(float *A[], int8_t iColInd[], int8_t iRowInd[],
                    int8_t iPivot[], int8_t isize) {
  float largest;
  float scaling;
  float recippiv;
  float ftmp;
  int8_t i, j, k, l, m;
  int8_t iPivotRow, iPivotCol;
  iPivotRow = iPivotCol = 0;
  for (j = 0; j < isize; j++) {
    iPivot[j] = 0;
  }
  for (i = 0; i < isize; i++) {
    largest = 0.0F;
    for (j = 0; j < isize; j++) {
      if (iPivot[j] != 1) {
        for (k = 0; k < isize; k++) {
          if (iPivot[k] == 0) {
            if (fabsf(A[j][k]) >= largest) {
              iPivotRow = j;
              iPivotCol = k;
              largest = (float)fabsf(A[iPivotRow][iPivotCol]);
            }
          } else if (iPivot[k] > 1) {
            fmatrixAeqI(A, isize);
            return;
          }
        }
      }
    }
    iPivot[iPivotCol]++;
    if (iPivotRow != iPivotCol) {
      for (l = 0; l < isize; l++) {
        ftmp = A[iPivotRow][l];
        A[iPivotRow][l] = A[iPivotCol][l];
        A[iPivotCol][l] = ftmp;
      }
    }
    iRowInd[i] = iPivotRow;
    iColInd[i] = iPivotCol;
    if (A[iPivotCol][iPivotCol] == 0.0F) {
      fmatrixAeqI(A, isize);
      return;
    }
    recippiv = 1.0F / A[iPivotCol][iPivotCol];
    A[iPivotCol][iPivotCol] = 1.0F;
    for (l = 0; l < isize; l++) {
      A[iPivotCol][l] *= recippiv;
    }
    for (m = 0; m < isize; m++) {
      if (m != iPivotCol) {
        scaling = A[m][iPivotCol];
        A[m][iPivotCol] = 0.0F;
        for (l = 0; l < isize; l++) {
          A[m][l] -= A[iPivotCol][l] * scaling;
        }
      }
    }
  }
  for (l = isize - 1; l >= 0; l--) {
    i = iRowInd[l];
    j = iColInd[l];
    if (i != j) {
      for (k = 0; k < isize; k++) {
        ftmp = A[k][i];
        A[k][i] = A[k][j];
        A[k][j] = ftmp;
      }
    }
  }
}


x86 assembly (clang, -O0):
<fmatrixAeqInvA>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
movq   $0x0,-0x70(%rbp)
movq   $0x0,-0x68(%rbp)
movq   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%rax
cmp    -0x28(%rbp),%rax
jae    1173 <fmatrixAeqInvA+0x63>
mov    -0x20(%rbp),%rax
mov    -0x48(%rbp),%rcx
movq   $0x0,(%rax,%rcx,8)
mov    -0x48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x48(%rbp)
jmp    1144 <fmatrixAeqInvA+0x34>
movq   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%rax
cmp    -0x28(%rbp),%rax
jae    1524 <fmatrixAeqInvA+0x414>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x2c(%rbp)
movq   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%rax
cmp    -0x28(%rbp),%rax
jae    12a2 <fmatrixAeqInvA+0x192>
mov    -0x20(%rbp),%rax
mov    -0x48(%rbp),%rcx
cmpq   $0x1,(%rax,%rcx,8)
je     128c <fmatrixAeqInvA+0x17c>
movq   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%rax
cmp    -0x28(%rbp),%rax
jae    1287 <fmatrixAeqInvA+0x177>
mov    -0x20(%rbp),%rax
mov    -0x50(%rbp),%rcx
cmpq   $0x0,(%rax,%rcx,8)
jne    1247 <fmatrixAeqInvA+0x137>
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movaps 0xe11(%rip),%xmm1
pand   %xmm1,%xmm0
ucomiss -0x2c(%rbp),%xmm0
jb     1242 <fmatrixAeqInvA+0x132>
mov    -0x48(%rbp),%rax
mov    %rax,-0x68(%rbp)
mov    -0x50(%rbp),%rax
mov    %rax,-0x70(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x68(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x70(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movaps 0xdd7(%rip),%xmm1
pand   %xmm1,%xmm0
movss  %xmm0,-0x2c(%rbp)
jmp    1271 <fmatrixAeqInvA+0x161>
mov    -0x20(%rbp),%rax
mov    -0x50(%rbp),%rcx
cmpq   $0x1,(%rax,%rcx,8)
jbe    126c <fmatrixAeqInvA+0x15c>
mov    -0x8(%rbp),%rdi
mov    -0x28(%rbp),%rsi
call   1030 <fmatrixAeqI@plt>
jmp    1609 <fmatrixAeqInvA+0x4f9>
jmp    1271 <fmatrixAeqInvA+0x161>
jmp    1276 <fmatrixAeqInvA+0x166>
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
jmp    11c2 <fmatrixAeqInvA+0xb2>
jmp    128c <fmatrixAeqInvA+0x17c>
jmp    1291 <fmatrixAeqInvA+0x181>
mov    -0x48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x48(%rbp)
jmp    1199 <fmatrixAeqInvA+0x89>
mov    -0x20(%rbp),%rax
mov    -0x70(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
add    $0x1,%rdx
mov    %rdx,(%rax,%rcx,8)
mov    -0x68(%rbp),%rax
cmp    -0x70(%rbp),%rax
je     134e <fmatrixAeqInvA+0x23e>
movq   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%rax
cmp    -0x28(%rbp),%rax
jae    1349 <fmatrixAeqInvA+0x239>
mov    -0x8(%rbp),%rax
mov    -0x68(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x70(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x68(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x58(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x38(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x70(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x58(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
jmp    12cc <fmatrixAeqInvA+0x1bc>
jmp    134e <fmatrixAeqInvA+0x23e>
mov    -0x68(%rbp),%rdx
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x70(%rbp),%rdx
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x70(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x70(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    13a7 <fmatrixAeqInvA+0x297>
jp     13a7 <fmatrixAeqInvA+0x297>
mov    -0x8(%rbp),%rdi
mov    -0x28(%rbp),%rsi
call   1030 <fmatrixAeqI@plt>
jmp    1609 <fmatrixAeqInvA+0x4f9>
mov    -0x8(%rbp),%rax
mov    -0x70(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x70(%rbp),%rcx
movss  0xc41(%rip),%xmm0
divss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x70(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x70(%rbp),%rcx
movss  0xc1f(%rip),%xmm0
movss  %xmm0,(%rax,%rcx,4)
movq   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%rax
cmp    -0x28(%rbp),%rax
jae    142c <fmatrixAeqInvA+0x31c>
movss  -0x34(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x70(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x58(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
jmp    13ee <fmatrixAeqInvA+0x2de>
movq   $0x0,-0x60(%rbp)
mov    -0x60(%rbp),%rax
cmp    -0x28(%rbp),%rax
jae    150e <fmatrixAeqInvA+0x3fe>
mov    -0x60(%rbp),%rax
cmp    -0x70(%rbp),%rax
je     14f8 <fmatrixAeqInvA+0x3e8>
mov    -0x8(%rbp),%rax
mov    -0x60(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x70(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x60(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x70(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movq   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%rax
cmp    -0x28(%rbp),%rax
jae    14f3 <fmatrixAeqInvA+0x3e3>
mov    -0x8(%rbp),%rax
mov    -0x70(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x30(%rbp),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x60(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movd   %xmm0,%edx
xor    $0x80000000,%edx
movd   %edx,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
jmp    148a <fmatrixAeqInvA+0x37a>
jmp    14f8 <fmatrixAeqInvA+0x3e8>
jmp    14fd <fmatrixAeqInvA+0x3ed>
mov    -0x60(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x60(%rbp)
jmp    1434 <fmatrixAeqInvA+0x324>
jmp    1513 <fmatrixAeqInvA+0x403>
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    117b <fmatrixAeqInvA+0x6b>
mov    -0x28(%rbp),%rax
sub    $0x1,%rax
mov    %rax,-0x58(%rbp)
cmpq   $0x0,-0x58(%rbp)
jb     1609 <fmatrixAeqInvA+0x4f9>
mov    -0x18(%rbp),%rax
mov    -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x40(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x48(%rbp)
mov    -0x40(%rbp),%rax
cmp    -0x48(%rbp),%rax
je     15f3 <fmatrixAeqInvA+0x4e3>
movq   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%rax
cmp    -0x28(%rbp),%rax
jae    15ee <fmatrixAeqInvA+0x4de>
mov    -0x8(%rbp),%rax
mov    -0x50(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x50(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x50(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x38(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x50(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x48(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
jmp    1571 <fmatrixAeqInvA+0x461>
jmp    15f3 <fmatrixAeqInvA+0x4e3>
jmp    15f8 <fmatrixAeqInvA+0x4e8>
mov    -0x58(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x58(%rbp)
jmp    1530 <fmatrixAeqInvA+0x420>
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<fmatrixAeqInvA>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x38,%rsp
mov    %r8,%r14
mov    %rdx,%r15
mov    %rsi,%r12
mov    %rdi,%rbx
test   %r8,%r8
je     15fb <fmatrixAeqInvA+0x4db>
mov    %rcx,%r13
lea    0x0(,%r14,8),%rdx
xor    %ebp,%ebp
mov    %rcx,%rdi
xor    %esi,%esi
call   1030 <memset@plt>
lea    -0x8(%r14),%r10
mov    %r10,0x18(%rsp)
shr    $0x3,%r10
add    $0x1,%r10
mov    %r14,%r9
and    $0xfffffffffffffff8,%r9
mov    %r10,%r11
and    $0xfffffffffffffffe,%r11
mov    %r14,%rdi
neg    %rdi
xorps  %xmm8,%xmm8
movss  0xe84(%rip),%xmm9
movaps 0xe6d(%rip),%xmm2
xor    %eax,%eax
xor    %r8d,%r8d
xor    %edx,%edx
xorps  %xmm3,%xmm3
jmp    11a9 <fmatrixAeqInvA+0x89>
nop
add    $0x1,%rdx
cmp    %r14,%rdx
je     11f9 <fmatrixAeqInvA+0xd9>
cmpq   $0x1,0x0(%r13,%rdx,8)
je     11a0 <fmatrixAeqInvA+0x80>
xor    %esi,%esi
jmp    11c9 <fmatrixAeqInvA+0xa9>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%rsi
cmp    %rsi,%r14
je     11a0 <fmatrixAeqInvA+0x80>
mov    0x0(%r13,%rsi,8),%rcx
cmp    $0x1,%rcx
je     11c0 <fmatrixAeqInvA+0xa0>
test   %rcx,%rcx
jne    1695 <fmatrixAeqInvA+0x575>
mov    (%rbx,%rdx,8),%rcx
movss  (%rcx,%rsi,4),%xmm4
andps  %xmm2,%xmm4
ucomiss %xmm3,%xmm4
jb     11c0 <fmatrixAeqInvA+0xa0>
movaps %xmm4,%xmm3
mov    %rdx,%rax
mov    %rsi,%rbp
jmp    11c0 <fmatrixAeqInvA+0xa0>
addq   $0x1,0x0(%r13,%rbp,8)
mov    (%rbx,%rax,8),%rsi
cmp    %rbp,%rax
mov    %r11,0x8(%rsp)
mov    %r8,0x10(%rsp)
je     135c <fmatrixAeqInvA+0x23c>
mov    %rdi,%r8
mov    (%rbx,%rbp,8),%rdx
cmp    $0x8,%r14
jb     1235 <fmatrixAeqInvA+0x115>
lea    (%rdx,%r14,4),%rcx
cmp    %rcx,%rsi
jae    12aa <fmatrixAeqInvA+0x18a>
lea    (%rsi,%r14,4),%rcx
cmp    %rcx,%rdx
jae    12aa <fmatrixAeqInvA+0x18a>
xor    %edi,%edi
mov    %rdi,%rcx
test   $0x1,%r14b
je     125b <fmatrixAeqInvA+0x13b>
movss  (%rsi,%rdi,4),%xmm3
movss  (%rdx,%rdi,4),%xmm4
movss  %xmm4,(%rsi,%rdi,4)
movss  %xmm3,(%rdx,%rdi,4)
mov    %rdi,%rcx
or     $0x1,%rcx
not    %rdi
cmp    %r8,%rdi
je     134c <fmatrixAeqInvA+0x22c>
nopw   0x0(%rax,%rax,1)
movss  (%rsi,%rcx,4),%xmm3
movss  (%rdx,%rcx,4),%xmm4
movss  %xmm4,(%rsi,%rcx,4)
movss  %xmm3,(%rdx,%rcx,4)
movss  0x4(%rsi,%rcx,4),%xmm3
movss  0x4(%rdx,%rcx,4),%xmm4
movss  %xmm4,0x4(%rsi,%rcx,4)
movss  %xmm3,0x4(%rdx,%rcx,4)
add    $0x2,%rcx
cmp    %rcx,%r14
jne    1270 <fmatrixAeqInvA+0x150>
jmp    134c <fmatrixAeqInvA+0x22c>
mov    0x18(%rsp),%rcx
cmp    $0x8,%rcx
jae    12b9 <fmatrixAeqInvA+0x199>
xor    %edi,%edi
jmp    1316 <fmatrixAeqInvA+0x1f6>
mov    0x8(%rsp),%rcx
xor    %edi,%edi
movups (%rsi,%rdi,4),%xmm3
movups 0x10(%rsi,%rdi,4),%xmm4
movups (%rdx,%rdi,4),%xmm5
movups 0x10(%rdx,%rdi,4),%xmm6
movups %xmm5,(%rsi,%rdi,4)
movups %xmm6,0x10(%rsi,%rdi,4)
movups %xmm3,(%rdx,%rdi,4)
movups %xmm4,0x10(%rdx,%rdi,4)
movups 0x20(%rsi,%rdi,4),%xmm3
movups 0x30(%rsi,%rdi,4),%xmm4
movups 0x20(%rdx,%rdi,4),%xmm5
movups 0x30(%rdx,%rdi,4),%xmm6
movups %xmm5,0x20(%rsi,%rdi,4)
movups %xmm6,0x30(%rsi,%rdi,4)
movups %xmm3,0x20(%rdx,%rdi,4)
movups %xmm4,0x30(%rdx,%rdi,4)
add    $0x10,%rdi
add    $0xfffffffffffffffe,%rcx
jne    12c0 <fmatrixAeqInvA+0x1a0>
test   $0x1,%r10b
je     1340 <fmatrixAeqInvA+0x220>
movups (%rsi,%rdi,4),%xmm3
movups 0x10(%rsi,%rdi,4),%xmm4
movups (%rdx,%rdi,4),%xmm5
movups 0x10(%rdx,%rdi,4),%xmm6
movups %xmm5,(%rsi,%rdi,4)
movups %xmm6,0x10(%rsi,%rdi,4)
movups %xmm3,(%rdx,%rdi,4)
movups %xmm4,0x10(%rdx,%rdi,4)
mov    %r9,%rdi
cmp    %r14,%r9
jne    1237 <fmatrixAeqInvA+0x117>
mov    %rdx,%rsi
mov    0x8(%rsp),%r11
mov    %r8,%rdi
mov    0x10(%rsp),%r8
mov    %rax,(%r15,%r8,8)
mov    %rbp,(%r12,%r8,8)
movss  (%rsi,%rbp,4),%xmm4
ucomiss %xmm8,%xmm4
jne    1375 <fmatrixAeqInvA+0x255>
jnp    1695 <fmatrixAeqInvA+0x575>
movaps %xmm9,%xmm3
divss  %xmm4,%xmm3
movl   $0x3f800000,(%rsi,%rbp,4)
cmp    $0x8,%r14
mov    %r9,0x20(%rsp)
jae    1396 <fmatrixAeqInvA+0x276>
xor    %ecx,%ecx
jmp    1420 <fmatrixAeqInvA+0x300>
movaps %xmm3,%xmm4
shufps $0x0,%xmm3,%xmm4
cmpq   $0x8,0x18(%rsp)
jae    13a9 <fmatrixAeqInvA+0x289>
xor    %edx,%edx
jmp    13ec <fmatrixAeqInvA+0x2cc>
mov    %r11,%rcx
xor    %edx,%edx
xchg   %ax,%ax
movups (%rsi,%rdx,4),%xmm5
movups 0x10(%rsi,%rdx,4),%xmm6
movups 0x20(%rsi,%rdx,4),%xmm7
movups 0x30(%rsi,%rdx,4),%xmm0
mulps  %xmm4,%xmm5
mulps  %xmm4,%xmm6
movups %xmm5,(%rsi,%rdx,4)
movups %xmm6,0x10(%rsi,%rdx,4)
mulps  %xmm4,%xmm7
mulps  %xmm4,%xmm0
movups %xmm7,0x20(%rsi,%rdx,4)
movups %xmm0,0x30(%rsi,%rdx,4)
add    $0x10,%rdx
add    $0xfffffffffffffffe,%rcx
jne    13b0 <fmatrixAeqInvA+0x290>
test   $0x1,%r10b
je     140a <fmatrixAeqInvA+0x2ea>
movups (%rsi,%rdx,4),%xmm0
movups 0x10(%rsi,%rdx,4),%xmm5
mulps  %xmm4,%xmm0
mulps  %xmm4,%xmm5
movups %xmm0,(%rsi,%rdx,4)
movups %xmm5,0x10(%rsi,%rdx,4)
mov    %r9,%rcx
cmp    %r14,%r9
je     1437 <fmatrixAeqInvA+0x317>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movss  (%rsi,%rcx,4),%xmm0
mulss  %xmm3,%xmm0
movss  %xmm0,(%rsi,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%r14
jne    1420 <fmatrixAeqInvA+0x300>
lea    (%rsi,%r14,4),%rcx
mov    %rcx,0x30(%rsp)
xor    %r8d,%r8d
mov    0x18(%rsp),%r11
mov    %rdi,0x28(%rsp)
jmp    145d <fmatrixAeqInvA+0x33d>
nop
add    $0x1,%r8
cmp    %r14,%r8
je     15df <fmatrixAeqInvA+0x4bf>
cmp    %rbp,%r8
je     1450 <fmatrixAeqInvA+0x330>
mov    (%rbx,%r8,8),%r9
movss  (%r9,%rbp,4),%xmm3
movl   $0x0,(%r9,%rbp,4)
cmp    $0x8,%r14
jb     1492 <fmatrixAeqInvA+0x372>
cmp    0x30(%rsp),%r9
jae    1513 <fmatrixAeqInvA+0x3f3>
lea    (%r9,%r14,4),%rcx
cmp    %rcx,%rsi
jae    1513 <fmatrixAeqInvA+0x3f3>
xor    %ecx,%ecx
mov    %rcx,%rdx
test   $0x1,%r14b
je     14bd <fmatrixAeqInvA+0x39d>
movss  (%r9,%rcx,4),%xmm0
movss  (%rsi,%rcx,4),%xmm1
mulss  %xmm3,%xmm1
subss  %xmm1,%xmm0
movss  %xmm0,(%r9,%rcx,4)
mov    %rcx,%rdx
or     $0x1,%rdx
not    %rcx
cmp    %rdi,%rcx
je     1450 <fmatrixAeqInvA+0x330>
cs nopw 0x0(%rax,%rax,1)
nop
movss  (%rsi,%rdx,4),%xmm0
mulss  %xmm3,%xmm0
movss  (%r9,%rdx,4),%xmm1
subss  %xmm0,%xmm1
movss  0x4(%r9,%rdx,4),%xmm0
movss  %xmm1,(%r9,%rdx,4)
movss  0x4(%rsi,%rdx,4),%xmm1
mulss  %xmm3,%xmm1
subss  %xmm1,%xmm0
movss  %xmm0,0x4(%r9,%rdx,4)
add    $0x2,%rdx
cmp    %rdx,%r14
jne    14d0 <fmatrixAeqInvA+0x3b0>
jmp    1450 <fmatrixAeqInvA+0x330>
movaps %xmm3,%xmm4
shufps $0x0,%xmm3,%xmm4
mov    %r11,%rcx
cmp    $0x8,%r11
jae    1527 <fmatrixAeqInvA+0x407>
xor    %edx,%edx
jmp    1593 <fmatrixAeqInvA+0x473>
mov    0x8(%rsp),%rdi
xor    %edx,%edx
xchg   %ax,%ax
movups (%rsi,%rdx,4),%xmm0
movups 0x10(%rsi,%rdx,4),%xmm5
mulps  %xmm4,%xmm0
movups (%r9,%rdx,4),%xmm6
subps  %xmm0,%xmm6
movups 0x10(%r9,%rdx,4),%xmm0
movups 0x20(%r9,%rdx,4),%xmm7
movups 0x30(%r9,%rdx,4),%xmm1
mulps  %xmm4,%xmm5
subps  %xmm5,%xmm0
movups %xmm6,(%r9,%rdx,4)
movups %xmm0,0x10(%r9,%rdx,4)
movups 0x20(%rsi,%rdx,4),%xmm0
movups 0x30(%rsi,%rdx,4),%xmm5
mulps  %xmm4,%xmm0
subps  %xmm0,%xmm7
mulps  %xmm4,%xmm5
subps  %xmm5,%xmm1
movups %xmm7,0x20(%r9,%rdx,4)
movups %xmm1,0x30(%r9,%rdx,4)
add    $0x10,%rdx
add    $0xfffffffffffffffe,%rdi
jne    1530 <fmatrixAeqInvA+0x410>
test   $0x1,%r10b
je     15c4 <fmatrixAeqInvA+0x4a4>
movups (%rsi,%rdx,4),%xmm0
movups 0x10(%rsi,%rdx,4),%xmm1
movups (%r9,%rdx,4),%xmm5
movups 0x10(%r9,%rdx,4),%xmm6
mulps  %xmm4,%xmm0
subps  %xmm0,%xmm5
mulps  %xmm4,%xmm1
subps  %xmm1,%xmm6
movups %xmm5,(%r9,%rdx,4)
movups %xmm6,0x10(%r9,%rdx,4)
mov    0x20(%rsp),%rdx
mov    %rdx,%rcx
cmp    %r14,%rdx
mov    0x28(%rsp),%rdi
je     1450 <fmatrixAeqInvA+0x330>
jmp    1494 <fmatrixAeqInvA+0x374>
mov    0x10(%rsp),%r8
add    $0x1,%r8
cmp    %r14,%r8
mov    0x20(%rsp),%r9
mov    0x8(%rsp),%r11
jne    1198 <fmatrixAeqInvA+0x78>
mov    %r14,%rax
and    $0xfffffffffffffffe,%rax
mov    %r14,%rcx
cs nopw 0x0(%rax,%rax,1)
nop
mov    -0x8(%r15,%rcx,8),%rdx
mov    -0x8(%r12,%rcx,8),%rsi
add    $0xffffffffffffffff,%rcx
cmp    %rsi,%rdx
je     1610 <fmatrixAeqInvA+0x4f0>
test   %r14,%r14
je     1610 <fmatrixAeqInvA+0x4f0>
xor    %edi,%edi
cmp    $0x1,%r14
je     1672 <fmatrixAeqInvA+0x552>
mov    (%rbx,%rdi,8),%rbp
movss  0x0(%rbp,%rdx,4),%xmm0
movss  0x0(%rbp,%rsi,4),%xmm1
movss  %xmm1,0x0(%rbp,%rdx,4)
movss  %xmm0,0x0(%rbp,%rsi,4)
mov    0x8(%rbx,%rdi,8),%rbp
movss  0x0(%rbp,%rdx,4),%xmm0
movss  0x0(%rbp,%rsi,4),%xmm1
movss  %xmm1,0x0(%rbp,%rdx,4)
movss  %xmm0,0x0(%rbp,%rsi,4)
add    $0x2,%rdi
cmp    %rdi,%rax
jne    1630 <fmatrixAeqInvA+0x510>
test   $0x1,%r14b
je     1610 <fmatrixAeqInvA+0x4f0>
mov    (%rbx,%rdi,8),%rdi
movss  (%rdi,%rdx,4),%xmm0
movss  (%rdi,%rsi,4),%xmm1
movss  %xmm1,(%rdi,%rdx,4)
movss  %xmm0,(%rdi,%rsi,4)
jmp    1610 <fmatrixAeqInvA+0x4f0>
mov    %rbx,%rdi
mov    %r14,%rsi
add    $0x38,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1040 <fmatrixAeqI@plt>

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

LLVM IR (-O2):
define void @fmatrixAeqInvA(float** %0, i64* nocapture %1, i64* nocapture %2, i64* nocapture %3, i64 %4) {
%6 = icmp eq i64 %4, 0
br i1 %6, label %371, label %7
7: ; preds = %5
%8 = bitcast i64* %3 to i8*
%9 = shl nuw i64 %4, 3
%10 = add i64 %4, -8
%11 = lshr i64 %10, 3
%12 = add nuw nsw i64 %11, 1
%13 = icmp ult i64 %4, 8
%14 = and i64 %4, -8
%15 = and i64 %12, 1
%16 = icmp ult i64 %10, 8
%17 = and i64 %12, 4611686018427387902
%18 = icmp eq i64 %15, 0
%19 = icmp eq i64 %14, %4
%20 = and i64 %4, 1
%21 = icmp eq i64 %20, 0
%22 = sub i64 0, %4
%23 = icmp ult i64 %4, 8
%24 = and i64 %4, -8
%25 = and i64 %12, 1
%26 = icmp ult i64 %10, 8
%27 = and i64 %12, 4611686018427387902
%28 = icmp eq i64 %25, 0
%29 = icmp eq i64 %24, %4
%30 = icmp ult i64 %4, 8
%31 = and i64 %4, -8
%32 = and i64 %12, 1
%33 = icmp ult i64 %10, 8
%34 = and i64 %12, 4611686018427387902
%35 = icmp eq i64 %32, 0
%36 = icmp eq i64 %31, %4
%37 = and i64 %4, 1
%38 = icmp eq i64 %37, 0
%39 = sub i64 0, %4
br label %40
40: ; preds = %7, %368
%41 = phi i64 [ %79, %368 ], [ 0, %7 ]
%42 = phi i64 [ %78, %368 ], [ 0, %7 ]
%43 = phi i64 [ %369, %368 ], [ 0, %7 ]
br label %44
44: ; preds = %40, %76
%45 = phi i64 [ %41, %40 ], [ %79, %76 ]
%46 = phi i64 [ %42, %40 ], [ %78, %76 ]
%47 = phi i64 [ 0, %40 ], [ %80, %76 ]
%48 = phi float [ 0.000000e+00, %40 ], [ %77, %76 ]
%49 = getelementptr inbounds i64, i64* %3, i64 %47
%50 = load i64, i64* %49
%51 = icmp eq i64 %50, 1
br i1 %51, label %76, label %52
52: ; preds = %44
%53 = getelementptr inbounds float*, float** %0, i64 %47
br label %54
54: ; preds = %52, %70
%55 = phi i64 [ %45, %52 ], [ %73, %70 ]
%56 = phi i64 [ %46, %52 ], [ %72, %70 ]
%57 = phi i64 [ 0, %52 ], [ %74, %70 ]
%58 = phi float [ %48, %52 ], [ %71, %70 ]
%59 = getelementptr inbounds i64, i64* %3, i64 %57
%60 = load i64, i64* %59
switch i64 %60, label %68 [
i64 0, label %61
i64 1, label %70
]
61: ; preds = %54
%62 = load float*, float** %53
%63 = getelementptr inbounds float, float* %62, i64 %57
%64 = load float, float* %63
%65 = tail call float @llvm.fabs.f32(float %64)
%66 = fcmp ult float %65, %58
br i1 %66, label %70, label %67
67: ; preds = %61
br label %70
68: ; preds = %54
%69 = tail call i32 @fmatrixAeqI(float** %0, i64 %4)
br label %415
70: ; preds = %54, %67, %61
%71 = phi float [ %65, %67 ], [ %58, %61 ], [ %58, %54 ]
%72 = phi i64 [ %47, %67 ], [ %56, %61 ], [ %56, %54 ]
%73 = phi i64 [ %57, %67 ], [ %55, %61 ], [ %55, %54 ]
%74 = add nuw i64 %57, 1
%75 = icmp eq i64 %74, %4
br i1 %75, label %76, label %54
76: ; preds = %70, %44
%77 = phi float [ %48, %44 ], [ %71, %70 ]
%78 = phi i64 [ %46, %44 ], [ %72, %70 ]
%79 = phi i64 [ %45, %44 ], [ %73, %70 ]
%80 = add nuw i64 %47, 1
%81 = icmp eq i64 %80, %4
br i1 %81, label %82, label %44
82: ; preds = %76
%83 = getelementptr inbounds i64, i64* %3, i64 %79
%84 = load i64, i64* %83
%85 = add i64 %84, 1
store i64 %85, i64* %83
%86 = icmp eq i64 %78, %79
%87 = getelementptr inbounds float*, float** %0, i64 %78
%88 = load float*, float** %87
br i1 %86, label %183, label %89
89: ; preds = %82
%90 = getelementptr inbounds float*, float** %0, i64 %79
%91 = load float*, float** %90
br i1 %13, label %158, label %92
92: ; preds = %89
%93 = getelementptr float, float* %88, i64 %4
%94 = getelementptr float, float* %91, i64 %4
%95 = icmp ult float* %88, %94
%96 = icmp ult float* %91, %93
%97 = and i1 %95, %96
br i1 %97, label %158, label %98
98: ; preds = %92
br i1 %16, label %138, label %99
99: ; preds = %98, %99
%100 = phi i64 [ %135, %99 ], [ 0, %98 ]
%101 = phi i64 [ %136, %99 ], [ 0, %98 ]
%102 = getelementptr inbounds float, float* %88, i64 %100
%103 = bitcast float* %102 to <4 x float>*
%104 = load <4 x float>, <4 x float>* %103
%105 = getelementptr inbounds float, float* %102, i64 4
%106 = bitcast float* %105 to <4 x float>*
%107 = load <4 x float>, <4 x float>* %106
%108 = getelementptr inbounds float, float* %91, i64 %100
%109 = bitcast float* %108 to <4 x float>*
%110 = load <4 x float>, <4 x float>* %109
%111 = getelementptr inbounds float, float* %108, i64 4
%112 = bitcast float* %111 to <4 x float>*
%113 = load <4 x float>, <4 x float>* %112
%114 = bitcast float* %102 to <4 x float>*
store <4 x float> %110, <4 x float>* %114
%115 = bitcast float* %105 to <4 x float>*
store <4 x float> %113, <4 x float>* %115
%116 = bitcast float* %108 to <4 x float>*
store <4 x float> %104, <4 x float>* %116
%117 = bitcast float* %111 to <4 x float>*
store <4 x float> %107, <4 x float>* %117
%118 = or i64 %100, 8
%119 = getelementptr inbounds float, float* %88, i64 %118
%120 = bitcast float* %119 to <4 x float>*
%121 = load <4 x float>, <4 x float>* %120
%122 = getelementptr inbounds float, float* %119, i64 4
%123 = bitcast float* %122 to <4 x float>*
%124 = load <4 x float>, <4 x float>* %123
%125 = getelementptr inbounds float, float* %91, i64 %118
%126 = bitcast float* %125 to <4 x float>*
%127 = load <4 x float>, <4 x float>* %126
%128 = getelementptr inbounds float, float* %125, i64 4
%129 = bitcast float* %128 to <4 x float>*
%130 = load <4 x float>, <4 x float>* %129
%131 = bitcast float* %119 to <4 x float>*
store <4 x float> %127, <4 x float>* %131
%132 = bitcast float* %122 to <4 x float>*
store <4 x float> %130, <4 x float>* %132
%133 = bitcast float* %125 to <4 x float>*
store <4 x float> %121, <4 x float>* %133
%134 = bitcast float* %128 to <4 x float>*
store <4 x float> %124, <4 x float>* %134
%135 = add nuw i64 %100, 16
%136 = add i64 %101, 2
%137 = icmp eq i64 %136, %17
br i1 %137, label %138, label %99
138: ; preds = %99, %98
%139 = phi i64 [ 0, %98 ], [ %135, %99 ]
br i1 %18, label %157, label %140
140: ; preds = %138
%141 = getelementptr inbounds float, float* %88, i64 %139
%142 = bitcast float* %141 to <4 x float>*
%143 = load <4 x float>, <4 x float>* %142
%144 = getelementptr inbounds float, float* %141, i64 4
%145 = bitcast float* %144 to <4 x float>*
%146 = load <4 x float>, <4 x float>* %145
%147 = getelementptr inbounds float, float* %91, i64 %139
%148 = bitcast float* %147 to <4 x float>*
%149 = load <4 x float>, <4 x float>* %148
%150 = getelementptr inbounds float, float* %147, i64 4
%151 = bitcast float* %150 to <4 x float>*
%152 = load <4 x float>, <4 x float>* %151
%153 = bitcast float* %141 to <4 x float>*
store <4 x float> %149, <4 x float>* %153
%154 = bitcast float* %144 to <4 x float>*
store <4 x float> %152, <4 x float>* %154
%155 = bitcast float* %147 to <4 x float>*
store <4 x float> %143, <4 x float>* %155
%156 = bitcast float* %150 to <4 x float>*
store <4 x float> %146, <4 x float>* %156
br label %157
157: ; preds = %138, %140
br i1 %19, label %183, label %158
158: ; preds = %92, %89, %157
%159 = phi i64 [ 0, %92 ], [ 0, %89 ], [ %14, %157 ]
%160 = xor i64 %159, -1
br i1 %21, label %167, label %161
161: ; preds = %158
%162 = getelementptr inbounds float, float* %88, i64 %159
%163 = load float, float* %162
%164 = getelementptr inbounds float, float* %91, i64 %159
%165 = load float, float* %164
store float %165, float* %162
store float %163, float* %164
%166 = or i64 %159, 1
br label %167
167: ; preds = %161, %158
%168 = phi i64 [ %159, %158 ], [ %166, %161 ]
%169 = icmp eq i64 %160, %22
br i1 %169, label %183, label %170
170: ; preds = %167, %170
%171 = phi i64 [ %181, %170 ], [ %168, %167 ]
%172 = getelementptr inbounds float, float* %88, i64 %171
%173 = load float, float* %172
%174 = getelementptr inbounds float, float* %91, i64 %171
%175 = load float, float* %174
store float %175, float* %172
store float %173, float* %174
%176 = add nuw i64 %171, 1
%177 = getelementptr inbounds float, float* %88, i64 %176
%178 = load float, float* %177
%179 = getelementptr inbounds float, float* %91, i64 %176
%180 = load float, float* %179
store float %180, float* %177
store float %178, float* %179
%181 = add nuw i64 %171, 2
%182 = icmp eq i64 %181, %4
br i1 %182, label %183, label %170
183: ; preds = %167, %170, %157, %82
%184 = phi float* [ %88, %82 ], [ %91, %157 ], [ %91, %170 ], [ %91, %167 ]
%185 = getelementptr inbounds i64, i64* %2, i64 %43
store i64 %78, i64* %185
%186 = getelementptr inbounds i64, i64* %1, i64 %43
store i64 %79, i64* %186
%187 = getelementptr inbounds float, float* %184, i64 %79
%188 = load float, float* %187
%189 = fcmp oeq float %188, 0.000000e+00
br i1 %189, label %190, label %192
190: ; preds = %183
%191 = tail call i32 @fmatrixAeqI(float** %0, i64 %4)
br label %415
192: ; preds = %183
%193 = fdiv float 1.000000e+00, %188
store float 1.000000e+00, float* %187
br i1 %23, label %240, label %194
194: ; preds = %192
%195 = insertelement <4 x float> poison, float %193, i64 0
%196 = shufflevector <4 x float> %195, <4 x float> poison, <4 x i32> zeroinitializer
%197 = insertelement <4 x float> poison, float %193, i64 0
%198 = shufflevector <4 x float> %197, <4 x float> poison, <4 x i32> zeroinitializer
br i1 %26, label %226, label %199
199: ; preds = %194, %199
%200 = phi i64 [ %223, %199 ], [ 0, %194 ]
%201 = phi i64 [ %224, %199 ], [ 0, %194 ]
%202 = getelementptr inbounds float, float* %184, i64 %200
%203 = bitcast float* %202 to <4 x float>*
%204 = load <4 x float>, <4 x float>* %203
%205 = getelementptr inbounds float, float* %202, i64 4
%206 = bitcast float* %205 to <4 x float>*
%207 = load <4 x float>, <4 x float>* %206
%208 = fmul <4 x float> %196, %204
%209 = fmul <4 x float> %198, %207
%210 = bitcast float* %202 to <4 x float>*
store <4 x float> %208, <4 x float>* %210
%211 = bitcast float* %205 to <4 x float>*
store <4 x float> %209, <4 x float>* %211
%212 = or i64 %200, 8
%213 = getelementptr inbounds float, float* %184, i64 %212
%214 = bitcast float* %213 to <4 x float>*
%215 = load <4 x float>, <4 x float>* %214
%216 = getelementptr inbounds float, float* %213, i64 4
%217 = bitcast float* %216 to <4 x float>*
%218 = load <4 x float>, <4 x float>* %217
%219 = fmul <4 x float> %196, %215
%220 = fmul <4 x float> %198, %218
%221 = bitcast float* %213 to <4 x float>*
store <4 x float> %219, <4 x float>* %221
%222 = bitcast float* %216 to <4 x float>*
store <4 x float> %220, <4 x float>* %222
%223 = add nuw i64 %200, 16
%224 = add i64 %201, 2
%225 = icmp eq i64 %224, %27
br i1 %225, label %226, label %199
226: ; preds = %199, %194
%227 = phi i64 [ 0, %194 ], [ %223, %199 ]
br i1 %28, label %239, label %228
228: ; preds = %226
%229 = getelementptr inbounds float, float* %184, i64 %227
%230 = bitcast float* %229 to <4 x float>*
%231 = load <4 x float>, <4 x float>* %230
%232 = getelementptr inbounds float, float* %229, i64 4
%233 = bitcast float* %232 to <4 x float>*
%234 = load <4 x float>, <4 x float>* %233
%235 = fmul <4 x float> %196, %231
%236 = fmul <4 x float> %198, %234
%237 = bitcast float* %229 to <4 x float>*
store <4 x float> %235, <4 x float>* %237
%238 = bitcast float* %232 to <4 x float>*
store <4 x float> %236, <4 x float>* %238
br label %239
239: ; preds = %226, %228
br i1 %29, label %249, label %240
240: ; preds = %192, %239
%241 = phi i64 [ 0, %192 ], [ %24, %239 ]
br label %242
242: ; preds = %240, %242
%243 = phi i64 [ %247, %242 ], [ %241, %240 ]
%244 = getelementptr inbounds float, float* %184, i64 %243
%245 = load float, float* %244
%246 = fmul float %193, %245
store float %246, float* %244
%247 = add nuw i64 %243, 1
%248 = icmp eq i64 %247, %4
br i1 %248, label %249, label %242
249: ; preds = %242, %239
%250 = getelementptr float, float* %184, i64 %4
br label %251
251: ; preds = %249, %365
%252 = phi i64 [ %366, %365 ], [ 0, %249 ]
%253 = icmp eq i64 %252, %79
br i1 %253, label %365, label %254
254: ; preds = %251
%255 = getelementptr inbounds float*, float** %0, i64 %252
%256 = load float*, float** %255
%257 = getelementptr inbounds float, float* %256, i64 %79
%258 = load float, float* %257
store float 0.000000e+00, float* %257
br i1 %30, label %334, label %259
259: ; preds = %254
%260 = getelementptr float, float* %256, i64 %4
%261 = icmp ult float* %256, %250
%262 = icmp ult float* %184, %260
%263 = and i1 %261, %262
br i1 %263, label %334, label %264
264: ; preds = %259
%265 = insertelement <4 x float> poison, float %258, i64 0
%266 = shufflevector <4 x float> %265, <4 x float> poison, <4 x i32> zeroinitializer
%267 = insertelement <4 x float> poison, float %258, i64 0
%268 = shufflevector <4 x float> %267, <4 x float> poison, <4 x i32> zeroinitializer
br i1 %33, label %312, label %269
269: ; preds = %264, %269
%270 = phi i64 [ %309, %269 ], [ 0, %264 ]
%271 = phi i64 [ %310, %269 ], [ 0, %264 ]
%272 = getelementptr inbounds float, float* %184, i64 %270
%273 = bitcast float* %272 to <4 x float>*
%274 = load <4 x float>, <4 x float>* %273
%275 = getelementptr inbounds float, float* %272, i64 4
%276 = bitcast float* %275 to <4 x float>*
%277 = load <4 x float>, <4 x float>* %276
%278 = getelementptr inbounds float, float* %256, i64 %270
%279 = bitcast float* %278 to <4 x float>*
%280 = load <4 x float>, <4 x float>* %279
%281 = getelementptr inbounds float, float* %278, i64 4
%282 = bitcast float* %281 to <4 x float>*
%283 = load <4 x float>, <4 x float>* %282
%284 = fneg <4 x float> %274
%285 = fneg <4 x float> %277
%286 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %284, <4 x float> %266, <4 x float> %280)
%287 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %285, <4 x float> %268, <4 x float> %283)
%288 = bitcast float* %278 to <4 x float>*
store <4 x float> %286, <4 x float>* %288
%289 = bitcast float* %281 to <4 x float>*
store <4 x float> %287, <4 x float>* %289
%290 = or i64 %270, 8
%291 = getelementptr inbounds float, float* %184, i64 %290
%292 = bitcast float* %291 to <4 x float>*
%293 = load <4 x float>, <4 x float>* %292
%294 = getelementptr inbounds float, float* %291, i64 4
%295 = bitcast float* %294 to <4 x float>*
%296 = load <4 x float>, <4 x float>* %295
%297 = getelementptr inbounds float, float* %256, i64 %290
%298 = bitcast float* %297 to <4 x float>*
%299 = load <4 x float>, <4 x float>* %298
%300 = getelementptr inbounds float, float* %297, i64 4
%301 = bitcast float* %300 to <4 x float>*
%302 = load <4 x float>, <4 x float>* %301
%303 = fneg <4 x float> %293
%304 = fneg <4 x float> %296
%305 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %303, <4 x float> %266, <4 x float> %299)
%306 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %304, <4 x float> %268, <4 x float> %302)
%307 = bitcast float* %297 to <4 x float>*
store <4 x float> %305, <4 x float>* %307
%308 = bitcast float* %300 to <4 x float>*
store <4 x float> %306, <4 x float>* %308
%309 = add nuw i64 %270, 16
%310 = add i64 %271, 2
%311 = icmp eq i64 %310, %34
br i1 %311, label %312, label %269
312: ; preds = %269, %264
%313 = phi i64 [ 0, %264 ], [ %309, %269 ]
br i1 %35, label %333, label %314
314: ; preds = %312
%315 = getelementptr inbounds float, float* %184, i64 %313
%316 = bitcast float* %315 to <4 x float>*
%317 = load <4 x float>, <4 x float>* %316
%318 = getelementptr inbounds float, float* %315, i64 4
%319 = bitcast float* %318 to <4 x float>*
%320 = load <4 x float>, <4 x float>* %319
%321 = getelementptr inbounds float, float* %256, i64 %313
%322 = bitcast float* %321 to <4 x float>*
%323 = load <4 x float>, <4 x float>* %322
%324 = getelementptr inbounds float, float* %321, i64 4
%325 = bitcast float* %324 to <4 x float>*
%326 = load <4 x float>, <4 x float>* %325
%327 = fneg <4 x float> %317
%328 = fneg <4 x float> %320
%329 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %327, <4 x float> %266, <4 x float> %323)
%330 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %328, <4 x float> %268, <4 x float> %326)
%331 = bitcast float* %321 to <4 x float>*
store <4 x float> %329, <4 x float>* %331
%332 = bitcast float* %324 to <4 x float>*
store <4 x float> %330, <4 x float>* %332
br label %333
333: ; preds = %312, %314
br i1 %36, label %365, label %334
334: ; preds = %259, %254, %333
%335 = phi i64 [ 0, %259 ], [ 0, %254 ], [ %31, %333 ]
%336 = xor i64 %335, -1
br i1 %38, label %345, label %337
337: ; preds = %334
%338 = getelementptr inbounds float, float* %184, i64 %335
%339 = load float, float* %338
%340 = getelementptr inbounds float, float* %256, i64 %335
%341 = load float, float* %340
%342 = fneg float %339
%343 = tail call float @llvm.fmuladd.f32(float %342, float %258, float %341)
store float %343, float* %340
%344 = or i64 %335, 1
br label %345
345: ; preds = %337, %334
%346 = phi i64 [ %335, %334 ], [ %344, %337 ]
%347 = icmp eq i64 %336, %39
br i1 %347, label %365, label %348
348: ; preds = %345, %348
%349 = phi i64 [ %363, %348 ], [ %346, %345 ]
%350 = getelementptr inbounds float, float* %184, i64 %349
%351 = load float, float* %350
%352 = getelementptr inbounds float, float* %256, i64 %349
%353 = load float, float* %352
%354 = fneg float %351
%355 = tail call float @llvm.fmuladd.f32(float %354, float %258, float %353)
store float %355, float* %352
%356 = add nuw i64 %349, 1
%357 = getelementptr inbounds float, float* %184, i64 %356
%358 = load float, float* %357
%359 = getelementptr inbounds float, float* %256, i64 %356
%360 = load float, float* %359
%361 = fneg float %358
%362 = tail call float @llvm.fmuladd.f32(float %361, float %258, float %360)
store float %362, float* %359
%363 = add nuw i64 %349, 2
%364 = icmp eq i64 %363, %4
br i1 %364, label %365, label %348
365: ; preds = %345, %348, %333, %251
%366 = add nuw i64 %252, 1
%367 = icmp eq i64 %366, %4
br i1 %367, label %368, label %251
368: ; preds = %365
%369 = add nuw i64 %43, 1
%370 = icmp eq i64 %369, %4
br i1 %370, label %371, label %40
371: ; preds = %368, %5
%372 = and i64 %4, 1
%373 = icmp eq i64 %4, 1
%374 = and i64 %4, -2
%375 = icmp eq i64 %372, 0
br label %385
376: ; preds = %396, %395
%377 = phi i64 [ 0, %395 ], [ %412, %396 ]
br i1 %375, label %394, label %378
378: ; preds = %376
%379 = getelementptr inbounds float*, float** %0, i64 %377
%380 = load float*, float** %379
%381 = getelementptr inbounds float, float* %380, i64 %389
%382 = load float, float* %381
%383 = getelementptr inbounds float, float* %380, i64 %391
%384 = load float, float* %383
store float %384, float* %381
store float %382, float* %383
br label %394
385: ; preds = %394, %371
%386 = phi i64 [ %4, %371 ], [ %387, %394 ]
%387 = add i64 %386, -1
%388 = getelementptr inbounds i64, i64* %2, i64 %387
%389 = load i64, i64* %388
%390 = getelementptr inbounds i64, i64* %1, i64 %387
%391 = load i64, i64* %390
%392 = icmp eq i64 %389, %391
%393 = or i1 %392, %6
br i1 %393, label %394, label %395
394: ; preds = %378, %376, %385
br label %385
395: ; preds = %385
br i1 %373, label %376, label %396
396: ; preds = %395, %396
%397 = phi i64 [ %412, %396 ], [ 0, %395 ]
%398 = phi i64 [ %413, %396 ], [ 0, %395 ]
%399 = getelementptr inbounds float*, float** %0, i64 %397
%400 = load float*, float** %399
%401 = getelementptr inbounds float, float* %400, i64 %389
%402 = load float, float* %401
%403 = getelementptr inbounds float, float* %400, i64 %391
%404 = load float, float* %403
store float %404, float* %401
store float %402, float* %403
%405 = or i64 %397, 1
%406 = getelementptr inbounds float*, float** %0, i64 %405
%407 = load float*, float** %406
%408 = getelementptr inbounds float, float* %407, i64 %389
%409 = load float, float* %408
%410 = getelementptr inbounds float, float* %407, i64 %391
%411 = load float, float* %410
store float %411, float* %408
store float %409, float* %410
%412 = add nuw i64 %397, 2
%413 = add i64 %398, 2
%414 = icmp eq i64 %413, %374
br i1 %414, label %376, label %396
415: ; preds = %190, %68
ret void
}