int minv(double *a, int n) {
  int lc, *le;
  double s, t, tq = 0., zr = 1.e-15;
  double *pa, *pd, *ps, *p, *q, *q0;
  int i, j, k, m;
  le = (int *)malloc(n * sizeof(int));
  q0 = (double *)malloc(n * sizeof(double));
  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) {
      free(le - j);
      free(q0);
      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;
    }
  }
  free(le);
  free(q0);
  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)
movslq -0x14(%rbp),%rdi
shl    $0x2,%rdi
call   1040 <malloc@plt>
mov    %rax,-0x20(%rbp)
movslq -0x14(%rbp),%rdi
shl    $0x3,%rdi
call   1040 <malloc@plt>
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    15d0 <minv+0x4b0>
cmpl   $0x0,-0x78(%rbp)
jle    1353 <minv+0x233>
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    11f3 <minv+0xd3>
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    11a9 <minv+0x89>
movl   $0x1,-0x74(%rbp)
mov    -0x74(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    12ed <minv+0x1cd>
mov    -0x74(%rbp),%eax
cmp    -0x78(%rbp),%eax
jge    1220 <minv+0x100>
mov    -0x74(%rbp),%eax
mov    %eax,-0x84(%rbp)
jmp    1229 <minv+0x109>
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    12c4 <minv+0x1a4>
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    1272 <minv+0x152>
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    11fa <minv+0xda>
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    134e <minv+0x22e>
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    1304 <minv+0x1e4>
jmp    1353 <minv+0x233>
mov    -0x50(%rbp),%rax
movsd  (%rax),%xmm0
movaps 0xcae(%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    13ec <minv+0x2cc>
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 0xc5b(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x30(%rbp)
ucomisd -0x28(%rbp),%xmm0
jbe    13d9 <minv+0x2b9>
movsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0x28(%rbp)
mov    -0x7c(%rbp),%eax
mov    %eax,-0x18(%rbp)
jmp    13de <minv+0x2be>
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
jmp    1382 <minv+0x262>
movsd  -0x38(%rbp),%xmm0
ucomisd -0x28(%rbp),%xmm0
jbe    140e <minv+0x2ee>
movsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
jmp    141b <minv+0x2fb>
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    146f <minv+0x34f>
mov    -0x20(%rbp),%rdi
movslq -0x78(%rbp),%rcx
xor    %eax,%eax
sub    %rcx,%rax
shl    $0x2,%rax
add    %rax,%rdi
call   1030 <free@plt>
mov    -0x70(%rbp),%rdi
call   1030 <free@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    1dc3 <minv+0xca3>
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     1527 <minv+0x407>
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    1522 <minv+0x402>
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    14c8 <minv+0x3a8>
jmp    1527 <minv+0x407>
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
mov    -0x50(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x50(%rbp),%rax
movsd  0xac4(%rip),%xmm0
divsd  (%rax),%xmm0
movsd  %xmm0,-0x30(%rbp)
mov    -0x7c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1591 <minv+0x471>
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    154d <minv+0x42d>
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    117c <minv+0x5c>
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    1674 <minv+0x554>
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    1661 <minv+0x541>
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    161e <minv+0x4fe>
jmp    1666 <minv+0x546>
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    15e3 <minv+0x4c3>
movl   $0x1,-0x78(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x78(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1861 <minv+0x741>
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    16fc <minv+0x5dc>
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    16b2 <minv+0x592>
movl   $0x0,-0x7c(%rbp)
mov    -0x7c(%rbp),%eax
cmp    -0x78(%rbp),%eax
jge    17ed <minv+0x6cd>
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    17cd <minv+0x6ad>
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    1764 <minv+0x644>
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    1703 <minv+0x5e3>
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    184e <minv+0x72e>
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    1804 <minv+0x6e4>
jmp    1853 <minv+0x733>
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    1683 <minv+0x563>
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     1ac7 <minv+0x9a7>
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    1936 <minv+0x816>
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    18ec <minv+0x7cc>
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    1a3c <minv+0x91c>
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    19fa <minv+0x8da>
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    1990 <minv+0x870>
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    1947 <minv+0x827>
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    1ab4 <minv+0x994>
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    1a6a <minv+0x94a>
jmp    1ab9 <minv+0x999>
mov    -0x78(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x78(%rbp)
jmp    188b <minv+0x76b>
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    1cce <minv+0xbae>
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    1b48 <minv+0xa28>
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    1afe <minv+0x9de>
movl   $0x0,-0x78(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x78(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1c4e <minv+0xb2e>
mov    -0x78(%rbp),%eax
cmp    -0x7c(%rbp),%eax
jle    1b95 <minv+0xa75>
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    1bc7 <minv+0xaa7>
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    1bcc <minv+0xaac>
mov    -0x74(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1c19 <minv+0xaf9>
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    1bcc <minv+0xaac>
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    1b57 <minv+0xa37>
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    1caf <minv+0xb8f>
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    1c65 <minv+0xb45>
jmp    1cb4 <minv+0xb94>
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
mov    -0x48(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x48(%rbp)
jmp    1ad6 <minv+0x9b6>
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     1daa <minv+0xc8a>
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    1d97 <minv+0xc77>
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    1d29 <minv+0xc09>
jmp    1d9c <minv+0xc7c>
mov    -0x78(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x78(%rbp)
jmp    1ce3 <minv+0xbc3>
mov    -0x20(%rbp),%rdi
call   1030 <free@plt>
mov    -0x70(%rbp),%rdi
call   1030 <free@plt>
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    $0xd8,%rsp
mov    %rdi,%r12
mov    %rsi,0x18(%rsp)
movslq %esi,%rbp
lea    0x0(,%rbp,4),%rdi
call   1040 <malloc@plt>
mov    %rax,%r13
lea    0x0(,%rbp,8),%r15
mov    %r15,%rdi
call   1040 <malloc@plt>
mov    %rax,%rbx
test   %ebp,%ebp
jle    1eda <minv+0xdba>
mov    %ebp,%eax
lea    -0x1(%rbp),%esi
lea    (%r12,%rsi,8),%rcx
add    $0x8,%rcx
mov    %rcx,0x70(%rsp)
lea    0x1(%rsi),%rdx
lea    -0x2(%rbp),%ecx
mov    %ecx,0x4c(%rsp)
mov    %rdx,0x78(%rsp)
and    $0xfffffffffffffffc,%rdx
mov    %rdx,0x68(%rsp)
lea    -0x4(%rdx),%rcx
mov    %rcx,0xb0(%rsp)
mov    %rcx,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
mov    %ebp,%ecx
and    $0xfffffff8,%ecx
mov    %ecx,0x80(%rsp)
mov    %rdx,%rcx
mov    %rdx,0xa8(%rsp)
and    $0xfffffffffffffffe,%rdx
mov    %rdx,0xa0(%rsp)
mov    %rbp,%rcx
shl    $0x6,%rcx
mov    %rcx,0x58(%rsp)
mov    %ebp,%edi
and    $0x7,%edi
mov    %rbp,%r10
shl    $0x4,%r10
mov    %rbp,%r11
shl    $0x5,%r11
xorpd  %xmm0,%xmm0
movapd 0x1e09(%rip),%xmm1
movapd 0x1e01(%rip),%xmm2
movsd  0x1e19(%rip),%xmm3
movsd  0x1e18(%rip),%xmm8
lea    (%r12,%rbp,8),%rcx
mov    %rcx,0xb8(%rsp)
lea    0x30(%r12),%r14
mov    %rax,0x60(%rsp)
lea    0x8(,%rax,8),%rax
mov    %rax,0x88(%rsp)
mov    %rbp,0x38(%rsp)
add    $0x3,%ebp
lea    (%r15,%r15,2),%rax
mov    %rax,0x90(%rsp)
xor    %r9d,%r9d
mov    %r12,0x8(%rsp)
mov    %r14,0xd0(%rsp)
xor    %r8d,%r8d
mov    %r12,0x50(%rsp)
mov    %r12,0x10(%rsp)
mov    %rbx,(%rsp)
mov    %r15,0x20(%rsp)
mov    %rsi,0x30(%rsp)
mov    %r11,0xc8(%rsp)
mov    %rdi,0x28(%rsp)
jmp    12d3 <minv+0x1b3>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x98(%rsp),%rax
lea    0x4(%rax),%r13
mov    0x8(%rsp),%rax
movsd  %xmm6,(%rax)
addq   $0x8,0x10(%rsp)
add    0x88(%rsp),%rax
mov    %rax,0x8(%rsp)
add    $0x1,%r9d
add    %r15,%r14
add    $0x3,%bpl
cmp    0x60(%rsp),%r8
mov    0x28(%rsp),%rdi
je     1a76 <minv+0x956>
mov    %rbp,0x40(%rsp)
mov    %r13,0x98(%rsp)
mov    %r8,%r12
test   %r8,%r8
mov    0x18(%rsp),%rbp
je     14b4 <minv+0x394>
mov    %rbx,%rax
mov    0x10(%rsp),%rcx
cmpl   $0x7,0x30(%rsp)
jb     139e <minv+0x27e>
mov    0x80(%rsp),%edx
mov    0x10(%rsp),%rsi
mov    %rbx,%rax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %rsi,%rcx
movsd  (%rsi),%xmm5
movsd  %xmm5,(%rax)
add    %r15,%rsi
movsd  (%rcx,%r15,1),%xmm5
movsd  %xmm5,0x8(%rax)
movsd  (%r15,%rsi,1),%xmm5
add    %r15,%rsi
movsd  %xmm5,0x10(%rax)
movsd  (%r15,%rsi,1),%xmm5
add    %r15,%rsi
movsd  %xmm5,0x18(%rax)
movsd  (%r15,%rsi,1),%xmm5
add    %r15,%rsi
movsd  %xmm5,0x20(%rax)
movsd  (%r15,%rsi,1),%xmm5
add    %r15,%rsi
movsd  %xmm5,0x28(%rax)
movsd  (%r15,%rsi,1),%xmm5
add    %r15,%rsi
movsd  %xmm5,0x30(%rax)
movsd  (%r15,%rsi,1),%xmm5
add    %r15,%rsi
movsd  %xmm5,0x38(%rax)
add    $0x40,%rax
add    %r15,%rsi
add    $0xfffffff8,%edx
jne    1320 <minv+0x200>
add    0x58(%rsp),%rcx
test   $0x7,%bpl
je     13c4 <minv+0x2a4>
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
movsd  (%rcx),%xmm5
movsd  %xmm5,(%rax,%rdx,8)
add    $0x1,%rdx
add    %r15,%rcx
cmp    %edx,%edi
jne    13b0 <minv+0x290>
cmp    $0x1,%ebp
jne    1510 <minv+0x3f0>
mov    %rbx,%rax
mov    0x10(%rsp),%rcx
cmpl   $0x7,0x30(%rsp)
mov    0x18(%rsp),%rbp
mov    0x20(%rsp),%r15
mov    0xc8(%rsp),%r11
mov    0x28(%rsp),%rdi
jb     148e <minv+0x36e>
mov    0x80(%rsp),%edx
mov    0x10(%rsp),%rsi
mov    %rbx,%rax
cs nopw 0x0(%rax,%rax,1)
mov    %rsi,%rcx
movsd  (%rax),%xmm5
movsd  %xmm5,(%rsi)
movsd  0x8(%rax),%xmm5
add    %r15,%rsi
movsd  %xmm5,(%rcx,%r15,1)
movsd  0x10(%rax),%xmm5
movsd  %xmm5,(%r15,%rsi,1)
add    %r15,%rsi
movsd  0x18(%rax),%xmm5
movsd  %xmm5,(%r15,%rsi,1)
add    %r15,%rsi
movsd  0x20(%rax),%xmm5
movsd  %xmm5,(%r15,%rsi,1)
add    %r15,%rsi
movsd  0x28(%rax),%xmm5
movsd  %xmm5,(%r15,%rsi,1)
add    %r15,%rsi
movsd  0x30(%rax),%xmm5
movsd  %xmm5,(%r15,%rsi,1)
add    %r15,%rsi
movsd  0x38(%rax),%xmm5
add    $0x40,%rax
movsd  %xmm5,(%r15,%rsi,1)
add    %r15,%rsi
add    %r15,%rsi
add    $0xfffffff8,%edx
jne    1410 <minv+0x2f0>
add    0x58(%rsp),%rcx
test   $0x7,%bpl
je     14b4 <minv+0x394>
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
movsd  (%rax,%rdx,8),%xmm5
movsd  %xmm5,(%rcx)
add    $0x1,%rdx
add    %r15,%rcx
cmp    %edx,%edi
jne    14a0 <minv+0x380>
mov    0x30(%rsp),%rax
mov    %eax,%edx
sub    %r12d,%edx
mov    0x8(%rsp),%rax
movsd  (%rax),%xmm5
movapd %xmm5,%xmm7
andpd  %xmm1,%xmm7
lea    0x1(%r12),%r8
cmp    0x38(%rsp),%r8
jge    1500 <minv+0x3e0>
test   $0x1,%dl
jne    1670 <minv+0x550>
mov    %r8d,%esi
mov    0x8(%rsp),%rcx
mov    %r12d,%eax
cmp    %r12d,0x4c(%rsp)
jne    16a5 <minv+0x585>
jmp    16e7 <minv+0x5c7>
nop
movapd %xmm7,%xmm6
mov    %r12d,%eax
jmp    16e7 <minv+0x5c7>
nopl   0x0(%rax)
lea    0x0(,%r12,8),%rax
mov    0x10(%rsp),%r13
sub    %rax,%r13
mov    $0x1,%r11d
xor    %edi,%edi
mov    0xb8(%rsp),%rax
jmp    1568 <minv+0x448>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    (%rsp),%rbx
movsd  (%rbx,%r11,8),%xmm6
subsd  %xmm5,%xmm6
movsd  %xmm6,(%rbx,%r11,8)
add    $0x1,%r11
add    0x20(%rsp),%rax
cmp    0x60(%rsp),%r11
je     13cd <minv+0x2ad>
cmp    %r11d,%r9d
mov    %r11d,%esi
cmovb  %r9d,%esi
cmp    $0x2,%esi
mov    $0x1,%edx
cmovl  %edx,%esi
add    $0x1,%edi
cmp    %edi,%r12d
mov    %edi,%ecx
cmovb  %r12d,%ecx
cmp    $0x2,%ecx
cmovl  %edx,%ecx
lea    -0x1(%rcx),%edx
cmp    $0x3,%edx
jae    15c0 <minv+0x4a0>
mov    %r11,%rdx
imul   0x38(%rsp),%rdx
lea    0x0(,%rdx,8),%rbp
add    %r13,%rbp
xorpd  %xmm5,%xmm5
test   $0x3,%cl
jne    163c <minv+0x51c>
jmp    1540 <minv+0x420>
nopw   0x0(%rax,%rax,1)
mov    %esi,%edx
and    $0x7ffffffc,%edx
xorpd  %xmm5,%xmm5
xor    %ebp,%ebp
xor    %r8d,%r8d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%rax,%rbp,8),%xmm6
mulsd  (%rbx,%rbp,8),%xmm6
movsd  0x8(%rax,%rbp,8),%xmm7
addsd  %xmm5,%xmm6
mulsd  0x8(%rbx,%rbp,8),%xmm7
addsd  %xmm6,%xmm7
movsd  0x10(%rax,%rbp,8),%xmm6
mulsd  0x10(%rbx,%rbp,8),%xmm6
addsd  %xmm7,%xmm6
movsd  0x18(%rax,%rbp,8),%xmm5
mulsd  0x18(%rbx,%rbp,8),%xmm5
addsd  %xmm6,%xmm5
add    $0xffffffffffffffe0,%r8
add    $0x4,%rbp
cmp    %ebp,%edx
jne    15e0 <minv+0x4c0>
sub    %r8,%rbx
mov    %rax,%rbp
sub    %r8,%rbp
test   $0x3,%cl
je     1540 <minv+0x420>
and    $0x3,%esi
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  0x0(%rbp,%rcx,8),%xmm6
mulsd  (%rbx,%rcx,8),%xmm6
addsd  %xmm6,%xmm5
add    $0x1,%rcx
cmp    %ecx,%esi
jne    1650 <minv+0x530>
jmp    1540 <minv+0x420>
nopl   0x0(%rax)
mov    0x38(%rsp),%rax
mov    0x8(%rsp),%rsi
lea    (%rsi,%rax,8),%rcx
movsd  (%rsi,%rax,8),%xmm6
andpd  %xmm1,%xmm6
ucomisd %xmm7,%xmm6
maxsd  %xmm7,%xmm6
mov    %r12d,%eax
cmova  %r8d,%eax
lea    0x1(%r8),%esi
movapd %xmm6,%xmm7
cmp    %r12d,0x4c(%rsp)
je     16e7 <minv+0x5c7>
movapd %xmm7,%xmm6
nopl   0x0(%rax)
movsd  (%rcx,%r15,1),%xmm7
andpd  %xmm2,%xmm7
ucomisd %xmm6,%xmm7
maxsd  %xmm6,%xmm7
cmova  %esi,%eax
movsd  (%rcx,%r10,1),%xmm6
add    %r10,%rcx
andpd  %xmm2,%xmm6
ucomisd %xmm7,%xmm6
lea    0x1(%rsi),%edi
cmova  %edi,%eax
maxsd  %xmm7,%xmm6
add    $0x2,%esi
cmp    %ebp,%esi
jne    16b0 <minv+0x590>
maxsd  %xmm6,%xmm0
movapd %xmm0,%xmm7
mulsd  %xmm3,%xmm7
ucomisd %xmm6,%xmm7
ja     1a55 <minv+0x935>
mov    0x98(%rsp),%rcx
mov    %eax,(%rcx)
mov    %eax,%ecx
cmp    %rcx,%r12
mov    0x40(%rsp),%rbp
je     194e <minv+0x82e>
mov    %edx,0xc0(%rsp)
mov    %r12,%rcx
imul   0x38(%rsp),%rcx
mov    0x50(%rsp),%rsi
lea    (%rsi,%rcx,8),%r13
imul   0x18(%rsp),%eax
xor    %edi,%edi
cltq
lea    (%rsi,%rax,8),%rsi
cmpl   $0x3,0x30(%rsp)
jb     1870 <minv+0x750>
mov    0x70(%rsp),%rbp
lea    0x0(%rbp,%rax,8),%rbp
cmp    %rbp,%r13
jae    1775 <minv+0x655>
add    0x78(%rsp),%rcx
mov    0x50(%rsp),%rbp
lea    0x0(,%rcx,8),%rcx
add    %rbp,%rcx
cmp    %rcx,%rsi
jb     1870 <minv+0x750>
cmpq   $0x0,0xb0(%rsp)
je     1a3b <minv+0x91b>
mov    0xd0(%rsp),%rcx
lea    (%rcx,%rax,8),%rcx
mov    0xa0(%rsp),%rdi
xor    %eax,%eax
mov    0x40(%rsp),%rbp
nop
movups -0x30(%r14,%rax,8),%xmm5
movups -0x20(%r14,%rax,8),%xmm6
movups -0x30(%rcx,%rax,8),%xmm7
movups -0x20(%rcx,%rax,8),%xmm4
movups %xmm7,-0x30(%r14,%rax,8)
movups %xmm4,-0x20(%r14,%rax,8)
movups %xmm5,-0x30(%rcx,%rax,8)
movups %xmm6,-0x20(%rcx,%rax,8)
movupd -0x10(%r14,%rax,8),%xmm4
movupd (%r14,%rax,8),%xmm5
movupd -0x10(%rcx,%rax,8),%xmm6
movupd (%rcx,%rax,8),%xmm7
movupd %xmm6,-0x10(%r14,%rax,8)
movupd %xmm7,(%r14,%rax,8)
movupd %xmm4,-0x10(%rcx,%rax,8)
movupd %xmm5,(%rcx,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rdi
jne    17a0 <minv+0x680>
testb  $0x1,0xa8(%rsp)
01
je     1842 <minv+0x722>
movupd 0x0(%r13,%rax,8),%xmm4
movupd 0x10(%r13,%rax,8),%xmm5
movupd (%rsi,%rax,8),%xmm6
movupd 0x10(%rsi,%rax,8),%xmm7
movupd %xmm6,0x0(%r13,%rax,8)
movupd %xmm7,0x10(%r13,%rax,8)
movupd %xmm4,(%rsi,%rax,8)
movupd %xmm5,0x10(%rsi,%rax,8)
mov    0x68(%rsp),%rax
cmp    %rax,0x78(%rsp)
je     193e <minv+0x81e>
mov    0x68(%rsp),%rax
lea    (%rsi,%rax,8),%rsi
lea    0x0(%r13,%rax,8),%r13
mov    %eax,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x18(%rsp),%rbp
mov    %ebp,%ecx
sub    %edi,%ecx
mov    %edi,%eax
not    %eax
add    %ebp,%eax
and    $0x3,%ecx
je     18b5 <minv+0x795>
neg    %ecx
xor    %ebp,%ebp
nopl   0x0(%rax,%rax,1)
movsd  0x0(%r13),%xmm4
movsd  (%rsi),%xmm5
movsd  %xmm5,0x0(%r13)
add    $0x8,%r13
movsd  %xmm4,(%rsi)
add    $0x8,%rsi
add    $0xffffffff,%ebp
cmp    %ebp,%ecx
jne    1890 <minv+0x770>
sub    %ebp,%edi
mov    0x40(%rsp),%rbp
cmp    $0x3,%eax
jb     193e <minv+0x81e>
mov    0x18(%rsp),%rax
sub    %edi,%eax
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
movsd  0x0(%r13,%rcx,8),%xmm4
movsd  (%rsi,%rcx,8),%xmm5
movsd  %xmm5,0x0(%r13,%rcx,8)
movsd  %xmm4,(%rsi,%rcx,8)
movsd  0x8(%r13,%rcx,8),%xmm4
movsd  0x8(%rsi,%rcx,8),%xmm5
movsd  %xmm5,0x8(%r13,%rcx,8)
movsd  %xmm4,0x8(%rsi,%rcx,8)
movsd  0x10(%r13,%rcx,8),%xmm4
movsd  0x10(%rsi,%rcx,8),%xmm5
movsd  %xmm5,0x10(%r13,%rcx,8)
movsd  %xmm4,0x10(%rsi,%rcx,8)
movsd  0x18(%r13,%rcx,8),%xmm4
movsd  0x18(%rsi,%rcx,8),%xmm5
movsd  %xmm5,0x18(%r13,%rcx,8)
movsd  %xmm4,0x18(%rsi,%rcx,8)
add    $0x4,%rcx
cmp    %ecx,%eax
jne    18d0 <minv+0x7b0>
mov    0x8(%rsp),%rax
movsd  (%rax),%xmm5
mov    0xc0(%rsp),%edx
movapd %xmm8,%xmm6
divsd  %xmm5,%xmm6
movzbl %bpl,%ebp
and    $0x3,%ebp
cmp    0x38(%rsp),%r8
mov    0x90(%rsp),%rsi
jge    1290 <minv+0x170>
mov    0x4c(%rsp),%ecx
sub    %r12d,%ecx
test   $0x3,%dl
je     19ca <minv+0x8aa>
mov    $0xffffffff,%esi
mov    0x8(%rsp),%rax
nopw   0x0(%rax,%rax,1)
movsd  (%rax,%r15,1),%xmm4
mulsd  %xmm6,%xmm4
movsd  %xmm4,(%rax,%r15,1)
add    %r15,%rax
mov    %esi,%edi
add    $0xffffffff,%esi
add    %ebp,%edi
add    $0xffffffff,%edi
cmp    $0xffffffff,%edi
jne    1990 <minv+0x870>
mov    %r9d,%edi
sub    %esi,%edi
mov    0x90(%rsp),%rsi
cmp    $0x3,%ecx
jb     1290 <minv+0x170>
jmp    19db <minv+0x8bb>
mov    %r8d,%edi
mov    0x8(%rsp),%rax
cmp    $0x3,%ecx
jb     1290 <minv+0x170>
mov    0x18(%rsp),%rcx
sub    %edi,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%rax,%r15,1),%xmm4
mulsd  %xmm6,%xmm4
movsd  %xmm4,(%rax,%r15,1)
movsd  (%rax,%r10,1),%xmm4
mulsd  %xmm6,%xmm4
movsd  %xmm4,(%rax,%r10,1)
movsd  (%rax,%rsi,1),%xmm4
mulsd  %xmm6,%xmm4
movsd  %xmm4,(%rax,%rsi,1)
movsd  (%rax,%r11,1),%xmm4
mulsd  %xmm6,%xmm4
movsd  %xmm4,(%rax,%r11,1)
add    %r11,%rax
add    $0xfffffffc,%ecx
jne    19f0 <minv+0x8d0>
jmp    1290 <minv+0x170>
xor    %eax,%eax
mov    0x40(%rsp),%rbp
testb  $0x1,0xa8(%rsp)
01
jne    1810 <minv+0x6f0>
jmp    1842 <minv+0x722>
mov    %r12d,%eax
shl    $0x2,%rax
mov    0x98(%rsp),%rdi
sub    %rax,%rdi
call   1030 <free@plt>
mov    $0xffffffff,%ebp
jmp    1ee8 <minv+0xdc8>
mov    0x18(%rsp),%rax
cmp    $0x2,%eax
jl     1eda <minv+0xdba>
lea    0x1(%rax),%r8d
mov    0x50(%rsp),%r12
lea    0x8(%r12),%r11
mov    $0x1,%r15d
xor    %r14d,%r14d
mov    %r12,%r9
mov    %r12,%rax
mov    0x20(%rsp),%rbp
jmp    1ac7 <minv+0x9a7>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r15d
add    $0x1,%r14d
add    $0x8,%r11
cmp    0x18(%rsp),%r15d
je     1b79 <minv+0xa59>
lea    (%rax,%r8,8),%rax
add    $0x8,%r9
mov    %r9,%rcx
cmp    $0x3,%r14d
jb     1b48 <minv+0xa28>
mov    %r15d,%edx
and    $0xfffffffc,%edx
mov    %r11,%rdi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%rax),%xmm0
mov    %rdi,%rcx
mulsd  (%rdi),%xmm0
movsd  %xmm0,(%rdi)
movsd  (%rax),%xmm0
mulsd  (%rdi,%rbp,1),%xmm0
movsd  %xmm0,(%rdi,%rbp,1)
add    %rbp,%rdi
movsd  (%rax),%xmm0
mulsd  0x0(%rbp,%rdi,1),%xmm0
lea    (%rdi,%rbp,1),%rsi
movsd  %xmm0,0x0(%rbp,%rdi,1)
movsd  (%rax),%xmm0
mulsd  0x0(%rbp,%rsi,1),%xmm0
lea    (%rsi,%rbp,1),%rdi
movsd  %xmm0,0x0(%rbp,%rsi,1)
add    %rbp,%rdi
add    $0xfffffffc,%edx
jne    1af0 <minv+0x9d0>
add    0xc8(%rsp),%rcx
test   $0x3,%r15b
mov    0x20(%rsp),%rsi
je     1ab0 <minv+0x990>
mov    %r15d,%edx
and    $0x3,%edx
nopl   (%rax)
movsd  (%rax),%xmm0
mulsd  (%rcx),%xmm0
movsd  %xmm0,(%rcx)
add    %rsi,%rcx
add    $0xffffffff,%edx
jne    1b60 <minv+0xa40>
jmp    1ab0 <minv+0x990>
cmpl   $0x2,0x18(%rsp)
mov    0x20(%rsp),%r8
jl     1eda <minv+0xdba>
lea    0x8(%r12),%rbx
add    $0x10,%r10
mov    0x38(%rsp),%rax
lea    (%r12,%rax,8),%rax
add    $0x8,%rax
mov    %rax,0x28(%rsp)
mov    $0x1,%r9d
mov    $0x2,%eax
mov    %rax,0x8(%rsp)
xor    %edi,%edi
mov    %r12,%rbp
mov    0x58(%rsp),%r14
jmp    1bdd <minv+0xabd>
add    $0x1,%r9
add    $0x1,%rdi
add    $0x8,%rbx
addq   $0x1,0x8(%rsp)
cmp    0x60(%rsp),%r9
je     1f04 <minv+0xde4>
mov    %r9d,%r15d
and    $0x7,%r15d
mov    %r9,%rcx
and    $0xfffffffffffffff8,%rcx
add    $0x8,%rbp
mov    (%rsp),%rax
mov    %rbp,0x10(%rsp)
cmp    $0x7,%rdi
jb     1c8e <minv+0xb6e>
mov    %rcx,%rsi
mov    %rbx,%rdx
mov    (%rsp),%rax
nopl   0x0(%rax)
mov    %rdx,%rbp
movsd  (%rdx),%xmm0
movsd  %xmm0,(%rax)
add    %r8,%rdx
movsd  0x0(%rbp,%r8,1),%xmm0
movsd  %xmm0,0x8(%rax)
movsd  (%r8,%rdx,1),%xmm0
add    %r8,%rdx
movsd  %xmm0,0x10(%rax)
movsd  (%r8,%rdx,1),%xmm0
add    %r8,%rdx
movsd  %xmm0,0x18(%rax)
movsd  (%r8,%rdx,1),%xmm0
add    %r8,%rdx
movsd  %xmm0,0x20(%rax)
movsd  (%r8,%rdx,1),%xmm0
add    %r8,%rdx
movsd  %xmm0,0x28(%rax)
movsd  (%r8,%rdx,1),%xmm0
add    %r8,%rdx
movsd  %xmm0,0x30(%rax)
movsd  (%r8,%rdx,1),%xmm0
add    %r8,%rdx
movsd  %xmm0,0x38(%rax)
add    $0x40,%rax
add    %r8,%rdx
add    $0xfffffffffffffff8,%rsi
jne    1c10 <minv+0xaf0>
add    %r14,%rbp
test   $0x7,%r9b
je     1cb6 <minv+0xb96>
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
movsd  0x0(%rbp),%xmm0
movsd  %xmm0,(%rax,%rdx,8)
add    $0x1,%rdx
add    %r8,%rbp
cmp    %rdx,%r15
jne    1ca0 <minv+0xb80>
test   %rdi,%rdi
mov    %rdi,0x40(%rsp)
je     1d80 <minv+0xc60>
mov    %r9,%r13
movabs $0x7ffffffffffffffe,%rax
ff ff 7f
and    %rax,%r13
mov    $0x2,%esi
mov    0x28(%rsp),%r8
mov    %r12,%r14
mov    (%rsp),%r12
xor    %edi,%edi
nopw   0x0(%rax,%rax,1)
mov    %esi,%eax
mov    0x8(%rsp),%rbp
sub    %rax,%rbp
mov    %edi,%edx
mov    %r9,%rax
sub    %rdx,%rax
xorpd  %xmm0,%xmm0
xor    %r11d,%r11d
nopl   0x0(%rax)
movsd  (%r14,%r11,8),%xmm1
mulsd  (%r12,%r11,8),%xmm1
subsd  %xmm1,%xmm0
add    $0x1,%r11
cmp    %r11,%rax
jne    1d10 <minv+0xbf0>
mov    (%rsp),%rax
movsd  %xmm0,(%rax,%rdi,8)
mov    %rdi,%rax
or     $0x1,%rax
xorpd  %xmm0,%xmm0
xor    %edx,%edx
nop
movsd  (%r8,%rdx,8),%xmm1
mulsd  0x8(%r12,%rdx,8),%xmm1
subsd  %xmm1,%xmm0
add    $0x1,%rdx
cmp    %rdx,%rbp
jne    1d40 <minv+0xc20>
mov    (%rsp),%rdx
movsd  %xmm0,(%rdx,%rax,8)
add    $0x2,%rdi
add    $0x10,%r12
add    %r10,%r14
add    $0x2,%esi
add    %r10,%r8
cmp    %r13,%rdi
jne    1cf0 <minv+0xbd0>
jmp    1d82 <minv+0xc62>
nop
xor    %edi,%edi
test   $0x1,%r9b
mov    0x18(%rsp),%r13
mov    0x50(%rsp),%r12
mov    0x20(%rsp),%r8
mov    0x30(%rsp),%r11
mov    0x58(%rsp),%r14
je     1e00 <minv+0xce0>
lea    0x0(,%r9,8),%rax
mov    0x10(%rsp),%rdx
sub    %rax,%rdx
mov    %rdi,%rax
imul   0x38(%rsp),%rax
lea    (%rdx,%rax,8),%rax
lea    (%rax,%rdi,8),%rdx
lea    0x1(%rdi),%esi
mov    0x8(%rsp),%rax
sub    %rsi,%rax
mov    (%rsp),%rsi
lea    (%rsi,%rdi,8),%rsi
xorpd  %xmm0,%xmm0
xor    %ebp,%ebp
nopl   0x0(%rax,%rax,1)
movsd  (%rdx,%rbp,8),%xmm1
mulsd  (%rsi,%rbp,8),%xmm1
subsd  %xmm1,%xmm0
add    $0x1,%rbp
cmp    %rbp,%rax
jne    1de0 <minv+0xcc0>
mov    (%rsp),%rax
movsd  %xmm0,(%rax,%rdi,8)
mov    (%rsp),%rax
mov    0x10(%rsp),%rbp
mov    %rbp,%rdx
mov    0x40(%rsp),%rdi
cmp    $0x7,%rdi
jb     1ead <minv+0xd8d>
mov    %rbx,%rsi
mov    (%rsp),%rax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %rsi,%rdx
movsd  (%rax),%xmm0
movsd  %xmm0,(%rsi)
movsd  0x8(%rax),%xmm0
add    %r8,%rsi
movsd  %xmm0,(%rdx,%r8,1)
movsd  0x10(%rax),%xmm0
movsd  %xmm0,(%r8,%rsi,1)
add    %r8,%rsi
movsd  0x18(%rax),%xmm0
movsd  %xmm0,(%r8,%rsi,1)
add    %r8,%rsi
movsd  0x20(%rax),%xmm0
movsd  %xmm0,(%r8,%rsi,1)
add    %r8,%rsi
movsd  0x28(%rax),%xmm0
movsd  %xmm0,(%r8,%rsi,1)
add    %r8,%rsi
movsd  0x30(%rax),%xmm0
movsd  %xmm0,(%r8,%rsi,1)
add    %r8,%rsi
movsd  0x38(%rax),%xmm0
add    $0x40,%rax
movsd  %xmm0,(%r8,%rsi,1)
add    %r8,%rsi
add    %r8,%rsi
add    $0xfffffffffffffff8,%rcx
jne    1e30 <minv+0xd10>
add    %r14,%rdx
test   $0x7,%r9b
je     1bc0 <minv+0xaa0>
xor    %ecx,%ecx
nopl   0x0(%rax)
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rdx)
add    $0x1,%rcx
add    %r8,%rdx
cmp    %rcx,%r15
jne    1ec0 <minv+0xda0>
jmp    1bc0 <minv+0xaa0>
add    $0xfffffffffffffffc,%r13
mov    %r13,%rdi
call   1030 <free@plt>
xor    %ebp,%ebp
mov    %rbx,%rdi
call   1030 <free@plt>
mov    %ebp,%eax
add    $0xd8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %r13d,%eax
imul   %eax,%eax
lea    (%r12,%rax,8),%rcx
mov    %rcx,0x70(%rsp)
lea    (%r12,%rax,8),%rdx
add    $0xfffffffffffffff8,%rdx
mov    %r13d,%ecx
not    %ecx
movslq %ecx,%rsi
mov    0x38(%rsp),%rbp
mov    %rbp,%rcx
neg    %rcx
mov    %rcx,0xa8(%rsp)
lea    (%rsi,%rbp,1),%rcx
add    %rax,%rcx
mov    %rsi,0xb0(%rsp)
lea    0x0(,%rsi,8),%rax
mov    %rax,0xa0(%rsp)
mov    %r8,%rax
neg    %rax
mov    %rax,0x40(%rsp)
lea    (%r12,%rcx,8),%r12
add    $0xfffffffffffffff8,%r12
mov    $0x1,%r10d
xor    %eax,%eax
mov    %rax,0x28(%rsp)
mov    $0x1,%bl
movapd 0x1091(%rip),%xmm0
mov    0x4c(%rsp),%eax
mov    %eax,%edi
mov    %rdx,0x68(%rsp)
jmp    1fc6 <minv+0xea6>
nopl   0x0(%rax)
add    $0xffffffff,%edi
add    $0x1,%r10d
mov    0x28(%rsp),%rax
add    $0x1,%eax
mov    %rax,0x28(%rsp)
add    0xa0(%rsp),%r12
add    $0x1,%bl
addq   $0xfffffffffffffff8,0x70(%rsp)
cmp    %r13d,%r10d
mov    0xc0(%rsp),%rdx
je     237a <minv+0x125a>
movzbl %bl,%ebx
and    $0x7,%ebx
mov    %r10d,%r15d
and    $0xfffffff8,%r15d
mov    0xb0(%rsp),%rax
lea    (%rdx,%rax,8),%rdx
mov    %edi,%eax
not    %eax
add    %r13d,%eax
mov    %rdx,0xc0(%rsp)
lea    (%rdx,%rbp,8),%r9
mov    %eax,0x78(%rsp)
test   %eax,%eax
mov    %rdi,0x10(%rsp)
jle    20d4 <minv+0xfb4>
mov    (%rsp),%rdx
mov    %r9,%rax
cmpl   $0x7,0x28(%rsp)
jb     20b4 <minv+0xf94>
mov    %r15d,%ecx
xor    %eax,%eax
mov    (%rsp),%rdx
mov    %r9,%rsi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%r12,%rax,1),%xmm1
movsd  %xmm1,(%rdx)
lea    (%rsi,%rbp,8),%rdi
movsd  (%rsi,%rbp,8),%xmm1
movsd  %xmm1,0x8(%rdx)
lea    (%rdi,%rbp,8),%rsi
movsd  (%rdi,%rbp,8),%xmm1
movsd  %xmm1,0x10(%rdx)
lea    (%rsi,%rbp,8),%rdi
movsd  (%rsi,%rbp,8),%xmm1
movsd  %xmm1,0x18(%rdx)
lea    (%rdi,%rbp,8),%rsi
movsd  (%rdi,%rbp,8),%xmm1
movsd  %xmm1,0x20(%rdx)
lea    (%rsi,%rbp,8),%rdi
movsd  (%rsi,%rbp,8),%xmm1
movsd  %xmm1,0x28(%rdx)
lea    (%rdi,%rbp,8),%rsi
movsd  (%rdi,%rbp,8),%xmm1
movsd  %xmm1,0x30(%rdx)
lea    (%rsi,%rbp,8),%rdi
movsd  (%rsi,%rbp,8),%xmm1
movsd  %xmm1,0x38(%rdx)
add    $0x40,%rdx
lea    (%rdi,%rbp,8),%rsi
add    %r14,%rax
add    $0xfffffff8,%ecx
jne    2030 <minv+0xf10>
add    %r12,%rax
mov    0x10(%rsp),%rdi
test   $0x7,%r10b
je     20d4 <minv+0xfb4>
xor    %ecx,%ecx
nopl   0x0(%rax)
movsd  (%rax),%xmm1
movsd  %xmm1,(%rdx,%rcx,8)
add    $0x1,%rcx
add    %r8,%rax
cmp    %ecx,%ebx
jne    20c0 <minv+0xfa0>
mov    %rbx,0xb8(%rsp)
mov    %r10d,0x88(%rsp)
mov    %r12,0x80(%rsp)
addq   $0xfffffffffffffff8,0x68(%rsp)
cmp    %edi,%r11d
mov    0xa8(%rsp),%rbx
jle    2260 <minv+0x1140>
mov    0x88(%rsp),%eax
movslq %eax,%r11
lea    0x1(%rdi),%ecx
mov    %ecx,0x8(%rsp)
neg    %eax
mov    %eax,0x90(%rsp)
xor    %r12d,%r12d
mov    0x28(%rsp),%rax
mov    %eax,%r13d
mov    0x70(%rsp),%r14
mov    0x30(%rsp),%rax
mov    0x68(%rsp),%r10
jmp    2170 <minv+0x1050>
nopl   0x0(%rax)
mov    (%rsp),%rcx
movsd  %xmm1,-0x8(%rcx,%r11,8)
add    $0xffffffffffffffff,%r11
lea    (%r10,%rbx,8),%r10
add    $0xffffffff,%eax
add    $0x1,%r12d
add    0x40(%rsp),%r14
add    $0x3,%r13b
mov    0x10(%rsp),%rdi
cmp    %edi,%eax
jle    2260 <minv+0x1140>
movsd  (%r10),%xmm1
xorpd  %xmm0,%xmm1
cmp    %eax,0x8(%rsp)
jge    2140 <minv+0x1020>
mov    %r12d,%ecx
not    %ecx
mov    0x28(%rsp),%rdx
add    %edx,%ecx
mov    %edx,%esi
sub    %r12d,%esi
test   $0x3,%sil
je     21eb <minv+0x10cb>
movzbl %r13b,%esi
and    $0x3,%esi
shl    $0x3,%rsi
xor    %edi,%edi
mov    0x18(%rsp),%rdx
mov    %edx,%r8d
mov    (%rsp),%rdx
nop
movsd  -0x8(%r14,%rdi,1),%xmm2
mulsd  (%rdx,%rdi,1),%xmm2
subsd  %xmm2,%xmm1
add    $0x1,%r8d
add    $0x8,%rdi
cmp    %edi,%esi
jne    21b0 <minv+0x1090>
add    0x90(%rsp),%r8d
lea    (%rdx,%rdi,1),%rbp
lea    (%r14,%rdi,1),%rsi
add    $0xfffffffffffffff0,%rsi
cmp    $0x3,%ecx
jb     2140 <minv+0x1020>
jmp    2200 <minv+0x10e0>
mov    0x8(%rsp),%r8d
mov    (%rsp),%rbp
mov    %r10,%rsi
cmp    $0x3,%ecx
jb     2140 <minv+0x1020>
mov    %r8d,%ecx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nop
movsd  0x8(%rsi,%rdi,8),%xmm2
mulsd  0x0(%rbp,%rdi,8),%xmm2
movsd  0x10(%rsi,%rdi,8),%xmm3
subsd  %xmm2,%xmm1
mulsd  0x8(%rbp,%rdi,8),%xmm3
subsd  %xmm3,%xmm1
movsd  0x18(%rsi,%rdi,8),%xmm2
mulsd  0x10(%rbp,%rdi,8),%xmm2
subsd  %xmm2,%xmm1
movsd  0x20(%rsi,%rdi,8),%xmm2
mulsd  0x18(%rbp,%rdi,8),%xmm2
subsd  %xmm2,%xmm1
add    $0x4,%rdi
lea    (%rdi,%rcx,1),%edx
cmp    %eax,%edx
jl     2210 <minv+0x10f0>
jmp    2140 <minv+0x1020>
cmpl   $0x0,0x78(%rsp)
mov    0x18(%rsp),%r13
mov    0x20(%rsp),%r8
mov    0x30(%rsp),%r11
mov    0x38(%rsp),%rbp
mov    0x58(%rsp),%r14
mov    0x80(%rsp),%r12
mov    0x88(%rsp),%r10d
mov    0xb8(%rsp),%rbx
jle    1f90 <minv+0xe70>
cmpl   $0x7,0x28(%rsp)
jae    22c0 <minv+0x11a0>
mov    (%rsp),%rax
test   $0x7,%r10b
jne    235e <minv+0x123e>
jmp    1f90 <minv+0xe70>
cs nopw 0x0(%rax,%rax,1)
xor    %ecx,%ecx
mov    (%rsp),%rax
cs nopw 0x0(%rax,%rax,1)
movsd  (%rax),%xmm1
movsd  %xmm1,(%r12,%rcx,1)
lea    (%r9,%rbp,8),%rdx
movsd  0x8(%rax),%xmm1
movsd  %xmm1,(%r9,%rbp,8)
lea    (%rdx,%rbp,8),%rsi
movsd  0x10(%rax),%xmm1
movsd  %xmm1,(%rdx,%rbp,8)
lea    (%rsi,%rbp,8),%rdx
movsd  0x18(%rax),%xmm1
movsd  %xmm1,(%rsi,%rbp,8)
lea    (%rdx,%rbp,8),%rsi
movsd  0x20(%rax),%xmm1
movsd  %xmm1,(%rdx,%rbp,8)
lea    (%rsi,%rbp,8),%rdx
movsd  0x28(%rax),%xmm1
movsd  %xmm1,(%rsi,%rbp,8)
lea    (%rdx,%rbp,8),%rsi
movsd  0x30(%rax),%xmm1
movsd  %xmm1,(%rdx,%rbp,8)
lea    (%rsi,%rbp,8),%rdx
movsd  0x38(%rax),%xmm1
add    $0x40,%rax
movsd  %xmm1,(%rsi,%rbp,8)
lea    (%rdx,%rbp,8),%r9
add    %r14,%rcx
add    $0xfffffff8,%r15d
jne    22d0 <minv+0x11b0>
add    %r12,%rcx
mov    %rcx,%r9
test   $0x7,%r10b
je     1f90 <minv+0xe70>
xor    %ecx,%ecx
movsd  (%rax,%rcx,8),%xmm1
movsd  %xmm1,(%r9)
add    $0x1,%rcx
add    %r8,%r9
cmp    %ecx,%ebx
jne    2360 <minv+0x1240>
jmp    1f90 <minv+0xe70>
mov    %r11d,%r8d
mov    %r13d,%r9d
and    $0xfffffff8,%r9d
mov    %r13d,%r12d
and    $0x7,%r12d
mov    (%rsp),%r10
add    $0x18,%r10
xor    %r15d,%r15d
mov    0x50(%rsp),%r11
jmp    23b1 <minv+0x1291>
nopl   (%rax)
add    $0x1,%r15
add    $0x8,%r11
cmp    %r8,%r15
je     268a <minv+0x156a>
mov    (%rsp),%rcx
mov    %r11,%rdx
cmpl   $0x7,0x30(%rsp)
jb     2455 <minv+0x1335>
mov    %r9d,%esi
mov    %r11,%rdi
mov    (%rsp),%rcx
mov    0x20(%rsp),%rax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %rdi,%rdx
movsd  (%rdi),%xmm0
movsd  %xmm0,(%rcx)
add    %rax,%rdi
movsd  (%rdx,%rax,1),%xmm0
movsd  %xmm0,0x8(%rcx)
movsd  (%rax,%rdi,1),%xmm0
add    %rax,%rdi
movsd  %xmm0,0x10(%rcx)
movsd  (%rax,%rdi,1),%xmm0
add    %rax,%rdi
movsd  %xmm0,0x18(%rcx)
movsd  (%rax,%rdi,1),%xmm0
add    %rax,%rdi
movsd  %xmm0,0x20(%rcx)
movsd  (%rax,%rdi,1),%xmm0
add    %rax,%rdi
movsd  %xmm0,0x28(%rcx)
movsd  (%rax,%rdi,1),%xmm0
add    %rax,%rdi
movsd  %xmm0,0x30(%rcx)
movsd  (%rax,%rdi,1),%xmm0
add    %rax,%rdi
movsd  %xmm0,0x38(%rcx)
add    $0x40,%rcx
add    %rax,%rdi
add    $0xfffffff8,%esi
jne    23e0 <minv+0x12c0>
add    %r14,%rdx
test   $0x7,%r13b
mov    0x20(%rsp),%rsi
je     2485 <minv+0x1365>
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%rdx),%xmm0
movsd  %xmm0,(%rcx,%rax,8)
add    $0x1,%rax
add    %rsi,%rdx
cmp    %eax,%r12d
jne    2470 <minv+0x1350>
lea    0x1(%r15),%r14d
xor    %edi,%edi
mov    0x50(%rsp),%rcx
jmp    24c1 <minv+0x13a1>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    (%rsp),%rax
movsd  %xmm0,(%rax,%rdi,8)
add    $0x1,%rdi
mov    0x38(%rsp),%rax
lea    (%rcx,%rax,8),%rcx
cmp    0x60(%rsp),%rdi
je     25b0 <minv+0x1490>
cmp    %r15,%rdi
jbe    24e0 <minv+0x13c0>
lea    (%rcx,%rdi,8),%rdx
xorpd  %xmm0,%xmm0
mov    %edi,%esi
cmp    %r13d,%esi
jge    24a0 <minv+0x1380>
jmp    24f9 <minv+0x13d9>
nopw   0x0(%rax,%rax,1)
mov    (%rsp),%rax
movsd  (%rax,%rdi,8),%xmm0
lea    (%rcx,%r15,8),%rdx
add    $0x8,%rdx
mov    %r14d,%esi
cmp    %r13d,%esi
jge    24a0 <minv+0x1380>
mov    %esi,%ebp
mov    0x60(%rsp),%rbx
mov    %ebx,%eax
sub    %esi,%eax
mov    %rbp,%rsi
not    %rsi
add    %rbx,%rsi
and    $0x3,%rax
je     253b <minv+0x141b>
mov    (%rsp),%rbx
nopw   0x0(%rax,%rax,1)
movsd  (%rdx),%xmm1
mulsd  (%rbx,%rbp,8),%xmm1
add    $0x8,%rdx
add    $0x1,%rbp
addsd  %xmm1,%xmm0
add    $0xffffffffffffffff,%rax
jne    2520 <minv+0x1400>
cmp    $0x3,%rsi
jb     24a0 <minv+0x1380>
mov    0x60(%rsp),%rax
sub    %rbp,%rax
lea    (%r10,%rbp,8),%rsi
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rdx,%rbp,8),%xmm1
movsd  0x8(%rdx,%rbp,8),%xmm2
mulsd  -0x18(%rsi,%rbp,8),%xmm1
mulsd  -0x10(%rsi,%rbp,8),%xmm2
addsd  %xmm0,%xmm1
movsd  0x10(%rdx,%rbp,8),%xmm3
mulsd  -0x8(%rsi,%rbp,8),%xmm3
addsd  %xmm1,%xmm2
movsd  0x18(%rdx,%rbp,8),%xmm0
mulsd  (%rsi,%rbp,8),%xmm0
addsd  %xmm2,%xmm3
addsd  %xmm3,%xmm0
add    $0x4,%rbp
cmp    %rbp,%rax
jne    2560 <minv+0x1440>
jmp    24a0 <minv+0x1380>
nopl   0x0(%rax)
mov    (%rsp),%rcx
mov    %r11,%rdx
cmpl   $0x7,0x30(%rsp)
mov    0x58(%rsp),%r14
jb     2655 <minv+0x1535>
mov    %r9d,%esi
mov    %r11,%rax
mov    (%rsp),%rcx
mov    0x20(%rsp),%rdi
cs nopw 0x0(%rax,%rax,1)
mov    %rax,%rdx
movsd  (%rcx),%xmm0
movsd  %xmm0,(%rax)
movsd  0x8(%rcx),%xmm0
add    %rdi,%rax
movsd  %xmm0,(%rdx,%rdi,1)
movsd  0x10(%rcx),%xmm0
movsd  %xmm0,(%rdi,%rax,1)
add    %rdi,%rax
movsd  0x18(%rcx),%xmm0
movsd  %xmm0,(%rdi,%rax,1)
add    %rdi,%rax
movsd  0x20(%rcx),%xmm0
movsd  %xmm0,(%rdi,%rax,1)
add    %rdi,%rax
movsd  0x28(%rcx),%xmm0
movsd  %xmm0,(%rdi,%rax,1)
add    %rdi,%rax
movsd  0x30(%rcx),%xmm0
movsd  %xmm0,(%rdi,%rax,1)
add    %rdi,%rax
movsd  0x38(%rcx),%xmm0
add    $0x40,%rcx
movsd  %xmm0,(%rdi,%rax,1)
add    %rdi,%rax
add    %rdi,%rax
add    $0xfffffff8,%esi
jne    25e0 <minv+0x14c0>
add    %r14,%rdx
test   $0x7,%r13b
mov    0x20(%rsp),%rsi
je     23a0 <minv+0x1280>
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
movsd  (%rcx,%rax,8),%xmm0
movsd  %xmm0,(%rdx)
add    $0x1,%rax
add    %rsi,%rdx
cmp    %eax,%r12d
jne    2670 <minv+0x1550>
jmp    23a0 <minv+0x1280>
mov    0x4c(%rsp),%r9d
mov    %r13d,%r8d
and    $0x3,%r8d
and    $0xfffffffc,%r13d
mov    0x50(%rsp),%r14
lea    (%r14,%r9,8),%r10
mov    (%rsp),%rbx
mov    0x20(%rsp),%rdx
mov    0x30(%rsp),%rcx
mov    0x98(%rsp),%rdi
jmp    26d8 <minv+0x15b8>
nopl   0x0(%rax,%rax,1)
add    $0xfffffffffffffffc,%rdi
lea    -0x1(%r9),%rax
add    $0xfffffffffffffff8,%r10
test   %r9,%r9
mov    %rax,%r9
jle    1ee1 <minv+0xdc1>
movslq -0x4(%rdi),%rax
lea    (%r14,%rax,8),%rbp
cmp    $0x3,%ecx
jae    2700 <minv+0x15e0>
lea    (%r14,%r9,8),%r15
test   %r8d,%r8d
jne    27ac <minv+0x168c>
jmp    26c0 <minv+0x15a0>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %r13d,%r11d
mov    %r10,%rsi
cs nopw 0x0(%rax,%rax,1)
mov    %rbp,%rcx
mov    %rsi,%r15
movsd  (%rsi),%xmm0
movsd  0x0(%rbp),%xmm1
movsd  %xmm1,(%rsi)
movsd  %xmm0,0x0(%rbp)
add    %rdx,%rsi
movsd  (%r15,%rdx,1),%xmm0
lea    0x0(%rbp,%rdx,1),%rbp
movsd  (%rcx,%rdx,1),%xmm1
movsd  %xmm1,(%r15,%rdx,1)
movsd  %xmm0,(%rcx,%rdx,1)
lea    (%rsi,%rdx,1),%r12
movsd  (%rdx,%rsi,1),%xmm0
lea    0x0(%rbp,%rdx,1),%rax
movsd  (%rdx,%rbp,1),%xmm1
movsd  %xmm1,(%rdx,%rsi,1)
movsd  %xmm0,(%rdx,%rbp,1)
lea    (%r12,%rdx,1),%rsi
movsd  (%rdx,%r12,1),%xmm0
lea    (%rax,%rdx,1),%rbp
movsd  (%rdx,%rax,1),%xmm1
movsd  %xmm1,(%rdx,%r12,1)
movsd  %xmm0,(%rdx,%rax,1)
add    %rdx,%rsi
add    %rdx,%rbp
add    $0xfffffffc,%r11d
jne    2710 <minv+0x15f0>
mov    0xc8(%rsp),%rax
add    %rax,%rcx
add    %rax,%r15
mov    %rcx,%rbp
mov    0x30(%rsp),%rcx
test   %r8d,%r8d
je     26c0 <minv+0x15a0>
mov    %r8d,%eax
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%r15,%rsi,1),%xmm0
movsd  0x0(%rbp,%rsi,1),%xmm1
movsd  %xmm1,(%r15,%rsi,1)
movsd  %xmm0,0x0(%rbp,%rsi,1)
add    %rdx,%rsi
add    $0xffffffff,%eax
jne    27c0 <minv+0x16a0>
jmp    26c0 <minv+0x15a0>

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

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