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;
  int tFlag = 0;
  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) {
        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)
movslq 0x10(%rbp),%rdi
shl    $0x2,%rdi
call   1060 <malloc@plt>
mov    %rax,-0x60(%rbp)
movsd  0xe32(%rip),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  0xe2d(%rip),%xmm0
movsd  %xmm0,-0x70(%rbp)
movl   $0xffffff9c,-0x74(%rbp)
movl   $0xffffff38,-0x78(%rbp)
movl   $0xfffffed4,-0x7c(%rbp)
mov    -0x10(%rbp),%rax
movsd  0xdff(%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    12c3 <sfa_one+0x153>
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    1235 <sfa_one+0xc5>
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     13a9 <sfa_one+0x239>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jge    13a4 <sfa_one+0x234>
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  0xc8f(%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    1353 <sfa_one+0x1e3>
jmp    13a9 <sfa_one+0x239>
mov    -0x4c(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    1518 <sfa_one+0x3a8>
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  0xc33(%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  0xbf2(%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  0xbac(%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  0xb66(%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  0xb20(%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    13af <sfa_one+0x23f>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    15ce <sfa_one+0x45e>
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd -0x38(%rbp),%xmm0
jbe    155a <sfa_one+0x3ea>
movsd  -0x38(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    15bb <sfa_one+0x44b>
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    15b6 <sfa_one+0x446>
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    15bb <sfa_one+0x44b>
jmp    15c0 <sfa_one+0x450>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    151f <sfa_one+0x3af>
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    168c <sfa_one+0x51c>
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    15fe <sfa_one+0x48e>
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     1ecb <sfa_one+0xd5b>
mov    -0x78(%rbp),%eax
mov    %eax,-0x7c(%rbp)
mov    -0x74(%rbp),%eax
mov    %eax,-0x78(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x28(%rbp),%rsi
mov    -0x20(%rbp),%rdx
mov    0x28(%rbp),%rcx
mov    -0x60(%rbp),%r8
movsd  -0x38(%rbp),%xmm0
mov    0x10(%rbp),%r9d
mov    $0x1,%al
call   1070 <supportSet@plt>
mov    %eax,-0x74(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    179d <sfa_one+0x62d>
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    174a <sfa_one+0x5da>
mov    -0x20(%rbp),%rsi
mov    0x20(%rbp),%rdx
mov    0x10(%rbp),%ecx
lea    -0x58(%rbp),%rdi
mov    $0x0,%al
call   1090 <Thomas@plt>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    1869 <sfa_one+0x6f9>
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd -0x38(%rbp),%xmm0
jbe    17f5 <sfa_one+0x685>
movsd  -0x38(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1856 <sfa_one+0x6e6>
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    1851 <sfa_one+0x6e1>
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    1856 <sfa_one+0x6e6>
jmp    185b <sfa_one+0x6eb>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    17ba <sfa_one+0x64a>
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    1927 <sfa_one+0x7b7>
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    1899 <sfa_one+0x729>
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     1a0d <sfa_one+0x89d>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jge    1a08 <sfa_one+0x898>
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  0x62b(%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    19b7 <sfa_one+0x847>
jmp    1a0d <sfa_one+0x89d>
mov    -0x4c(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    1b7c <sfa_one+0xa0c>
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  0x5cf(%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  0x58e(%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  0x548(%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  0x502(%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  0x4bc(%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    1a13 <sfa_one+0x8a3>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    1c32 <sfa_one+0xac2>
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd -0x38(%rbp),%xmm0
jbe    1bbe <sfa_one+0xa4e>
movsd  -0x38(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1c1f <sfa_one+0xaaf>
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    1c1a <sfa_one+0xaaa>
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    1c1f <sfa_one+0xaaf>
jmp    1c24 <sfa_one+0xab4>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1b83 <sfa_one+0xa13>
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    1cf0 <sfa_one+0xb80>
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    1c62 <sfa_one+0xaf2>
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    1eb8 <sfa_one+0xd48>
movsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x68(%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
mov    $0x1,%al
call   1050 <dualityGap2@plt>
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm1
movsd  -0x40(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jb     1dc8 <sfa_one+0xc58>
jmp    1ecb <sfa_one+0xd5b>
movl   $0x1,-0x4c(%rbp)
cmpl   $0xf4240,0x10(%rbp)
jle    1de8 <sfa_one+0xc78>
movl   $0x5,-0x4c(%rbp)
jmp    1e01 <sfa_one+0xc91>
cmpl   $0x186a0,0x10(%rbp)
jle    1dfc <sfa_one+0xc8c>
movl   $0x3,-0x4c(%rbp)
jmp    1e01 <sfa_one+0xc91>
mov    -0x74(%rbp),%edi
sub    -0x78(%rbp),%edi
call   1040 <abs@plt>
cmp    -0x4c(%rbp),%eax
jge    1eb3 <sfa_one+0xd43>
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    -0x60(%rbp),%r10
movsd  -0x38(%rbp),%xmm0
mov    0x10(%rbp),%eax
mov    %r11,(%rsp)
mov    %r10,0x8(%rsp)
mov    %eax,0x10(%rsp)
mov    $0x1,%al
call   1080 <generateSolution@plt>
mov    %eax,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm1
movsd  -0x40(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    1e7d <sfa_one+0xd0d>
mov    -0x4c(%rbp),%eax
mov    %eax,-0x74(%rbp)
movl   $0x2,-0x50(%rbp)
jmp    1ecb <sfa_one+0xd5b>
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
ucomisd -0x70(%rbp),%xmm0
jne    1eae <sfa_one+0xd3e>
jp     1eae <sfa_one+0xd3e>
mov    -0x74(%rbp),%eax
cmp    -0x7c(%rbp),%eax
jne    1eae <sfa_one+0xd3e>
movl   $0x2,-0x50(%rbp)
jmp    1ecb <sfa_one+0xd5b>
jmp    1eb3 <sfa_one+0xd43>
jmp    1eb8 <sfa_one+0xd48>
jmp    1ebd <sfa_one+0xd4d>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1704 <sfa_one+0x594>
cmpl   $0x2,-0x50(%rbp)
je     1f14 <sfa_one+0xda4>
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    -0x60(%rbp),%r10
movsd  -0x38(%rbp),%xmm0
mov    0x10(%rbp),%eax
mov    %r11,(%rsp)
mov    %r10,0x8(%rsp)
mov    %eax,0x10(%rsp)
mov    $0x1,%al
call   1080 <generateSolution@plt>
mov    %eax,-0x74(%rbp)
mov    -0x60(%rbp),%rdi
call   1030 <free@plt>
mov    -0x74(%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    $0x138,%rsp
movsd  %xmm1,0xb0(%rsp)
movaps %xmm0,0x60(%rsp)
mov    %r9,%r12
mov    %r8,0x88(%rsp)
mov    %rcx,%rbp
mov    %rdx,0x70(%rsp)
mov    %rsi,%r14
mov    %rdi,%r15
movslq 0x170(%rsp),%rbx
mov    0x188(%rsp),%r13
lea    0x0(,%rbx,4),%rdi
call   1050 <malloc@plt>
mov    %rbx,%r10
mov    %rax,0x30(%rsp)
movabs $0xbff0000000000000,%rax
mov    %r14,0x78(%rsp)
mov    %rax,(%r14)
movsd  0x0(%rbp),%xmm0
addsd  %xmm0,%xmm0
subsd  0x8(%rbp),%xmm0
subsd  (%r12),%xmm0
lea    -0x1(%rbx),%eax
movsd  %xmm0,0x0(%r13)
mov    %eax,%r14d
cmp    $0x3,%rbx
mov    %rbx,0x10(%rsp)
jl     13a4 <sfa_one+0x244>
lea    -0x1(%r14),%r8
mov    $0x1,%ecx
cmp    $0x4,%r8
jae    12c0 <sfa_one+0x160>
mov    %rcx,%rdx
not    %rdx
test   $0x1,%r14b
jne    1248 <sfa_one+0xe8>
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  (%r12,%rcx,8),%xmm1
movsd  %xmm1,0x0(%r13,%rcx,8)
add    $0x1,%rcx
add    %r14,%rdx
je     13a4 <sfa_one+0x244>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
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  (%r12,%rcx,8),%xmm1
movsd  %xmm1,0x0(%r13,%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(%r12,%rcx,8),%xmm1
movsd  %xmm1,0x8(%r13,%rcx,8)
lea    0x2(%rcx),%rdx
mov    %rdx,%rcx
cmp    %rdx,%r14
jne    1260 <sfa_one+0x100>
jmp    13a4 <sfa_one+0x244>
lea    0x8(%r13),%rdx
lea    0x0(,%r14,8),%rsi
add    %r13,%rsi
lea    0x8(,%r14,8),%rdi
add    %rbp,%rdi
lea    0x8(%r12),%r9
lea    (%r12,%r14,8),%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    27f5 <sfa_one+0x1695>
and    %sil,%dl
mov    0x10(%rsp),%r10
jne    1211 <sfa_one+0xb1>
mov    %r8,%rsi
and    $0xfffffffffffffffc,%rsi
lea    0x1(%rsi),%rcx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
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(%r12,%rdi,8),%xmm1
subpd  %xmm1,%xmm4
movupd 0x18(%r12,%rdi,8),%xmm1
subpd  %xmm1,%xmm0
movupd %xmm4,0x8(%r13,%rdi,8)
movupd %xmm0,0x18(%r13,%rdi,8)
add    $0x4,%rdi
cmp    %rdi,%rsi
jne    1330 <sfa_one+0x1d0>
cmp    %rsi,%r8
jne    1211 <sfa_one+0xb1>
movslq %r10d,%rbx
movslq %eax,%r8
movsd  0x0(%rbp,%r8,8),%xmm0
movapd %xmm0,%xmm1
subsd  -0x10(%rbp,%rbx,8),%xmm1
addsd  %xmm0,%xmm1
subsd  (%r12,%r8,8),%xmm1
movsd  %xmm1,0x0(%r13,%r8,8)
imul   $0x66666667,%rbx,%rax
mov    %rax,%rcx
shr    $0x3f,%rcx
sar    $0x21,%rax
add    %ecx,%eax
lea    (%rax,%rax,4),%eax
mov    %r10d,%edi
sub    %eax,%edi
test   %edi,%edi
jle    14b8 <sfa_one+0x358>
movsd  0x0(%r13),%xmm0
mulsd  0x1c02(%rip),%xmm0
addsd  0x0(%rbp),%xmm0
movsd  %xmm0,0x0(%rbp)
cmp    $0x1,%edi
je     14b8 <sfa_one+0x358>
movsd  0x8(%r13),%xmm0
mulsd  0x1be1(%rip),%xmm0
addsd  0x8(%rbp),%xmm0
movsd  %xmm0,0x8(%rbp)
cmp    $0x2,%edi
je     14b8 <sfa_one+0x358>
movsd  0x10(%r13),%xmm0
mulsd  0x1bc0(%rip),%xmm0
addsd  0x10(%rbp),%xmm0
movsd  %xmm0,0x10(%rbp)
cmp    $0x3,%edi
je     14b8 <sfa_one+0x358>
movsd  0x18(%r13),%xmm0
mulsd  0x1ba3(%rip),%xmm0
addsd  0x18(%rbp),%xmm0
movsd  %xmm0,0x18(%rbp)
cmp    $0x4,%edi
je     14b8 <sfa_one+0x358>
movsd  0x1b94(%rip),%xmm0
movsd  0x20(%r13),%xmm1
mulsd  %xmm0,%xmm1
movsd  0x20(%rbp),%xmm2
subsd  %xmm1,%xmm2
movsd  0x28(%rbp),%xmm1
movsd  %xmm2,0x20(%rbp)
movsd  0x28(%r13),%xmm2
mulsd  %xmm0,%xmm2
subsd  %xmm2,%xmm1
movsd  %xmm1,0x28(%rbp)
movsd  0x30(%rbp),%xmm1
mulsd  0x30(%r13),%xmm0
subsd  %xmm0,%xmm1
movsd  %xmm1,0x30(%rbp)
movabs $0xcccccccccccccccd,%r11
cc cc cc
cmp    %r10d,%edi
movapd 0x60(%rsp),%xmm9
mov    %edi,0x8(%rsp)
jge    15e4 <sfa_one+0x484>
movslq %edi,%rsi
mov    %rsi,%rdi
not    %rdi
add    %r10,%rdi
mov    %rdi,%rax
mul    %r11
cmp    $0x5,%rdi
jb     1540 <sfa_one+0x3e0>
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    0x28(,%rax,8),%rdx
add    %r13,%rdx
cmp    %rdx,%rcx
jae    269c <sfa_one+0x153c>
lea    0x28(,%rax,8),%rax
add    %rbp,%rax
lea    0x0(,%rsi,8),%rcx
add    %r13,%rcx
cmp    %rax,%rcx
jae    269c <sfa_one+0x153c>
mov    %rsi,%rax
mov    0x8(%rsp),%edi
movsd  0x1ab9(%rip),%xmm0
nop
movsd  0x0(%r13,%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(%r13,%rax,8),%xmm2
mulsd  %xmm0,%xmm2
subsd  %xmm2,%xmm1
movsd  %xmm1,0x8(%rbp,%rax,8)
movsd  0x10(%rbp,%rax,8),%xmm1
movsd  0x10(%r13,%rax,8),%xmm2
mulsd  %xmm0,%xmm2
subsd  %xmm2,%xmm1
movsd  %xmm1,0x10(%rbp,%rax,8)
movsd  0x18(%rbp,%rax,8),%xmm1
movsd  0x18(%r13,%rax,8),%xmm2
mulsd  %xmm0,%xmm2
subsd  %xmm2,%xmm1
movsd  %xmm1,0x18(%rbp,%rax,8)
movsd  0x20(%rbp,%rax,8),%xmm1
movsd  0x20(%r13,%rax,8),%xmm2
mulsd  %xmm0,%xmm2
subsd  %xmm2,%xmm1
movsd  %xmm1,0x20(%rbp,%rax,8)
add    $0x5,%rax
cmp    %r10,%rax
jl     1550 <sfa_one+0x3f0>
mov    %r10d,%eax
mov    %rax,0x38(%rsp)
test   %r10d,%r10d
jle    1633 <sfa_one+0x4d3>
movapd 0x1a37(%rip),%xmm0
xorpd  %xmm9,%xmm0
cmp    $0x1,%r10d
jne    1720 <sfa_one+0x5c0>
xor    %eax,%eax
testb  $0x1,0x38(%rsp)
je     1633 <sfa_one+0x4d3>
movsd  0x0(%rbp,%rax,8),%xmm2
ucomisd %xmm9,%xmm2
movapd %xmm9,%xmm1
ja     162d <sfa_one+0x4cd>
ucomisd %xmm2,%xmm0
movapd %xmm0,%xmm1
jbe    1633 <sfa_one+0x4d3>
movsd  %xmm1,0x0(%rbp,%rax,8)
mov    0x178(%rsp),%edx
add    $0xfffffffffffffffe,%rbx
movsd  0x0(%rbp),%xmm0
addsd  %xmm0,%xmm0
subsd  0x8(%rbp),%xmm0
subsd  (%r12),%xmm0
movsd  %xmm0,0x0(%r13)
cmp    $0x3,%r10d
mov    %r14,0x20(%rsp)
jl     188b <sfa_one+0x72b>
lea    -0x1(%r14),%r9
mov    $0x1,%eax
cmp    $0x4,%r9
jae    1783 <sfa_one+0x623>
mov    %rax,%rcx
not    %rcx
test   $0x1,%r14b
jne    16b1 <sfa_one+0x551>
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  (%r12,%rax,8),%xmm1
movsd  %xmm1,0x0(%r13,%rax,8)
add    $0x1,%rax
add    %r14,%rcx
je     188b <sfa_one+0x72b>
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  (%r12,%rax,8),%xmm1
movsd  %xmm1,0x0(%r13,%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(%r12,%rax,8),%xmm1
movsd  %xmm1,0x8(%r13,%rax,8)
lea    0x2(%rax),%rcx
mov    %rcx,%rax
cmp    %rcx,%r14
jne    16c0 <sfa_one+0x560>
jmp    188b <sfa_one+0x72b>
mov    0x38(%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     160a <sfa_one+0x4aa>
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>
mov    %r8,0x48(%rsp)
lea    0x8(%r13),%rcx
lea    0x0(,%r14,8),%rsi
add    %r13,%rsi
lea    0x8(,%r14,8),%rdx
add    %rbp,%rdx
lea    0x8(%r12),%r10
lea    (%r12,%r14,8),%rdi
cmp    %rdx,%rcx
setb   %r11b
cmp    %rbp,%rsi
seta   %r14b
cmp    %rdi,%rcx
setb   %dl
cmp    %rsi,%r10
setb   %cl
test   %r14b,%r11b
jne    27ff <sfa_one+0x169f>
and    %cl,%dl
mov    0x10(%rsp),%r10
mov    0x20(%rsp),%r14
mov    0x48(%rsp),%r8
mov    0x8(%rsp),%edi
mov    0x178(%rsp),%edx
movabs $0xcccccccccccccccd,%r11
cc cc cc
jne    167a <sfa_one+0x51a>
mov    %r9,%rdx
and    $0xfffffffffffffffc,%rdx
lea    0x1(%rdx),%rax
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
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(%r12,%rsi,8),%xmm1
subpd  %xmm1,%xmm4
movupd 0x18(%r12,%rsi,8),%xmm1
subpd  %xmm1,%xmm0
movupd %xmm4,0x8(%r13,%rsi,8)
movupd %xmm0,0x18(%r13,%rsi,8)
add    $0x4,%rsi
cmp    %rsi,%rdx
jne    1810 <sfa_one+0x6b0>
cmp    %rdx,%r9
mov    0x178(%rsp),%edx
jne    167a <sfa_one+0x51a>
mov    %r11,%rsi
mov    0x180(%rsp),%r11
movsd  0x0(%rbp,%r8,8),%xmm0
movapd %xmm0,%xmm1
subsd  0x0(%rbp,%rbx,8),%xmm1
addsd  %xmm0,%xmm1
subsd  (%r12,%r8,8),%xmm1
movsd  %xmm1,0x0(%r13,%r8,8)
test   %edx,%edx
jle    260e <sfa_one+0x14ae>
mov    %r8,0x48(%rsp)
mov    %rbx,0xd0(%rsp)
movslq %edi,%r9
movapd 0x1757(%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,0x9c(%rsp)
lea    0x8(%r13),%r10
mov    0x20(%rsp),%rax
lea    0x0(%r13,%rax,8),%r14
mov    0x20(%rsp),%rax
lea    0x8(%rbp,%rax,8),%rax
mov    %rax,0x40(%rsp)
lea    0x8(%r12),%rax
mov    %rax,0x18(%rsp)
mov    0x20(%rsp),%rax
lea    (%r12,%rax,8),%rax
mov    %rax,0x28(%rsp)
mov    %r9,%rax
not    %rax
add    0x10(%rsp),%rax
mov    %rax,0x108(%rsp)
mul    %rsi
mov    %rdx,%rax
shr    $0x2,%rax
lea    (%rax,%rax,4),%rsi
add    %r9,%rsi
add    $0x1,%rax
mov    0x38(%rsp),%r8
lea    (%r11,%r8,8),%rdx
lea    (%r12,%r8,8),%rdi
cmp    %r11,%rdi
seta   %bl
lea    (%r15,%r8,8),%rdi
add    $0x8,%rdi
cmp    %r12,%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,0x100(%rsp)
mov    %r8d,%ecx
and    $0xfffffffe,%ecx
mov    %rcx,0xc0(%rsp)
cmp    0x40(%rsp),%r10
setb   %r11b
cmp    %rbp,%r14
seta   %dl
mov    0x20(%rsp),%rdi
lea    -0x1(%rdi),%rcx
and    %r11b,%dl
lea    0x0(,%r9,8),%rdi
add    %rbp,%rdi
mov    %rdi,0x40(%rsp)
cmp    0x28(%rsp),%r10
mov    0x10(%rsp),%r10
lea    0x28(%rbp,%rsi,8),%rdi
mov    %rdi,0x28(%rsp)
setb   %dil
cmp    %r14,0x18(%rsp)
mov    0x20(%rsp),%r14
lea    0x0(%r13,%r9,8),%rbx
mov    %rbx,0x18(%rsp)
lea    0x28(%r13,%rsi,8),%rsi
setb   %r11b
and    %dil,%r11b
or     %dl,%r11b
mov    %r11b,0x7(%rsp)
mov    %rcx,0x58(%rsp)
mov    %rcx,%rdx
and    $0xfffffffffffffffc,%rdx
mov    %r14,%rcx
neg    %rcx
mov    %rcx,0xb8(%rsp)
cmp    %rsi,0x40(%rsp)
setb   %sil
mov    0x28(%rsp),%rcx
cmp    %rcx,0x18(%rsp)
setb   %cl
and    %sil,%cl
mov    %cl,0xe(%rsp)
mov    %rax,0xf0(%rsp)
and    $0xfffffffffffffffe,%rax
mov    %rax,0xa8(%rsp)
lea    (%rax,%rax,4),%rax
add    %r9,%rax
mov    %rax,0xe8(%rsp)
lea    0x0(,%r8,8),%rax
and    $0xffffffffffffffe0,%rax
mov    %rax,0xf8(%rsp)
movsd  0x1579(%rip),%xmm0
mov    0x178(%rsp),%eax
add    $0x1,%eax
mov    %eax,0x98(%rsp)
lea    -0x1(%r8),%rax
mov    %rax,0x90(%rsp)
mov    %rdx,0xc8(%rsp)
lea    0x1(%rdx),%rax
mov    %rax,0xa0(%rsp)
mov    %r9,0x110(%rsp)
lea    0x0(,%r9,8),%rax
mov    %rax,0xe0(%rsp)
mov    $0x1,%eax
mov    $0xffffff9c,%edx
movl   $0xffffff38,0x54(%rsp)
ff
movapd %xmm8,0x120(%rsp)
jmp    1b62 <sfa_one+0xa02>
xchg   %ax,%ax
movsd  0x0(%rbp,%rsi,8),%xmm0
movapd %xmm0,%xmm1
subsd  0x0(%rbp,%r8,8),%xmm1
addsd  %xmm0,%xmm1
subsd  (%r12,%rsi,8),%xmm1
movsd  %xmm1,0x0(%r13,%rsi,8)
mov    0x18(%rsp),%rsi
mov    %esi,%eax
cltd
idivl  0x190(%rsp)
test   %edx,%edx
je     1bd0 <sfa_one+0xa70>
movsd  0xd8(%rsp),%xmm0
mov    0x178(%rsp),%ecx
mov    0x28(%rsp),%edx
mov    0x40(%rsp),%ebx
lea    0x1(%rsi),%eax
mov    %edx,0x54(%rsp)
mov    %ebx,%edx
cmp    %ecx,%esi
je     2615 <sfa_one+0x14b5>
movsd  %xmm0,0xd8(%rsp)
mov    %edx,0x28(%rsp)
mov    %rax,0x18(%rsp)
mov    %r15,%rdi
mov    0x88(%rsp),%rsi
mov    %rbp,%rdx
mov    %r13,%rcx
mov    0x30(%rsp),%r8
movapd %xmm9,%xmm0
mov    %r10d,%r9d
mov    $0x1,%al
call   1060 <supportSet@plt>
mov    0x10(%rsp),%rcx
test   %ecx,%ecx
mov    %eax,0x40(%rsp)
jle    1cf0 <sfa_one+0xb90>
cmp    $0x4,%ecx
setb   %dl
or     0xf(%rsp),%dl
mov    0x180(%rsp),%rdx
je     1d60 <sfa_one+0xc00>
xor    %r8d,%r8d
mov    0x38(%rsp),%rsi
jmp    1dd1 <sfa_one+0xc71>
nop
mov    0x78(%rsp),%r14
movsd  (%r14),%xmm0
movsd  %xmm0,0x80(%rsp)
mov    %r14,%rdi
mov    %rbp,%rsi
mov    %r13,%rdx
mov    0x180(%rsp),%rcx
mov    %r12,%r8
movapd %xmm9,%xmm0
mov    %r10d,%r9d
mov    $0x1,%al
call   1040 <dualityGap2@plt>
movsd  0xb0(%rsp),%xmm0
ucomisd (%r14),%xmm0
jae    268a <sfa_one+0x152a>
mov    0x40(%rsp),%ebx
mov    %ebx,%eax
mov    0x28(%rsp),%edx
sub    %edx,%eax
mov    %eax,%ecx
neg    %ecx
cmovs  %eax,%ecx
cmp    0x9c(%rsp),%ecx
jae    1f23 <sfa_one+0xdc3>
sub    $0x8,%rsp
mov    %r15,%rdi
mov    %rbp,%rsi
mov    0x80(%rsp),%r14
mov    %r14,%rdx
mov    0x90(%rsp),%rcx
mov    %r12,%r8
mov    %r13,%r9
movaps 0x68(%rsp),%xmm0
mov    $0x1,%al
push   0x18(%rsp)
push   0x40(%rsp)
push   0x198(%rsp)
call   1070 <generateSolution@plt>
add    $0x20,%rsp
movsd  (%r14),%xmm0
movsd  0xb0(%rsp),%xmm1
ucomisd %xmm0,%xmm1
ja     27d3 <sfa_one+0x1673>
ucomisd 0xd8(%rsp),%xmm0
mov    0x20(%rsp),%r14
mov    0x178(%rsp),%ecx
mov    0x18(%rsp),%rsi
jne    25f0 <sfa_one+0x1490>
jp     25f0 <sfa_one+0x1490>
mov    0x54(%rsp),%eax
cmp    %eax,%ebx
movapd 0x60(%rsp),%xmm9
mov    0x10(%rsp),%r10
mov    0x28(%rsp),%edx
movsd  0x80(%rsp),%xmm0
jne    1b51 <sfa_one+0x9f1>
jmp    27e4 <sfa_one+0x1684>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    0x118(%rsp),%rdi
mov    %rbp,%rsi
mov    0x180(%rsp),%rdx
xor    %eax,%eax
call   1080 <Thomas@plt>
mov    0x10(%rsp),%r10
movapd 0x60(%rsp),%xmm9
mov    0xd0(%rsp),%r8
mov    0x48(%rsp),%rsi
mov    0x8(%rsp),%edi
movapd 0x120(%rsp),%xmm8
mov    0xc8(%rsp),%rdx
movsd  0x12c6(%rip),%xmm10
movapd 0x12d5(%rip),%xmm11
mov    0xc0(%rsp),%rbx
jmp    1f80 <sfa_one+0xe20>
nopl   0x0(%rax,%rax,1)
xor    %edi,%edi
mov    0xf8(%rsp),%rsi
nopw   0x0(%rax,%rax,1)
movupd (%r12,%rdi,1),%xmm0
movupd 0x10(%r12,%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    1d70 <sfa_one+0xc10>
mov    0x100(%rsp),%rdi
mov    %rdi,%r8
mov    0x38(%rsp),%rsi
cmp    %rsi,%rdi
je     1e4f <sfa_one+0xcef>
mov    %r8,%rdi
test   $0x1,%sil
je     1df9 <sfa_one+0xc99>
movsd  (%r12,%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,0x90(%rsp)
je     1e4f <sfa_one+0xcef>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%r12,%rdi,8),%xmm0
subsd  0x8(%r15,%rdi,8),%xmm0
addsd  (%r15,%rdi,8),%xmm0
movsd  %xmm0,(%rdx,%rdi,8)
movsd  0x8(%r12,%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    1e10 <sfa_one+0xcb0>
lea    0x118(%rsp),%rdi
mov    %rbp,%rsi
xor    %eax,%eax
call   1080 <Thomas@plt>
mov    0x10(%rsp),%r10
test   %r10d,%r10d
movapd 0x60(%rsp),%xmm9
mov    0xd0(%rsp),%r8
mov    0x48(%rsp),%rsi
mov    0x8(%rsp),%edi
movapd 0x120(%rsp),%xmm8
mov    0xc8(%rsp),%rdx
movsd  0x116c(%rip),%xmm10
movapd 0x117b(%rip),%xmm11
mov    0xc0(%rsp),%rbx
jle    1f80 <sfa_one+0xe20>
cmpq   $0x0,0x90(%rsp)
je     1f4e <sfa_one+0xdee>
xor    %eax,%eax
jmp    1edf <sfa_one+0xd7f>
cs nopw 0x0(%rax,%rax,1)
movsd  %xmm0,0x8(%rbp,%rax,8)
add    $0x2,%rax
cmp    %rax,%rbx
je     1f50 <sfa_one+0xdf0>
movsd  0x0(%rbp,%rax,8),%xmm1
ucomisd %xmm9,%xmm1
movapd %xmm9,%xmm0
ja     1efd <sfa_one+0xd9d>
ucomisd %xmm1,%xmm8
movapd %xmm8,%xmm0
jbe    1f03 <sfa_one+0xda3>
movsd  %xmm0,0x0(%rbp,%rax,8)
movsd  0x8(%rbp,%rax,8),%xmm1
ucomisd %xmm9,%xmm1
movapd %xmm9,%xmm0
ja     1ed0 <sfa_one+0xd70>
ucomisd %xmm1,%xmm8
movapd %xmm8,%xmm0
ja     1ed0 <sfa_one+0xd70>
jmp    1ed6 <sfa_one+0xd76>
movapd 0x60(%rsp),%xmm9
mov    0x10(%rsp),%r10
mov    0x20(%rsp),%r14
mov    0x178(%rsp),%ecx
mov    0x18(%rsp),%rsi
movsd  0x80(%rsp),%xmm0
jmp    1b51 <sfa_one+0x9f1>
xor    %eax,%eax
testb  $0x1,0x38(%rsp)
je     1f80 <sfa_one+0xe20>
movsd  0x0(%rbp,%rax,8),%xmm1
ucomisd %xmm9,%xmm1
movapd %xmm9,%xmm0
ja     1f75 <sfa_one+0xe15>
ucomisd %xmm1,%xmm8
movapd %xmm8,%xmm0
jbe    1f80 <sfa_one+0xe20>
movsd  %xmm0,0x0(%rbp,%rax,8)
nopl   0x0(%rax,%rax,1)
movsd  0x0(%rbp),%xmm0
addsd  %xmm0,%xmm0
subsd  0x8(%rbp),%xmm0
subsd  (%r12),%xmm0
movsd  %xmm0,0x0(%r13)
cmp    $0x3,%r10d
jl     20e0 <sfa_one+0xf80>
cmpq   $0x4,0x58(%rsp)
setb   %al
or     0x7(%rsp),%al
mov    $0x1,%ecx
jne    203e <sfa_one+0xede>
xor    %eax,%eax
xchg   %ax,%ax
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(%r12,%rax,8),%xmm1
subpd  %xmm1,%xmm4
movupd 0x18(%r12,%rax,8),%xmm1
subpd  %xmm1,%xmm0
movupd %xmm4,0x8(%r13,%rax,8)
movupd %xmm0,0x18(%r13,%rax,8)
add    $0x4,%rax
cmp    %rax,%rdx
jne    1fc0 <sfa_one+0xe60>
mov    0xa0(%rsp),%rcx
cmp    %rdx,0x58(%rsp)
je     20e0 <sfa_one+0xf80>
mov    %rcx,%rax
test   $0x1,%r14b
jne    2072 <sfa_one+0xf12>
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  (%r12,%rcx,8),%xmm1
movsd  %xmm1,0x0(%r13,%rcx,8)
not    %rcx
cmp    0xb8(%rsp),%rcx
je     20e0 <sfa_one+0xf80>
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  (%r12,%rax,8),%xmm1
movsd  %xmm1,0x0(%r13,%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(%r12,%rax,8),%xmm1
movsd  %xmm1,0x8(%r13,%rax,8)
lea    0x2(%rax),%rcx
mov    %rcx,%rax
cmp    %rcx,%r14
jne    2080 <sfa_one+0xf20>
nopl   0x0(%rax,%rax,1)
movsd  0x0(%rbp,%rsi,8),%xmm0
movapd %xmm0,%xmm1
subsd  0x0(%rbp,%r8,8),%xmm1
addsd  %xmm0,%xmm1
subsd  (%r12,%rsi,8),%xmm1
movsd  %xmm1,0x0(%r13,%rsi,8)
test   %edi,%edi
jle    21e0 <sfa_one+0x1080>
movsd  0x0(%r13),%xmm0
mulsd  0xee8(%rip),%xmm0
addsd  0x0(%rbp),%xmm0
movsd  %xmm0,0x0(%rbp)
cmp    $0x1,%edi
je     21e0 <sfa_one+0x1080>
movsd  0x8(%r13),%xmm0
mulsd  0xec7(%rip),%xmm0
addsd  0x8(%rbp),%xmm0
movsd  %xmm0,0x8(%rbp)
cmp    $0x2,%edi
je     21e0 <sfa_one+0x1080>
movsd  0x10(%r13),%xmm0
mulsd  0xea6(%rip),%xmm0
addsd  0x10(%rbp),%xmm0
movsd  %xmm0,0x10(%rbp)
cmp    $0x3,%edi
je     21e0 <sfa_one+0x1080>
movsd  0x18(%r13),%xmm0
mulsd  0xe89(%rip),%xmm0
addsd  0x18(%rbp),%xmm0
movsd  %xmm0,0x18(%rbp)
cmp    $0x4,%edi
je     21e0 <sfa_one+0x1080>
movsd  0x20(%r13),%xmm0
mulsd  %xmm10,%xmm0
movsd  0x20(%rbp),%xmm1
subsd  %xmm0,%xmm1
movsd  0x28(%rbp),%xmm0
movsd  %xmm1,0x20(%rbp)
movsd  0x28(%r13),%xmm1
mulsd  %xmm10,%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,0x28(%rbp)
movsd  0x30(%rbp),%xmm0
movsd  0x30(%r13),%xmm1
mulsd  %xmm10,%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,0x30(%rbp)
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
cmp    %r10d,%edi
jge    23c9 <sfa_one+0x1269>
cmpq   $0x5,0x108(%rsp)
setb   %al
or     0xe(%rsp),%al
mov    0x110(%rsp),%rax
jne    2330 <sfa_one+0x11d0>
mov    0xe0(%rsp),%rax
mov    0xa8(%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  0x0(%r13,%rax,1),%xmm4
movsd  0x8(%r13,%rax,1),%xmm5
movsd  0x10(%r13,%rax,1),%xmm6
movsd  0x18(%r13,%rax,1),%xmm7
movhpd 0x28(%r13,%rax,1),%xmm4
mulpd  %xmm11,%xmm4
subpd  %xmm4,%xmm0
movhpd 0x30(%rbp,%rax,1),%xmm2
movhpd 0x30(%r13,%rax,1),%xmm5
mulpd  %xmm11,%xmm5
subpd  %xmm5,%xmm2
movhpd 0x38(%rbp,%rax,1),%xmm1
movhpd 0x38(%r13,%rax,1),%xmm6
mulpd  %xmm11,%xmm6
subpd  %xmm6,%xmm1
movhpd 0x40(%rbp,%rax,1),%xmm3
movhpd 0x40(%r13,%rax,1),%xmm7
mulpd  %xmm11,%xmm7
subpd  %xmm7,%xmm3
movsd  0x20(%rbp,%rax,1),%xmm4
movhpd 0x48(%rbp,%rax,1),%xmm4
movsd  0x20(%r13,%rax,1),%xmm5
movhpd 0x48(%r13,%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    2220 <sfa_one+0x10c0>
mov    0xe8(%rsp),%rax
mov    0xa8(%rsp),%rcx
cmp    %rcx,0xf0(%rsp)
je     23c9 <sfa_one+0x1269>
nop
movsd  0x0(%r13,%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(%r13,%rax,8),%xmm1
mulsd  %xmm10,%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%rbp,%rax,8)
movsd  0x10(%rbp,%rax,8),%xmm0
movsd  0x10(%r13,%rax,8),%xmm1
mulsd  %xmm10,%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,0x10(%rbp,%rax,8)
movsd  0x18(%rbp,%rax,8),%xmm0
movsd  0x18(%r13,%rax,8),%xmm1
mulsd  %xmm10,%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,0x18(%rbp,%rax,8)
movsd  0x20(%rbp,%rax,8),%xmm0
movsd  0x20(%r13,%rax,8),%xmm1
mulsd  %xmm10,%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,0x20(%rbp,%rax,8)
add    $0x5,%rax
cmp    %r10,%rax
jl     2330 <sfa_one+0x11d0>
test   %r10d,%r10d
jle    247d <sfa_one+0x131d>
cmpq   $0x0,0x90(%rsp)
je     2450 <sfa_one+0x12f0>
xor    %eax,%eax
jmp    23ff <sfa_one+0x129f>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  %xmm0,0x8(%rbp,%rax,8)
add    $0x2,%rax
cmp    %rax,%rbx
je     2452 <sfa_one+0x12f2>
movsd  0x0(%rbp,%rax,8),%xmm1
ucomisd %xmm9,%xmm1
movapd %xmm9,%xmm0
ja     241d <sfa_one+0x12bd>
ucomisd %xmm1,%xmm8
movapd %xmm8,%xmm0
jbe    2423 <sfa_one+0x12c3>
movsd  %xmm0,0x0(%rbp,%rax,8)
movsd  0x8(%rbp,%rax,8),%xmm1
ucomisd %xmm9,%xmm1
movapd %xmm9,%xmm0
ja     23f0 <sfa_one+0x1290>
ucomisd %xmm1,%xmm8
movapd %xmm8,%xmm0
ja     23f0 <sfa_one+0x1290>
jmp    23f6 <sfa_one+0x1296>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
xor    %eax,%eax
testb  $0x1,0x38(%rsp)
je     247d <sfa_one+0x131d>
movsd  0x0(%rbp,%rax,8),%xmm1
ucomisd %xmm9,%xmm1
movapd %xmm9,%xmm0
ja     2477 <sfa_one+0x1317>
ucomisd %xmm1,%xmm8
movapd %xmm8,%xmm0
jbe    247d <sfa_one+0x131d>
movsd  %xmm0,0x0(%rbp,%rax,8)
movsd  0x0(%rbp),%xmm0
addsd  %xmm0,%xmm0
subsd  0x8(%rbp),%xmm0
subsd  (%r12),%xmm0
movsd  %xmm0,0x0(%r13)
cmp    $0x3,%r10d
jl     1b00 <sfa_one+0x9a0>
cmpq   $0x4,0x58(%rsp)
setb   %al
or     0x7(%rsp),%al
mov    $0x1,%ecx
jne    253e <sfa_one+0x13de>
xor    %eax,%eax
nopl   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(%r12,%rax,8),%xmm1
subpd  %xmm1,%xmm4
movupd 0x18(%r12,%rax,8),%xmm1
subpd  %xmm1,%xmm0
movupd %xmm4,0x8(%r13,%rax,8)
movupd %xmm0,0x18(%r13,%rax,8)
add    $0x4,%rax
cmp    %rax,%rdx
jne    24c0 <sfa_one+0x1360>
mov    0xa0(%rsp),%rcx
cmp    %rdx,0x58(%rsp)
je     1b00 <sfa_one+0x9a0>
mov    %rcx,%rax
test   $0x1,%r14b
jne    2572 <sfa_one+0x1412>
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  (%r12,%rcx,8),%xmm1
movsd  %xmm1,0x0(%r13,%rcx,8)
not    %rcx
cmp    0xb8(%rsp),%rcx
je     1b00 <sfa_one+0x9a0>
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  (%r12,%rax,8),%xmm1
movsd  %xmm1,0x0(%r13,%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(%r12,%rax,8),%xmm1
movsd  %xmm1,0x8(%r13,%rax,8)
lea    0x2(%rax),%rcx
mov    %rcx,%rax
cmp    %rcx,%r14
jne    2590 <sfa_one+0x1430>
jmp    1b00 <sfa_one+0x9a0>
movapd 0x60(%rsp),%xmm9
mov    0x10(%rsp),%r10
mov    0x28(%rsp),%edx
movsd  0x80(%rsp),%xmm0
jmp    1b51 <sfa_one+0x9f1>
mov    $0x1,%eax
jmp    261c <sfa_one+0x14bc>
mov    0x98(%rsp),%eax
mov    %rax,0x18(%rsp)
mov    0x30(%rsp),%r14
sub    $0x8,%rsp
mov    %r15,%rdi
mov    %rbp,%rsi
mov    0x80(%rsp),%rdx
mov    0x90(%rsp),%rcx
mov    %r12,%r8
mov    %r13,%r9
movapd %xmm9,%xmm0
mov    $0x1,%al
push   %r10
push   %r14
push   0x198(%rsp)
call   1070 <generateSolution@plt>
add    $0x20,%rsp
mov    %eax,%ebx
mov    %r14,%rdi
mov    0x70(%rsp),%rbp
call   1030 <free@plt>
mov    %ebx,0x0(%rbp)
mov    0x18(%rsp),%rax
add    $0x138,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    0x30(%rsp),%r14
movaps 0x60(%rsp),%xmm9
mov    0x10(%rsp),%r10
jmp    2626 <sfa_one+0x14c6>
shr    $0x2,%r9
add    $0x1,%r9
mov    %r9,%rdx
and    $0xfffffffffffffffe,%rdx
lea    (%rdx,%rdx,4),%rax
add    %rsi,%rax
shl    $0x3,%rsi
movapd 0x961(%rip),%xmm8
mov    %rdx,%rdi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
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  0x0(%r13,%rsi,1),%xmm5
movsd  0x8(%r13,%rsi,1),%xmm6
movsd  0x10(%r13,%rsi,1),%xmm7
movsd  0x18(%r13,%rsi,1),%xmm0
movhpd 0x28(%r13,%rsi,1),%xmm5
mulpd  %xmm8,%xmm5
subpd  %xmm5,%xmm1
movhpd 0x30(%rbp,%rsi,1),%xmm3
movhpd 0x30(%r13,%rsi,1),%xmm6
mulpd  %xmm8,%xmm6
subpd  %xmm6,%xmm3
movhpd 0x38(%rbp,%rsi,1),%xmm2
movhpd 0x38(%r13,%rsi,1),%xmm7
mulpd  %xmm8,%xmm7
subpd  %xmm7,%xmm2
movhpd 0x40(%rbp,%rsi,1),%xmm4
movhpd 0x40(%r13,%rsi,1),%xmm0
mulpd  %xmm8,%xmm0
subpd  %xmm0,%xmm4
movsd  0x20(%rbp,%rsi,1),%xmm0
movhpd 0x48(%rbp,%rsi,1),%xmm0
movsd  0x20(%r13,%rsi,1),%xmm5
movhpd 0x48(%r13,%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    26d0 <sfa_one+0x1570>
cmp    %rdx,%r9
mov    0x8(%rsp),%edi
jne    1547 <sfa_one+0x3e7>
jmp    15e4 <sfa_one+0x484>
mov    %eax,%ebx
mov    0x70(%rsp),%rbp
mov    0x30(%rsp),%rdi
jmp    266b <sfa_one+0x150b>
mov    0x70(%rsp),%rbp
mov    0x30(%rsp),%rdi
mov    %eax,%ebx
jmp    266b <sfa_one+0x150b>
mov    0x10(%rsp),%r10
jmp    1211 <sfa_one+0xb1>
mov    0x10(%rsp),%r10
mov    0x20(%rsp),%r14
mov    0x48(%rsp),%r8
mov    0x8(%rsp),%edi
mov    0x178(%rsp),%edx
movabs $0xcccccccccccccccd,%r11
cc cc cc
jmp    167a <sfa_one+0x51a>

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

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 = sext i32 %7 to i64
%17 = shl nsw i64 %16, 2
%18 = tail call i8* @malloc(i64 %17)
%19 = bitcast i8* %18 to i32*
store double -1.000000e+00, double* %1
%20 = load double, double* %3
%21 = fadd double %20, %20
%22 = getelementptr inbounds double, double* %3, i64 1
%23 = load double, double* %22
%24 = fsub double %21, %23
%25 = load double, double* %5
%26 = fsub double %24, %25
store double %26, double* %10
%27 = add i32 %7, -1
%28 = icmp sgt i32 %7, 2
br i1 %28, label %29, label %151
29: ; preds = %13
%30 = zext i32 %27 to i64
%31 = add nsw i64 %30, -1
%32 = icmp ult i64 %31, 4
br i1 %32, label %94, label %33
33: ; preds = %29
%34 = getelementptr double, double* %10, i64 1
%35 = getelementptr double, double* %10, i64 %30
%36 = add nuw nsw i64 %30, 1
%37 = getelementptr double, double* %3, i64 %36
%38 = getelementptr double, double* %5, i64 1
%39 = getelementptr double, double* %5, i64 %30
%40 = icmp ult double* %34, %37
%41 = icmp ugt double* %35, %3
%42 = and i1 %40, %41
%43 = icmp ult double* %34, %39
%44 = icmp ult double* %38, %35
%45 = and i1 %43, %44
%46 = or i1 %42, %45
br i1 %46, label %94, label %47
47: ; preds = %33
%48 = and i64 %31, -4
%49 = or i64 %48, 1
br label %50
50: ; preds = %50, %47
%51 = phi i64 [ 0, %47 ], [ %90, %50 ]
%52 = or i64 %51, 1
%53 = getelementptr inbounds double, double* %3, i64 %51
%54 = bitcast double* %53 to <2 x double>*
%55 = load <2 x double>, <2 x double>* %54
%56 = getelementptr inbounds double, double* %53, i64 2
%57 = bitcast double* %56 to <2 x double>*
%58 = load <2 x double>, <2 x double>* %57
%59 = getelementptr inbounds double, double* %3, i64 %52
%60 = bitcast double* %59 to <2 x double>*
%61 = load <2 x double>, <2 x double>* %60
%62 = getelementptr inbounds double, double* %59, i64 2
%63 = bitcast double* %62 to <2 x double>*
%64 = load <2 x double>, <2 x double>* %63
%65 = fsub <2 x double> %61, %55
%66 = fsub <2 x double> %64, %58
%67 = fadd <2 x double> %61, %65
%68 = fadd <2 x double> %64, %66
%69 = or i64 %51, 2
%70 = getelementptr inbounds double, double* %3, i64 %69
%71 = bitcast double* %70 to <2 x double>*
%72 = load <2 x double>, <2 x double>* %71
%73 = getelementptr inbounds double, double* %70, i64 2
%74 = bitcast double* %73 to <2 x double>*
%75 = load <2 x double>, <2 x double>* %74
%76 = fsub <2 x double> %67, %72
%77 = fsub <2 x double> %68, %75
%78 = getelementptr inbounds double, double* %5, i64 %52
%79 = bitcast double* %78 to <2 x double>*
%80 = load <2 x double>, <2 x double>* %79
%81 = getelementptr inbounds double, double* %78, i64 2
%82 = bitcast double* %81 to <2 x double>*
%83 = load <2 x double>, <2 x double>* %82
%84 = fsub <2 x double> %76, %80
%85 = fsub <2 x double> %77, %83
%86 = getelementptr inbounds double, double* %10, i64 %52
%87 = bitcast double* %86 to <2 x double>*
store <2 x double> %84, <2 x double>* %87
%88 = getelementptr inbounds double, double* %86, i64 2
%89 = bitcast double* %88 to <2 x double>*
store <2 x double> %85, <2 x double>* %89
%90 = add nuw i64 %51, 4
%91 = icmp eq i64 %90, %48
br i1 %91, label %92, label %50
92: ; preds = %50
%93 = icmp eq i64 %31, %48
br i1 %93, label %151, label %94
94: ; preds = %33, %29, %92
%95 = phi i64 [ 1, %33 ], [ 1, %29 ], [ %49, %92 ]
%96 = xor i64 %95, -1
%97 = and i64 %30, 1
%98 = icmp eq i64 %97, 0
br i1 %98, label %99, label %115
99: ; preds = %94
%100 = add nsw i64 %95, -1
%101 = getelementptr inbounds double, double* %3, i64 %100
%102 = load double, double* %101
%103 = getelementptr inbounds double, double* %3, i64 %95
%104 = load double, double* %103
%105 = fsub double %104, %102
%106 = fadd double %104, %105
%107 = add nuw nsw i64 %95, 1
%108 = getelementptr inbounds double, double* %3, i64 %107
%109 = load double, double* %108
%110 = fsub double %106, %109
%111 = getelementptr inbounds double, double* %5, i64 %95
%112 = load double, double* %111
%113 = fsub double %110, %112
%114 = getelementptr inbounds double, double* %10, i64 %95
store double %113, double* %114
br label %115
115: ; preds = %99, %94
%116 = phi i64 [ %95, %94 ], [ %107, %99 ]
%117 = sub nsw i64 0, %30
%118 = icmp eq i64 %96, %117
br i1 %118, label %151, label %119
119: ; preds = %115, %119
%120 = phi i64 [ %142, %119 ], [ %116, %115 ]
%121 = add nsw i64 %120, -1
%122 = getelementptr inbounds double, double* %3, i64 %121
%123 = load double, double* %122
%124 = getelementptr inbounds double, double* %3, i64 %120
%125 = load double, double* %124
%126 = fsub double %125, %123
%127 = fadd double %125, %126
%128 = add nuw nsw i64 %120, 1
%129 = getelementptr inbounds double, double* %3, i64 %128
%130 = load double, double* %129
%131 = fsub double %127, %130
%132 = getelementptr inbounds double, double* %5, i64 %120
%133 = load double, double* %132
%134 = fsub double %131, %133
%135 = getelementptr inbounds double, double* %10, i64 %120
store double %134, double* %135
%136 = getelementptr inbounds double, double* %3, i64 %120
%137 = load double, double* %136
%138 = getelementptr inbounds double, double* %3, i64 %128
%139 = load double, double* %138
%140 = fsub double %139, %137
%141 = fadd double %139, %140
%142 = add nuw nsw i64 %120, 2
%143 = getelementptr inbounds double, double* %3, i64 %142
%144 = load double, double* %143
%145 = fsub double %141, %144
%146 = getelementptr inbounds double, double* %5, i64 %128
%147 = load double, double* %146
%148 = fsub double %145, %147
%149 = getelementptr inbounds double, double* %10, i64 %128
store double %148, double* %149
%150 = icmp eq i64 %142, %30
br i1 %150, label %151, label %119
151: ; preds = %115, %119, %92, %13
%152 = add nsw i32 %7, -2
%153 = sext i32 %152 to i64
%154 = getelementptr inbounds double, double* %3, i64 %153
%155 = load double, double* %154
%156 = sext i32 %27 to i64
%157 = getelementptr inbounds double, double* %3, i64 %156
%158 = load double, double* %157
%159 = fsub double %158, %155
%160 = fadd double %158, %159
%161 = getelementptr inbounds double, double* %5, i64 %156
%162 = load double, double* %161
%163 = fsub double %160, %162
%164 = getelementptr inbounds double, double* %10, i64 %156
store double %163, double* %164
%165 = srem i32 %7, 5
%166 = icmp sgt i32 %165, 0
br i1 %166, label %167, label %216
167: ; preds = %151
%168 = load double, double* %3
%169 = load double, double* %10
%170 = fmul double %169, 2.500000e-01
%171 = fsub double %168, %170
store double %171, double* %3
%172 = icmp eq i32 %165, 1
br i1 %172, label %216, label %173
173: ; preds = %167
%174 = getelementptr inbounds double, double* %3, i64 1
%175 = load double, double* %174
%176 = getelementptr inbounds double, double* %10, i64 1
%177 = load double, double* %176
%178 = fmul double %177, 2.500000e-01
%179 = fsub double %175, %178
store double %179, double* %174
%180 = icmp eq i32 %165, 2
br i1 %180, label %216, label %181
181: ; preds = %173
%182 = getelementptr inbounds double, double* %3, i64 2
%183 = load double, double* %182
%184 = getelementptr inbounds double, double* %10, i64 2
%185 = load double, double* %184
%186 = fmul double %185, 2.500000e-01
%187 = fsub double %183, %186
store double %187, double* %182
%188 = icmp eq i32 %165, 3
br i1 %188, label %216, label %189
189: ; preds = %181
%190 = getelementptr inbounds double, double* %3, i64 3
%191 = load double, double* %190
%192 = getelementptr inbounds double, double* %10, i64 3
%193 = load double, double* %192
%194 = fmul double %193, 2.500000e-01
%195 = fsub double %191, %194
store double %195, double* %190
%196 = icmp eq i32 %165, 4
br i1 %196, label %216, label %197
197: ; preds = %189
%198 = getelementptr inbounds double, double* %3, i64 4
%199 = load double, double* %198
%200 = getelementptr inbounds double, double* %10, i64 4
%201 = load double, double* %200
%202 = fmul double %201, 2.500000e-01
%203 = fsub double %199, %202
store double %203, double* %198
%204 = getelementptr inbounds double, double* %3, i64 5
%205 = load double, double* %204
%206 = getelementptr inbounds double, double* %10, i64 5
%207 = load double, double* %206
%208 = fmul double %207, 2.500000e-01
%209 = fsub double %205, %208
store double %209, double* %204
%210 = getelementptr inbounds double, double* %3, i64 6
%211 = load double, double* %210
%212 = getelementptr inbounds double, double* %10, i64 6
%213 = load double, double* %212
%214 = fmul double %213, 2.500000e-01
%215 = fsub double %211, %214
store double %215, double* %210
br label %216
216: ; preds = %167, %173, %181, %189, %197, %151
%217 = icmp slt i32 %165, %7
br i1 %217, label %218, label %339
218: ; preds = %216
%219 = sext i32 %165 to i64
%220 = xor i64 %219, -1
%221 = add nsw i64 %220, %16
%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 = %218
%226 = getelementptr double, double* %3, i64 %219
%227 = xor i64 %219, -1
%228 = add nsw i64 %227, %16
%229 = urem i64 %228, 5
%230 = sub nsw i64 %228, %229
%231 = add nsw i64 %230, %219
%232 = add nsw i64 %231, 5
%233 = getelementptr double, double* %3, i64 %232
%234 = getelementptr double, double* %10, i64 %219
%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, %219
br label %243
243: ; preds = %243, %239
%244 = phi i64 [ 0, %239 ], [ %333, %243 ]
%245 = mul i64 %244, 5
%246 = add i64 %245, %219
%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, %218, %335
%338 = phi i64 [ %219, %225 ], [ %219, %218 ], [ %242, %335 ]
br label %348
339: ; preds = %348, %335, %216
%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, %16
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* %22
%424 = fsub double %422, %423
%425 = load double, double* %5
%426 = fsub double %424, %425
store double %426, double* %10
br i1 %28, label %427, label %549
427: ; preds = %420
%428 = zext i32 %27 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* %154
%551 = load double, double* %157
%552 = fsub double %551, %550
%553 = fadd double %551, %552
%554 = load double, double* %161
%555 = fsub double %553, %554
store double %555, double* %164
%556 = icmp slt i32 %8, 1
br i1 %556, label %1244, label %557
557: ; preds = %549
%558 = fneg double %6
%559 = icmp slt i32 %165, 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 %165 to i64
%565 = add nuw i32 %8, 1
%566 = zext i32 %7 to i64
%567 = zext i32 %27 to i64
%568 = zext i32 %27 to i64
%569 = getelementptr double, double* %10, i64 1
%570 = getelementptr double, double* %10, i64 %567
%571 = add nuw nsw i64 %567, 1
%572 = getelementptr double, double* %3, i64 %571
%573 = getelementptr double, double* %5, i64 1
%574 = getelementptr double, double* %5, i64 %567
%575 = add nsw i64 %567, -1
%576 = getelementptr double, double* %3, i64 %564
%577 = xor i64 %564, -1
%578 = add nsw i64 %577, %16
%579 = urem i64 %578, 5
%580 = sub nsw i64 %578, %579
%581 = add nsw i64 %580, %564
%582 = add nsw i64 %581, 5
%583 = getelementptr double, double* %3, i64 %582
%584 = getelementptr double, double* %10, i64 %564
%585 = getelementptr double, double* %10, i64 %582
%586 = xor i64 %564, -1
%587 = add nsw i64 %586, %16
%588 = udiv i64 %587, 5
%589 = add nuw nsw i64 %588, 1
%590 = getelementptr double, double* %10, i64 1
%591 = getelementptr double, double* %10, i64 %567
%592 = add nuw nsw i64 %567, 1
%593 = getelementptr double, double* %3, i64 %592
%594 = getelementptr double, double* %5, i64 1
%595 = getelementptr double, double* %5, i64 %567
%596 = add nsw i64 %567, -1
%597 = getelementptr double, double* %9, i64 %566
%598 = getelementptr double, double* %5, i64 %566
%599 = add nuw nsw i64 %566, 1
%600 = getelementptr double, double* %0, i64 %599
%601 = add nsw i64 %566, -1
%602 = icmp ult i32 %7, 4
%603 = icmp ugt double* %598, %9
%604 = icmp ugt double* %597, %5
%605 = and i1 %603, %604
%606 = icmp ugt double* %600, %9
%607 = icmp ugt double* %597, %0
%608 = and i1 %606, %607
%609 = or i1 %605, %608
%610 = and i64 %566, 4294967292
%611 = icmp eq i64 %610, %566
%612 = and i64 %566, 1
%613 = icmp eq i64 %612, 0
%614 = and i64 %566, 1
%615 = icmp eq i64 %601, 0
%616 = and i64 %566, 4294967294
%617 = icmp eq i64 %614, 0
%618 = icmp ult i64 %596, 4
%619 = icmp ult double* %590, %593
%620 = icmp ugt double* %591, %3
%621 = and i1 %619, %620
%622 = icmp ult double* %590, %595
%623 = icmp ult double* %594, %591
%624 = and i1 %622, %623
%625 = or i1 %621, %624
%626 = and i64 %596, -4
%627 = or i64 %626, 1
%628 = icmp eq i64 %596, %626
%629 = and i64 %567, 1
%630 = icmp eq i64 %629, 0
%631 = sub nsw i64 0, %567
%632 = icmp eq i32 %165, 1
%633 = getelementptr inbounds double, double* %3, i64 1
%634 = getelementptr inbounds double, double* %10, i64 1
%635 = icmp eq i32 %165, 2
%636 = getelementptr inbounds double, double* %3, i64 2
%637 = getelementptr inbounds double, double* %10, i64 2
%638 = icmp eq i32 %165, 3
%639 = getelementptr inbounds double, double* %3, i64 3
%640 = getelementptr inbounds double, double* %10, i64 3
%641 = icmp eq i32 %165, 4
%642 = getelementptr inbounds double, double* %3, i64 4
%643 = getelementptr inbounds double, double* %10, i64 4
%644 = getelementptr inbounds double, double* %3, i64 5
%645 = getelementptr inbounds double, double* %10, i64 5
%646 = getelementptr inbounds double, double* %3, i64 6
%647 = getelementptr inbounds double, double* %10, i64 6
%648 = icmp ult i64 %587, 5
%649 = icmp ult double* %576, %585
%650 = icmp ult double* %584, %583
%651 = and i1 %649, %650
%652 = and i64 %589, 9223372036854775806
%653 = mul i64 %652, 5
%654 = add i64 %653, %564
%655 = icmp eq i64 %589, %652
%656 = and i64 %566, 1
%657 = icmp eq i64 %601, 0
%658 = and i64 %566, 4294967294
%659 = icmp eq i64 %656, 0
%660 = icmp ult i64 %575, 4
%661 = icmp ult double* %569, %572
%662 = icmp ugt double* %570, %3
%663 = and i1 %661, %662
%664 = icmp ult double* %569, %574
%665 = icmp ult double* %573, %570
%666 = and i1 %664, %665
%667 = or i1 %663, %666
%668 = and i64 %575, -4
%669 = or i64 %668, 1
%670 = icmp eq i64 %575, %668
%671 = and i64 %567, 1
%672 = icmp eq i64 %671, 0
%673 = sub nsw i64 0, %567
br label %674
674: ; preds = %557, %1240
%675 = phi i32 [ -200, %557 ], [ %676, %1240 ]
%676 = phi i32 [ -100, %557 ], [ %679, %1240 ]
%677 = phi double [ -1.000000e+00, %557 ], [ %1241, %1240 ]
%678 = phi i32 [ 1, %557 ], [ %1242, %1240 ]
%679 = call i32 (double*, double*, double*, double*, i32*, double, i32, ...) bitcast (i32 (...)* @supportSet to i32 (double*, double*, double*, double*, i32*, double, i32, ...)*)(double* %0, double* %4, double* %3, double* %10, i32* %19, double %6, i32 %7)
br i1 %340, label %680, label %730
680: ; preds = %674
%681 = select i1 %602, i1 true, i1 %609
br i1 %681, label %714, label %682
682: ; preds = %680, %682
%683 = phi i64 [ %711, %682 ], [ 0, %680 ]
%684 = getelementptr inbounds double, double* %5, i64 %683
%685 = bitcast double* %684 to <2 x double>*
%686 = load <2 x double>, <2 x double>* %685
%687 = getelementptr inbounds double, double* %684, i64 2
%688 = bitcast double* %687 to <2 x double>*
%689 = load <2 x double>, <2 x double>* %688
%690 = or i64 %683, 1
%691 = getelementptr inbounds double, double* %0, i64 %690
%692 = bitcast double* %691 to <2 x double>*
%693 = load <2 x double>, <2 x double>* %692
%694 = getelementptr inbounds double, double* %691, i64 2
%695 = bitcast double* %694 to <2 x double>*
%696 = load <2 x double>, <2 x double>* %695
%697 = fsub <2 x double> %686, %693
%698 = fsub <2 x double> %689, %696
%699 = getelementptr inbounds double, double* %0, i64 %683
%700 = bitcast double* %699 to <2 x double>*
%701 = load <2 x double>, <2 x double>* %700
%702 = getelementptr inbounds double, double* %699, i64 2
%703 = bitcast double* %702 to <2 x double>*
%704 = load <2 x double>, <2 x double>* %703
%705 = fadd <2 x double> %697, %701
%706 = fadd <2 x double> %698, %704
%707 = getelementptr inbounds double, double* %9, i64 %683
%708 = bitcast double* %707 to <2 x double>*
store <2 x double> %705, <2 x double>* %708
%709 = getelementptr inbounds double, double* %707, i64 2
%710 = bitcast double* %709 to <2 x double>*
store <2 x double> %706, <2 x double>* %710
%711 = add nuw i64 %683, 4
%712 = icmp eq i64 %711, %610
br i1 %712, label %713, label %682
713: ; preds = %682
br i1 %611, label %755, label %714
714: ; preds = %680, %713
%715 = phi i64 [ 0, %680 ], [ %610, %713 ]
br i1 %613, label %727, label %716
716: ; preds = %714
%717 = getelementptr inbounds double, double* %5, i64 %715
%718 = load double, double* %717
%719 = or i64 %715, 1
%720 = getelementptr inbounds double, double* %0, i64 %719
%721 = load double, double* %720
%722 = fsub double %718, %721
%723 = getelementptr inbounds double, double* %0, i64 %715
%724 = load double, double* %723
%725 = fadd double %722, %724
%726 = getelementptr inbounds double, double* %9, i64 %715
store double %725, double* %726
br label %727
727: ; preds = %716, %714
%728 = phi i64 [ %715, %714 ], [ %719, %716 ]
%729 = icmp eq i64 %601, %715
br i1 %729, label %755, label %732
730: ; preds = %674
%731 = call i32 (double*, double*, double*, i32, ...) bitcast (i32 (...)* @Thomas to i32 (double*, double*, double*, i32, ...)*)(double* %14, double* %3, double* %9, i32 %7)
br label %791
732: ; preds = %727, %732
%733 = phi i64 [ %746, %732 ], [ %728, %727 ]
%734 = getelementptr inbounds double, double* %5, i64 %733
%735 = load double, double* %734
%736 = add nuw nsw i64 %733, 1
%737 = getelementptr inbounds double, double* %0, i64 %736
%738 = load double, double* %737
%739 = fsub double %735, %738
%740 = getelementptr inbounds double, double* %0, i64 %733
%741 = load double, double* %740
%742 = fadd double %739, %741
%743 = getelementptr inbounds double, double* %9, i64 %733
store double %742, double* %743
%744 = getelementptr inbounds double, double* %5, i64 %736
%745 = load double, double* %744
%746 = add nuw nsw i64 %733, 2
%747 = getelementptr inbounds double, double* %0, i64 %746
%748 = load double, double* %747
%749 = fsub double %745, %748
%750 = getelementptr inbounds double, double* %0, i64 %736
%751 = load double, double* %750
%752 = fadd double %749, %751
%753 = getelementptr inbounds double, double* %9, i64 %736
store double %752, double* %753
%754 = icmp eq i64 %746, %566
br i1 %754, label %755, label %732
755: ; preds = %727, %732, %713
%756 = call i32 (double*, double*, double*, i32, ...) bitcast (i32 (...)* @Thomas to i32 (double*, double*, double*, i32, ...)*)(double* %14, double* %3, double* %9, i32 %7)
br i1 %340, label %757, label %791
757: ; preds = %755
br i1 %615, label %781, label %758
758: ; preds = %757, %777
%759 = phi i64 [ %778, %777 ], [ 0, %757 ]
%760 = phi i64 [ %779, %777 ], [ 0, %757 ]
%761 = getelementptr inbounds double, double* %3, i64 %759
%762 = load double, double* %761
%763 = fcmp ogt double %762, %6
br i1 %763, label %766, label %764
764: ; preds = %758
%765 = fcmp olt double %762, %558
br i1 %765, label %766, label %768
766: ; preds = %764, %758
%767 = phi double [ %6, %758 ], [ %558, %764 ]
store double %767, double* %761
br label %768
768: ; preds = %766, %764
%769 = or i64 %759, 1
%770 = getelementptr inbounds double, double* %3, i64 %769
%771 = load double, double* %770
%772 = fcmp ogt double %771, %6
br i1 %772, label %775, label %773
773: ; preds = %768
%774 = fcmp olt double %771, %558
br i1 %774, label %775, label %777
775: ; preds = %773, %768
%776 = phi double [ %6, %768 ], [ %558, %773 ]
store double %776, double* %770
br label %777
777: ; preds = %775, %773
%778 = add nuw nsw i64 %759, 2
%779 = add i64 %760, 2
%780 = icmp eq i64 %779, %616
br i1 %780, label %781, label %758
781: ; preds = %777, %757
%782 = phi i64 [ 0, %757 ], [ %778, %777 ]
br i1 %617, label %791, label %783
783: ; preds = %781
%784 = getelementptr inbounds double, double* %3, i64 %782
%785 = load double, double* %784
%786 = fcmp ogt double %785, %6
br i1 %786, label %789, label %787
787: ; preds = %783
%788 = fcmp olt double %785, %558
br i1 %788, label %789, label %791
789: ; preds = %787, %783
%790 = phi double [ %6, %783 ], [ %558, %787 ]
store double %790, double* %784
br label %791
791: ; preds = %781, %789, %787, %730, %755
%792 = load double, double* %3
%793 = fadd double %792, %792
%794 = load double, double* %22
%795 = fsub double %793, %794
%796 = load double, double* %5
%797 = fsub double %795, %796
store double %797, double* %10
br i1 %28, label %798, label %897
798: ; preds = %791
%799 = select i1 %618, i1 true, i1 %625
br i1 %799, label %843, label %800
800: ; preds = %798, %800
%801 = phi i64 [ %840, %800 ], [ 0, %798 ]
%802 = or i64 %801, 1
%803 = getelementptr inbounds double, double* %3, i64 %801
%804 = bitcast double* %803 to <2 x double>*
%805 = load <2 x double>, <2 x double>* %804
%806 = getelementptr inbounds double, double* %803, i64 2
%807 = bitcast double* %806 to <2 x double>*
%808 = load <2 x double>, <2 x double>* %807
%809 = getelementptr inbounds double, double* %3, i64 %802
%810 = bitcast double* %809 to <2 x double>*
%811 = load <2 x double>, <2 x double>* %810
%812 = getelementptr inbounds double, double* %809, i64 2
%813 = bitcast double* %812 to <2 x double>*
%814 = load <2 x double>, <2 x double>* %813
%815 = fsub <2 x double> %811, %805
%816 = fsub <2 x double> %814, %808
%817 = fadd <2 x double> %811, %815
%818 = fadd <2 x double> %814, %816
%819 = or i64 %801, 2
%820 = getelementptr inbounds double, double* %3, i64 %819
%821 = bitcast double* %820 to <2 x double>*
%822 = load <2 x double>, <2 x double>* %821
%823 = getelementptr inbounds double, double* %820, i64 2
%824 = bitcast double* %823 to <2 x double>*
%825 = load <2 x double>, <2 x double>* %824
%826 = fsub <2 x double> %817, %822
%827 = fsub <2 x double> %818, %825
%828 = getelementptr inbounds double, double* %5, i64 %802
%829 = bitcast double* %828 to <2 x double>*
%830 = load <2 x double>, <2 x double>* %829
%831 = getelementptr inbounds double, double* %828, i64 2
%832 = bitcast double* %831 to <2 x double>*
%833 = load <2 x double>, <2 x double>* %832
%834 = fsub <2 x double> %826, %830
%835 = fsub <2 x double> %827, %833
%836 = getelementptr inbounds double, double* %10, i64 %802
%837 = bitcast double* %836 to <2 x double>*
store <2 x double> %834, <2 x double>* %837
%838 = getelementptr inbounds double, double* %836, i64 2
%839 = bitcast double* %838 to <2 x double>*
store <2 x double> %835, <2 x double>* %839
%840 = add nuw i64 %801, 4
%841 = icmp eq i64 %840, %626
br i1 %841, label %842, label %800
842: ; preds = %800
br i1 %628, label %897, label %843
843: ; preds = %798, %842
%844 = phi i64 [ 1, %798 ], [ %627, %842 ]
%845 = xor i64 %844, -1
br i1 %630, label %846, label %862
846: ; preds = %843
%847 = add nsw i64 %844, -1
%848 = getelementptr inbounds double, double* %3, i64 %847
%849 = load double, double* %848
%850 = getelementptr inbounds double, double* %3, i64 %844
%851 = load double, double* %850
%852 = fsub double %851, %849
%853 = fadd double %851, %852
%854 = add nuw nsw i64 %844, 1
%855 = getelementptr inbounds double, double* %3, i64 %854
%856 = load double, double* %855
%857 = fsub double %853, %856
%858 = getelementptr inbounds double, double* %5, i64 %844
%859 = load double, double* %858
%860 = fsub double %857, %859
%861 = getelementptr inbounds double, double* %10, i64 %844
store double %860, double* %861
br label %862
862: ; preds = %846, %843
%863 = phi i64 [ %844, %843 ], [ %854, %846 ]
%864 = icmp eq i64 %845, %631
br i1 %864, label %897, label %865
865: ; preds = %862, %865
%866 = phi i64 [ %888, %865 ], [ %863, %862 ]
%867 = add nsw i64 %866, -1
%868 = getelementptr inbounds double, double* %3, i64 %867
%869 = load double, double* %868
%870 = getelementptr inbounds double, double* %3, i64 %866
%871 = load double, double* %870
%872 = fsub double %871, %869
%873 = fadd double %871, %872
%874 = add nuw nsw i64 %866, 1
%875 = getelementptr inbounds double, double* %3, i64 %874
%876 = load double, double* %875
%877 = fsub double %873, %876
%878 = getelementptr inbounds double, double* %5, i64 %866
%879 = load double, double* %878
%880 = fsub double %877, %879
%881 = getelementptr inbounds double, double* %10, i64 %866
store double %880, double* %881
%882 = getelementptr inbounds double, double* %3, i64 %866
%883 = load double, double* %882
%884 = getelementptr inbounds double, double* %3, i64 %874
%885 = load double, double* %884
%886 = fsub double %885, %883
%887 = fadd double %885, %886
%888 = add nuw nsw i64 %866, 2
%889 = getelementptr inbounds double, double* %3, i64 %888
%890 = load double, double* %889
%891 = fsub double %887, %890
%892 = getelementptr inbounds double, double* %5, i64 %874
%893 = load double, double* %892
%894 = fsub double %891, %893
%895 = getelementptr inbounds double, double* %10, i64 %874
store double %894, double* %895
%896 = icmp eq i64 %888, %567
br i1 %896, label %897, label %865
897: ; preds = %862, %865, %842, %791
%898 = load double, double* %154
%899 = load double, double* %157
%900 = fsub double %899, %898
%901 = fadd double %899, %900
%902 = load double, double* %161
%903 = fsub double %901, %902
store double %903, double* %164
br i1 %559, label %937, label %904
904: ; preds = %897
%905 = load double, double* %3
%906 = load double, double* %10
%907 = fmul double %906, 2.500000e-01
%908 = fsub double %905, %907
store double %908, double* %3
br i1 %632, label %937, label %909
909: ; preds = %904
%910 = load double, double* %633
%911 = load double, double* %634
%912 = fmul double %911, 2.500000e-01
%913 = fsub double %910, %912
store double %913, double* %633
br i1 %635, label %937, label %914
914: ; preds = %909
%915 = load double, double* %636
%916 = load double, double* %637
%917 = fmul double %916, 2.500000e-01
%918 = fsub double %915, %917
store double %918, double* %636
br i1 %638, label %937, label %919
919: ; preds = %914
%920 = load double, double* %639
%921 = load double, double* %640
%922 = fmul double %921, 2.500000e-01
%923 = fsub double %920, %922
store double %923, double* %639
br i1 %641, label %937, label %924
924: ; preds = %919
%925 = load double, double* %642
%926 = load double, double* %643
%927 = fmul double %926, 2.500000e-01
%928 = fsub double %925, %927
store double %928, double* %642
%929 = load double, double* %644
%930 = load double, double* %645
%931 = fmul double %930, 2.500000e-01
%932 = fsub double %929, %931
store double %932, double* %644
%933 = load double, double* %646
%934 = load double, double* %647
%935 = fmul double %934, 2.500000e-01
%936 = fsub double %933, %935
store double %936, double* %646
br label %937
937: ; preds = %904, %909, %914, %919, %924, %897
br i1 %217, label %938, label %1035
938: ; preds = %937
%939 = select i1 %648, i1 true, i1 %651
br i1 %939, label %1033, label %940
940: ; preds = %938, %940
%941 = phi i64 [ %1030, %940 ], [ 0, %938 ]
%942 = mul i64 %941, 5
%943 = add i64 %942, %564
%944 = add i64 %943, 5
%945 = getelementptr inbounds double, double* %3, i64 %943
%946 = getelementptr inbounds double, double* %3, i64 %944
%947 = load double, double* %945
%948 = load double, double* %946
%949 = insertelement <2 x double> poison, double %947, i64 0
%950 = insertelement <2 x double> %949, double %948, i64 1
%951 = getelementptr inbounds double, double* %10, i64 %943
%952 = getelementptr inbounds double, double* %10, i64 %944
%953 = load double, double* %951
%954 = load double, double* %952
%955 = insertelement <2 x double> poison, double %953, i64 0
%956 = insertelement <2 x double> %955, double %954, i64 1
%957 = fmul <2 x double> %956, <double 2.500000e-01, double 2.500000e-01>
%958 = fsub <2 x double> %950, %957
%959 = add nsw i64 %943, 1
%960 = add i64 %943, 6
%961 = getelementptr inbounds double, double* %3, i64 %959
%962 = getelementptr inbounds double, double* %3, i64 %960
%963 = load double, double* %961
%964 = load double, double* %962
%965 = insertelement <2 x double> poison, double %963, i64 0
%966 = insertelement <2 x double> %965, double %964, i64 1
%967 = getelementptr inbounds double, double* %10, i64 %959
%968 = getelementptr inbounds double, double* %10, i64 %960
%969 = load double, double* %967
%970 = load double, double* %968
%971 = insertelement <2 x double> poison, double %969, i64 0
%972 = insertelement <2 x double> %971, double %970, i64 1
%973 = fmul <2 x double> %972, <double 2.500000e-01, double 2.500000e-01>
%974 = fsub <2 x double> %966, %973
%975 = add nsw i64 %943, 2
%976 = add i64 %943, 7
%977 = getelementptr inbounds double, double* %3, i64 %975
%978 = getelementptr inbounds double, double* %3, i64 %976
%979 = load double, double* %977
%980 = load double, double* %978
%981 = insertelement <2 x double> poison, double %979, i64 0
%982 = insertelement <2 x double> %981, double %980, i64 1
%983 = getelementptr inbounds double, double* %10, i64 %975
%984 = getelementptr inbounds double, double* %10, i64 %976
%985 = load double, double* %983
%986 = load double, double* %984
%987 = insertelement <2 x double> poison, double %985, i64 0
%988 = insertelement <2 x double> %987, double %986, i64 1
%989 = fmul <2 x double> %988, <double 2.500000e-01, double 2.500000e-01>
%990 = fsub <2 x double> %982, %989
%991 = add nsw i64 %943, 3
%992 = add i64 %943, 8
%993 = getelementptr inbounds double, double* %3, i64 %991
%994 = getelementptr inbounds double, double* %3, i64 %992
%995 = load double, double* %993
%996 = load double, double* %994
%997 = insertelement <2 x double> poison, double %995, i64 0
%998 = insertelement <2 x double> %997, double %996, i64 1
%999 = getelementptr inbounds double, double* %10, i64 %991
%1000 = getelementptr inbounds double, double* %10, i64 %992
%1001 = load double, double* %999
%1002 = load double, double* %1000
%1003 = insertelement <2 x double> poison, double %1001, i64 0
%1004 = insertelement <2 x double> %1003, double %1002, i64 1
%1005 = fmul <2 x double> %1004, <double 2.500000e-01, double 2.500000e-01>
%1006 = fsub <2 x double> %998, %1005
%1007 = add nsw i64 %943, 4
%1008 = add i64 %943, 9
%1009 = getelementptr inbounds double, double* %3, i64 %1007
%1010 = getelementptr inbounds double, double* %3, i64 %1008
%1011 = load double, double* %1009
%1012 = load double, double* %1010
%1013 = insertelement <2 x double> poison, double %1011, i64 0
%1014 = insertelement <2 x double> %1013, double %1012, i64 1
%1015 = getelementptr inbounds double, double* %10, i64 %1007
%1016 = getelementptr inbounds double, double* %10, i64 %1008
%1017 = load double, double* %1015
%1018 = load double, double* %1016
%1019 = insertelement <2 x double> poison, double %1017, i64 0
%1020 = insertelement <2 x double> %1019, double %1018, i64 1
%1021 = fmul <2 x double> %1020, <double 2.500000e-01, double 2.500000e-01>
%1022 = fsub <2 x double> %1014, %1021
%1023 = getelementptr inbounds double, double* %3, i64 %943
%1024 = bitcast double* %1023 to <10 x double>*
%1025 = shufflevector <2 x double> %958, <2 x double> %974, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
%1026 = shufflevector <2 x double> %990, <2 x double> %1006, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
%1027 = shufflevector <4 x double> %1025, <4 x double> %1026, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
%1028 = shufflevector <2 x double> %1022, <2 x double> poison, <8 x i32> <i32 0, i32 1, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef>
%1029 = shufflevector <8 x double> %1027, <8 x double> %1028, <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> %1029, <10 x double>* %1024
%1030 = add nuw i64 %941, 2
%1031 = icmp eq i64 %1030, %652
br i1 %1031, label %1032, label %940
1032: ; preds = %940
br i1 %655, label %1035, label %1033
1033: ; preds = %938, %1032
%1034 = phi i64 [ %564, %938 ], [ %654, %1032 ]
br label %1037
1035: ; preds = %1037, %1032, %937
br i1 %340, label %1036, label %1108
1036: ; preds = %1035
br i1 %657, label %1098, label %1075
1037: ; preds = %1033, %1037
%1038 = phi i64 [ %1073, %1037 ], [ %1034, %1033 ]
%1039 = getelementptr inbounds double, double* %3, i64 %1038
%1040 = load double, double* %1039
%1041 = getelementptr inbounds double, double* %10, i64 %1038
%1042 = load double, double* %1041
%1043 = fmul double %1042, 2.500000e-01
%1044 = fsub double %1040, %1043
store double %1044, double* %1039
%1045 = add nsw i64 %1038, 1
%1046 = getelementptr inbounds double, double* %3, i64 %1045
%1047 = load double, double* %1046
%1048 = getelementptr inbounds double, double* %10, i64 %1045
%1049 = load double, double* %1048
%1050 = fmul double %1049, 2.500000e-01
%1051 = fsub double %1047, %1050
store double %1051, double* %1046
%1052 = add nsw i64 %1038, 2
%1053 = getelementptr inbounds double, double* %3, i64 %1052
%1054 = load double, double* %1053
%1055 = getelementptr inbounds double, double* %10, i64 %1052
%1056 = load double, double* %1055
%1057 = fmul double %1056, 2.500000e-01
%1058 = fsub double %1054, %1057
store double %1058, double* %1053
%1059 = add nsw i64 %1038, 3
%1060 = getelementptr inbounds double, double* %3, i64 %1059
%1061 = load double, double* %1060
%1062 = getelementptr inbounds double, double* %10, i64 %1059
%1063 = load double, double* %1062
%1064 = fmul double %1063, 2.500000e-01
%1065 = fsub double %1061, %1064
store double %1065, double* %1060
%1066 = add nsw i64 %1038, 4
%1067 = getelementptr inbounds double, double* %3, i64 %1066
%1068 = load double, double* %1067
%1069 = getelementptr inbounds double, double* %10, i64 %1066
%1070 = load double, double* %1069
%1071 = fmul double %1070, 2.500000e-01
%1072 = fsub double %1068, %1071
store double %1072, double* %1067
%1073 = add nsw i64 %1038, 5
%1074 = icmp slt i64 %1073, %16
br i1 %1074, label %1037, label %1035
1075: ; preds = %1036, %1094
%1076 = phi i64 [ %1095, %1094 ], [ 0, %1036 ]
%1077 = phi i64 [ %1096, %1094 ], [ 0, %1036 ]
%1078 = getelementptr inbounds double, double* %3, i64 %1076
%1079 = load double, double* %1078
%1080 = fcmp ogt double %1079, %6
br i1 %1080, label %1083, label %1081
1081: ; preds = %1075
%1082 = fcmp olt double %1079, %558
br i1 %1082, label %1083, label %1085
1083: ; preds = %1081, %1075
%1084 = phi double [ %6, %1075 ], [ %558, %1081 ]
store double %1084, double* %1078
br label %1085
1085: ; preds = %1083, %1081
%1086 = or i64 %1076, 1
%1087 = getelementptr inbounds double, double* %3, i64 %1086
%1088 = load double, double* %1087
%1089 = fcmp ogt double %1088, %6
br i1 %1089, label %1092, label %1090
1090: ; preds = %1085
%1091 = fcmp olt double %1088, %558
br i1 %1091, label %1092, label %1094
1092: ; preds = %1090, %1085
%1093 = phi double [ %6, %1085 ], [ %558, %1090 ]
store double %1093, double* %1087
br label %1094
1094: ; preds = %1092, %1090
%1095 = add nuw nsw i64 %1076, 2
%1096 = add i64 %1077, 2
%1097 = icmp eq i64 %1096, %658
br i1 %1097, label %1098, label %1075
1098: ; preds = %1094, %1036
%1099 = phi i64 [ 0, %1036 ], [ %1095, %1094 ]
br i1 %659, label %1108, label %1100
1100: ; preds = %1098
%1101 = getelementptr inbounds double, double* %3, i64 %1099
%1102 = load double, double* %1101
%1103 = fcmp ogt double %1102, %6
br i1 %1103, label %1106, label %1104
1104: ; preds = %1100
%1105 = fcmp olt double %1102, %558
br i1 %1105, label %1106, label %1108
1106: ; preds = %1104, %1100
%1107 = phi double [ %6, %1100 ], [ %558, %1104 ]
store double %1107, double* %1101
br label %1108
1108: ; preds = %1098, %1106, %1104, %1035
%1109 = load double, double* %3
%1110 = fadd double %1109, %1109
%1111 = load double, double* %22
%1112 = fsub double %1110, %1111
%1113 = load double, double* %5
%1114 = fsub double %1112, %1113
store double %1114, double* %10
br i1 %28, label %1115, label %1214
1115: ; preds = %1108
%1116 = select i1 %660, i1 true, i1 %667
br i1 %1116, label %1160, label %1117
1117: ; preds = %1115, %1117
%1118 = phi i64 [ %1157, %1117 ], [ 0, %1115 ]
%1119 = or i64 %1118, 1
%1120 = getelementptr inbounds double, double* %3, i64 %1118
%1121 = bitcast double* %1120 to <2 x double>*
%1122 = load <2 x double>, <2 x double>* %1121
%1123 = getelementptr inbounds double, double* %1120, i64 2
%1124 = bitcast double* %1123 to <2 x double>*
%1125 = load <2 x double>, <2 x double>* %1124
%1126 = getelementptr inbounds double, double* %3, i64 %1119
%1127 = bitcast double* %1126 to <2 x double>*
%1128 = load <2 x double>, <2 x double>* %1127
%1129 = getelementptr inbounds double, double* %1126, i64 2
%1130 = bitcast double* %1129 to <2 x double>*
%1131 = load <2 x double>, <2 x double>* %1130
%1132 = fsub <2 x double> %1128, %1122
%1133 = fsub <2 x double> %1131, %1125
%1134 = fadd <2 x double> %1128, %1132
%1135 = fadd <2 x double> %1131, %1133
%1136 = or i64 %1118, 2
%1137 = getelementptr inbounds double, double* %3, i64 %1136
%1138 = bitcast double* %1137 to <2 x double>*
%1139 = load <2 x double>, <2 x double>* %1138
%1140 = getelementptr inbounds double, double* %1137, i64 2
%1141 = bitcast double* %1140 to <2 x double>*
%1142 = load <2 x double>, <2 x double>* %1141
%1143 = fsub <2 x double> %1134, %1139
%1144 = fsub <2 x double> %1135, %1142
%1145 = getelementptr inbounds double, double* %5, i64 %1119
%1146 = bitcast double* %1145 to <2 x double>*
%1147 = load <2 x double>, <2 x double>* %1146
%1148 = getelementptr inbounds double, double* %1145, i64 2
%1149 = bitcast double* %1148 to <2 x double>*
%1150 = load <2 x double>, <2 x double>* %1149
%1151 = fsub <2 x double> %1143, %1147
%1152 = fsub <2 x double> %1144, %1150
%1153 = getelementptr inbounds double, double* %10, i64 %1119
%1154 = bitcast double* %1153 to <2 x double>*
store <2 x double> %1151, <2 x double>* %1154
%1155 = getelementptr inbounds double, double* %1153, i64 2
%1156 = bitcast double* %1155 to <2 x double>*
store <2 x double> %1152, <2 x double>* %1156
%1157 = add nuw i64 %1118, 4
%1158 = icmp eq i64 %1157, %668
br i1 %1158, label %1159, label %1117
1159: ; preds = %1117
br i1 %670, label %1214, label %1160
1160: ; preds = %1115, %1159
%1161 = phi i64 [ 1, %1115 ], [ %669, %1159 ]
%1162 = xor i64 %1161, -1
br i1 %672, label %1163, label %1179
1163: ; preds = %1160
%1164 = add nsw i64 %1161, -1
%1165 = getelementptr inbounds double, double* %3, i64 %1164
%1166 = load double, double* %1165
%1167 = getelementptr inbounds double, double* %3, i64 %1161
%1168 = load double, double* %1167
%1169 = fsub double %1168, %1166
%1170 = fadd double %1168, %1169
%1171 = add nuw nsw i64 %1161, 1
%1172 = getelementptr inbounds double, double* %3, i64 %1171
%1173 = load double, double* %1172
%1174 = fsub double %1170, %1173
%1175 = getelementptr inbounds double, double* %5, i64 %1161
%1176 = load double, double* %1175
%1177 = fsub double %1174, %1176
%1178 = getelementptr inbounds double, double* %10, i64 %1161
store double %1177, double* %1178
br label %1179
1179: ; preds = %1163, %1160
%1180 = phi i64 [ %1161, %1160 ], [ %1171, %1163 ]
%1181 = icmp eq i64 %1162, %673
br i1 %1181, label %1214, label %1182
1182: ; preds = %1179, %1182
%1183 = phi i64 [ %1205, %1182 ], [ %1180, %1179 ]
%1184 = add nsw i64 %1183, -1
%1185 = getelementptr inbounds double, double* %3, i64 %1184
%1186 = load double, double* %1185
%1187 = getelementptr inbounds double, double* %3, i64 %1183
%1188 = load double, double* %1187
%1189 = fsub double %1188, %1186
%1190 = fadd double %1188, %1189
%1191 = add nuw nsw i64 %1183, 1
%1192 = getelementptr inbounds double, double* %3, i64 %1191
%1193 = load double, double* %1192
%1194 = fsub double %1190, %1193
%1195 = getelementptr inbounds double, double* %5, i64 %1183
%1196 = load double, double* %1195
%1197 = fsub double %1194, %1196
%1198 = getelementptr inbounds double, double* %10, i64 %1183
store double %1197, double* %1198
%1199 = getelementptr inbounds double, double* %3, i64 %1183
%1200 = load double, double* %1199
%1201 = getelementptr inbounds double, double* %3, i64 %1191
%1202 = load double, double* %1201
%1203 = fsub double %1202, %1200
%1204 = fadd double %1202, %1203
%1205 = add nuw nsw i64 %1183, 2
%1206 = getelementptr inbounds double, double* %3, i64 %1205
%1207 = load double, double* %1206
%1208 = fsub double %1204, %1207
%1209 = getelementptr inbounds double, double* %5, i64 %1191
%1210 = load double, double* %1209
%1211 = fsub double %1208, %1210
%1212 = getelementptr inbounds double, double* %10, i64 %1191
store double %1211, double* %1212
%1213 = icmp eq i64 %1205, %568
br i1 %1213, label %1214, label %1182
1214: ; preds = %1179, %1182, %1159, %1108
%1215 = load double, double* %154
%1216 = load double, double* %157
%1217 = fsub double %1216, %1215
%1218 = fadd double %1216, %1217
%1219 = load double, double* %161
%1220 = fsub double %1218, %1219
store double %1220, double* %164
%1221 = srem i32 %678, %12
%1222 = icmp eq i32 %1221, 0
br i1 %1222, label %1223, label %1240
1223: ; preds = %1214
%1224 = load double, double* %1
%1225 = call i32 (double*, double*, double*, double*, double*, double, i32, ...) bitcast (i32 (...)* @dualityGap2 to i32 (double*, double*, double*, double*, double*, double, i32, ...)*)(double* %1, double* %3, double* %10, double* %9, double* %5, double %6, i32 %7)
%1226 = load double, double* %1
%1227 = fcmp ugt double %1226, %11
br i1 %1227, label %1228, label %1244
1228: ; preds = %1223
%1229 = sub nsw i32 %679, %676
%1230 = call i32 @llvm.abs.i32(i32 %1229, i1 true)
%1231 = icmp ult i32 %1230, %563
br i1 %1231, label %1232, label %1240
1232: ; preds = %1228
%1233 = call i32 (double*, double*, double*, double*, double*, double*, double*, i32*, double, i32, ...) bitcast (i32 (...)* @generateSolution to i32 (double*, double*, double*, double*, double*, double*, double*, i32*, double, i32, ...)*)(double* %0, double* %3, double* %1, double* %4, double* %5, double* %10, double* %9, i32* %19, double %6, i32 %7)
%1234 = load double, double* %1
%1235 = fcmp olt double %1234, %11
br i1 %1235, label %1247, label %1236
1236: ; preds = %1232
%1237 = fcmp oeq double %1234, %677
%1238 = icmp eq i32 %679, %675
%1239 = select i1 %1237, i1 %1238, i1 false
br i1 %1239, label %1247, label %1240
1240: ; preds = %1214, %1236, %1228
%1241 = phi double [ %1224, %1236 ], [ %1224, %1228 ], [ %677, %1214 ]
%1242 = add nuw i32 %678, 1
%1243 = icmp eq i32 %678, %8
br i1 %1243, label %1244, label %674
1244: ; preds = %1223, %1240, %549
%1245 = phi i32 [ 1, %549 ], [ %565, %1240 ], [ %678, %1223 ]
%1246 = call i32 (double*, double*, double*, double*, double*, double*, double*, i32*, double, i32, ...) bitcast (i32 (...)* @generateSolution to i32 (double*, double*, double*, double*, double*, double*, double*, i32*, double, i32, ...)*)(double* %0, double* %3, double* %1, double* %4, double* %5, double* %10, double* %9, i32* %19, double %6, i32 %7)
br label %1247
1247: ; preds = %1236, %1232, %1244
%1248 = phi i32 [ %1245, %1244 ], [ %678, %1232 ], [ %678, %1236 ]
%1249 = phi i32 [ %1246, %1244 ], [ %675, %1236 ], [ %1233, %1232 ]
store i32 %1249, i32* %2
ret i32 %1248
}