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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ Thomas(double *, double *, double *, int);
int abs(int);
int /*<<< orphan*/ dualityGap2(double *, double *, double *, double *, double *,
                               double, int);
int /*<<< orphan*/ free(int *);
int generateSolution(double *, double *, double *, double *, double *, double *,
                     double *, int *, double, int);
scalar_t__ malloc(int);
int supportSet(double *, double *, double *, double *, int *, double, int);
int sfa_one(double *x, double *gap, int *activeS, double *z, double *v,
            double *Av, double lambda, int nn, int maxStep, double *s,
            double *g, double tol, int tau) {
  int i, iterStep, m, tFlag = 0, n = nn + 1;
  double temp;
  int *S = (int *)malloc(sizeof(int) * nn);
  double gapp = -1, gappp = -2;
  int numS = -100, numSp = -200, numSpp = -300;
  *gap = -1;
  g[0] = z[0] + z[0] - z[1] - Av[0];
  for (i = 1; i < nn - 1; i++) {
    g[i] = -z[i - 1] + z[i] + z[i] - z[i + 1] - Av[i];
  }
  g[nn - 1] = -z[nn - 2] + z[nn - 1] + z[nn - 1] - Av[nn - 1];
  m = nn % 5;
  if (m != 0) {
    for (i = 0; i < m; i++)
      z[i] = z[i] - g[i] / 4;
  }
  for (i = m; i < nn; i += 5) {
    z[i] = z[i] - g[i] / 4;
    z[i + 1] = z[i + 1] - g[i + 1] / 4;
    z[i + 2] = z[i + 2] - g[i + 2] / 4;
    z[i + 3] = z[i + 3] - g[i + 3] / 4;
    z[i + 4] = z[i + 4] - g[i + 4] / 4;
  }
  for (i = 0; i < nn; i++) {
    if (z[i] > lambda)
      z[i] = lambda;
    else if (z[i] < -lambda)
      z[i] = -lambda;
  }
  g[0] = z[0] + z[0] - z[1] - Av[0];
  for (i = 1; i < nn - 1; i++) {
    g[i] = -z[i - 1] + z[i] + z[i] - z[i + 1] - Av[i];
  }
  g[nn - 1] = -z[nn - 2] + z[nn - 1] + z[nn - 1] - Av[nn - 1];
  for (iterStep = 1; iterStep <= maxStep; iterStep++) {
    numSpp = numSp;
    numSp = numS;
    numS = supportSet(x, v, z, g, S, lambda, nn);
    for (i = 0; i < nn; i++)
      s[i] = Av[i] - x[i + 1] + x[i];
    Thomas(&temp, z, s, nn);
    for (i = 0; i < nn; i++) {
      if (z[i] > lambda)
        z[i] = lambda;
      else if (z[i] < -lambda)
        z[i] = -lambda;
    }
    g[0] = z[0] + z[0] - z[1] - Av[0];
    for (i = 1; i < nn - 1; i++) {
      g[i] = -z[i - 1] + z[i] + z[i] - z[i + 1] - Av[i];
    }
    g[nn - 1] = -z[nn - 2] + z[nn - 1] + z[nn - 1] - Av[nn - 1];
    m = nn % 5;
    if (m != 0) {
      for (i = 0; i < m; i++)
        z[i] = z[i] - g[i] / 4;
    }
    for (i = m; i < nn; i += 5) {
      z[i] = z[i] - g[i] / 4;
      z[i + 1] = z[i + 1] - g[i + 1] / 4;
      z[i + 2] = z[i + 2] - g[i + 2] / 4;
      z[i + 3] = z[i + 3] - g[i + 3] / 4;
      z[i + 4] = z[i + 4] - g[i + 4] / 4;
    }
    for (i = 0; i < nn; i++) {
      if (z[i] > lambda)
        z[i] = lambda;
      else if (z[i] < -lambda)
        z[i] = -lambda;
    }
    g[0] = z[0] + z[0] - z[1] - Av[0];
    for (i = 1; i < nn - 1; i++) {
      g[i] = -z[i - 1] + z[i] + z[i] - z[i + 1] - Av[i];
    }
    g[nn - 1] = -z[nn - 2] + z[nn - 1] + z[nn - 1] - Av[nn - 1];
    if (iterStep % tau == 0) {
      gappp = gapp;
      gapp = *gap;
      dualityGap2(gap, z, g, s, Av, lambda, nn);
      if (*gap <= tol) {
        tFlag = 1;
        break;
      }
      m = 1;
      if (nn > 1000000)
        m = 5;
      else if (nn > 100000)
        m = 3;
      if (abs(numS - numSp) < m) {
        m = generateSolution(x, z, gap, v, Av, g, s, S, lambda, nn);
        if (*gap < tol) {
          numS = m;
          tFlag = 2;
          break;
        }
        if ((*gap == gappp) && (numS == numSpp)) {
          tFlag = 2;
          break;
        }
      }
    }
  }
  if (tFlag != 2) {
    numS = generateSolution(x, z, gap, v, Av, g, s, S, lambda, nn);
  }
  free(S);
  *activeS = numS;
  return (iterStep);
}


x86 assembly (clang, -O0):
<sfa_one>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa0,%rsp
mov    0x30(%rbp),%eax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%eax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
movsd  %xmm0,-0x38(%rbp)
movsd  %xmm1,-0x40(%rbp)
movl   $0x0,-0x50(%rbp)
mov    0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
movslq 0x10(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1060 <malloc@plt>
mov    %rax,-0x68(%rbp)
movsd  0xe27(%rip),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  0xe22(%rip),%xmm0
movsd  %xmm0,-0x78(%rbp)
movl   $0xffffff9c,-0x7c(%rbp)
movl   $0xffffff38,-0x80(%rbp)
movl   $0xfffffed4,-0x84(%rbp)
mov    -0x10(%rbp),%rax
movsd  0xdf1(%rip),%xmm0
movsd  %xmm0,(%rax)
mov    -0x20(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x20(%rbp),%rax
addsd  (%rax),%xmm0
mov    -0x20(%rbp),%rax
subsd  0x8(%rax),%xmm0
mov    -0x30(%rbp),%rax
subsd  (%rax),%xmm0
mov    0x28(%rbp),%rax
movsd  %xmm0,(%rax)
movl   $0x1,-0x44(%rbp)
mov    -0x44(%rbp),%eax
mov    0x10(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    12d1 <sfa_one+0x161>
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x44(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1243 <sfa_one+0xd3>
mov    -0x20(%rbp),%rax
mov    0x10(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x20(%rbp),%rax
mov    0x10(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    0x10(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    0x10(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
mov    0x10(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x10(%rbp),%eax
mov    $0x5,%ecx
cltd
idiv   %ecx
mov    %edx,-0x4c(%rbp)
cmpl   $0x0,-0x4c(%rbp)
je     13b7 <sfa_one+0x247>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jge    13b2 <sfa_one+0x242>
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  0xc81(%rip),%xmm2
divsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1361 <sfa_one+0x1f1>
jmp    13b7 <sfa_one+0x247>
mov    -0x4c(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    1526 <sfa_one+0x3b6>
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  0xc25(%rip),%xmm2
divsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  0xbe4(%rip),%xmm2
divsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  0xb9e(%rip),%xmm2
divsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  0xb58(%rip),%xmm2
divsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  0xb12(%rip),%xmm2
divsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x5,%eax
mov    %eax,-0x44(%rbp)
jmp    13bd <sfa_one+0x24d>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    15dc <sfa_one+0x46c>
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd -0x38(%rbp),%xmm0
jbe    1568 <sfa_one+0x3f8>
movsd  -0x38(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    15c9 <sfa_one+0x459>
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x38(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
ucomisd %xmm1,%xmm0
jbe    15c4 <sfa_one+0x454>
movsd  -0x38(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    15c9 <sfa_one+0x459>
jmp    15ce <sfa_one+0x45e>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    152d <sfa_one+0x3bd>
mov    -0x20(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x20(%rbp),%rax
addsd  (%rax),%xmm0
mov    -0x20(%rbp),%rax
subsd  0x8(%rax),%xmm0
mov    -0x30(%rbp),%rax
subsd  (%rax),%xmm0
mov    0x28(%rbp),%rax
movsd  %xmm0,(%rax)
movl   $0x1,-0x44(%rbp)
mov    -0x44(%rbp),%eax
mov    0x10(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    169a <sfa_one+0x52a>
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x44(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    160c <sfa_one+0x49c>
mov    -0x20(%rbp),%rax
mov    0x10(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x20(%rbp),%rax
mov    0x10(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    0x10(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    0x10(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
mov    0x10(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x1,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    0x18(%rbp),%eax
jg     1ede <sfa_one+0xd6e>
mov    -0x80(%rbp),%eax
mov    %eax,-0x84(%rbp)
mov    -0x7c(%rbp),%eax
mov    %eax,-0x80(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x28(%rbp),%rsi
mov    -0x20(%rbp),%rdx
mov    0x28(%rbp),%rcx
mov    -0x68(%rbp),%r8
movsd  -0x38(%rbp),%xmm0
mov    0x10(%rbp),%r9d
call   1070 <supportSet@plt>
mov    %eax,-0x7c(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    17ac <sfa_one+0x63c>
mov    -0x30(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1759 <sfa_one+0x5e9>
mov    -0x20(%rbp),%rsi
mov    0x20(%rbp),%rdx
mov    0x10(%rbp),%ecx
lea    -0x60(%rbp),%rdi
call   1090 <Thomas@plt>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    1876 <sfa_one+0x706>
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd -0x38(%rbp),%xmm0
jbe    1802 <sfa_one+0x692>
movsd  -0x38(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1863 <sfa_one+0x6f3>
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x38(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
ucomisd %xmm1,%xmm0
jbe    185e <sfa_one+0x6ee>
movsd  -0x38(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1863 <sfa_one+0x6f3>
jmp    1868 <sfa_one+0x6f8>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    17c7 <sfa_one+0x657>
mov    -0x20(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x20(%rbp),%rax
addsd  (%rax),%xmm0
mov    -0x20(%rbp),%rax
subsd  0x8(%rax),%xmm0
mov    -0x30(%rbp),%rax
subsd  (%rax),%xmm0
mov    0x28(%rbp),%rax
movsd  %xmm0,(%rax)
movl   $0x1,-0x44(%rbp)
mov    -0x44(%rbp),%eax
mov    0x10(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1934 <sfa_one+0x7c4>
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x44(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    18a6 <sfa_one+0x736>
mov    -0x20(%rbp),%rax
mov    0x10(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x20(%rbp),%rax
mov    0x10(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    0x10(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    0x10(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
mov    0x10(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x10(%rbp),%eax
mov    $0x5,%ecx
cltd
idiv   %ecx
mov    %edx,-0x4c(%rbp)
cmpl   $0x0,-0x4c(%rbp)
je     1a1a <sfa_one+0x8aa>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jge    1a15 <sfa_one+0x8a5>
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  0x61e(%rip),%xmm2
divsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    19c4 <sfa_one+0x854>
jmp    1a1a <sfa_one+0x8aa>
mov    -0x4c(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    1b89 <sfa_one+0xa19>
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  0x5c2(%rip),%xmm2
divsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  0x581(%rip),%xmm2
divsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  0x53b(%rip),%xmm2
divsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  0x4f5(%rip),%xmm2
divsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  0x4af(%rip),%xmm2
divsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x5,%eax
mov    %eax,-0x44(%rbp)
jmp    1a20 <sfa_one+0x8b0>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    1c3f <sfa_one+0xacf>
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd -0x38(%rbp),%xmm0
jbe    1bcb <sfa_one+0xa5b>
movsd  -0x38(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1c2c <sfa_one+0xabc>
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x38(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
ucomisd %xmm1,%xmm0
jbe    1c27 <sfa_one+0xab7>
movsd  -0x38(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1c2c <sfa_one+0xabc>
jmp    1c31 <sfa_one+0xac1>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1b90 <sfa_one+0xa20>
mov    -0x20(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x20(%rbp),%rax
addsd  (%rax),%xmm0
mov    -0x20(%rbp),%rax
subsd  0x8(%rax),%xmm0
mov    -0x30(%rbp),%rax
subsd  (%rax),%xmm0
mov    0x28(%rbp),%rax
movsd  %xmm0,(%rax)
movl   $0x1,-0x44(%rbp)
mov    -0x44(%rbp),%eax
mov    0x10(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1cfd <sfa_one+0xb8d>
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x44(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1c6f <sfa_one+0xaff>
mov    -0x20(%rbp),%rax
mov    0x10(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x20(%rbp),%rax
mov    0x10(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    0x10(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    0x10(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
mov    0x10(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x48(%rbp),%eax
cltd
idivl  0x30(%rbp)
cmp    $0x0,%edx
jne    1ecb <sfa_one+0xd5b>
movsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x10(%rbp),%rdi
mov    -0x20(%rbp),%rsi
mov    0x28(%rbp),%rdx
mov    0x20(%rbp),%rcx
mov    -0x30(%rbp),%r8
movsd  -0x38(%rbp),%xmm0
mov    0x10(%rbp),%r9d
call   1050 <dualityGap2@plt>
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm1
movsd  -0x40(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jb     1dda <sfa_one+0xc6a>
movl   $0x1,-0x50(%rbp)
jmp    1ede <sfa_one+0xd6e>
movl   $0x1,-0x4c(%rbp)
cmpl   $0xf4240,0x10(%rbp)
jle    1dfa <sfa_one+0xc8a>
movl   $0x5,-0x4c(%rbp)
jmp    1e13 <sfa_one+0xca3>
cmpl   $0x186a0,0x10(%rbp)
jle    1e0e <sfa_one+0xc9e>
movl   $0x3,-0x4c(%rbp)
jmp    1e13 <sfa_one+0xca3>
mov    -0x7c(%rbp),%edi
sub    -0x80(%rbp),%edi
call   1040 <abs@plt>
cmp    -0x4c(%rbp),%eax
jge    1ec6 <sfa_one+0xd56>
mov    -0x8(%rbp),%rdi
mov    -0x20(%rbp),%rsi
mov    -0x10(%rbp),%rdx
mov    -0x28(%rbp),%rcx
mov    -0x30(%rbp),%r8
mov    0x28(%rbp),%r9
mov    0x20(%rbp),%r11
mov    -0x68(%rbp),%r10
movsd  -0x38(%rbp),%xmm0
mov    0x10(%rbp),%eax
mov    %r11,(%rsp)
mov    %r10,0x8(%rsp)
mov    %eax,0x10(%rsp)
call   1080 <generateSolution@plt>
mov    %eax,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm1
movsd  -0x40(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    1e8d <sfa_one+0xd1d>
mov    -0x4c(%rbp),%eax
mov    %eax,-0x7c(%rbp)
movl   $0x2,-0x50(%rbp)
jmp    1ede <sfa_one+0xd6e>
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
ucomisd -0x78(%rbp),%xmm0
jne    1ec1 <sfa_one+0xd51>
jp     1ec1 <sfa_one+0xd51>
mov    -0x7c(%rbp),%eax
cmp    -0x84(%rbp),%eax
jne    1ec1 <sfa_one+0xd51>
movl   $0x2,-0x50(%rbp)
jmp    1ede <sfa_one+0xd6e>
jmp    1ec6 <sfa_one+0xd56>
jmp    1ecb <sfa_one+0xd5b>
jmp    1ed0 <sfa_one+0xd60>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1712 <sfa_one+0x5a2>
cmpl   $0x2,-0x50(%rbp)
je     1f25 <sfa_one+0xdb5>
mov    -0x8(%rbp),%rdi
mov    -0x20(%rbp),%rsi
mov    -0x10(%rbp),%rdx
mov    -0x28(%rbp),%rcx
mov    -0x30(%rbp),%r8
mov    0x28(%rbp),%r9
mov    0x20(%rbp),%r11
mov    -0x68(%rbp),%r10
movsd  -0x38(%rbp),%xmm0
mov    0x10(%rbp),%eax
mov    %r11,(%rsp)
mov    %r10,0x8(%rsp)
mov    %eax,0x10(%rsp)
call   1080 <generateSolution@plt>
mov    %eax,-0x7c(%rbp)
mov    -0x68(%rbp),%rdi
call   1030 <free@plt>
mov    -0x7c(%rbp),%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x48(%rbp),%eax
add    $0xa0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<sfa_one>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x148,%rsp
movsd  %xmm1,0xc0(%rsp)
movaps %xmm0,0x60(%rsp)
mov    %r9,%r13
mov    %r8,0x90(%rsp)
mov    %rcx,%rbp
mov    %rdx,0x78(%rsp)
mov    %rsi,%r12
mov    %rdi,%r15
mov    0x198(%rsp),%r14
mov    0x180(%rsp),%ebx
lea    0x0(,%rbx,4),%edi
call   1050 <malloc@plt>
mov    %rbx,%r10
mov    %rax,0x38(%rsp)
movabs $0xbff0000000000000,%rax
mov    %r12,0x80(%rsp)
mov    %rax,(%r12)
movsd  0x0(%rbp),%xmm0
addsd  %xmm0,%xmm0
subsd  0x8(%rbp),%xmm0
subsd  0x0(%r13),%xmm0
movsd  %xmm0,(%r14)
lea    -0x1(%rbx),%eax
mov    %eax,%r12d
cmp    $0x3,%r10d
jl     1394 <sfa_one+0x234>
lea    -0x1(%r12),%r8
mov    $0x1,%ecx
cmp    $0x4,%r8
jae    12b0 <sfa_one+0x150>
mov    %rcx,%rdx
not    %rdx
test   $0x1,%r12b
jne    1245 <sfa_one+0xe5>
movsd  0x0(%rbp,%rcx,8),%xmm0
movapd %xmm0,%xmm1
subsd  -0x8(%rbp,%rcx,8),%xmm1
addsd  %xmm0,%xmm1
subsd  0x8(%rbp,%rcx,8),%xmm1
subsd  0x0(%r13,%rcx,8),%xmm1
movsd  %xmm1,(%r14,%rcx,8)
add    $0x1,%rcx
add    %r12,%rdx
je     1394 <sfa_one+0x234>
xchg   %ax,%ax
movsd  0x0(%rbp,%rcx,8),%xmm0
movapd %xmm0,%xmm1
subsd  -0x8(%rbp,%rcx,8),%xmm1
addsd  %xmm0,%xmm1
subsd  0x8(%rbp,%rcx,8),%xmm1
subsd  0x0(%r13,%rcx,8),%xmm1
movsd  %xmm1,(%r14,%rcx,8)
movsd  0x8(%rbp,%rcx,8),%xmm0
movapd %xmm0,%xmm1
subsd  0x0(%rbp,%rcx,8),%xmm1
addsd  %xmm0,%xmm1
subsd  0x10(%rbp,%rcx,8),%xmm1
subsd  0x8(%r13,%rcx,8),%xmm1
movsd  %xmm1,0x8(%r14,%rcx,8)
lea    0x2(%rcx),%rdx
mov    %rdx,%rcx
cmp    %rdx,%r12
jne    1250 <sfa_one+0xf0>
jmp    1394 <sfa_one+0x234>
lea    0x8(%r14),%rdx
lea    (%r14,%r12,8),%rsi
lea    0x8(,%r12,8),%rdi
add    %rbp,%rdi
lea    0x8(%r13),%r9
lea    0x0(,%r12,8),%r10
add    %r13,%r10
cmp    %rdi,%rdx
setb   %dil
cmp    %rbp,%rsi
seta   %r11b
cmp    %r10,%rdx
setb   %dl
cmp    %rsi,%r9
setb   %sil
test   %r11b,%dil
jne    2805 <sfa_one+0x16a5>
and    %sil,%dl
mov    0x180(%rsp),%r10d
jne    120e <sfa_one+0xae>
mov    %r8,%rsi
and    $0xfffffffffffffffc,%rsi
lea    0x1(%rsi),%rcx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movupd 0x0(%rbp,%rdi,8),%xmm0
movupd 0x8(%rbp,%rdi,8),%xmm1
movupd 0x10(%rbp,%rdi,8),%xmm2
movupd 0x18(%rbp,%rdi,8),%xmm3
movapd %xmm1,%xmm4
subpd  %xmm0,%xmm4
movapd %xmm3,%xmm0
subpd  %xmm2,%xmm0
addpd  %xmm1,%xmm4
addpd  %xmm3,%xmm0
movupd 0x20(%rbp,%rdi,8),%xmm1
subpd  %xmm1,%xmm0
subpd  %xmm2,%xmm4
movupd 0x8(%r13,%rdi,8),%xmm1
subpd  %xmm1,%xmm4
movupd 0x18(%r13,%rdi,8),%xmm1
subpd  %xmm1,%xmm0
movupd %xmm4,0x8(%r14,%rdi,8)
movupd %xmm0,0x18(%r14,%rdi,8)
add    $0x4,%rdi
cmp    %rdi,%rsi
jne    1320 <sfa_one+0x1c0>
cmp    %rsi,%r8
jne    120e <sfa_one+0xae>
movslq %r10d,%rdx
movslq %eax,%rbx
movsd  0x0(%rbp,%rbx,8),%xmm0
movapd %xmm0,%xmm1
subsd  -0x10(%rbp,%rdx,8),%xmm1
addsd  %xmm0,%xmm1
subsd  0x0(%r13,%rbx,8),%xmm1
movsd  %xmm1,(%r14,%rbx,8)
imul   $0x66666667,%rdx,%rax
mov    %rax,%rcx
shr    $0x3f,%rcx
sar    $0x21,%rax
add    %ecx,%eax
lea    (%rax,%rax,4),%eax
mov    %r10d,%r8d
sub    %eax,%r8d
test   %r8d,%r8d
jle    14ac <sfa_one+0x34c>
movsd  (%r14),%xmm0
mulsd  0x1c12(%rip),%xmm0
addsd  0x0(%rbp),%xmm0
movsd  %xmm0,0x0(%rbp)
cmp    $0x1,%r8d
je     14ac <sfa_one+0x34c>
movsd  0x8(%r14),%xmm0
mulsd  0x1bf0(%rip),%xmm0
addsd  0x8(%rbp),%xmm0
movsd  %xmm0,0x8(%rbp)
cmp    $0x2,%r8d
je     14ac <sfa_one+0x34c>
movsd  0x10(%r14),%xmm0
mulsd  0x1bce(%rip),%xmm0
addsd  0x10(%rbp),%xmm0
movsd  %xmm0,0x10(%rbp)
cmp    $0x3,%r8d
je     14ac <sfa_one+0x34c>
movsd  0x18(%r14),%xmm0
mulsd  0x1bb0(%rip),%xmm0
addsd  0x18(%rbp),%xmm0
movsd  %xmm0,0x18(%rbp)
cmp    $0x4,%r8d
je     14ac <sfa_one+0x34c>
movsd  0x1ba0(%rip),%xmm0
movsd  0x20(%r14),%xmm1
mulsd  %xmm0,%xmm1
movsd  0x20(%rbp),%xmm2
subsd  %xmm1,%xmm2
movsd  0x28(%rbp),%xmm1
movsd  %xmm2,0x20(%rbp)
movsd  0x28(%r14),%xmm2
mulsd  %xmm0,%xmm2
subsd  %xmm2,%xmm1
movsd  %xmm1,0x28(%rbp)
movsd  0x30(%rbp),%xmm1
mulsd  0x30(%r14),%xmm0
subsd  %xmm0,%xmm1
movsd  %xmm1,0x30(%rbp)
movabs $0xcccccccccccccccd,%r11
cc cc cc
cmp    %r10d,%r8d
movapd 0x60(%rsp),%xmm9
mov    %rdx,0x28(%rsp)
jge    15d3 <sfa_one+0x473>
movslq %r8d,%rsi
mov    %rsi,%rdi
not    %rdi
add    %rdx,%rdi
mov    %rdi,%rax
mul    %r11
cmp    $0x5,%rdi
jb     152b <sfa_one+0x3cb>
mov    %rdx,%r9
lea    0x0(,%rsi,8),%rcx
add    %rbp,%rcx
mov    %rdi,%rax
mul    %r11
shr    $0x2,%rdx
lea    (%rdx,%rdx,4),%rax
add    %rsi,%rax
lea    (%r14,%rax,8),%rdx
add    $0x28,%rdx
cmp    %rdx,%rcx
jae    26b0 <sfa_one+0x1550>
lea    0x28(,%rax,8),%rax
add    %rbp,%rax
lea    (%r14,%rsi,8),%rcx
cmp    %rax,%rcx
jae    26b0 <sfa_one+0x1550>
mov    %rsi,%rax
mov    0x28(%rsp),%rdx
movsd  0x1acd(%rip),%xmm0
nopl   0x0(%rax,%rax,1)
movsd  (%r14,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  0x0(%rbp,%rax,8),%xmm2
subsd  %xmm1,%xmm2
movsd  0x8(%rbp,%rax,8),%xmm1
movsd  %xmm2,0x0(%rbp,%rax,8)
movsd  0x8(%r14,%rax,8),%xmm2
mulsd  %xmm0,%xmm2
subsd  %xmm2,%xmm1
movsd  %xmm1,0x8(%rbp,%rax,8)
movsd  0x10(%rbp,%rax,8),%xmm1
movsd  0x10(%r14,%rax,8),%xmm2
mulsd  %xmm0,%xmm2
subsd  %xmm2,%xmm1
movsd  %xmm1,0x10(%rbp,%rax,8)
movsd  0x18(%rbp,%rax,8),%xmm1
movsd  0x18(%r14,%rax,8),%xmm2
mulsd  %xmm0,%xmm2
subsd  %xmm2,%xmm1
movsd  %xmm1,0x18(%rbp,%rax,8)
movsd  0x20(%rbp,%rax,8),%xmm1
movsd  0x20(%r14,%rax,8),%xmm2
mulsd  %xmm0,%xmm2
subsd  %xmm2,%xmm1
movsd  %xmm1,0x20(%rbp,%rax,8)
add    $0x5,%rax
cmp    %rdx,%rax
jl     1540 <sfa_one+0x3e0>
mov    %r10d,%eax
mov    %rax,0x40(%rsp)
test   %r10d,%r10d
jle    1622 <sfa_one+0x4c2>
movapd 0x1a48(%rip),%xmm0
xorpd  %xmm9,%xmm0
cmp    $0x1,%r10d
jne    1720 <sfa_one+0x5c0>
xor    %eax,%eax
testb  $0x1,0x40(%rsp)
je     1622 <sfa_one+0x4c2>
movsd  0x0(%rbp,%rax,8),%xmm2
ucomisd %xmm9,%xmm2
movapd %xmm9,%xmm1
ja     161c <sfa_one+0x4bc>
ucomisd %xmm2,%xmm0
movapd %xmm0,%xmm1
jbe    1622 <sfa_one+0x4c2>
movsd  %xmm1,0x0(%rbp,%rax,8)
mov    0x188(%rsp),%esi
lea    -0x2(%rdx),%rax
mov    %rax,0xa0(%rsp)
movsd  0x0(%rbp),%xmm0
addsd  %xmm0,%xmm0
subsd  0x8(%rbp),%xmm0
subsd  0x0(%r13),%xmm0
movsd  %xmm0,(%r14)
cmp    $0x3,%r10d
mov    %r12,0x18(%rsp)
mov    %r8d,0x24(%rsp)
jl     1890 <sfa_one+0x730>
lea    -0x1(%r12),%r9
mov    $0x1,%eax
cmp    $0x4,%r9
jae    1783 <sfa_one+0x623>
mov    %rax,%rcx
not    %rcx
test   $0x1,%r12b
jne    16ad <sfa_one+0x54d>
movsd  0x0(%rbp,%rax,8),%xmm0
movapd %xmm0,%xmm1
subsd  -0x8(%rbp,%rax,8),%xmm1
addsd  %xmm0,%xmm1
subsd  0x8(%rbp,%rax,8),%xmm1
subsd  0x0(%r13,%rax,8),%xmm1
movsd  %xmm1,(%r14,%rax,8)
add    $0x1,%rax
add    %r12,%rcx
je     1890 <sfa_one+0x730>
cs nopw 0x0(%rax,%rax,1)
movsd  0x0(%rbp,%rax,8),%xmm0
movapd %xmm0,%xmm1
subsd  -0x8(%rbp,%rax,8),%xmm1
addsd  %xmm0,%xmm1
subsd  0x8(%rbp,%rax,8),%xmm1
subsd  0x0(%r13,%rax,8),%xmm1
movsd  %xmm1,(%r14,%rax,8)
movsd  0x8(%rbp,%rax,8),%xmm0
movapd %xmm0,%xmm1
subsd  0x0(%rbp,%rax,8),%xmm1
addsd  %xmm0,%xmm1
subsd  0x10(%rbp,%rax,8),%xmm1
subsd  0x8(%r13,%rax,8),%xmm1
movsd  %xmm1,0x8(%r14,%rax,8)
lea    0x2(%rax),%rcx
mov    %rcx,%rax
cmp    %rcx,%r12
jne    16c0 <sfa_one+0x560>
jmp    1890 <sfa_one+0x730>
mov    0x40(%rsp),%rcx
and    $0xfffffffe,%ecx
xor    %eax,%eax
jmp    1743 <sfa_one+0x5e3>
nopl   0x0(%rax)
movsd  %xmm1,0x8(%rbp,%rax,8)
add    $0x2,%rax
cmp    %rax,%rcx
je     15f9 <sfa_one+0x499>
movsd  0x0(%rbp,%rax,8),%xmm2
ucomisd %xmm9,%xmm2
movapd %xmm9,%xmm1
ja     175f <sfa_one+0x5ff>
ucomisd %xmm2,%xmm0
movapd %xmm0,%xmm1
jbe    1765 <sfa_one+0x605>
movsd  %xmm1,0x0(%rbp,%rax,8)
movsd  0x8(%rbp,%rax,8),%xmm2
ucomisd %xmm9,%xmm2
movapd %xmm9,%xmm1
ja     1730 <sfa_one+0x5d0>
ucomisd %xmm2,%xmm0
movapd %xmm0,%xmm1
ja     1730 <sfa_one+0x5d0>
jmp    1736 <sfa_one+0x5d6>
lea    0x8(%r14),%rcx
lea    (%r14,%r12,8),%rsi
lea    0x8(,%r12,8),%rdx
add    %rbp,%rdx
lea    0x8(%r13),%r10
lea    0x0(,%r12,8),%rdi
add    %r13,%rdi
cmp    %rdx,%rcx
setb   %r11b
cmp    %rbp,%rsi
seta   %r12b
cmp    %rdi,%rcx
setb   %dl
cmp    %rsi,%r10
setb   %cl
test   %r12b,%r11b
jne    2812 <sfa_one+0x16b2>
and    %cl,%dl
mov    0x180(%rsp),%r10d
mov    0x18(%rsp),%r12
mov    0x28(%rsp),%rdx
mov    0x24(%rsp),%r8d
mov    0x188(%rsp),%esi
movabs $0xcccccccccccccccd,%r11
cc cc cc
jne    1676 <sfa_one+0x516>
mov    %r9,%rdx
and    $0xfffffffffffffffc,%rdx
lea    0x1(%rdx),%rax
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nop
movupd 0x0(%rbp,%rsi,8),%xmm0
movupd 0x8(%rbp,%rsi,8),%xmm1
movupd 0x10(%rbp,%rsi,8),%xmm2
movupd 0x18(%rbp,%rsi,8),%xmm3
movapd %xmm1,%xmm4
subpd  %xmm0,%xmm4
movapd %xmm3,%xmm0
subpd  %xmm2,%xmm0
addpd  %xmm1,%xmm4
addpd  %xmm3,%xmm0
movupd 0x20(%rbp,%rsi,8),%xmm1
subpd  %xmm1,%xmm0
subpd  %xmm2,%xmm4
movupd 0x8(%r13,%rsi,8),%xmm1
subpd  %xmm1,%xmm4
movupd 0x18(%r13,%rsi,8),%xmm1
subpd  %xmm1,%xmm0
movupd %xmm4,0x8(%r14,%rsi,8)
movupd %xmm0,0x18(%r14,%rsi,8)
add    $0x4,%rsi
cmp    %rsi,%rdx
jne    1810 <sfa_one+0x6b0>
cmp    %rdx,%r9
mov    0x28(%rsp),%rdx
mov    0x188(%rsp),%esi
jne    1676 <sfa_one+0x516>
mov    %r11,%rdi
mov    0x190(%rsp),%r11
movsd  0x0(%rbp,%rbx,8),%xmm0
movapd %xmm0,%xmm1
mov    0xa0(%rsp),%rax
subsd  0x0(%rbp,%rax,8),%xmm1
addsd  %xmm0,%xmm1
subsd  0x0(%r13,%rbx,8),%xmm1
movsd  %xmm1,(%r14,%rbx,8)
test   %esi,%esi
jle    2621 <sfa_one+0x14c1>
mov    %rbx,0xe0(%rsp)
movslq %r8d,%r9
movapd 0x1750(%rip),%xmm8
xorpd  %xmm9,%xmm8
xor    %eax,%eax
cmp    $0x186a1,%r10d
setge  %al
cmp    $0xf4241,%r10d
lea    0x1(%rax,%rax,1),%eax
mov    $0x5,%ecx
cmovl  %eax,%ecx
mov    %ecx,0xac(%rsp)
lea    0x8(%r14),%r10
mov    0x18(%rsp),%rax
lea    (%r14,%rax,8),%r12
mov    0x18(%rsp),%rax
lea    0x8(%rbp,%rax,8),%rax
mov    %rax,0x48(%rsp)
lea    0x8(%r13),%rax
mov    %rax,0x10(%rsp)
mov    0x18(%rsp),%rax
lea    0x0(%r13,%rax,8),%rax
mov    %rax,0x30(%rsp)
mov    %r9,%rax
not    %rax
add    %rdx,%rax
mov    %rax,0x118(%rsp)
mul    %rdi
mov    %rdx,%rax
shr    $0x2,%rax
lea    (%rax,%rax,4),%rsi
add    %r9,%rsi
add    $0x1,%rax
mov    0x40(%rsp),%r8
lea    (%r11,%r8,8),%rdx
lea    0x0(,%r8,8),%rdi
add    %r13,%rdi
cmp    %r11,%rdi
seta   %bl
lea    (%r15,%r8,8),%rdi
add    $0x8,%rdi
cmp    %r13,%rdx
seta   %cl
and    %bl,%cl
cmp    %r11,%rdi
seta   %dil
cmp    %r15,%rdx
seta   %dl
and    %dil,%dl
or     %cl,%dl
mov    %dl,0xf(%rsp)
mov    %r8d,%ecx
and    $0xfffffffc,%ecx
mov    %rcx,0x110(%rsp)
mov    %r8d,%ecx
and    $0xfffffffe,%ecx
mov    %rcx,0xd0(%rsp)
cmp    0x48(%rsp),%r10
setb   %r11b
cmp    %rbp,%r12
seta   %dl
mov    0x18(%rsp),%rdi
lea    -0x1(%rdi),%rcx
and    %r11b,%dl
lea    0x0(,%r9,8),%rdi
add    %rbp,%rdi
mov    %rdi,0x48(%rsp)
cmp    0x30(%rsp),%r10
mov    0x180(%rsp),%r10d
lea    0x28(%rbp,%rsi,8),%rdi
mov    %rdi,0x30(%rsp)
setb   %dil
cmp    %r12,0x10(%rsp)
mov    0x18(%rsp),%r12
lea    (%r14,%r9,8),%rbx
mov    %rbx,0x10(%rsp)
lea    0x28(%r14,%rsi,8),%rsi
setb   %r11b
and    %dil,%r11b
or     %dl,%r11b
mov    %r11b,0xd(%rsp)
mov    %rcx,0x58(%rsp)
mov    %rcx,%rdx
and    $0xfffffffffffffffc,%rdx
mov    %r12,%rcx
neg    %rcx
mov    %rcx,0xc8(%rsp)
cmp    %rsi,0x48(%rsp)
setb   %sil
mov    0x10(%rsp),%rcx
cmp    0x30(%rsp),%rcx
setb   %cl
and    %sil,%cl
mov    %cl,0xe(%rsp)
mov    %rax,0x100(%rsp)
and    $0xfffffffffffffffe,%rax
mov    %rax,0xb8(%rsp)
lea    (%rax,%rax,4),%rax
add    %r9,%rax
mov    %rax,0xf8(%rsp)
lea    0x0(,%r8,8),%rax
and    $0xffffffffffffffe0,%rax
mov    %rax,0x108(%rsp)
movsd  0x156c(%rip),%xmm0
mov    0x188(%rsp),%eax
add    $0x1,%eax
mov    %eax,0xa8(%rsp)
lea    -0x1(%r8),%rax
mov    %rax,0x98(%rsp)
mov    %rdx,0xd8(%rsp)
lea    0x1(%rdx),%rax
mov    %rax,0xb0(%rsp)
mov    %r9,0x120(%rsp)
lea    0x0(,%r9,8),%rax
mov    %rax,0xf0(%rsp)
mov    $0x1,%eax
mov    $0xffffff9c,%edx
movl   $0xffffff38,0x54(%rsp)
ff
movapd %xmm8,0x130(%rsp)
jmp    1b7a <sfa_one+0xa1a>
nopl   0x0(%rax,%rax,1)
movsd  0x0(%rbp,%r8,8),%xmm0
movapd %xmm0,%xmm1
mov    0xa0(%rsp),%rax
subsd  0x0(%rbp,%rax,8),%xmm1
addsd  %xmm0,%xmm1
subsd  0x0(%r13,%r8,8),%xmm1
movsd  %xmm1,(%r14,%r8,8)
mov    0x10(%rsp),%rsi
mov    %esi,%eax
cltd
idivl  0x1a0(%rsp)
test   %edx,%edx
je     1bf0 <sfa_one+0xa90>
movsd  0xe8(%rsp),%xmm0
mov    0x188(%rsp),%ecx
mov    0x30(%rsp),%edx
mov    0x48(%rsp),%ebx
lea    0x1(%rsi),%eax
mov    %edx,0x54(%rsp)
mov    %ebx,%edx
cmp    %ecx,%esi
je     2628 <sfa_one+0x14c8>
movsd  %xmm0,0xe8(%rsp)
mov    %edx,0x30(%rsp)
mov    %rax,0x10(%rsp)
mov    %r15,%rdi
mov    0x90(%rsp),%rsi
mov    %rbp,%rdx
mov    %r14,%rcx
mov    0x38(%rsp),%r8
movapd %xmm9,%xmm0
mov    %r10d,%r9d
call   1060 <supportSet@plt>
mov    0x180(%rsp),%ecx
test   %ecx,%ecx
mov    %eax,0x48(%rsp)
jle    1d10 <sfa_one+0xbb0>
cmp    $0x4,%ecx
setb   %dl
or     0xf(%rsp),%dl
mov    0x190(%rsp),%rdx
je     1d80 <sfa_one+0xc20>
xor    %r8d,%r8d
mov    0x40(%rsp),%rsi
jmp    1df2 <sfa_one+0xc92>
nopw   0x0(%rax,%rax,1)
mov    0x80(%rsp),%r12
movsd  (%r12),%xmm0
movsd  %xmm0,0x88(%rsp)
mov    %r12,%rdi
mov    %rbp,%rsi
mov    %r14,%rdx
mov    0x190(%rsp),%rcx
mov    %r13,%r8
movapd %xmm9,%xmm0
mov    %r10d,%r9d
call   1040 <dualityGap2@plt>
movsd  0xc0(%rsp),%xmm0
ucomisd (%r12),%xmm0
jae    269b <sfa_one+0x153b>
mov    0x48(%rsp),%ebx
mov    %ebx,%eax
mov    0x30(%rsp),%edx
sub    %edx,%eax
mov    %eax,%ecx
neg    %ecx
cmovs  %eax,%ecx
cmp    0xac(%rsp),%ecx
jae    1f43 <sfa_one+0xde3>
sub    $0x8,%rsp
mov    %r15,%rdi
mov    %rbp,%rsi
mov    0x88(%rsp),%r12
mov    %r12,%rdx
mov    0x98(%rsp),%rcx
mov    %r13,%r8
mov    %r14,%r9
movaps 0x68(%rsp),%xmm0
mov    0x188(%rsp),%eax
push   %rax
push   0x48(%rsp)
push   0x1a8(%rsp)
call   1070 <generateSolution@plt>
add    $0x20,%rsp
movsd  (%r12),%xmm0
movsd  0xc0(%rsp),%xmm1
ucomisd %xmm0,%xmm1
ja     27e3 <sfa_one+0x1683>
ucomisd 0xe8(%rsp),%xmm0
mov    0x18(%rsp),%r12
mov    0x188(%rsp),%ecx
mov    0x10(%rsp),%rsi
jne    2600 <sfa_one+0x14a0>
jp     2600 <sfa_one+0x14a0>
mov    0x54(%rsp),%eax
cmp    %eax,%ebx
movapd 0x60(%rsp),%xmm9
mov    0x180(%rsp),%r10d
mov    0x30(%rsp),%edx
movsd  0x88(%rsp),%xmm0
jne    1b69 <sfa_one+0xa09>
jmp    27f4 <sfa_one+0x1694>
nopl   (%rax)
lea    0x128(%rsp),%rdi
mov    %rbp,%rsi
mov    0x190(%rsp),%rdx
call   1080 <Thomas@plt>
mov    0x180(%rsp),%r10d
movapd 0x60(%rsp),%xmm9
mov    0x28(%rsp),%rdx
mov    0xe0(%rsp),%r8
mov    0x24(%rsp),%edi
movapd 0x130(%rsp),%xmm8
mov    0xd8(%rsp),%rsi
movsd  0x12a5(%rip),%xmm10
movapd 0x12b4(%rip),%xmm11
mov    0xd0(%rsp),%rbx
jmp    1fa0 <sfa_one+0xe40>
nopl   0x0(%rax)
xor    %edi,%edi
mov    0x108(%rsp),%rsi
nopw   0x0(%rax,%rax,1)
movupd 0x0(%r13,%rdi,1),%xmm0
movupd 0x10(%r13,%rdi,1),%xmm1
movupd (%r15,%rdi,1),%xmm2
movupd 0x8(%r15,%rdi,1),%xmm3
subpd  %xmm3,%xmm0
addpd  %xmm2,%xmm0
movupd 0x10(%r15,%rdi,1),%xmm2
movupd 0x18(%r15,%rdi,1),%xmm3
subpd  %xmm3,%xmm1
addpd  %xmm2,%xmm1
movupd %xmm0,(%rdx,%rdi,1)
movupd %xmm1,0x10(%rdx,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%rsi
jne    1d90 <sfa_one+0xc30>
mov    0x110(%rsp),%rdi
mov    %rdi,%r8
mov    0x40(%rsp),%rsi
cmp    %rsi,%rdi
je     1e70 <sfa_one+0xd10>
mov    %r8,%rdi
test   $0x1,%sil
je     1e1b <sfa_one+0xcbb>
movsd  0x0(%r13,%r8,8),%xmm0
mov    %r8,%rdi
or     $0x1,%rdi
subsd  (%r15,%rdi,8),%xmm0
addsd  (%r15,%r8,8),%xmm0
movsd  %xmm0,(%rdx,%r8,8)
cmp    %r8,0x98(%rsp)
je     1e70 <sfa_one+0xd10>
cs nopw 0x0(%rax,%rax,1)
nop
movsd  0x0(%r13,%rdi,8),%xmm0
subsd  0x8(%r15,%rdi,8),%xmm0
addsd  (%r15,%rdi,8),%xmm0
movsd  %xmm0,(%rdx,%rdi,8)
movsd  0x8(%r13,%rdi,8),%xmm0
subsd  0x10(%r15,%rdi,8),%xmm0
addsd  0x8(%r15,%rdi,8),%xmm0
movsd  %xmm0,0x8(%rdx,%rdi,8)
lea    0x2(%rdi),%rbx
mov    %rbx,%rdi
cmp    %rbx,%rsi
jne    1e30 <sfa_one+0xcd0>
lea    0x128(%rsp),%rdi
mov    %rbp,%rsi
call   1080 <Thomas@plt>
mov    0x180(%rsp),%r10d
test   %r10d,%r10d
movapd 0x60(%rsp),%xmm9
mov    0x28(%rsp),%rdx
mov    0xe0(%rsp),%r8
mov    0x24(%rsp),%edi
movapd 0x130(%rsp),%xmm8
mov    0xd8(%rsp),%rsi
movsd  0x114a(%rip),%xmm10
movapd 0x1159(%rip),%xmm11
mov    0xd0(%rsp),%rbx
jle    1fa0 <sfa_one+0xe40>
cmpq   $0x0,0x98(%rsp)
je     1f71 <sfa_one+0xe11>
xor    %eax,%eax
jmp    1eff <sfa_one+0xd9f>
nopl   0x0(%rax,%rax,1)
movsd  %xmm0,0x8(%rbp,%rax,8)
add    $0x2,%rax
cmp    %rax,%rbx
je     1f73 <sfa_one+0xe13>
movsd  0x0(%rbp,%rax,8),%xmm1
ucomisd %xmm9,%xmm1
movapd %xmm9,%xmm0
ja     1f1d <sfa_one+0xdbd>
ucomisd %xmm1,%xmm8
movapd %xmm8,%xmm0
jbe    1f23 <sfa_one+0xdc3>
movsd  %xmm0,0x0(%rbp,%rax,8)
movsd  0x8(%rbp,%rax,8),%xmm1
ucomisd %xmm9,%xmm1
movapd %xmm9,%xmm0
ja     1ef0 <sfa_one+0xd90>
ucomisd %xmm1,%xmm8
movapd %xmm8,%xmm0
ja     1ef0 <sfa_one+0xd90>
jmp    1ef6 <sfa_one+0xd96>
movapd 0x60(%rsp),%xmm9
mov    0x180(%rsp),%r10d
mov    0x18(%rsp),%r12
mov    0x188(%rsp),%ecx
mov    0x10(%rsp),%rsi
movsd  0x88(%rsp),%xmm0
jmp    1b69 <sfa_one+0xa09>
xor    %eax,%eax
testb  $0x1,0x40(%rsp)
je     1fa0 <sfa_one+0xe40>
movsd  0x0(%rbp,%rax,8),%xmm1
ucomisd %xmm9,%xmm1
movapd %xmm9,%xmm0
ja     1f98 <sfa_one+0xe38>
ucomisd %xmm1,%xmm8
movapd %xmm8,%xmm0
jbe    1fa0 <sfa_one+0xe40>
movsd  %xmm0,0x0(%rbp,%rax,8)
xchg   %ax,%ax
movsd  0x0(%rbp),%xmm0
addsd  %xmm0,%xmm0
subsd  0x8(%rbp),%xmm0
subsd  0x0(%r13),%xmm0
movsd  %xmm0,(%r14)
cmp    $0x3,%r10d
jl     2100 <sfa_one+0xfa0>
cmpq   $0x4,0x58(%rsp)
setb   %al
or     0xd(%rsp),%al
mov    $0x1,%ecx
jne    205e <sfa_one+0xefe>
xor    %eax,%eax
nopl   (%rax)
movupd 0x0(%rbp,%rax,8),%xmm0
movupd 0x8(%rbp,%rax,8),%xmm1
movupd 0x10(%rbp,%rax,8),%xmm2
movupd 0x18(%rbp,%rax,8),%xmm3
movapd %xmm1,%xmm4
subpd  %xmm0,%xmm4
movapd %xmm3,%xmm0
subpd  %xmm2,%xmm0
addpd  %xmm1,%xmm4
addpd  %xmm3,%xmm0
movupd 0x20(%rbp,%rax,8),%xmm1
subpd  %xmm1,%xmm0
subpd  %xmm2,%xmm4
movupd 0x8(%r13,%rax,8),%xmm1
subpd  %xmm1,%xmm4
movupd 0x18(%r13,%rax,8),%xmm1
subpd  %xmm1,%xmm0
movupd %xmm4,0x8(%r14,%rax,8)
movupd %xmm0,0x18(%r14,%rax,8)
add    $0x4,%rax
cmp    %rax,%rsi
jne    1fe0 <sfa_one+0xe80>
mov    0xb0(%rsp),%rcx
cmp    %rsi,0x58(%rsp)
je     2100 <sfa_one+0xfa0>
mov    %rcx,%rax
test   $0x1,%r12b
jne    2092 <sfa_one+0xf32>
movsd  0x0(%rbp,%rcx,8),%xmm0
movapd %xmm0,%xmm1
subsd  -0x8(%rbp,%rcx,8),%xmm1
addsd  %xmm0,%xmm1
subsd  0x8(%rbp,%rcx,8),%xmm1
lea    0x1(%rcx),%rax
subsd  0x0(%r13,%rcx,8),%xmm1
movsd  %xmm1,(%r14,%rcx,8)
not    %rcx
cmp    0xc8(%rsp),%rcx
je     2100 <sfa_one+0xfa0>
nop
movsd  0x0(%rbp,%rax,8),%xmm0
movapd %xmm0,%xmm1
subsd  -0x8(%rbp,%rax,8),%xmm1
addsd  %xmm0,%xmm1
subsd  0x8(%rbp,%rax,8),%xmm1
subsd  0x0(%r13,%rax,8),%xmm1
movsd  %xmm1,(%r14,%rax,8)
movsd  0x8(%rbp,%rax,8),%xmm0
movapd %xmm0,%xmm1
subsd  0x0(%rbp,%rax,8),%xmm1
addsd  %xmm0,%xmm1
subsd  0x10(%rbp,%rax,8),%xmm1
subsd  0x8(%r13,%rax,8),%xmm1
movsd  %xmm1,0x8(%r14,%rax,8)
lea    0x2(%rax),%rcx
mov    %rcx,%rax
cmp    %rcx,%r12
jne    20a0 <sfa_one+0xf40>
nopl   0x0(%rax,%rax,1)
movsd  0x0(%rbp,%r8,8),%xmm0
movapd %xmm0,%xmm1
mov    0xa0(%rsp),%rax
subsd  0x0(%rbp,%rax,8),%xmm1
addsd  %xmm0,%xmm1
subsd  0x0(%r13,%r8,8),%xmm1
movsd  %xmm1,(%r14,%r8,8)
test   %edi,%edi
jle    2200 <sfa_one+0x10a0>
movsd  (%r14),%xmm0
mulsd  0xec1(%rip),%xmm0
addsd  0x0(%rbp),%xmm0
movsd  %xmm0,0x0(%rbp)
cmp    $0x1,%edi
je     2200 <sfa_one+0x10a0>
movsd  0x8(%r14),%xmm0
mulsd  0xea0(%rip),%xmm0
addsd  0x8(%rbp),%xmm0
movsd  %xmm0,0x8(%rbp)
cmp    $0x2,%edi
je     2200 <sfa_one+0x10a0>
movsd  0x10(%r14),%xmm0
mulsd  0xe7f(%rip),%xmm0
addsd  0x10(%rbp),%xmm0
movsd  %xmm0,0x10(%rbp)
cmp    $0x3,%edi
je     2200 <sfa_one+0x10a0>
movsd  0x18(%r14),%xmm0
mulsd  0xe62(%rip),%xmm0
addsd  0x18(%rbp),%xmm0
movsd  %xmm0,0x18(%rbp)
cmp    $0x4,%edi
je     2200 <sfa_one+0x10a0>
movsd  0x20(%r14),%xmm0
mulsd  %xmm10,%xmm0
movsd  0x20(%rbp),%xmm1
subsd  %xmm0,%xmm1
movsd  0x28(%rbp),%xmm0
movsd  %xmm1,0x20(%rbp)
movsd  0x28(%r14),%xmm1
mulsd  %xmm10,%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,0x28(%rbp)
movsd  0x30(%rbp),%xmm0
movsd  0x30(%r14),%xmm1
mulsd  %xmm10,%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,0x30(%rbp)
nopl   0x0(%rax,%rax,1)
cmp    %r10d,%edi
jge    23e8 <sfa_one+0x1288>
cmpq   $0x5,0x118(%rsp)
setb   %al
or     0xe(%rsp),%al
mov    0x120(%rsp),%rax
jne    2350 <sfa_one+0x11f0>
mov    0xf0(%rsp),%rax
mov    0xb8(%rsp),%rcx
nopw   0x0(%rax,%rax,1)
movsd  0x0(%rbp,%rax,1),%xmm0
movsd  0x8(%rbp,%rax,1),%xmm2
movsd  0x10(%rbp,%rax,1),%xmm1
movsd  0x18(%rbp,%rax,1),%xmm3
movhpd 0x28(%rbp,%rax,1),%xmm0
movsd  (%r14,%rax,1),%xmm4
movsd  0x8(%r14,%rax,1),%xmm5
movsd  0x10(%r14,%rax,1),%xmm6
movsd  0x18(%r14,%rax,1),%xmm7
movhpd 0x28(%r14,%rax,1),%xmm4
mulpd  %xmm11,%xmm4
subpd  %xmm4,%xmm0
movhpd 0x30(%rbp,%rax,1),%xmm2
movhpd 0x30(%r14,%rax,1),%xmm5
mulpd  %xmm11,%xmm5
subpd  %xmm5,%xmm2
movhpd 0x38(%rbp,%rax,1),%xmm1
movhpd 0x38(%r14,%rax,1),%xmm6
mulpd  %xmm11,%xmm6
subpd  %xmm6,%xmm1
movhpd 0x40(%rbp,%rax,1),%xmm3
movhpd 0x40(%r14,%rax,1),%xmm7
mulpd  %xmm11,%xmm7
subpd  %xmm7,%xmm3
movsd  0x20(%rbp,%rax,1),%xmm4
movhpd 0x48(%rbp,%rax,1),%xmm4
movsd  0x20(%r14,%rax,1),%xmm5
movhpd 0x48(%r14,%rax,1),%xmm5
mulpd  %xmm11,%xmm5
subpd  %xmm5,%xmm4
movapd %xmm0,%xmm5
unpcklpd %xmm2,%xmm5
movsd  %xmm4,%xmm0
unpckhpd %xmm1,%xmm2
unpcklpd %xmm3,%xmm1
movhlps %xmm3,%xmm4
movups %xmm4,0x40(%rbp,%rax,1)
movupd %xmm2,0x30(%rbp,%rax,1)
movupd %xmm0,0x20(%rbp,%rax,1)
movupd %xmm1,0x10(%rbp,%rax,1)
movupd %xmm5,0x0(%rbp,%rax,1)
add    $0x50,%rax
add    $0xfffffffffffffffe,%rcx
jne    2240 <sfa_one+0x10e0>
mov    0xf8(%rsp),%rax
mov    0xb8(%rsp),%rcx
cmp    %rcx,0x100(%rsp)
je     23e8 <sfa_one+0x1288>
xchg   %ax,%ax
movsd  (%r14,%rax,8),%xmm0
mulsd  %xmm10,%xmm0
movsd  0x0(%rbp,%rax,8),%xmm1
subsd  %xmm0,%xmm1
movsd  0x8(%rbp,%rax,8),%xmm0
movsd  %xmm1,0x0(%rbp,%rax,8)
movsd  0x8(%r14,%rax,8),%xmm1
mulsd  %xmm10,%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%rbp,%rax,8)
movsd  0x10(%rbp,%rax,8),%xmm0
movsd  0x10(%r14,%rax,8),%xmm1
mulsd  %xmm10,%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,0x10(%rbp,%rax,8)
movsd  0x18(%rbp,%rax,8),%xmm0
movsd  0x18(%r14,%rax,8),%xmm1
mulsd  %xmm10,%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,0x18(%rbp,%rax,8)
movsd  0x20(%rbp,%rax,8),%xmm0
movsd  0x20(%r14,%rax,8),%xmm1
mulsd  %xmm10,%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,0x20(%rbp,%rax,8)
add    $0x5,%rax
cmp    %rdx,%rax
jl     2350 <sfa_one+0x11f0>
test   %r10d,%r10d
jle    248d <sfa_one+0x132d>
cmpq   $0x0,0x98(%rsp)
je     2460 <sfa_one+0x1300>
xor    %eax,%eax
jmp    240f <sfa_one+0x12af>
movsd  %xmm0,0x8(%rbp,%rax,8)
add    $0x2,%rax
cmp    %rax,%rbx
je     2462 <sfa_one+0x1302>
movsd  0x0(%rbp,%rax,8),%xmm1
ucomisd %xmm9,%xmm1
movapd %xmm9,%xmm0
ja     242d <sfa_one+0x12cd>
ucomisd %xmm1,%xmm8
movapd %xmm8,%xmm0
jbe    2433 <sfa_one+0x12d3>
movsd  %xmm0,0x0(%rbp,%rax,8)
movsd  0x8(%rbp,%rax,8),%xmm1
ucomisd %xmm9,%xmm1
movapd %xmm9,%xmm0
ja     2400 <sfa_one+0x12a0>
ucomisd %xmm1,%xmm8
movapd %xmm8,%xmm0
ja     2400 <sfa_one+0x12a0>
jmp    2406 <sfa_one+0x12a6>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
xor    %eax,%eax
testb  $0x1,0x40(%rsp)
je     248d <sfa_one+0x132d>
movsd  0x0(%rbp,%rax,8),%xmm1
ucomisd %xmm9,%xmm1
movapd %xmm9,%xmm0
ja     2487 <sfa_one+0x1327>
ucomisd %xmm1,%xmm8
movapd %xmm8,%xmm0
jbe    248d <sfa_one+0x132d>
movsd  %xmm0,0x0(%rbp,%rax,8)
movsd  0x0(%rbp),%xmm0
addsd  %xmm0,%xmm0
subsd  0x8(%rbp),%xmm0
subsd  0x0(%r13),%xmm0
movsd  %xmm0,(%r14)
cmp    $0x3,%r10d
jl     1b10 <sfa_one+0x9b0>
cmpq   $0x4,0x58(%rsp)
setb   %al
or     0xd(%rsp),%al
mov    $0x1,%ecx
jne    254e <sfa_one+0x13ee>
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
movupd 0x0(%rbp,%rax,8),%xmm0
movupd 0x8(%rbp,%rax,8),%xmm1
movupd 0x10(%rbp,%rax,8),%xmm2
movupd 0x18(%rbp,%rax,8),%xmm3
movapd %xmm1,%xmm4
subpd  %xmm0,%xmm4
movapd %xmm3,%xmm0
subpd  %xmm2,%xmm0
addpd  %xmm1,%xmm4
addpd  %xmm3,%xmm0
movupd 0x20(%rbp,%rax,8),%xmm1
subpd  %xmm1,%xmm0
subpd  %xmm2,%xmm4
movupd 0x8(%r13,%rax,8),%xmm1
subpd  %xmm1,%xmm4
movupd 0x18(%r13,%rax,8),%xmm1
subpd  %xmm1,%xmm0
movupd %xmm4,0x8(%r14,%rax,8)
movupd %xmm0,0x18(%r14,%rax,8)
add    $0x4,%rax
cmp    %rax,%rsi
jne    24d0 <sfa_one+0x1370>
mov    0xb0(%rsp),%rcx
cmp    %rsi,0x58(%rsp)
je     1b10 <sfa_one+0x9b0>
mov    %rcx,%rax
test   $0x1,%r12b
jne    2582 <sfa_one+0x1422>
movsd  0x0(%rbp,%rcx,8),%xmm0
movapd %xmm0,%xmm1
subsd  -0x8(%rbp,%rcx,8),%xmm1
addsd  %xmm0,%xmm1
subsd  0x8(%rbp,%rcx,8),%xmm1
lea    0x1(%rcx),%rax
subsd  0x0(%r13,%rcx,8),%xmm1
movsd  %xmm1,(%r14,%rcx,8)
not    %rcx
cmp    0xc8(%rsp),%rcx
je     1b10 <sfa_one+0x9b0>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  0x0(%rbp,%rax,8),%xmm0
movapd %xmm0,%xmm1
subsd  -0x8(%rbp,%rax,8),%xmm1
addsd  %xmm0,%xmm1
subsd  0x8(%rbp,%rax,8),%xmm1
subsd  0x0(%r13,%rax,8),%xmm1
movsd  %xmm1,(%r14,%rax,8)
movsd  0x8(%rbp,%rax,8),%xmm0
movapd %xmm0,%xmm1
subsd  0x0(%rbp,%rax,8),%xmm1
addsd  %xmm0,%xmm1
subsd  0x10(%rbp,%rax,8),%xmm1
subsd  0x8(%r13,%rax,8),%xmm1
movsd  %xmm1,0x8(%r14,%rax,8)
lea    0x2(%rax),%rcx
mov    %rcx,%rax
cmp    %rcx,%r12
jne    25a0 <sfa_one+0x1440>
jmp    1b10 <sfa_one+0x9b0>
movapd 0x60(%rsp),%xmm9
mov    0x180(%rsp),%r10d
mov    0x30(%rsp),%edx
movsd  0x88(%rsp),%xmm0
jmp    1b69 <sfa_one+0xa09>
mov    $0x1,%eax
jmp    262f <sfa_one+0x14cf>
mov    0xa8(%rsp),%eax
mov    %rax,0x10(%rsp)
mov    0x38(%rsp),%r12
sub    $0x8,%rsp
mov    %r15,%rdi
mov    %rbp,%rsi
mov    0x88(%rsp),%rdx
mov    0x98(%rsp),%rcx
mov    %r13,%r8
mov    %r14,%r9
movapd %xmm9,%xmm0
push   %r10
push   %r12
push   0x1a8(%rsp)
call   1070 <generateSolution@plt>
add    $0x20,%rsp
mov    %eax,%ebx
mov    %r12,%rdi
mov    0x78(%rsp),%rbp
call   1030 <free@plt>
mov    %ebx,0x0(%rbp)
mov    0x10(%rsp),%rax
add    $0x148,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    0x38(%rsp),%r12
movaps 0x60(%rsp),%xmm9
mov    0x180(%rsp),%r10d
jmp    2639 <sfa_one+0x14d9>
shr    $0x2,%r9
add    $0x1,%r9
mov    %r9,%rdx
and    $0xfffffffffffffffe,%rdx
lea    (%rdx,%rdx,4),%rax
add    %rsi,%rax
shl    $0x3,%rsi
movapd 0x94d(%rip),%xmm8
mov    %rdx,%rdi
cs nopw 0x0(%rax,%rax,1)
movsd  0x0(%rbp,%rsi,1),%xmm1
movsd  0x8(%rbp,%rsi,1),%xmm3
movsd  0x10(%rbp,%rsi,1),%xmm2
movsd  0x18(%rbp,%rsi,1),%xmm4
movhpd 0x28(%rbp,%rsi,1),%xmm1
movsd  (%r14,%rsi,1),%xmm5
movsd  0x8(%r14,%rsi,1),%xmm6
movsd  0x10(%r14,%rsi,1),%xmm7
movsd  0x18(%r14,%rsi,1),%xmm0
movhpd 0x28(%r14,%rsi,1),%xmm5
mulpd  %xmm8,%xmm5
subpd  %xmm5,%xmm1
movhpd 0x30(%rbp,%rsi,1),%xmm3
movhpd 0x30(%r14,%rsi,1),%xmm6
mulpd  %xmm8,%xmm6
subpd  %xmm6,%xmm3
movhpd 0x38(%rbp,%rsi,1),%xmm2
movhpd 0x38(%r14,%rsi,1),%xmm7
mulpd  %xmm8,%xmm7
subpd  %xmm7,%xmm2
movhpd 0x40(%rbp,%rsi,1),%xmm4
movhpd 0x40(%r14,%rsi,1),%xmm0
mulpd  %xmm8,%xmm0
subpd  %xmm0,%xmm4
movsd  0x20(%rbp,%rsi,1),%xmm0
movhpd 0x48(%rbp,%rsi,1),%xmm0
movsd  0x20(%r14,%rsi,1),%xmm5
movhpd 0x48(%r14,%rsi,1),%xmm5
mulpd  %xmm8,%xmm5
subpd  %xmm5,%xmm0
movapd %xmm1,%xmm5
unpcklpd %xmm3,%xmm5
movsd  %xmm0,%xmm1
unpckhpd %xmm2,%xmm3
unpcklpd %xmm4,%xmm2
movhlps %xmm4,%xmm0
movups %xmm0,0x40(%rbp,%rsi,1)
movupd %xmm3,0x30(%rbp,%rsi,1)
movupd %xmm1,0x20(%rbp,%rsi,1)
movupd %xmm2,0x10(%rbp,%rsi,1)
movupd %xmm5,0x0(%rbp,%rsi,1)
add    $0x50,%rsi
add    $0xfffffffffffffffe,%rdi
jne    26e0 <sfa_one+0x1580>
cmp    %rdx,%r9
mov    0x28(%rsp),%rdx
jne    1533 <sfa_one+0x3d3>
jmp    15d3 <sfa_one+0x473>
mov    %eax,%ebx
mov    0x78(%rsp),%rbp
mov    0x38(%rsp),%rdi
jmp    267c <sfa_one+0x151c>
mov    0x78(%rsp),%rbp
mov    0x38(%rsp),%rdi
mov    %eax,%ebx
jmp    267c <sfa_one+0x151c>
mov    0x180(%rsp),%r10d
jmp    120e <sfa_one+0xae>
mov    0x180(%rsp),%r10d
mov    0x18(%rsp),%r12
mov    0x28(%rsp),%rdx
mov    0x24(%rsp),%r8d
mov    0x188(%rsp),%esi
movabs $0xcccccccccccccccd,%r11
cc cc cc
jmp    1676 <sfa_one+0x516>

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

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