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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
double DBL_MAX;
int /*<<< orphan*/ abort();
double fabs(double);
int /*<<< orphan*/ printf(char *, ...);
void dlp2_1pt_i(int ma, int na, double **a, int nv1, double *c, int *LPidx,
                int FixPt, int TstPt, int *Bidx, double *x, double **Binv,
                int **RelTab) {
  int ibrk;
  int i, i1, j, k, ell;
  double eps = 1.0e-6, vmax, top, bot, sigj, dtmp;
  if (0 > 0)
    printf("entered dlp2_1pt_i with ma = %d and na = %d\n", ma, na);
  while (1) {
    vmax = -DBL_MAX;
    for (i = 0; i < na; i++)
      if (Bidx[i] != -1) {
        dtmp = c[0] * Binv[i][0];
        for (j = 1; j < na; j++)
          dtmp += c[j] * Binv[i][j];
        if (dtmp > vmax) {
          vmax = dtmp;
          k = i;
        }
      }
    if (vmax < eps)
      return;
    sigj = DBL_MAX;
    ell = -1;
    for (i1 = 0; i1 < ma; i1++) {
      i = LPidx[i1];
      ibrk = 0;
      for (j = 0; j < na; j++)
        if (Bidx[j] == i) {
          ibrk = 1;
          break;
        }
      if (ibrk)
        continue;
      bot = a[i][0] * Binv[k][0];
      for (j = 1; j < na; j++)
        bot += a[i][j] * Binv[k][j];
      if (bot >= -eps)
        continue;
      top = -a[i][nv1];
      for (j = 0; j < na; j++)
        top += a[i][j] * x[j];
      top /= bot;
      if (top >= sigj)
        continue;
      sigj = top;
      ell = i;
    }
    if (ell < 0) {
      printf("dlp2_1pt_i : LP unbounded\n\a");
      abort();
    }
    for (i = 0; i < na; i++)
      x[i] -= sigj * Binv[k][i];
    top = a[ell][0] * Binv[k][0];
    for (i = 1; i < na; i++)
      top += a[ell][i] * Binv[k][i];
    if (fabs(top) < eps) {
      printf("dlp2_1pt_i : Base matrix is singular\a\n");
      abort();
    }
    top = 1.0 / top;
    for (i = 0; i < na; i++)
      Binv[k][i] *= top;
    for (j = 0; j < na; j++)
      if (j != k) {
        top = a[ell][0] * Binv[j][0];
        for (i = 1; i < na; i++)
          top += a[ell][i] * Binv[j][i];
        for (i = 0; i < na; i++)
          Binv[j][i] -= top * Binv[k][i];
      }
    Bidx[k] = ell;
    if (ell >= TstPt) {
      for (i = 0; i < na; i++)
        if (i != k && Bidx[i] > -1 && !RelTab[ell][Bidx[i]])
          RelTab[ell][Bidx[i]] = RelTab[Bidx[i]][ell] = 1;
      if (!RelTab[ell][FixPt])
        RelTab[ell][FixPt] = RelTab[FixPt][ell] = 1;
    }
  }
}


x86 assembly (clang, -O0):
<dlp2_1pt_i>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%eax
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %rdx,-0x10(%rbp)
mov    %ecx,-0x14(%rbp)
mov    %r8,-0x20(%rbp)
mov    %r9,-0x28(%rbp)
movsd  0xea5(%rip),%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    0x2e79(%rip),%rax
movsd  (%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x50(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1256 <dlp2_1pt_i+0x136>
mov    0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
cmpl   $0xffffffff,(%rax,%rcx,4)
je     1243 <dlp2_1pt_i+0x123>
mov    -0x20(%rbp),%rax
movsd  (%rax),%xmm0
mov    0x30(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mulsd  (%rax),%xmm0
movsd  %xmm0,-0x70(%rbp)
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    121e <dlp2_1pt_i+0xfe>
mov    -0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x70(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    11d0 <dlp2_1pt_i+0xb0>
movsd  -0x70(%rbp),%xmm0
ucomisd -0x50(%rbp),%xmm0
jbe    123e <dlp2_1pt_i+0x11e>
movsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x30(%rbp),%eax
mov    %eax,-0x3c(%rbp)
jmp    1243 <dlp2_1pt_i+0x123>
jmp    1248 <dlp2_1pt_i+0x128>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    118e <dlp2_1pt_i+0x6e>
movsd  -0x50(%rbp),%xmm1
movsd  -0x48(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    1270 <dlp2_1pt_i+0x150>
add    $0x70,%rsp
pop    %rbp
ret
mov    0x2d69(%rip),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x68(%rbp)
movl   $0xffffffff,-0x40(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1482 <dlp2_1pt_i+0x362>
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x30(%rbp)
movl   $0x0,-0x2c(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    12f5 <dlp2_1pt_i+0x1d5>
mov    0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x30(%rbp),%eax
jne    12e2 <dlp2_1pt_i+0x1c2>
movl   $0x1,-0x2c(%rbp)
jmp    12f5 <dlp2_1pt_i+0x1d5>
jmp    12e7 <dlp2_1pt_i+0x1c7>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    12b6 <dlp2_1pt_i+0x196>
cmpl   $0x0,-0x2c(%rbp)
je     1304 <dlp2_1pt_i+0x1e4>
jmp    1474 <dlp2_1pt_i+0x354>
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  (%rax),%xmm0
mov    0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mulsd  (%rax),%xmm0
movsd  %xmm0,-0x60(%rbp)
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1386 <dlp2_1pt_i+0x266>
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x60(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1330 <dlp2_1pt_i+0x210>
movsd  -0x60(%rbp),%xmm0
movsd  -0x48(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
ucomisd %xmm1,%xmm0
jb     13b6 <dlp2_1pt_i+0x296>
jmp    1474 <dlp2_1pt_i+0x354>
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x14(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x58(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    143c <dlp2_1pt_i+0x31c>
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    13ee <dlp2_1pt_i+0x2ce>
movsd  -0x60(%rbp),%xmm1
movsd  -0x58(%rbp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x58(%rbp),%xmm0
ucomisd -0x68(%rbp),%xmm0
jb     1464 <dlp2_1pt_i+0x344>
jmp    1474 <dlp2_1pt_i+0x354>
movsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x30(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    128e <dlp2_1pt_i+0x16e>
cmpl   $0x0,-0x40(%rbp)
jge    14a1 <dlp2_1pt_i+0x381>
lea    0xb8d(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    $0x0,%al
call   1030 <abort@plt>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    150d <dlp2_1pt_i+0x3ed>
movsd  -0x68(%rbp),%xmm0
mov    0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x28(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    14a8 <dlp2_1pt_i+0x388>
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  (%rax),%xmm0
mov    0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mulsd  (%rax),%xmm0
movsd  %xmm0,-0x58(%rbp)
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    158f <dlp2_1pt_i+0x46f>
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1539 <dlp2_1pt_i+0x419>
movsd  -0x58(%rbp),%xmm1
movaps 0xa75(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  -0x48(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    15c3 <dlp2_1pt_i+0x4a3>
lea    0xa87(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    $0x0,%al
call   1030 <abort@plt>
movsd  0xa3d(%rip),%xmm0
divsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1615 <dlp2_1pt_i+0x4f5>
movsd  -0x58(%rbp),%xmm0
mov    0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    15dc <dlp2_1pt_i+0x4bc>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1742 <dlp2_1pt_i+0x622>
mov    -0x38(%rbp),%eax
cmp    -0x3c(%rbp),%eax
je     172f <dlp2_1pt_i+0x60f>
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  (%rax),%xmm0
mov    0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mulsd  (%rax),%xmm0
movsd  %xmm0,-0x58(%rbp)
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    16b6 <dlp2_1pt_i+0x596>
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1660 <dlp2_1pt_i+0x540>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    172a <dlp2_1pt_i+0x60a>
movsd  -0x58(%rbp),%xmm0
mov    0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    16bd <dlp2_1pt_i+0x59d>
jmp    172f <dlp2_1pt_i+0x60f>
jmp    1734 <dlp2_1pt_i+0x614>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    161c <dlp2_1pt_i+0x4fc>
mov    -0x40(%rbp),%edx
mov    0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x40(%rbp),%eax
cmp    0x18(%rbp),%eax
jl     184d <dlp2_1pt_i+0x72d>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1800 <dlp2_1pt_i+0x6e0>
mov    -0x30(%rbp),%eax
cmp    -0x3c(%rbp),%eax
je     17ed <dlp2_1pt_i+0x6cd>
mov    0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
cmpl   $0xffffffff,(%rax,%rcx,4)
jle    17ed <dlp2_1pt_i+0x6cd>
mov    0x38(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x20(%rbp),%rcx
movslq -0x30(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    17ed <dlp2_1pt_i+0x6cd>
mov    0x38(%rbp),%rax
mov    0x20(%rbp),%rcx
movslq -0x30(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movl   $0x1,(%rax,%rcx,4)
mov    0x38(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x20(%rbp),%rcx
movslq -0x30(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movl   $0x1,(%rax,%rcx,4)
jmp    17f2 <dlp2_1pt_i+0x6d2>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1763 <dlp2_1pt_i+0x643>
mov    0x38(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq 0x10(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    1848 <dlp2_1pt_i+0x728>
mov    0x38(%rbp),%rax
movslq 0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movl   $0x1,(%rax,%rcx,4)
mov    0x38(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq 0x10(%rbp),%rcx
movl   $0x1,(%rax,%rcx,4)
jmp    184d <dlp2_1pt_i+0x72d>
jmp    1160 <dlp2_1pt_i+0x40>

x86 assembly (clang, -O2):
<dlp2_1pt_i>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xc8,%rsp
mov    %r9,%r10
mov    %rdx,0x70(%rsp)
movslq %ecx,%r15
mov    %esi,%r13d
lea    -0x1(%r13),%r14
mov    %r13d,%eax
and    $0xfffffffc,%eax
mov    %rax,0x90(%rsp)
add    $0xfffffffffffffffc,%rax
mov    %rax,0x88(%rsp)
mov    %rax,%rcx
shr    $0x2,%rcx
add    $0x1,%rcx
lea    -0x5(%r13),%rax
mov    %rax,0x60(%rsp)
mov    %rax,%rbp
shr    $0x2,%rbp
add    $0x1,%rbp
mov    %r14d,%r12d
and    $0x3,%r12d
mov    %r14,%rax
mov    %r14,0x10(%rsp)
and    $0xfffffffffffffffc,%r14
mov    %rcx,%rax
mov    %rcx,0x80(%rsp)
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0x78(%rsp)
mov    %r13,%rax
neg    %rax
mov    %rax,0x68(%rsp)
mov    %rbp,%rax
mov    %rbp,0x58(%rsp)
and    $0xfffffffffffffffe,%rbp
mov    %rbp,0x40(%rsp)
movapd 0xe28(%rip),%xmm11
movsd  0xe3f(%rip),%xmm10
movapd 0xe26(%rip),%xmm9
movsd  0xe3d(%rip),%xmm8
movsd  0xe2d(%rip),%xmm4
mov    0x118(%rsp),%rax
mov    0x110(%rsp),%r9
movslq 0x100(%rsp),%rcx
mov    %rcx,0x48(%rsp)
mov    %edi,0x3c(%rsp)
mov    %edi,%ecx
mov    %rcx,0xc0(%rsp)
lea    (%rax,%r13,8),%rax
mov    %rax,0x98(%rsp)
lea    -0x2(%r13),%rax
mov    %rax,0x18(%rsp)
lea    0x1(%r14),%rax
mov    %rax,0x50(%rsp)
mov    %r10,0xa8(%rsp)
mov    %r15,0xa0(%rsp)
jmp    1278 <dlp2_1pt_i+0x148>
cs nopw 0x0(%rax,%rax,1)
mov    0x28(%rsp),%rax
mov    (%rbx,%rax,8),%rax
mov    0x48(%rsp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     1679 <dlp2_1pt_i+0x549>
mov    0x2d61(%rip),%rax
movsd  (%rax),%xmm5
movapd %xmm5,%xmm6
xorpd  %xmm11,%xmm6
test   %esi,%esi
jle    1380 <dlp2_1pt_i+0x250>
xor    %eax,%eax
jmp    12ad <dlp2_1pt_i+0x17d>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rax
cmp    %r13,%rax
je     1380 <dlp2_1pt_i+0x250>
cmpl   $0xffffffff,(%r9,%rax,4)
je     12a0 <dlp2_1pt_i+0x170>
movsd  (%r8),%xmm7
mov    0x120(%rsp),%rcx
mov    (%rcx,%rax,8),%rdi
mulsd  (%rdi),%xmm7
cmp    $0x2,%esi
jl     1367 <dlp2_1pt_i+0x237>
mov    $0x1,%ecx
cmpq   $0x3,0x18(%rsp)
jb     1341 <dlp2_1pt_i+0x211>
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  0x8(%r8,%rcx,8),%xmm3
movsd  0x10(%r8,%rcx,8),%xmm2
mulsd  0x8(%rdi,%rcx,8),%xmm3
mulsd  0x10(%rdi,%rcx,8),%xmm2
addsd  %xmm7,%xmm3
movsd  0x18(%r8,%rcx,8),%xmm1
mulsd  0x18(%rdi,%rcx,8),%xmm1
addsd  %xmm3,%xmm2
movsd  0x20(%r8,%rcx,8),%xmm7
mulsd  0x20(%rdi,%rcx,8),%xmm7
addsd  %xmm2,%xmm1
addsd  %xmm1,%xmm7
add    $0x4,%rcx
cmp    %rcx,%r14
jne    12f0 <dlp2_1pt_i+0x1c0>
add    $0x1,%rcx
test   %r12,%r12
je     1367 <dlp2_1pt_i+0x237>
lea    (%rdi,%rcx,8),%rdi
lea    (%r8,%rcx,8),%rcx
xor    %ebp,%ebp
movsd  (%rcx,%rbp,8),%xmm1
mulsd  (%rdi,%rbp,8),%xmm1
addsd  %xmm1,%xmm7
add    $0x1,%rbp
cmp    %rbp,%r12
jne    1350 <dlp2_1pt_i+0x220>
ucomisd %xmm6,%xmm7
jbe    12a0 <dlp2_1pt_i+0x170>
mov    %eax,%edx
movapd %xmm7,%xmm6
jmp    12a0 <dlp2_1pt_i+0x170>
nopl   0x0(%rax)
ucomisd %xmm6,%xmm10
ja     1cf2 <dlp2_1pt_i+0xbc2>
cmpl   $0x0,0x3c(%rsp)
jle    1d04 <dlp2_1pt_i+0xbd4>
mov    %edx,0x24(%rsp)
movslq %edx,%rax
mov    %rax,0x30(%rsp)
movl   $0xffffffff,0xc(%rsp)
ff
xor    %r11d,%r11d
mov    0x70(%rsp),%rdx
jmp    13d2 <dlp2_1pt_i+0x2a2>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%r11
cmp    0xc0(%rsp),%r11
je     15a0 <dlp2_1pt_i+0x470>
mov    (%r10,%r11,4),%ebx
test   %esi,%esi
jle    13ef <dlp2_1pt_i+0x2bf>
xor    %eax,%eax
nopl   0x0(%rax)
cmp    %ebx,(%r9,%rax,4)
je     13c0 <dlp2_1pt_i+0x290>
add    $0x1,%rax
cmp    %rax,%r13
jne    13e0 <dlp2_1pt_i+0x2b0>
movslq %ebx,%rax
mov    (%rdx,%rax,8),%rdi
movsd  (%rdi),%xmm6
mov    0x120(%rsp),%rax
mov    0x30(%rsp),%rcx
mov    (%rax,%rcx,8),%rbp
movsd  0x0(%rbp),%xmm7
mulsd  %xmm6,%xmm7
cmp    $0x2,%esi
jl     14a8 <dlp2_1pt_i+0x378>
mov    $0x1,%ecx
cmpq   $0x3,0x18(%rsp)
jb     147d <dlp2_1pt_i+0x34d>
xor    %ecx,%ecx
nopl   0x0(%rax)
movsd  0x8(%rdi,%rcx,8),%xmm1
movsd  0x10(%rdi,%rcx,8),%xmm2
mulsd  0x8(%rbp,%rcx,8),%xmm1
mulsd  0x10(%rbp,%rcx,8),%xmm2
addsd  %xmm7,%xmm1
movsd  0x18(%rdi,%rcx,8),%xmm3
mulsd  0x18(%rbp,%rcx,8),%xmm3
addsd  %xmm1,%xmm2
movsd  0x20(%rdi,%rcx,8),%xmm7
mulsd  0x20(%rbp,%rcx,8),%xmm7
addsd  %xmm2,%xmm3
addsd  %xmm3,%xmm7
add    $0x4,%rcx
cmp    %rcx,%r14
jne    1430 <dlp2_1pt_i+0x300>
add    $0x1,%rcx
testb  $0x3,0x10(%rsp)
je     14a8 <dlp2_1pt_i+0x378>
lea    0x0(%rbp,%rcx,8),%rbp
lea    (%rdi,%rcx,8),%rcx
xor    %eax,%eax
nop
movsd  (%rcx,%rax,8),%xmm1
mulsd  0x0(%rbp,%rax,8),%xmm1
addsd  %xmm1,%xmm7
add    $0x1,%rax
cmp    %rax,%r12
jne    1490 <dlp2_1pt_i+0x360>
ucomisd %xmm4,%xmm7
jae    13c0 <dlp2_1pt_i+0x290>
movsd  (%rdi,%r15,8),%xmm3
xorpd  %xmm11,%xmm3
test   %esi,%esi
mov    0x118(%rsp),%rax
jle    157a <dlp2_1pt_i+0x44a>
mulsd  (%rax),%xmm6
addsd  %xmm3,%xmm6
cmp    $0x1,%esi
je     157e <dlp2_1pt_i+0x44e>
mov    $0x1,%ecx
cmpq   $0x3,0x18(%rsp)
jb     153d <dlp2_1pt_i+0x40d>
xor    %ecx,%ecx
nopl   (%rax)
movsd  0x8(%rdi,%rcx,8),%xmm1
movsd  0x10(%rdi,%rcx,8),%xmm2
mulsd  0x8(%rax,%rcx,8),%xmm1
mulsd  0x10(%rax,%rcx,8),%xmm2
addsd  %xmm6,%xmm1
movsd  0x18(%rdi,%rcx,8),%xmm3
mulsd  0x18(%rax,%rcx,8),%xmm3
addsd  %xmm1,%xmm2
movsd  0x20(%rdi,%rcx,8),%xmm6
mulsd  0x20(%rax,%rcx,8),%xmm6
addsd  %xmm2,%xmm3
addsd  %xmm3,%xmm6
add    $0x4,%rcx
cmp    %rcx,%r14
jne    14f0 <dlp2_1pt_i+0x3c0>
add    $0x1,%rcx
testb  $0x3,0x10(%rsp)
je     157e <dlp2_1pt_i+0x44e>
mov    0x118(%rsp),%rax
lea    (%rax,%rcx,8),%rbp
lea    (%rdi,%rcx,8),%rcx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
movsd  (%rcx,%rax,8),%xmm1
mulsd  0x0(%rbp,%rax,8),%xmm1
addsd  %xmm1,%xmm6
add    $0x1,%rax
cmp    %rax,%r12
jne    1560 <dlp2_1pt_i+0x430>
jmp    157e <dlp2_1pt_i+0x44e>
movapd %xmm3,%xmm6
divsd  %xmm7,%xmm6
ucomisd %xmm5,%xmm6
jae    13c0 <dlp2_1pt_i+0x290>
mov    %ebx,0xc(%rsp)
movapd %xmm6,%xmm5
jmp    13c0 <dlp2_1pt_i+0x290>
nopl   0x0(%rax)
cmpl   $0x0,0xc(%rsp)
js     1d04 <dlp2_1pt_i+0xbd4>
mov    0x120(%rsp),%rax
mov    0x30(%rsp),%rcx
mov    (%rax,%rcx,8),%r10
test   %esi,%esi
mov    0x70(%rsp),%rdx
jle    1790 <dlp2_1pt_i+0x660>
xorpd  %xmm11,%xmm5
cmp    $0x4,%esi
jb     15f3 <dlp2_1pt_i+0x4c3>
lea    (%r10,%r13,8),%rax
cmp    0x118(%rsp),%rax
jbe    169a <dlp2_1pt_i+0x56a>
cmp    0x98(%rsp),%r10
jae    169a <dlp2_1pt_i+0x56a>
xor    %eax,%eax
mov    %rax,%rcx
test   $0x1,%r13b
je     1621 <dlp2_1pt_i+0x4f1>
movsd  (%r10,%rax,8),%xmm0
mulsd  %xmm5,%xmm0
mov    0x118(%rsp),%rcx
addsd  (%rcx,%rax,8),%xmm0
movsd  %xmm0,(%rcx,%rax,8)
mov    %rax,%rcx
or     $0x1,%rcx
not    %rax
cmp    0x68(%rsp),%rax
mov    0x118(%rsp),%rax
je     1790 <dlp2_1pt_i+0x660>
nopw   0x0(%rax,%rax,1)
movsd  (%r10,%rcx,8),%xmm0
mulsd  %xmm5,%xmm0
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x8(%r10,%rcx,8),%xmm0
mulsd  %xmm5,%xmm0
addsd  0x8(%rax,%rcx,8),%xmm0
movsd  %xmm0,0x8(%rax,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%r13
jne    1640 <dlp2_1pt_i+0x510>
jmp    1790 <dlp2_1pt_i+0x660>
mov    0x48(%rsp),%rdi
mov    (%rbx,%rdi,8),%rcx
mov    0x28(%rsp),%rbx
movl   $0x1,(%rcx,%rbx,4)
movl   $0x1,(%rax,%rdi,4)
jmp    1278 <dlp2_1pt_i+0x148>
movapd %xmm5,%xmm6
unpcklpd %xmm5,%xmm6
cmpq   $0x0,0x88(%rsp)
je     1cdd <dlp2_1pt_i+0xbad>
mov    0x78(%rsp),%rcx
xor    %eax,%eax
mov    0x118(%rsp),%rdi
movupd (%r10,%rax,8),%xmm1
movupd 0x10(%r10,%rax,8),%xmm2
mulpd  %xmm6,%xmm1
movupd (%rdi,%rax,8),%xmm3
addpd  %xmm1,%xmm3
movupd 0x10(%rdi,%rax,8),%xmm1
movupd 0x20(%rdi,%rax,8),%xmm7
movupd 0x30(%rdi,%rax,8),%xmm0
mulpd  %xmm6,%xmm2
addpd  %xmm1,%xmm2
movupd %xmm3,(%rdi,%rax,8)
movupd %xmm2,0x10(%rdi,%rax,8)
movupd 0x20(%r10,%rax,8),%xmm1
movupd 0x30(%r10,%rax,8),%xmm2
mulpd  %xmm6,%xmm1
addpd  %xmm7,%xmm1
mulpd  %xmm6,%xmm2
addpd  %xmm0,%xmm2
movupd %xmm1,0x20(%rdi,%rax,8)
movupd %xmm2,0x30(%rdi,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    16c0 <dlp2_1pt_i+0x590>
testb  $0x1,0x80(%rsp)
01
je     1778 <dlp2_1pt_i+0x648>
movupd (%r10,%rax,8),%xmm0
movupd 0x10(%r10,%rax,8),%xmm1
mov    0x118(%rsp),%rcx
movupd (%rcx,%rax,8),%xmm2
movupd 0x10(%rcx,%rax,8),%xmm3
mulpd  %xmm6,%xmm0
addpd  %xmm2,%xmm0
mulpd  %xmm6,%xmm1
addpd  %xmm3,%xmm1
movupd %xmm0,(%rcx,%rax,8)
movupd %xmm1,0x10(%rcx,%rax,8)
mov    0x90(%rsp),%rcx
mov    %rcx,%rax
cmp    %r13,%rcx
jne    15f5 <dlp2_1pt_i+0x4c5>
nopl   0x0(%rax)
movslq 0xc(%rsp),%rax
mov    %rax,0x28(%rsp)
mov    (%rdx,%rax,8),%r15
movsd  (%r10),%xmm5
movsd  (%r15),%xmm7
mulsd  %xmm5,%xmm7
cmp    $0x2,%esi
jl     1857 <dlp2_1pt_i+0x727>
mov    $0x1,%ecx
cmpq   $0x3,0x18(%rsp)
jb     1825 <dlp2_1pt_i+0x6f5>
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  0x8(%r15,%rcx,8),%xmm0
movsd  0x10(%r15,%rcx,8),%xmm1
mulsd  0x8(%r10,%rcx,8),%xmm0
mulsd  0x10(%r10,%rcx,8),%xmm1
addsd  %xmm7,%xmm0
movsd  0x18(%r15,%rcx,8),%xmm2
mulsd  0x18(%r10,%rcx,8),%xmm2
addsd  %xmm0,%xmm1
movsd  0x20(%r15,%rcx,8),%xmm7
mulsd  0x20(%r10,%rcx,8),%xmm7
addsd  %xmm1,%xmm2
addsd  %xmm2,%xmm7
add    $0x4,%rcx
cmp    %rcx,%r14
jne    17d0 <dlp2_1pt_i+0x6a0>
add    $0x1,%rcx
testb  $0x3,0x10(%rsp)
je     1857 <dlp2_1pt_i+0x727>
lea    (%r10,%rcx,8),%rdi
lea    (%r15,%rcx,8),%rcx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
movsd  (%rcx,%rax,8),%xmm0
mulsd  (%rdi,%rax,8),%xmm0
addsd  %xmm0,%xmm7
add    $0x1,%rax
cmp    %rax,%r12
jne    1840 <dlp2_1pt_i+0x710>
movapd %xmm7,%xmm0
andpd  %xmm9,%xmm0
ucomisd %xmm0,%xmm10
ja     1d19 <dlp2_1pt_i+0xbe9>
mov    %esi,%ebp
test   %esi,%esi
mov    0x68(%rsp),%rsi
jle    1c40 <dlp2_1pt_i+0xb10>
movapd %xmm8,%xmm6
divsd  %xmm7,%xmm6
mulsd  %xmm6,%xmm5
movsd  %xmm5,(%r10)
mov    %ebp,%eax
cmp    $0x1,%ebp
je     1979 <dlp2_1pt_i+0x849>
mov    $0x1,%ecx
cmpq   $0x4,0x10(%rsp)
jb     1960 <dlp2_1pt_i+0x830>
movapd %xmm6,%xmm5
unpcklpd %xmm6,%xmm5
cmpq   $0x4,0x60(%rsp)
jae    18bc <dlp2_1pt_i+0x78c>
xor    %ecx,%ecx
jmp    1922 <dlp2_1pt_i+0x7f2>
mov    0x40(%rsp),%rdx
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movupd 0x8(%r10,%rcx,8),%xmm0
movupd 0x18(%r10,%rcx,8),%xmm1
movupd 0x28(%r10,%rcx,8),%xmm2
movupd 0x38(%r10,%rcx,8),%xmm3
mulpd  %xmm5,%xmm0
mulpd  %xmm5,%xmm1
movupd %xmm0,0x8(%r10,%rcx,8)
movupd %xmm1,0x18(%r10,%rcx,8)
mulpd  %xmm5,%xmm2
mulpd  %xmm5,%xmm3
movupd %xmm2,0x28(%r10,%rcx,8)
movupd %xmm3,0x38(%r10,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rdx
jne    18d0 <dlp2_1pt_i+0x7a0>
testb  $0x1,0x58(%rsp)
je     1953 <dlp2_1pt_i+0x823>
shl    $0x3,%rcx
or     $0x8,%rcx
movupd (%r10,%rcx,1),%xmm0
movupd 0x10(%r10,%rcx,1),%xmm1
mulpd  %xmm5,%xmm0
mulpd  %xmm5,%xmm1
movupd %xmm0,(%r10,%rcx,1)
movupd %xmm1,0x10(%r10,%rcx,1)
mov    0x50(%rsp),%rcx
cmp    %r14,0x10(%rsp)
je     1979 <dlp2_1pt_i+0x849>
nop
movsd  (%r10,%rcx,8),%xmm0
mulsd  %xmm6,%xmm0
movsd  %xmm0,(%r10,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%r13
jne    1960 <dlp2_1pt_i+0x830>
test   %eax,%eax
jle    1c40 <dlp2_1pt_i+0xb10>
mov    0x24(%rsp),%ebx
lea    0x8(%r10),%rax
mov    %rax,0xb0(%rsp)
lea    (%r10,%r13,8),%rax
mov    %rax,0xb8(%rsp)
xor    %r11d,%r11d
jmp    19bd <dlp2_1pt_i+0x88d>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%r11
cmp    %r13,%r11
je     1c40 <dlp2_1pt_i+0xb10>
cmp    %rbx,%r11
je     19b0 <dlp2_1pt_i+0x880>
mov    0x120(%rsp),%rax
mov    (%rax,%r11,8),%rdx
movsd  (%rdx),%xmm6
movsd  (%r15),%xmm5
mulsd  %xmm6,%xmm5
cmp    $0x2,%ebp
jl     1a87 <dlp2_1pt_i+0x957>
mov    $0x1,%edi
cmpq   $0x3,0x18(%rsp)
jb     1a51 <dlp2_1pt_i+0x921>
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  0x8(%r15,%rdi,8),%xmm0
movsd  0x10(%r15,%rdi,8),%xmm1
mulsd  0x8(%rdx,%rdi,8),%xmm0
mulsd  0x10(%rdx,%rdi,8),%xmm1
addsd  %xmm5,%xmm0
movsd  0x18(%r15,%rdi,8),%xmm2
mulsd  0x18(%rdx,%rdi,8),%xmm2
addsd  %xmm0,%xmm1
movsd  0x20(%r15,%rdi,8),%xmm5
mulsd  0x20(%rdx,%rdi,8),%xmm5
addsd  %xmm1,%xmm2
addsd  %xmm2,%xmm5
add    $0x4,%rdi
cmp    %rdi,%r14
jne    1a00 <dlp2_1pt_i+0x8d0>
add    $0x1,%rdi
testb  $0x3,0x10(%rsp)
je     1a87 <dlp2_1pt_i+0x957>
lea    (%rdx,%rdi,8),%rcx
lea    (%r15,%rdi,8),%rdi
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%rdi,%rax,8),%xmm0
mulsd  (%rcx,%rax,8),%xmm0
addsd  %xmm0,%xmm5
add    $0x1,%rax
cmp    %rax,%r12
jne    1a70 <dlp2_1pt_i+0x940>
movsd  (%r10),%xmm0
mulsd  %xmm5,%xmm0
subsd  %xmm0,%xmm6
movsd  %xmm6,(%rdx)
cmp    $0x1,%ebp
je     19b0 <dlp2_1pt_i+0x880>
xorpd  %xmm11,%xmm5
mov    $0x1,%ecx
cmpq   $0x4,0x10(%rsp)
jb     1bd0 <dlp2_1pt_i+0xaa0>
lea    0x8(%rdx),%rax
cmp    0xb8(%rsp),%rax
jae    1ad7 <dlp2_1pt_i+0x9a7>
lea    (%rdx,%r13,8),%rax
cmp    %rax,0xb0(%rsp)
jb     1bd0 <dlp2_1pt_i+0xaa0>
movapd %xmm5,%xmm6
unpcklpd %xmm5,%xmm6
cmpq   $0x4,0x60(%rsp)
jae    1aee <dlp2_1pt_i+0x9be>
xor    %edi,%edi
jmp    1b76 <dlp2_1pt_i+0xa46>
mov    0x40(%rsp),%rcx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nop
movupd 0x8(%r10,%rdi,8),%xmm0
movupd 0x18(%r10,%rdi,8),%xmm1
mulpd  %xmm6,%xmm0
movupd 0x8(%rdx,%rdi,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x18(%rdx,%rdi,8),%xmm0
movupd 0x28(%rdx,%rdi,8),%xmm3
movupd 0x38(%rdx,%rdi,8),%xmm7
mulpd  %xmm6,%xmm1
addpd  %xmm0,%xmm1
movupd %xmm2,0x8(%rdx,%rdi,8)
movupd %xmm1,0x18(%rdx,%rdi,8)
movupd 0x28(%r10,%rdi,8),%xmm0
movupd 0x38(%r10,%rdi,8),%xmm1
mulpd  %xmm6,%xmm0
addpd  %xmm3,%xmm0
mulpd  %xmm6,%xmm1
addpd  %xmm7,%xmm1
movupd %xmm0,0x28(%rdx,%rdi,8)
movupd %xmm1,0x38(%rdx,%rdi,8)
add    $0x8,%rdi
add    $0xfffffffffffffffe,%rcx
jne    1b00 <dlp2_1pt_i+0x9d0>
testb  $0x1,0x58(%rsp)
je     1bb8 <dlp2_1pt_i+0xa88>
shl    $0x3,%rdi
or     $0x8,%rdi
movupd (%rdx,%rdi,1),%xmm0
movupd 0x10(%rdx,%rdi,1),%xmm1
movupd (%r10,%rdi,1),%xmm2
movupd 0x10(%r10,%rdi,1),%xmm3
mulpd  %xmm6,%xmm2
addpd  %xmm0,%xmm2
mulpd  %xmm6,%xmm3
addpd  %xmm1,%xmm3
movupd %xmm2,(%rdx,%rdi,1)
movupd %xmm3,0x10(%rdx,%rdi,1)
mov    0x50(%rsp),%rcx
cmp    %r14,0x10(%rsp)
je     19b0 <dlp2_1pt_i+0x880>
nopl   0x0(%rax,%rax,1)
mov    %rcx,%rdi
test   $0x1,%r13b
jne    1bf1 <dlp2_1pt_i+0xac1>
movsd  (%r10,%rcx,8),%xmm0
mulsd  %xmm5,%xmm0
addsd  (%rdx,%rcx,8),%xmm0
movsd  %xmm0,(%rdx,%rcx,8)
lea    0x1(%rcx),%rdi
not    %rcx
cmp    %rsi,%rcx
je     19b0 <dlp2_1pt_i+0x880>
nopl   (%rax)
movsd  (%r10,%rdi,8),%xmm0
mulsd  %xmm5,%xmm0
addsd  (%rdx,%rdi,8),%xmm0
movsd  %xmm0,(%rdx,%rdi,8)
movsd  0x8(%r10,%rdi,8),%xmm0
mulsd  %xmm5,%xmm0
addsd  0x8(%rdx,%rdi,8),%xmm0
movsd  %xmm0,0x8(%rdx,%rdi,8)
add    $0x2,%rdi
cmp    %rdi,%r13
jne    1c00 <dlp2_1pt_i+0xad0>
jmp    19b0 <dlp2_1pt_i+0x880>
nopl   0x0(%rax)
mov    0x30(%rsp),%rax
mov    0xc(%rsp),%ecx
mov    %ecx,(%r9,%rax,4)
cmp    0x108(%rsp),%ecx
mov    0xa8(%rsp),%r10
mov    %ebp,%esi
mov    0xa0(%rsp),%r15
mov    0x128(%rsp),%rbx
mov    0x24(%rsp),%edx
jl     1278 <dlp2_1pt_i+0x148>
test   %esi,%esi
jle    1260 <dlp2_1pt_i+0x130>
mov    %edx,%ecx
xor    %ebp,%ebp
jmp    1c9d <dlp2_1pt_i+0xb6d>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%rbp
cmp    %rbp,%r13
je     1260 <dlp2_1pt_i+0x130>
cmp    %rbp,%rcx
je     1c90 <dlp2_1pt_i+0xb60>
mov    (%r9,%rbp,4),%eax
test   %eax,%eax
js     1c90 <dlp2_1pt_i+0xb60>
mov    0x28(%rsp),%rdi
mov    (%rbx,%rdi,8),%rdi
cmpl   $0x0,(%rdi,%rax,4)
jne    1c90 <dlp2_1pt_i+0xb60>
mov    (%rbx,%rax,8),%rax
mov    %r15,%r11
mov    0x28(%rsp),%r15
movl   $0x1,(%rax,%r15,4)
mov    %r11,%r15
movslq (%r9,%rbp,4),%rax
movl   $0x1,(%rdi,%rax,4)
jmp    1c90 <dlp2_1pt_i+0xb60>
xor    %eax,%eax
testb  $0x1,0x80(%rsp)
01
jne    173d <dlp2_1pt_i+0x60d>
jmp    1778 <dlp2_1pt_i+0x648>
add    $0xc8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    0x32d(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
xor    %eax,%eax
call   1030 <abort@plt>
lea    0x334(%rip),%rdi
call   1040 <puts@plt>
xor    %eax,%eax
call   1030 <abort@plt>

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

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