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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ Thomas(double *, double *, double *, int);
int /*<<< orphan*/ dualityGap(double *, double *, double *, double *, double *,
                              double, int);
scalar_t__ fabs(int);
int /*<<< orphan*/ free(int *);
scalar_t__ malloc(int);
int supportSet(double *, double *, double *, double *, int *, double, int);
int sfa_special(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;
  double temp;
  int *S = (int *)malloc(sizeof(int) * nn);
  double gapp = -1;
  int numS = -1, numSp = -1;
  *gap = -1;
  for (iterStep = 1; iterStep <= maxStep; iterStep++) {
    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];
    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;
    }
    if (iterStep % tau == 0) {
      gapp = *gap;
      dualityGap(gap, z, g, s, Av, lambda, nn);
      if (*gap <= tol) {
        break;
      }
      if ((*gap < 1) && (numS == numSp) && fabs(gapp == *gap)) {
        break;
      }
    }
  }
  free(S);
  *activeS = numS;
  return (iterStep);
}


x86 assembly (clang, -O0):
<sfa_special>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%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)
movslq 0x10(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1060 <malloc@plt>
mov    %rax,-0x58(%rbp)
movsd  0xe4a(%rip),%xmm0
movsd  %xmm0,-0x60(%rbp)
movl   $0xffffffff,-0x64(%rbp)
movl   $0xffffffff,-0x68(%rbp)
mov    -0x10(%rbp),%rax
movsd  0xe2b(%rip),%xmm0
movsd  %xmm0,(%rax)
movl   $0x1,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    0x18(%rbp),%eax
jg     152d <sfa_special+0x3cd>
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    12aa <sfa_special+0x14a>
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    121c <sfa_special+0xbc>
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    -0x64(%rbp),%eax
mov    %eax,-0x68(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x28(%rbp),%rsi
mov    -0x20(%rbp),%rdx
mov    0x28(%rbp),%rcx
mov    -0x58(%rbp),%r8
movsd  -0x38(%rbp),%xmm0
mov    0x10(%rbp),%r9d
call   1070 <supportSet@plt>
mov    %eax,-0x64(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    13a0 <sfa_special+0x240>
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    134d <sfa_special+0x1ed>
mov    -0x20(%rbp),%rsi
mov    0x20(%rbp),%rdx
mov    0x10(%rbp),%ecx
lea    -0x50(%rbp),%rdi
call   1080 <Thomas@plt>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    146a <sfa_special+0x30a>
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd -0x38(%rbp),%xmm0
jbe    13f6 <sfa_special+0x296>
movsd  -0x38(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1457 <sfa_special+0x2f7>
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    1452 <sfa_special+0x2f2>
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    1457 <sfa_special+0x2f7>
jmp    145c <sfa_special+0x2fc>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    13bb <sfa_special+0x25b>
mov    -0x48(%rbp),%eax
cltd
idivl  0x30(%rbp)
cmp    $0x0,%edx
jne    151a <sfa_special+0x3ba>
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x10(%rbp),%rdi
mov    -0x20(%rbp),%rsi
mov    0x28(%rbp),%rdx
mov    0x20(%rbp),%rcx
mov    -0x30(%rbp),%r8
movsd  -0x38(%rbp),%xmm0
mov    0x10(%rbp),%r9d
call   1040 <dualityGap@plt>
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm1
movsd  -0x40(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jb     14c5 <sfa_special+0x365>
jmp    152d <sfa_special+0x3cd>
mov    -0x10(%rbp),%rax
movsd  0xb37(%rip),%xmm0
ucomisd (%rax),%xmm0
jbe    1515 <sfa_special+0x3b5>
mov    -0x64(%rbp),%eax
cmp    -0x68(%rbp),%eax
jne    1515 <sfa_special+0x3b5>
movsd  -0x60(%rbp),%xmm0
mov    -0x10(%rbp),%rax
ucomisd (%rax),%xmm0
sete   %al
setnp  %cl
and    %cl,%al
and    $0x1,%al
movzbl %al,%edi
call   1050 <fabs@plt>
cmp    $0x0,%rax
je     1515 <sfa_special+0x3b5>
jmp    152d <sfa_special+0x3cd>
jmp    151a <sfa_special+0x3ba>
jmp    151f <sfa_special+0x3bf>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    11e0 <sfa_special+0x80>
mov    -0x58(%rbp),%rdi
call   1030 <free@plt>
mov    -0x64(%rbp),%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x48(%rbp),%eax
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<sfa_special>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xe8,%rsp
movsd  %xmm1,0xa0(%rsp)
movapd %xmm0,0x40(%rsp)
mov    %r9,%r13
mov    %r8,0xc0(%rsp)
mov    %rcx,%rbx
mov    %rdx,%r15
mov    %rsi,%rbp
mov    %rdi,%r14
mov    0x128(%rsp),%r12d
mov    0x120(%rsp),%eax
lea    0x0(,%rax,4),%edi
call   1060 <malloc@plt>
mov    %rax,0x60(%rsp)
movabs $0xbff0000000000000,%rax
mov    %rbp,0x98(%rsp)
mov    %rax,0x0(%rbp)
test   %r12d,%r12d
jle    1824 <sfa_special+0x6c4>
mov    %r15,0x28(%rsp)
mov    0x138(%rsp),%rdi
mov    0x130(%rsp),%rbp
mov    0x120(%rsp),%eax
mov    %rax,%rdx
lea    -0x1(%rax),%ecx
add    $0xfffffffe,%eax
cltq
mov    %rax,0xb8(%rsp)
movslq %ecx,%rax
mov    %rax,0xb0(%rsp)
movapd 0xde8(%rip),%xmm6
movapd 0x40(%rsp),%xmm5
xorpd  %xmm5,%xmm6
mov    %edx,%esi
lea    0x0(%rbp,%rsi,8),%r15
lea    0x0(%r13,%rsi,8),%rax
mov    %rax,0x10(%rsp)
lea    0x8(%rdi),%rdx
lea    (%rdi,%rcx,8),%r8
lea    0x8(%rbx,%rcx,8),%rdi
lea    0x8(%r13),%r10
lea    0x0(,%rcx,8),%r11
add    %r13,%r11
lea    -0x1(%rcx),%r9
cmp    %rdi,%rdx
mov    %rcx,%rdi
setb   %cl
cmp    %rbx,%r8
seta   %al
and    %cl,%al
cmp    %r11,%rdx
setb   %cl
cmp    %r8,%r10
setb   %dl
and    %cl,%dl
or     %al,%dl
mov    %dl,0xa(%rsp)
mov    %r9,0x50(%rsp)
and    $0xfffffffffffffffc,%r9
mov    %rdi,%rax
neg    %rax
mov    %rax,0x90(%rsp)
cmp    %rbp,0x10(%rsp)
mov    0x138(%rsp),%rcx
seta   %al
lea    (%r14,%rsi,8),%r8
add    $0x8,%r8
cmp    %r13,%r15
seta   %dl
and    %al,%dl
cmp    %rbp,%r8
seta   %r8b
lea    0x1(%r12),%eax
mov    %eax,0x3c(%rsp)
cmp    %r14,%r15
seta   %al
and    %r8b,%al
or     %dl,%al
mov    %al,0xb(%rsp)
mov    %esi,%eax
and    $0xfffffffc,%eax
mov    %rax,0x88(%rsp)
mov    %esi,%eax
and    $0xfffffffe,%eax
mov    %rax,0x68(%rsp)
lea    0x0(,%rsi,8),%rax
and    $0xffffffffffffffe0,%rax
mov    %rax,0x80(%rsp)
mov    %rsi,0x30(%rsp)
lea    -0x1(%rsi),%rax
mov    %rax,0x58(%rsp)
mov    %r9,0x78(%rsp)
lea    0x1(%r9),%rax
mov    %rax,0x70(%rsp)
mov    $0x1,%esi
movl   $0xffffffff,0xc(%rsp)
ff
mov    0x120(%rsp),%r15d
mov    %rdi,0x20(%rsp)
movapd %xmm6,0xd0(%rsp)
jmp    134e <sfa_special+0x1ee>
nopw   0x0(%rax,%rax,1)
lea    0x1(%rsi),%eax
cmp    %r12d,%esi
mov    %eax,%esi
je     1817 <sfa_special+0x6b7>
mov    0xc(%rsp),%eax
mov    %eax,0x1c(%rsp)
movsd  (%rbx),%xmm0
addsd  %xmm0,%xmm0
subsd  0x8(%rbx),%xmm0
subsd  0x0(%r13),%xmm0
movsd  %xmm0,(%rcx)
cmp    $0x3,%r15d
jl     14c0 <sfa_special+0x360>
cmpq   $0x4,0x50(%rsp)
setb   %al
or     0xa(%rsp),%al
mov    $0x1,%edx
jne    141b <sfa_special+0x2bb>
xor    %eax,%eax
mov    0x78(%rsp),%rdx
cs nopw 0x0(%rax,%rax,1)
movupd (%rbx,%rax,8),%xmm0
movupd 0x8(%rbx,%rax,8),%xmm1
movupd 0x10(%rbx,%rax,8),%xmm2
movupd 0x18(%rbx,%rax,8),%xmm3
movapd %xmm1,%xmm4
subpd  %xmm0,%xmm4
movapd %xmm3,%xmm0
subpd  %xmm2,%xmm0
addpd  %xmm1,%xmm4
addpd  %xmm3,%xmm0
movupd 0x20(%rbx,%rax,8),%xmm1
subpd  %xmm1,%xmm0
subpd  %xmm2,%xmm4
movupd 0x8(%r13,%rax,8),%xmm1
subpd  %xmm1,%xmm4
movupd 0x18(%r13,%rax,8),%xmm1
subpd  %xmm1,%xmm0
movupd %xmm4,0x8(%rcx,%rax,8)
movupd %xmm0,0x18(%rcx,%rax,8)
add    $0x4,%rax
cmp    %rax,%rdx
jne    13a0 <sfa_special+0x240>
mov    %rdx,%rax
mov    0x70(%rsp),%rdx
cmp    %rax,0x50(%rsp)
je     14c0 <sfa_special+0x360>
mov    %rdx,%rax
test   $0x1,%dil
jne    144d <sfa_special+0x2ed>
movsd  (%rbx,%rdx,8),%xmm0
movapd %xmm0,%xmm1
subsd  -0x8(%rbx,%rdx,8),%xmm1
addsd  %xmm0,%xmm1
subsd  0x8(%rbx,%rdx,8),%xmm1
lea    0x1(%rdx),%rax
subsd  0x0(%r13,%rdx,8),%xmm1
movsd  %xmm1,(%rcx,%rdx,8)
not    %rdx
cmp    0x90(%rsp),%rdx
je     14c0 <sfa_special+0x360>
nopw   0x0(%rax,%rax,1)
movsd  (%rbx,%rax,8),%xmm0
movapd %xmm0,%xmm1
subsd  -0x8(%rbx,%rax,8),%xmm1
addsd  %xmm0,%xmm1
subsd  0x8(%rbx,%rax,8),%xmm1
subsd  0x0(%r13,%rax,8),%xmm1
movsd  %xmm1,(%rcx,%rax,8)
movsd  0x8(%rbx,%rax,8),%xmm0
movapd %xmm0,%xmm1
subsd  (%rbx,%rax,8),%xmm1
addsd  %xmm0,%xmm1
subsd  0x10(%rbx,%rax,8),%xmm1
subsd  0x8(%r13,%rax,8),%xmm1
movsd  %xmm1,0x8(%rcx,%rax,8)
lea    0x2(%rax),%rdx
mov    %rdx,%rax
cmp    %rdx,%rdi
jne    1460 <sfa_special+0x300>
nopw   0x0(%rax,%rax,1)
mov    %rsi,0x10(%rsp)
mov    0xb0(%rsp),%rdx
movsd  (%rbx,%rdx,8),%xmm0
movapd %xmm0,%xmm1
mov    0xb8(%rsp),%rax
subsd  (%rbx,%rax,8),%xmm1
addsd  %xmm0,%xmm1
subsd  0x0(%r13,%rdx,8),%xmm1
movsd  %xmm1,(%rcx,%rdx,8)
mov    %r14,%rdi
mov    0xc0(%rsp),%rsi
mov    %rbx,%rdx
mov    0x60(%rsp),%r8
movapd %xmm5,%xmm0
mov    %r15d,%r9d
call   1070 <supportSet@plt>
mov    %eax,0xc(%rsp)
test   %r15d,%r15d
jle    1540 <sfa_special+0x3e0>
cmp    $0x4,%r15d
setb   %al
or     0xb(%rsp),%al
je     1580 <sfa_special+0x420>
xor    %ecx,%ecx
mov    0x30(%rsp),%rdx
jmp    15ee <sfa_special+0x48e>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    0xc8(%rsp),%rdi
mov    %rbx,%rsi
mov    %rbp,%rdx
mov    %r15d,%ecx
call   1080 <Thomas@plt>
movapd 0x40(%rsp),%xmm5
mov    0x138(%rsp),%rcx
mov    0x20(%rsp),%rdi
mov    0x10(%rsp),%rsi
jmp    1730 <sfa_special+0x5d0>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
xor    %eax,%eax
mov    0x30(%rsp),%rdx
mov    0x80(%rsp),%rcx
nop
movupd 0x0(%r13,%rax,1),%xmm0
movupd 0x10(%r13,%rax,1),%xmm1
movupd (%r14,%rax,1),%xmm2
movupd 0x8(%r14,%rax,1),%xmm3
subpd  %xmm3,%xmm0
addpd  %xmm2,%xmm0
movupd 0x10(%r14,%rax,1),%xmm2
movupd 0x18(%r14,%rax,1),%xmm3
subpd  %xmm3,%xmm1
addpd  %xmm2,%xmm1
movupd %xmm0,0x0(%rbp,%rax,1)
movupd %xmm1,0x10(%rbp,%rax,1)
add    $0x20,%rax
cmp    %rax,%rcx
jne    1590 <sfa_special+0x430>
mov    0x88(%rsp),%rax
mov    %rax,%rcx
cmp    %rdx,%rax
je     1661 <sfa_special+0x501>
mov    %rcx,%rax
test   $0x1,%dl
je     1616 <sfa_special+0x4b6>
movsd  0x0(%r13,%rcx,8),%xmm0
mov    %rcx,%rax
or     $0x1,%rax
subsd  (%r14,%rax,8),%xmm0
addsd  (%r14,%rcx,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rcx,8)
cmp    %rcx,0x58(%rsp)
je     1661 <sfa_special+0x501>
nopl   (%rax)
movsd  0x0(%r13,%rax,8),%xmm0
subsd  0x8(%r14,%rax,8),%xmm0
addsd  (%r14,%rax,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rax,8)
movsd  0x8(%r13,%rax,8),%xmm0
subsd  0x10(%r14,%rax,8),%xmm0
addsd  0x8(%r14,%rax,8),%xmm0
movsd  %xmm0,0x8(%rbp,%rax,8)
lea    0x2(%rax),%rcx
mov    %rcx,%rax
cmp    %rcx,%rdx
jne    1620 <sfa_special+0x4c0>
lea    0xc8(%rsp),%rdi
mov    %rbx,%rsi
mov    %rbp,%rdx
mov    %r15d,%ecx
call   1080 <Thomas@plt>
test   %r15d,%r15d
movapd 0x40(%rsp),%xmm5
mov    0x138(%rsp),%rcx
mov    0x20(%rsp),%rdi
movapd 0xd0(%rsp),%xmm6
mov    0x10(%rsp),%rsi
jle    1730 <sfa_special+0x5d0>
cmpq   $0x0,0x58(%rsp)
je     1709 <sfa_special+0x5a9>
xor    %eax,%eax
mov    0x68(%rsp),%rdx
jmp    16cf <sfa_special+0x56f>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  %xmm0,0x8(%rbx,%rax,8)
add    $0x2,%rax
cmp    %rax,%rdx
je     170b <sfa_special+0x5ab>
movsd  (%rbx,%rax,8),%xmm1
ucomisd %xmm5,%xmm1
movapd %xmm5,%xmm0
ja     16e8 <sfa_special+0x588>
ucomisd %xmm1,%xmm6
movapd %xmm6,%xmm0
jbe    16ed <sfa_special+0x58d>
movsd  %xmm0,(%rbx,%rax,8)
movsd  0x8(%rbx,%rax,8),%xmm1
ucomisd %xmm5,%xmm1
movapd %xmm5,%xmm0
ja     16c0 <sfa_special+0x560>
ucomisd %xmm1,%xmm6
movapd %xmm6,%xmm0
ja     16c0 <sfa_special+0x560>
jmp    16c6 <sfa_special+0x566>
xor    %eax,%eax
testb  $0x1,0x30(%rsp)
je     1730 <sfa_special+0x5d0>
movsd  (%rbx,%rax,8),%xmm1
ucomisd %xmm5,%xmm1
movapd %xmm5,%xmm0
ja     172b <sfa_special+0x5cb>
ucomisd %xmm1,%xmm6
movapd %xmm6,%xmm0
jbe    1730 <sfa_special+0x5d0>
movsd  %xmm0,(%rbx,%rax,8)
mov    %esi,%eax
cltd
idivl  0x140(%rsp)
test   %edx,%edx
jne    1340 <sfa_special+0x1e0>
mov    %r15,%r9
mov    0x98(%rsp),%r12
movsd  (%r12),%xmm0
movsd  %xmm0,0xa8(%rsp)
mov    %r12,%rdi
mov    %rbx,%rsi
mov    %rcx,%rdx
mov    %rbp,%rcx
mov    %r13,%r8
movapd %xmm5,%xmm0
call   1040 <dualityGap@plt>
movsd  (%r12),%xmm0
movsd  0xa0(%rsp),%xmm1
ucomisd %xmm0,%xmm1
jae    1830 <sfa_special+0x6d0>
movsd  0x87b(%rip),%xmm1
ucomisd %xmm0,%xmm1
movapd 0x40(%rsp),%xmm5
mov    0x128(%rsp),%r12d
mov    0x138(%rsp),%rcx
mov    0x20(%rsp),%rdi
mov    0x10(%rsp),%rsi
jbe    1340 <sfa_special+0x1e0>
mov    0xc(%rsp),%eax
cmp    0x1c(%rsp),%eax
jne    1340 <sfa_special+0x1e0>
movsd  0xa8(%rsp),%xmm1
cmpeqsd %xmm0,%xmm1
movq   %xmm1,%rdi
and    $0x1,%edi
call   1050 <fabs@plt>
mov    0x10(%rsp),%rsi
mov    0x20(%rsp),%rdi
mov    0x138(%rsp),%rcx
movapd 0x40(%rsp),%xmm5
test   %rax,%rax
je     1340 <sfa_special+0x1e0>
mov    0x1c(%rsp),%ebp
mov    0x28(%rsp),%r15
mov    %rsi,%rbx
jmp    183e <sfa_special+0x6de>
mov    0x3c(%rsp),%eax
mov    %eax,%ebx
mov    0x28(%rsp),%r15
jmp    183a <sfa_special+0x6da>
mov    $0xffffffff,%ebp
mov    $0x1,%ebx
jmp    183e <sfa_special+0x6de>
mov    0x28(%rsp),%r15
mov    0x10(%rsp),%rbx
mov    0xc(%rsp),%ebp
mov    0x60(%rsp),%rdi
call   1030 <free@plt>
mov    %ebp,(%r15)
mov    %ebx,%eax
add    $0xe8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define i32 @sfa_special(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 double
%30 = alloca i32*
%31 = alloca double
%32 = alloca i32
%33 = 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
%34 = load i32, i32* %21
%35 = sext i32 %34 to i64
%36 = mul i64 4, %35
%37 = trunc i64 %36 to i32
%38 = call i64 @malloc(i32 %37)
%39 = inttoptr i64 %38 to i32*
store i32* %39, i32** %30
store double -1.000000e+00, double* %31
store i32 -1, i32* %32
store i32 -1, i32* %33
%40 = load double*, double** %15
store double -1.000000e+00, double* %40
store i32 1, i32* %28
br label %41
41: ; preds = %265, %13
%42 = load i32, i32* %28
%43 = load i32, i32* %22
%44 = icmp sle i32 %42, %43
br i1 %44, label %45, label %268
45: ; preds = %41
%46 = load double*, double** %17
%47 = getelementptr inbounds double, double* %46, i64 0
%48 = load double, double* %47
%49 = load double*, double** %17
%50 = getelementptr inbounds double, double* %49, i64 0
%51 = load double, double* %50
%52 = fadd double %48, %51
%53 = load double*, double** %17
%54 = getelementptr inbounds double, double* %53, i64 1
%55 = load double, double* %54
%56 = fsub double %52, %55
%57 = load double*, double** %19
%58 = getelementptr inbounds double, double* %57, i64 0
%59 = load double, double* %58
%60 = fsub double %56, %59
%61 = load double*, double** %24
%62 = getelementptr inbounds double, double* %61, i64 0
store double %60, double* %62
store i32 1, i32* %27
br label %63
63: ; preds = %105, %45
%64 = load i32, i32* %27
%65 = load i32, i32* %21
%66 = sub nsw i32 %65, 1
%67 = icmp slt i32 %64, %66
br i1 %67, label %68, label %108
68: ; preds = %63
%69 = load double*, double** %17
%70 = load i32, i32* %27
%71 = sub nsw i32 %70, 1
%72 = sext i32 %71 to i64
%73 = getelementptr inbounds double, double* %69, i64 %72
%74 = load double, double* %73
%75 = fneg double %74
%76 = load double*, double** %17
%77 = load i32, i32* %27
%78 = sext i32 %77 to i64
%79 = getelementptr inbounds double, double* %76, i64 %78
%80 = load double, double* %79
%81 = fadd double %75, %80
%82 = load double*, double** %17
%83 = load i32, i32* %27
%84 = sext i32 %83 to i64
%85 = getelementptr inbounds double, double* %82, i64 %84
%86 = load double, double* %85
%87 = fadd double %81, %86
%88 = load double*, double** %17
%89 = load i32, i32* %27
%90 = add nsw i32 %89, 1
%91 = sext i32 %90 to i64
%92 = getelementptr inbounds double, double* %88, i64 %91
%93 = load double, double* %92
%94 = fsub double %87, %93
%95 = load double*, double** %19
%96 = load i32, i32* %27
%97 = sext i32 %96 to i64
%98 = getelementptr inbounds double, double* %95, i64 %97
%99 = load double, double* %98
%100 = fsub double %94, %99
%101 = load double*, double** %24
%102 = load i32, i32* %27
%103 = sext i32 %102 to i64
%104 = getelementptr inbounds double, double* %101, i64 %103
store double %100, double* %104
br label %105
105: ; preds = %68
%106 = load i32, i32* %27
%107 = add nsw i32 %106, 1
store i32 %107, i32* %27
br label %63
108: ; preds = %63
%109 = load double*, double** %17
%110 = load i32, i32* %21
%111 = sub nsw i32 %110, 2
%112 = sext i32 %111 to i64
%113 = getelementptr inbounds double, double* %109, i64 %112
%114 = load double, double* %113
%115 = fneg double %114
%116 = load double*, double** %17
%117 = load i32, i32* %21
%118 = sub nsw i32 %117, 1
%119 = sext i32 %118 to i64
%120 = getelementptr inbounds double, double* %116, i64 %119
%121 = load double, double* %120
%122 = fadd double %115, %121
%123 = load double*, double** %17
%124 = load i32, i32* %21
%125 = sub nsw i32 %124, 1
%126 = sext i32 %125 to i64
%127 = getelementptr inbounds double, double* %123, i64 %126
%128 = load double, double* %127
%129 = fadd double %122, %128
%130 = load double*, double** %19
%131 = load i32, i32* %21
%132 = sub nsw i32 %131, 1
%133 = sext i32 %132 to i64
%134 = getelementptr inbounds double, double* %130, i64 %133
%135 = load double, double* %134
%136 = fsub double %129, %135
%137 = load double*, double** %24
%138 = load i32, i32* %21
%139 = sub nsw i32 %138, 1
%140 = sext i32 %139 to i64
%141 = getelementptr inbounds double, double* %137, i64 %140
store double %136, double* %141
%142 = load i32, i32* %32
store i32 %142, i32* %33
%143 = load double*, double** %14
%144 = load double*, double** %18
%145 = load double*, double** %17
%146 = load double*, double** %24
%147 = load i32*, i32** %30
%148 = load double, double* %20
%149 = load i32, i32* %21
%150 = call i32 @supportSet(double* %143, double* %144, double* %145, double* %146, i32* %147, double %148, i32 %149)
store i32 %150, i32* %32
store i32 0, i32* %27
br label %151
151: ; preds = %178, %108
%152 = load i32, i32* %27
%153 = load i32, i32* %21
%154 = icmp slt i32 %152, %153
br i1 %154, label %155, label %181
155: ; preds = %151
%156 = load double*, double** %19
%157 = load i32, i32* %27
%158 = sext i32 %157 to i64
%159 = getelementptr inbounds double, double* %156, i64 %158
%160 = load double, double* %159
%161 = load double*, double** %14
%162 = load i32, i32* %27
%163 = add nsw i32 %162, 1
%164 = sext i32 %163 to i64
%165 = getelementptr inbounds double, double* %161, i64 %164
%166 = load double, double* %165
%167 = fsub double %160, %166
%168 = load double*, double** %14
%169 = load i32, i32* %27
%170 = sext i32 %169 to i64
%171 = getelementptr inbounds double, double* %168, i64 %170
%172 = load double, double* %171
%173 = fadd double %167, %172
%174 = load double*, double** %23
%175 = load i32, i32* %27
%176 = sext i32 %175 to i64
%177 = getelementptr inbounds double, double* %174, i64 %176
store double %173, double* %177
br label %178
178: ; preds = %155
%179 = load i32, i32* %27
%180 = add nsw i32 %179, 1
store i32 %180, i32* %27
br label %151
181: ; preds = %151
%182 = load double*, double** %17
%183 = load double*, double** %23
%184 = load i32, i32* %21
%185 = call i32 @Thomas(double* %29, double* %182, double* %183, i32 %184)
store i32 0, i32* %27
br label %186
186: ; preds = %222, %181
%187 = load i32, i32* %27
%188 = load i32, i32* %21
%189 = icmp slt i32 %187, %188
br i1 %189, label %190, label %225
190: ; preds = %186
%191 = load double*, double** %17
%192 = load i32, i32* %27
%193 = sext i32 %192 to i64
%194 = getelementptr inbounds double, double* %191, i64 %193
%195 = load double, double* %194
%196 = load double, double* %20
%197 = fcmp ogt double %195, %196
br i1 %197, label %198, label %204
198: ; preds = %190
%199 = load double, double* %20
%200 = load double*, double** %17
%201 = load i32, i32* %27
%202 = sext i32 %201 to i64
%203 = getelementptr inbounds double, double* %200, i64 %202
store double %199, double* %203
br label %221
204: ; preds = %190
%205 = load double*, double** %17
%206 = load i32, i32* %27
%207 = sext i32 %206 to i64
%208 = getelementptr inbounds double, double* %205, i64 %207
%209 = load double, double* %208
%210 = load double, double* %20
%211 = fneg double %210
%212 = fcmp olt double %209, %211
br i1 %212, label %213, label %220
213: ; preds = %204
%214 = load double, double* %20
%215 = fneg double %214
%216 = load double*, double** %17
%217 = load i32, i32* %27
%218 = sext i32 %217 to i64
%219 = getelementptr inbounds double, double* %216, i64 %218
store double %215, double* %219
br label %220
220: ; preds = %213, %204
br label %221
221: ; preds = %220, %198
br label %222
222: ; preds = %221
%223 = load i32, i32* %27
%224 = add nsw i32 %223, 1
store i32 %224, i32* %27
br label %186
225: ; preds = %186
%226 = load i32, i32* %28
%227 = load i32, i32* %26
%228 = srem i32 %226, %227
%229 = icmp eq i32 %228, 0
br i1 %229, label %230, label %264
230: ; preds = %225
%231 = load double*, double** %15
%232 = load double, double* %231
store double %232, double* %31
%233 = load double*, double** %15
%234 = load double*, double** %17
%235 = load double*, double** %24
%236 = load double*, double** %23
%237 = load double*, double** %19
%238 = load double, double* %20
%239 = load i32, i32* %21
%240 = call i32 @dualityGap(double* %233, double* %234, double* %235, double* %236, double* %237, double %238, i32 %239)
%241 = load double*, double** %15
%242 = load double, double* %241
%243 = load double, double* %25
%244 = fcmp ole double %242, %243
br i1 %244, label %245, label %246
245: ; preds = %230
br label %268
246: ; preds = %230
%247 = load double*, double** %15
%248 = load double, double* %247
%249 = fcmp olt double %248, 1.000000e+00
br i1 %249, label %250, label %263
250: ; preds = %246
%251 = load i32, i32* %32
%252 = load i32, i32* %33
%253 = icmp eq i32 %251, %252
br i1 %253, label %254, label %263
254: ; preds = %250
%255 = load double, double* %31
%256 = load double*, double** %15
%257 = load double, double* %256
%258 = fcmp oeq double %255, %257
%259 = zext i1 %258 to i32
%260 = call i64 @fabs(i32 %259)
%261 = icmp ne i64 %260, 0
br i1 %261, label %262, label %263
262: ; preds = %254
br label %268
263: ; preds = %254, %250, %246
br label %264
264: ; preds = %263, %225
br label %265
265: ; preds = %264
%266 = load i32, i32* %28
%267 = add nsw i32 %266, 1
store i32 %267, i32* %28
br label %41
268: ; preds = %262, %245, %41
%269 = load i32*, i32** %30
%270 = call i32 @free(i32* %269)
%271 = load i32, i32* %32
%272 = load i32*, i32** %16
store i32 %271, i32* %272
%273 = load i32, i32* %28
ret i32 %273
}

LLVM IR (-O2):
define i32 @sfa_special(double* %0, double* %1, i32* nocapture writeonly %2, double* %3, double* %4, double* %5, double %6, i32 %7, i32 %8, double* %9, double* %10, double %11, i32 %12) {
%14 = alloca double
%15 = bitcast double* %14 to i8*
%16 = shl i32 %7, 2
%17 = tail call i64 @malloc(i32 %16)
%18 = inttoptr i64 %17 to i32*
store double -1.000000e+00, double* %1
%19 = icmp slt i32 %8, 1
br i1 %19, label %325, label %20
20: ; preds = %13
%21 = getelementptr inbounds double, double* %3, i64 1
%22 = add i32 %7, -1
%23 = icmp sgt i32 %7, 2
%24 = add nsw i32 %7, -2
%25 = sext i32 %24 to i64
%26 = getelementptr inbounds double, double* %3, i64 %25
%27 = sext i32 %22 to i64
%28 = getelementptr inbounds double, double* %3, i64 %27
%29 = getelementptr inbounds double, double* %5, i64 %27
%30 = getelementptr inbounds double, double* %10, i64 %27
%31 = icmp sgt i32 %7, 0
%32 = fneg double %6
%33 = add nuw i32 %8, 1
%34 = zext i32 %22 to i64
%35 = zext i32 %7 to i64
%36 = getelementptr double, double* %9, i64 %35
%37 = getelementptr double, double* %5, i64 %35
%38 = add nuw nsw i64 %35, 1
%39 = getelementptr double, double* %0, i64 %38
%40 = getelementptr double, double* %10, i64 1
%41 = getelementptr double, double* %10, i64 %34
%42 = add nuw nsw i64 %34, 1
%43 = getelementptr double, double* %3, i64 %42
%44 = getelementptr double, double* %5, i64 1
%45 = getelementptr double, double* %5, i64 %34
%46 = add nsw i64 %34, -1
%47 = add nsw i64 %35, -1
%48 = icmp ult i64 %46, 4
%49 = icmp ult double* %40, %43
%50 = icmp ugt double* %41, %3
%51 = and i1 %49, %50
%52 = icmp ult double* %40, %45
%53 = icmp ult double* %44, %41
%54 = and i1 %52, %53
%55 = or i1 %51, %54
%56 = and i64 %46, -4
%57 = or i64 %56, 1
%58 = icmp eq i64 %46, %56
%59 = and i64 %34, 1
%60 = icmp eq i64 %59, 0
%61 = sub nsw i64 0, %34
%62 = icmp ult i32 %7, 4
%63 = icmp ugt double* %37, %9
%64 = icmp ugt double* %36, %5
%65 = and i1 %63, %64
%66 = icmp ugt double* %39, %9
%67 = icmp ugt double* %36, %0
%68 = and i1 %66, %67
%69 = or i1 %65, %68
%70 = and i64 %35, 4294967292
%71 = icmp eq i64 %70, %35
%72 = and i64 %35, 1
%73 = icmp eq i64 %72, 0
%74 = and i64 %35, 1
%75 = icmp eq i64 %47, 0
%76 = and i64 %35, 4294967294
%77 = icmp eq i64 %74, 0
br label %78
78: ; preds = %20, %322
%79 = phi i32 [ -1, %20 ], [ %193, %322 ]
%80 = phi i32 [ 1, %20 ], [ %323, %322 ]
%81 = load double, double* %3
%82 = fadd double %81, %81
%83 = load double, double* %21
%84 = fsub double %82, %83
%85 = load double, double* %5
%86 = fsub double %84, %85
store double %86, double* %10
br i1 %23, label %87, label %186
87: ; preds = %78
%88 = select i1 %48, i1 true, i1 %55
br i1 %88, label %132, label %89
89: ; preds = %87, %89
%90 = phi i64 [ %129, %89 ], [ 0, %87 ]
%91 = or i64 %90, 1
%92 = getelementptr inbounds double, double* %3, i64 %90
%93 = bitcast double* %92 to <2 x double>*
%94 = load <2 x double>, <2 x double>* %93
%95 = getelementptr inbounds double, double* %92, i64 2
%96 = bitcast double* %95 to <2 x double>*
%97 = load <2 x double>, <2 x double>* %96
%98 = getelementptr inbounds double, double* %3, i64 %91
%99 = bitcast double* %98 to <2 x double>*
%100 = load <2 x double>, <2 x double>* %99
%101 = getelementptr inbounds double, double* %98, i64 2
%102 = bitcast double* %101 to <2 x double>*
%103 = load <2 x double>, <2 x double>* %102
%104 = fsub <2 x double> %100, %94
%105 = fsub <2 x double> %103, %97
%106 = fadd <2 x double> %100, %104
%107 = fadd <2 x double> %103, %105
%108 = or i64 %90, 2
%109 = getelementptr inbounds double, double* %3, i64 %108
%110 = bitcast double* %109 to <2 x double>*
%111 = load <2 x double>, <2 x double>* %110
%112 = getelementptr inbounds double, double* %109, i64 2
%113 = bitcast double* %112 to <2 x double>*
%114 = load <2 x double>, <2 x double>* %113
%115 = fsub <2 x double> %106, %111
%116 = fsub <2 x double> %107, %114
%117 = getelementptr inbounds double, double* %5, i64 %91
%118 = bitcast double* %117 to <2 x double>*
%119 = load <2 x double>, <2 x double>* %118
%120 = getelementptr inbounds double, double* %117, i64 2
%121 = bitcast double* %120 to <2 x double>*
%122 = load <2 x double>, <2 x double>* %121
%123 = fsub <2 x double> %115, %119
%124 = fsub <2 x double> %116, %122
%125 = getelementptr inbounds double, double* %10, i64 %91
%126 = bitcast double* %125 to <2 x double>*
store <2 x double> %123, <2 x double>* %126
%127 = getelementptr inbounds double, double* %125, i64 2
%128 = bitcast double* %127 to <2 x double>*
store <2 x double> %124, <2 x double>* %128
%129 = add nuw i64 %90, 4
%130 = icmp eq i64 %129, %56
br i1 %130, label %131, label %89
131: ; preds = %89
br i1 %58, label %186, label %132
132: ; preds = %87, %131
%133 = phi i64 [ 1, %87 ], [ %57, %131 ]
%134 = xor i64 %133, -1
br i1 %60, label %135, label %151
135: ; preds = %132
%136 = add nsw i64 %133, -1
%137 = getelementptr inbounds double, double* %3, i64 %136
%138 = load double, double* %137
%139 = getelementptr inbounds double, double* %3, i64 %133
%140 = load double, double* %139
%141 = fsub double %140, %138
%142 = fadd double %140, %141
%143 = add nuw nsw i64 %133, 1
%144 = getelementptr inbounds double, double* %3, i64 %143
%145 = load double, double* %144
%146 = fsub double %142, %145
%147 = getelementptr inbounds double, double* %5, i64 %133
%148 = load double, double* %147
%149 = fsub double %146, %148
%150 = getelementptr inbounds double, double* %10, i64 %133
store double %149, double* %150
br label %151
151: ; preds = %135, %132
%152 = phi i64 [ %133, %132 ], [ %143, %135 ]
%153 = icmp eq i64 %134, %61
br i1 %153, label %186, label %154
154: ; preds = %151, %154
%155 = phi i64 [ %177, %154 ], [ %152, %151 ]
%156 = add nsw i64 %155, -1
%157 = getelementptr inbounds double, double* %3, i64 %156
%158 = load double, double* %157
%159 = getelementptr inbounds double, double* %3, i64 %155
%160 = load double, double* %159
%161 = fsub double %160, %158
%162 = fadd double %160, %161
%163 = add nuw nsw i64 %155, 1
%164 = getelementptr inbounds double, double* %3, i64 %163
%165 = load double, double* %164
%166 = fsub double %162, %165
%167 = getelementptr inbounds double, double* %5, i64 %155
%168 = load double, double* %167
%169 = fsub double %166, %168
%170 = getelementptr inbounds double, double* %10, i64 %155
store double %169, double* %170
%171 = getelementptr inbounds double, double* %3, i64 %155
%172 = load double, double* %171
%173 = getelementptr inbounds double, double* %3, i64 %163
%174 = load double, double* %173
%175 = fsub double %174, %172
%176 = fadd double %174, %175
%177 = add nuw nsw i64 %155, 2
%178 = getelementptr inbounds double, double* %3, i64 %177
%179 = load double, double* %178
%180 = fsub double %176, %179
%181 = getelementptr inbounds double, double* %5, i64 %163
%182 = load double, double* %181
%183 = fsub double %180, %182
%184 = getelementptr inbounds double, double* %10, i64 %163
store double %183, double* %184
%185 = icmp eq i64 %177, %34
br i1 %185, label %186, label %154
186: ; preds = %151, %154, %131, %78
%187 = load double, double* %26
%188 = load double, double* %28
%189 = fsub double %188, %187
%190 = fadd double %188, %189
%191 = load double, double* %29
%192 = fsub double %190, %191
store double %192, double* %30
%193 = call i32 @supportSet(double* %0, double* %4, double* %3, double* %10, i32* %18, double %6, i32 %7)
br i1 %31, label %194, label %244
194: ; preds = %186
%195 = select i1 %62, i1 true, i1 %69
br i1 %195, label %228, label %196
196: ; preds = %194, %196
%197 = phi i64 [ %225, %196 ], [ 0, %194 ]
%198 = getelementptr inbounds double, double* %5, i64 %197
%199 = bitcast double* %198 to <2 x double>*
%200 = load <2 x double>, <2 x double>* %199
%201 = getelementptr inbounds double, double* %198, i64 2
%202 = bitcast double* %201 to <2 x double>*
%203 = load <2 x double>, <2 x double>* %202
%204 = or i64 %197, 1
%205 = getelementptr inbounds double, double* %0, i64 %204
%206 = bitcast double* %205 to <2 x double>*
%207 = load <2 x double>, <2 x double>* %206
%208 = getelementptr inbounds double, double* %205, i64 2
%209 = bitcast double* %208 to <2 x double>*
%210 = load <2 x double>, <2 x double>* %209
%211 = fsub <2 x double> %200, %207
%212 = fsub <2 x double> %203, %210
%213 = getelementptr inbounds double, double* %0, i64 %197
%214 = bitcast double* %213 to <2 x double>*
%215 = load <2 x double>, <2 x double>* %214
%216 = getelementptr inbounds double, double* %213, i64 2
%217 = bitcast double* %216 to <2 x double>*
%218 = load <2 x double>, <2 x double>* %217
%219 = fadd <2 x double> %211, %215
%220 = fadd <2 x double> %212, %218
%221 = getelementptr inbounds double, double* %9, i64 %197
%222 = bitcast double* %221 to <2 x double>*
store <2 x double> %219, <2 x double>* %222
%223 = getelementptr inbounds double, double* %221, i64 2
%224 = bitcast double* %223 to <2 x double>*
store <2 x double> %220, <2 x double>* %224
%225 = add nuw i64 %197, 4
%226 = icmp eq i64 %225, %70
br i1 %226, label %227, label %196
227: ; preds = %196
br i1 %71, label %269, label %228
228: ; preds = %194, %227
%229 = phi i64 [ 0, %194 ], [ %70, %227 ]
br i1 %73, label %241, label %230
230: ; preds = %228
%231 = getelementptr inbounds double, double* %5, i64 %229
%232 = load double, double* %231
%233 = or i64 %229, 1
%234 = getelementptr inbounds double, double* %0, i64 %233
%235 = load double, double* %234
%236 = fsub double %232, %235
%237 = getelementptr inbounds double, double* %0, i64 %229
%238 = load double, double* %237
%239 = fadd double %236, %238
%240 = getelementptr inbounds double, double* %9, i64 %229
store double %239, double* %240
br label %241
241: ; preds = %230, %228
%242 = phi i64 [ %229, %228 ], [ %233, %230 ]
%243 = icmp eq i64 %47, %229
br i1 %243, label %269, label %246
244: ; preds = %186
%245 = call i32 @Thomas(double* %14, double* %3, double* %9, i32 %7)
br label %305
246: ; preds = %241, %246
%247 = phi i64 [ %260, %246 ], [ %242, %241 ]
%248 = getelementptr inbounds double, double* %5, i64 %247
%249 = load double, double* %248
%250 = add nuw nsw i64 %247, 1
%251 = getelementptr inbounds double, double* %0, i64 %250
%252 = load double, double* %251
%253 = fsub double %249, %252
%254 = getelementptr inbounds double, double* %0, i64 %247
%255 = load double, double* %254
%256 = fadd double %253, %255
%257 = getelementptr inbounds double, double* %9, i64 %247
store double %256, double* %257
%258 = getelementptr inbounds double, double* %5, i64 %250
%259 = load double, double* %258
%260 = add nuw nsw i64 %247, 2
%261 = getelementptr inbounds double, double* %0, i64 %260
%262 = load double, double* %261
%263 = fsub double %259, %262
%264 = getelementptr inbounds double, double* %0, i64 %250
%265 = load double, double* %264
%266 = fadd double %263, %265
%267 = getelementptr inbounds double, double* %9, i64 %250
store double %266, double* %267
%268 = icmp eq i64 %260, %35
br i1 %268, label %269, label %246
269: ; preds = %241, %246, %227
%270 = call i32 @Thomas(double* %14, double* %3, double* %9, i32 %7)
br i1 %31, label %271, label %305
271: ; preds = %269
br i1 %75, label %295, label %272
272: ; preds = %271, %291
%273 = phi i64 [ %292, %291 ], [ 0, %271 ]
%274 = phi i64 [ %293, %291 ], [ 0, %271 ]
%275 = getelementptr inbounds double, double* %3, i64 %273
%276 = load double, double* %275
%277 = fcmp ogt double %276, %6
br i1 %277, label %280, label %278
278: ; preds = %272
%279 = fcmp olt double %276, %32
br i1 %279, label %280, label %282
280: ; preds = %278, %272
%281 = phi double [ %6, %272 ], [ %32, %278 ]
store double %281, double* %275
br label %282
282: ; preds = %280, %278
%283 = or i64 %273, 1
%284 = getelementptr inbounds double, double* %3, i64 %283
%285 = load double, double* %284
%286 = fcmp ogt double %285, %6
br i1 %286, label %289, label %287
287: ; preds = %282
%288 = fcmp olt double %285, %32
br i1 %288, label %289, label %291
289: ; preds = %287, %282
%290 = phi double [ %6, %282 ], [ %32, %287 ]
store double %290, double* %284
br label %291
291: ; preds = %289, %287
%292 = add nuw nsw i64 %273, 2
%293 = add i64 %274, 2
%294 = icmp eq i64 %293, %76
br i1 %294, label %295, label %272
295: ; preds = %291, %271
%296 = phi i64 [ 0, %271 ], [ %292, %291 ]
br i1 %77, label %305, label %297
297: ; preds = %295
%298 = getelementptr inbounds double, double* %3, i64 %296
%299 = load double, double* %298
%300 = fcmp ogt double %299, %6
br i1 %300, label %303, label %301
301: ; preds = %297
%302 = fcmp olt double %299, %32
br i1 %302, label %303, label %305
303: ; preds = %301, %297
%304 = phi double [ %6, %297 ], [ %32, %301 ]
store double %304, double* %298
br label %305
305: ; preds = %295, %303, %301, %244, %269
%306 = srem i32 %80, %12
%307 = icmp eq i32 %306, 0
br i1 %307, label %308, label %322
308: ; preds = %305
%309 = load double, double* %1
%310 = call i32 @dualityGap(double* %1, double* %3, double* %10, double* %9, double* %5, double %6, i32 %7)
%311 = load double, double* %1
%312 = fcmp ugt double %311, %11
br i1 %312, label %313, label %325
313: ; preds = %308
%314 = fcmp olt double %311, 1.000000e+00
%315 = icmp eq i32 %193, %79
%316 = select i1 %314, i1 %315, i1 false
br i1 %316, label %317, label %322
317: ; preds = %313
%318 = fcmp oeq double %309, %311
%319 = zext i1 %318 to i32
%320 = call i64 @fabs(i32 %319)
%321 = icmp eq i64 %320, 0
br i1 %321, label %322, label %325
322: ; preds = %305, %317, %313
%323 = add nuw i32 %80, 1
%324 = icmp eq i32 %80, %8
br i1 %324, label %325, label %78
325: ; preds = %322, %308, %317, %13
%326 = phi i32 [ 1, %13 ], [ %33, %322 ], [ %80, %308 ], [ %80, %317 ]
%327 = phi i32 [ -1, %13 ], [ %193, %322 ], [ %193, %308 ], [ %79, %317 ]
%328 = call i32 @free(i32* %18)
store i32 %327, i32* %2
ret i32 %326
}