#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 dlp1_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, i, i1, j, k, ell;
  double eps = 1.0e-6, vmax, top, bot, sigj, dtmp;
  if (0 > 0)
    printf("entered dlp1_1pt_i with ma = %d and na = %d\n", ma, na);
  while (1) {
    vmax = -DBL_MAX;
    for (i = 0; i < na; i++) {
      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("dlp1_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("dlp1_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 && !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):
<dlp1_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    123f <dlp1_1pt_i+0x11f>
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    120c <dlp1_1pt_i+0xec>
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    11be <dlp1_1pt_i+0x9e>
movsd  -0x70(%rbp),%xmm0
ucomisd -0x50(%rbp),%xmm0
jbe    122c <dlp1_1pt_i+0x10c>
movsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x30(%rbp),%eax
mov    %eax,-0x3c(%rbp)
jmp    1231 <dlp1_1pt_i+0x111>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    118e <dlp1_1pt_i+0x6e>
movsd  -0x50(%rbp),%xmm1
movsd  -0x48(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    1259 <dlp1_1pt_i+0x139>
add    $0x70,%rsp
pop    %rbp
ret
mov    0x2d80(%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    146b <dlp1_1pt_i+0x34b>
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    12de <dlp1_1pt_i+0x1be>
mov    0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x30(%rbp),%eax
jne    12cb <dlp1_1pt_i+0x1ab>
movl   $0x1,-0x2c(%rbp)
jmp    12de <dlp1_1pt_i+0x1be>
jmp    12d0 <dlp1_1pt_i+0x1b0>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    129f <dlp1_1pt_i+0x17f>
cmpl   $0x0,-0x2c(%rbp)
je     12ed <dlp1_1pt_i+0x1cd>
jmp    145d <dlp1_1pt_i+0x33d>
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    136f <dlp1_1pt_i+0x24f>
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    1319 <dlp1_1pt_i+0x1f9>
movsd  -0x60(%rbp),%xmm0
movsd  -0x48(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
ucomisd %xmm1,%xmm0
jb     139f <dlp1_1pt_i+0x27f>
jmp    145d <dlp1_1pt_i+0x33d>
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    1425 <dlp1_1pt_i+0x305>
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    13d7 <dlp1_1pt_i+0x2b7>
movsd  -0x60(%rbp),%xmm1
movsd  -0x58(%rbp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x58(%rbp),%xmm0
ucomisd -0x68(%rbp),%xmm0
jb     144d <dlp1_1pt_i+0x32d>
jmp    145d <dlp1_1pt_i+0x33d>
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    1277 <dlp1_1pt_i+0x157>
cmpl   $0x0,-0x40(%rbp)
jge    148a <dlp1_1pt_i+0x36a>
lea    0xba4(%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    14f6 <dlp1_1pt_i+0x3d6>
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    1491 <dlp1_1pt_i+0x371>
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    1578 <dlp1_1pt_i+0x458>
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    1522 <dlp1_1pt_i+0x402>
movsd  -0x58(%rbp),%xmm1
movaps 0xa8c(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  -0x48(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    15ac <dlp1_1pt_i+0x48c>
lea    0xa9e(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    $0x0,%al
call   1030 <abort@plt>
movsd  0xa54(%rip),%xmm0
divsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    15fe <dlp1_1pt_i+0x4de>
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    15c5 <dlp1_1pt_i+0x4a5>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    172b <dlp1_1pt_i+0x60b>
mov    -0x38(%rbp),%eax
cmp    -0x3c(%rbp),%eax
je     1718 <dlp1_1pt_i+0x5f8>
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    169f <dlp1_1pt_i+0x57f>
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    1649 <dlp1_1pt_i+0x529>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1713 <dlp1_1pt_i+0x5f3>
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    16a6 <dlp1_1pt_i+0x586>
jmp    1718 <dlp1_1pt_i+0x5f8>
jmp    171d <dlp1_1pt_i+0x5fd>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1605 <dlp1_1pt_i+0x4e5>
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     1824 <dlp1_1pt_i+0x704>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    17d7 <dlp1_1pt_i+0x6b7>
mov    -0x30(%rbp),%eax
cmp    -0x3c(%rbp),%eax
je     17c4 <dlp1_1pt_i+0x6a4>
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    17c4 <dlp1_1pt_i+0x6a4>
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    17c9 <dlp1_1pt_i+0x6a9>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    174c <dlp1_1pt_i+0x62c>
mov    0x38(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq 0x10(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    181f <dlp1_1pt_i+0x6ff>
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    1824 <dlp1_1pt_i+0x704>
jmp    1160 <dlp1_1pt_i+0x40>

x86 assembly (clang, -O2):
<dlp1_1pt_i>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xb8,%rsp
movslq %ecx,%r15
mov    %esi,%r12d
lea    -0x1(%r12),%r11
mov    %r12d,%eax
and    $0xfffffffc,%eax
mov    %rax,0x88(%rsp)
add    $0xfffffffffffffffc,%rax
mov    %rax,0x80(%rsp)
mov    %rax,%rcx
shr    $0x2,%rcx
add    $0x1,%rcx
lea    -0x5(%r12),%rax
mov    %rax,0x60(%rsp)
mov    %rax,%rbp
shr    $0x2,%rbp
add    $0x1,%rbp
mov    %r11d,%r13d
and    $0x3,%r13d
mov    %r11,%rax
mov    %r11,0x10(%rsp)
and    $0xfffffffffffffffc,%r11
mov    %rcx,%rax
mov    %rcx,0x78(%rsp)
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0x70(%rsp)
mov    %r12,%rax
neg    %rax
mov    %rax,0x68(%rsp)
mov    %rbp,%rax
mov    %rbp,0x58(%rsp)
and    $0xfffffffffffffffe,%rbp
mov    %rbp,0x40(%rsp)
movapd 0xe31(%rip),%xmm11
movsd  0xe48(%rip),%xmm10
movapd 0xe2f(%rip),%xmm9
movsd  0xe46(%rip),%xmm8
movsd  0xe36(%rip),%xmm4
mov    0x108(%rsp),%rax
mov    0x100(%rsp),%r10
movslq 0xf0(%rsp),%rcx
mov    %rcx,0x48(%rsp)
mov    %edi,0x3c(%rsp)
mov    %edi,%ecx
mov    %rcx,0xb0(%rsp)
lea    (%rax,%r12,8),%rax
mov    %rax,0x90(%rsp)
lea    -0x2(%r12),%rax
mov    %rax,0x18(%rsp)
lea    0x1(%r11),%rax
mov    %rax,0x50(%rsp)
mov    %rdx,0xa0(%rsp)
mov    %r15,0x98(%rsp)
jmp    1269 <dlp1_1pt_i+0x139>
xchg   %ax,%ax
mov    0x28(%rsp),%rax
mov    0x0(%rbp,%rax,8),%rcx
mov    0x48(%rsp),%rax
cmpl   $0x0,(%rcx,%rax,4)
je     1667 <dlp1_1pt_i+0x537>
mov    0x2d70(%rip),%rax
movsd  (%rax),%xmm3
movapd %xmm3,%xmm5
xorpd  %xmm11,%xmm5
test   %esi,%esi
jle    1370 <dlp1_1pt_i+0x240>
movsd  (%r8),%xmm7
xor    %eax,%eax
jmp    12ac <dlp1_1pt_i+0x17c>
xchg   %ax,%ax
ucomisd %xmm5,%xmm6
cmova  %eax,%ebx
maxsd  %xmm5,%xmm6
add    $0x1,%rax
movapd %xmm6,%xmm5
cmp    %r12,%rax
je     1374 <dlp1_1pt_i+0x244>
mov    0x110(%rsp),%rcx
mov    (%rcx,%rax,8),%rcx
movsd  (%rcx),%xmm6
mulsd  %xmm7,%xmm6
cmp    $0x2,%esi
jl     1290 <dlp1_1pt_i+0x160>
mov    $0x1,%edi
cmpq   $0x3,0x18(%rsp)
jb     1331 <dlp1_1pt_i+0x201>
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  0x8(%r8,%rdi,8),%xmm2
movsd  0x10(%r8,%rdi,8),%xmm1
mulsd  0x8(%rcx,%rdi,8),%xmm2
mulsd  0x10(%rcx,%rdi,8),%xmm1
addsd  %xmm6,%xmm2
movsd  0x18(%r8,%rdi,8),%xmm0
mulsd  0x18(%rcx,%rdi,8),%xmm0
addsd  %xmm2,%xmm1
movsd  0x20(%r8,%rdi,8),%xmm6
mulsd  0x20(%rcx,%rdi,8),%xmm6
addsd  %xmm1,%xmm0
addsd  %xmm0,%xmm6
add    $0x4,%rdi
cmp    %rdi,%r11
jne    12e0 <dlp1_1pt_i+0x1b0>
add    $0x1,%rdi
test   %r13,%r13
je     1290 <dlp1_1pt_i+0x160>
lea    (%rcx,%rdi,8),%rcx
lea    (%r8,%rdi,8),%rdi
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%rdi,%rbp,8),%xmm0
mulsd  (%rcx,%rbp,8),%xmm0
addsd  %xmm0,%xmm6
add    $0x1,%rbp
cmp    %rbp,%r13
jne    1350 <dlp1_1pt_i+0x220>
jmp    1290 <dlp1_1pt_i+0x160>
nopl   0x0(%rax)
movapd %xmm5,%xmm6
ucomisd %xmm6,%xmm10
ja     1cb5 <dlp1_1pt_i+0xb85>
cmpl   $0x0,0x3c(%rsp)
mov    0x108(%rsp),%rdi
jle    1cc7 <dlp1_1pt_i+0xb97>
mov    %ebx,0x24(%rsp)
movslq %ebx,%rax
mov    %rax,0x30(%rsp)
movl   $0xffffffff,0xc(%rsp)
ff
xor    %r14d,%r14d
jmp    13ca <dlp1_1pt_i+0x29a>
nopl   0x0(%rax,%rax,1)
mov    0x108(%rsp),%rdi
add    $0x1,%r14
cmp    0xb0(%rsp),%r14
je     15b0 <dlp1_1pt_i+0x480>
mov    (%r9,%r14,4),%ebx
test   %esi,%esi
jle    13ef <dlp1_1pt_i+0x2bf>
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
cmp    %ebx,(%r10,%rcx,4)
je     13b8 <dlp1_1pt_i+0x288>
add    $0x1,%rcx
cmp    %rcx,%r12
jne    13e0 <dlp1_1pt_i+0x2b0>
movslq %ebx,%rcx
mov    (%rdx,%rcx,8),%rdi
movsd  (%rdi),%xmm6
mov    0x110(%rsp),%rax
mov    0x30(%rsp),%rcx
mov    (%rax,%rcx,8),%rcx
movsd  (%rcx),%xmm7
mulsd  %xmm6,%xmm7
cmp    $0x2,%esi
jl     14a8 <dlp1_1pt_i+0x378>
mov    $0x1,%ebp
cmpq   $0x3,0x18(%rsp)
jb     147d <dlp1_1pt_i+0x34d>
xor    %ebp,%ebp
nopl   0x0(%rax,%rax,1)
movsd  0x8(%rdi,%rbp,8),%xmm0
movsd  0x10(%rdi,%rbp,8),%xmm1
mulsd  0x8(%rcx,%rbp,8),%xmm0
mulsd  0x10(%rcx,%rbp,8),%xmm1
addsd  %xmm7,%xmm0
movsd  0x18(%rdi,%rbp,8),%xmm2
mulsd  0x18(%rcx,%rbp,8),%xmm2
addsd  %xmm0,%xmm1
movsd  0x20(%rdi,%rbp,8),%xmm7
mulsd  0x20(%rcx,%rbp,8),%xmm7
addsd  %xmm1,%xmm2
addsd  %xmm2,%xmm7
add    $0x4,%rbp
cmp    %rbp,%r11
jne    1430 <dlp1_1pt_i+0x300>
add    $0x1,%rbp
testb  $0x3,0x10(%rsp)
je     14a8 <dlp1_1pt_i+0x378>
lea    (%rcx,%rbp,8),%rcx
lea    (%rdi,%rbp,8),%rbp
xor    %eax,%eax
xchg   %ax,%ax
movsd  0x0(%rbp,%rax,8),%xmm0
mulsd  (%rcx,%rax,8),%xmm0
addsd  %xmm0,%xmm7
add    $0x1,%rax
cmp    %rax,%r13
jne    1490 <dlp1_1pt_i+0x360>
ucomisd %xmm4,%xmm7
jae    13b0 <dlp1_1pt_i+0x280>
movsd  (%rdi,%r15,8),%xmm5
xorpd  %xmm11,%xmm5
test   %esi,%esi
mov    0x108(%rsp),%rax
jle    157a <dlp1_1pt_i+0x44a>
mulsd  (%rax),%xmm6
addsd  %xmm5,%xmm6
cmp    $0x1,%esi
je     157e <dlp1_1pt_i+0x44e>
mov    $0x1,%ecx
cmpq   $0x3,0x18(%rsp)
jb     153d <dlp1_1pt_i+0x40d>
xor    %ecx,%ecx
nopl   (%rax)
movsd  0x8(%rdi,%rcx,8),%xmm0
movsd  0x10(%rdi,%rcx,8),%xmm1
mulsd  0x8(%rax,%rcx,8),%xmm0
mulsd  0x10(%rax,%rcx,8),%xmm1
addsd  %xmm6,%xmm0
movsd  0x18(%rdi,%rcx,8),%xmm2
mulsd  0x18(%rax,%rcx,8),%xmm2
addsd  %xmm0,%xmm1
movsd  0x20(%rdi,%rcx,8),%xmm6
mulsd  0x20(%rax,%rcx,8),%xmm6
addsd  %xmm1,%xmm2
addsd  %xmm2,%xmm6
add    $0x4,%rcx
cmp    %rcx,%r11
jne    14f0 <dlp1_1pt_i+0x3c0>
add    $0x1,%rcx
testb  $0x3,0x10(%rsp)
je     157e <dlp1_1pt_i+0x44e>
mov    0x108(%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),%xmm0
mulsd  0x0(%rbp,%rax,8),%xmm0
addsd  %xmm0,%xmm6
add    $0x1,%rax
cmp    %rax,%r13
jne    1560 <dlp1_1pt_i+0x430>
jmp    157e <dlp1_1pt_i+0x44e>
movapd %xmm5,%xmm6
divsd  %xmm7,%xmm6
ucomisd %xmm3,%xmm6
mov    0x108(%rsp),%rdi
jae    13b8 <dlp1_1pt_i+0x288>
mov    %ebx,0xc(%rsp)
movapd %xmm6,%xmm3
jmp    13b8 <dlp1_1pt_i+0x288>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
cmpl   $0x0,0xc(%rsp)
js     1cc7 <dlp1_1pt_i+0xb97>
mov    0x110(%rsp),%rax
mov    0x30(%rsp),%rcx
mov    (%rax,%rcx,8),%rbx
test   %esi,%esi
jle    1770 <dlp1_1pt_i+0x640>
xorpd  %xmm11,%xmm3
cmp    $0x4,%esi
jb     15f9 <dlp1_1pt_i+0x4c9>
lea    (%rbx,%r12,8),%rcx
cmp    %rdi,%rcx
jbe    1689 <dlp1_1pt_i+0x559>
cmp    0x90(%rsp),%rbx
jae    1689 <dlp1_1pt_i+0x559>
xor    %eax,%eax
mov    %rax,%rcx
test   $0x1,%r12b
je     161e <dlp1_1pt_i+0x4ee>
movsd  (%rbx,%rax,8),%xmm0
mulsd  %xmm3,%xmm0
addsd  (%rdi,%rax,8),%xmm0
movsd  %xmm0,(%rdi,%rax,8)
mov    %rax,%rcx
or     $0x1,%rcx
not    %rax
cmp    0x68(%rsp),%rax
je     1770 <dlp1_1pt_i+0x640>
nopl   0x0(%rax)
movsd  (%rbx,%rcx,8),%xmm0
mulsd  %xmm3,%xmm0
addsd  (%rdi,%rcx,8),%xmm0
movsd  %xmm0,(%rdi,%rcx,8)
movsd  0x8(%rbx,%rcx,8),%xmm0
mulsd  %xmm3,%xmm0
addsd  0x8(%rdi,%rcx,8),%xmm0
movsd  %xmm0,0x8(%rdi,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%r12
jne    1630 <dlp1_1pt_i+0x500>
jmp    1770 <dlp1_1pt_i+0x640>
mov    0x48(%rsp),%rdi
mov    0x0(%rbp,%rdi,8),%rax
mov    0x28(%rsp),%rbp
movl   $0x1,(%rax,%rbp,4)
movl   $0x1,(%rcx,%rdi,4)
jmp    1269 <dlp1_1pt_i+0x139>
movapd %xmm3,%xmm5
unpcklpd %xmm3,%xmm5
cmpq   $0x0,0x80(%rsp)
je     1ca3 <dlp1_1pt_i+0xb73>
mov    0x70(%rsp),%rax
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
movupd (%rbx,%rcx,8),%xmm0
movupd 0x10(%rbx,%rcx,8),%xmm1
mulpd  %xmm5,%xmm0
movupd (%rdi,%rcx,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x10(%rdi,%rcx,8),%xmm0
movupd 0x20(%rdi,%rcx,8),%xmm6
movupd 0x30(%rdi,%rcx,8),%xmm7
mulpd  %xmm5,%xmm1
addpd  %xmm0,%xmm1
movupd %xmm2,(%rdi,%rcx,8)
movupd %xmm1,0x10(%rdi,%rcx,8)
movupd 0x20(%rbx,%rcx,8),%xmm0
movupd 0x30(%rbx,%rcx,8),%xmm1
mulpd  %xmm5,%xmm0
addpd  %xmm6,%xmm0
mulpd  %xmm5,%xmm1
addpd  %xmm7,%xmm1
movupd %xmm0,0x20(%rdi,%rcx,8)
movupd %xmm1,0x30(%rdi,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rax
jne    16b0 <dlp1_1pt_i+0x580>
testb  $0x1,0x78(%rsp)
je     1757 <dlp1_1pt_i+0x627>
movupd (%rbx,%rcx,8),%xmm0
movupd 0x10(%rbx,%rcx,8),%xmm1
movupd (%rdi,%rcx,8),%xmm2
movupd 0x10(%rdi,%rcx,8),%xmm6
mulpd  %xmm5,%xmm0
addpd  %xmm2,%xmm0
mulpd  %xmm5,%xmm1
addpd  %xmm6,%xmm1
movupd %xmm0,(%rdi,%rcx,8)
movupd %xmm1,0x10(%rdi,%rcx,8)
mov    0x88(%rsp),%rcx
mov    %rcx,%rax
cmp    %r12,%rcx
jne    15fb <dlp1_1pt_i+0x4cb>
nopl   0x0(%rax,%rax,1)
movslq 0xc(%rsp),%rax
mov    %rax,0x28(%rsp)
mov    (%rdx,%rax,8),%r15
movsd  (%rbx),%xmm5
movsd  (%r15),%xmm6
mulsd  %xmm5,%xmm6
cmp    $0x2,%esi
jl     1837 <dlp1_1pt_i+0x707>
mov    $0x1,%ecx
cmpq   $0x3,0x18(%rsp)
jb     1801 <dlp1_1pt_i+0x6d1>
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  0x8(%r15,%rcx,8),%xmm0
movsd  0x10(%r15,%rcx,8),%xmm1
mulsd  0x8(%rbx,%rcx,8),%xmm0
mulsd  0x10(%rbx,%rcx,8),%xmm1
addsd  %xmm6,%xmm0
movsd  0x18(%r15,%rcx,8),%xmm2
mulsd  0x18(%rbx,%rcx,8),%xmm2
addsd  %xmm0,%xmm1
movsd  0x20(%r15,%rcx,8),%xmm6
mulsd  0x20(%rbx,%rcx,8),%xmm6
addsd  %xmm1,%xmm2
addsd  %xmm2,%xmm6
add    $0x4,%rcx
cmp    %rcx,%r11
jne    17b0 <dlp1_1pt_i+0x680>
add    $0x1,%rcx
testb  $0x3,0x10(%rsp)
je     1837 <dlp1_1pt_i+0x707>
lea    (%rbx,%rcx,8),%rax
lea    (%r15,%rcx,8),%rcx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%rcx,%rdi,8),%xmm0
mulsd  (%rax,%rdi,8),%xmm0
addsd  %xmm0,%xmm6
add    $0x1,%rdi
cmp    %rdi,%r13
jne    1820 <dlp1_1pt_i+0x6f0>
movapd %xmm6,%xmm0
andpd  %xmm9,%xmm0
ucomisd %xmm0,%xmm10
ja     1cdc <dlp1_1pt_i+0xbac>
mov    %r9,%rax
mov    %esi,%ebp
test   %esi,%esi
jle    1bf0 <dlp1_1pt_i+0xac0>
movapd %xmm8,%xmm3
divsd  %xmm6,%xmm3
mulsd  %xmm3,%xmm5
movsd  %xmm5,(%rbx)
mov    %ebp,%esi
cmp    $0x1,%ebp
je     1947 <dlp1_1pt_i+0x817>
mov    $0x1,%ecx
cmpq   $0x4,0x10(%rsp)
jb     1930 <dlp1_1pt_i+0x800>
movapd %xmm3,%xmm5
unpcklpd %xmm3,%xmm5
cmpq   $0x4,0x60(%rsp)
jae    1899 <dlp1_1pt_i+0x769>
xor    %ecx,%ecx
jmp    18ea <dlp1_1pt_i+0x7ba>
mov    0x40(%rsp),%rdx
xor    %ecx,%ecx
movupd 0x8(%rbx,%rcx,8),%xmm0
movupd 0x18(%rbx,%rcx,8),%xmm1
movupd 0x28(%rbx,%rcx,8),%xmm2
movupd 0x38(%rbx,%rcx,8),%xmm6
mulpd  %xmm5,%xmm0
mulpd  %xmm5,%xmm1
movupd %xmm0,0x8(%rbx,%rcx,8)
movupd %xmm1,0x18(%rbx,%rcx,8)
mulpd  %xmm5,%xmm2
mulpd  %xmm5,%xmm6
movupd %xmm2,0x28(%rbx,%rcx,8)
movupd %xmm6,0x38(%rbx,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rdx
jne    18a0 <dlp1_1pt_i+0x770>
testb  $0x1,0x58(%rsp)
je     1917 <dlp1_1pt_i+0x7e7>
shl    $0x3,%rcx
or     $0x8,%rcx
movupd (%rbx,%rcx,1),%xmm0
movupd 0x10(%rbx,%rcx,1),%xmm1
mulpd  %xmm5,%xmm0
mulpd  %xmm5,%xmm1
movupd %xmm0,(%rbx,%rcx,1)
movupd %xmm1,0x10(%rbx,%rcx,1)
mov    0x50(%rsp),%rcx
cmp    %r11,0x10(%rsp)
je     1947 <dlp1_1pt_i+0x817>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rbx,%rcx,8),%xmm0
mulsd  %xmm3,%xmm0
movsd  %xmm0,(%rbx,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%r12
jne    1930 <dlp1_1pt_i+0x800>
test   %esi,%esi
jle    1bf0 <dlp1_1pt_i+0xac0>
mov    0x24(%rsp),%edx
lea    0x8(%rbx),%r9
lea    (%rbx,%r12,8),%rcx
mov    %rcx,0xa8(%rsp)
xor    %r14d,%r14d
jmp    197d <dlp1_1pt_i+0x84d>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r14
cmp    %r12,%r14
je     1bf0 <dlp1_1pt_i+0xac0>
cmp    %rdx,%r14
je     1970 <dlp1_1pt_i+0x840>
mov    0x110(%rsp),%rcx
mov    (%rcx,%r14,8),%r10
movsd  (%r10),%xmm3
movsd  (%r15),%xmm5
mulsd  %xmm3,%xmm5
cmp    $0x2,%ebp
jl     1a47 <dlp1_1pt_i+0x917>
mov    $0x1,%ecx
cmpq   $0x3,0x18(%rsp)
jb     1a15 <dlp1_1pt_i+0x8e5>
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  %xmm5,%xmm0
movsd  0x18(%r15,%rcx,8),%xmm2
mulsd  0x18(%r10,%rcx,8),%xmm2
addsd  %xmm0,%xmm1
movsd  0x20(%r15,%rcx,8),%xmm5
mulsd  0x20(%r10,%rcx,8),%xmm5
addsd  %xmm1,%xmm2
addsd  %xmm2,%xmm5
add    $0x4,%rcx
cmp    %rcx,%r11
jne    19c0 <dlp1_1pt_i+0x890>
add    $0x1,%rcx
testb  $0x3,0x10(%rsp)
je     1a47 <dlp1_1pt_i+0x917>
lea    (%r10,%rcx,8),%rdi
lea    (%r15,%rcx,8),%rcx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
movsd  (%rcx,%rsi,8),%xmm0
mulsd  (%rdi,%rsi,8),%xmm0
addsd  %xmm0,%xmm5
add    $0x1,%rsi
cmp    %rsi,%r13
jne    1a30 <dlp1_1pt_i+0x900>
movsd  (%rbx),%xmm0
mulsd  %xmm5,%xmm0
subsd  %xmm0,%xmm3
movsd  %xmm3,(%r10)
cmp    $0x1,%ebp
je     1970 <dlp1_1pt_i+0x840>
xorpd  %xmm11,%xmm5
mov    $0x1,%ecx
cmpq   $0x4,0x10(%rsp)
jb     1b80 <dlp1_1pt_i+0xa50>
lea    0x8(%r10),%rsi
cmp    0xa8(%rsp),%rsi
jae    1a92 <dlp1_1pt_i+0x962>
lea    (%r10,%r12,8),%rsi
cmp    %rsi,%r9
jb     1b80 <dlp1_1pt_i+0xa50>
movapd %xmm5,%xmm3
unpcklpd %xmm5,%xmm3
cmpq   $0x4,0x60(%rsp)
jae    1aa9 <dlp1_1pt_i+0x979>
xor    %edi,%edi
jmp    1b2a <dlp1_1pt_i+0x9fa>
mov    0x40(%rsp),%rcx
xor    %edi,%edi
movupd 0x8(%rbx,%rdi,8),%xmm0
movupd 0x18(%rbx,%rdi,8),%xmm1
mulpd  %xmm3,%xmm0
movupd 0x8(%r10,%rdi,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x18(%r10,%rdi,8),%xmm0
movupd 0x28(%r10,%rdi,8),%xmm6
movupd 0x38(%r10,%rdi,8),%xmm7
mulpd  %xmm3,%xmm1
addpd  %xmm0,%xmm1
movupd %xmm2,0x8(%r10,%rdi,8)
movupd %xmm1,0x18(%r10,%rdi,8)
movupd 0x28(%rbx,%rdi,8),%xmm0
movupd 0x38(%rbx,%rdi,8),%xmm1
mulpd  %xmm3,%xmm0
addpd  %xmm6,%xmm0
mulpd  %xmm3,%xmm1
addpd  %xmm7,%xmm1
movupd %xmm0,0x28(%r10,%rdi,8)
movupd %xmm1,0x38(%r10,%rdi,8)
add    $0x8,%rdi
add    $0xfffffffffffffffe,%rcx
jne    1ab0 <dlp1_1pt_i+0x980>
testb  $0x1,0x58(%rsp)
je     1b6e <dlp1_1pt_i+0xa3e>
shl    $0x3,%rdi
or     $0x8,%rdi
movupd (%r10,%rdi,1),%xmm0
movupd 0x10(%r10,%rdi,1),%xmm1
movupd (%rbx,%rdi,1),%xmm2
movupd 0x10(%rbx,%rdi,1),%xmm6
mulpd  %xmm3,%xmm2
addpd  %xmm0,%xmm2
mulpd  %xmm3,%xmm6
addpd  %xmm1,%xmm6
movupd %xmm2,(%r10,%rdi,1)
movupd %xmm6,0x10(%r10,%rdi,1)
mov    0x50(%rsp),%rcx
cmp    %r11,0x10(%rsp)
je     1970 <dlp1_1pt_i+0x840>
xchg   %ax,%ax
mov    %rcx,%rdi
test   $0x1,%r12b
jne    1ba2 <dlp1_1pt_i+0xa72>
movsd  (%rbx,%rcx,8),%xmm0
mulsd  %xmm5,%xmm0
addsd  (%r10,%rcx,8),%xmm0
movsd  %xmm0,(%r10,%rcx,8)
lea    0x1(%rcx),%rdi
not    %rcx
cmp    0x68(%rsp),%rcx
je     1970 <dlp1_1pt_i+0x840>
movsd  (%rbx,%rdi,8),%xmm0
mulsd  %xmm5,%xmm0
addsd  (%r10,%rdi,8),%xmm0
movsd  %xmm0,(%r10,%rdi,8)
movsd  0x8(%rbx,%rdi,8),%xmm0
mulsd  %xmm5,%xmm0
addsd  0x8(%r10,%rdi,8),%xmm0
movsd  %xmm0,0x8(%r10,%rdi,8)
add    $0x2,%rdi
cmp    %rdi,%r12
jne    1bb0 <dlp1_1pt_i+0xa80>
jmp    1970 <dlp1_1pt_i+0x840>
nopl   0x0(%rax,%rax,1)
mov    0x30(%rsp),%rcx
mov    0xc(%rsp),%edx
mov    0x100(%rsp),%r10
mov    %edx,(%r10,%rcx,4)
cmp    0xf8(%rsp),%edx
mov    %rax,%r9
mov    0xa0(%rsp),%rdx
mov    %ebp,%esi
mov    0x98(%rsp),%r15
mov    0x118(%rsp),%rbp
mov    0x24(%rsp),%ebx
jl     1269 <dlp1_1pt_i+0x139>
test   %esi,%esi
jle    1250 <dlp1_1pt_i+0x120>
mov    %ebx,%r14d
xor    %eax,%eax
jmp    1c5d <dlp1_1pt_i+0xb2d>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%rax
cmp    %rax,%r12
je     1250 <dlp1_1pt_i+0x120>
cmp    %rax,%r14
je     1c50 <dlp1_1pt_i+0xb20>
mov    0x28(%rsp),%rcx
mov    0x0(%rbp,%rcx,8),%rcx
movslq (%r10,%rax,4),%rdi
cmpl   $0x0,(%rcx,%rdi,4)
jne    1c50 <dlp1_1pt_i+0xb20>
mov    0x0(%rbp,%rdi,8),%rdi
mov    %r15,%r10
mov    0x28(%rsp),%r15
movl   $0x1,(%rdi,%r15,4)
mov    %r10,%r15
mov    0x100(%rsp),%r10
movslq (%r10,%rax,4),%rdi
movl   $0x1,(%rcx,%rdi,4)
jmp    1c50 <dlp1_1pt_i+0xb20>
xor    %ecx,%ecx
testb  $0x1,0x78(%rsp)
jne    1726 <dlp1_1pt_i+0x5f6>
jmp    1757 <dlp1_1pt_i+0x627>
add    $0xb8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    0x36a(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
xor    %eax,%eax
call   1030 <abort@plt>
lea    0x371(%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"dlp1_1pt_i : LP unbounded\0A\07\00"
@.str.1 = [39 x i8] c"dlp1_1pt_i : Base matrix is singular\07\0A\00"
define void @dlp1_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, %513
%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 = %88, %37
%41 = load i32, i32* %26
%42 = load i32, i32* %14
%43 = icmp slt i32 %41, %42
br i1 %43, label %44, label %91
44: ; preds = %40
%45 = load double*, double** %17
%46 = getelementptr inbounds double, double* %45, i64 0
%47 = load double, double* %46
%48 = load double**, double*** %23
%49 = load i32, i32* %26
%50 = sext i32 %49 to i64
%51 = getelementptr inbounds double*, double** %48, i64 %50
%52 = load double*, double** %51
%53 = getelementptr inbounds double, double* %52, i64 0
%54 = load double, double* %53
%55 = fmul double %47, %54
store double %55, double* %36
store i32 1, i32* %28
br label %56
56: ; preds = %77, %44
%57 = load i32, i32* %28
%58 = load i32, i32* %14
%59 = icmp slt i32 %57, %58
br i1 %59, label %60, label %80
60: ; preds = %56
%61 = load double*, double** %17
%62 = load i32, i32* %28
%63 = sext i32 %62 to i64
%64 = getelementptr inbounds double, double* %61, i64 %63
%65 = load double, double* %64
%66 = load double**, double*** %23
%67 = load i32, i32* %26
%68 = sext i32 %67 to i64
%69 = getelementptr inbounds double*, double** %66, i64 %68
%70 = load double*, double** %69
%71 = load i32, i32* %28
%72 = sext i32 %71 to i64
%73 = getelementptr inbounds double, double* %70, i64 %72
%74 = load double, double* %73
%75 = load double, double* %36
%76 = call double @llvm.fmuladd.f64(double %65, double %74, double %75)
store double %76, double* %36
br label %77
77: ; preds = %60
%78 = load i32, i32* %28
%79 = add nsw i32 %78, 1
store i32 %79, i32* %28
br label %56
80: ; preds = %56
%81 = load double, double* %36
%82 = load double, double* %32
%83 = fcmp ogt double %81, %82
br i1 %83, label %84, label %87
84: ; preds = %80
%85 = load double, double* %36
store double %85, double* %32
%86 = load i32, i32* %26
store i32 %86, i32* %29
br label %87
87: ; preds = %84, %80
br label %88
88: ; preds = %87
%89 = load i32, i32* %26
%90 = add nsw i32 %89, 1
store i32 %90, i32* %26
br label %40
91: ; preds = %40
%92 = load double, double* %32
%93 = load double, double* %31
%94 = fcmp olt double %92, %93
br i1 %94, label %95, label %96
95: ; preds = %91
ret void
96: ; preds = %91
%97 = load double, double* @DBL_MAX
store double %97, double* %35
store i32 -1, i32* %30
store i32 0, i32* %27
br label %98
98: ; preds = %225, %96
%99 = load i32, i32* %27
%100 = load i32, i32* %13
%101 = icmp slt i32 %99, %100
br i1 %101, label %102, label %228
102: ; preds = %98
%103 = load i32*, i32** %18
%104 = load i32, i32* %27
%105 = sext i32 %104 to i64
%106 = getelementptr inbounds i32, i32* %103, i64 %105
%107 = load i32, i32* %106
store i32 %107, i32* %26
store i32 0, i32* %25
store i32 0, i32* %28
br label %108
108: ; preds = %122, %102
%109 = load i32, i32* %28
%110 = load i32, i32* %14
%111 = icmp slt i32 %109, %110
br i1 %111, label %112, label %125
112: ; preds = %108
%113 = load i32*, i32** %21
%114 = load i32, i32* %28
%115 = sext i32 %114 to i64
%116 = getelementptr inbounds i32, i32* %113, i64 %115
%117 = load i32, i32* %116
%118 = load i32, i32* %26
%119 = icmp eq i32 %117, %118
br i1 %119, label %120, label %121
120: ; preds = %112
store i32 1, i32* %25
br label %125
121: ; preds = %112
br label %122
122: ; preds = %121
%123 = load i32, i32* %28
%124 = add nsw i32 %123, 1
store i32 %124, i32* %28
br label %108
125: ; preds = %120, %108
%126 = load i32, i32* %25
%127 = icmp ne i32 %126, 0
br i1 %127, label %128, label %129
128: ; preds = %125
br label %225
129: ; preds = %125
%130 = load double**, double*** %15
%131 = load i32, i32* %26
%132 = sext i32 %131 to i64
%133 = getelementptr inbounds double*, double** %130, i64 %132
%134 = load double*, double** %133
%135 = getelementptr inbounds double, double* %134, i64 0
%136 = load double, double* %135
%137 = load double**, double*** %23
%138 = load i32, i32* %29
%139 = sext i32 %138 to i64
%140 = getelementptr inbounds double*, double** %137, i64 %139
%141 = load double*, double** %140
%142 = getelementptr inbounds double, double* %141, i64 0
%143 = load double, double* %142
%144 = fmul double %136, %143
store double %144, double* %34
store i32 1, i32* %28
br label %145
145: ; preds = %170, %129
%146 = load i32, i32* %28
%147 = load i32, i32* %14
%148 = icmp slt i32 %146, %147
br i1 %148, label %149, label %173
149: ; preds = %145
%150 = load double**, double*** %15
%151 = load i32, i32* %26
%152 = sext i32 %151 to i64
%153 = getelementptr inbounds double*, double** %150, i64 %152
%154 = load double*, double** %153
%155 = load i32, i32* %28
%156 = sext i32 %155 to i64
%157 = getelementptr inbounds double, double* %154, i64 %156
%158 = load double, double* %157
%159 = load double**, double*** %23
%160 = load i32, i32* %29
%161 = sext i32 %160 to i64
%162 = getelementptr inbounds double*, double** %159, i64 %161
%163 = load double*, double** %162
%164 = load i32, i32* %28
%165 = sext i32 %164 to i64
%166 = getelementptr inbounds double, double* %163, i64 %165
%167 = load double, double* %166
%168 = load double, double* %34
%169 = call double @llvm.fmuladd.f64(double %158, double %167, double %168)
store double %169, double* %34
br label %170
170: ; preds = %149
%171 = load i32, i32* %28
%172 = add nsw i32 %171, 1
store i32 %172, i32* %28
br label %145
173: ; preds = %145
%174 = load double, double* %34
%175 = load double, double* %31
%176 = fneg double %175
%177 = fcmp oge double %174, %176
br i1 %177, label %178, label %179
178: ; preds = %173
br label %225
179: ; preds = %173
%180 = load double**, double*** %15
%181 = load i32, i32* %26
%182 = sext i32 %181 to i64
%183 = getelementptr inbounds double*, double** %180, i64 %182
%184 = load double*, double** %183
%185 = load i32, i32* %16
%186 = sext i32 %185 to i64
%187 = getelementptr inbounds double, double* %184, i64 %186
%188 = load double, double* %187
%189 = fneg double %188
store double %189, double* %33
store i32 0, i32* %28
br label %190
190: ; preds = %211, %179
%191 = load i32, i32* %28
%192 = load i32, i32* %14
%193 = icmp slt i32 %191, %192
br i1 %193, label %194, label %214
194: ; preds = %190
%195 = load double**, double*** %15
%196 = load i32, i32* %26
%197 = sext i32 %196 to i64
%198 = getelementptr inbounds double*, double** %195, i64 %197
%199 = load double*, double** %198
%200 = load i32, i32* %28
%201 = sext i32 %200 to i64
%202 = getelementptr inbounds double, double* %199, i64 %201
%203 = load double, double* %202
%204 = load double*, double** %22
%205 = load i32, i32* %28
%206 = sext i32 %205 to i64
%207 = getelementptr inbounds double, double* %204, i64 %206
%208 = load double, double* %207
%209 = load double, double* %33
%210 = call double @llvm.fmuladd.f64(double %203, double %208, double %209)
store double %210, double* %33
br label %211
211: ; preds = %194
%212 = load i32, i32* %28
%213 = add nsw i32 %212, 1
store i32 %213, i32* %28
br label %190
214: ; preds = %190
%215 = load double, double* %34
%216 = load double, double* %33
%217 = fdiv double %216, %215
store double %217, double* %33
%218 = load double, double* %33
%219 = load double, double* %35
%220 = fcmp oge double %218, %219
br i1 %220, label %221, label %222
221: ; preds = %214
br label %225
222: ; preds = %214
%223 = load double, double* %33
store double %223, double* %35
%224 = load i32, i32* %26
store i32 %224, i32* %30
br label %225
225: ; preds = %222, %221, %178, %128
%226 = load i32, i32* %27
%227 = add nsw i32 %226, 1
store i32 %227, i32* %27
br label %98
228: ; preds = %98
%229 = load i32, i32* %30
%230 = icmp slt i32 %229, 0
br i1 %230, label %231, label %234
231: ; preds = %228
%232 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str, i64 0, i64 0))
%233 = call i32 (...) @abort()
unreachable
234: ; preds = %228
store i32 0, i32* %26
br label %235
235: ; preds = %257, %234
%236 = load i32, i32* %26
%237 = load i32, i32* %14
%238 = icmp slt i32 %236, %237
br i1 %238, label %239, label %260
239: ; preds = %235
%240 = load double, double* %35
%241 = load double**, double*** %23
%242 = load i32, i32* %29
%243 = sext i32 %242 to i64
%244 = getelementptr inbounds double*, double** %241, i64 %243
%245 = load double*, double** %244
%246 = load i32, i32* %26
%247 = sext i32 %246 to i64
%248 = getelementptr inbounds double, double* %245, i64 %247
%249 = load double, double* %248
%250 = load double*, double** %22
%251 = load i32, i32* %26
%252 = sext i32 %251 to i64
%253 = getelementptr inbounds double, double* %250, i64 %252
%254 = load double, double* %253
%255 = fneg double %240
%256 = call double @llvm.fmuladd.f64(double %255, double %249, double %254)
store double %256, double* %253
br label %257
257: ; preds = %239
%258 = load i32, i32* %26
%259 = add nsw i32 %258, 1
store i32 %259, i32* %26
br label %235
260: ; preds = %235
%261 = load double**, double*** %15
%262 = load i32, i32* %30
%263 = sext i32 %262 to i64
%264 = getelementptr inbounds double*, double** %261, i64 %263
%265 = load double*, double** %264
%266 = getelementptr inbounds double, double* %265, i64 0
%267 = load double, double* %266
%268 = load double**, double*** %23
%269 = load i32, i32* %29
%270 = sext i32 %269 to i64
%271 = getelementptr inbounds double*, double** %268, i64 %270
%272 = load double*, double** %271
%273 = getelementptr inbounds double, double* %272, i64 0
%274 = load double, double* %273
%275 = fmul double %267, %274
store double %275, double* %33
store i32 1, i32* %26
br label %276
276: ; preds = %301, %260
%277 = load i32, i32* %26
%278 = load i32, i32* %14
%279 = icmp slt i32 %277, %278
br i1 %279, label %280, label %304
280: ; preds = %276
%281 = load double**, double*** %15
%282 = load i32, i32* %30
%283 = sext i32 %282 to i64
%284 = getelementptr inbounds double*, double** %281, i64 %283
%285 = load double*, double** %284
%286 = load i32, i32* %26
%287 = sext i32 %286 to i64
%288 = getelementptr inbounds double, double* %285, i64 %287
%289 = load double, double* %288
%290 = load double**, double*** %23
%291 = load i32, i32* %29
%292 = sext i32 %291 to i64
%293 = getelementptr inbounds double*, double** %290, i64 %292
%294 = load double*, double** %293
%295 = load i32, i32* %26
%296 = sext i32 %295 to i64
%297 = getelementptr inbounds double, double* %294, i64 %296
%298 = load double, double* %297
%299 = load double, double* %33
%300 = call double @llvm.fmuladd.f64(double %289, double %298, double %299)
store double %300, double* %33
br label %301
301: ; preds = %280
%302 = load i32, i32* %26
%303 = add nsw i32 %302, 1
store i32 %303, i32* %26
br label %276
304: ; preds = %276
%305 = load double, double* %33
%306 = call double @llvm.fabs.f64(double %305)
%307 = load double, double* %31
%308 = fcmp olt double %306, %307
br i1 %308, label %309, label %312
309: ; preds = %304
%310 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str.1, i64 0, i64 0))
%311 = call i32 (...) @abort()
unreachable
312: ; preds = %304
%313 = load double, double* %33
%314 = fdiv double 1.000000e+00, %313
store double %314, double* %33
store i32 0, i32* %26
br label %315
315: ; preds = %331, %312
%316 = load i32, i32* %26
%317 = load i32, i32* %14
%318 = icmp slt i32 %316, %317
br i1 %318, label %319, label %334
319: ; preds = %315
%320 = load double, double* %33
%321 = load double**, double*** %23
%322 = load i32, i32* %29
%323 = sext i32 %322 to i64
%324 = getelementptr inbounds double*, double** %321, i64 %323
%325 = load double*, double** %324
%326 = load i32, i32* %26
%327 = sext i32 %326 to i64
%328 = getelementptr inbounds double, double* %325, i64 %327
%329 = load double, double* %328
%330 = fmul double %329, %320
store double %330, double* %328
br label %331
331: ; preds = %319
%332 = load i32, i32* %26
%333 = add nsw i32 %332, 1
store i32 %333, i32* %26
br label %315
334: ; preds = %315
store i32 0, i32* %28
br label %335
335: ; preds = %419, %334
%336 = load i32, i32* %28
%337 = load i32, i32* %14
%338 = icmp slt i32 %336, %337
br i1 %338, label %339, label %422
339: ; preds = %335
%340 = load i32, i32* %28
%341 = load i32, i32* %29
%342 = icmp ne i32 %340, %341
br i1 %342, label %343, label %418
343: ; preds = %339
%344 = load double**, double*** %15
%345 = load i32, i32* %30
%346 = sext i32 %345 to i64
%347 = getelementptr inbounds double*, double** %344, i64 %346
%348 = load double*, double** %347
%349 = getelementptr inbounds double, double* %348, i64 0
%350 = load double, double* %349
%351 = load double**, double*** %23
%352 = load i32, i32* %28
%353 = sext i32 %352 to i64
%354 = getelementptr inbounds double*, double** %351, i64 %353
%355 = load double*, double** %354
%356 = getelementptr inbounds double, double* %355, i64 0
%357 = load double, double* %356
%358 = fmul double %350, %357
store double %358, double* %33
store i32 1, i32* %26
br label %359
359: ; preds = %384, %343
%360 = load i32, i32* %26
%361 = load i32, i32* %14
%362 = icmp slt i32 %360, %361
br i1 %362, label %363, label %387
363: ; preds = %359
%364 = load double**, double*** %15
%365 = load i32, i32* %30
%366 = sext i32 %365 to i64
%367 = getelementptr inbounds double*, double** %364, i64 %366
%368 = load double*, double** %367
%369 = load i32, i32* %26
%370 = sext i32 %369 to i64
%371 = getelementptr inbounds double, double* %368, i64 %370
%372 = load double, double* %371
%373 = load double**, double*** %23
%374 = load i32, i32* %28
%375 = sext i32 %374 to i64
%376 = getelementptr inbounds double*, double** %373, i64 %375
%377 = load double*, double** %376
%378 = load i32, i32* %26
%379 = sext i32 %378 to i64
%380 = getelementptr inbounds double, double* %377, i64 %379
%381 = load double, double* %380
%382 = load double, double* %33
%383 = call double @llvm.fmuladd.f64(double %372, double %381, double %382)
store double %383, double* %33
br label %384
384: ; preds = %363
%385 = load i32, i32* %26
%386 = add nsw i32 %385, 1
store i32 %386, i32* %26
br label %359
387: ; preds = %359
store i32 0, i32* %26
br label %388
388: ; preds = %414, %387
%389 = load i32, i32* %26
%390 = load i32, i32* %14
%391 = icmp slt i32 %389, %390
br i1 %391, label %392, label %417
392: ; preds = %388
%393 = load double, double* %33
%394 = load double**, double*** %23
%395 = load i32, i32* %29
%396 = sext i32 %395 to i64
%397 = getelementptr inbounds double*, double** %394, i64 %396
%398 = load double*, double** %397
%399 = load i32, i32* %26
%400 = sext i32 %399 to i64
%401 = getelementptr inbounds double, double* %398, i64 %400
%402 = load double, double* %401
%403 = load double**, double*** %23
%404 = load i32, i32* %28
%405 = sext i32 %404 to i64
%406 = getelementptr inbounds double*, double** %403, i64 %405
%407 = load double*, double** %406
%408 = load i32, i32* %26
%409 = sext i32 %408 to i64
%410 = getelementptr inbounds double, double* %407, i64 %409
%411 = load double, double* %410
%412 = fneg double %393
%413 = call double @llvm.fmuladd.f64(double %412, double %402, double %411)
store double %413, double* %410
br label %414
414: ; preds = %392
%415 = load i32, i32* %26
%416 = add nsw i32 %415, 1
store i32 %416, i32* %26
br label %388
417: ; preds = %388
br label %418
418: ; preds = %417, %339
br label %419
419: ; preds = %418
%420 = load i32, i32* %28
%421 = add nsw i32 %420, 1
store i32 %421, i32* %28
br label %335
422: ; preds = %335
%423 = load i32, i32* %30
%424 = load i32*, i32** %21
%425 = load i32, i32* %29
%426 = sext i32 %425 to i64
%427 = getelementptr inbounds i32, i32* %424, i64 %426
store i32 %423, i32* %427
%428 = load i32, i32* %30
%429 = load i32, i32* %20
%430 = icmp sge i32 %428, %429
br i1 %430, label %431, label %513
431: ; preds = %422
store i32 0, i32* %26
br label %432
432: ; preds = %481, %431
%433 = load i32, i32* %26
%434 = load i32, i32* %14
%435 = icmp slt i32 %433, %434
br i1 %435, label %436, label %484
436: ; preds = %432
%437 = load i32, i32* %26
%438 = load i32, i32* %29
%439 = icmp ne i32 %437, %438
br i1 %439, label %440, label %480
440: ; preds = %436
%441 = load i32**, i32*** %24
%442 = load i32, i32* %30
%443 = sext i32 %442 to i64
%444 = getelementptr inbounds i32*, i32** %441, i64 %443
%445 = load i32*, i32** %444
%446 = load i32*, i32** %21
%447 = load i32, i32* %26
%448 = sext i32 %447 to i64
%449 = getelementptr inbounds i32, i32* %446, i64 %448
%450 = load i32, i32* %449
%451 = sext i32 %450 to i64
%452 = getelementptr inbounds i32, i32* %445, i64 %451
%453 = load i32, i32* %452
%454 = icmp ne i32 %453, 0
br i1 %454, label %480, label %455
455: ; preds = %440
%456 = load i32**, i32*** %24
%457 = load i32*, i32** %21
%458 = load i32, i32* %26
%459 = sext i32 %458 to i64
%460 = getelementptr inbounds i32, i32* %457, i64 %459
%461 = load i32, i32* %460
%462 = sext i32 %461 to i64
%463 = getelementptr inbounds i32*, i32** %456, i64 %462
%464 = load i32*, i32** %463
%465 = load i32, i32* %30
%466 = sext i32 %465 to i64
%467 = getelementptr inbounds i32, i32* %464, i64 %466
store i32 1, i32* %467
%468 = load i32**, i32*** %24
%469 = load i32, i32* %30
%470 = sext i32 %469 to i64
%471 = getelementptr inbounds i32*, i32** %468, i64 %470
%472 = load i32*, i32** %471
%473 = load i32*, i32** %21
%474 = load i32, i32* %26
%475 = sext i32 %474 to i64
%476 = getelementptr inbounds i32, i32* %473, i64 %475
%477 = load i32, i32* %476
%478 = sext i32 %477 to i64
%479 = getelementptr inbounds i32, i32* %472, i64 %478
store i32 1, i32* %479
br label %480
480: ; preds = %455, %440, %436
br label %481
481: ; preds = %480
%482 = load i32, i32* %26
%483 = add nsw i32 %482, 1
store i32 %483, i32* %26
br label %432
484: ; preds = %432
%485 = load i32**, i32*** %24
%486 = load i32, i32* %30
%487 = sext i32 %486 to i64
%488 = getelementptr inbounds i32*, i32** %485, i64 %487
%489 = load i32*, i32** %488
%490 = load i32, i32* %19
%491 = sext i32 %490 to i64
%492 = getelementptr inbounds i32, i32* %489, i64 %491
%493 = load i32, i32* %492
%494 = icmp ne i32 %493, 0
br i1 %494, label %512, label %495
495: ; preds = %484
%496 = load i32**, i32*** %24
%497 = load i32, i32* %19
%498 = sext i32 %497 to i64
%499 = getelementptr inbounds i32*, i32** %496, i64 %498
%500 = load i32*, i32** %499
%501 = load i32, i32* %30
%502 = sext i32 %501 to i64
%503 = getelementptr inbounds i32, i32* %500, i64 %502
store i32 1, i32* %503
%504 = load i32**, i32*** %24
%505 = load i32, i32* %30
%506 = sext i32 %505 to i64
%507 = getelementptr inbounds i32*, i32** %504, i64 %506
%508 = load i32*, i32** %507
%509 = load i32, i32* %19
%510 = sext i32 %509 to i64
%511 = getelementptr inbounds i32, i32* %508, i64 %510
store i32 1, i32* %511
br label %512
512: ; preds = %495, %484
br label %513
513: ; preds = %512, %422
br label %37
}

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