int minv(double *a, int n) {
  static int *sle = 0;
  static double *sq0 = 0;
  static int rsize = 0;
  int lc, *le;
  double s, t, tq = 0., zr = 1.e-15;
  double *pa, *pd, *ps, *p, *q, *q0;
  int i, j, k, m;
  if (rsize < n) {
    if (sle)
      MemFree(sle);
    if (sq0)
      MemFree(sq0);
    rsize = n;
    sle = (int *)MemAlloc(rsize * sizeof(int));
    sq0 = (double *)MemAlloc(rsize * sizeof(double));
  }
  le = sle;
  q0 = sq0;
  for (j = 0, pa = pd = a; j < n; ++j, ++pa, pd += n + 1) {
    if (j > 0) {
      for (i = 0, q = q0, p = pa; i < n; ++i, p += n)
        *q++ = *p;
      for (i = 1; i < n; ++i) {
        lc = i < j ? i : j;
        for (k = 0, p = pa + i * n - j, q = q0, t = 0.; k < lc; ++k)
          t += *p++ * *q++;
        q0[i] -= t;
      }
      for (i = 0, q = q0, p = pa; i < n; ++i, p += n)
        *p = *q++;
    }
    s = fabs(*pd);
    lc = j;
    for (k = j + 1, ps = pd; k < n; ++k) {
      if ((t = fabs(*(ps += n))) > s) {
        s = t;
        lc = k;
      }
    }
    tq = tq > s ? tq : s;
    if (s < zr * tq) {
      return -1;
    }
    *le++ = lc;
    if (lc != j) {
      for (k = 0, p = a + n * j, q = a + n * lc; k < n; ++k) {
        t = *p;
        *p++ = *q;
        *q++ = t;
      }
    }
    for (k = j + 1, ps = pd, t = 1. / *pd; k < n; ++k)
      *(ps += n) *= t;
    *pd = t;
  }
  for (j = 1, pd = ps = a; j < n; ++j) {
    for (k = 0, pd += n + 1, q = ++ps; k < j; ++k, q += n)
      *q *= *pd;
  }
  for (j = 1, pa = a; j < n; ++j) {
    ++pa;
    for (i = 0, q = q0, p = pa; i < j; ++i, p += n)
      *q++ = *p;
    for (k = 0; k < j; ++k) {
      t = 0.;
      for (i = k, p = pa + k * n + k - j, q = q0 + k; i < j; ++i)
        t -= *p++ * *q++;
      q0[k] = t;
    }
    for (i = 0, q = q0, p = pa; i < j; ++i, p += n)
      *p = *q++;
  }
  for (j = n - 2, pd = pa = a + n * n - 1; j >= 0; --j) {
    --pa;
    pd -= n + 1;
    for (i = 0, m = n - j - 1, q = q0, p = pd + n; i < m; ++i, p += n)
      *q++ = *p;
    for (k = n - 1, ps = pa; k > j; --k, ps -= n) {
      t = -(*ps);
      for (i = j + 1, p = ps, q = q0; i < k; ++i)
        t -= *++p * *q++;
      q0[--m] = t;
    }
    for (i = 0, m = n - j - 1, q = q0, p = pd + n; i < m; ++i, p += n)
      *p = *q++;
  }
  for (k = 0, pa = a; k < n - 1; ++k, ++pa) {
    for (i = 0, q = q0, p = pa; i < n; ++i, p += n)
      *q++ = *p;
    for (j = 0, ps = a; j < n; ++j, ps += n) {
      if (j > k) {
        t = 0.;
        p = ps + j;
        i = j;
      } else {
        t = q0[j];
        p = ps + k + 1;
        i = k + 1;
      }
      for (; i < n;)
        t += *p++ * q0[i++];
      q0[j] = t;
    }
    for (i = 0, q = q0, p = pa; i < n; ++i, p += n)
      *p = *q++;
  }
  for (j = n - 2, le--; j >= 0; --j) {
    for (k = 0, p = a + j, q = a + *(--le); k < n; ++k, p += n, q += n) {
      t = *p;
      *p = *q;
      *q = t;
    }
  }
  return 0;
}


x86 assembly (clang, -O0):
<minv>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  0xebe(%rip),%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    0x2efb(%rip),%eax
cmp    -0x14(%rbp),%eax
jge    11cd <minv+0xad>
cmpq   $0x0,0x2eda(%rip)
je     1172 <minv+0x52>
mov    0x2ecd(%rip),%rdi
mov    $0x0,%al
call   1030 <MemFree@plt>
cmpq   $0x0,0x2ec6(%rip)
je     118e <minv+0x6e>
mov    0x2eb9(%rip),%rdi
mov    $0x0,%al
call   1030 <MemFree@plt>
mov    -0x14(%rbp),%eax
mov    %eax,0x2eb1(%rip)
movslq 0x2eaa(%rip),%rdi
shl    $0x2,%rdi
mov    $0x0,%al
call   1040 <MemAlloc@plt>
cltq
mov    %rax,0x2e86(%rip)
movslq 0x2e8f(%rip),%rdi
shl    $0x3,%rdi
mov    $0x0,%al
call   1040 <MemAlloc@plt>
cltq
mov    %rax,0x2e73(%rip)
mov    0x2e64(%rip),%rax
mov    %rax,-0x20(%rbp)
mov    0x2e61(%rip),%rax
mov    %rax,-0x70(%rbp)
movl   $0x0,-0x78(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    %rax,-0x48(%rbp)
mov    -0x78(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1628 <minv+0x508>
cmpl   $0x0,-0x78(%rbp)
jle    13cd <minv+0x2ad>
movl   $0x0,-0x74(%rbp)
mov    -0x70(%rbp),%rax
mov    %rax,-0x68(%rbp)
mov    -0x48(%rbp),%rax
mov    %rax,-0x60(%rbp)
mov    -0x74(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    126d <minv+0x14d>
mov    -0x60(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x68(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x68(%rbp)
movsd  %xmm0,(%rax)
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
mov    -0x14(%rbp),%ecx
mov    -0x60(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
jmp    1223 <minv+0x103>
movl   $0x1,-0x74(%rbp)
mov    -0x74(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1367 <minv+0x247>
mov    -0x74(%rbp),%eax
cmp    -0x78(%rbp),%eax
jge    129a <minv+0x17a>
mov    -0x74(%rbp),%eax
mov    %eax,-0x84(%rbp)
jmp    12a3 <minv+0x183>
mov    -0x78(%rbp),%eax
mov    %eax,-0x84(%rbp)
mov    -0x84(%rbp),%eax
mov    %eax,-0x18(%rbp)
movl   $0x0,-0x7c(%rbp)
mov    -0x48(%rbp),%rax
mov    -0x74(%rbp),%ecx
imul   -0x14(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x78(%rbp),%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
mov    -0x70(%rbp),%rax
mov    %rax,-0x68(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x30(%rbp)
mov    -0x7c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    133e <minv+0x21e>
mov    -0x60(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x60(%rbp)
movsd  (%rax),%xmm0
mov    -0x68(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x68(%rbp)
movsd  (%rax),%xmm2
movsd  -0x30(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x30(%rbp)
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
jmp    12ec <minv+0x1cc>
movsd  -0x30(%rbp),%xmm1
mov    -0x70(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    1274 <minv+0x154>
movl   $0x0,-0x74(%rbp)
mov    -0x70(%rbp),%rax
mov    %rax,-0x68(%rbp)
mov    -0x48(%rbp),%rax
mov    %rax,-0x60(%rbp)
mov    -0x74(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    13c8 <minv+0x2a8>
mov    -0x68(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x68(%rbp)
movsd  (%rax),%xmm0
mov    -0x60(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
mov    -0x14(%rbp),%ecx
mov    -0x60(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
jmp    137e <minv+0x25e>
jmp    13cd <minv+0x2ad>
mov    -0x50(%rbp),%rax
movsd  (%rax),%xmm0
movaps 0xc34(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x28(%rbp)
mov    -0x78(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
mov    -0x50(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x7c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1466 <minv+0x346>
mov    -0x14(%rbp),%ecx
mov    -0x58(%rbp),%rax
movslq %ecx,%rcx
mov    %rcx,%rsi
shl    $0x3,%rsi
mov    %rax,%rdx
add    %rsi,%rdx
mov    %rdx,-0x58(%rbp)
movsd  (%rax,%rcx,8),%xmm0
movaps 0xbe1(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x30(%rbp)
ucomisd -0x28(%rbp),%xmm0
jbe    1453 <minv+0x333>
movsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0x28(%rbp)
mov    -0x7c(%rbp),%eax
mov    %eax,-0x18(%rbp)
jmp    1458 <minv+0x338>
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
jmp    13fc <minv+0x2dc>
movsd  -0x38(%rbp),%xmm0
ucomisd -0x28(%rbp),%xmm0
jbe    1488 <minv+0x368>
movsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
jmp    1495 <minv+0x375>
movsd  -0x28(%rbp),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0x38(%rbp)
movsd  -0x28(%rbp),%xmm1
movsd  -0x40(%rbp),%xmm0
mulsd  -0x38(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    14c7 <minv+0x3a7>
movl   $0xffffffff,-0x4(%rbp)
jmp    1e09 <minv+0xce9>
mov    -0x18(%rbp),%ecx
mov    -0x20(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0x20(%rbp)
mov    %ecx,(%rax)
mov    -0x18(%rbp),%eax
cmp    -0x78(%rbp),%eax
je     157f <minv+0x45f>
movl   $0x0,-0x7c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x78(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x18(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x68(%rbp)
mov    -0x7c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    157a <minv+0x45a>
mov    -0x60(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x30(%rbp)
mov    -0x68(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x60(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x60(%rbp)
movsd  %xmm0,(%rax)
movsd  -0x30(%rbp),%xmm0
mov    -0x68(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x68(%rbp)
movsd  %xmm0,(%rax)
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
jmp    1520 <minv+0x400>
jmp    157f <minv+0x45f>
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
mov    -0x50(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x50(%rbp),%rax
movsd  0xa6c(%rip),%xmm0
divsd  (%rax),%xmm0
movsd  %xmm0,-0x30(%rbp)
mov    -0x7c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    15e9 <minv+0x4c9>
movsd  -0x30(%rbp),%xmm0
mov    -0x14(%rbp),%ecx
mov    -0x58(%rbp),%rax
movslq %ecx,%rcx
mov    %rcx,%rsi
shl    $0x3,%rsi
mov    %rax,%rdx
add    %rsi,%rdx
mov    %rdx,-0x58(%rbp)
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
jmp    15a5 <minv+0x485>
movsd  -0x30(%rbp),%xmm0
mov    -0x50(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
mov    -0x48(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x48(%rbp)
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
mov    -0x50(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
jmp    11f6 <minv+0xd6>
movl   $0x1,-0x78(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    %rax,-0x50(%rbp)
mov    -0x78(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    16cc <minv+0x5ac>
movl   $0x0,-0x7c(%rbp)
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
mov    -0x50(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
mov    -0x58(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x58(%rbp)
mov    %rax,-0x68(%rbp)
mov    -0x7c(%rbp),%eax
cmp    -0x78(%rbp),%eax
jge    16b9 <minv+0x599>
mov    -0x50(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x68(%rbp),%rax
mulsd  (%rax),%xmm0
movsd  %xmm0,(%rax)
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
mov    -0x14(%rbp),%ecx
mov    -0x68(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x68(%rbp)
jmp    1676 <minv+0x556>
jmp    16be <minv+0x59e>
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    163b <minv+0x51b>
movl   $0x1,-0x78(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x78(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    18b9 <minv+0x799>
mov    -0x48(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x48(%rbp)
movl   $0x0,-0x74(%rbp)
mov    -0x70(%rbp),%rax
mov    %rax,-0x68(%rbp)
mov    -0x48(%rbp),%rax
mov    %rax,-0x60(%rbp)
mov    -0x74(%rbp),%eax
cmp    -0x78(%rbp),%eax
jge    1754 <minv+0x634>
mov    -0x60(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x68(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x68(%rbp)
movsd  %xmm0,(%rax)
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
mov    -0x14(%rbp),%ecx
mov    -0x60(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
jmp    170a <minv+0x5ea>
movl   $0x0,-0x7c(%rbp)
mov    -0x7c(%rbp),%eax
cmp    -0x78(%rbp),%eax
jge    1845 <minv+0x725>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x30(%rbp)
mov    -0x7c(%rbp),%eax
mov    %eax,-0x74(%rbp)
mov    -0x48(%rbp),%rax
mov    -0x7c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x7c(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x78(%rbp),%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
mov    -0x70(%rbp),%rax
movslq -0x7c(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x68(%rbp)
mov    -0x74(%rbp),%eax
cmp    -0x78(%rbp),%eax
jge    1825 <minv+0x705>
mov    -0x60(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x60(%rbp)
movsd  (%rax),%xmm0
mov    -0x68(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x68(%rbp)
movsd  (%rax),%xmm2
movsd  -0x30(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x30(%rbp)
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    17bc <minv+0x69c>
movsd  -0x30(%rbp),%xmm0
mov    -0x70(%rbp),%rax
movslq -0x7c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
jmp    175b <minv+0x63b>
movl   $0x0,-0x74(%rbp)
mov    -0x70(%rbp),%rax
mov    %rax,-0x68(%rbp)
mov    -0x48(%rbp),%rax
mov    %rax,-0x60(%rbp)
mov    -0x74(%rbp),%eax
cmp    -0x78(%rbp),%eax
jge    18a6 <minv+0x786>
mov    -0x68(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x68(%rbp)
movsd  (%rax),%xmm0
mov    -0x60(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
mov    -0x14(%rbp),%ecx
mov    -0x60(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
jmp    185c <minv+0x73c>
jmp    18ab <minv+0x78b>
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    16db <minv+0x5bb>
mov    -0x14(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x78(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x14(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x48(%rbp)
mov    %rax,-0x50(%rbp)
cmpl   $0x0,-0x78(%rbp)
jl     1b1f <minv+0x9ff>
mov    -0x48(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x48(%rbp)
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
mov    -0x50(%rbp),%rax
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
movl   $0x0,-0x74(%rbp)
mov    -0x14(%rbp),%eax
sub    -0x78(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x80(%rbp)
mov    -0x70(%rbp),%rax
mov    %rax,-0x68(%rbp)
mov    -0x50(%rbp),%rax
movslq -0x14(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
mov    -0x74(%rbp),%eax
cmp    -0x80(%rbp),%eax
jge    198e <minv+0x86e>
mov    -0x60(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x68(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x68(%rbp)
movsd  %xmm0,(%rax)
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
mov    -0x14(%rbp),%ecx
mov    -0x60(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
jmp    1944 <minv+0x824>
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x7c(%rbp)
mov    -0x48(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x7c(%rbp),%eax
cmp    -0x78(%rbp),%eax
jle    1a94 <minv+0x974>
mov    -0x58(%rbp),%rax
movsd  (%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x30(%rbp)
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
mov    -0x58(%rbp),%rax
mov    %rax,-0x60(%rbp)
mov    -0x70(%rbp),%rax
mov    %rax,-0x68(%rbp)
mov    -0x74(%rbp),%eax
cmp    -0x7c(%rbp),%eax
jge    1a52 <minv+0x932>
mov    -0x60(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x60(%rbp)
movsd  0x8(%rax),%xmm0
mov    -0x68(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x68(%rbp)
movsd  (%rax),%xmm2
movsd  -0x30(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x30(%rbp)
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    19e8 <minv+0x8c8>
movsd  -0x30(%rbp),%xmm0
mov    -0x70(%rbp),%rax
mov    -0x80(%rbp),%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x80(%rbp)
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x7c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x7c(%rbp)
mov    -0x14(%rbp),%ecx
mov    -0x58(%rbp),%rax
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x58(%rbp)
jmp    199f <minv+0x87f>
movl   $0x0,-0x74(%rbp)
mov    -0x14(%rbp),%eax
sub    -0x78(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x80(%rbp)
mov    -0x70(%rbp),%rax
mov    %rax,-0x68(%rbp)
mov    -0x50(%rbp),%rax
movslq -0x14(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
mov    -0x74(%rbp),%eax
cmp    -0x80(%rbp),%eax
jge    1b0c <minv+0x9ec>
mov    -0x68(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x68(%rbp)
movsd  (%rax),%xmm0
mov    -0x60(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
mov    -0x14(%rbp),%ecx
mov    -0x60(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
jmp    1ac2 <minv+0x9a2>
jmp    1b11 <minv+0x9f1>
mov    -0x78(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x78(%rbp)
jmp    18e3 <minv+0x7c3>
movl   $0x0,-0x7c(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x7c(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1d26 <minv+0xc06>
movl   $0x0,-0x74(%rbp)
mov    -0x70(%rbp),%rax
mov    %rax,-0x68(%rbp)
mov    -0x48(%rbp),%rax
mov    %rax,-0x60(%rbp)
mov    -0x74(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1ba0 <minv+0xa80>
mov    -0x60(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x68(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x68(%rbp)
movsd  %xmm0,(%rax)
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
mov    -0x14(%rbp),%ecx
mov    -0x60(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
jmp    1b56 <minv+0xa36>
movl   $0x0,-0x78(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x78(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1ca6 <minv+0xb86>
mov    -0x78(%rbp),%eax
cmp    -0x7c(%rbp),%eax
jle    1bed <minv+0xacd>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x30(%rbp)
mov    -0x58(%rbp),%rax
movslq -0x78(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
mov    -0x78(%rbp),%eax
mov    %eax,-0x74(%rbp)
jmp    1c1f <minv+0xaff>
mov    -0x70(%rbp),%rax
movslq -0x78(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x30(%rbp)
mov    -0x58(%rbp),%rax
movslq -0x7c(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
add    $0x8,%rax
mov    %rax,-0x60(%rbp)
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    1c24 <minv+0xb04>
mov    -0x74(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1c71 <minv+0xb51>
mov    -0x60(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x60(%rbp)
movsd  (%rax),%xmm0
mov    -0x70(%rbp),%rax
mov    -0x74(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x74(%rbp)
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x30(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x30(%rbp)
jmp    1c24 <minv+0xb04>
movsd  -0x30(%rbp),%xmm0
mov    -0x70(%rbp),%rax
movslq -0x78(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
mov    -0x14(%rbp),%ecx
mov    -0x58(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x58(%rbp)
jmp    1baf <minv+0xa8f>
movl   $0x0,-0x74(%rbp)
mov    -0x70(%rbp),%rax
mov    %rax,-0x68(%rbp)
mov    -0x48(%rbp),%rax
mov    %rax,-0x60(%rbp)
mov    -0x74(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1d07 <minv+0xbe7>
mov    -0x68(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x68(%rbp)
movsd  (%rax),%xmm0
mov    -0x60(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
mov    -0x14(%rbp),%ecx
mov    -0x60(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
jmp    1cbd <minv+0xb9d>
jmp    1d0c <minv+0xbec>
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
mov    -0x48(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x48(%rbp)
jmp    1b2e <minv+0xa0e>
mov    -0x14(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x78(%rbp)
mov    -0x20(%rbp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,-0x20(%rbp)
cmpl   $0x0,-0x78(%rbp)
jl     1e02 <minv+0xce2>
movl   $0x0,-0x7c(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x78(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    %rcx,%rdx
add    $0xfffffffffffffffc,%rdx
mov    %rdx,-0x20(%rbp)
movslq -0x4(%rcx),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x68(%rbp)
mov    -0x7c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1def <minv+0xccf>
mov    -0x60(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x30(%rbp)
mov    -0x68(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x60(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x30(%rbp),%xmm0
mov    -0x68(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
mov    -0x14(%rbp),%ecx
mov    -0x60(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
mov    -0x14(%rbp),%ecx
mov    -0x68(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x68(%rbp)
jmp    1d81 <minv+0xc61>
jmp    1df4 <minv+0xcd4>
mov    -0x78(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x78(%rbp)
jmp    1d3b <minv+0xc1b>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<minv>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xc8,%rsp
mov    %rdi,%rbp
cmp    %esi,0x3f0e(%rip)
mov    %rsi,0x18(%rsp)
jge    11b8 <minv+0x98>
mov    0x3ef0(%rip),%rdi
test   %rdi,%rdi
je     1159 <minv+0x39>
xor    %eax,%eax
call   1030 <MemFree@plt>
mov    0x18(%rsp),%rsi
mov    0x3ee0(%rip),%rdi
test   %rdi,%rdi
je     1171 <minv+0x51>
xor    %eax,%eax
call   1030 <MemFree@plt>
mov    0x18(%rsp),%rsi
mov    %esi,0x3ed1(%rip)
movslq %esi,%rdi
shl    $0x2,%rdi
xor    %eax,%eax
call   1040 <MemAlloc@plt>
cltq
mov    %rax,0x3eaa(%rip)
movslq 0x3eb3(%rip),%rdi
shl    $0x3,%rdi
xor    %eax,%eax
call   1040 <MemAlloc@plt>
mov    0x18(%rsp),%rsi
movslq %eax,%r12
mov    %r12,0x3e91(%rip)
test   %esi,%esi
jg     11c7 <minv+0xa7>
jmp    2753 <minv+0x1633>
mov    0x3e81(%rip),%r12
test   %esi,%esi
jle    2753 <minv+0x1633>
mov    0x3e6a(%rip),%rax
mov    %esi,%edi
lea    -0x1(%rsi),%ecx
lea    0x8(,%rcx,8),%rdx
add    %rbp,%rdx
mov    %rdx,0xa0(%rsp)
mov    %rcx,0x40(%rsp)
add    $0x1,%rcx
mov    %rcx,0x80(%rsp)
and    $0xfffffffffffffffc,%rcx
mov    %rcx,0x68(%rsp)
add    $0xfffffffffffffffc,%rcx
mov    %rcx,0x78(%rsp)
mov    %rcx,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
mov    %esi,%ecx
and    $0xfffffff8,%ecx
mov    %ecx,0x3c(%rsp)
mov    %rdx,%rcx
mov    %rdx,0x98(%rsp)
and    $0xfffffffffffffffe,%rdx
mov    %rdx,0x90(%rsp)
mov    %rdi,%rcx
shl    $0x6,%rcx
mov    %rcx,0x60(%rsp)
mov    %esi,%r11d
and    $0x7,%r11d
mov    %rdi,%r9
shl    $0x4,%r9
mov    %rdi,%rbx
shl    $0x5,%rbx
xorpd  %xmm0,%xmm0
movapd 0x1d9f(%rip),%xmm1
movapd 0x1d97(%rip),%xmm2
movsd  0x1daf(%rip),%xmm3
movsd  0x1dae(%rip),%xmm8
lea    -0x2(%rsi),%ecx
mov    %ecx,0x4c(%rsp)
lea    0x0(,%rdi,8),%rdx
lea    0x0(%rbp,%rdi,8),%rcx
mov    %rcx,0xa8(%rsp)
lea    0x30(%rbp),%r13
mov    %rdi,0x20(%rsp)
lea    0x8(,%rdi,8),%rcx
mov    %rcx,0xb8(%rsp)
lea    0x3(%rsi),%r10d
lea    (%rdx,%rdx,2),%rcx
mov    %rcx,0xb0(%rsp)
xor    %r14d,%r14d
mov    %rbp,%r8
mov    %r13,0x88(%rsp)
mov    %rbp,0x50(%rsp)
mov    %rbp,0x8(%rsp)
xor    %r15d,%r15d
mov    %rbx,0x28(%rsp)
mov    %r11,0x58(%rsp)
jmp    132a <minv+0x20a>
cs nopw 0x0(%rax,%rax,1)
mov    0xc0(%rsp),%rax
add    $0x4,%rax
movsd  %xmm6,(%r8)
addq   $0x8,0x8(%rsp)
add    0xb8(%rsp),%r8
add    $0x1,%r14d
add    %rdx,%r13
add    $0x3,%r10b
mov    0x30(%rsp),%r15
cmp    0x20(%rsp),%r15
je     1a46 <minv+0x926>
mov    %r10,0x70(%rsp)
mov    %rax,0xc0(%rsp)
test   %r15,%r15
mov    %r8,0x10(%rsp)
je     14d5 <minv+0x3b5>
mov    %r12,%rax
mov    0x8(%rsp),%rdi
mov    %rdi,%rcx
mov    0x3c(%rsp),%ebp
cmpl   $0x7,0x40(%rsp)
jb     13d7 <minv+0x2b7>
nop
mov    %rdi,%rcx
movsd  (%rdi),%xmm5
movsd  %xmm5,(%rax)
add    %rdx,%rdi
movsd  (%rcx,%rdx,1),%xmm5
movsd  %xmm5,0x8(%rax)
movsd  (%rdx,%rdi,1),%xmm5
add    %rdx,%rdi
movsd  %xmm5,0x10(%rax)
movsd  (%rdx,%rdi,1),%xmm5
add    %rdx,%rdi
movsd  %xmm5,0x18(%rax)
movsd  (%rdx,%rdi,1),%xmm5
add    %rdx,%rdi
movsd  %xmm5,0x20(%rax)
movsd  (%rdx,%rdi,1),%xmm5
add    %rdx,%rdi
movsd  %xmm5,0x28(%rax)
movsd  (%rdx,%rdi,1),%xmm5
add    %rdx,%rdi
movsd  %xmm5,0x30(%rax)
movsd  (%rdx,%rdi,1),%xmm5
add    %rdx,%rdi
movsd  %xmm5,0x38(%rax)
add    $0x40,%rax
add    %rdx,%rdi
add    $0xfffffff8,%ebp
jne    1360 <minv+0x240>
add    0x60(%rsp),%rcx
test   $0x7,%sil
je     13f5 <minv+0x2d5>
xor    %edi,%edi
nop
movsd  (%rcx),%xmm5
movsd  %xmm5,(%rax,%rdi,8)
add    $0x1,%rdi
add    %rdx,%rcx
cmp    %edi,%r11d
jne    13e0 <minv+0x2c0>
cmp    $0x1,%esi
jne    1530 <minv+0x410>
mov    %r12,%rax
mov    0x8(%rsp),%rcx
cmpl   $0x7,0x40(%rsp)
mov    0x18(%rsp),%rsi
mov    0x28(%rsp),%rbx
mov    0x58(%rsp),%r11
mov    0x10(%rsp),%r8
jb     14b7 <minv+0x397>
mov    0x3c(%rsp),%ebp
mov    0x8(%rsp),%rdi
mov    %r12,%rax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %rdi,%rcx
movsd  (%rax),%xmm5
movsd  %xmm5,(%rdi)
movsd  0x8(%rax),%xmm5
add    %rdx,%rdi
movsd  %xmm5,(%rcx,%rdx,1)
movsd  0x10(%rax),%xmm5
movsd  %xmm5,(%rdx,%rdi,1)
add    %rdx,%rdi
movsd  0x18(%rax),%xmm5
movsd  %xmm5,(%rdx,%rdi,1)
add    %rdx,%rdi
movsd  0x20(%rax),%xmm5
movsd  %xmm5,(%rdx,%rdi,1)
add    %rdx,%rdi
movsd  0x28(%rax),%xmm5
movsd  %xmm5,(%rdx,%rdi,1)
add    %rdx,%rdi
movsd  0x30(%rax),%xmm5
movsd  %xmm5,(%rdx,%rdi,1)
add    %rdx,%rdi
movsd  0x38(%rax),%xmm5
add    $0x40,%rax
movsd  %xmm5,(%rdx,%rdi,1)
add    %rdx,%rdi
add    %rdx,%rdi
add    $0xfffffff8,%ebp
jne    1440 <minv+0x320>
add    0x60(%rsp),%rcx
test   $0x7,%sil
je     14d5 <minv+0x3b5>
xor    %edi,%edi
nop
movsd  (%rax,%rdi,8),%xmm5
movsd  %xmm5,(%rcx)
add    $0x1,%rdi
add    %rdx,%rcx
cmp    %edi,%r11d
jne    14c0 <minv+0x3a0>
mov    0x40(%rsp),%rax
mov    %eax,%r10d
sub    %r15d,%r10d
movsd  (%r8),%xmm5
movapd %xmm5,%xmm7
andpd  %xmm1,%xmm7
lea    0x1(%r15),%rbp
cmp    0x20(%rsp),%rbp
mov    %rbp,0x30(%rsp)
jae    1520 <minv+0x400>
test   $0x1,%r10b
jne    1670 <minv+0x550>
mov    %r8,%rcx
mov    %r15d,%eax
cmp    %r15d,0x4c(%rsp)
jne    169f <minv+0x57f>
jmp    16e6 <minv+0x5c6>
nopl   (%rax)
movapd %xmm7,%xmm6
mov    %r15d,%eax
jmp    16e6 <minv+0x5c6>
nopl   0x0(%rax)
lea    0x0(,%r15,8),%rax
mov    0x8(%rsp),%r8
sub    %rax,%r8
mov    $0x1,%edi
xor    %r11d,%r11d
mov    0xa8(%rsp),%rcx
jmp    1582 <minv+0x462>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%r12,%rdi,8),%xmm6
subsd  %xmm5,%xmm6
movsd  %xmm6,(%r12,%rdi,8)
add    $0x1,%rdi
add    %rdx,%rcx
cmp    0x20(%rsp),%rdi
je     13fe <minv+0x2de>
cmp    %edi,%r14d
mov    %edi,%ebx
cmovb  %r14d,%ebx
cmp    $0x2,%ebx
mov    $0x1,%eax
cmovl  %eax,%ebx
add    $0x1,%r11d
cmp    %r11d,%r15d
mov    %r11d,%esi
cmovb  %r15d,%esi
cmp    $0x2,%esi
cmovl  %eax,%esi
lea    -0x1(%rsi),%eax
cmp    $0x3,%eax
jae    15d0 <minv+0x4b0>
mov    %rdi,%rax
imul   0x20(%rsp),%rax
lea    (%r8,%rax,8),%rbp
xorpd  %xmm5,%xmm5
mov    %r12,%rax
test   $0x3,%sil
jne    1644 <minv+0x524>
jmp    1560 <minv+0x440>
xchg   %ax,%ax
mov    %ebx,%eax
and    $0x7ffffffc,%eax
xorpd  %xmm5,%xmm5
xor    %ebp,%ebp
xor    %r10d,%r10d
movsd  (%rcx,%rbp,8),%xmm6
mulsd  (%r12,%rbp,8),%xmm6
movsd  0x8(%rcx,%rbp,8),%xmm7
addsd  %xmm5,%xmm6
mulsd  0x8(%r12,%rbp,8),%xmm7
addsd  %xmm6,%xmm7
movsd  0x10(%rcx,%rbp,8),%xmm6
mulsd  0x10(%r12,%rbp,8),%xmm6
addsd  %xmm7,%xmm6
movsd  0x18(%rcx,%rbp,8),%xmm5
mulsd  0x18(%r12,%rbp,8),%xmm5
addsd  %xmm6,%xmm5
add    $0xffffffffffffffe0,%r10
add    $0x4,%rbp
cmp    %ebp,%eax
jne    15e0 <minv+0x4c0>
mov    %r12,%rax
sub    %r10,%rax
mov    %rcx,%rbp
sub    %r10,%rbp
test   $0x3,%sil
je     1560 <minv+0x440>
and    $0x3,%ebx
xor    %esi,%esi
nopl   0x0(%rax)
movsd  0x0(%rbp,%rsi,8),%xmm6
mulsd  (%rax,%rsi,8),%xmm6
addsd  %xmm6,%xmm5
add    $0x1,%rsi
cmp    %esi,%ebx
jne    1650 <minv+0x530>
jmp    1560 <minv+0x440>
nopl   0x0(%rax)
mov    0x20(%rsp),%rax
lea    (%r8,%rax,8),%rcx
movsd  (%r8,%rax,8),%xmm6
andpd  %xmm1,%xmm6
ucomisd %xmm7,%xmm6
maxsd  %xmm7,%xmm6
mov    %r15d,%eax
cmova  %ebp,%eax
add    $0x1,%ebp
movapd %xmm6,%xmm7
cmp    %r15d,0x4c(%rsp)
je     16e6 <minv+0x5c6>
movapd %xmm7,%xmm6
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rcx,%rdx,1),%xmm7
andpd  %xmm2,%xmm7
ucomisd %xmm6,%xmm7
maxsd  %xmm6,%xmm7
cmova  %ebp,%eax
movsd  (%rcx,%r9,1),%xmm6
add    %r9,%rcx
andpd  %xmm2,%xmm6
ucomisd %xmm7,%xmm6
lea    0x1(%rbp),%edi
cmova  %edi,%eax
maxsd  %xmm7,%xmm6
add    $0x2,%ebp
cmp    %esi,%ebp
jne    16b0 <minv+0x590>
maxsd  %xmm6,%xmm0
movapd %xmm0,%xmm7
mulsd  %xmm3,%xmm7
ucomisd %xmm6,%xmm7
ja     1a3c <minv+0x91c>
mov    0xc0(%rsp),%rcx
mov    %eax,(%rcx)
mov    %eax,%ecx
cmp    %rcx,%r15
je     194d <minv+0x82d>
mov    %r15,%rbp
imul   0x20(%rsp),%rbp
mov    0x50(%rsp),%rdi
lea    (%rdi,%rbp,8),%r11
imul   %esi,%eax
xor    %ecx,%ecx
cltq
lea    (%rdi,%rax,8),%r8
cmpl   $0x3,0x40(%rsp)
jb     1860 <minv+0x740>
mov    0xa0(%rsp),%rsi
lea    (%rsi,%rax,8),%rdi
cmp    %rdi,%r11
jae    1764 <minv+0x644>
add    0x80(%rsp),%rbp
mov    0x50(%rsp),%rsi
lea    (%rsi,%rbp,8),%rsi
cmp    %rsi,%r8
jb     1860 <minv+0x740>
cmpq   $0x0,0x78(%rsp)
je     1a27 <minv+0x907>
mov    0x88(%rsp),%rcx
lea    (%rcx,%rax,8),%rcx
mov    0x90(%rsp),%rsi
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
movups -0x30(%r13,%rax,8),%xmm5
movups -0x20(%r13,%rax,8),%xmm6
movups -0x30(%rcx,%rax,8),%xmm7
movups -0x20(%rcx,%rax,8),%xmm4
movups %xmm7,-0x30(%r13,%rax,8)
movups %xmm4,-0x20(%r13,%rax,8)
movups %xmm5,-0x30(%rcx,%rax,8)
movups %xmm6,-0x20(%rcx,%rax,8)
movupd -0x10(%r13,%rax,8),%xmm4
movupd 0x0(%r13,%rax,8),%xmm5
movupd -0x10(%rcx,%rax,8),%xmm6
movupd (%rcx,%rax,8),%xmm7
movupd %xmm6,-0x10(%r13,%rax,8)
movupd %xmm7,0x0(%r13,%rax,8)
movupd %xmm4,-0x10(%rcx,%rax,8)
movupd %xmm5,(%rcx,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rsi
jne    1790 <minv+0x670>
testb  $0x1,0x98(%rsp)
01
je     1836 <minv+0x716>
movupd (%r11,%rax,8),%xmm4
movupd 0x10(%r11,%rax,8),%xmm5
movupd (%r8,%rax,8),%xmm6
movupd 0x10(%r8,%rax,8),%xmm7
movupd %xmm6,(%r11,%rax,8)
movupd %xmm7,0x10(%r11,%rax,8)
movupd %xmm4,(%r8,%rax,8)
movupd %xmm5,0x10(%r8,%rax,8)
mov    0x68(%rsp),%rax
cmp    %rax,0x80(%rsp)
je     1934 <minv+0x814>
mov    0x68(%rsp),%rax
lea    (%r8,%rax,8),%r8
lea    (%r11,%rax,8),%r11
mov    %eax,%ecx
nopl   0x0(%rax,%rax,1)
mov    0x18(%rsp),%rdi
mov    %edi,%esi
sub    %ecx,%esi
mov    %ecx,%eax
not    %eax
add    %edi,%eax
and    $0x3,%esi
je     18a5 <minv+0x785>
neg    %esi
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
movsd  (%r11),%xmm4
movsd  (%r8),%xmm5
movsd  %xmm5,(%r11)
add    $0x8,%r11
movsd  %xmm4,(%r8)
add    $0x8,%r8
add    $0xffffffff,%edi
cmp    %edi,%esi
jne    1880 <minv+0x760>
sub    %edi,%ecx
cmp    $0x3,%eax
jb     1934 <minv+0x814>
mov    0x18(%rsp),%rax
sub    %ecx,%eax
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
movsd  (%r11,%rcx,8),%xmm4
movsd  (%r8,%rcx,8),%xmm5
movsd  %xmm5,(%r11,%rcx,8)
movsd  %xmm4,(%r8,%rcx,8)
movsd  0x8(%r11,%rcx,8),%xmm4
movsd  0x8(%r8,%rcx,8),%xmm5
movsd  %xmm5,0x8(%r11,%rcx,8)
movsd  %xmm4,0x8(%r8,%rcx,8)
movsd  0x10(%r11,%rcx,8),%xmm4
movsd  0x10(%r8,%rcx,8),%xmm5
movsd  %xmm5,0x10(%r11,%rcx,8)
movsd  %xmm4,0x10(%r8,%rcx,8)
movsd  0x18(%r11,%rcx,8),%xmm4
movsd  0x18(%r8,%rcx,8),%xmm5
movsd  %xmm5,0x18(%r11,%rcx,8)
movsd  %xmm4,0x18(%r8,%rcx,8)
add    $0x4,%rcx
cmp    %ecx,%eax
jne    18c0 <minv+0x7a0>
mov    0x10(%rsp),%r8
movsd  (%r8),%xmm5
mov    0x18(%rsp),%rsi
mov    0x28(%rsp),%rbx
mov    0x58(%rsp),%r11
mov    %r10d,%ecx
movapd %xmm8,%xmm6
divsd  %xmm5,%xmm6
mov    0x70(%rsp),%r10
movzbl %r10b,%r10d
and    $0x3,%r10d
mov    0x30(%rsp),%rax
cmp    0x20(%rsp),%rax
jae    12f0 <minv+0x1d0>
mov    0x4c(%rsp),%r8d
sub    %r15d,%r8d
test   $0x3,%cl
je     19b7 <minv+0x897>
mov    $0xffffffff,%ebp
mov    0x10(%rsp),%rax
mov    %r10,%rcx
movsd  (%rax,%rdx,1),%xmm4
mulsd  %xmm6,%xmm4
movsd  %xmm4,(%rax,%rdx,1)
add    %rdx,%rax
mov    %ebp,%edi
add    $0xffffffff,%ebp
add    %ecx,%edi
add    $0xffffffff,%edi
cmp    $0xffffffff,%edi
jne    1990 <minv+0x870>
mov    %r14d,%edi
sub    %ebp,%edi
jmp    19c3 <minv+0x8a3>
mov    0x30(%rsp),%rax
mov    %eax,%edi
mov    0x10(%rsp),%rax
cmp    $0x3,%r8d
mov    0xb0(%rsp),%rbp
mov    0x10(%rsp),%r8
jb     12f0 <minv+0x1d0>
mov    %esi,%ecx
sub    %edi,%ecx
xchg   %ax,%ax
movsd  (%rax,%rdx,1),%xmm4
mulsd  %xmm6,%xmm4
movsd  %xmm4,(%rax,%rdx,1)
movsd  (%rax,%r9,1),%xmm4
mulsd  %xmm6,%xmm4
movsd  %xmm4,(%rax,%r9,1)
movsd  (%rax,%rbp,1),%xmm4
mulsd  %xmm6,%xmm4
movsd  %xmm4,(%rax,%rbp,1)
movsd  (%rax,%rbx,1),%xmm4
mulsd  %xmm6,%xmm4
movsd  %xmm4,(%rax,%rbx,1)
add    %rbx,%rax
add    $0xfffffffc,%ecx
jne    19e0 <minv+0x8c0>
jmp    12f0 <minv+0x1d0>
xor    %eax,%eax
testb  $0x1,0x98(%rsp)
01
jne    1802 <minv+0x6e2>
jmp    1836 <minv+0x716>
mov    $0xffffffff,%eax
jmp    2755 <minv+0x1635>
xor    %eax,%eax
cmp    $0x2,%esi
mov    0x50(%rsp),%r15
jl     2755 <minv+0x1635>
lea    0x1(%rsi),%r8d
lea    0x8(%r15),%r11
mov    $0x1,%ebx
xor    %r14d,%r14d
mov    %r15,%r10
mov    %r15,%rax
jmp    1a85 <minv+0x965>
xchg   %ax,%ax
add    $0x1,%ebx
add    $0x1,%r14d
add    $0x8,%r11
cmp    0x18(%rsp),%ebx
je     1b19 <minv+0x9f9>
lea    (%rax,%r8,8),%rax
add    $0x8,%r10
mov    %r10,%rcx
cmp    $0x3,%r14d
jb     1af1 <minv+0x9d1>
mov    %ebx,%edi
and    $0xfffffffc,%edi
mov    %r11,%rsi
xchg   %ax,%ax
movsd  (%rax),%xmm0
mov    %rsi,%rcx
mulsd  (%rsi),%xmm0
movsd  %xmm0,(%rsi)
movsd  (%rax),%xmm0
mulsd  (%rsi,%rdx,1),%xmm0
movsd  %xmm0,(%rsi,%rdx,1)
add    %rdx,%rsi
movsd  (%rax),%xmm0
mulsd  (%rdx,%rsi,1),%xmm0
lea    (%rsi,%rdx,1),%rbp
movsd  %xmm0,(%rdx,%rsi,1)
movsd  (%rax),%xmm0
mulsd  (%rdx,%rbp,1),%xmm0
lea    (%rdx,%rbp,1),%rsi
movsd  %xmm0,(%rdx,%rbp,1)
add    %rdx,%rsi
add    $0xfffffffc,%edi
jne    1aa0 <minv+0x980>
add    0x28(%rsp),%rcx
test   $0x3,%bl
je     1a70 <minv+0x950>
mov    %ebx,%edi
and    $0x3,%edi
nop
movsd  (%rax),%xmm0
mulsd  (%rcx),%xmm0
movsd  %xmm0,(%rcx)
add    %rdx,%rcx
add    $0xffffffff,%edi
jne    1b00 <minv+0x9e0>
jmp    1a70 <minv+0x950>
xor    %eax,%eax
cmpl   $0x2,0x18(%rsp)
jl     2755 <minv+0x1635>
lea    0x8(%r15),%r10
add    $0x10,%r9
mov    0x20(%rsp),%rax
lea    (%r15,%rax,8),%rax
add    $0x8,%rax
mov    %rax,0x58(%rsp)
mov    $0x2,%eax
mov    %rax,0x30(%rsp)
xor    %r11d,%r11d
mov    $0x1,%ebx
jmp    1b7d <minv+0xa5d>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%rbx
add    $0x1,%r11
add    $0x8,%r10
addq   $0x1,0x30(%rsp)
cmp    0x20(%rsp),%rbx
je     1e6a <minv+0xd4a>
mov    %ebx,%r8d
and    $0x7,%r8d
mov    %rbx,%rax
and    $0xfffffffffffffff8,%rax
add    $0x8,%r15
mov    %r12,%rcx
mov    %r15,%rbp
mov    %rax,%rdi
mov    %r10,%rsi
cmp    $0x7,%r11
jb     1c29 <minv+0xb09>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %rsi,%rbp
movsd  (%rsi),%xmm0
movsd  %xmm0,(%rcx)
add    %rdx,%rsi
movsd  0x0(%rbp,%rdx,1),%xmm0
movsd  %xmm0,0x8(%rcx)
movsd  (%rdx,%rsi,1),%xmm0
add    %rdx,%rsi
movsd  %xmm0,0x10(%rcx)
movsd  (%rdx,%rsi,1),%xmm0
add    %rdx,%rsi
movsd  %xmm0,0x18(%rcx)
movsd  (%rdx,%rsi,1),%xmm0
add    %rdx,%rsi
movsd  %xmm0,0x20(%rcx)
movsd  (%rdx,%rsi,1),%xmm0
add    %rdx,%rsi
movsd  %xmm0,0x28(%rcx)
movsd  (%rdx,%rsi,1),%xmm0
add    %rdx,%rsi
movsd  %xmm0,0x30(%rcx)
movsd  (%rdx,%rsi,1),%xmm0
add    %rdx,%rsi
movsd  %xmm0,0x38(%rcx)
add    $0x40,%rcx
add    %rdx,%rsi
add    $0xfffffffffffffff8,%rdi
jne    1bb0 <minv+0xa90>
add    0x60(%rsp),%rbp
test   $0x7,%bl
je     1c46 <minv+0xb26>
xor    %esi,%esi
movsd  0x0(%rbp),%xmm0
movsd  %xmm0,(%rcx,%rsi,8)
add    $0x1,%rsi
add    %rdx,%rbp
cmp    %rsi,%r8
jne    1c30 <minv+0xb10>
test   %r11,%r11
mov    %r10,0x10(%rsp)
mov    %r11,0x8(%rsp)
mov    %r15,0x70(%rsp)
mov    %r8,0x28(%rsp)
je     1d20 <minv+0xc00>
mov    %rbx,%r10
movabs $0x7ffffffffffffffe,%rcx
ff ff 7f
and    %rcx,%r10
mov    $0x2,%edi
mov    0x58(%rsp),%rbp
mov    0x50(%rsp),%r8
mov    %r12,%rsi
xor    %r11d,%r11d
nopl   0x0(%rax,%rax,1)
mov    %edi,%ecx
mov    0x30(%rsp),%r14
sub    %rcx,%r14
mov    %r11d,%ecx
mov    %rbx,%r13
sub    %rcx,%rbx
xorpd  %xmm0,%xmm0
xor    %r15d,%r15d
nopw   0x0(%rax,%rax,1)
movsd  (%r8,%r15,8),%xmm1
mulsd  (%rsi,%r15,8),%xmm1
subsd  %xmm1,%xmm0
add    $0x1,%r15
cmp    %r15,%rbx
jne    1cb0 <minv+0xb90>
movsd  %xmm0,(%r12,%r11,8)
mov    %r11,%rbx
or     $0x1,%rbx
xorpd  %xmm0,%xmm0
xor    %ecx,%ecx
nopl   0x0(%rax)
movsd  0x0(%rbp,%rcx,8),%xmm1
mulsd  0x8(%rsi,%rcx,8),%xmm1
subsd  %xmm1,%xmm0
add    $0x1,%rcx
cmp    %rcx,%r14
jne    1ce0 <minv+0xbc0>
movsd  %xmm0,(%r12,%rbx,8)
add    $0x2,%r11
add    $0x10,%rsi
add    %r9,%r8
add    $0x2,%edi
add    %r9,%rbp
cmp    %r10,%r11
mov    %r13,%rbx
jne    1c90 <minv+0xb70>
jmp    1d23 <minv+0xc03>
xchg   %ax,%ax
xor    %r11d,%r11d
test   $0x1,%bl
mov    0x18(%rsp),%r8
mov    0x10(%rsp),%r10
mov    0x70(%rsp),%r15
mov    0x28(%rsp),%r14
je     1d9b <minv+0xc7b>
lea    0x0(,%rbx,8),%rcx
mov    %r15,%rsi
sub    %rcx,%rsi
lea    (%r12,%r11,8),%rcx
mov    %r11,%rdi
imul   0x20(%rsp),%rdi
lea    (%rsi,%rdi,8),%rsi
lea    (%rsi,%r11,8),%rsi
add    $0x1,%r11d
mov    0x30(%rsp),%rdi
sub    %r11,%rdi
xorpd  %xmm0,%xmm0
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%rsi,%rbp,8),%xmm1
mulsd  (%rcx,%rbp,8),%xmm1
subsd  %xmm1,%xmm0
add    $0x1,%rbp
cmp    %rbp,%rdi
jne    1d80 <minv+0xc60>
movsd  %xmm0,(%rcx)
mov    %r12,%rcx
mov    %r15,%rsi
mov    0x8(%rsp),%r11
cmp    $0x7,%r11
jb     1e38 <minv+0xd18>
mov    %r10,%rdi
mov    %r12,%rcx
cs nopw 0x0(%rax,%rax,1)
mov    %rdi,%rsi
movsd  (%rcx),%xmm0
movsd  %xmm0,(%rdi)
movsd  0x8(%rcx),%xmm0
add    %rdx,%rdi
movsd  %xmm0,(%rsi,%rdx,1)
movsd  0x10(%rcx),%xmm0
movsd  %xmm0,(%rdx,%rdi,1)
add    %rdx,%rdi
movsd  0x18(%rcx),%xmm0
movsd  %xmm0,(%rdx,%rdi,1)
add    %rdx,%rdi
movsd  0x20(%rcx),%xmm0
movsd  %xmm0,(%rdx,%rdi,1)
add    %rdx,%rdi
movsd  0x28(%rcx),%xmm0
movsd  %xmm0,(%rdx,%rdi,1)
add    %rdx,%rdi
movsd  0x30(%rcx),%xmm0
movsd  %xmm0,(%rdx,%rdi,1)
add    %rdx,%rdi
movsd  0x38(%rcx),%xmm0
add    $0x40,%rcx
movsd  %xmm0,(%rdx,%rdi,1)
add    %rdx,%rdi
add    %rdx,%rdi
add    $0xfffffffffffffff8,%rax
jne    1dc0 <minv+0xca0>
add    0x60(%rsp),%rsi
test   $0x7,%bl
je     1b60 <minv+0xa40>
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rcx,%rax,8),%xmm0
movsd  %xmm0,(%rsi)
add    $0x1,%rax
add    %rdx,%rsi
cmp    %rax,%r14
jne    1e50 <minv+0xd30>
jmp    1b60 <minv+0xa40>
mov    %r8d,%eax
imul   %eax,%eax
mov    0x50(%rsp),%rsi
lea    (%rsi,%rax,8),%rcx
mov    %rcx,0x68(%rsp)
lea    (%rsi,%rax,8),%rbx
add    $0xfffffffffffffff8,%rbx
mov    %r8d,%ecx
not    %ecx
movslq %ecx,%rcx
movslq %r8d,%rbp
mov    %rbp,%rdi
neg    %rdi
lea    (%rcx,%rbp,1),%rdx
add    %rax,%rdx
mov    %rcx,0x90(%rsp)
lea    0x0(,%rcx,8),%rax
mov    %rax,0x88(%rsp)
mov    %rbp,%r14
shl    $0x6,%r14
lea    0x0(,%rbp,8),%r9
mov    %r9,%rax
neg    %rax
mov    %rax,0x70(%rsp)
lea    (%rsi,%rdx,8),%r10
add    $0xfffffffffffffff8,%r10
mov    $0x1,%r11d
xor    %eax,%eax
mov    %rax,0x28(%rsp)
mov    $0x1,%r15b
movapd 0x1120(%rip),%xmm0
mov    0x4c(%rsp),%eax
mov    %eax,%esi
mov    %rbx,0x78(%rsp)
mov    %rdi,0x58(%rsp)
mov    %rbp,0x30(%rsp)
mov    %r14,0x60(%rsp)
jmp    1f3f <minv+0xe1f>
nopl   0x0(%rax)
add    $0xffffffff,%esi
add    $0x1,%r11d
mov    0x28(%rsp),%rax
add    $0x1,%eax
mov    %rax,0x28(%rsp)
add    0x88(%rsp),%r10
add    $0x1,%r15b
addq   $0xfffffffffffffff8,0x68(%rsp)
cmp    %r8d,%r11d
je     231a <minv+0x11fa>
movzbl %r15b,%r15d
and    $0x7,%r15d
mov    %r11d,%r13d
and    $0xfffffff8,%r13d
mov    0x90(%rsp),%rax
lea    (%rbx,%rax,8),%rbx
mov    %esi,%eax
not    %eax
add    %r8d,%eax
mov    %rbx,0xb0(%rsp)
lea    (%rbx,%rbp,8),%rcx
mov    %eax,0xa0(%rsp)
test   %eax,%eax
mov    %rsi,0x8(%rsp)
jle    2055 <minv+0xf35>
mov    %r12,%rbx
mov    %rcx,%rdx
cmpl   $0x7,0x28(%rsp)
jb     2029 <minv+0xf09>
mov    %r13d,%esi
xor    %edx,%edx
mov    %r12,%rbx
mov    %rcx,%rax
nopl   (%rax)
movsd  (%r10,%rdx,1),%xmm1
movsd  %xmm1,(%rbx)
lea    (%rax,%rbp,8),%rdi
movsd  (%rax,%rbp,8),%xmm1
movsd  %xmm1,0x8(%rbx)
lea    (%rdi,%rbp,8),%rax
movsd  (%rdi,%rbp,8),%xmm1
movsd  %xmm1,0x10(%rbx)
lea    (%rax,%rbp,8),%rdi
movsd  (%rax,%rbp,8),%xmm1
movsd  %xmm1,0x18(%rbx)
lea    (%rdi,%rbp,8),%rax
movsd  (%rdi,%rbp,8),%xmm1
movsd  %xmm1,0x20(%rbx)
lea    (%rax,%rbp,8),%rdi
movsd  (%rax,%rbp,8),%xmm1
movsd  %xmm1,0x28(%rbx)
lea    (%rdi,%rbp,8),%rax
movsd  (%rdi,%rbp,8),%xmm1
movsd  %xmm1,0x30(%rbx)
lea    (%rax,%rbp,8),%rdi
movsd  (%rax,%rbp,8),%xmm1
movsd  %xmm1,0x38(%rbx)
add    $0x40,%rbx
lea    (%rdi,%rbp,8),%rax
add    %r14,%rdx
add    $0xfffffff8,%esi
jne    1fa0 <minv+0xe80>
add    %r10,%rdx
mov    0x58(%rsp),%rdi
mov    0x8(%rsp),%rsi
test   $0x7,%r11b
je     2055 <minv+0xf35>
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%rdx),%xmm1
movsd  %xmm1,(%rbx,%rax,8)
add    $0x1,%rax
add    %r9,%rdx
cmp    %eax,%r15d
jne    2040 <minv+0xf20>
mov    %r13d,0x98(%rsp)
mov    %r15,0x80(%rsp)
mov    %r11d,0x3c(%rsp)
mov    %r10,0xa8(%rsp)
addq   $0xfffffffffffffff8,0x78(%rsp)
cmp    %esi,0x40(%rsp)
jle    21f0 <minv+0x10d0>
mov    0x3c(%rsp),%eax
movslq %eax,%r8
lea    0x1(%rsi),%edx
mov    %edx,0x10(%rsp)
neg    %eax
mov    %eax,0xb8(%rsp)
xor    %r14d,%r14d
mov    0x28(%rsp),%rax
mov    %eax,%r15d
mov    0x68(%rsp),%r13
mov    0x40(%rsp),%rax
mov    %eax,%edx
mov    0x78(%rsp),%rbp
jmp    20ed <minv+0xfcd>
nopw   0x0(%rax,%rax,1)
movsd  %xmm1,-0x8(%r12,%r8,8)
add    $0xffffffffffffffff,%r8
lea    0x0(%rbp,%rdi,8),%rbp
add    $0xffffffff,%edx
add    $0x1,%r14d
add    0x70(%rsp),%r13
add    $0x3,%r15b
mov    0x8(%rsp),%rsi
cmp    %esi,%edx
jle    21f0 <minv+0x10d0>
movsd  0x0(%rbp),%xmm1
xorpd  %xmm0,%xmm1
cmp    %edx,0x10(%rsp)
jge    20c0 <minv+0xfa0>
mov    %r14d,%ebx
not    %ebx
mov    0x28(%rsp),%rax
add    %eax,%ebx
sub    %r14d,%eax
test   $0x3,%al
je     216f <minv+0x104f>
movzbl %r15b,%edi
and    $0x3,%edi
shl    $0x3,%rdi
xor    %eax,%eax
mov    0x18(%rsp),%rsi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  -0x8(%r13,%rax,1),%xmm2
mulsd  (%r12,%rax,1),%xmm2
subsd  %xmm2,%xmm1
add    $0x1,%esi
add    $0x8,%rax
cmp    %eax,%edi
jne    2130 <minv+0x1010>
add    0xb8(%rsp),%esi
lea    (%r12,%rax,1),%r10
lea    (%rax,%r13,1),%r11
add    $0xfffffffffffffff0,%r11
mov    0x58(%rsp),%rdi
cmp    $0x3,%ebx
jb     20c0 <minv+0xfa0>
jmp    2182 <minv+0x1062>
mov    0x10(%rsp),%esi
mov    %r12,%r10
mov    %rbp,%r11
cmp    $0x3,%ebx
jb     20c0 <minv+0xfa0>
mov    %esi,%esi
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
movsd  0x8(%r11,%rbx,8),%xmm2
mulsd  (%r10,%rbx,8),%xmm2
movsd  0x10(%r11,%rbx,8),%xmm3
subsd  %xmm2,%xmm1
mulsd  0x8(%r10,%rbx,8),%xmm3
subsd  %xmm3,%xmm1
movsd  0x18(%r11,%rbx,8),%xmm2
mulsd  0x10(%r10,%rbx,8),%xmm2
subsd  %xmm2,%xmm1
movsd  0x20(%r11,%rbx,8),%xmm2
mulsd  0x18(%r10,%rbx,8),%xmm2
subsd  %xmm2,%xmm1
add    $0x4,%rbx
lea    (%rbx,%rsi,1),%eax
cmp    %edx,%eax
jl     2190 <minv+0x1070>
jmp    20c0 <minv+0xfa0>
nopw   0x0(%rax,%rax,1)
cmpl   $0x0,0xa0(%rsp)
mov    0x18(%rsp),%r8
mov    0x30(%rsp),%rbp
mov    0x60(%rsp),%r14
mov    0xb0(%rsp),%rbx
mov    0xa8(%rsp),%r10
mov    0x3c(%rsp),%r11d
mov    0x80(%rsp),%r15
jle    1f10 <minv+0xdf0>
cmpl   $0x7,0x28(%rsp)
jae    2250 <minv+0x1130>
mov    %r12,%rdx
test   $0x7,%r11b
jne    22f9 <minv+0x11d9>
jmp    1f10 <minv+0xdf0>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %rbx,%r13
xor    %esi,%esi
mov    %r12,%rdx
mov    0x98(%rsp),%ebx
nop
movsd  (%rdx),%xmm1
movsd  %xmm1,(%r10,%rsi,1)
lea    (%rcx,%rbp,8),%rax
movsd  0x8(%rdx),%xmm1
movsd  %xmm1,(%rcx,%rbp,8)
lea    (%rax,%rbp,8),%rdi
movsd  0x10(%rdx),%xmm1
movsd  %xmm1,(%rax,%rbp,8)
lea    (%rdi,%rbp,8),%rax
movsd  0x18(%rdx),%xmm1
movsd  %xmm1,(%rdi,%rbp,8)
lea    (%rax,%rbp,8),%rdi
movsd  0x20(%rdx),%xmm1
movsd  %xmm1,(%rax,%rbp,8)
lea    (%rdi,%rbp,8),%rax
movsd  0x28(%rdx),%xmm1
movsd  %xmm1,(%rdi,%rbp,8)
lea    (%rax,%rbp,8),%rdi
movsd  0x30(%rdx),%xmm1
movsd  %xmm1,(%rax,%rbp,8)
lea    (%rdi,%rbp,8),%rax
movsd  0x38(%rdx),%xmm1
add    $0x40,%rdx
movsd  %xmm1,(%rdi,%rbp,8)
lea    (%rax,%rbp,8),%rcx
add    %r14,%rsi
add    $0xfffffff8,%ebx
jne    2260 <minv+0x1140>
add    %r10,%rsi
mov    %rsi,%rcx
mov    0x58(%rsp),%rdi
mov    0x8(%rsp),%rsi
mov    %r13,%rbx
test   $0x7,%r11b
je     1f10 <minv+0xdf0>
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
movsd  (%rdx,%rax,8),%xmm1
movsd  %xmm1,(%rcx)
add    $0x1,%rax
add    %r9,%rcx
cmp    %eax,%r15d
jne    2300 <minv+0x11e0>
jmp    1f10 <minv+0xdf0>
mov    0x40(%rsp),%eax
mov    %rax,0x8(%rsp)
mov    %r8d,%eax
and    $0xfffffff8,%eax
mov    %eax,0x10(%rsp)
mov    %r8d,%r15d
and    $0x7,%r15d
lea    0x18(%r12),%r10
xor    %r13d,%r13d
mov    0x50(%rsp),%r11
mov    0x20(%rsp),%rcx
jmp    2363 <minv+0x1243>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r13
add    $0x8,%r11
cmp    0x8(%rsp),%r13
je     260a <minv+0x14ea>
mov    %r12,%rdx
mov    %r11,%rbx
mov    0x10(%rsp),%esi
mov    %r11,%rdi
cmpl   $0x7,0x40(%rsp)
jb     23fc <minv+0x12dc>
nopl   0x0(%rax,%rax,1)
mov    %rdi,%rbx
movsd  (%rdi),%xmm0
movsd  %xmm0,(%rdx)
add    %r9,%rdi
movsd  (%rbx,%r9,1),%xmm0
movsd  %xmm0,0x8(%rdx)
movsd  (%r9,%rdi,1),%xmm0
add    %r9,%rdi
movsd  %xmm0,0x10(%rdx)
movsd  (%r9,%rdi,1),%xmm0
add    %r9,%rdi
movsd  %xmm0,0x18(%rdx)
movsd  (%r9,%rdi,1),%xmm0
add    %r9,%rdi
movsd  %xmm0,0x20(%rdx)
movsd  (%r9,%rdi,1),%xmm0
add    %r9,%rdi
movsd  %xmm0,0x28(%rdx)
movsd  (%r9,%rdi,1),%xmm0
add    %r9,%rdi
movsd  %xmm0,0x30(%rdx)
movsd  (%r9,%rdi,1),%xmm0
add    %r9,%rdi
movsd  %xmm0,0x38(%rdx)
add    $0x40,%rdx
add    %r9,%rdi
add    $0xfffffff8,%esi
jne    2380 <minv+0x1260>
add    %r14,%rbx
test   $0x7,%r8b
je     2425 <minv+0x1305>
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%rbx),%xmm0
movsd  %xmm0,(%rdx,%rax,8)
add    $0x1,%rax
add    %r9,%rbx
cmp    %eax,%r15d
jne    2410 <minv+0x12f0>
lea    0x1(%r13),%r14d
xor    %edx,%edx
mov    0x50(%rsp),%rbx
jmp    245e <minv+0x133e>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  %xmm0,(%r12,%rdx,8)
add    $0x1,%rdx
mov    0x30(%rsp),%rax
lea    (%rbx,%rax,8),%rbx
cmp    0x20(%rsp),%rdx
je     2540 <minv+0x1420>
cmp    %r13,%rdx
jbe    2480 <minv+0x1360>
lea    (%rbx,%rdx,8),%rbp
xorpd  %xmm0,%xmm0
mov    %edx,%eax
cmp    %r8d,%eax
jge    2440 <minv+0x1320>
jmp    2496 <minv+0x1376>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%r12,%rdx,8),%xmm0
lea    (%rbx,%r13,8),%rbp
add    $0x8,%rbp
mov    %r14d,%eax
cmp    %r8d,%eax
jge    2440 <minv+0x1320>
mov    %eax,%esi
mov    %ecx,%r8d
sub    %eax,%r8d
mov    %rsi,%rdi
not    %rdi
add    %rcx,%rdi
and    $0x3,%r8
je     24cd <minv+0x13ad>
nopl   (%rax)
movsd  0x0(%rbp),%xmm1
mulsd  (%r12,%rsi,8),%xmm1
add    $0x8,%rbp
add    $0x1,%rsi
addsd  %xmm1,%xmm0
add    $0xffffffffffffffff,%r8
jne    24b0 <minv+0x1390>
cmp    $0x3,%rdi
mov    0x18(%rsp),%r8
jb     2440 <minv+0x1320>
mov    0x20(%rsp),%rdi
sub    %rsi,%rdi
lea    (%r10,%rsi,8),%rsi
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
movsd  0x0(%rbp,%rax,8),%xmm1
movsd  0x8(%rbp,%rax,8),%xmm2
mulsd  -0x18(%rsi,%rax,8),%xmm1
mulsd  -0x10(%rsi,%rax,8),%xmm2
addsd  %xmm0,%xmm1
movsd  0x10(%rbp,%rax,8),%xmm3
mulsd  -0x8(%rsi,%rax,8),%xmm3
addsd  %xmm1,%xmm2
movsd  0x18(%rbp,%rax,8),%xmm0
mulsd  (%rsi,%rax,8),%xmm0
addsd  %xmm2,%xmm3
addsd  %xmm3,%xmm0
add    $0x4,%rax
cmp    %rax,%rdi
jne    24f0 <minv+0x13d0>
jmp    2440 <minv+0x1320>
nopl   (%rax)
mov    %r12,%rdx
mov    %r11,%rbx
cmpl   $0x7,0x40(%rsp)
mov    0x60(%rsp),%r14
jb     25dc <minv+0x14bc>
mov    0x10(%rsp),%esi
mov    %r11,%rdi
mov    %r12,%rdx
mov    %rdi,%rbx
movsd  (%rdx),%xmm0
movsd  %xmm0,(%rdi)
movsd  0x8(%rdx),%xmm0
add    %r9,%rdi
movsd  %xmm0,(%rbx,%r9,1)
movsd  0x10(%rdx),%xmm0
movsd  %xmm0,(%r9,%rdi,1)
add    %r9,%rdi
movsd  0x18(%rdx),%xmm0
movsd  %xmm0,(%r9,%rdi,1)
add    %r9,%rdi
movsd  0x20(%rdx),%xmm0
movsd  %xmm0,(%r9,%rdi,1)
add    %r9,%rdi
movsd  0x28(%rdx),%xmm0
movsd  %xmm0,(%r9,%rdi,1)
add    %r9,%rdi
movsd  0x30(%rdx),%xmm0
movsd  %xmm0,(%r9,%rdi,1)
add    %r9,%rdi
movsd  0x38(%rdx),%xmm0
add    $0x40,%rdx
movsd  %xmm0,(%r9,%rdi,1)
add    %r9,%rdi
add    %r9,%rdi
add    $0xfffffff8,%esi
jne    2560 <minv+0x1440>
add    %r14,%rbx
test   $0x7,%r8b
je     2350 <minv+0x1230>
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
movsd  (%rdx,%rax,8),%xmm0
movsd  %xmm0,(%rbx)
add    $0x1,%rax
add    %r9,%rbx
cmp    %eax,%r15d
jne    25f0 <minv+0x14d0>
jmp    2350 <minv+0x1230>
mov    0x4c(%rsp),%r11d
mov    %r8,%r14
and    $0x3,%r8d
and    $0xfffffffc,%r14d
mov    0x30(%rsp),%r13
shl    $0x5,%r13
mov    0x50(%rsp),%r15
lea    (%r15,%r11,8),%r10
mov    0xc0(%rsp),%rcx
jmp    265b <minv+0x153b>
cs nopw 0x0(%rax,%rax,1)
mov    %r12,%rcx
add    $0xfffffffffffffffc,%rcx
lea    -0x1(%r11),%rax
add    $0xfffffffffffffff8,%r10
test   %r11,%r11
mov    %rax,%r11
jle    2753 <minv+0x1633>
mov    %rcx,%r12
movslq -0x4(%rcx),%rax
lea    (%r15,%rax,8),%rbx
cmpl   $0x3,0x40(%rsp)
jae    2680 <minv+0x1560>
lea    (%r15,%r11,8),%rbp
test   %r8d,%r8d
jne    2728 <minv+0x1608>
jmp    2640 <minv+0x1520>
nopl   0x0(%rax)
mov    %r14d,%esi
mov    %r10,%rax
cs nopw 0x0(%rax,%rax,1)
mov    %rbx,%rdx
mov    %rax,%rbp
movsd  (%rax),%xmm0
movsd  (%rbx),%xmm1
movsd  %xmm1,(%rax)
movsd  %xmm0,(%rbx)
add    %r9,%rax
movsd  0x0(%rbp,%r9,1),%xmm0
lea    (%rbx,%r9,1),%rbx
movsd  (%rdx,%r9,1),%xmm1
movsd  %xmm1,0x0(%rbp,%r9,1)
movsd  %xmm0,(%rdx,%r9,1)
lea    (%rax,%r9,1),%rdi
movsd  (%r9,%rax,1),%xmm0
lea    (%rbx,%r9,1),%rcx
movsd  (%r9,%rbx,1),%xmm1
movsd  %xmm1,(%r9,%rax,1)
movsd  %xmm0,(%r9,%rbx,1)
lea    (%rdi,%r9,1),%rax
movsd  (%r9,%rdi,1),%xmm0
lea    (%rcx,%r9,1),%rbx
movsd  (%r9,%rcx,1),%xmm1
movsd  %xmm1,(%r9,%rdi,1)
movsd  %xmm0,(%r9,%rcx,1)
add    %r9,%rax
add    %r9,%rbx
add    $0xfffffffc,%esi
jne    2690 <minv+0x1570>
add    %r13,%rdx
add    %r13,%rbp
mov    %rdx,%rbx
test   %r8d,%r8d
je     2640 <minv+0x1520>
mov    %r8d,%eax
xor    %edx,%edx
nopl   (%rax)
movsd  0x0(%rbp,%rdx,1),%xmm0
movsd  (%rbx,%rdx,1),%xmm1
movsd  %xmm1,0x0(%rbp,%rdx,1)
movsd  %xmm0,(%rbx,%rdx,1)
add    %r9,%rdx
add    $0xffffffff,%eax
jne    2730 <minv+0x1610>
jmp    2640 <minv+0x1520>
xor    %eax,%eax
add    $0xc8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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