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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int imatrix_solve_n_m(const double A[], const double B[], double X[], int n,
                      int m, void *workmem) {
  unsigned char *buffer = (unsigned char *)workmem;
  int *js, l, k, i, j, is, p, q;
  double *a, *b, d, t;
  if (workmem == NULL) {
    return sizeof(int) * n + sizeof(double) * (m * n + n * n);
  }
  a = (double *)(buffer + sizeof(int) * n);
  b = (double *)(buffer + sizeof(int) * n + sizeof(double) * n * n);
  for (i = n * n - 1; i >= 0; i--)
    a[i] = A[i];
  for (i = m * n - 1; i >= 0; i--)
    b[i] = B[i];
  js = (int *)workmem;
  is = 0;
  l = 1;
  for (k = 0; k <= n - 1; k++) {
    d = 0.0;
    for (i = k; i <= n - 1; i++) {
      for (j = k; j <= n - 1; j++) {
        t = a[i * n + j];
        if (t < 0)
          t = -t;
        if (t > d) {
          d = t;
          js[k] = j;
          is = i;
        }
      }
    }
    if (d + 1.0 == 1.0)
      l = 0;
    else {
      if (js[k] != k) {
        for (i = 0; i <= n - 1; i++) {
          p = i * n + k;
          q = i * n + js[k];
          t = a[p];
          a[p] = a[q];
          a[q] = t;
        }
      }
      if (is != k) {
        for (j = k; j <= n - 1; j++) {
          p = k * n + j;
          q = is * n + j;
          t = a[p];
          a[p] = a[q];
          a[q] = t;
        }
        for (j = 0; j <= m - 1; j++) {
          p = k * m + j;
          q = is * m + j;
          t = b[p];
          b[p] = b[q];
          b[q] = t;
        }
      }
    }
    if (l == 0) {
      return -1;
    }
    d = a[k * n + k];
    for (j = k + 1; j <= n - 1; j++) {
      p = k * n + j;
      a[p] = a[p] / d;
    }
    for (j = 0; j <= m - 1; j++) {
      p = k * m + j;
      b[p] = b[p] / d;
    }
    for (j = k + 1; j <= n - 1; j++) {
      for (i = 0; i <= n - 1; i++) {
        p = i * n + j;
        if (i != k) {
          a[p] = a[p] - a[i * n + k] * a[k * n + j];
        }
      }
    }
    for (j = 0; j <= m - 1; j++) {
      for (i = 0; i <= n - 1; i++) {
        p = i * m + j;
        if (i != k) {
          b[p] = b[p] - a[i * n + k] * b[k * m + j];
        }
      }
    }
  }
  for (k = n - 1; k >= 0; k--) {
    if (js[k] != k) {
      for (j = 0; j <= m - 1; j++) {
        p = k * m + j;
        q = js[k] * m + j;
        t = b[p];
        b[p] = b[q];
        b[q] = t;
      }
    }
  }
  for (i = m * n - 1; i >= 0; i--)
    X[i] = b[i];
  return 0;
}


x86 assembly (clang, -O0):
<imatrix_solve_n_m>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %ecx,-0x24(%rbp)
mov    %r8d,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,-0x38(%rbp)
cmpq   $0x0,-0x30(%rbp)
jne    1158 <imatrix_solve_n_m+0x58>
movslq -0x24(%rbp),%rax
shl    $0x2,%rax
mov    -0x28(%rbp),%ecx
imul   -0x24(%rbp),%ecx
mov    -0x24(%rbp),%edx
imul   -0x24(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %eax,-0x4(%rbp)
jmp    1891 <imatrix_solve_n_m+0x791>
mov    -0x38(%rbp),%rax
movslq -0x24(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x68(%rbp)
mov    -0x38(%rbp),%rax
movslq -0x24(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
shl    $0x3,%rcx
movslq -0x24(%rbp),%rdx
imul   %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x70(%rbp)
mov    -0x24(%rbp),%eax
imul   -0x24(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x4c(%rbp)
cmpl   $0x0,-0x4c(%rbp)
jl     11d0 <imatrix_solve_n_m+0xd0>
mov    -0x10(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x68(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x4c(%rbp)
jmp    119e <imatrix_solve_n_m+0x9e>
mov    -0x28(%rbp),%eax
imul   -0x24(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x4c(%rbp)
cmpl   $0x0,-0x4c(%rbp)
jl     120f <imatrix_solve_n_m+0x10f>
mov    -0x18(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x70(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x4c(%rbp)
jmp    11dd <imatrix_solve_n_m+0xdd>
mov    -0x30(%rbp),%rax
mov    %rax,-0x40(%rbp)
movl   $0x0,-0x54(%rbp)
movl   $0x1,-0x44(%rbp)
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     1786 <imatrix_solve_n_m+0x686>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x48(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     1311 <imatrix_solve_n_m+0x211>
mov    -0x48(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%eax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     12fe <imatrix_solve_n_m+0x1fe>
mov    -0x68(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
xorps  %xmm0,%xmm0
ucomisd -0x80(%rbp),%xmm0
jbe    12bd <imatrix_solve_n_m+0x1bd>
movsd  -0x80(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x80(%rbp),%xmm0
ucomisd -0x78(%rbp),%xmm0
jbe    12eb <imatrix_solve_n_m+0x1eb>
movsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x50(%rbp),%edx
mov    -0x40(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x4c(%rbp),%eax
mov    %eax,-0x54(%rbp)
jmp    12f0 <imatrix_solve_n_m+0x1f0>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    1262 <imatrix_solve_n_m+0x162>
jmp    1303 <imatrix_solve_n_m+0x203>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    124b <imatrix_solve_n_m+0x14b>
movsd  0xce7(%rip),%xmm0
addsd  -0x78(%rbp),%xmm0
movsd  0xcda(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    1342 <imatrix_solve_n_m+0x242>
jp     1342 <imatrix_solve_n_m+0x242>
movl   $0x0,-0x44(%rbp)
jmp    14f2 <imatrix_solve_n_m+0x3f2>
mov    -0x40(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x48(%rbp),%eax
je     13e1 <imatrix_solve_n_m+0x2e1>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     13dc <imatrix_solve_n_m+0x2dc>
mov    -0x4c(%rbp),%eax
imul   -0x24(%rbp),%eax
add    -0x48(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x4c(%rbp),%eax
imul   -0x24(%rbp),%eax
mov    -0x40(%rbp),%rcx
movslq -0x48(%rbp),%rdx
add    (%rcx,%rdx,4),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x68(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x68(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x68(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x80(%rbp),%xmm0
mov    -0x68(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    135d <imatrix_solve_n_m+0x25d>
jmp    13e1 <imatrix_solve_n_m+0x2e1>
mov    -0x54(%rbp),%eax
cmp    -0x48(%rbp),%eax
je     14ed <imatrix_solve_n_m+0x3ed>
mov    -0x48(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%eax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     146a <imatrix_solve_n_m+0x36a>
mov    -0x48(%rbp),%eax
imul   -0x24(%rbp),%eax
add    -0x50(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x54(%rbp),%eax
imul   -0x24(%rbp),%eax
add    -0x50(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x68(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x68(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x68(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x80(%rbp),%xmm0
mov    -0x68(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    13f3 <imatrix_solve_n_m+0x2f3>
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     14e8 <imatrix_solve_n_m+0x3e8>
mov    -0x48(%rbp),%eax
imul   -0x28(%rbp),%eax
add    -0x50(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x54(%rbp),%eax
imul   -0x28(%rbp),%eax
add    -0x50(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x70(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x70(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x70(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x80(%rbp),%xmm0
mov    -0x70(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    1471 <imatrix_solve_n_m+0x371>
jmp    14ed <imatrix_solve_n_m+0x3ed>
jmp    14f2 <imatrix_solve_n_m+0x3f2>
cmpl   $0x0,-0x44(%rbp)
jne    1508 <imatrix_solve_n_m+0x408>
movl   $0xffffffff,-0x4(%rbp)
jmp    1891 <imatrix_solve_n_m+0x791>
mov    -0x68(%rbp),%rax
mov    -0x48(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%eax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     1577 <imatrix_solve_n_m+0x477>
mov    -0x48(%rbp),%eax
imul   -0x24(%rbp),%eax
add    -0x50(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x68(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0x78(%rbp),%xmm0
mov    -0x68(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    152c <imatrix_solve_n_m+0x42c>
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     15c9 <imatrix_solve_n_m+0x4c9>
mov    -0x48(%rbp),%eax
imul   -0x28(%rbp),%eax
add    -0x50(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x70(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0x78(%rbp),%xmm0
mov    -0x70(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    157e <imatrix_solve_n_m+0x47e>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%eax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     169f <imatrix_solve_n_m+0x59f>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     168c <imatrix_solve_n_m+0x58c>
mov    -0x4c(%rbp),%eax
imul   -0x24(%rbp),%eax
add    -0x50(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x48(%rbp),%eax
je     1679 <imatrix_solve_n_m+0x579>
mov    -0x68(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x68(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x68(%rbp),%rax
mov    -0x48(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x68(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    167e <imatrix_solve_n_m+0x57e>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    15ea <imatrix_solve_n_m+0x4ea>
jmp    1691 <imatrix_solve_n_m+0x591>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    15d2 <imatrix_solve_n_m+0x4d2>
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     1773 <imatrix_solve_n_m+0x673>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     1760 <imatrix_solve_n_m+0x660>
mov    -0x4c(%rbp),%eax
imul   -0x28(%rbp),%eax
add    -0x50(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x48(%rbp),%eax
je     174d <imatrix_solve_n_m+0x64d>
mov    -0x70(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x68(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x70(%rbp),%rax
mov    -0x48(%rbp),%ecx
imul   -0x28(%rbp),%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x70(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1752 <imatrix_solve_n_m+0x652>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    16be <imatrix_solve_n_m+0x5be>
jmp    1765 <imatrix_solve_n_m+0x665>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    16a6 <imatrix_solve_n_m+0x5a6>
jmp    1778 <imatrix_solve_n_m+0x678>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    122c <imatrix_solve_n_m+0x12c>
mov    -0x24(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x48(%rbp)
cmpl   $0x0,-0x48(%rbp)
jl     184b <imatrix_solve_n_m+0x74b>
mov    -0x40(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x48(%rbp),%eax
je     1838 <imatrix_solve_n_m+0x738>
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     1833 <imatrix_solve_n_m+0x733>
mov    -0x48(%rbp),%eax
imul   -0x28(%rbp),%eax
add    -0x50(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x40(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
imul   -0x28(%rbp),%eax
add    -0x50(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x70(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x70(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x70(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x80(%rbp),%xmm0
mov    -0x70(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    17b4 <imatrix_solve_n_m+0x6b4>
jmp    1838 <imatrix_solve_n_m+0x738>
jmp    183d <imatrix_solve_n_m+0x73d>
mov    -0x48(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x48(%rbp)
jmp    178f <imatrix_solve_n_m+0x68f>
mov    -0x28(%rbp),%eax
imul   -0x24(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x4c(%rbp)
cmpl   $0x0,-0x4c(%rbp)
jl     188a <imatrix_solve_n_m+0x78a>
mov    -0x70(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x4c(%rbp)
jmp    1858 <imatrix_solve_n_m+0x758>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<imatrix_solve_n_m>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x190,%rsp
test   %r9,%r9
je     13ba <imatrix_solve_n_m+0x2ba>
mov    %r8,-0x80(%rsp)
mov    %rdx,0x20(%rsp)
movslq %ecx,%r12
lea    0x0(,%r12,4),%rax
mov    %rax,-0x38(%rsp)
lea    (%r9,%r12,4),%rax
mov    %rax,-0x68(%rsp)
lea    0x0(,%r12,8),%r11
mov    %r11,%r10
imul   %r12,%r10
mov    %r12d,%ebx
imul   %ebx,%ebx
test   %ebx,%ebx
mov    %r12,-0x70(%rsp)
je     12c6 <imatrix_solve_n_m+0x1c6>
mov    %ebx,%r14d
mov    $0x1,%ebp
mov    $0x1,%eax
cmovle %ebx,%eax
mov    %ebx,%r15d
sub    %eax,%r15d
cmp    $0x3,%r15d
jb     1290 <imatrix_solve_n_m+0x190>
lea    -0x1(%rbx),%eax
mov    -0x38(%rsp),%rdx
lea    (%rdx,%rax,8),%r8
test   %ebx,%ebx
cmovle %ebx,%ebp
sub    %ebp,%ebx
lea    0x0(,%rbx,8),%rbp
mov    %r8,%rdx
sub    %rbp,%rdx
add    %r9,%rdx
lea    (%rdi,%rax,8),%rbp
add    $0x8,%rbp
cmp    %rbp,%rdx
jae    11c8 <imatrix_solve_n_m+0xc8>
lea    (%r9,%r8,1),%rdx
add    $0x8,%rdx
sub    %rbx,%rax
lea    (%rdi,%rax,8),%rax
cmp    %rax,%rdx
ja     1290 <imatrix_solve_n_m+0x190>
add    $0x1,%r15
mov    %r15,%rdx
and    $0xfffffffffffffffc,%rdx
lea    -0x4(%rdx),%rax
mov    %rax,%rbx
shr    $0x2,%rbx
add    $0x1,%rbx
test   %rax,%rax
je     2488 <imatrix_solve_n_m+0x1388>
mov    %rdx,-0x78(%rsp)
mov    %rbx,%rdx
and    $0xfffffffffffffffe,%rdx
mov    $0xfffffffb,%r13d
add    %r14,%r13
lea    -0x1(%r14),%r12
xor    %ebp,%ebp
mov    -0x68(%rsp),%r8
nopl   0x0(%rax,%rax,1)
lea    (%r12,%rbp,1),%eax
movups -0x18(%rdi,%rax,8),%xmm0
movups -0x8(%rdi,%rax,8),%xmm1
movups %xmm1,-0x8(%r8,%rax,8)
movups %xmm0,-0x18(%r8,%rax,8)
lea    0x0(%r13,%rbp,1),%eax
movupd -0x18(%rdi,%rax,8),%xmm0
movupd -0x8(%rdi,%rax,8),%xmm1
movupd %xmm1,-0x8(%r8,%rax,8)
movupd %xmm0,-0x18(%r8,%rax,8)
add    $0xfffffffffffffff8,%rbp
add    $0xfffffffffffffffe,%rdx
jne    1210 <imatrix_solve_n_m+0x110>
neg    %rbp
mov    -0x70(%rsp),%r12
mov    -0x78(%rsp),%rdx
test   $0x1,%bl
je     1288 <imatrix_solve_n_m+0x188>
not    %ebp
lea    (%r14,%rbp,1),%eax
movupd -0x18(%rdi,%rax,8),%xmm0
movupd -0x8(%rdi,%rax,8),%xmm1
mov    -0x68(%rsp),%rbp
movupd %xmm1,-0x8(%rbp,%rax,8)
movupd %xmm0,-0x18(%rbp,%rax,8)
cmp    %rdx,%r15
je     12c6 <imatrix_solve_n_m+0x1c6>
sub    %rdx,%r14
lea    0x1(%r14),%eax
add    $0xffffffff,%r14d
mov    -0x38(%rsp),%rdx
lea    (%rdx,%r14,8),%rbx
add    %r9,%rbx
lea    (%rdi,%r14,8),%rdx
xor    %edi,%edi
nopw   0x0(%rax,%rax,1)
movsd  (%rdx,%rdi,8),%xmm0
movsd  %xmm0,(%rbx,%rdi,8)
add    $0xffffffffffffffff,%rdi
lea    (%rax,%rdi,1),%ebp
cmp    $0x1,%ebp
jg     12b0 <imatrix_solve_n_m+0x1b0>
add    -0x68(%rsp),%r10
mov    -0x80(%rsp),%rdx
mov    %edx,%eax
mov    %ecx,-0x44(%rsp)
imul   %ecx,%eax
lea    -0x1(%rax),%r13d
mov    %r13d,%r15d
mov    %rax,0xd0(%rsp)
test   %eax,%eax
jle    1500 <imatrix_solve_n_m+0x400>
cmp    $0x3,%r13d
jb     1326 <imatrix_solve_n_m+0x226>
lea    (%rsi,%r15,8),%rax
add    $0x8,%rax
cmp    %rax,%r10
jae    13cd <imatrix_solve_n_m+0x2cd>
mov    %r11,%rax
or     $0x4,%rax
imul   %r12,%rax
lea    (%rax,%r15,8),%rax
add    %r9,%rax
add    $0x8,%rax
cmp    %rsi,%rax
jbe    13cd <imatrix_solve_n_m+0x2cd>
mov    %r15,%rdx
lea    0x1(%rdx),%eax
mov    %rdx,%rcx
and    $0x3,%rax
je     1355 <imatrix_solve_n_m+0x255>
mov    %rdx,%rcx
nopl   0x0(%rax,%rax,1)
movsd  (%rsi,%rcx,8),%xmm0
movsd  %xmm0,(%r10,%rcx,8)
add    $0xffffffffffffffff,%rcx
add    $0xffffffffffffffff,%rax
jne    1340 <imatrix_solve_n_m+0x240>
cmp    $0x3,%rdx
mov    -0x80(%rsp),%rdx
jb     1500 <imatrix_solve_n_m+0x400>
add    $0x1,%rcx
lea    0x4(%r11),%rax
imul   %r12,%rax
add    %r9,%rax
add    $0xffffffffffffffe8,%rax
nopw   0x0(%rax,%rax,1)
movsd  -0x8(%rsi,%rcx,8),%xmm0
movsd  %xmm0,0x10(%rax,%rcx,8)
movsd  -0x10(%rsi,%rcx,8),%xmm0
movsd  %xmm0,0x8(%rax,%rcx,8)
movsd  -0x18(%rsi,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x20(%rsi,%rcx,8),%xmm0
movsd  %xmm0,-0x8(%rax,%rcx,8)
add    $0xfffffffffffffffc,%rcx
jne    1380 <imatrix_solve_n_m+0x280>
jmp    1500 <imatrix_solve_n_m+0x400>
add    %ecx,%r8d
lea    0x4(,%r8,8),%eax
imul   %ecx,%eax
jmp    2617 <imatrix_solve_n_m+0x1517>
lea    0x1(%r15),%r8
mov    %r8,%rbx
and    $0xfffffffffffffffc,%rbx
lea    -0x4(%rbx),%rax
mov    %rax,%rdi
shr    $0x2,%rdi
add    $0x1,%rdi
mov    %edi,%r14d
and    $0x3,%r14d
cmp    $0xc,%rax
jae    13fb <imatrix_solve_n_m+0x2fb>
xor    %ebp,%ebp
jmp    148f <imatrix_solve_n_m+0x38f>
movabs $0x7ffffffffffffffe,%rax
ff ff 7f
add    $0xfffffffffffffffe,%rax
and    %rax,%rdi
lea    0x4(%r11),%rax
imul   %r12,%rax
lea    (%rax,%r15,8),%rax
lea    (%r9,%rax,1),%rcx
add    $0xfffffffffffffff8,%rcx
lea    (%rsi,%r15,8),%rdx
add    $0xfffffffffffffff8,%rdx
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
movups -0x10(%rdx,%rbp,8),%xmm0
movups (%rdx,%rbp,8),%xmm1
movups %xmm1,(%rcx,%rbp,8)
movups %xmm0,-0x10(%rcx,%rbp,8)
movups -0x30(%rdx,%rbp,8),%xmm0
movups -0x20(%rdx,%rbp,8),%xmm1
movups %xmm1,-0x20(%rcx,%rbp,8)
movups %xmm0,-0x30(%rcx,%rbp,8)
movups -0x50(%rdx,%rbp,8),%xmm0
movups -0x40(%rdx,%rbp,8),%xmm1
movups %xmm1,-0x40(%rcx,%rbp,8)
movups %xmm0,-0x50(%rcx,%rbp,8)
movupd -0x70(%rdx,%rbp,8),%xmm0
movupd -0x60(%rdx,%rbp,8),%xmm1
movupd %xmm1,-0x60(%rcx,%rbp,8)
movupd %xmm0,-0x70(%rcx,%rbp,8)
add    $0xfffffffffffffff0,%rbp
add    $0xfffffffffffffffc,%rdi
jne    1430 <imatrix_solve_n_m+0x330>
neg    %rbp
test   %r14,%r14
je     14f2 <imatrix_solve_n_m+0x3f2>
lea    0x4(%r11),%rax
imul   %r12,%rax
lea    (%rax,%r15,8),%rax
lea    0x0(,%rbp,8),%rcx
sub    %rcx,%rax
add    %r9,%rax
add    $0xfffffffffffffff8,%rax
mov    %r15,%rcx
sub    %rbp,%rcx
lea    (%rsi,%rcx,8),%rcx
add    $0xfffffffffffffff8,%rcx
shl    $0x5,%r14
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
movupd -0x10(%rcx,%rdx,1),%xmm0
movupd (%rcx,%rdx,1),%xmm1
movupd %xmm1,(%rax,%rdx,1)
movupd %xmm0,-0x10(%rax,%rdx,1)
add    $0xffffffffffffffe0,%rdx
mov    %r14,%rdi
add    %rdx,%rdi
jne    14d0 <imatrix_solve_n_m+0x3d0>
cmp    %rbx,%r8
mov    -0x80(%rsp),%rdx
jne    247d <imatrix_solve_n_m+0x137d>
mov    %r13d,0x14(%rsp)
mov    %r15,0x18(%rsp)
mov    %r10,-0x58(%rsp)
mov    -0x44(%rsp),%eax
test   %eax,%eax
jle    23e2 <imatrix_solve_n_m+0x12e2>
movslq %edx,%rcx
mov    %eax,%r13d
mov    %ecx,%edx
mov    %r11,%rbp
or     $0x4,%rbp
mov    -0x70(%rsp),%rax
imul   %rax,%rbp
mov    %edx,%esi
and    $0xfffffffc,%esi
mov    %rsi,0xc8(%rsp)
add    $0xfffffffffffffffc,%rsi
mov    %rsi,0x28(%rsp)
mov    %rsi,%rdi
shr    $0x2,%rdi
add    $0x1,%rdi
mov    %edx,%esi
and    $0xfffffffe,%esi
mov    %rsi,0x110(%rsp)
add    $0xfffffffffffffffe,%rsi
mov    %rsi,0x108(%rsp)
mov    %rsi,%rbx
shr    %rbx
add    $0x1,%rbx
mov    %r13d,%esi
and    $0xfffffffe,%esi
mov    %rsi,0xf8(%rsp)
mov    %r13,%rsi
neg    %rsi
mov    %rsi,0x80(%rsp)
mov    %rdi,%rsi
mov    %rdi,(%rsp)
and    $0xfffffffffffffffe,%rdi
mov    %rdi,0xc0(%rsp)
mov    %rdx,%rsi
neg    %rsi
mov    %rsi,0x48(%rsp)
mov    %rbx,%rsi
mov    %rbx,0x100(%rsp)
and    $0xfffffffffffffffe,%rbx
mov    %rbx,0xe0(%rsp)
mov    %rax,%rbx
shl    $0x4,%rbx
lea    0x4(%r11),%rsi
imul   %rax,%rsi
movapd 0x1a21(%rip),%xmm0
xorpd  %xmm1,%xmm1
movsd  0x1a25(%rip),%xmm2
movabs $0x7ffffffffffffffe,%rax
ff ff 7f
mov    %rax,-0x8(%rsp)
mov    %rcx,-0x40(%rsp)
lea    0x0(,%rcx,8),%r15
mov    %rdx,-0x78(%rsp)
lea    0x0(%rbp,%rdx,8),%rcx
mov    %rbp,0x60(%rsp)
lea    (%r9,%rbp,1),%rax
mov    %rax,0x30(%rsp)
mov    %rcx,0x130(%rsp)
lea    (%r9,%rcx,1),%rax
mov    %rax,0x40(%rsp)
lea    0x8(%r11),%rdi
mov    -0x38(%rsp),%r10
lea    (%r10,%r13,8),%rax
mov    %rax,0x128(%rsp)
lea    (%r9,%r10,1),%rax
mov    %rax,0xd8(%rsp)
lea    -0x1(%r13),%rax
mov    %rax,0x88(%rsp)
lea    (%r10,%r10,2),%r8
lea    -0x4(%r13),%rdx
lea    0x10(%r9,%r10,1),%rax
mov    %rax,0x68(%rsp)
lea    0x8(%r10),%rax
mov    %rax,0xa0(%rsp)
lea    0x8(%r9,%r10,1),%r14
lea    0x30(%rsi,%r9,1),%r12
lea    0x8(%rsi,%r9,1),%rbp
lea    -0x3(%r13),%rcx
mov    %rsi,0xb0(%rsp)
lea    0x10(%rsi,%r9,1),%rax
mov    %rax,0x70(%rsp)
mov    $0x1,%eax
mov    %rax,-0x30(%rsp)
mov    -0x68(%rsp),%rax
mov    %rax,-0x10(%rsp)
mov    -0x58(%rsp),%rsi
mov    %rax,0x98(%rsp)
mov    %rbp,0x38(%rsp)
mov    %rbp,0x90(%rsp)
xor    %ebp,%ebp
mov    %r12,0xb8(%rsp)
mov    %r12,0x58(%rsp)
mov    %r14,0xe8(%rsp)
mov    %r8,0xf0(%rsp)
mov    %r8,0xa8(%rsp)
mov    %rax,%r12
xor    %r8d,%r8d
mov    %rbx,0x120(%rsp)
mov    %rdi,0x118(%rsp)
jmp    17a0 <imatrix_solve_n_m+0x6a0>
addq   $0x1,-0x30(%rsp)
mov    0x118(%rsp),%rdi
mov    -0x28(%rsp),%r12
add    %rdi,%r12
addq   $0x8,0xa8(%rsp)
add    $0x8,%r10
mov    0x188(%rsp),%rdx
add    $0xffffffffffffffff,%rdx
addq   $0x8,0x68(%rsp)
mov    -0x20(%rsp),%r14
add    %r11,%r14
add    %r15,0x58(%rsp)
add    %r15,0x90(%rsp)
mov    0x180(%rsp),%rcx
add    $0xffffffffffffffff,%rcx
add    %r11,0x98(%rsp)
add    %r15,0x70(%rsp)
mov    -0x18(%rsp),%rsi
add    %r15,%rsi
addq   $0x8,0xa0(%rsp)
addq   $0x8,-0x10(%rsp)
mov    -0x60(%rsp),%rbp
cmp    %r13,%rbp
mov    0x120(%rsp),%rbx
je     211c <imatrix_solve_n_m+0x101c>
mov    %r14,-0x20(%rsp)
mov    %rsi,-0x18(%rsp)
mov    %rcx,0x180(%rsp)
shr    %rcx
add    $0x1,%rcx
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0x150(%rsp)
mov    %rdx,0x188(%rsp)
shr    $0x2,%rdx
add    $0x1,%rdx
and    $0xfffffffffffffffe,%rdx
mov    0x88(%rsp),%rax
sub    %rbp,%rax
add    $0xfffffffffffffffe,%rax
mov    %rax,0x178(%rsp)
shr    %rax
add    $0x1,%rax
mov    %rax,0x78(%rsp)
mov    %r13,%rax
sub    %rbp,%rax
mov    %rax,-0x60(%rsp)
add    $0xfffffffffffffffc,%rax
mov    %rax,0x140(%rsp)
shr    $0x2,%rax
add    $0x1,%rax
mov    %rax,0x148(%rsp)
imul   %rbp,%rdi
add    -0x38(%rsp),%rdi
add    %r9,%rdi
mov    %rdi,0x170(%rsp)
mov    %r11,%rax
imul   %rbp,%rax
mov    0x128(%rsp),%rsi
add    %rsi,%rax
add    %r9,%rax
mov    %rax,0x160(%rsp)
lea    0x0(,%rbp,8),%rax
sub    %rax,%rsi
add    %r9,%rsi
mov    %rsi,0x168(%rsp)
mov    %r15,%rcx
imul   %rbp,%rcx
mov    0x60(%rsp),%rax
add    %rcx,%rax
add    %r9,%rax
mov    %rax,0x158(%rsp)
add    0x130(%rsp),%rcx
add    %r9,%rcx
mov    %rcx,0x138(%rsp)
mov    %rbp,%rax
not    %rax
add    %r13,%rax
mov    %rax,0x8(%rsp)
mov    0x80(%rsp),%rax
lea    (%rax,%rbp,1),%rdi
xorpd  %xmm3,%xmm3
mov    %r12,-0x28(%rsp)
mov    %rbp,%rsi
mov    0xa8(%rsp),%rcx
jmp    18dc <imatrix_solve_n_m+0x7dc>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rsi
add    %r11,%r12
cmp    %r13,%rsi
je     1940 <imatrix_solve_n_m+0x840>
xor    %r14d,%r14d
jmp    18fc <imatrix_solve_n_m+0x7fc>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%r14
mov    %rdi,%rax
add    %r14,%rax
je     18d0 <imatrix_solve_n_m+0x7d0>
movsd  (%r12,%r14,8),%xmm5
movapd %xmm5,%xmm6
xorpd  %xmm0,%xmm6
movapd %xmm5,%xmm4
cmpltsd %xmm1,%xmm4
andpd  %xmm4,%xmm6
andnpd %xmm5,%xmm4
orpd   %xmm6,%xmm4
ucomisd %xmm3,%xmm4
jbe    18f0 <imatrix_solve_n_m+0x7f0>
lea    (%r14,%rbp,1),%eax
mov    %eax,(%r9,%rbp,4)
mov    %esi,%r8d
movapd %xmm4,%xmm3
jmp    18f0 <imatrix_solve_n_m+0x7f0>
cs nopw 0x0(%rax,%rax,1)
addsd  %xmm2,%xmm3
ucomisd %xmm2,%xmm3
jne    1950 <imatrix_solve_n_m+0x850>
jnp    2112 <imatrix_solve_n_m+0x1012>
mov    (%r9,%rbp,4),%eax
cmp    %rax,%rbp
je     1a04 <imatrix_solve_n_m+0x904>
movslq %eax,%rdi
cmpq   $0x0,0x88(%rsp)
mov    %rdi,-0x50(%rsp)
je     1aa6 <imatrix_solve_n_m+0x9a6>
mov    0xf0(%rsp),%rax
lea    (%rax,%rdi,8),%rax
mov    -0x38(%rsp),%rsi
mov    %rbx,%r12
lea    (%rsi,%rdi,8),%rbx
mov    %r9,%rsi
xor    %edi,%edi
mov    0xf8(%rsp),%r14
nopl   0x0(%rax)
movsd  (%rsi,%r10,1),%xmm3
movsd  (%rsi,%rbx,1),%xmm4
movsd  %xmm4,(%rsi,%r10,1)
movsd  %xmm3,(%rsi,%rbx,1)
movsd  (%rsi,%rcx,1),%xmm3
movsd  (%rsi,%rax,1),%xmm4
movsd  %xmm4,(%rsi,%rcx,1)
movsd  %xmm3,(%rsi,%rax,1)
add    $0x2,%rdi
add    %r12,%rsi
cmp    %rdi,%r14
jne    19a0 <imatrix_solve_n_m+0x8a0>
test   $0x1,%r13b
je     1a04 <imatrix_solve_n_m+0x904>
imul   -0x70(%rsp),%rdi
lea    (%rdi,%rbp,1),%rax
add    -0x50(%rsp),%rdi
mov    -0x68(%rsp),%rsi
movsd  (%rsi,%rax,8),%xmm3
movsd  (%rsi,%rdi,8),%xmm4
movsd  %xmm4,(%rsi,%rax,8)
movsd  %xmm3,(%rsi,%rdi,8)
mov    %r8d,%eax
cmp    %rax,%rbp
mov    0x98(%rsp),%r12
mov    0x90(%rsp),%r14
mov    -0x20(%rsp),%rbx
mov    -0x28(%rsp),%rcx
mov    -0x70(%rsp),%rdi
je     1e20 <imatrix_solve_n_m+0xd20>
mov    %rbp,%rax
imul   %rdi,%rax
mov    %rax,0x50(%rsp)
mov    %r8d,%eax
imul   -0x44(%rsp),%eax
cltq
mov    %rax,-0x50(%rsp)
mov    %rbp,%rsi
cmpq   $0x4,-0x60(%rsp)
jb     1ba0 <imatrix_solve_n_m+0xaa0>
mov    -0x50(%rsp),%rax
add    %rbp,%rax
mov    0x168(%rsp),%rsi
lea    (%rsi,%rax,8),%rsi
cmp    %rsi,0x170(%rsp)
jae    1a94 <imatrix_solve_n_m+0x994>
mov    0xd8(%rsp),%rsi
lea    (%rsi,%rax,8),%rax
mov    %rbp,%rsi
cmp    0x160(%rsp),%rax
jb     1ba0 <imatrix_solve_n_m+0xaa0>
cmpq   $0x4,0x140(%rsp)
jae    1ab7 <imatrix_solve_n_m+0x9b7>
xor    %edi,%edi
jmp    1b2e <imatrix_solve_n_m+0xa2e>
xor    %edi,%edi
test   $0x1,%r13b
jne    19dc <imatrix_solve_n_m+0x8dc>
jmp    1a04 <imatrix_solve_n_m+0x904>
mov    0x68(%rsp),%rax
mov    -0x50(%rsp),%rsi
lea    (%rax,%rsi,8),%rsi
xor    %edi,%edi
nopw   0x0(%rax,%rax,1)
movups (%rcx,%rdi,8),%xmm3
movups 0x10(%rcx,%rdi,8),%xmm4
movups -0x10(%rsi,%rdi,8),%xmm5
movups (%rsi,%rdi,8),%xmm6
movups %xmm5,(%rcx,%rdi,8)
movups %xmm6,0x10(%rcx,%rdi,8)
movups %xmm3,-0x10(%rsi,%rdi,8)
movups %xmm4,(%rsi,%rdi,8)
movupd 0x20(%rcx,%rdi,8),%xmm3
movupd 0x30(%rcx,%rdi,8),%xmm4
movupd 0x10(%rsi,%rdi,8),%xmm5
movupd 0x20(%rsi,%rdi,8),%xmm6
movupd %xmm5,0x20(%rcx,%rdi,8)
movupd %xmm6,0x30(%rcx,%rdi,8)
movupd %xmm3,0x10(%rsi,%rdi,8)
movupd %xmm4,0x20(%rsi,%rdi,8)
add    $0x8,%rdi
add    $0xfffffffffffffffe,%rdx
jne    1ad0 <imatrix_solve_n_m+0x9d0>
mov    -0x60(%rsp),%rsi
and    $0xfffffffffffffffc,%rsi
testb  $0x1,0x148(%rsp)
01
je     1b82 <imatrix_solve_n_m+0xa82>
add    %rbp,%rdi
mov    0x50(%rsp),%rax
add    %rdi,%rax
add    -0x50(%rsp),%rdi
mov    -0x68(%rsp),%rdx
movupd (%rdx,%rax,8),%xmm3
movupd 0x10(%rdx,%rax,8),%xmm4
movupd (%rdx,%rdi,8),%xmm5
movupd 0x10(%rdx,%rdi,8),%xmm6
movupd %xmm5,(%rdx,%rax,8)
movupd %xmm6,0x10(%rdx,%rax,8)
movupd %xmm3,(%rdx,%rdi,8)
movupd %xmm4,0x10(%rdx,%rdi,8)
cmp    %rsi,-0x60(%rsp)
mov    -0x70(%rsp),%rdi
je     1c35 <imatrix_solve_n_m+0xb35>
add    %rbp,%rsi
cs nopw 0x0(%rax,%rax,1)
nop
mov    %r13d,%eax
sub    %esi,%eax
mov    %rsi,%rdx
test   $0x1,%al
je     1bde <imatrix_solve_n_m+0xade>
mov    0x50(%rsp),%rdi
add    %rsi,%rdi
mov    -0x50(%rsp),%rax
add    %rsi,%rax
mov    -0x68(%rsp),%rdx
movsd  (%rdx,%rdi,8),%xmm3
movsd  (%rdx,%rax,8),%xmm4
movsd  %xmm4,(%rdx,%rdi,8)
mov    -0x70(%rsp),%rdi
movsd  %xmm3,(%rdx,%rax,8)
lea    0x1(%rsi),%rdx
not    %rsi
cmp    0x80(%rsp),%rsi
je     1c35 <imatrix_solve_n_m+0xb35>
mov    0xe8(%rsp),%rax
mov    -0x50(%rsp),%rsi
lea    (%rax,%rsi,8),%rax
nopl   0x0(%rax)
movsd  -0x8(%rbx,%rdx,8),%xmm3
movsd  -0x8(%rax,%rdx,8),%xmm4
movsd  %xmm4,-0x8(%rbx,%rdx,8)
movsd  %xmm3,-0x8(%rax,%rdx,8)
movsd  (%rbx,%rdx,8),%xmm3
movsd  (%rax,%rdx,8),%xmm4
movsd  %xmm4,(%rbx,%rdx,8)
movsd  %xmm3,(%rax,%rdx,8)
add    $0x2,%rdx
cmp    %rdx,%r13
jne    1c00 <imatrix_solve_n_m+0xb00>
cmpl   $0x0,-0x80(%rsp)
jle    1e20 <imatrix_solve_n_m+0xd20>
mov    %rbp,%rsi
imul   -0x40(%rsp),%rsi
mov    %r8d,%eax
mov    -0x80(%rsp),%rdx
imul   %edx,%eax
movslq %eax,%rbx
cmp    $0x4,%edx
mov    %rbx,-0x60(%rsp)
jb     1c8f <imatrix_solve_n_m+0xb8f>
mov    0x40(%rsp),%rax
lea    (%rax,%rbx,8),%rax
cmp    %rax,0x158(%rsp)
jae    1d2e <imatrix_solve_n_m+0xc2e>
mov    0x30(%rsp),%rax
lea    (%rax,%rbx,8),%rax
cmp    0x138(%rsp),%rax
jae    1d2e <imatrix_solve_n_m+0xc2e>
xor    %eax,%eax
mov    -0x78(%rsp),%rbx
mov    %rax,%rdx
test   $0x1,%bl
je     1cce <imatrix_solve_n_m+0xbce>
add    %rax,%rsi
mov    -0x60(%rsp),%rdx
add    %rax,%rdx
mov    -0x58(%rsp),%rdi
movsd  (%rdi,%rsi,8),%xmm3
movsd  (%rdi,%rdx,8),%xmm4
movsd  %xmm4,(%rdi,%rsi,8)
movsd  %xmm3,(%rdi,%rdx,8)
mov    -0x70(%rsp),%rdi
mov    %rax,%rdx
or     $0x1,%rdx
not    %rax
cmp    0x48(%rsp),%rax
mov    -0x78(%rsp),%rsi
je     1e20 <imatrix_solve_n_m+0xd20>
mov    0x38(%rsp),%rax
mov    -0x60(%rsp),%rbx
lea    (%rax,%rbx,8),%rax
nop
movsd  -0x8(%r14,%rdx,8),%xmm3
movsd  -0x8(%rax,%rdx,8),%xmm4
movsd  %xmm4,-0x8(%r14,%rdx,8)
movsd  %xmm3,-0x8(%rax,%rdx,8)
movsd  (%r14,%rdx,8),%xmm3
movsd  (%rax,%rdx,8),%xmm4
movsd  %xmm4,(%r14,%rdx,8)
movsd  %xmm3,(%rax,%rdx,8)
add    $0x2,%rdx
cmp    %rdx,%rsi
jne    1cf0 <imatrix_solve_n_m+0xbf0>
jmp    1e20 <imatrix_solve_n_m+0xd20>
cmpq   $0x0,0x28(%rsp)
je     2101 <imatrix_solve_n_m+0x1001>
mov    0xb8(%rsp),%rax
lea    (%rax,%rbx,8),%rdi
mov    0xc0(%rsp),%rbx
xor    %edx,%edx
mov    0x58(%rsp),%rax
cs nopw 0x0(%rax,%rax,1)
nop
movups -0x30(%rax,%rdx,8),%xmm3
movups -0x20(%rax,%rdx,8),%xmm4
movups -0x30(%rdi,%rdx,8),%xmm5
movups -0x20(%rdi,%rdx,8),%xmm6
movups %xmm5,-0x30(%rax,%rdx,8)
movups %xmm6,-0x20(%rax,%rdx,8)
movups %xmm3,-0x30(%rdi,%rdx,8)
movups %xmm4,-0x20(%rdi,%rdx,8)
movupd -0x10(%rax,%rdx,8),%xmm3
movupd (%rax,%rdx,8),%xmm4
movupd -0x10(%rdi,%rdx,8),%xmm5
movupd (%rdi,%rdx,8),%xmm6
movupd %xmm5,-0x10(%rax,%rdx,8)
movupd %xmm6,(%rax,%rdx,8)
movupd %xmm3,-0x10(%rdi,%rdx,8)
movupd %xmm4,(%rdi,%rdx,8)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rbx
jne    1d60 <imatrix_solve_n_m+0xc60>
testb  $0x1,(%rsp)
je     1dfe <imatrix_solve_n_m+0xcfe>
lea    (%rdx,%rsi,1),%rax
add    -0x60(%rsp),%rdx
mov    -0x58(%rsp),%rdi
movupd (%rdi,%rax,8),%xmm3
movupd 0x10(%rdi,%rax,8),%xmm4
movupd (%rdi,%rdx,8),%xmm5
movupd 0x10(%rdi,%rdx,8),%xmm6
movupd %xmm5,(%rdi,%rax,8)
movupd %xmm6,0x10(%rdi,%rax,8)
movupd %xmm3,(%rdi,%rdx,8)
movupd %xmm4,0x10(%rdi,%rdx,8)
mov    0xc8(%rsp),%rdx
mov    %rdx,%rax
mov    -0x78(%rsp),%rbx
cmp    %rbx,%rdx
mov    -0x70(%rsp),%rdi
jne    1c96 <imatrix_solve_n_m+0xb96>
nopl   0x0(%rax)
mov    %rbp,%r14
imul   %rdi,%r14
lea    (%r14,%rbp,1),%rax
mov    -0x68(%rsp),%rdx
movsd  (%rdx,%rax,8),%xmm3
lea    0x1(%rbp),%rax
mov    %rax,-0x60(%rsp)
cmp    %rdi,%rax
mov    -0x18(%rsp),%rsi
jge    1f19 <imatrix_solve_n_m+0xe19>
mov    -0x30(%rsp),%rdx
cmpq   $0x2,0x8(%rsp)
jb     1f00 <imatrix_solve_n_m+0xe00>
movapd %xmm3,%xmm4
unpcklpd %xmm3,%xmm4
cmpq   $0x2,0x178(%rsp)
jae    1e79 <imatrix_solve_n_m+0xd79>
xor    %edi,%edi
mov    0x78(%rsp),%rbx
jmp    1eba <imatrix_solve_n_m+0xdba>
xor    %edi,%edi
mov    0x150(%rsp),%rax
mov    0x78(%rsp),%rbx
nopl   0x0(%rax,%rax,1)
movupd 0x8(%rcx,%rdi,8),%xmm5
movupd 0x18(%rcx,%rdi,8),%xmm6
divpd  %xmm4,%xmm5
movupd %xmm5,0x8(%rcx,%rdi,8)
divpd  %xmm4,%xmm6
movupd %xmm6,0x18(%rcx,%rdi,8)
add    $0x4,%rdi
add    $0xfffffffffffffffe,%rax
jne    1e90 <imatrix_solve_n_m+0xd90>
mov    0x8(%rsp),%rax
mov    %rax,%rdx
and    $0xfffffffffffffffe,%rdx
test   $0x1,%bl
je     1eeb <imatrix_solve_n_m+0xdeb>
add    -0x30(%rsp),%rdi
add    %r14,%rdi
mov    -0x68(%rsp),%rax
movupd (%rax,%rdi,8),%xmm5
divpd  %xmm4,%xmm5
movupd %xmm5,(%rax,%rdi,8)
mov    0x8(%rsp),%rax
cmp    %rdx,%rax
mov    -0x70(%rsp),%rdi
je     1f19 <imatrix_solve_n_m+0xe19>
add    -0x30(%rsp),%rdx
nopw   0x0(%rax,%rax,1)
movsd  (%r12,%rdx,8),%xmm4
divsd  %xmm3,%xmm4
movsd  %xmm4,(%r12,%rdx,8)
add    $0x1,%rdx
cmp    %rdx,%r13
jne    1f00 <imatrix_solve_n_m+0xe00>
mov    -0x80(%rsp),%rax
test   %eax,%eax
mov    -0x78(%rsp),%rbx
jle    1ff7 <imatrix_solve_n_m+0xef7>
cmp    $0x1,%eax
jne    1f40 <imatrix_solve_n_m+0xe40>
xor    %eax,%eax
jmp    1fe0 <imatrix_solve_n_m+0xee0>
nopw   0x0(%rax,%rax,1)
movapd %xmm3,%xmm4
unpcklpd %xmm3,%xmm4
cmpq   $0x0,0x108(%rsp)
je     20ec <imatrix_solve_n_m+0xfec>
mov    0xe0(%rsp),%rax
xor    %ecx,%ecx
mov    0x70(%rsp),%rdx
cs nopw 0x0(%rax,%rax,1)
movupd -0x10(%rdx,%rcx,8),%xmm5
movupd (%rdx,%rcx,8),%xmm6
divpd  %xmm4,%xmm5
movupd %xmm5,-0x10(%rdx,%rcx,8)
divpd  %xmm4,%xmm6
movupd %xmm6,(%rdx,%rcx,8)
add    $0x4,%rcx
add    $0xfffffffffffffffe,%rax
jne    1f70 <imatrix_solve_n_m+0xe70>
testb  $0x1,0x100(%rsp)
01
je     1fc1 <imatrix_solve_n_m+0xec1>
mov    %rbp,%rax
imul   -0x40(%rsp),%rax
add    %rax,%rcx
mov    -0x58(%rsp),%rax
movupd (%rax,%rcx,8),%xmm5
divpd  %xmm4,%xmm5
movupd %xmm5,(%rax,%rcx,8)
mov    0x110(%rsp),%rcx
mov    %rcx,%rax
cmp    %rbx,%rcx
je     1ff7 <imatrix_solve_n_m+0xef7>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%rsi,%rax,8),%xmm4
divsd  %xmm3,%xmm4
movsd  %xmm4,(%rsi,%rax,8)
add    $0x1,%rax
cmp    %rax,%rbx
jne    1fe0 <imatrix_solve_n_m+0xee0>
mov    0xa0(%rsp),%rcx
mov    -0x30(%rsp),%r12
cmp    %rdi,-0x60(%rsp)
mov    -0x58(%rsp),%rsi
mov    -0x68(%rsp),%rdx
jl     20b1 <imatrix_solve_n_m+0xfb1>
cmpl   $0x0,-0x80(%rsp)
jle    1710 <imatrix_solve_n_m+0x610>
mov    %rbp,%r14
imul   -0x40(%rsp),%r14
mov    %rsi,%r12
xor    %eax,%eax
jmp    2053 <imatrix_solve_n_m+0xf53>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%rax
add    $0x8,%r12
cmp    -0x78(%rsp),%rax
je     1710 <imatrix_solve_n_m+0x610>
lea    (%rax,%r14,1),%rdi
mov    -0x10(%rsp),%rbx
mov    %r12,%rdx
xor    %ecx,%ecx
jmp    207f <imatrix_solve_n_m+0xf7f>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%rcx
add    %r15,%rdx
add    %r11,%rbx
cmp    %rcx,%r13
je     2040 <imatrix_solve_n_m+0xf40>
cmp    %rcx,%rbp
je     2070 <imatrix_solve_n_m+0xf70>
movsd  (%rdx),%xmm3
movsd  (%rbx),%xmm4
mulsd  (%rsi,%rdi,8),%xmm4
subsd  %xmm4,%xmm3
movsd  %xmm3,(%rdx)
jmp    2070 <imatrix_solve_n_m+0xf70>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r12
add    $0x8,%rcx
cmp    %r13,%r12
je     2019 <imatrix_solve_n_m+0xf19>
lea    (%r12,%r14,1),%rax
mov    %r9,%rdi
xor    %ebx,%ebx
jmp    20cc <imatrix_solve_n_m+0xfcc>
nopl   0x0(%rax)
add    $0x1,%rbx
add    %r11,%rdi
cmp    %rbx,%r13
je     20a0 <imatrix_solve_n_m+0xfa0>
cmp    %rbx,%rbp
je     20c0 <imatrix_solve_n_m+0xfc0>
movsd  (%rdi,%rcx,1),%xmm3
movsd  (%rdi,%r10,1),%xmm4
mulsd  (%rdx,%rax,8),%xmm4
subsd  %xmm4,%xmm3
movsd  %xmm3,(%rdi,%rcx,1)
jmp    20c0 <imatrix_solve_n_m+0xfc0>
xor    %ecx,%ecx
testb  $0x1,0x100(%rsp)
01
jne    1fa2 <imatrix_solve_n_m+0xea2>
jmp    1fc1 <imatrix_solve_n_m+0xec1>
xor    %edx,%edx
testb  $0x1,(%rsp)
jne    1dc4 <imatrix_solve_n_m+0xcc4>
jmp    1dfe <imatrix_solve_n_m+0xcfe>
mov    $0xffffffff,%eax
jmp    2617 <imatrix_solve_n_m+0x1517>
cmpl   $0x0,-0x44(%rsp)
mov    -0x80(%rsp),%r13
jle    23e2 <imatrix_solve_n_m+0x12e2>
mov    -0x70(%rsp),%r8
lea    -0x1(%r8),%rax
imul   -0x40(%rsp),%rax
mov    0x60(%rsp),%rcx
lea    (%rcx,%rax,8),%r10
neg    %r15
mov    -0x78(%rsp),%r12
lea    (%r10,%r12,8),%rcx
mov    %rcx,-0x10(%rsp)
and    $0xfffffffc,%r12d
mov    %r12,-0x20(%rsp)
mov    -0x8(%rsp),%rcx
and    (%rsp),%rcx
mov    %rcx,-0x8(%rsp)
mov    0xb0(%rsp),%rcx
lea    (%rcx,%rax,8),%rax
lea    (%r9,%rax,1),%rsi
add    $0x30,%rsi
add    %r9,%rcx
add    $0x30,%rcx
mov    %rcx,-0x28(%rsp)
lea    (%r9,%rax,1),%rbp
add    $0x8,%rbp
xor    %ecx,%ecx
mov    %r10,-0x18(%rsp)
jmp    21b4 <imatrix_solve_n_m+0x10b4>
nopl   (%rax)
add    $0x1,%rcx
add    %r15,%rsi
add    %r15,%rbp
cmp    $0x1,%rax
jle    23e2 <imatrix_solve_n_m+0x12e2>
mov    %r8,%rax
add    $0xffffffffffffffff,%r8
mov    -0x4(%r9,%rax,4),%edi
cmp    %rdi,%r8
je     21a0 <imatrix_solve_n_m+0x10a0>
test   %r13d,%r13d
jle    21a0 <imatrix_solve_n_m+0x10a0>
mov    %r8,%r14
imul   -0x40(%rsp),%r14
imul   %r13d,%edi
movslq %edi,%r12
cmp    $0x4,%r13d
jae    21f0 <imatrix_solve_n_m+0x10f0>
xor    %ebx,%ebx
mov    -0x78(%rsp),%rdx
jmp    2330 <imatrix_solve_n_m+0x1230>
nopl   0x0(%rax)
mov    %r15,%rdi
imul   %rcx,%rdi
lea    (%r10,%rdi,1),%rbx
add    %r9,%rbx
mov    0x40(%rsp),%rdx
lea    (%rdx,%r12,8),%rdx
cmp    %rdx,%rbx
jae    2233 <imatrix_solve_n_m+0x1133>
add    -0x10(%rsp),%rdi
add    %r9,%rdi
mov    0x30(%rsp),%rdx
lea    (%rdx,%r12,8),%rdx
cmp    %rdi,%rdx
jae    2233 <imatrix_solve_n_m+0x1133>
xor    %ebx,%ebx
mov    -0x80(%rsp),%r13
mov    -0x78(%rsp),%rdx
jmp    2330 <imatrix_solve_n_m+0x1230>
cmpq   $0x0,0x28(%rsp)
je     23cc <imatrix_solve_n_m+0x12cc>
mov    -0x28(%rsp),%rdx
lea    (%rdx,%r12,8),%r10
mov    -0x8(%rsp),%rbx
xor    %edi,%edi
mov    -0x80(%rsp),%r13
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movups -0x30(%rsi,%rdi,8),%xmm0
movups -0x20(%rsi,%rdi,8),%xmm1
movups -0x30(%r10,%rdi,8),%xmm2
movups -0x20(%r10,%rdi,8),%xmm3
movups %xmm2,-0x30(%rsi,%rdi,8)
movups %xmm3,-0x20(%rsi,%rdi,8)
movups %xmm0,-0x30(%r10,%rdi,8)
movups %xmm1,-0x20(%r10,%rdi,8)
movupd -0x10(%rsi,%rdi,8),%xmm0
movupd (%rsi,%rdi,8),%xmm1
movupd -0x10(%r10,%rdi,8),%xmm2
movupd (%r10,%rdi,8),%xmm3
movupd %xmm2,-0x10(%rsi,%rdi,8)
movupd %xmm3,(%rsi,%rdi,8)
movupd %xmm0,-0x10(%r10,%rdi,8)
movupd %xmm1,(%r10,%rdi,8)
add    $0x8,%rdi
add    $0xfffffffffffffffe,%rbx
jne    2260 <imatrix_solve_n_m+0x1160>
testb  $0x1,(%rsp)
je     2309 <imatrix_solve_n_m+0x1209>
lea    (%rdi,%r14,1),%rdx
add    %r12,%rdi
mov    -0x58(%rsp),%rbx
movupd (%rbx,%rdx,8),%xmm0
movupd 0x10(%rbx,%rdx,8),%xmm1
movupd (%rbx,%rdi,8),%xmm2
movupd 0x10(%rbx,%rdi,8),%xmm3
movupd %xmm2,(%rbx,%rdx,8)
movupd %xmm3,0x10(%rbx,%rdx,8)
mov    -0x80(%rsp),%r13
movupd %xmm0,(%rbx,%rdi,8)
movupd %xmm1,0x10(%rbx,%rdi,8)
mov    -0x20(%rsp),%rdi
mov    %rdi,%rbx
mov    -0x78(%rsp),%rdx
cmp    %rdx,%rdi
mov    -0x18(%rsp),%r10
je     21a0 <imatrix_solve_n_m+0x10a0>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %rbx,%rdi
test   $0x1,%dl
je     2366 <imatrix_solve_n_m+0x1266>
add    %rbx,%r14
lea    (%rbx,%r12,1),%rdx
mov    -0x58(%rsp),%rdi
movsd  (%rdi,%r14,8),%xmm0
movsd  (%rdi,%rdx,8),%xmm1
movsd  %xmm1,(%rdi,%r14,8)
movsd  %xmm0,(%rdi,%rdx,8)
mov    -0x80(%rsp),%r13
mov    %rbx,%rdi
or     $0x1,%rdi
not    %rbx
cmp    0x48(%rsp),%rbx
mov    -0x78(%rsp),%rdx
je     21a0 <imatrix_solve_n_m+0x10a0>
mov    0x38(%rsp),%rbx
lea    (%rbx,%r12,8),%rbx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  -0x8(%rbp,%rdi,8),%xmm0
movsd  -0x8(%rbx,%rdi,8),%xmm1
movsd  %xmm1,-0x8(%rbp,%rdi,8)
movsd  %xmm0,-0x8(%rbx,%rdi,8)
movsd  0x0(%rbp,%rdi,8),%xmm0
movsd  (%rbx,%rdi,8),%xmm1
movsd  %xmm1,0x0(%rbp,%rdi,8)
movsd  %xmm0,(%rbx,%rdi,8)
add    $0x2,%rdi
cmp    %rdi,%rdx
jne    2390 <imatrix_solve_n_m+0x1290>
jmp    21a0 <imatrix_solve_n_m+0x10a0>
xor    %edi,%edi
mov    -0x80(%rsp),%r13
testb  $0x1,(%rsp)
jne    22cc <imatrix_solve_n_m+0x11cc>
jmp    2309 <imatrix_solve_n_m+0x1209>
cmpl   $0x0,0xd0(%rsp)
jle    2615 <imatrix_solve_n_m+0x1515>
cmpl   $0x3,0x14(%rsp)
jae    2410 <imatrix_solve_n_m+0x1310>
mov    0x20(%rsp),%rbx
mov    -0x70(%rsp),%r14
mov    -0x58(%rsp),%r15
mov    0x18(%rsp),%r12
jmp    259c <imatrix_solve_n_m+0x149c>
mov    %r11,%rax
or     $0x4,%rax
mov    -0x70(%rsp),%r14
imul   %r14,%rax
mov    0x18(%rsp),%r12
lea    (%rax,%r12,8),%rax
add    %r9,%rax
add    $0x8,%rax
mov    0x20(%rsp),%rbx
cmp    %rbx,%rax
mov    -0x58(%rsp),%r15
jbe    2450 <imatrix_solve_n_m+0x1350>
lea    (%rbx,%r12,8),%rax
add    $0x8,%rax
cmp    %rax,%r15
jb     259c <imatrix_solve_n_m+0x149c>
lea    0x1(%r12),%r8
mov    %r8,%r10
and    $0xfffffffffffffffc,%r10
lea    -0x4(%r10),%rdx
mov    %rdx,%rdi
shr    $0x2,%rdi
add    $0x1,%rdi
mov    %edi,%ecx
and    $0x3,%ecx
cmp    $0xc,%rdx
jae    2498 <imatrix_solve_n_m+0x1398>
xor    %esi,%esi
jmp    2530 <imatrix_solve_n_m+0x1430>
mov    %r15,%rdx
sub    %rbx,%rdx
jmp    1329 <imatrix_solve_n_m+0x229>
xor    %ebp,%ebp
test   $0x1,%bl
jne    1265 <imatrix_solve_n_m+0x165>
jmp    1288 <imatrix_solve_n_m+0x188>
movabs $0x7ffffffffffffffe,%rdx
ff ff 7f
add    $0xfffffffffffffffe,%rdx
and    %rdx,%rdi
lea    (%rbx,%r12,8),%rbp
add    $0xfffffffffffffff8,%rbp
lea    0x4(%r11),%rdx
imul   %r14,%rdx
lea    (%rdx,%r12,8),%rdx
add    %r9,%rdx
add    $0xfffffffffffffff8,%rdx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
movups -0x10(%rdx,%rsi,8),%xmm0
movups (%rdx,%rsi,8),%xmm1
movups %xmm1,0x0(%rbp,%rsi,8)
movups %xmm0,-0x10(%rbp,%rsi,8)
movups -0x30(%rdx,%rsi,8),%xmm0
movups -0x20(%rdx,%rsi,8),%xmm1
movups %xmm1,-0x20(%rbp,%rsi,8)
movups %xmm0,-0x30(%rbp,%rsi,8)
movups -0x50(%rdx,%rsi,8),%xmm0
movups -0x40(%rdx,%rsi,8),%xmm1
movups %xmm1,-0x40(%rbp,%rsi,8)
movups %xmm0,-0x50(%rbp,%rsi,8)
movupd -0x70(%rdx,%rsi,8),%xmm0
movupd -0x60(%rdx,%rsi,8),%xmm1
movupd %xmm1,-0x60(%rbp,%rsi,8)
movupd %xmm0,-0x70(%rbp,%rsi,8)
add    $0xfffffffffffffff0,%rsi
add    $0xfffffffffffffffc,%rdi
jne    24d0 <imatrix_solve_n_m+0x13d0>
neg    %rsi
test   %rcx,%rcx
je     2592 <imatrix_solve_n_m+0x1492>
mov    %r12,%rdx
sub    %rsi,%rdx
lea    (%rbx,%rdx,8),%rdx
add    $0xfffffffffffffff8,%rdx
lea    0x4(%r11),%rdi
imul   %r14,%rdi
lea    (%rdi,%r12,8),%rdi
shl    $0x3,%rsi
sub    %rsi,%rdi
lea    (%rdi,%r9,1),%rsi
add    $0xfffffffffffffff8,%rsi
shl    $0x5,%rcx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movupd -0x10(%rsi,%rdi,1),%xmm0
movupd (%rsi,%rdi,1),%xmm1
movupd %xmm1,(%rdx,%rdi,1)
movupd %xmm0,-0x10(%rdx,%rdi,1)
add    $0xffffffffffffffe0,%rdi
mov    %rcx,%rax
add    %rdi,%rax
jne    2570 <imatrix_solve_n_m+0x1470>
xor    %eax,%eax
cmp    %r10,%r8
je     2617 <imatrix_solve_n_m+0x1517>
sub    %r10,%r12
lea    0x1(%r12),%ecx
mov    %r12,%rax
and    $0x3,%rcx
je     25c5 <imatrix_solve_n_m+0x14c5>
mov    %r12,%rax
nopl   (%rax)
movsd  (%r15,%rax,8),%xmm0
movsd  %xmm0,(%rbx,%rax,8)
add    $0xffffffffffffffff,%rax
add    $0xffffffffffffffff,%rcx
jne    25b0 <imatrix_solve_n_m+0x14b0>
cmp    $0x3,%r12
jb     2615 <imatrix_solve_n_m+0x1515>
add    $0x1,%rax
add    $0x4,%r11
imul   %r14,%r11
lea    (%r11,%r9,1),%rcx
add    $0xffffffffffffffe8,%rcx
nop
movsd  0x10(%rcx,%rax,8),%xmm0
movsd  %xmm0,-0x8(%rbx,%rax,8)
movsd  0x8(%rcx,%rax,8),%xmm0
movsd  %xmm0,-0x10(%rbx,%rax,8)
movsd  (%rcx,%rax,8),%xmm0
movsd  %xmm0,-0x18(%rbx,%rax,8)
movsd  -0x8(%rcx,%rax,8),%xmm0
movsd  %xmm0,-0x20(%rbx,%rax,8)
add    $0xfffffffffffffffc,%rax
jne    25e0 <imatrix_solve_n_m+0x14e0>
xor    %eax,%eax
add    $0x190,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define i32 @imatrix_solve_n_m(double* nocapture %0, double* nocapture %1, double* nocapture writeonly %2, i32 %3, i32 %4, i8* %5) {
%7 = bitcast double* %1 to i8*
%8 = bitcast double* %2 to i8*
%9 = icmp eq i8* %5, null
br i1 %9, label %10, label %15
10: ; preds = %6
%11 = add i32 %4, %3
%12 = shl i32 %11, 3
%13 = or i32 %12, 4
%14 = mul i32 %13, %3
br label %1163
15: ; preds = %6
%16 = sext i32 %3 to i64
%17 = shl nsw i64 %16, 2
%18 = getelementptr inbounds i8, i8* %5, i64 %17
%19 = bitcast i8* %18 to double*
%20 = shl nsw i64 %16, 3
%21 = mul i64 %20, %16
%22 = getelementptr i8, i8* %18, i64 %21
%23 = bitcast i8* %22 to double*
%24 = mul i32 %3, %3
%25 = icmp eq i32 %24, 0
br i1 %25, label %140, label %26
26: ; preds = %15
%27 = zext i32 %24 to i64
%28 = call i32 @llvm.smin.i32(i32 %24, i32 1)
%29 = sub i32 %24, %28
%30 = zext i32 %29 to i64
%31 = add nuw nsw i64 %30, 1
%32 = icmp ult i32 %29, 3
br i1 %32, label %129, label %33
33: ; preds = %26
%34 = add i32 %24, -1
%35 = zext i32 %34 to i64
%36 = shl nuw nsw i64 %35, 3
%37 = add nsw i64 %36, %17
%38 = call i32 @llvm.smin.i32(i32 %24, i32 1)
%39 = sub i32 %24, %38
%40 = zext i32 %39 to i64
%41 = mul nsw i64 %40, -8
%42 = add nsw i64 %41, %37
%43 = getelementptr i8, i8* %5, i64 %42
%44 = add nsw i64 %36, %17
%45 = add nsw i64 %44, 8
%46 = getelementptr i8, i8* %5, i64 %45
%47 = sub nsw i64 %35, %40
%48 = getelementptr double, double* %0, i64 %47
%49 = bitcast double* %48 to i8*
%50 = add nuw nsw i64 %35, 1
%51 = getelementptr double, double* %0, i64 %50
%52 = bitcast double* %51 to i8*
%53 = icmp ult i8* %43, %52
%54 = icmp ugt i8* %46, %49
%55 = and i1 %53, %54
br i1 %55, label %129, label %56
56: ; preds = %33
%57 = and i64 %31, 8589934588
%58 = sub nsw i64 %27, %57
%59 = add nsw i64 %57, -4
%60 = lshr exact i64 %59, 2
%61 = add nuw nsw i64 %60, 1
%62 = and i64 %61, 1
%63 = icmp eq i64 %59, 0
br i1 %63, label %106, label %64
64: ; preds = %56
%65 = and i64 %61, 9223372036854775806
br label %66
66: ; preds = %66, %64
%67 = phi i64 [ 0, %64 ], [ %103, %66 ]
%68 = phi i64 [ 0, %64 ], [ %104, %66 ]
%69 = xor i64 %67, -1
%70 = add i64 %69, %27
%71 = and i64 %70, 4294967295
%72 = getelementptr inbounds double, double* %0, i64 %71
%73 = getelementptr inbounds double, double* %72, i64 -1
%74 = bitcast double* %73 to <2 x double>*
%75 = load <2 x double>, <2 x double>* %74
%76 = getelementptr inbounds double, double* %72, i64 -2
%77 = getelementptr inbounds double, double* %76, i64 -1
%78 = bitcast double* %77 to <2 x double>*
%79 = load <2 x double>, <2 x double>* %78
%80 = getelementptr inbounds double, double* %19, i64 %71
%81 = getelementptr inbounds double, double* %80, i64 -1
%82 = bitcast double* %81 to <2 x double>*
store <2 x double> %75, <2 x double>* %82
%83 = getelementptr inbounds double, double* %80, i64 -2
%84 = getelementptr inbounds double, double* %83, i64 -1
%85 = bitcast double* %84 to <2 x double>*
store <2 x double> %79, <2 x double>* %85
%86 = sub i64 4294967291, %67
%87 = add i64 %86, %27
%88 = and i64 %87, 4294967295
%89 = getelementptr inbounds double, double* %0, i64 %88
%90 = getelementptr inbounds double, double* %89, i64 -1
%91 = bitcast double* %90 to <2 x double>*
%92 = load <2 x double>, <2 x double>* %91
%93 = getelementptr inbounds double, double* %89, i64 -2
%94 = getelementptr inbounds double, double* %93, i64 -1
%95 = bitcast double* %94 to <2 x double>*
%96 = load <2 x double>, <2 x double>* %95
%97 = getelementptr inbounds double, double* %19, i64 %88
%98 = getelementptr inbounds double, double* %97, i64 -1
%99 = bitcast double* %98 to <2 x double>*
store <2 x double> %92, <2 x double>* %99
%100 = getelementptr inbounds double, double* %97, i64 -2
%101 = getelementptr inbounds double, double* %100, i64 -1
%102 = bitcast double* %101 to <2 x double>*
store <2 x double> %96, <2 x double>* %102
%103 = add nuw i64 %67, 8
%104 = add i64 %68, 2
%105 = icmp eq i64 %104, %65
br i1 %105, label %106, label %66
106: ; preds = %66, %56
%107 = phi i64 [ 0, %56 ], [ %103, %66 ]
%108 = icmp eq i64 %62, 0
br i1 %108, label %127, label %109
109: ; preds = %106
%110 = xor i64 %107, -1
%111 = add i64 %110, %27
%112 = and i64 %111, 4294967295
%113 = getelementptr inbounds double, double* %0, i64 %112
%114 = getelementptr inbounds double, double* %113, i64 -1
%115 = bitcast double* %114 to <2 x double>*
%116 = load <2 x double>, <2 x double>* %115
%117 = getelementptr inbounds double, double* %113, i64 -2
%118 = getelementptr inbounds double, double* %117, i64 -1
%119 = bitcast double* %118 to <2 x double>*
%120 = load <2 x double>, <2 x double>* %119
%121 = getelementptr inbounds double, double* %19, i64 %112
%122 = getelementptr inbounds double, double* %121, i64 -1
%123 = bitcast double* %122 to <2 x double>*
store <2 x double> %116, <2 x double>* %123
%124 = getelementptr inbounds double, double* %121, i64 -2
%125 = getelementptr inbounds double, double* %124, i64 -1
%126 = bitcast double* %125 to <2 x double>*
store <2 x double> %120, <2 x double>* %126
br label %127
127: ; preds = %106, %109
%128 = icmp eq i64 %31, %57
br i1 %128, label %140, label %129
129: ; preds = %33, %26, %127
%130 = phi i64 [ %27, %33 ], [ %27, %26 ], [ %58, %127 ]
br label %131
131: ; preds = %129, %131
%132 = phi i64 [ %133, %131 ], [ %130, %129 ]
%133 = add nsw i64 %132, -1
%134 = and i64 %133, 4294967295
%135 = getelementptr inbounds double, double* %0, i64 %134
%136 = load double, double* %135
%137 = getelementptr inbounds double, double* %19, i64 %134
store double %136, double* %137
%138 = trunc i64 %132 to i32
%139 = icmp sgt i32 %138, 1
br i1 %139, label %131, label %140
140: ; preds = %131, %127, %15
%141 = mul nsw i32 %4, %3
%142 = add i32 %141, -1
%143 = icmp sgt i32 %141, 0
br i1 %143, label %144, label %302
144: ; preds = %140
%145 = zext i32 %142 to i64
%146 = add nuw nsw i64 %145, 1
%147 = icmp ult i32 %142, 3
br i1 %147, label %266, label %148
148: ; preds = %144
%149 = or i64 %20, 4
%150 = mul i64 %149, %16
%151 = shl nuw nsw i64 %145, 3
%152 = add i64 %150, %151
%153 = add i64 %152, 8
%154 = getelementptr i8, i8* %5, i64 %153
%155 = add nuw nsw i64 %145, 1
%156 = getelementptr double, double* %1, i64 %155
%157 = bitcast double* %156 to i8*
%158 = icmp ult i8* %22, %157
%159 = icmp ugt i8* %154, %7
%160 = and i1 %158, %159
br i1 %160, label %266, label %161
161: ; preds = %148
%162 = and i64 %146, 8589934588
%163 = sub nsw i64 %145, %162
%164 = add nsw i64 %162, -4
%165 = lshr exact i64 %164, 2
%166 = add nuw nsw i64 %165, 1
%167 = and i64 %166, 3
%168 = icmp ult i64 %164, 12
br i1 %168, label %240, label %169
169: ; preds = %161
%170 = and i64 %166, 9223372036854775804
br label %171
171: ; preds = %171, %169
%172 = phi i64 [ 0, %169 ], [ %237, %171 ]
%173 = phi i64 [ 0, %169 ], [ %238, %171 ]
%174 = sub i64 %145, %172
%175 = getelementptr inbounds double, double* %1, i64 %174
%176 = getelementptr inbounds double, double* %175, i64 -1
%177 = bitcast double* %176 to <2 x double>*
%178 = load <2 x double>, <2 x double>* %177
%179 = getelementptr inbounds double, double* %175, i64 -2
%180 = getelementptr inbounds double, double* %179, i64 -1
%181 = bitcast double* %180 to <2 x double>*
%182 = load <2 x double>, <2 x double>* %181
%183 = getelementptr inbounds double, double* %23, i64 %174
%184 = getelementptr inbounds double, double* %183, i64 -1
%185 = bitcast double* %184 to <2 x double>*
store <2 x double> %178, <2 x double>* %185
%186 = getelementptr inbounds double, double* %183, i64 -2
%187 = getelementptr inbounds double, double* %186, i64 -1
%188 = bitcast double* %187 to <2 x double>*
store <2 x double> %182, <2 x double>* %188
%189 = or i64 %172, 4
%190 = sub i64 %145, %189
%191 = getelementptr inbounds double, double* %1, i64 %190
%192 = getelementptr inbounds double, double* %191, i64 -1
%193 = bitcast double* %192 to <2 x double>*
%194 = load <2 x double>, <2 x double>* %193
%195 = getelementptr inbounds double, double* %191, i64 -2
%196 = getelementptr inbounds double, double* %195, i64 -1
%197 = bitcast double* %196 to <2 x double>*
%198 = load <2 x double>, <2 x double>* %197
%199 = getelementptr inbounds double, double* %23, i64 %190
%200 = getelementptr inbounds double, double* %199, i64 -1
%201 = bitcast double* %200 to <2 x double>*
store <2 x double> %194, <2 x double>* %201
%202 = getelementptr inbounds double, double* %199, i64 -2
%203 = getelementptr inbounds double, double* %202, i64 -1
%204 = bitcast double* %203 to <2 x double>*
store <2 x double> %198, <2 x double>* %204
%205 = or i64 %172, 8
%206 = sub i64 %145, %205
%207 = getelementptr inbounds double, double* %1, i64 %206
%208 = getelementptr inbounds double, double* %207, i64 -1
%209 = bitcast double* %208 to <2 x double>*
%210 = load <2 x double>, <2 x double>* %209
%211 = getelementptr inbounds double, double* %207, i64 -2
%212 = getelementptr inbounds double, double* %211, i64 -1
%213 = bitcast double* %212 to <2 x double>*
%214 = load <2 x double>, <2 x double>* %213
%215 = getelementptr inbounds double, double* %23, i64 %206
%216 = getelementptr inbounds double, double* %215, i64 -1
%217 = bitcast double* %216 to <2 x double>*
store <2 x double> %210, <2 x double>* %217
%218 = getelementptr inbounds double, double* %215, i64 -2
%219 = getelementptr inbounds double, double* %218, i64 -1
%220 = bitcast double* %219 to <2 x double>*
store <2 x double> %214, <2 x double>* %220
%221 = or i64 %172, 12
%222 = sub i64 %145, %221
%223 = getelementptr inbounds double, double* %1, i64 %222
%224 = getelementptr inbounds double, double* %223, i64 -1
%225 = bitcast double* %224 to <2 x double>*
%226 = load <2 x double>, <2 x double>* %225
%227 = getelementptr inbounds double, double* %223, i64 -2
%228 = getelementptr inbounds double, double* %227, i64 -1
%229 = bitcast double* %228 to <2 x double>*
%230 = load <2 x double>, <2 x double>* %229
%231 = getelementptr inbounds double, double* %23, i64 %222
%232 = getelementptr inbounds double, double* %231, i64 -1
%233 = bitcast double* %232 to <2 x double>*
store <2 x double> %226, <2 x double>* %233
%234 = getelementptr inbounds double, double* %231, i64 -2
%235 = getelementptr inbounds double, double* %234, i64 -1
%236 = bitcast double* %235 to <2 x double>*
store <2 x double> %230, <2 x double>* %236
%237 = add nuw i64 %172, 16
%238 = add nuw i64 %173, 4
%239 = icmp eq i64 %238, %170
br i1 %239, label %240, label %171
240: ; preds = %171, %161
%241 = phi i64 [ 0, %161 ], [ %237, %171 ]
%242 = icmp eq i64 %167, 0
br i1 %242, label %264, label %243
243: ; preds = %240, %243
%244 = phi i64 [ %261, %243 ], [ %241, %240 ]
%245 = phi i64 [ %262, %243 ], [ 0, %240 ]
%246 = sub i64 %145, %244
%247 = getelementptr inbounds double, double* %1, i64 %246
%248 = getelementptr inbounds double, double* %247, i64 -1
%249 = bitcast double* %248 to <2 x double>*
%250 = load <2 x double>, <2 x double>* %249
%251 = getelementptr inbounds double, double* %247, i64 -2
%252 = getelementptr inbounds double, double* %251, i64 -1
%253 = bitcast double* %252 to <2 x double>*
%254 = load <2 x double>, <2 x double>* %253
%255 = getelementptr inbounds double, double* %23, i64 %246
%256 = getelementptr inbounds double, double* %255, i64 -1
%257 = bitcast double* %256 to <2 x double>*
store <2 x double> %250, <2 x double>* %257
%258 = getelementptr inbounds double, double* %255, i64 -2
%259 = getelementptr inbounds double, double* %258, i64 -1
%260 = bitcast double* %259 to <2 x double>*
store <2 x double> %254, <2 x double>* %260
%261 = add nuw i64 %244, 4
%262 = add i64 %245, 1
%263 = icmp eq i64 %262, %167
br i1 %263, label %264, label %243
264: ; preds = %243, %240
%265 = icmp eq i64 %146, %162
br i1 %265, label %302, label %266
266: ; preds = %148, %144, %264
%267 = phi i64 [ %145, %148 ], [ %145, %144 ], [ %163, %264 ]
%268 = add nsw i64 %267, 1
%269 = and i64 %268, 3
%270 = icmp eq i64 %269, 0
br i1 %270, label %280, label %271
271: ; preds = %266, %271
%272 = phi i64 [ %277, %271 ], [ %267, %266 ]
%273 = phi i64 [ %278, %271 ], [ 0, %266 ]
%274 = getelementptr inbounds double, double* %1, i64 %272
%275 = load double, double* %274
%276 = getelementptr inbounds double, double* %23, i64 %272
store double %275, double* %276
%277 = add nsw i64 %272, -1
%278 = add i64 %273, 1
%279 = icmp eq i64 %278, %269
br i1 %279, label %280, label %271
280: ; preds = %271, %266
%281 = phi i64 [ %267, %266 ], [ %277, %271 ]
%282 = icmp ult i64 %267, 3
br i1 %282, label %302, label %283
283: ; preds = %280, %283
%284 = phi i64 [ %300, %283 ], [ %281, %280 ]
%285 = getelementptr inbounds double, double* %1, i64 %284
%286 = load double, double* %285
%287 = getelementptr inbounds double, double* %23, i64 %284
store double %286, double* %287
%288 = add nsw i64 %284, -1
%289 = getelementptr inbounds double, double* %1, i64 %288
%290 = load double, double* %289
%291 = getelementptr inbounds double, double* %23, i64 %288
store double %290, double* %291
%292 = add nsw i64 %284, -2
%293 = getelementptr inbounds double, double* %1, i64 %292
%294 = load double, double* %293
%295 = getelementptr inbounds double, double* %23, i64 %292
store double %294, double* %295
%296 = add nsw i64 %284, -3
%297 = getelementptr inbounds double, double* %1, i64 %296
%298 = load double, double* %297
%299 = getelementptr inbounds double, double* %23, i64 %296
store double %298, double* %299
%300 = add nsw i64 %284, -4
%301 = icmp eq i64 %296, 0
br i1 %301, label %302, label %283
302: ; preds = %280, %283, %264, %140
%303 = bitcast i8* %5 to i32*
%304 = icmp sgt i32 %3, 0
br i1 %304, label %305, label %879
305: ; preds = %302
%306 = icmp sgt i32 %4, 0
%307 = sext i32 %4 to i64
%308 = zext i32 %3 to i64
%309 = zext i32 %4 to i64
%310 = zext i32 %4 to i64
%311 = zext i32 %4 to i64
%312 = or i64 %20, 4
%313 = mul i64 %312, %16
%314 = shl nsw i64 %307, 3
%315 = shl nuw nsw i64 %309, 3
%316 = add i64 %313, %315
%317 = getelementptr i8, i8* %5, i64 %313
%318 = getelementptr i8, i8* %5, i64 %316
%319 = add nsw i64 %20, 8
%320 = shl nuw nsw i64 %308, 3
%321 = add nsw i64 %320, %17
%322 = shl nsw i64 %16, 3
%323 = getelementptr i8, i8* %5, i64 %17
%324 = add nsw i64 %308, -1
%325 = and i64 %309, 4294967292
%326 = add nsw i64 %325, -4
%327 = lshr exact i64 %326, 2
%328 = add nuw nsw i64 %327, 1
%329 = and i64 %309, 4294967294
%330 = add nsw i64 %329, -2
%331 = lshr exact i64 %330, 1
%332 = add nuw i64 %331, 1
%333 = and i64 %308, 1
%334 = icmp eq i64 %324, 0
%335 = and i64 %308, 4294967294
%336 = icmp eq i64 %333, 0
%337 = sub nsw i64 0, %308
%338 = icmp ult i32 %4, 4
%339 = and i64 %309, 4294967292
%340 = and i64 %328, 1
%341 = icmp eq i64 %326, 0
%342 = and i64 %328, 9223372036854775806
%343 = icmp eq i64 %340, 0
%344 = icmp eq i64 %339, %309
%345 = and i64 %309, 1
%346 = icmp eq i64 %345, 0
%347 = sub nsw i64 0, %309
%348 = icmp eq i32 %4, 1
%349 = and i64 %309, 4294967294
%350 = and i64 %332, 1
%351 = icmp eq i64 %330, 0
%352 = and i64 %332, -2
%353 = icmp eq i64 %350, 0
%354 = icmp eq i64 %349, %309
br label %358
355: ; preds = %876, %827
%356 = add nuw nsw i64 %359, 1
%357 = icmp eq i64 %724, %308
br i1 %357, label %388, label %358
358: ; preds = %355, %305
%359 = phi i64 [ 1, %305 ], [ %356, %355 ]
%360 = phi i64 [ 0, %305 ], [ %724, %355 ]
%361 = phi i32 [ 0, %305 ], [ %435, %355 ]
%362 = sub i64 %324, %360
%363 = add i64 %362, -2
%364 = lshr i64 %363, 1
%365 = add nuw i64 %364, 1
%366 = sub nsw i64 %308, %360
%367 = add i64 %366, -4
%368 = lshr i64 %367, 2
%369 = add nuw nsw i64 %368, 1
%370 = sub nsw i64 %308, %360
%371 = mul i64 %319, %360
%372 = add i64 %17, %371
%373 = getelementptr i8, i8* %5, i64 %372
%374 = mul i64 %322, %360
%375 = add i64 %321, %374
%376 = getelementptr i8, i8* %5, i64 %375
%377 = mul nsw i64 %360, -8
%378 = add i64 %321, %377
%379 = getelementptr i8, i8* %5, i64 %378
%380 = mul i64 %314, %360
%381 = add i64 %313, %380
%382 = getelementptr i8, i8* %5, i64 %381
%383 = add i64 %316, %380
%384 = getelementptr i8, i8* %5, i64 %383
%385 = xor i64 %360, -1
%386 = add nsw i64 %385, %308
%387 = getelementptr inbounds i32, i32* %303, i64 %360
br label %415
388: ; preds = %355
br i1 %304, label %389, label %879
389: ; preds = %388
%390 = icmp slt i32 %4, 1
%391 = sext i32 %4 to i64
%392 = zext i32 %4 to i64
%393 = add nsw i64 %16, -1
%394 = mul i64 %393, %307
%395 = shl i64 %394, 3
%396 = or i64 %20, 4
%397 = mul i64 %396, %16
%398 = add i64 %395, %397
%399 = mul nsw i64 %307, -8
%400 = shl nuw nsw i64 %309, 3
%401 = add i64 %398, %400
%402 = getelementptr i8, i8* %5, i64 %397
%403 = add i64 %397, %400
%404 = getelementptr i8, i8* %5, i64 %403
%405 = icmp ult i32 %4, 4
%406 = and i64 %309, 4294967292
%407 = and i64 %328, 1
%408 = icmp eq i64 %326, 0
%409 = and i64 %328, 9223372036854775806
%410 = icmp eq i64 %407, 0
%411 = icmp eq i64 %406, %309
%412 = and i64 %309, 1
%413 = icmp eq i64 %412, 0
%414 = sub nsw i64 0, %309
br label %1019
415: ; preds = %439, %358
%416 = phi i64 [ %360, %358 ], [ %440, %439 ]
%417 = phi double [ 0.000000e+00, %358 ], [ %436, %439 ]
%418 = phi i32 [ %361, %358 ], [ %435, %439 ]
%419 = mul nsw i64 %416, %16
%420 = trunc i64 %416 to i32
br label %421
421: ; preds = %415, %434
%422 = phi i64 [ %360, %415 ], [ %437, %434 ]
%423 = phi double [ %417, %415 ], [ %436, %434 ]
%424 = phi i32 [ %418, %415 ], [ %435, %434 ]
%425 = add nsw i64 %422, %419
%426 = getelementptr inbounds double, double* %19, i64 %425
%427 = load double, double* %426
%428 = fcmp olt double %427, 0.000000e+00
%429 = fneg double %427
%430 = select i1 %428, double %429, double %427
%431 = fcmp ogt double %430, %423
br i1 %431, label %432, label %434
432: ; preds = %421
%433 = trunc i64 %422 to i32
store i32 %433, i32* %387
br label %434
434: ; preds = %421, %432
%435 = phi i32 [ %420, %432 ], [ %424, %421 ]
%436 = phi double [ %430, %432 ], [ %423, %421 ]
%437 = add nuw nsw i64 %422, 1
%438 = icmp eq i64 %437, %308
br i1 %438, label %439, label %421
439: ; preds = %434
%440 = add nuw nsw i64 %416, 1
%441 = icmp eq i64 %440, %308
br i1 %441, label %442, label %415
442: ; preds = %439
%443 = fadd double %436, 1.000000e+00
%444 = fcmp oeq double %443, 1.000000e+00
br i1 %444, label %1163, label %445
445: ; preds = %442
%446 = getelementptr inbounds i32, i32* %303, i64 %360
%447 = load i32, i32* %446
%448 = zext i32 %447 to i64
%449 = icmp eq i64 %360, %448
br i1 %449, label %483, label %450
450: ; preds = %445
%451 = sext i32 %447 to i64
br i1 %334, label %473, label %452
452: ; preds = %450, %452
%453 = phi i64 [ %470, %452 ], [ 0, %450 ]
%454 = phi i64 [ %471, %452 ], [ 0, %450 ]
%455 = mul nsw i64 %453, %16
%456 = add nsw i64 %455, %360
%457 = add nsw i64 %455, %451
%458 = getelementptr inbounds double, double* %19, i64 %456
%459 = load double, double* %458
%460 = getelementptr inbounds double, double* %19, i64 %457
%461 = load double, double* %460
store double %461, double* %458
store double %459, double* %460
%462 = or i64 %453, 1
%463 = mul nsw i64 %462, %16
%464 = add nsw i64 %463, %360
%465 = add nsw i64 %463, %451
%466 = getelementptr inbounds double, double* %19, i64 %464
%467 = load double, double* %466
%468 = getelementptr inbounds double, double* %19, i64 %465
%469 = load double, double* %468
store double %469, double* %466
store double %467, double* %468
%470 = add nuw nsw i64 %453, 2
%471 = add i64 %454, 2
%472 = icmp eq i64 %471, %335
br i1 %472, label %473, label %452
473: ; preds = %452, %450
%474 = phi i64 [ 0, %450 ], [ %470, %452 ]
br i1 %336, label %483, label %475
475: ; preds = %473
%476 = mul nsw i64 %474, %16
%477 = add nsw i64 %476, %360
%478 = add nsw i64 %476, %451
%479 = getelementptr inbounds double, double* %19, i64 %477
%480 = load double, double* %479
%481 = getelementptr inbounds double, double* %19, i64 %478
%482 = load double, double* %481
store double %482, double* %479
store double %480, double* %481
br label %483
483: ; preds = %475, %473, %445
%484 = zext i32 %435 to i64
%485 = icmp eq i64 %360, %484
br i1 %485, label %719, label %486
486: ; preds = %483
%487 = mul nsw i64 %360, %16
%488 = mul nsw i32 %435, %3
%489 = sext i32 %488 to i64
%490 = icmp ult i64 %370, 4
br i1 %490, label %576, label %491
491: ; preds = %486
%492 = add i64 %360, %489
%493 = shl nsw i64 %492, 3
%494 = getelementptr i8, i8* %323, i64 %493
%495 = getelementptr i8, i8* %379, i64 %493
%496 = icmp ult i8* %373, %495
%497 = icmp ult i8* %494, %376
%498 = and i1 %496, %497
br i1 %498, label %576, label %499
499: ; preds = %491
%500 = and i64 %370, -4
%501 = add i64 %360, %500
%502 = and i64 %369, 1
%503 = icmp ult i64 %367, 4
br i1 %503, label %551, label %504
504: ; preds = %499
%505 = and i64 %369, 9223372036854775806
br label %506
506: ; preds = %506, %504
%507 = phi i64 [ 0, %504 ], [ %548, %506 ]
%508 = phi i64 [ 0, %504 ], [ %549, %506 ]
%509 = add i64 %360, %507
%510 = add nsw i64 %509, %487
%511 = add nsw i64 %509, %489
%512 = getelementptr inbounds double, double* %19, i64 %510
%513 = bitcast double* %512 to <2 x double>*
%514 = load <2 x double>, <2 x double>* %513
%515 = getelementptr inbounds double, double* %512, i64 2
%516 = bitcast double* %515 to <2 x double>*
%517 = load <2 x double>, <2 x double>* %516
%518 = getelementptr inbounds double, double* %19, i64 %511
%519 = bitcast double* %518 to <2 x double>*
%520 = load <2 x double>, <2 x double>* %519
%521 = getelementptr inbounds double, double* %518, i64 2
%522 = bitcast double* %521 to <2 x double>*
%523 = load <2 x double>, <2 x double>* %522
%524 = bitcast double* %512 to <2 x double>*
store <2 x double> %520, <2 x double>* %524
%525 = bitcast double* %515 to <2 x double>*
store <2 x double> %523, <2 x double>* %525
%526 = bitcast double* %518 to <2 x double>*
store <2 x double> %514, <2 x double>* %526
%527 = bitcast double* %521 to <2 x double>*
store <2 x double> %517, <2 x double>* %527
%528 = or i64 %507, 4
%529 = add i64 %360, %528
%530 = add nsw i64 %529, %487
%531 = add nsw i64 %529, %489
%532 = getelementptr inbounds double, double* %19, i64 %530
%533 = bitcast double* %532 to <2 x double>*
%534 = load <2 x double>, <2 x double>* %533
%535 = getelementptr inbounds double, double* %532, i64 2
%536 = bitcast double* %535 to <2 x double>*
%537 = load <2 x double>, <2 x double>* %536
%538 = getelementptr inbounds double, double* %19, i64 %531
%539 = bitcast double* %538 to <2 x double>*
%540 = load <2 x double>, <2 x double>* %539
%541 = getelementptr inbounds double, double* %538, i64 2
%542 = bitcast double* %541 to <2 x double>*
%543 = load <2 x double>, <2 x double>* %542
%544 = bitcast double* %532 to <2 x double>*
store <2 x double> %540, <2 x double>* %544
%545 = bitcast double* %535 to <2 x double>*
store <2 x double> %543, <2 x double>* %545
%546 = bitcast double* %538 to <2 x double>*
store <2 x double> %534, <2 x double>* %546
%547 = bitcast double* %541 to <2 x double>*
store <2 x double> %537, <2 x double>* %547
%548 = add nuw i64 %507, 8
%549 = add i64 %508, 2
%550 = icmp eq i64 %549, %505
br i1 %550, label %551, label %506
551: ; preds = %506, %499
%552 = phi i64 [ 0, %499 ], [ %548, %506 ]
%553 = icmp eq i64 %502, 0
br i1 %553, label %574, label %554
554: ; preds = %551
%555 = add i64 %360, %552
%556 = add nsw i64 %555, %487
%557 = add nsw i64 %555, %489
%558 = getelementptr inbounds double, double* %19, i64 %556
%559 = bitcast double* %558 to <2 x double>*
%560 = load <2 x double>, <2 x double>* %559
%561 = getelementptr inbounds double, double* %558, i64 2
%562 = bitcast double* %561 to <2 x double>*
%563 = load <2 x double>, <2 x double>* %562
%564 = getelementptr inbounds double, double* %19, i64 %557
%565 = bitcast double* %564 to <2 x double>*
%566 = load <2 x double>, <2 x double>* %565
%567 = getelementptr inbounds double, double* %564, i64 2
%568 = bitcast double* %567 to <2 x double>*
%569 = load <2 x double>, <2 x double>* %568
%570 = bitcast double* %558 to <2 x double>*
store <2 x double> %566, <2 x double>* %570
%571 = bitcast double* %561 to <2 x double>*
store <2 x double> %569, <2 x double>* %571
%572 = bitcast double* %564 to <2 x double>*
store <2 x double> %560, <2 x double>* %572
%573 = bitcast double* %567 to <2 x double>*
store <2 x double> %563, <2 x double>* %573
br label %574
574: ; preds = %551, %554
%575 = icmp eq i64 %370, %500
br i1 %575, label %593, label %576
576: ; preds = %491, %486, %574
%577 = phi i64 [ %360, %491 ], [ %360, %486 ], [ %501, %574 ]
%578 = sub i64 %308, %577
%579 = xor i64 %577, -1
%580 = and i64 %578, 1
%581 = icmp eq i64 %580, 0
br i1 %581, label %590, label %582
582: ; preds = %576
%583 = add nsw i64 %577, %487
%584 = add nsw i64 %577, %489
%585 = getelementptr inbounds double, double* %19, i64 %583
%586 = load double, double* %585
%587 = getelementptr inbounds double, double* %19, i64 %584
%588 = load double, double* %587
store double %588, double* %585
store double %586, double* %587
%589 = add nuw nsw i64 %577, 1
br label %590
590: ; preds = %582, %576
%591 = phi i64 [ %577, %576 ], [ %589, %582 ]
%592 = icmp eq i64 %579, %337
br i1 %592, label %593, label %685
593: ; preds = %590, %685, %574
br i1 %306, label %594, label %719
594: ; preds = %593
%595 = mul nsw i64 %360, %307
%596 = mul nsw i32 %435, %4
%597 = sext i32 %596 to i64
br i1 %338, label %671, label %598
598: ; preds = %594
%599 = shl nsw i64 %597, 3
%600 = getelementptr i8, i8* %317, i64 %599
%601 = getelementptr i8, i8* %318, i64 %599
%602 = icmp ult i8* %382, %601
%603 = icmp ult i8* %600, %384
%604 = and i1 %602, %603
br i1 %604, label %671, label %605
605: ; preds = %598
br i1 %341, label %649, label %606
606: ; preds = %605, %606
%607 = phi i64 [ %646, %606 ], [ 0, %605 ]
%608 = phi i64 [ %647, %606 ], [ 0, %605 ]
%609 = add nsw i64 %607, %595
%610 = add nsw i64 %607, %597
%611 = getelementptr inbounds double, double* %23, i64 %609
%612 = bitcast double* %611 to <2 x double>*
%613 = load <2 x double>, <2 x double>* %612
%614 = getelementptr inbounds double, double* %611, i64 2
%615 = bitcast double* %614 to <2 x double>*
%616 = load <2 x double>, <2 x double>* %615
%617 = getelementptr inbounds double, double* %23, i64 %610
%618 = bitcast double* %617 to <2 x double>*
%619 = load <2 x double>, <2 x double>* %618
%620 = getelementptr inbounds double, double* %617, i64 2
%621 = bitcast double* %620 to <2 x double>*
%622 = load <2 x double>, <2 x double>* %621
%623 = bitcast double* %611 to <2 x double>*
store <2 x double> %619, <2 x double>* %623
%624 = bitcast double* %614 to <2 x double>*
store <2 x double> %622, <2 x double>* %624
%625 = bitcast double* %617 to <2 x double>*
store <2 x double> %613, <2 x double>* %625
%626 = bitcast double* %620 to <2 x double>*
store <2 x double> %616, <2 x double>* %626
%627 = or i64 %607, 4
%628 = add nsw i64 %627, %595
%629 = add nsw i64 %627, %597
%630 = getelementptr inbounds double, double* %23, i64 %628
%631 = bitcast double* %630 to <2 x double>*
%632 = load <2 x double>, <2 x double>* %631
%633 = getelementptr inbounds double, double* %630, i64 2
%634 = bitcast double* %633 to <2 x double>*
%635 = load <2 x double>, <2 x double>* %634
%636 = getelementptr inbounds double, double* %23, i64 %629
%637 = bitcast double* %636 to <2 x double>*
%638 = load <2 x double>, <2 x double>* %637
%639 = getelementptr inbounds double, double* %636, i64 2
%640 = bitcast double* %639 to <2 x double>*
%641 = load <2 x double>, <2 x double>* %640
%642 = bitcast double* %630 to <2 x double>*
store <2 x double> %638, <2 x double>* %642
%643 = bitcast double* %633 to <2 x double>*
store <2 x double> %641, <2 x double>* %643
%644 = bitcast double* %636 to <2 x double>*
store <2 x double> %632, <2 x double>* %644
%645 = bitcast double* %639 to <2 x double>*
store <2 x double> %635, <2 x double>* %645
%646 = add nuw i64 %607, 8
%647 = add i64 %608, 2
%648 = icmp eq i64 %647, %342
br i1 %648, label %649, label %606
649: ; preds = %606, %605
%650 = phi i64 [ 0, %605 ], [ %646, %606 ]
br i1 %343, label %670, label %651
651: ; preds = %649
%652 = add nsw i64 %650, %595
%653 = add nsw i64 %650, %597
%654 = getelementptr inbounds double, double* %23, i64 %652
%655 = bitcast double* %654 to <2 x double>*
%656 = load <2 x double>, <2 x double>* %655
%657 = getelementptr inbounds double, double* %654, i64 2
%658 = bitcast double* %657 to <2 x double>*
%659 = load <2 x double>, <2 x double>* %658
%660 = getelementptr inbounds double, double* %23, i64 %653
%661 = bitcast double* %660 to <2 x double>*
%662 = load <2 x double>, <2 x double>* %661
%663 = getelementptr inbounds double, double* %660, i64 2
%664 = bitcast double* %663 to <2 x double>*
%665 = load <2 x double>, <2 x double>* %664
%666 = bitcast double* %654 to <2 x double>*
store <2 x double> %662, <2 x double>* %666
%667 = bitcast double* %657 to <2 x double>*
store <2 x double> %665, <2 x double>* %667
%668 = bitcast double* %660 to <2 x double>*
store <2 x double> %656, <2 x double>* %668
%669 = bitcast double* %663 to <2 x double>*
store <2 x double> %659, <2 x double>* %669
br label %670
670: ; preds = %649, %651
br i1 %344, label %719, label %671
671: ; preds = %598, %594, %670
%672 = phi i64 [ 0, %598 ], [ 0, %594 ], [ %339, %670 ]
%673 = xor i64 %672, -1
br i1 %346, label %682, label %674
674: ; preds = %671
%675 = add nsw i64 %672, %595
%676 = add nsw i64 %672, %597
%677 = getelementptr inbounds double, double* %23, i64 %675
%678 = load double, double* %677
%679 = getelementptr inbounds double, double* %23, i64 %676
%680 = load double, double* %679
store double %680, double* %677
store double %678, double* %679
%681 = or i64 %672, 1
br label %682
682: ; preds = %674, %671
%683 = phi i64 [ %672, %671 ], [ %681, %674 ]
%684 = icmp eq i64 %673, %347
br i1 %684, label %719, label %702
685: ; preds = %590, %685
%686 = phi i64 [ %700, %685 ], [ %591, %590 ]
%687 = add nsw i64 %686, %487
%688 = add nsw i64 %686, %489
%689 = getelementptr inbounds double, double* %19, i64 %687
%690 = load double, double* %689
%691 = getelementptr inbounds double, double* %19, i64 %688
%692 = load double, double* %691
store double %692, double* %689
store double %690, double* %691
%693 = add nuw nsw i64 %686, 1
%694 = add nsw i64 %693, %487
%695 = add nsw i64 %693, %489
%696 = getelementptr inbounds double, double* %19, i64 %694
%697 = load double, double* %696
%698 = getelementptr inbounds double, double* %19, i64 %695
%699 = load double, double* %698
store double %699, double* %696
store double %697, double* %698
%700 = add nuw nsw i64 %686, 2
%701 = icmp eq i64 %700, %308
br i1 %701, label %593, label %685
702: ; preds = %682, %702
%703 = phi i64 [ %717, %702 ], [ %683, %682 ]
%704 = add nsw i64 %703, %595
%705 = add nsw i64 %703, %597
%706 = getelementptr inbounds double, double* %23, i64 %704
%707 = load double, double* %706
%708 = getelementptr inbounds double, double* %23, i64 %705
%709 = load double, double* %708
store double %709, double* %706
store double %707, double* %708
%710 = add nuw nsw i64 %703, 1
%711 = add nsw i64 %710, %595
%712 = add nsw i64 %710, %597
%713 = getelementptr inbounds double, double* %23, i64 %711
%714 = load double, double* %713
%715 = getelementptr inbounds double, double* %23, i64 %712
%716 = load double, double* %715
store double %716, double* %713
store double %714, double* %715
%717 = add nuw nsw i64 %703, 2
%718 = icmp eq i64 %717, %309
br i1 %718, label %719, label %702
719: ; preds = %682, %702, %670, %593, %483
%720 = mul nsw i64 %360, %16
%721 = add nsw i64 %720, %360
%722 = getelementptr inbounds double, double* %19, i64 %721
%723 = load double, double* %722
%724 = add nuw nsw i64 %360, 1
%725 = icmp slt i64 %724, %16
br i1 %725, label %726, label %773
726: ; preds = %719
%727 = icmp ult i64 %386, 2
br i1 %727, label %771, label %728
728: ; preds = %726
%729 = and i64 %386, -2
%730 = add i64 %359, %729
%731 = insertelement <2 x double> poison, double %723, i64 0
%732 = shufflevector <2 x double> %731, <2 x double> poison, <2 x i32> zeroinitializer
%733 = and i64 %365, 1
%734 = icmp ult i64 %363, 2
br i1 %734, label %758, label %735
735: ; preds = %728
%736 = and i64 %365, -2
br label %737
737: ; preds = %737, %735
%738 = phi i64 [ 0, %735 ], [ %755, %737 ]
%739 = phi i64 [ 0, %735 ], [ %756, %737 ]
%740 = add i64 %359, %738
%741 = add nsw i64 %740, %720
%742 = getelementptr inbounds double, double* %19, i64 %741
%743 = bitcast double* %742 to <2 x double>*
%744 = load <2 x double>, <2 x double>* %743
%745 = fdiv <2 x double> %744, %732
%746 = bitcast double* %742 to <2 x double>*
store <2 x double> %745, <2 x double>* %746
%747 = or i64 %738, 2
%748 = add i64 %359, %747
%749 = add nsw i64 %748, %720
%750 = getelementptr inbounds double, double* %19, i64 %749
%751 = bitcast double* %750 to <2 x double>*
%752 = load <2 x double>, <2 x double>* %751
%753 = fdiv <2 x double> %752, %732
%754 = bitcast double* %750 to <2 x double>*
store <2 x double> %753, <2 x double>* %754
%755 = add nuw i64 %738, 4
%756 = add nuw i64 %739, 2
%757 = icmp eq i64 %756, %736
br i1 %757, label %758, label %737
758: ; preds = %737, %728
%759 = phi i64 [ 0, %728 ], [ %755, %737 ]
%760 = icmp eq i64 %733, 0
br i1 %760, label %769, label %761
761: ; preds = %758
%762 = add i64 %359, %759
%763 = add nsw i64 %762, %720
%764 = getelementptr inbounds double, double* %19, i64 %763
%765 = bitcast double* %764 to <2 x double>*
%766 = load <2 x double>, <2 x double>* %765
%767 = fdiv <2 x double> %766, %732
%768 = bitcast double* %764 to <2 x double>*
store <2 x double> %767, <2 x double>* %768
br label %769
769: ; preds = %758, %761
%770 = icmp eq i64 %386, %729
br i1 %770, label %773, label %771
771: ; preds = %726, %769
%772 = phi i64 [ %359, %726 ], [ %730, %769 ]
br label %810
773: ; preds = %810, %769, %719
br i1 %306, label %774, label %818
774: ; preds = %773
%775 = mul nsw i64 %360, %307
br i1 %348, label %808, label %776
776: ; preds = %774
%777 = insertelement <2 x double> poison, double %723, i64 0
%778 = shufflevector <2 x double> %777, <2 x double> poison, <2 x i32> zeroinitializer
br i1 %351, label %798, label %779
779: ; preds = %776, %779
%780 = phi i64 [ %795, %779 ], [ 0, %776 ]
%781 = phi i64 [ %796, %779 ], [ 0, %776 ]
%782 = add nsw i64 %780, %775
%783 = getelementptr inbounds double, double* %23, i64 %782
%784 = bitcast double* %783 to <2 x double>*
%785 = load <2 x double>, <2 x double>* %784
%786 = fdiv <2 x double> %785, %778
%787 = bitcast double* %783 to <2 x double>*
store <2 x double> %786, <2 x double>* %787
%788 = or i64 %780, 2
%789 = add nsw i64 %788, %775
%790 = getelementptr inbounds double, double* %23, i64 %789
%791 = bitcast double* %790 to <2 x double>*
%792 = load <2 x double>, <2 x double>* %791
%793 = fdiv <2 x double> %792, %778
%794 = bitcast double* %790 to <2 x double>*
store <2 x double> %793, <2 x double>* %794
%795 = add nuw i64 %780, 4
%796 = add nuw i64 %781, 2
%797 = icmp eq i64 %796, %352
br i1 %797, label %798, label %779
798: ; preds = %779, %776
%799 = phi i64 [ 0, %776 ], [ %795, %779 ]
br i1 %353, label %807, label %800
800: ; preds = %798
%801 = add nsw i64 %799, %775
%802 = getelementptr inbounds double, double* %23, i64 %801
%803 = bitcast double* %802 to <2 x double>*
%804 = load <2 x double>, <2 x double>* %803
%805 = fdiv <2 x double> %804, %778
%806 = bitcast double* %802 to <2 x double>*
store <2 x double> %805, <2 x double>* %806
br label %807
807: ; preds = %798, %800
br i1 %354, label %818, label %808
808: ; preds = %774, %807
%809 = phi i64 [ 0, %774 ], [ %349, %807 ]
br label %819
810: ; preds = %771, %810
%811 = phi i64 [ %816, %810 ], [ %772, %771 ]
%812 = add nsw i64 %811, %720
%813 = getelementptr inbounds double, double* %19, i64 %812
%814 = load double, double* %813
%815 = fdiv double %814, %723
store double %815, double* %813
%816 = add nuw nsw i64 %811, 1
%817 = icmp eq i64 %816, %308
br i1 %817, label %773, label %810
818: ; preds = %819, %807, %773
br i1 %725, label %830, label %827
819: ; preds = %808, %819
%820 = phi i64 [ %825, %819 ], [ %809, %808 ]
%821 = add nsw i64 %820, %775
%822 = getelementptr inbounds double, double* %23, i64 %821
%823 = load double, double* %822
%824 = fdiv double %823, %723
store double %824, double* %822
%825 = add nuw nsw i64 %820, 1
%826 = icmp eq i64 %825, %310
br i1 %826, label %818, label %819
827: ; preds = %851, %818
br i1 %306, label %828, label %355
828: ; preds = %827
%829 = mul nsw i64 %360, %307
br label %854
830: ; preds = %818, %851
%831 = phi i64 [ %852, %851 ], [ %359, %818 ]
%832 = add nsw i64 %831, %720
%833 = getelementptr inbounds double, double* %19, i64 %832
br label %834
834: ; preds = %830, %848
%835 = phi i64 [ 0, %830 ], [ %849, %848 ]
%836 = mul nsw i64 %835, %16
%837 = icmp eq i64 %835, %360
br i1 %837, label %848, label %838
838: ; preds = %834
%839 = add nsw i64 %836, %831
%840 = getelementptr inbounds double, double* %19, i64 %839
%841 = load double, double* %840
%842 = add nsw i64 %836, %360
%843 = getelementptr inbounds double, double* %19, i64 %842
%844 = load double, double* %843
%845 = load double, double* %833
%846 = fneg double %844
%847 = tail call double @llvm.fmuladd.f64(double %846, double %845, double %841)
store double %847, double* %840
br label %848
848: ; preds = %834, %838
%849 = add nuw nsw i64 %835, 1
%850 = icmp eq i64 %849, %308
br i1 %850, label %851, label %834
851: ; preds = %848
%852 = add nuw nsw i64 %831, 1
%853 = icmp eq i64 %852, %308
br i1 %853, label %827, label %830
854: ; preds = %876, %828
%855 = phi i64 [ 0, %828 ], [ %877, %876 ]
%856 = add nsw i64 %855, %829
%857 = getelementptr inbounds double, double* %23, i64 %856
br label %858
858: ; preds = %854, %873
%859 = phi i64 [ 0, %854 ], [ %874, %873 ]
%860 = icmp eq i64 %859, %360
br i1 %860, label %873, label %861
861: ; preds = %858
%862 = mul nsw i64 %859, %307
%863 = add nsw i64 %862, %855
%864 = getelementptr inbounds double, double* %23, i64 %863
%865 = load double, double* %864
%866 = mul nsw i64 %859, %16
%867 = add nsw i64 %866, %360
%868 = getelementptr inbounds double, double* %19, i64 %867
%869 = load double, double* %868
%870 = load double, double* %857
%871 = fneg double %869
%872 = tail call double @llvm.fmuladd.f64(double %871, double %870, double %865)
store double %872, double* %864
br label %873
873: ; preds = %858, %861
%874 = add nuw nsw i64 %859, 1
%875 = icmp eq i64 %874, %308
br i1 %875, label %876, label %858
876: ; preds = %873
%877 = add nuw nsw i64 %855, 1
%878 = icmp eq i64 %877, %311
br i1 %878, label %355, label %854
879: ; preds = %1141, %302, %388
br i1 %143, label %880, label %1163
880: ; preds = %879
%881 = zext i32 %142 to i64
%882 = add nuw nsw i64 %881, 1
%883 = icmp ult i32 %142, 3
br i1 %883, label %1002, label %884
884: ; preds = %880
%885 = add nuw nsw i64 %881, 1
%886 = getelementptr double, double* %2, i64 %885
%887 = bitcast double* %886 to i8*
%888 = or i64 %20, 4
%889 = mul i64 %888, %16
%890 = shl nuw nsw i64 %881, 3
%891 = add i64 %889, %890
%892 = add i64 %891, 8
%893 = getelementptr i8, i8* %5, i64 %892
%894 = icmp ugt i8* %893, %8
%895 = icmp ult i8* %22, %887
%896 = and i1 %894, %895
br i1 %896, label %1002, label %897
897: ; preds = %884
%898 = and i64 %882, 8589934588
%899 = sub nsw i64 %881, %898
%900 = add nsw i64 %898, -4
%901 = lshr exact i64 %900, 2
%902 = add nuw nsw i64 %901, 1
%903 = and i64 %902, 3
%904 = icmp ult i64 %900, 12
br i1 %904, label %976, label %905
905: ; preds = %897
%906 = and i64 %902, 9223372036854775804
br label %907
907: ; preds = %907, %905
%908 = phi i64 [ 0, %905 ], [ %973, %907 ]
%909 = phi i64 [ 0, %905 ], [ %974, %907 ]
%910 = sub i64 %881, %908
%911 = getelementptr inbounds double, double* %23, i64 %910
%912 = getelementptr inbounds double, double* %911, i64 -1
%913 = bitcast double* %912 to <2 x double>*
%914 = load <2 x double>, <2 x double>* %913
%915 = getelementptr inbounds double, double* %911, i64 -2
%916 = getelementptr inbounds double, double* %915, i64 -1
%917 = bitcast double* %916 to <2 x double>*
%918 = load <2 x double>, <2 x double>* %917
%919 = getelementptr inbounds double, double* %2, i64 %910
%920 = getelementptr inbounds double, double* %919, i64 -1
%921 = bitcast double* %920 to <2 x double>*
store <2 x double> %914, <2 x double>* %921
%922 = getelementptr inbounds double, double* %919, i64 -2
%923 = getelementptr inbounds double, double* %922, i64 -1
%924 = bitcast double* %923 to <2 x double>*
store <2 x double> %918, <2 x double>* %924
%925 = or i64 %908, 4
%926 = sub i64 %881, %925
%927 = getelementptr inbounds double, double* %23, i64 %926
%928 = getelementptr inbounds double, double* %927, i64 -1
%929 = bitcast double* %928 to <2 x double>*
%930 = load <2 x double>, <2 x double>* %929
%931 = getelementptr inbounds double, double* %927, i64 -2
%932 = getelementptr inbounds double, double* %931, i64 -1
%933 = bitcast double* %932 to <2 x double>*
%934 = load <2 x double>, <2 x double>* %933
%935 = getelementptr inbounds double, double* %2, i64 %926
%936 = getelementptr inbounds double, double* %935, i64 -1
%937 = bitcast double* %936 to <2 x double>*
store <2 x double> %930, <2 x double>* %937
%938 = getelementptr inbounds double, double* %935, i64 -2
%939 = getelementptr inbounds double, double* %938, i64 -1
%940 = bitcast double* %939 to <2 x double>*
store <2 x double> %934, <2 x double>* %940
%941 = or i64 %908, 8
%942 = sub i64 %881, %941
%943 = getelementptr inbounds double, double* %23, i64 %942
%944 = getelementptr inbounds double, double* %943, i64 -1
%945 = bitcast double* %944 to <2 x double>*
%946 = load <2 x double>, <2 x double>* %945
%947 = getelementptr inbounds double, double* %943, i64 -2
%948 = getelementptr inbounds double, double* %947, i64 -1
%949 = bitcast double* %948 to <2 x double>*
%950 = load <2 x double>, <2 x double>* %949
%951 = getelementptr inbounds double, double* %2, i64 %942
%952 = getelementptr inbounds double, double* %951, i64 -1
%953 = bitcast double* %952 to <2 x double>*
store <2 x double> %946, <2 x double>* %953
%954 = getelementptr inbounds double, double* %951, i64 -2
%955 = getelementptr inbounds double, double* %954, i64 -1
%956 = bitcast double* %955 to <2 x double>*
store <2 x double> %950, <2 x double>* %956
%957 = or i64 %908, 12
%958 = sub i64 %881, %957
%959 = getelementptr inbounds double, double* %23, i64 %958
%960 = getelementptr inbounds double, double* %959, i64 -1
%961 = bitcast double* %960 to <2 x double>*
%962 = load <2 x double>, <2 x double>* %961
%963 = getelementptr inbounds double, double* %959, i64 -2
%964 = getelementptr inbounds double, double* %963, i64 -1
%965 = bitcast double* %964 to <2 x double>*
%966 = load <2 x double>, <2 x double>* %965
%967 = getelementptr inbounds double, double* %2, i64 %958
%968 = getelementptr inbounds double, double* %967, i64 -1
%969 = bitcast double* %968 to <2 x double>*
store <2 x double> %962, <2 x double>* %969
%970 = getelementptr inbounds double, double* %967, i64 -2
%971 = getelementptr inbounds double, double* %970, i64 -1
%972 = bitcast double* %971 to <2 x double>*
store <2 x double> %966, <2 x double>* %972
%973 = add nuw i64 %908, 16
%974 = add nuw i64 %909, 4
%975 = icmp eq i64 %974, %906
br i1 %975, label %976, label %907
976: ; preds = %907, %897
%977 = phi i64 [ 0, %897 ], [ %973, %907 ]
%978 = icmp eq i64 %903, 0
br i1 %978, label %1000, label %979
979: ; preds = %976, %979
%980 = phi i64 [ %997, %979 ], [ %977, %976 ]
%981 = phi i64 [ %998, %979 ], [ 0, %976 ]
%982 = sub i64 %881, %980
%983 = getelementptr inbounds double, double* %23, i64 %982
%984 = getelementptr inbounds double, double* %983, i64 -1
%985 = bitcast double* %984 to <2 x double>*
%986 = load <2 x double>, <2 x double>* %985
%987 = getelementptr inbounds double, double* %983, i64 -2
%988 = getelementptr inbounds double, double* %987, i64 -1
%989 = bitcast double* %988 to <2 x double>*
%990 = load <2 x double>, <2 x double>* %989
%991 = getelementptr inbounds double, double* %2, i64 %982
%992 = getelementptr inbounds double, double* %991, i64 -1
%993 = bitcast double* %992 to <2 x double>*
store <2 x double> %986, <2 x double>* %993
%994 = getelementptr inbounds double, double* %991, i64 -2
%995 = getelementptr inbounds double, double* %994, i64 -1
%996 = bitcast double* %995 to <2 x double>*
store <2 x double> %990, <2 x double>* %996
%997 = add nuw i64 %980, 4
%998 = add i64 %981, 1
%999 = icmp eq i64 %998, %903
br i1 %999, label %1000, label %979
1000: ; preds = %979, %976
%1001 = icmp eq i64 %882, %898
br i1 %1001, label %1163, label %1002
1002: ; preds = %884, %880, %1000
%1003 = phi i64 [ %881, %884 ], [ %881, %880 ], [ %899, %1000 ]
%1004 = add nsw i64 %1003, 1
%1005 = and i64 %1004, 3
%1006 = icmp eq i64 %1005, 0
br i1 %1006, label %1016, label %1007
1007: ; preds = %1002, %1007
%1008 = phi i64 [ %1013, %1007 ], [ %1003, %1002 ]
%1009 = phi i64 [ %1014, %1007 ], [ 0, %1002 ]
%1010 = getelementptr inbounds double, double* %23, i64 %1008
%1011 = load double, double* %1010
%1012 = getelementptr inbounds double, double* %2, i64 %1008
store double %1011, double* %1012
%1013 = add nsw i64 %1008, -1
%1014 = add i64 %1009, 1
%1015 = icmp eq i64 %1014, %1005
br i1 %1015, label %1016, label %1007
1016: ; preds = %1007, %1002
%1017 = phi i64 [ %1003, %1002 ], [ %1013, %1007 ]
%1018 = icmp ult i64 %1003, 3
br i1 %1018, label %1163, label %1144
1019: ; preds = %389, %1141
%1020 = phi i64 [ 0, %389 ], [ %1143, %1141 ]
%1021 = phi i64 [ %16, %389 ], [ %1027, %1141 ]
%1022 = mul i64 %399, %1020
%1023 = add i64 %398, %1022
%1024 = getelementptr i8, i8* %5, i64 %1023
%1025 = add i64 %401, %1022
%1026 = getelementptr i8, i8* %5, i64 %1025
%1027 = add nsw i64 %1021, -1
%1028 = getelementptr inbounds i32, i32* %303, i64 %1027
%1029 = load i32, i32* %1028
%1030 = zext i32 %1029 to i64
%1031 = icmp eq i64 %1027, %1030
%1032 = or i1 %1031, %390
br i1 %1032, label %1141, label %1033
1033: ; preds = %1019
%1034 = mul nsw i64 %1027, %391
%1035 = mul nsw i32 %1029, %4
%1036 = sext i32 %1035 to i64
br i1 %405, label %1110, label %1037
1037: ; preds = %1033
%1038 = shl nsw i64 %1036, 3
%1039 = getelementptr i8, i8* %402, i64 %1038
%1040 = getelementptr i8, i8* %404, i64 %1038
%1041 = icmp ult i8* %1024, %1040
%1042 = icmp ult i8* %1039, %1026
%1043 = and i1 %1041, %1042
br i1 %1043, label %1110, label %1044
1044: ; preds = %1037
br i1 %408, label %1088, label %1045
1045: ; preds = %1044, %1045
%1046 = phi i64 [ %1085, %1045 ], [ 0, %1044 ]
%1047 = phi i64 [ %1086, %1045 ], [ 0, %1044 ]
%1048 = add nsw i64 %1046, %1034
%1049 = add nsw i64 %1046, %1036
%1050 = getelementptr inbounds double, double* %23, i64 %1048
%1051 = bitcast double* %1050 to <2 x double>*
%1052 = load <2 x double>, <2 x double>* %1051
%1053 = getelementptr inbounds double, double* %1050, i64 2
%1054 = bitcast double* %1053 to <2 x double>*
%1055 = load <2 x double>, <2 x double>* %1054
%1056 = getelementptr inbounds double, double* %23, i64 %1049
%1057 = bitcast double* %1056 to <2 x double>*
%1058 = load <2 x double>, <2 x double>* %1057
%1059 = getelementptr inbounds double, double* %1056, i64 2
%1060 = bitcast double* %1059 to <2 x double>*
%1061 = load <2 x double>, <2 x double>* %1060
%1062 = bitcast double* %1050 to <2 x double>*
store <2 x double> %1058, <2 x double>* %1062
%1063 = bitcast double* %1053 to <2 x double>*
store <2 x double> %1061, <2 x double>* %1063
%1064 = bitcast double* %1056 to <2 x double>*
store <2 x double> %1052, <2 x double>* %1064
%1065 = bitcast double* %1059 to <2 x double>*
store <2 x double> %1055, <2 x double>* %1065
%1066 = or i64 %1046, 4
%1067 = add nsw i64 %1066, %1034
%1068 = add nsw i64 %1066, %1036
%1069 = getelementptr inbounds double, double* %23, i64 %1067
%1070 = bitcast double* %1069 to <2 x double>*
%1071 = load <2 x double>, <2 x double>* %1070
%1072 = getelementptr inbounds double, double* %1069, i64 2
%1073 = bitcast double* %1072 to <2 x double>*
%1074 = load <2 x double>, <2 x double>* %1073
%1075 = getelementptr inbounds double, double* %23, i64 %1068
%1076 = bitcast double* %1075 to <2 x double>*
%1077 = load <2 x double>, <2 x double>* %1076
%1078 = getelementptr inbounds double, double* %1075, i64 2
%1079 = bitcast double* %1078 to <2 x double>*
%1080 = load <2 x double>, <2 x double>* %1079
%1081 = bitcast double* %1069 to <2 x double>*
store <2 x double> %1077, <2 x double>* %1081
%1082 = bitcast double* %1072 to <2 x double>*
store <2 x double> %1080, <2 x double>* %1082
%1083 = bitcast double* %1075 to <2 x double>*
store <2 x double> %1071, <2 x double>* %1083
%1084 = bitcast double* %1078 to <2 x double>*
store <2 x double> %1074, <2 x double>* %1084
%1085 = add nuw i64 %1046, 8
%1086 = add i64 %1047, 2
%1087 = icmp eq i64 %1086, %409
br i1 %1087, label %1088, label %1045
1088: ; preds = %1045, %1044
%1089 = phi i64 [ 0, %1044 ], [ %1085, %1045 ]
br i1 %410, label %1109, label %1090
1090: ; preds = %1088
%1091 = add nsw i64 %1089, %1034
%1092 = add nsw i64 %1089, %1036
%1093 = getelementptr inbounds double, double* %23, i64 %1091
%1094 = bitcast double* %1093 to <2 x double>*
%1095 = load <2 x double>, <2 x double>* %1094
%1096 = getelementptr inbounds double, double* %1093, i64 2
%1097 = bitcast double* %1096 to <2 x double>*
%1098 = load <2 x double>, <2 x double>* %1097
%1099 = getelementptr inbounds double, double* %23, i64 %1092
%1100 = bitcast double* %1099 to <2 x double>*
%1101 = load <2 x double>, <2 x double>* %1100
%1102 = getelementptr inbounds double, double* %1099, i64 2
%1103 = bitcast double* %1102 to <2 x double>*
%1104 = load <2 x double>, <2 x double>* %1103
%1105 = bitcast double* %1093 to <2 x double>*
store <2 x double> %1101, <2 x double>* %1105
%1106 = bitcast double* %1096 to <2 x double>*
store <2 x double> %1104, <2 x double>* %1106
%1107 = bitcast double* %1099 to <2 x double>*
store <2 x double> %1095, <2 x double>* %1107
%1108 = bitcast double* %1102 to <2 x double>*
store <2 x double> %1098, <2 x double>* %1108
br label %1109
1109: ; preds = %1088, %1090
br i1 %411, label %1141, label %1110
1110: ; preds = %1037, %1033, %1109
%1111 = phi i64 [ 0, %1037 ], [ 0, %1033 ], [ %406, %1109 ]
%1112 = xor i64 %1111, -1
br i1 %413, label %1121, label %1113
1113: ; preds = %1110
%1114 = add nsw i64 %1111, %1034
%1115 = add nsw i64 %1111, %1036
%1116 = getelementptr inbounds double, double* %23, i64 %1114
%1117 = load double, double* %1116
%1118 = getelementptr inbounds double, double* %23, i64 %1115
%1119 = load double, double* %1118
store double %1119, double* %1116
store double %1117, double* %1118
%1120 = or i64 %1111, 1
br label %1121
1121: ; preds = %1113, %1110
%1122 = phi i64 [ %1111, %1110 ], [ %1120, %1113 ]
%1123 = icmp eq i64 %1112, %414
br i1 %1123, label %1141, label %1124
1124: ; preds = %1121, %1124
%1125 = phi i64 [ %1139, %1124 ], [ %1122, %1121 ]
%1126 = add nsw i64 %1125, %1034
%1127 = add nsw i64 %1125, %1036
%1128 = getelementptr inbounds double, double* %23, i64 %1126
%1129 = load double, double* %1128
%1130 = getelementptr inbounds double, double* %23, i64 %1127
%1131 = load double, double* %1130
store double %1131, double* %1128
store double %1129, double* %1130
%1132 = add nuw nsw i64 %1125, 1
%1133 = add nsw i64 %1132, %1034
%1134 = add nsw i64 %1132, %1036
%1135 = getelementptr inbounds double, double* %23, i64 %1133
%1136 = load double, double* %1135
%1137 = getelementptr inbounds double, double* %23, i64 %1134
%1138 = load double, double* %1137
store double %1138, double* %1135
store double %1136, double* %1137
%1139 = add nuw nsw i64 %1125, 2
%1140 = icmp eq i64 %1139, %392
br i1 %1140, label %1141, label %1124
1141: ; preds = %1121, %1124, %1109, %1019
%1142 = icmp sgt i64 %1021, 1
%1143 = add i64 %1020, 1
br i1 %1142, label %1019, label %879
1144: ; preds = %1016, %1144
%1145 = phi i64 [ %1161, %1144 ], [ %1017, %1016 ]
%1146 = getelementptr inbounds double, double* %23, i64 %1145
%1147 = load double, double* %1146
%1148 = getelementptr inbounds double, double* %2, i64 %1145
store double %1147, double* %1148
%1149 = add nsw i64 %1145, -1
%1150 = getelementptr inbounds double, double* %23, i64 %1149
%1151 = load double, double* %1150
%1152 = getelementptr inbounds double, double* %2, i64 %1149
store double %1151, double* %1152
%1153 = add nsw i64 %1145, -2
%1154 = getelementptr inbounds double, double* %23, i64 %1153
%1155 = load double, double* %1154
%1156 = getelementptr inbounds double, double* %2, i64 %1153
store double %1155, double* %1156
%1157 = add nsw i64 %1145, -3
%1158 = getelementptr inbounds double, double* %23, i64 %1157
%1159 = load double, double* %1158
%1160 = getelementptr inbounds double, double* %2, i64 %1157
store double %1159, double* %1160
%1161 = add nsw i64 %1145, -4
%1162 = icmp eq i64 %1157, 0
br i1 %1162, label %1163, label %1144
1163: ; preds = %442, %1016, %1144, %1000, %879, %10
%1164 = phi i32 [ %14, %10 ], [ 0, %879 ], [ 0, %1000 ], [ 0, %1144 ], [ 0, %1016 ], [ -1, %442 ]
ret i32 %1164
}