int Matrix_Inverse(float *pSrc, unsigned short n, float *pDst) {
  float *pIn = pSrc;
  float *pOut = pDst;
  float *pInT1, *pInT2;
  float *pOutT1, *pOutT2;
  float *pPivotRowIn, *pPRT_in, *pPivotRowDst, *pPRT_pDst;
  float maxC;
  float Xchg, in = 0.0f, in1;
  unsigned int i, rowCnt, flag = 0u, j, loopCnt, k, l;
  int status;
  pOutT1 = pOut;
  rowCnt = n;
  while (rowCnt > 0u) {
    j = n - rowCnt;
    while (j > 0u) {
      *pOutT1++ = 0.0f;
      j--;
    }
    *pOutT1++ = 1.0f;
    j = rowCnt - 1u;
    while (j > 0u) {
      *pOutT1++ = 0.0f;
      j--;
    }
    rowCnt--;
  }
  loopCnt = n;
  l = 0u;
  while (loopCnt > 0u) {
    pInT1 = pIn + (l * n);
    pOutT1 = pOut + (l * n);
    in = *pInT1;
    maxC = 0;
    for (i = l; i < n; i++) {
      maxC = *pInT1 > 0 ? (*pInT1 > maxC ? *pInT1 : maxC)
                        : (-*pInT1 > maxC ? -*pInT1 : maxC);
      pInT1 += n;
    }
    if (maxC == 0.0f) {
      return -1;
    }
    pInT1 = pIn;
    k = 1u;
    if ((in > 0.0f ? in : -in) != maxC) {
      i = n - (l + 1u);
      while (i > 0u) {
        pInT2 = pInT1 + (n * l);
        pOutT2 = pOutT1 + (n * k);
        if ((*pInT2 > 0.0f ? *pInT2 : -*pInT2) == maxC) {
          j = n - l;
          while (j > 0u) {
            Xchg = *pInT2;
            *pInT2++ = *pInT1;
            *pInT1++ = Xchg;
            j--;
          }
          j = n;
          while (j > 0u) {
            Xchg = *pOutT2;
            *pOutT2++ = *pOutT1;
            *pOutT1++ = Xchg;
            j--;
          }
          flag = 1u;
          break;
        }
        k++;
        i--;
      }
    }
    if ((flag != 1u) && (in == 0.0f)) {
      return -1;
    }
    pPivotRowIn = pIn + (l * n);
    pPivotRowDst = pOut + (l * n);
    pInT1 = pPivotRowIn;
    pInT2 = pPivotRowDst;
    in = *pPivotRowIn;
    j = (n - l);
    while (j > 0u) {
      in1 = *pInT1;
      *pInT1++ = in1 / in;
      j--;
    }
    j = n;
    while (j > 0u) {
      in1 = *pInT2;
      *pInT2++ = in1 / in;
      j--;
    }
    pInT1 = pIn;
    pInT2 = pOut;
    i = 0u;
    k = n;
    while (k > 0u) {
      if (i == l) {
        pInT1 += n - l;
        pInT2 += n;
      } else {
        in = *pInT1;
        pPRT_in = pPivotRowIn;
        pPRT_pDst = pPivotRowDst;
        j = (n - l);
        while (j > 0u) {
          in1 = *pInT1;
          *pInT1++ = in1 - (in * *pPRT_in++);
          j--;
        }
        j = n;
        while (j > 0u) {
          in1 = *pInT2;
          *pInT2++ = in1 - (in * *pPRT_pDst++);
          j--;
        }
      }
      pInT1 = pInT1 + l;
      k--;
      i++;
    }
    pIn++;
    loopCnt--;
    l++;
  }
  status = 0;
  if ((flag != 1u) && (in == 0.0f)) {
    status = -1;
  }
  return (status);
}


x86 assembly (clang, -O0):
<Matrix_Inverse>:
push   %rbp
mov    %rsp,%rbp
sub    $0x38,%rsp
mov    %si,%ax
mov    %rdi,-0x10(%rbp)
mov    %ax,-0x12(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x30(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x7c(%rbp)
movl   $0x0,-0x8c(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,-0x48(%rbp)
movzwl -0x12(%rbp),%eax
mov    %eax,-0x88(%rbp)
cmpl   $0x0,-0x88(%rbp)
jbe    1214 <Matrix_Inverse+0x114>
movzwl -0x12(%rbp),%eax
sub    -0x88(%rbp),%eax
mov    %eax,-0x90(%rbp)
cmpl   $0x0,-0x90(%rbp)
jbe    119f <Matrix_Inverse+0x9f>
mov    -0x48(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x48(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax)
mov    -0x90(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x90(%rbp)
jmp    1168 <Matrix_Inverse+0x68>
mov    -0x48(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x48(%rbp)
movss  0xe4a(%rip),%xmm0
movss  %xmm0,(%rax)
mov    -0x88(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x90(%rbp)
cmpl   $0x0,-0x90(%rbp)
jbe    1200 <Matrix_Inverse+0x100>
mov    -0x48(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x48(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax)
mov    -0x90(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x90(%rbp)
jmp    11c9 <Matrix_Inverse+0xc9>
mov    -0x88(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x88(%rbp)
jmp    114b <Matrix_Inverse+0x4b>
movzwl -0x12(%rbp),%eax
mov    %eax,-0x94(%rbp)
movl   $0x0,-0x9c(%rbp)
cmpl   $0x0,-0x94(%rbp)
jbe    192b <Matrix_Inverse+0x82b>
mov    -0x28(%rbp),%rax
mov    -0x9c(%rbp),%ecx
movzwl -0x12(%rbp),%edx
imul   %edx,%ecx
mov    %ecx,%ecx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x9c(%rbp),%ecx
movzwl -0x12(%rbp),%edx
imul   %edx,%ecx
mov    %ecx,%ecx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    -0x38(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x7c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x74(%rbp)
mov    -0x9c(%rbp),%eax
mov    %eax,-0x84(%rbp)
mov    -0x84(%rbp),%eax
movzwl -0x12(%rbp),%ecx
cmp    %ecx,%eax
jae    1396 <Matrix_Inverse+0x296>
mov    -0x38(%rbp),%rax
movss  (%rax),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jbe    1301 <Matrix_Inverse+0x201>
mov    -0x38(%rbp),%rax
movss  (%rax),%xmm0
ucomiss -0x74(%rbp),%xmm0
jbe    12df <Matrix_Inverse+0x1df>
mov    -0x38(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0xa4(%rbp)
ff
jmp    12ec <Matrix_Inverse+0x1ec>
movss  -0x74(%rbp),%xmm0
movss  %xmm0,-0xa4(%rbp)
ff
movss  -0xa4(%rbp),%xmm0
ff
movss  %xmm0,-0xa8(%rbp)
ff
jmp    135f <Matrix_Inverse+0x25f>
mov    -0x38(%rbp),%rax
movss  (%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
ucomiss -0x74(%rbp),%xmm0
jbe    1342 <Matrix_Inverse+0x242>
mov    -0x38(%rbp),%rax
movss  (%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0xac(%rbp)
ff
jmp    134f <Matrix_Inverse+0x24f>
movss  -0x74(%rbp),%xmm0
movss  %xmm0,-0xac(%rbp)
ff
movss  -0xac(%rbp),%xmm0
ff
movss  %xmm0,-0xa8(%rbp)
ff
movss  -0xa8(%rbp),%xmm0
ff
movss  %xmm0,-0x74(%rbp)
movzwl -0x12(%rbp),%ecx
mov    -0x38(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
jmp    1292 <Matrix_Inverse+0x192>
movss  -0x74(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    13b9 <Matrix_Inverse+0x2b9>
jp     13b9 <Matrix_Inverse+0x2b9>
movl   $0xffffffff,-0x4(%rbp)
jmp    196c <Matrix_Inverse+0x86c>
mov    -0x28(%rbp),%rax
mov    %rax,-0x38(%rbp)
movl   $0x1,-0x98(%rbp)
movss  -0x7c(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jbe    13ee <Matrix_Inverse+0x2ee>
movss  -0x7c(%rbp),%xmm0
movss  %xmm0,-0xb0(%rbp)
ff
jmp    1408 <Matrix_Inverse+0x308>
movss  -0x7c(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0xb0(%rbp)
ff
movss  -0xb0(%rbp),%xmm0
ff
ucomiss -0x74(%rbp),%xmm0
jne    1425 <Matrix_Inverse+0x325>
jp     1425 <Matrix_Inverse+0x325>
jmp    15f0 <Matrix_Inverse+0x4f0>
movzwl -0x12(%rbp),%eax
mov    -0x9c(%rbp),%ecx
add    $0x1,%ecx
sub    %ecx,%eax
mov    %eax,-0x84(%rbp)
cmpl   $0x0,-0x84(%rbp)
jbe    15eb <Matrix_Inverse+0x4eb>
mov    -0x38(%rbp),%rax
movzwl -0x12(%rbp),%ecx
imul   -0x9c(%rbp),%ecx
mov    %ecx,%ecx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    -0x48(%rbp),%rax
movzwl -0x12(%rbp),%ecx
imul   -0x98(%rbp),%ecx
mov    %ecx,%ecx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
mov    -0x40(%rbp),%rax
movss  (%rax),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jbe    14a8 <Matrix_Inverse+0x3a8>
mov    -0x40(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0xb4(%rbp)
ff
jmp    14c5 <Matrix_Inverse+0x3c5>
mov    -0x40(%rbp),%rax
movss  (%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0xb4(%rbp)
ff
movss  -0xb4(%rbp),%xmm0
ff
ucomiss -0x74(%rbp),%xmm0
jne    15c8 <Matrix_Inverse+0x4c8>
jp     15c8 <Matrix_Inverse+0x4c8>
movzwl -0x12(%rbp),%eax
sub    -0x9c(%rbp),%eax
mov    %eax,-0x90(%rbp)
cmpl   $0x0,-0x90(%rbp)
jbe    154e <Matrix_Inverse+0x44e>
mov    -0x40(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x78(%rbp)
mov    -0x38(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x40(%rbp)
movss  %xmm0,(%rax)
movss  -0x78(%rbp),%xmm0
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x38(%rbp)
movss  %xmm0,(%rax)
mov    -0x90(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x90(%rbp)
jmp    14ed <Matrix_Inverse+0x3ed>
movzwl -0x12(%rbp),%eax
mov    %eax,-0x90(%rbp)
cmpl   $0x0,-0x90(%rbp)
jbe    15b9 <Matrix_Inverse+0x4b9>
mov    -0x50(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x78(%rbp)
mov    -0x48(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x50(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x50(%rbp)
movss  %xmm0,(%rax)
movss  -0x78(%rbp),%xmm0
mov    -0x48(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x48(%rbp)
movss  %xmm0,(%rax)
mov    -0x90(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x90(%rbp)
jmp    1558 <Matrix_Inverse+0x458>
movl   $0x1,-0x8c(%rbp)
jmp    15eb <Matrix_Inverse+0x4eb>
mov    -0x98(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x98(%rbp)
mov    -0x84(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x84(%rbp)
jmp    143a <Matrix_Inverse+0x33a>
jmp    15f0 <Matrix_Inverse+0x4f0>
cmpl   $0x1,-0x8c(%rbp)
je     1620 <Matrix_Inverse+0x520>
movss  -0x7c(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    1620 <Matrix_Inverse+0x520>
jp     1620 <Matrix_Inverse+0x520>
movl   $0xffffffff,-0x4(%rbp)
jmp    196c <Matrix_Inverse+0x86c>
mov    -0x28(%rbp),%rax
mov    -0x9c(%rbp),%ecx
movzwl -0x12(%rbp),%edx
imul   %edx,%ecx
mov    %ecx,%ecx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x58(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x9c(%rbp),%ecx
movzwl -0x12(%rbp),%edx
imul   %edx,%ecx
mov    %ecx,%ecx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x68(%rbp)
mov    -0x58(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x68(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x58(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x7c(%rbp)
movzwl -0x12(%rbp),%eax
sub    -0x9c(%rbp),%eax
mov    %eax,-0x90(%rbp)
cmpl   $0x0,-0x90(%rbp)
jbe    16d4 <Matrix_Inverse+0x5d4>
mov    -0x38(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x80(%rbp)
movss  -0x80(%rbp),%xmm0
divss  -0x7c(%rbp),%xmm0
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x38(%rbp)
movss  %xmm0,(%rax)
mov    -0x90(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x90(%rbp)
jmp    1689 <Matrix_Inverse+0x589>
movzwl -0x12(%rbp),%eax
mov    %eax,-0x90(%rbp)
cmpl   $0x0,-0x90(%rbp)
jbe    1729 <Matrix_Inverse+0x629>
mov    -0x40(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x80(%rbp)
movss  -0x80(%rbp),%xmm0
divss  -0x7c(%rbp),%xmm0
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x40(%rbp)
movss  %xmm0,(%rax)
mov    -0x90(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x90(%rbp)
jmp    16de <Matrix_Inverse+0x5de>
mov    -0x28(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,-0x40(%rbp)
movl   $0x0,-0x84(%rbp)
movzwl -0x12(%rbp),%eax
mov    %eax,-0x98(%rbp)
cmpl   $0x0,-0x98(%rbp)
jbe    18fc <Matrix_Inverse+0x7fc>
mov    -0x84(%rbp),%eax
cmp    -0x9c(%rbp),%eax
jne    17a2 <Matrix_Inverse+0x6a2>
movzwl -0x12(%rbp),%ecx
sub    -0x9c(%rbp),%ecx
mov    -0x38(%rbp),%rax
mov    %ecx,%ecx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
movzwl -0x12(%rbp),%ecx
mov    -0x40(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
jmp    18c4 <Matrix_Inverse+0x7c4>
mov    -0x38(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x7c(%rbp)
mov    -0x58(%rbp),%rax
mov    %rax,-0x60(%rbp)
mov    -0x68(%rbp),%rax
mov    %rax,-0x70(%rbp)
movzwl -0x12(%rbp),%eax
sub    -0x9c(%rbp),%eax
mov    %eax,-0x90(%rbp)
cmpl   $0x0,-0x90(%rbp)
jbe    1842 <Matrix_Inverse+0x742>
mov    -0x38(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x80(%rbp)
movss  -0x80(%rbp),%xmm1
movss  -0x7c(%rbp),%xmm0
mov    -0x60(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x60(%rbp)
movss  (%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x38(%rbp)
movss  %xmm0,(%rax)
mov    -0x90(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x90(%rbp)
jmp    17cf <Matrix_Inverse+0x6cf>
movzwl -0x12(%rbp),%eax
mov    %eax,-0x90(%rbp)
cmpl   $0x0,-0x90(%rbp)
jbe    18bf <Matrix_Inverse+0x7bf>
mov    -0x40(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x80(%rbp)
movss  -0x80(%rbp),%xmm1
movss  -0x7c(%rbp),%xmm0
mov    -0x70(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x70(%rbp)
movss  (%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x40(%rbp)
movss  %xmm0,(%rax)
mov    -0x90(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x90(%rbp)
jmp    184c <Matrix_Inverse+0x74c>
jmp    18c4 <Matrix_Inverse+0x7c4>
mov    -0x38(%rbp),%rax
mov    -0x9c(%rbp),%ecx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x98(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x98(%rbp)
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
jmp    174d <Matrix_Inverse+0x64d>
mov    -0x28(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x28(%rbp)
mov    -0x94(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x94(%rbp)
mov    -0x9c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c(%rbp)
jmp    1228 <Matrix_Inverse+0x128>
movl   $0x0,-0xa0(%rbp)
cmpl   $0x1,-0x8c(%rbp)
je     1963 <Matrix_Inverse+0x863>
movss  -0x7c(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    1963 <Matrix_Inverse+0x863>
jp     1963 <Matrix_Inverse+0x863>
movl   $0xffffffff,-0xa0(%rbp)
ff ff ff
mov    -0xa0(%rbp),%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x38,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<Matrix_Inverse>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x158,%rsp
mov    %rdi,0x58(%rsp)
xorps  %xmm10,%xmm10
xorps  %xmm2,%xmm2
test   %esi,%esi
je     1d80 <Matrix_Inverse+0xc70>
mov    %rdx,%r13
mov    %esi,%r10d
movl   $0x3f800000,(%rdx)
add    $0xffffffff,%r10d
mov    %rdx,0x68(%rsp)
mov    %rsi,0x18(%rsp)
mov    %r10,0x28(%rsp)
je     13c0 <Matrix_Inverse+0x2b0>
lea    0x0(,%r10,4),%rbp
lea    0x4(%r13),%rdi
lea    -0x2(%rsi),%ebx
xor    %esi,%esi
mov    %rbp,%rdx
call   1030 <memset@plt>
mov    0x28(%rsp),%r10
mov    0x18(%rsp),%rsi
xorps  %xmm10,%xmm10
movabs $0x3f80000000000000,%rax
mov    %rax,0x8(%r13,%rbx,4)
test   %ebx,%ebx
je     13c0 <Matrix_Inverse+0x2b0>
lea    0xc(,%rbx,4),%rcx
add    %r13,%rcx
lea    -0x3(%rsi),%r9d
mov    $0x1,%r8d
cmp    $0x3,%si
je     135c <Matrix_Inverse+0x24c>
mov    %rbp,0x70(%rsp)
lea    -0x8(%rbp),%rdx
add    $0xfffffffc,%esi
mov    %ebx,%eax
and    $0xfffffffe,%eax
mov    %rax,0x60(%rsp)
mov    $0xc,%ebp
mov    $0x14,%edi
xor    %r12d,%r12d
mov    %r10d,%eax
mov    %r9d,(%rsp)
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %eax,0x20(%rsp)
mov    %rdi,0x40(%rsp)
mov    %rdx,0x8(%rsp)
mov    %rsi,0x48(%rsp)
mov    %rbx,0x10(%rsp)
mov    %rcx,%r15
mov    %r12,%r13
mov    (%rsp),%r14d
mov    %r14d,%ecx
mov    %rcx,0x80(%rsp)
mov    %esi,%eax
mov    %rax,0x30(%rsp)
lea    0x0(,%rax,4),%rax
lea    (%rax,%rcx,4),%rax
mov    %rax,0x38(%rsp)
lea    0x1(%rsi),%r12d
lea    0x4(%r15),%rdi
add    $0x4,%rdx
xor    %esi,%esi
call   1030 <memset@plt>
lea    (%r15,%r12,4),%rax
mov    %rax,0x78(%rsp)
lea    (%r15,%r12,4),%rdi
add    $0x8,%rdi
mov    %r13d,%ebx
or     $0x1,%ebx
lea    -0x4(%rbp),%rdx
xor    %esi,%esi
call   1030 <memset@plt>
mov    0x78(%rsp),%rax
lea    (%rax,%rbx,4),%rax
add    $0x8,%rax
mov    0x30(%rsp),%rcx
lea    (%rax,%rcx,4),%rax
mov    %rax,0x30(%rsp)
mov    0x80(%rsp),%rax
lea    (%r15,%rax,4),%rax
movl   $0x3f800000,0x10(%rax,%r13,4)
80 3f
lea    (%rax,%r13,4),%rdi
add    $0x14,%rdi
xor    %esi,%esi
mov    0x8(%rsp),%rdx
call   1030 <memset@plt>
lea    0x2(%r13),%r12
add    $0xfffffffe,%r14d
mov    %r14d,(%rsp)
mov    0x38(%rsp),%rax
add    %r15,%rax
lea    (%rax,%r13,4),%rdi
add    $0x18,%rdi
mov    %rax,%rbx
xor    %esi,%esi
mov    %rbp,%rdx
call   1030 <memset@plt>
mov    0x20(%rsp),%eax
mov    0x40(%rsp),%rdi
mov    0x8(%rsp),%rdx
mov    0x48(%rsp),%rsi
mov    0x30(%rsp),%rcx
lea    (%rcx,%r13,4),%rcx
add    $0x18,%rcx
movl   $0x3f800000,0x24(%rbx,%r13,8)
80 3f
mov    0x10(%rsp),%rbx
add    $0x8,%rbp
add    $0xfffffffffffffff8,%rdx
add    $0x10,%rdi
add    $0xfffffffe,%eax
add    $0xfffffffe,%ebx
add    $0xfffffffe,%esi
cmp    %r12d,0x60(%rsp)
jne    11f0 <Matrix_Inverse+0xe0>
add    $0x1,%r12
mov    %r12,%r8
mov    %eax,%eax
lea    (%rdi,%rax,4),%rax
mov    %ebx,%ecx
lea    (%rax,%rcx,4),%rax
add    %rax,%r15
add    $0x1,%esi
mov    %r15,%rcx
mov    %esi,%r9d
xorps  %xmm10,%xmm10
mov    0x68(%rsp),%r13
mov    0x18(%rsp),%rsi
mov    0x28(%rsp),%r10
mov    0x70(%rsp),%rbp
test   $0x1,%sil
je     13c0 <Matrix_Inverse+0x2b0>
lea    0x4(%rcx),%rdi
mov    %r8,%rbx
lea    0x0(,%r8,4),%rax
sub    %rax,%rbp
mov    %r9d,%r15d
xor    %esi,%esi
mov    %rbp,%rdx
mov    %rcx,%rbp
call   1030 <memset@plt>
lea    0x0(,%r15,4),%r14
add    %rbp,%r14
lea    0x8(,%r15,4),%rdi
add    %rbp,%rdi
lea    0x4(,%rbx,4),%rdx
xor    %esi,%esi
call   1030 <memset@plt>
mov    0x28(%rsp),%r10
mov    0x18(%rsp),%rsi
xorps  %xmm10,%xmm10
movl   $0x3f800000,0xc(%r14,%rbx,4)
80 3f
movabs $0x1fffffff8,%r15
movzwl %si,%r8d
mov    %r10d,%edx
add    $0x1,%rdx
mov    $0xfffffffe,%ecx
add    %r8,%rcx
mov    %rcx,0xf8(%rsp)
mov    0x58(%rsp),%r11
lea    0x4(%r11),%rcx
mov    %rcx,0xf0(%rsp)
lea    0x4(%r15),%r9
and    %rdx,%r9
lea    -0x4(%r9),%rcx
mov    %rcx,0xd8(%rsp)
mov    %rcx,%rbp
shr    $0x2,%rbp
add    $0x1,%rbp
mov    %rdx,%rcx
mov    %rdx,0x20(%rsp)
and    $0xfffffffffffffff8,%rdx
lea    -0x8(%rdx),%rcx
mov    %rcx,0x148(%rsp)
mov    %rcx,%rax
shr    $0x3,%rax
add    $0x1,%rax
mov    %esi,%edi
mov    %r9,%rcx
mov    %r9,0x98(%rsp)
sub    %r9d,%edi
mov    %edi,0x88(%rsp)
mov    %rbp,%rcx
mov    %rbp,0xd0(%rsp)
and    $0xfffffffffffffffe,%rbp
mov    %rbp,0xc8(%rsp)
mov    %esi,%edi
mov    %rdx,%rcx
mov    %rdx,0x60(%rsp)
sub    %edx,%edi
mov    %edi,0x94(%rsp)
mov    %rax,%rcx
mov    %rax,0x140(%rsp)
and    $0xfffffffffffffffe,%rax
mov    %rax,0x128(%rsp)
xorps  %xmm9,%xmm9
movaps 0xb65(%rip),%xmm8
lea    0x0(,%r8,4),%r10
lea    0x4(,%r8,4),%rbx
lea    0x8(%r11),%rax
mov    %rax,0xe8(%rsp)
mov    %r8,0x38(%rsp)
lea    (%r11,%r8,4),%rax
mov    %rax,0xa8(%rsp)
lea    0x14(%r11),%rax
mov    %rax,0xa0(%rsp)
lea    -0x2(%rsi),%ecx
lea    0x10(%r13),%rdx
lea    0x34(%r11),%r9
lea    0x30(%r13),%r8
xor    %r11d,%r11d
mov    %esi,%eax
mov    %esi,0x54(%rsp)
mov    %r10,0xb0(%rsp)
mov    %rbx,0xe0(%rsp)
jmp    155f <Matrix_Inverse+0x44f>
xchg   %ax,%ax
addq   $0x4,0x58(%rsp)
add    $0x1,%r11
mov    0xe0(%rsp),%rbx
add    %rbx,0xa8(%rsp)
add    %rbx,0xa0(%rsp)
mov    0x8c(%rsp),%ecx
add    $0xffffffff,%ecx
mov    0xb0(%rsp),%r10
mov    0xb8(%rsp),%rdx
add    %r10,%rdx
add    %rbx,%r9
add    %r10,%r8
addl   $0xffffffff,0x54(%rsp)
mov    0x68(%rsp),%r13
movabs $0x1fffffff8,%r15
je     1d80 <Matrix_Inverse+0xc70>
mov    0x38(%rsp),%rsi
cmp    %rsi,%r11
jae    1d8e <Matrix_Inverse+0xc7e>
movl   $0xffffffff,0x8(%rsp)
ff
mov    %rdx,0xb8(%rsp)
mov    %ecx,0x8c(%rsp)
mov    %ecx,%edx
add    $0x1,%rdx
mov    %rdx,%rcx
and    $0xfffffffffffffff8,%rcx
add    $0xfffffffffffffff8,%rcx
shr    $0x3,%rcx
add    $0x1,%rcx
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0x100(%rsp)
and    $0xfffffffffffffffc,%rdx
add    $0xfffffffffffffffc,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
and    $0xfffffffffffffffe,%rdx
mov    0xf8(%rsp),%rcx
mov    %ecx,%edi
sub    %r11d,%edi
add    $0x1,%rdi
and    %r15,%rdi
add    $0xfffffffffffffff8,%rdi
mov    %rdi,0x120(%rsp)
shr    $0x3,%rdi
add    $0x1,%rdi
mov    %rdi,0x118(%rsp)
mov    %ecx,%r14d
sub    %r11d,%r14d
add    $0x1,%r14
lea    0x4(%r15),%rbp
mov    %rbp,0x48(%rsp)
and    %rbp,%r14
add    $0xfffffffffffffffc,%r14
mov    %r14,%rdi
shr    $0x2,%rdi
add    $0x1,%rdi
mov    %ecx,%eax
sub    %r11d,%eax
mov    %ecx,%r15d
sub    %r11d,%r15d
mov    %ecx,%r12d
sub    %r11d,%r12d
mov    %rbx,%rcx
imul   %r11,%rcx
mov    0xf0(%rsp),%r10
lea    (%r10,%rcx,1),%rbx
mov    %rbx,0x130(%rsp)
mov    0xb0(%rsp),%rbx
add    0xe8(%rsp),%rcx
mov    %r12,0x138(%rsp)
lea    (%rcx,%r12,4),%rcx
mov    %rcx,0x150(%rsp)
mov    %r11,%rcx
imul   %rsi,%rcx
lea    0x0(,%rcx,4),%rbp
add    %r13,%rbp
mov    %rbp,0x78(%rsp)
add    0x20(%rsp),%rcx
lea    0x0(,%rcx,4),%rcx
add    %r13,%rcx
mov    %rcx,0x30(%rsp)
mov    %r11d,%ecx
imul   0x18(%rsp),%ecx
mov    0x58(%rsp),%rsi
movss  (%rsi,%rcx,4),%xmm2
lea    (%rsi,%rcx,4),%rsi
mov    %rsi,(%rsp)
lea    0x0(%r13,%rcx,4),%rcx
mov    %rax,%r13
mov    %rcx,0x10(%rsp)
xorps  %xmm3,%xmm3
movaps %xmm2,%xmm4
lea    0x1(%rax),%r10
mov    %r15,0x80(%rsp)
lea    0x1(%r15),%rcx
mov    %rcx,0xc0(%rsp)
mov    $0x1,%ecx
mov    0xa8(%rsp),%rbp
mov    0x54(%rsp),%esi
ucomiss %xmm9,%xmm4
ja     16f4 <Matrix_Inverse+0x5e4>
nopw   0x0(%rax,%rax,1)
xorps  %xmm8,%xmm4
maxss  %xmm3,%xmm4
movaps %xmm4,%xmm3
cmp    %ecx,%esi
je     1720 <Matrix_Inverse+0x610>
movss  0x0(%rbp),%xmm4
add    $0x1,%ecx
add    %rbx,%rbp
ucomiss %xmm9,%xmm4
jbe    16f0 <Matrix_Inverse+0x5e0>
jmp    16f4 <Matrix_Inverse+0x5e4>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
ucomiss %xmm9,%xmm3
jne    172c <Matrix_Inverse+0x61c>
jnp    1d96 <Matrix_Inverse+0xc86>
ucomiss %xmm9,%xmm2
jne    1738 <Matrix_Inverse+0x628>
jnp    1d96 <Matrix_Inverse+0xc86>
mov    0x18(%rsp),%rax
sub    %r11d,%eax
mov    %rax,0x8(%rsp)
mov    0xa0(%rsp),%rsi
je     17f6 <Matrix_Inverse+0x6e6>
movaps %xmm2,%xmm3
divss  %xmm2,%xmm3
mov    (%rsp),%rax
movss  %xmm3,(%rax)
mov    0x8(%rsp),%rax
mov    %eax,%r12d
add    $0xffffffff,%r12d
je     17f6 <Matrix_Inverse+0x6e6>
mov    (%rsp),%rax
add    $0x4,%rax
cmp    $0x3,%r13d
jb     17da <Matrix_Inverse+0x6ca>
movaps %xmm2,%xmm3
shufps $0x0,%xmm2,%xmm3
xor    %ecx,%ecx
test   %r14,%r14
je     17b2 <Matrix_Inverse+0x6a2>
movups -0x10(%rsi,%rcx,4),%xmm4
movups (%rsi,%rcx,4),%xmm5
divps  %xmm3,%xmm4
movups %xmm4,-0x10(%rsi,%rcx,4)
divps  %xmm3,%xmm5
movups %xmm5,(%rsi,%rcx,4)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rdx
jne    1790 <Matrix_Inverse+0x680>
mov    0x48(%rsp),%rdx
and    %r10,%rdx
test   $0x1,%dil
je     17cb <Matrix_Inverse+0x6bb>
movups (%rax,%rcx,4),%xmm4
divps  %xmm3,%xmm4
movups %xmm4,(%rax,%rcx,4)
cmp    %rdx,%r10
je     17f6 <Matrix_Inverse+0x6e6>
mov    %rdx,%rcx
sub    %ecx,%r12d
lea    (%rax,%rdx,4),%rax
mov    %r12d,%ecx
xor    %edx,%edx
nop
movss  (%rax,%rdx,4),%xmm3
divss  %xmm2,%xmm3
movss  %xmm3,(%rax,%rdx,4)
add    $0x1,%rdx
cmp    %edx,%ecx
jne    17e0 <Matrix_Inverse+0x6d0>
mov    0x18(%rsp),%rsi
mov    %esi,%ecx
mov    0x10(%rsp),%rax
mov    0x28(%rsp),%r10
cmp    $0x3,%r10d
movabs $0x1fffffff8,%rdi
jb     18b3 <Matrix_Inverse+0x7a3>
movaps %xmm2,%xmm3
shufps $0x0,%xmm2,%xmm3
cmpq   $0x0,0xd8(%rsp)
je     1d6b <Matrix_Inverse+0xc5b>
mov    0xc8(%rsp),%rcx
xor    %eax,%eax
mov    0xb8(%rsp),%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups -0x10(%rdx,%rax,4),%xmm4
movups (%rdx,%rax,4),%xmm5
divps  %xmm3,%xmm4
movups %xmm4,-0x10(%rdx,%rax,4)
divps  %xmm3,%xmm5
movups %xmm5,(%rdx,%rax,4)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    1850 <Matrix_Inverse+0x740>
testb  $0x1,0xd0(%rsp)
01
je     188c <Matrix_Inverse+0x77c>
mov    0x10(%rsp),%rcx
movups (%rcx,%rax,4),%xmm4
divps  %xmm3,%xmm4
movups %xmm4,(%rcx,%rax,4)
mov    0x98(%rsp),%rax
cmp    %rax,0x20(%rsp)
je     18d6 <Matrix_Inverse+0x7c6>
mov    0x98(%rsp),%rax
mov    0x10(%rsp),%rcx
lea    (%rcx,%rax,4),%rax
mov    0x88(%rsp),%ecx
mov    %ecx,%ecx
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movss  (%rax,%rdx,4),%xmm3
divss  %xmm2,%xmm3
movss  %xmm3,(%rax,%rdx,4)
add    $0x1,%rdx
cmp    %edx,%ecx
jne    18c0 <Matrix_Inverse+0x7b0>
mov    0x8(%rsp),%rax
mov    %eax,%ecx
mov    %rcx,0x48(%rsp)
add    $0xffffffff,%eax
mov    0xc0(%rsp),%rcx
and    %rdi,%rcx
mov    %eax,0x40(%rsp)
sub    %ecx,%eax
mov    %eax,0x90(%rsp)
mov    (%rsp),%rax
mov    %rcx,0x110(%rsp)
lea    (%rax,%rcx,4),%rax
mov    %rax,0x108(%rsp)
mov    0x60(%rsp),%rax
mov    0x10(%rsp),%rcx
lea    (%rcx,%rax,4),%rax
mov    %rax,0x70(%rsp)
xor    %r13d,%r13d
mov    %esi,%r12d
mov    0x58(%rsp),%r15
mov    0x68(%rsp),%rdx
mov    0x38(%rsp),%rbx
jmp    195f <Matrix_Inverse+0x84f>
nop
mov    0x48(%rsp),%rax
lea    (%r15,%rax,4),%r15
lea    (%rdx,%rbx,4),%rdx
lea    (%r15,%r11,4),%r15
add    $0x1,%r13d
add    $0xffffffff,%r12d
je     1500 <Matrix_Inverse+0x3f0>
mov    %r13d,%eax
cmp    %rax,%r11
je     1940 <Matrix_Inverse+0x830>
movss  (%r15),%xmm2
movaps %xmm2,%xmm3
xorps  %xmm8,%xmm3
cmpl   $0x0,0x8(%rsp)
je     1a95 <Matrix_Inverse+0x985>
lea    0x4(%r15),%r14
mov    (%rsp),%rax
movss  (%rax),%xmm4
mulss  %xmm3,%xmm4
addss  %xmm2,%xmm4
movss  %xmm4,(%r15)
cmpl   $0x0,0x40(%rsp)
je     1a92 <Matrix_Inverse+0x982>
cmpl   $0x7,0x80(%rsp)
07
jb     19d8 <Matrix_Inverse+0x8c8>
cmp    %r14,0x150(%rsp)
jbe    1c4a <Matrix_Inverse+0xb3a>
mov    0x138(%rsp),%rax
lea    (%r15,%rax,4),%rax
add    $0x8,%rax
cmp    %rax,0x130(%rsp)
jae    1c4a <Matrix_Inverse+0xb3a>
mov    0x40(%rsp),%eax
mov    (%rsp),%rbp
lea    -0x1(%rax),%r10d
mov    %eax,%ecx
and    $0x3,%ecx
je     1a14 <Matrix_Inverse+0x904>
xor    %esi,%esi
nopl   (%rax)
movss  0x4(%rbp),%xmm0
mulss  %xmm3,%xmm0
add    $0x4,%rbp
addss  (%r14),%xmm0
movss  %xmm0,(%r14)
add    $0x4,%r14
add    $0x1,%esi
cmp    %esi,%ecx
jne    19f0 <Matrix_Inverse+0x8e0>
sub    %esi,%eax
mov    %r14,%r15
cmp    $0x3,%r10d
mov    0x18(%rsp),%rsi
mov    0x28(%rsp),%r10
jb     1a95 <Matrix_Inverse+0x985>
mov    %eax,%eax
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
movss  0x4(%rbp,%rcx,4),%xmm0
mulss  %xmm3,%xmm0
addss  (%r14),%xmm0
movss  %xmm0,(%r14)
movss  0x8(%rbp,%rcx,4),%xmm0
mulss  %xmm3,%xmm0
addss  0x4(%r14),%xmm0
movss  %xmm0,0x4(%r14)
movss  0xc(%rbp,%rcx,4),%xmm0
mulss  %xmm3,%xmm0
addss  0x8(%r14),%xmm0
movss  %xmm0,0x8(%r14)
movss  0x10(%rbp,%rcx,4),%xmm0
mulss  %xmm3,%xmm0
addss  0xc(%r14),%xmm0
movss  %xmm0,0xc(%r14)
add    $0x10,%r14
add    $0x4,%rcx
cmp    %ecx,%eax
jne    1a30 <Matrix_Inverse+0x920>
mov    %r14,%r15
cmp    $0x7,%r10d
jb     1aba <Matrix_Inverse+0x9aa>
cmp    0x30(%rsp),%rdx
jae    1b6f <Matrix_Inverse+0xa5f>
mov    0x20(%rsp),%rax
lea    (%rdx,%rax,4),%rax
cmp    %rax,0x78(%rsp)
jae    1b6f <Matrix_Inverse+0xa5f>
mov    %esi,%eax
mov    0x10(%rsp),%rbp
lea    -0x1(%rax),%ecx
mov    %eax,%edi
and    $0x3,%edi
je     1af7 <Matrix_Inverse+0x9e7>
xor    %ebx,%ebx
nopl   (%rax)
movss  0x0(%rbp),%xmm0
mulss  %xmm3,%xmm0
add    $0x4,%rbp
addss  (%rdx),%xmm0
movss  %xmm0,(%rdx)
add    $0x4,%rdx
add    $0x1,%ebx
cmp    %ebx,%edi
jne    1ad0 <Matrix_Inverse+0x9c0>
sub    %ebx,%eax
mov    0x38(%rsp),%rbx
cmp    $0x3,%ecx
jb     194d <Matrix_Inverse+0x83d>
mov    %eax,%eax
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  0x0(%rbp,%rcx,4),%xmm0
mulss  %xmm3,%xmm0
addss  (%rdx),%xmm0
movss  %xmm0,(%rdx)
movss  0x4(%rbp,%rcx,4),%xmm0
mulss  %xmm3,%xmm0
addss  0x4(%rdx),%xmm0
movss  %xmm0,0x4(%rdx)
movss  0x8(%rbp,%rcx,4),%xmm0
mulss  %xmm3,%xmm0
addss  0x8(%rdx),%xmm0
movss  %xmm0,0x8(%rdx)
movss  0xc(%rbp,%rcx,4),%xmm0
mulss  %xmm3,%xmm0
addss  0xc(%rdx),%xmm0
movss  %xmm0,0xc(%rdx)
add    $0x10,%rdx
add    $0x4,%rcx
cmp    %ecx,%eax
jne    1b10 <Matrix_Inverse+0xa00>
jmp    194d <Matrix_Inverse+0x83d>
movaps %xmm3,%xmm4
shufps $0x0,%xmm3,%xmm4
cmpq   $0x0,0x148(%rsp)
je     1d44 <Matrix_Inverse+0xc34>
mov    0x128(%rsp),%rcx
xor    %eax,%eax
nop
movups -0x30(%r8,%rax,4),%xmm0
movups -0x20(%r8,%rax,4),%xmm1
mulps  %xmm4,%xmm0
movups (%rdx,%rax,4),%xmm5
addps  %xmm0,%xmm5
movups 0x10(%rdx,%rax,4),%xmm0
movups 0x20(%rdx,%rax,4),%xmm6
movups 0x30(%rdx,%rax,4),%xmm7
mulps  %xmm4,%xmm1
addps  %xmm0,%xmm1
movups %xmm5,(%rdx,%rax,4)
movups %xmm1,0x10(%rdx,%rax,4)
movups -0x10(%r8,%rax,4),%xmm0
movups (%r8,%rax,4),%xmm1
mulps  %xmm4,%xmm0
addps  %xmm6,%xmm0
mulps  %xmm4,%xmm1
addps  %xmm7,%xmm1
movups %xmm0,0x20(%rdx,%rax,4)
movups %xmm1,0x30(%rdx,%rax,4)
add    $0x10,%rax
add    $0xfffffffffffffffe,%rcx
jne    1b90 <Matrix_Inverse+0xa80>
testb  $0x1,0x140(%rsp)
01
je     1c25 <Matrix_Inverse+0xb15>
movups (%rdx,%rax,4),%xmm0
movups 0x10(%rdx,%rax,4),%xmm1
mov    0x10(%rsp),%rcx
movups (%rcx,%rax,4),%xmm5
movups 0x10(%rcx,%rax,4),%xmm6
mulps  %xmm4,%xmm5
addps  %xmm0,%xmm5
mulps  %xmm4,%xmm6
addps  %xmm1,%xmm6
movups %xmm5,(%rdx,%rax,4)
movups %xmm6,0x10(%rdx,%rax,4)
mov    0x60(%rsp),%rcx
lea    (%rdx,%rcx,4),%rdx
mov    0x94(%rsp),%eax
mov    0x70(%rsp),%rbp
cmp    %rcx,0x20(%rsp)
je     194d <Matrix_Inverse+0x83d>
jmp    1ac1 <Matrix_Inverse+0x9b1>
movaps %xmm3,%xmm4
shufps $0x0,%xmm3,%xmm4
cmpq   $0x0,0x120(%rsp)
je     1d59 <Matrix_Inverse+0xc49>
mov    0x100(%rsp),%rcx
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
movups -0x30(%r9,%rax,4),%xmm5
movups -0x20(%r9,%rax,4),%xmm6
mulps  %xmm4,%xmm5
movups 0x4(%r15,%rax,4),%xmm7
addps  %xmm5,%xmm7
movups 0x14(%r15,%rax,4),%xmm5
movups 0x24(%r15,%rax,4),%xmm1
movups 0x34(%r15,%rax,4),%xmm0
mulps  %xmm4,%xmm6
addps  %xmm5,%xmm6
movups %xmm7,0x4(%r15,%rax,4)
movups %xmm6,0x14(%r15,%rax,4)
movups -0x10(%r9,%rax,4),%xmm5
movups (%r9,%rax,4),%xmm6
mulps  %xmm4,%xmm5
addps  %xmm1,%xmm5
mulps  %xmm4,%xmm6
addps  %xmm0,%xmm6
movups %xmm5,0x24(%r15,%rax,4)
movups %xmm6,0x34(%r15,%rax,4)
add    $0x10,%rax
add    $0xfffffffffffffffe,%rcx
jne    1c70 <Matrix_Inverse+0xb60>
testb  $0x1,0x118(%rsp)
01
je     1d13 <Matrix_Inverse+0xc03>
movups (%r14,%rax,4),%xmm0
movups 0x10(%r14,%rax,4),%xmm1
mov    (%rsp),%rcx
movups 0x4(%rcx,%rax,4),%xmm5
movups 0x14(%rcx,%rax,4),%xmm6
mulps  %xmm4,%xmm5
addps  %xmm0,%xmm5
mulps  %xmm4,%xmm6
addps  %xmm1,%xmm6
movups %xmm5,(%r14,%rax,4)
movups %xmm6,0x10(%r14,%rax,4)
mov    0x110(%rsp),%rcx
lea    (%r14,%rcx,4),%r14
mov    0x90(%rsp),%eax
mov    0x108(%rsp),%rbp
mov    %r14,%r15
cmp    %rcx,0xc0(%rsp)
jne    19e0 <Matrix_Inverse+0x8d0>
jmp    1a95 <Matrix_Inverse+0x985>
xor    %eax,%eax
testb  $0x1,0x140(%rsp)
01
jne    1bf9 <Matrix_Inverse+0xae9>
jmp    1c25 <Matrix_Inverse+0xb15>
xor    %eax,%eax
testb  $0x1,0x118(%rsp)
01
jne    1ce3 <Matrix_Inverse+0xbd3>
jmp    1d13 <Matrix_Inverse+0xc03>
xor    %eax,%eax
testb  $0x1,0xd0(%rsp)
01
jne    187c <Matrix_Inverse+0x76c>
jmp    188c <Matrix_Inverse+0x77c>
cmpeqss %xmm10,%xmm2
movss  %xmm2,0x8(%rsp)
jmp    1d96 <Matrix_Inverse+0xc86>
movl   $0xffffffff,0x8(%rsp)
ff
mov    0x8(%rsp),%eax
add    $0x158,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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