#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
float fabs(float);
int /*<<< orphan*/ free_ivector(int *, int, int);
int /*<<< orphan*/ free_vector(float *, int, int);
int *ivector(int, int);
int /*<<< orphan*/ nrerror(char *);
float *vector(int, int);
void pinvs(int ie1, int ie2, int je1, int jsf, int jc1, int k, float ***c,
           float **s) {
  int js1, jpiv, jp, je2, jcoff, j, irow, ipiv, id, icoff, i, *indxr;
  float pivinv, piv, dum, big, *pscl;
  indxr = ivector(ie1, ie2);
  pscl = vector(ie1, ie2);
  je2 = je1 + ie2 - ie1;
  js1 = je2 + 1;
  for (i = ie1; i <= ie2; i++) {
    big = 0.0;
    for (j = je1; j <= je2; j++)
      if (fabs(s[i][j]) > big)
        big = fabs(s[i][j]);
    if (big == 0.0)
      nrerror("Singular matrix - row all 0, in pinvs");
    pscl[i] = 1.0 / big;
    indxr[i] = 0;
  }
  for (id = ie1; id <= ie2; id++) {
    piv = 0.0;
    for (i = ie1; i <= ie2; i++) {
      if (indxr[i] == 0) {
        big = 0.0;
        for (j = je1; j <= je2; j++) {
          if (fabs(s[i][j]) > big) {
            jp = j;
            big = fabs(s[i][j]);
          }
        }
        if (big * pscl[i] > piv) {
          ipiv = i;
          jpiv = jp;
          piv = big * pscl[i];
        }
      }
    }
    if (s[ipiv][jpiv] == 0.0)
      nrerror("Singular matrix in routine pinvs");
    indxr[ipiv] = jpiv;
    pivinv = 1.0 / s[ipiv][jpiv];
    for (j = je1; j <= jsf; j++)
      s[ipiv][j] *= pivinv;
    s[ipiv][jpiv] = 1.0;
    for (i = ie1; i <= ie2; i++) {
      if (indxr[i] != jpiv) {
        if (s[i][jpiv]) {
          dum = s[i][jpiv];
          for (j = je1; j <= jsf; j++)
            s[i][j] -= dum * s[ipiv][j];
          s[i][jpiv] = 0.0;
        }
      }
    }
  }
  jcoff = jc1 - js1;
  icoff = ie1 - je1;
  for (i = ie1; i <= ie2; i++) {
    irow = indxr[i] + icoff;
    for (j = js1; j <= jsf; j++)
      c[irow][j + jcoff][k] = s[i][j];
  }
  free_vector(pscl, ie1, ie2);
  free_ivector(indxr, ie1, ie2);
}


x86 assembly (clang, -O0):
<pinvs>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %edx,-0xc(%rbp)
mov    %ecx,-0x10(%rbp)
mov    %r8d,-0x14(%rbp)
mov    %r9d,-0x18(%rbp)
mov    -0x4(%rbp),%edi
mov    -0x8(%rbp),%esi
call   1080 <ivector@plt>
mov    %rax,-0x50(%rbp)
mov    -0x4(%rbp),%edi
mov    -0x8(%rbp),%esi
call   1060 <vector@plt>
mov    %rax,-0x68(%rbp)
mov    -0xc(%rbp),%eax
add    -0x8(%rbp),%eax
sub    -0x4(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x4(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     12a4 <pinvs+0x144>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0xc(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x28(%rbp),%eax
jg     1239 <pinvs+0xd9>
mov    0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
call   1050 <fabs@plt>
ucomiss -0x60(%rbp),%xmm0
jbe    1226 <pinvs+0xc6>
mov    0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
call   1050 <fabs@plt>
movss  %xmm0,-0x60(%rbp)
jmp    122b <pinvs+0xcb>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    11d7 <pinvs+0x77>
movss  -0x60(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1261 <pinvs+0x101>
jp     1261 <pinvs+0x101>
lea    0xdb0(%rip),%rdi
call   1030 <nrerror@plt>
movss  -0x60(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xd8e(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x68(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x50(%rbp),%rax
movslq -0x44(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    11bd <pinvs+0x5d>
mov    -0x4(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     1598 <pinvs+0x438>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x4(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     13af <pinvs+0x24f>
mov    -0x50(%rbp),%rax
movslq -0x44(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    139c <pinvs+0x23c>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0xc(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x28(%rbp),%eax
jg     1358 <pinvs+0x1f8>
mov    0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
call   1050 <fabs@plt>
ucomiss -0x60(%rbp),%xmm0
jbe    1345 <pinvs+0x1e5>
mov    -0x30(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
call   1050 <fabs@plt>
movss  %xmm0,-0x60(%rbp)
jmp    134a <pinvs+0x1ea>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    12f0 <pinvs+0x190>
movss  -0x60(%rbp),%xmm0
mov    -0x68(%rbp),%rax
movslq -0x44(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
ucomiss -0x58(%rbp),%xmm0
jbe    1397 <pinvs+0x237>
mov    -0x44(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,-0x20(%rbp)
movss  -0x60(%rbp),%xmm0
mov    -0x68(%rbp),%rax
movslq -0x44(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x58(%rbp)
jmp    139c <pinvs+0x23c>
jmp    13a1 <pinvs+0x241>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    12c4 <pinvs+0x164>
mov    0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    13e7 <pinvs+0x287>
jp     13e7 <pinvs+0x287>
lea    0xc50(%rip),%rdi
call   1030 <nrerror@plt>
mov    -0x20(%rbp),%edx
mov    -0x50(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xbea(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0xc(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     1462 <pinvs+0x302>
movss  -0x54(%rbp),%xmm0
mov    0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1429 <pinvs+0x2c9>
mov    0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x20(%rbp),%rcx
movss  0xb8e(%rip),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x4(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     1585 <pinvs+0x425>
mov    -0x50(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x20(%rbp),%eax
je     1572 <pinvs+0x412>
mov    0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    14d1 <pinvs+0x371>
jp     14d1 <pinvs+0x371>
jmp    156d <pinvs+0x40d>
mov    0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0xc(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     1555 <pinvs+0x3f5>
movss  -0x5c(%rbp),%xmm0
mov    0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%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    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    14f1 <pinvs+0x391>
mov    0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x20(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
jmp    1572 <pinvs+0x412>
jmp    1577 <pinvs+0x417>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1485 <pinvs+0x325>
jmp    158a <pinvs+0x42a>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    12aa <pinvs+0x14a>
mov    -0x14(%rbp),%eax
sub    -0x1c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x4(%rbp),%eax
sub    -0xc(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x4(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     1637 <pinvs+0x4d7>
mov    -0x50(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
add    -0x40(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x1c(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     1624 <pinvs+0x4c4>
mov    0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x18(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    15d3 <pinvs+0x473>
jmp    1629 <pinvs+0x4c9>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    15b0 <pinvs+0x450>
mov    -0x68(%rbp),%rdi
mov    -0x4(%rbp),%esi
mov    -0x8(%rbp),%edx
call   1040 <free_vector@plt>
mov    -0x50(%rbp),%rdi
mov    -0x4(%rbp),%esi
mov    -0x8(%rbp),%edx
call   1070 <free_ivector@plt>
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<pinvs>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xd8,%rsp
mov    %r9d,0x70(%rsp)
mov    %r8d,0x6c(%rsp)
mov    %rcx,0x38(%rsp)
mov    %edx,%ebp
mov    %esi,%ebx
mov    %edi,%r14d
call   1070 <ivector@plt>
mov    %rax,0x18(%rsp)
mov    %r14d,%edi
mov    %ebx,%esi
call   1050 <vector@plt>
mov    %rax,0x50(%rsp)
mov    %ebx,%r13d
sub    %r14d,%r13d
mov    %rbx,%rax
mov    %rbx,0x20(%rsp)
mov    %r14d,0x10(%rsp)
sub    %r14d,%eax
jl     1896 <pinvs+0x746>
mov    %eax,0x14(%rsp)
add    %ebp,%r13d
mov    0x118(%rsp),%rax
mov    %rax,0x28(%rsp)
mov    0x110(%rsp),%rax
mov    %rax,0xc0(%rsp)
movslq %ebp,%rax
mov    %rax,0x8(%rsp)
mov    0x10(%rsp),%ecx
movslq %ecx,%rbx
mov    0x20(%rsp),%rax
lea    0x1(%rax),%edx
mov    %edx,0x4(%rsp)
mov    %edx,%r8d
sub    %ecx,%r8d
mov    %r8d,%r14d
and    $0x3,%r14d
lea    (%rax,%rbp,1),%r12d
sub    %ecx,%r12d
add    $0x1,%r12d
movaps 0xdf6(%rip),%xmm7
mov    0x18(%rsp),%rsi
mov    0x50(%rsp),%r15
mov    %r8d,0x34(%rsp)
jmp    127f <pinvs+0x12f>
nopl   0x0(%rax,%rax,1)
ucomiss 0xdfd(%rip),%xmm4
mov    0x4(%rsp),%edx
jne    125a <pinvs+0x10a>
jp     125a <pinvs+0x10a>
movaps %xmm4,0x40(%rsp)
lea    0xded(%rip),%rdi
call   1030 <nrerror@plt>
movaps 0x40(%rsp),%xmm4
movaps 0xdb4(%rip),%xmm7
mov    0x34(%rsp),%r8d
mov    0x4(%rsp),%edx
mov    0x18(%rsp),%rsi
movss  0xdbe(%rip),%xmm0
divss  %xmm4,%xmm0
movss  %xmm0,(%r15,%rbx,4)
movl   $0x0,(%rsi,%rbx,4)
add    $0x1,%rbx
cmp    %ebx,%edx
je     1323 <pinvs+0x1d3>
xorps  %xmm4,%xmm4
cmp    %ebp,%r13d
jl     122f <pinvs+0xdf>
mov    0x28(%rsp),%rax
mov    (%rax,%rbx,8),%rax
test   %r14d,%r14d
je     12ba <pinvs+0x16a>
xorps  %xmm1,%xmm1
mov    %r14d,%ecx
mov    0x8(%rsp),%rdx
movss  (%rax,%rdx,4),%xmm0
andps  %xmm7,%xmm0
maxss  %xmm1,%xmm0
add    $0x1,%rdx
movaps %xmm0,%xmm1
add    $0xffffffff,%ecx
jne    12a0 <pinvs+0x150>
jmp    12c2 <pinvs+0x172>
xorps  %xmm0,%xmm0
mov    0x8(%rsp),%rdx
movaps %xmm0,%xmm4
cmpl   $0x3,0x14(%rsp)
jb     1220 <pinvs+0xd0>
mov    %r12d,%ecx
sub    %edx,%ecx
lea    (%rax,%rdx,4),%rax
add    $0xc,%rax
xor    %edx,%edx
nop
movss  -0xc(%rax,%rdx,4),%xmm1
movss  -0x8(%rax,%rdx,4),%xmm2
movss  -0x4(%rax,%rdx,4),%xmm3
movss  (%rax,%rdx,4),%xmm4
andps  %xmm7,%xmm1
maxss  %xmm0,%xmm1
andps  %xmm7,%xmm2
maxss  %xmm1,%xmm2
andps  %xmm7,%xmm3
maxss  %xmm2,%xmm3
andps  %xmm7,%xmm4
maxss  %xmm3,%xmm4
add    $0x4,%rdx
movaps %xmm4,%xmm0
cmp    %edx,%ecx
jne    12e0 <pinvs+0x190>
jmp    1220 <pinvs+0xd0>
mov    0x10(%rsp),%eax
cmp    %eax,0x20(%rsp)
mov    0x14(%rsp),%ebx
jl     1896 <pinvs+0x746>
mov    0x10(%rsp),%eax
movslq %eax,%rcx
mov    %rcx,0xa8(%rsp)
mov    0x38(%rsp),%r10
lea    0x1(%r10),%r15d
mov    %r10d,%esi
sub    %ebp,%esi
mov    0x8(%rsp),%rcx
lea    (%rcx,%rsi,1),%rdi
add    $0x1,%rdi
mov    %rdi,0xb0(%rsp)
mov    %rsi,0xb8(%rsp)
add    $0x1,%rsi
mov    %rsi,0xa0(%rsp)
and    $0xfffffffffffffff8,%rsi
lea    -0x8(%rsi),%rdi
mov    %rdi,0x90(%rsp)
shr    $0x3,%rdi
add    $0x1,%rdi
lea    0x1(%rcx),%r9
mov    %rsi,0x98(%rsp)
add    %rcx,%rsi
mov    %rsi,0x80(%rsp)
mov    %rdi,%rsi
mov    %rdi,0x88(%rsp)
and    $0xfffffffffffffffe,%rdi
mov    %rdi,0x78(%rsp)
add    $0xc,%rcx
mov    %rcx,0x58(%rsp)
xorps  %xmm8,%xmm8
movaps 0xc3d(%rip),%xmm9
mov    0x18(%rsp),%r11
mov    %r13d,0x30(%rsp)
mov    %rbp,0x60(%rsp)
mov    %r9,0xc8(%rsp)
jmp    1420 <pinvs+0x2d0>
nopl   0x0(%rax)
mov    0xd0(%rsp),%rcx
lea    0x1(%rcx),%eax
cmp    0x20(%rsp),%ecx
mov    0x30(%rsp),%r13d
mov    0x60(%rsp),%rbp
mov    0x14(%rsp),%ebx
mov    0x34(%rsp),%r8d
mov    0xc8(%rsp),%r9
je     188c <pinvs+0x73c>
mov    %rax,0xd0(%rsp)
mov    0xa8(%rsp),%rax
xorps  %xmm0,%xmm0
mov    0x50(%rsp),%rdi
jmp    1452 <pinvs+0x302>
nopw   0x0(%rax,%rax,1)
movaps %xmm0,%xmm1
add    $0x1,%rax
movaps %xmm1,%xmm0
cmp    %eax,%edx
je     1510 <pinvs+0x3c0>
cmpl   $0x0,(%r11,%rax,4)
jne    1440 <pinvs+0x2f0>
xorps  %xmm1,%xmm1
cmp    %ebp,%r13d
jl     14e6 <pinvs+0x396>
mov    0x28(%rsp),%rcx
mov    (%rcx,%rax,8),%rcx
xorps  %xmm2,%xmm2
test   $0x1,%r8b
jne    1482 <pinvs+0x332>
mov    0x8(%rsp),%rdx
test   %ebx,%ebx
jne    14b0 <pinvs+0x360>
jmp    14e6 <pinvs+0x396>
mov    0x8(%rsp),%rdx
movss  (%rcx,%rdx,4),%xmm2
xorps  %xmm1,%xmm1
ucomiss %xmm2,%xmm1
cmovne %ebp,%r14d
je     149e <pinvs+0x34e>
andps  %xmm7,%xmm2
movaps %xmm2,%xmm1
mov    %r9,%rdx
movaps %xmm1,%xmm2
test   %ebx,%ebx
je     14e6 <pinvs+0x396>
nopl   0x0(%rax,%rax,1)
movss  (%rcx,%rdx,4),%xmm3
andps  %xmm7,%xmm3
ucomiss %xmm2,%xmm3
movss  0x4(%rcx,%rdx,4),%xmm1
cmova  %edx,%r14d
maxss  %xmm2,%xmm3
andps  %xmm7,%xmm1
ucomiss %xmm3,%xmm1
lea    0x1(%rdx),%esi
cmova  %esi,%r14d
maxss  %xmm3,%xmm1
add    $0x2,%rdx
movaps %xmm1,%xmm2
cmp    %edx,%r12d
jne    14b0 <pinvs+0x360>
mulss  (%rdi,%rax,4),%xmm1
ucomiss %xmm0,%xmm1
jbe    14fd <pinvs+0x3ad>
mov    %eax,%ecx
mov    %eax,0x74(%rsp)
mov    %r14d,0x40(%rsp)
jmp    1500 <pinvs+0x3b0>
movaps %xmm0,%xmm1
mov    0x4(%rsp),%edx
jmp    1443 <pinvs+0x2f3>
nopl   0x0(%rax)
movslq 0x74(%rsp),%rbx
mov    0x28(%rsp),%rbp
mov    0x0(%rbp,%rbx,8),%rax
movslq 0x40(%rsp),%r13
movss  (%rax,%r13,4),%xmm1
ucomiss %xmm8,%xmm1
jne    156a <pinvs+0x41a>
jp     156a <pinvs+0x41a>
lea    0xb15(%rip),%rdi
call   1030 <nrerror@plt>
movaps 0xaca(%rip),%xmm9
xorps  %xmm8,%xmm8
movaps 0xaaf(%rip),%xmm7
mov    0x4(%rsp),%edx
mov    0x18(%rsp),%r11
mov    0x38(%rsp),%r10
mov    0x0(%rbp,%rbx,8),%rax
movss  (%rax,%r13,4),%xmm1
mov    0x40(%rsp),%ecx
mov    %ecx,(%r11,%rbx,4)
cmp    0x60(%rsp),%r10d
mov    %rbp,%rbx
jl     1677 <pinvs+0x527>
movss  0xa98(%rip),%xmm0
divss  %xmm1,%xmm0
mov    0x8(%rsp),%rcx
cmpl   $0x7,0xb8(%rsp)
07
jb     1660 <pinvs+0x510>
movaps %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm1
cmpq   $0x0,0x90(%rsp)
je     160e <pinvs+0x4be>
mov    0x58(%rsp),%rcx
lea    (%rax,%rcx,4),%rdx
mov    0x78(%rsp),%rsi
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movups -0x30(%rdx,%rcx,4),%xmm2
movups -0x20(%rdx,%rcx,4),%xmm3
movups -0x10(%rdx,%rcx,4),%xmm4
movups (%rdx,%rcx,4),%xmm5
mulps  %xmm1,%xmm2
mulps  %xmm1,%xmm3
movups %xmm2,-0x30(%rdx,%rcx,4)
movups %xmm3,-0x20(%rdx,%rcx,4)
mulps  %xmm1,%xmm4
mulps  %xmm1,%xmm5
movups %xmm4,-0x10(%rdx,%rcx,4)
movups %xmm5,(%rdx,%rcx,4)
add    $0x10,%rcx
add    $0xfffffffffffffffe,%rsi
jne    15d0 <pinvs+0x480>
jmp    1610 <pinvs+0x4c0>
xor    %ecx,%ecx
testb  $0x1,0x88(%rsp)
01
mov    0x4(%rsp),%edx
je     163b <pinvs+0x4eb>
add    0x8(%rsp),%rcx
movups (%rax,%rcx,4),%xmm2
movups 0x10(%rax,%rcx,4),%xmm3
mulps  %xmm1,%xmm2
mulps  %xmm1,%xmm3
movups %xmm2,(%rax,%rcx,4)
movups %xmm3,0x10(%rax,%rcx,4)
mov    0x80(%rsp),%rcx
mov    0x98(%rsp),%rsi
cmp    %rsi,0xa0(%rsp)
je     1677 <pinvs+0x527>
cs nopw 0x0(%rax,%rax,1)
nop
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,(%rax,%rcx,4)
add    $0x1,%rcx
cmp    %ecx,%r15d
jne    1660 <pinvs+0x510>
movl   $0x3f800000,(%rax,%r13,4)
3f
mov    0x8(%rsp),%rcx
lea    (%rax,%rcx,4),%r8
mov    0xb0(%rsp),%rcx
lea    (%rax,%rcx,4),%r9
mov    0x58(%rsp),%rcx
lea    (%rax,%rcx,4),%rsi
mov    0xa8(%rsp),%rdi
mov    0x40(%rsp),%ebp
jmp    16cc <pinvs+0x57c>
nopl   0x0(%rax,%rax,1)
movl   $0x0,(%rcx,%r13,4)
mov    0x4(%rsp),%edx
mov    0x40(%rsp),%ebp
add    $0x1,%rdi
cmp    %edi,%edx
je     13f0 <pinvs+0x2a0>
cmp    %ebp,(%r11,%rdi,4)
je     16c0 <pinvs+0x570>
mov    (%rbx,%rdi,8),%rcx
movss  (%rcx,%r13,4),%xmm0
ucomiss %xmm8,%xmm0
jne    16e4 <pinvs+0x594>
jnp    16c0 <pinvs+0x570>
cmp    0x60(%rsp),%r10d
jl     16b0 <pinvs+0x560>
xorps  %xmm9,%xmm0
mov    0x8(%rsp),%rbp
cmpl   $0x7,0xb8(%rsp)
07
jb     1804 <pinvs+0x6b4>
mov    0x8(%rsp),%rdx
lea    (%rcx,%rdx,4),%rdx
cmp    %r9,%rdx
jae    172a <pinvs+0x5da>
mov    0xb0(%rsp),%rdx
lea    (%rcx,%rdx,4),%rdx
mov    0x8(%rsp),%rbp
cmp    %rdx,%r8
jb     1804 <pinvs+0x6b4>
movaps %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm1
cmpq   $0x0,0x90(%rsp)
je     1877 <pinvs+0x727>
mov    0x58(%rsp),%rdx
lea    (%rcx,%rdx,4),%rdx
mov    0x78(%rsp),%rbp
xor    %ebx,%ebx
movups -0x30(%rsi,%rbx,4),%xmm2
movups -0x20(%rsi,%rbx,4),%xmm3
mulps  %xmm1,%xmm2
movups -0x30(%rdx,%rbx,4),%xmm4
addps  %xmm2,%xmm4
movups -0x20(%rdx,%rbx,4),%xmm2
movups -0x10(%rdx,%rbx,4),%xmm5
movups (%rdx,%rbx,4),%xmm6
mulps  %xmm1,%xmm3
addps  %xmm2,%xmm3
movups %xmm4,-0x30(%rdx,%rbx,4)
movups %xmm3,-0x20(%rdx,%rbx,4)
movups -0x10(%rsi,%rbx,4),%xmm2
movups (%rsi,%rbx,4),%xmm3
mulps  %xmm1,%xmm2
addps  %xmm5,%xmm2
mulps  %xmm1,%xmm3
addps  %xmm6,%xmm3
movups %xmm2,-0x10(%rdx,%rbx,4)
movups %xmm3,(%rdx,%rbx,4)
add    $0x10,%rbx
add    $0xfffffffffffffffe,%rbp
jne    1750 <pinvs+0x600>
testb  $0x1,0x88(%rsp)
01
je     17e1 <pinvs+0x691>
add    0x8(%rsp),%rbx
movups (%rax,%rbx,4),%xmm2
movups 0x10(%rax,%rbx,4),%xmm3
movups (%rcx,%rbx,4),%xmm4
movups 0x10(%rcx,%rbx,4),%xmm5
mulps  %xmm1,%xmm2
addps  %xmm4,%xmm2
mulps  %xmm1,%xmm3
addps  %xmm5,%xmm3
movups %xmm2,(%rcx,%rbx,4)
movups %xmm3,0x10(%rcx,%rbx,4)
mov    0x80(%rsp),%rbp
mov    0x98(%rsp),%rdx
cmp    %rdx,0xa0(%rsp)
mov    0x28(%rsp),%rbx
je     16b0 <pinvs+0x560>
mov    %r15d,%edx
sub    %ebp,%edx
test   $0x1,%dl
jne    181b <pinvs+0x6cb>
mov    %rbp,%rdx
cmp    %r10d,%ebp
jne    1840 <pinvs+0x6f0>
jmp    16b0 <pinvs+0x560>
movss  (%rax,%rbp,4),%xmm1
mulss  %xmm0,%xmm1
addss  (%rcx,%rbp,4),%xmm1
movss  %xmm1,(%rcx,%rbp,4)
mov    %rbp,%rdx
add    $0x1,%rdx
cmp    %r10d,%ebp
je     16b0 <pinvs+0x560>
xchg   %ax,%ax
movss  (%rax,%rdx,4),%xmm1
mulss  %xmm0,%xmm1
addss  (%rcx,%rdx,4),%xmm1
movss  %xmm1,(%rcx,%rdx,4)
movss  0x4(%rax,%rdx,4),%xmm1
mulss  %xmm0,%xmm1
addss  0x4(%rcx,%rdx,4),%xmm1
movss  %xmm1,0x4(%rcx,%rdx,4)
add    $0x2,%rdx
cmp    %edx,%r15d
jne    1840 <pinvs+0x6f0>
jmp    16b0 <pinvs+0x560>
xor    %ebx,%ebx
testb  $0x1,0x88(%rsp)
01
jne    17b5 <pinvs+0x665>
jmp    17e1 <pinvs+0x691>
mov    0x10(%rsp),%eax
cmp    %eax,0x20(%rsp)
jge    18cc <pinvs+0x77c>
mov    0x50(%rsp),%rdi
mov    0x10(%rsp),%ebp
mov    %ebp,%esi
mov    0x20(%rsp),%rbx
mov    %ebx,%edx
call   1040 <free_vector@plt>
mov    0x18(%rsp),%rdi
mov    %ebp,%esi
mov    %ebx,%edx
add    $0xd8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1060 <free_ivector@plt>
mov    0x10(%rsp),%edx
mov    %edx,%ecx
sub    %ebp,%ecx
mov    %r13d,%esi
not    %esi
add    0x6c(%rsp),%esi
movslq 0x70(%rsp),%rax
movslq %r13d,%r14
mov    0x38(%rsp),%r15
movslq %r15d,%r9
movslq %esi,%rsi
movslq %edx,%rdi
sub    %r13d,%r15d
mov    %r14,%r8
not    %r8
add    %r9,%r8
and    $0x3,%r15d
lea    0x1(%rsi),%rdx
mov    %rdx,0x40(%rsp)
lea    0x0(,%r15,8),%r10
add    $0x4,%rsi
mov    %rsi,0x8(%rsp)
movslq %ecx,%r11
jmp    1943 <pinvs+0x7f3>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%rdi
cmp    %edi,0x4(%rsp)
mov    0x30(%rsp),%r13d
je     1896 <pinvs+0x746>
cmp    0x38(%rsp),%r13d
jge    1930 <pinvs+0x7e0>
mov    0x18(%rsp),%rcx
movslq (%rcx,%rdi,4),%rcx
add    %r11,%rcx
mov    0x28(%rsp),%rdx
mov    (%rdx,%rdi,8),%rsi
mov    0xc0(%rsp),%rdx
mov    (%rdx,%rcx,8),%r13
mov    %r14,%rcx
test   %r15,%r15
je     19ae <pinvs+0x85e>
mov    0x40(%rsp),%rcx
lea    0x0(,%rcx,8),%rbx
add    %r13,%rbx
mov    %r10,%rbp
mov    %r14,%r12
nopl   0x0(%rax)
lea    0x1(%r12),%rcx
movss  0x4(%rsi,%r12,4),%xmm0
mov    (%rbx,%r12,8),%rdx
movss  %xmm0,(%rdx,%rax,4)
mov    %rcx,%r12
add    $0xfffffffffffffff8,%rbp
jne    1990 <pinvs+0x840>
cmp    $0x3,%r8
jb     1930 <pinvs+0x7e0>
mov    0x8(%rsp),%rdx
lea    0x0(,%rdx,8),%rbp
add    %r13,%rbp
nopl   0x0(%rax,%rax,1)
movss  0x4(%rsi,%rcx,4),%xmm0
mov    -0x18(%rbp,%rcx,8),%rdx
movss  %xmm0,(%rdx,%rax,4)
movss  0x8(%rsi,%rcx,4),%xmm0
mov    -0x10(%rbp,%rcx,8),%rdx
movss  %xmm0,(%rdx,%rax,4)
movss  0xc(%rsi,%rcx,4),%xmm0
mov    -0x8(%rbp,%rcx,8),%rdx
movss  %xmm0,(%rdx,%rax,4)
movss  0x10(%rsi,%rcx,4),%xmm0
mov    0x0(%rbp,%rcx,8),%rdx
lea    0x4(%rcx),%rbx
movss  %xmm0,(%rdx,%rax,4)
mov    %rbx,%rcx
cmp    %r9,%rbx
jl     19d0 <pinvs+0x880>
jmp    1930 <pinvs+0x7e0>

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

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