LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/canzarlab[P]Trajan/src/Greedy.cpp
// Function: Greedy::WriteSolution(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Greedy::WriteSolution(string fileName)
{
    ofstream sol_file(fileName);
    double weight = 0.0;
    vn n1 = t1.GetNodes(), n2 = t2.GetNodes();
    for (const iid& e : M)
        sol_file << n1[get<0>(e)]->taxon << " " << n2[get<1>(e)]->taxon << " 1\n", weight += get<2>(e);
    PrintScore(weight);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x248, %rsp            # imm = 0x248
movq %rdi, %rbx
leaq 0x48(%rsp), %rdi
movl $0x10, %edx
callq 0x9700
movq 0x30(%rbx), %rax
movq 0x68(%rax), %rsi
movl 0x70(%rax), %edx
leaq 0x30(%rsp), %rdi
callq 0x3d303
movq 0x38(%rbx), %rax
movq 0x68(%rax), %rsi
movl 0x70(%rax), %edx
leaq 0x18(%rsp), %rdi
callq 0x3d303
movq 0xb8(%rbx), %rbp
movq %rbx, 0x10(%rsp)
movq 0xc0(%rbx), %rbx
xorpd %xmm0, %xmm0
cmpq %rbx, %rbp
je 0x32b79
movsd %xmm0, 0x8(%rsp)
leaq 0x48(%rsp), %r14
leaq 0x29769(%rip), %r15     # 0x5c262
leaq 0x3c6d7(%rip), %r12     # 0x6f1d7
movslq 0xc(%rbp), %rax
movq 0x30(%rsp), %rcx
movq (%rcx,%rax,8), %rax
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
movq %r14, %rdi
callq 0x93a0
movq %rax, %r13
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x93a0
movslq 0x8(%rbp), %rax
movq 0x18(%rsp), %rcx
movq (%rcx,%rax,8), %rax
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
movq %r13, %rdi
callq 0x93a0
movl $0x3, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x93a0
movsd 0x8(%rsp), %xmm0
addsd (%rbp), %xmm0
movsd %xmm0, 0x8(%rsp)
addq $0x10, %rbp
cmpq %rbx, %rbp
jne 0x32b00
jmp 0x32b7f
movsd %xmm0, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movsd 0x8(%rsp), %xmm0
callq 0x3472a
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x32ba6
movq 0x28(%rsp), %rsi
subq %rdi, %rsi
callq 0x9340
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x32bbd
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x9340
movq 0x553dc(%rip), %rax     # 0x87fa0
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq 0x50(%rsp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, 0x48(%rsp,%rcx)
callq 0x92c0
leaq 0x140(%rsp), %rdi
callq 0x9110
addq $0x248, %rsp            # imm = 0x248
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x32c0d
movq %rax, %rbx
jmp 0x32c27
movq %rax, %rbx
jmp 0x32c3e
movq %rax, %rbx
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x32c27
movq 0x28(%rsp), %rsi
subq %rdi, %rsi
callq 0x9340
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x32c3e
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x9340
leaq 0x48(%rsp), %rdi
callq 0x9500
movq %rbx, %rdi
callq 0x9670
// File: /workspace/github_cpp_makefile_star2_O1/canzarlab[P]Trajan/src/Solver.cpp
// Function: Solver::SymdifDist(double) const
double Solver::SymdifDist(double weight) const
{
    if (tt) return TumorDist(weight);
    int max1 = 0, max2 = 0;
    int r1 = GetMax(t1.GetRoot(), max1);
    int r2 = GetMax(t2.GetRoot(), max2);
    return max1 + max2 - r1 - r2 - weight;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x53a7c(%rip), %rax     # 0x88404
cmpb $0x1, (%rax)
jne 0x3499f
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x34b80
xorl %eax, %eax
leaq 0x14(%rsp), %r14
movl %eax, (%r14)
leaq 0x10(%rsp), %r15
movl %eax, (%r15)
movq 0x30(%rbx), %rax
movq 0x68(%rax), %rsi
movq %rbx, %rdi
movq %r14, %rdx
movsd %xmm0, 0x8(%rsp)
callq 0x34a02
movl %eax, %ebp
movq 0x38(%rbx), %rax
movq 0x68(%rax), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x34a02
movl (%r14), %ecx
addl %ebp, %eax
subl %eax, %ecx
addl (%r15), %ecx
xorps %xmm0, %xmm0
cvtsi2sd %ecx, %xmm0
subsd 0x8(%rsp), %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/canzarlab[P]Trajan/src/Solver.cpp
// Function: Solver::GetMax(newick_node*, int&) const
int Solver::GetMax(newick_node* node, int& hmax) const
{
    int sum = 0;
    for (newick_child* child = node->child; child; child = child->next)
        sum += GetMax(child->node, hmax);
    hmax += sum;
    return node->child ? sum : 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq (%rsi), %r12
testq %r12, %r12
je 0x34a3a
movq %rdi, %r15
xorl %ebp, %ebp
movq (%r12), %rsi
movq %r15, %rdi
movq %r14, %rdx
callq 0x34a02
addl %eax, %ebp
movq 0x8(%r12), %r12
testq %r12, %r12
jne 0x34a1d
jmp 0x34a3c
xorl %ebp, %ebp
addl %ebp, (%r14)
cmpq $0x0, (%rbx)
movl $0x1, %eax
cmovnel %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/canzarlab[P]Trajan/src/Solver.cpp
// Function: Solver::GetMax(Graph&, Graph&, newick_node*, newick_node*) const
double Solver::GetMax(Graph& t1, Graph& t2, newick_node* root, newick_node* rnode) const
{
    double m = root->parent && root->child ? SymdifSim(t1.clade[rnode], t2.clade[root]) : 0;
    for (newick_child* child = root->child; child; child = child->next)
        m = max(m, GetMax(t1, t2, child->node, rnode));
    return m;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rcx, 0x8(%rsp)
movq %r8, (%rsp)
xorpd %xmm1, %xmm1
cmpq $0x0, 0x30(%rcx)
je 0x34aae
cmpq $0x0, (%rcx)
je 0x34aae
leaq 0x20(%r14), %rdi
movq %rsp, %rsi
callq 0x302c6
movq %rax, %r12
leaq 0x20(%rbx), %rdi
leaq 0x8(%rsp), %rsi
callq 0x302c6
movq %r12, %rdi
movq %rax, %rsi
callq 0x4650f
movapd %xmm0, %xmm1
movq 0x8(%rsp), %rax
movq (%rax), %r12
testq %r12, %r12
je 0x34aed
movsd %xmm1, 0x10(%rsp)
movq (%r12), %rcx
movq (%rsp), %r8
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x34a54
maxsd 0x10(%rsp), %xmm0
movq 0x8(%r12), %r12
movapd %xmm0, %xmm1
testq %r12, %r12
jne 0x34abb
jmp 0x34af1
movapd %xmm1, %xmm0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/canzarlab[P]Trajan/src/Solver.cpp
// Function: Solver::CalcY(Graph&, Graph&, newick_node*) const
double Solver::CalcY(Graph& t1, Graph& t2, newick_node* root) const
{
    double w = root->parent && root->child ? GetMax(t1, t2, t2.GetRoot(), root) : 0;
    for (newick_child* child = root->child; child; child = child->next)
        w += CalcY(t1, t2, child->node);
    return w;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r12
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorpd %xmm0, %xmm0
cmpq $0x0, 0x30(%rcx)
je 0x34b39
cmpq $0x0, (%r12)
je 0x34b39
movq 0x68(%rbx), %rcx
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq %r12, %r8
callq 0x34a54
movq (%r12), %r12
testq %r12, %r12
je 0x34b73
movsd %xmm0, (%rsp)
movq (%r12), %rcx
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x34afe
movsd (%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
movsd (%rsp), %xmm0
movq 0x8(%r12), %r12
jmp 0x34b3d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/canzarlab[P]Trajan/src/Solver.cpp
// Function: Solver::IsNotInConflict(int, int, int, int) const
bool Solver::IsNotInConflict(int i, int j, int x, int y) const
{
    if (i == j || x == y) return false;
    if (cf == 0) return true;
    bool c2 = (t1.D[j][i] || t1.D[i][j]) == (t2.D[x][y] || t2.D[y][x]);
    bool c1 = (t1.D[i][j] == t2.D[x][y]); // assuming c2 is satisfied
    if (cf == 1) return !c2 || c1;
    return c2 && c1;
}

// Assembly:
cmpl %edx, %esi
sete %al
cmpl %r8d, %ecx
sete %r9b
orb %al, %r9b
je 0x34bfa
xorl %eax, %eax
retq
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
leaq 0x537f5(%rip), %rax     # 0x88400
movl (%rax), %r9d
testl %r9d, %r9d
je 0x34d8c
movq 0x30(%rdi), %r10
movslq %edx, %rax
movq 0x50(%r10), %rdx
leaq (%rax,%rax,4), %r10
movslq %esi, %rbx
leaq 0x3f(%rbx), %r11
testq %rbx, %rbx
cmovnsq %rbx, %r11
sarq $0x6, %r11
shlq $0x3, %r11
addq (%rdx,%r10,8), %r11
movabsq $-0x8000000000000000, %r10 # imm = 0x8000000000000000
leaq 0x3f(%r10), %r14
andq %rbx, %r14
xorl %r15d, %r15d
cmpq %r10, %r14
setbe %r15b
movq -0x8(%r11,%r15,8), %r14
movl $0x1, %r11d
btq %rsi, %r14
leaq (%rbx,%rbx,4), %rsi
movl $0x1, %ebx
jb 0x34cab
leaq 0x3f(%rax), %rbx
testq %rax, %rax
cmovnsq %rax, %rbx
sarq $0x6, %rbx
shlq $0x3, %rbx
addq (%rdx,%rsi,8), %rbx
leaq 0x3f(%r10), %r14
andq %rax, %r14
xorl %r15d, %r15d
cmpq %r10, %r14
setbe %r15b
movq -0x8(%rbx,%r15,8), %r14
xorl %ebx, %ebx
btq %rax, %r14
setb %bl
movq %rsi, -0x8(%rsp)
movq 0x38(%rdi), %rdi
movslq %ecx, %r15
movq 0x50(%rdi), %r12
leaq (%r15,%r15,4), %rcx
movslq %r8d, %r13
leaq 0x3f(%r13), %rbp
testq %r13, %r13
cmovnsq %r13, %rbp
sarq $0x6, %rbp
shlq $0x3, %rbp
addq (%r12,%rcx,8), %rbp
leaq 0x3f(%r10), %rdi
movq %r13, %rcx
andq %rdi, %rcx
xorl %esi, %esi
cmpq %r10, %rcx
setbe %sil
movl $0x1, %r14d
movl %r8d, %ecx
shlq %cl, %r14
andq -0x8(%rbp,%rsi,8), %r14
jne 0x34d41
leaq (,%r13,4), %rcx
addq %r13, %rcx
leaq 0x3f(%r15), %rsi
testq %r15, %r15
cmovnsq %r15, %rsi
sarq $0x6, %rsi
shlq $0x3, %rsi
addq (%r12,%rcx,8), %rsi
movq %r15, %rcx
andq %rdi, %rcx
xorl %r8d, %r8d
cmpq %r10, %rcx
setbe %r8b
movq -0x8(%rsi,%r8,8), %rcx
xorl %r11d, %r11d
btq %r15, %rcx
setb %r11b
leaq 0x3f(%rax), %rcx
testq %rax, %rax
cmovnsq %rax, %rcx
sarq $0x6, %rcx
shlq $0x3, %rcx
movq -0x8(%rsp), %rsi
addq (%rdx,%rsi,8), %rcx
andq %rax, %rdi
xorl %edx, %edx
cmpq %r10, %rdi
setbe %dl
movq -0x8(%rcx,%rdx,8), %rcx
btq %rax, %rcx
setb %cl
testq %r14, %r14
sete %al
xorb %cl, %al
cmpl $0x1, %r9d
jne 0x34d90
cmpl %r11d, %ebx
setne %cl
orb %cl, %al
jmp 0x34d9a
movb $0x1, %al
jmp 0x34d9a
cmpl %r11d, %ebx
sete %cl
andb %al, %cl
movl %ecx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/canzarlab[P]Trajan/src/Geno.h
// Function: PackingJRF::getBoundsConstraints(double*, double*)
bool getBoundsConstraints(Scalar* cl, Scalar* cu) override
    {
    // we have equality constraints here
        Vector::MapType(cu, _m) = _b;
        Vector::MapType(cl, _m) = Vector::Constant(_m, -INF);
        return true;
    }

// Assembly:
pushq %rax
movq 0x38(%rdi), %rax
testq %rax, %rax
js 0x36cef
movq 0x10(%rdi), %rcx
cmpq 0x8(%rcx), %rax
jne 0x36d0e
movq %rax, %r8
testb $0x7, %dl
jne 0x36bfe
movl %edx, %r8d
shrl $0x3, %r8d
andl $0x1, %r8d
cmpq %rax, %r8
cmovgeq %rax, %r8
movq (%rcx), %rcx
movq %rax, %r10
subq %r8, %r10
movq %r10, %r9
shrq $0x3f, %r9
addq %r10, %r9
andq $-0x2, %r9
testq %r8, %r8
jle 0x36c31
xorl %r11d, %r11d
movsd (%rcx,%r11,8), %xmm0
movsd %xmm0, (%rdx,%r11,8)
incq %r11
cmpq %r11, %r8
jne 0x36c1d
addq %r8, %r9
cmpq $0x2, %r10
jl 0x36c4d
movups (%rcx,%r8,8), %xmm0
movaps %xmm0, (%rdx,%r8,8)
addq $0x2, %r8
cmpq %r9, %r8
jl 0x36c3a
cmpq %rax, %r9
jge 0x36c66
movsd (%rcx,%r9,8), %xmm0
movsd %xmm0, (%rdx,%r9,8)
incq %r9
cmpq %r9, %rax
jne 0x36c52
movq 0x38(%rdi), %rax
testq %rax, %rax
js 0x36d2d
movq %rax, %rcx
testb $0x7, %sil
jne 0x36c8b
movl %esi, %ecx
shrl $0x3, %ecx
andl $0x1, %ecx
cmpq %rax, %rcx
cmovgeq %rax, %rcx
movq %rax, %r8
subq %rcx, %r8
movq %r8, %rdx
shrq $0x3f, %rdx
addq %r8, %rdx
andq $-0x2, %rdx
movabsq $-0x10000000000000, %rdi # imm = 0xFFF0000000000000
testq %rcx, %rcx
jle 0x36cbd
xorl %r9d, %r9d
movq %rdi, (%rsi,%r9,8)
incq %r9
cmpq %r9, %rcx
jne 0x36cb1
addq %rcx, %rdx
cmpq $0x2, %r8
jl 0x36cda
movaps 0x385c3(%rip), %xmm0    # 0x6f290
movaps %xmm0, (%rsi,%rcx,8)
addq $0x2, %rcx
cmpq %rdx, %rcx
jl 0x36ccd
cmpq %rax, %rdx
jge 0x36ceb
movq %rdi, (%rsi,%rdx,8)
incq %rdx
cmpq %rdx, %rax
jne 0x36cdf
movb $0x1, %al
popq %rcx
retq
leaq 0x25e91(%rip), %rdi     # 0x5cb87
leaq 0x25c07(%rip), %rsi     # 0x5c904
leaq 0x25e90(%rip), %rcx     # 0x5cb94
movl $0xa3, %edx
callq 0x9200
leaq 0x2783c(%rip), %rdi     # 0x5e551
leaq 0x2789e(%rip), %rsi     # 0x5e5ba
leaq 0x38629(%rip), %rcx     # 0x6f34c
movl $0x101, %edx            # imm = 0x101
callq 0x9200
leaq 0x25808(%rip), %rdi     # 0x5c53c
leaq 0x25896(%rip), %rsi     # 0x5c5d1
leaq 0x2668a(%rip), %rcx     # 0x5d3cc
movl $0x4a, %edx
callq 0x9200
// File: /workspace/github_cpp_makefile_star2_O1/canzarlab[P]Trajan/src/Geno.h
// Function: SimpleJRF::functionValueAndGradient(double const*, double&, double*)
virtual bool functionValueAndGradient(const Scalar* variablesPtr,
                                          Scalar& functionValue,
                                          Scalar* gradientPtr)
    {
        Vector::ConstMapType x = Vector::ConstMapType(variablesPtr, _n);
        Vector::MapType g = Vector::MapType(gradientPtr, _n);
        functionValue = _c.dot(x);
        g = _c;
        return true;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq 0x30(%rdi), %r12
testq %r12, %r12
js 0x37008
movq %rdi, %r15
movq 0x18(%rdi), %rax
cmpq %r12, 0x8(%rax)
jne 0x37027
movq %rcx, %rbx
movq %rdx, %r14
movq %rax, 0x8(%rsp)
movq %rsi, 0x10(%rsp)
movq %r12, 0x18(%rsp)
testq %r12, %r12
je 0x36f6c
movq (%rax), %rax
leaq 0x30(%rsp), %rdi
movq %rax, 0x8(%rdi)
movq %rsi, 0x18(%rdi)
movq %r12, 0x28(%rdi)
leaq 0x8(%rsp), %rax
movq %rax, 0x30(%rdi)
leaq 0x7(%rsp), %rsi
callq 0x37324
jmp 0x36f6f
xorps %xmm0, %xmm0
movsd %xmm0, (%r14)
movq 0x18(%r15), %rax
cmpq 0x8(%rax), %r12
jne 0x37046
movq %r12, %rcx
testb $0x7, %bl
jne 0x36f99
movl %ebx, %ecx
shrl $0x3, %ecx
andl $0x1, %ecx
cmpq %r12, %rcx
cmovgeq %r12, %rcx
movq (%rax), %rax
movq %r12, %rsi
subq %rcx, %rsi
movq %rsi, %rdx
shrq $0x3f, %rdx
addq %rsi, %rdx
andq $-0x2, %rdx
testq %rcx, %rcx
jle 0x36fc9
xorl %edi, %edi
movsd (%rax,%rdi,8), %xmm0
movsd %xmm0, (%rbx,%rdi,8)
incq %rdi
cmpq %rdi, %rcx
jne 0x36fb7
addq %rcx, %rdx
cmpq $0x2, %rsi
jl 0x36fe3
movups (%rax,%rcx,8), %xmm0
movaps %xmm0, (%rbx,%rcx,8)
addq $0x2, %rcx
cmpq %rdx, %rcx
jl 0x36fd2
cmpq %r12, %rdx
jge 0x36ffa
movsd (%rax,%rdx,8), %xmm0
movsd %xmm0, (%rbx,%rdx,8)
incq %rdx
cmpq %rdx, %r12
jne 0x36fe8
movb $0x1, %al
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x25b78(%rip), %rdi     # 0x5cb87
leaq 0x258ee(%rip), %rsi     # 0x5c904
leaq 0x26721(%rip), %rcx     # 0x5d73e
movl $0xa3, %edx
callq 0x9200
leaq 0x26d58(%rip), %rdi     # 0x5dd86
leaq 0x26d68(%rip), %rsi     # 0x5dd9d
leaq 0x3839b(%rip), %rcx     # 0x6f3d7
movl $0x52, %edx
callq 0x9200
leaq 0x27504(%rip), %rdi     # 0x5e551
leaq 0x27566(%rip), %rsi     # 0x5e5ba
leaq 0x382f1(%rip), %rcx     # 0x6f34c
movl $0x101, %edx            # imm = 0x101
callq 0x9200
nop
// File: /workspace/github_cpp_makefile_star2_O1/canzarlab[P]Trajan/src/Geno.h
// Function: SimpleJRF::functionValueConstraints(double const*, double*)
virtual bool functionValueConstraints(const Scalar* variablesPtr,
                                          Scalar* constraintValuesPtr)
    {
        Vector::ConstMapType x = Vector::ConstMapType(variablesPtr, _n);
        Vector::MapType constraintValues = Vector::MapType(constraintValuesPtr, _m);
        constraintValues = _A * x;
        return true;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq 0x30(%rdi), %rax
testq %rax, %rax
js 0x37155
movq 0x38(%rdi), %r15
testq %r15, %r15
js 0x3716c
movq 0x8(%rdi), %rcx
movq %rcx, (%rsp)
movq %rsi, 0x8(%rsp)
movq %rax, 0x10(%rsp)
cmpq %rax, 0x8(%rcx)
jne 0x3718b
movq %rdx, %rbx
leaq 0x20(%rsp), %r14
movq %rsp, %rsi
movq %r14, %rdi
callq 0x37438
cmpq 0x8(%r14), %r15
jne 0x371aa
movq %r15, %rax
testb $0x7, %bl
jne 0x370e1
movl %ebx, %eax
shrl $0x3, %eax
andl $0x1, %eax
cmpq %r15, %rax
cmovgeq %r15, %rax
movq 0x20(%rsp), %rdi
movq %r15, %rdx
subq %rax, %rdx
movq %rdx, %rcx
shrq $0x3f, %rcx
addq %rdx, %rcx
andq $-0x2, %rcx
testq %rax, %rax
jle 0x37113
xorl %esi, %esi
movsd (%rdi,%rsi,8), %xmm0
movsd %xmm0, (%rbx,%rsi,8)
incq %rsi
cmpq %rsi, %rax
jne 0x37101
addq %rax, %rcx
cmpq $0x2, %rdx
jl 0x3712d
movups (%rdi,%rax,8), %xmm0
movaps %xmm0, (%rbx,%rax,8)
addq $0x2, %rax
cmpq %rcx, %rax
jl 0x3711c
cmpq %r15, %rcx
jge 0x37144
movsd (%rdi,%rcx,8), %xmm0
movsd %xmm0, (%rbx,%rcx,8)
incq %rcx
cmpq %rcx, %r15
jne 0x37132
callq 0x93c0
movb $0x1, %al
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x25a2b(%rip), %rdi     # 0x5cb87
leaq 0x257a1(%rip), %rsi     # 0x5c904
leaq 0x265d4(%rip), %rcx     # 0x5d73e
jmp 0x37181
leaq 0x25a14(%rip), %rdi     # 0x5cb87
leaq 0x2578a(%rip), %rsi     # 0x5c904
leaq 0x25a13(%rip), %rcx     # 0x5cb94
movl $0xa3, %edx
callq 0x9200
leaq 0x27796(%rip), %rdi     # 0x5e928
leaq 0x2781b(%rip), %rsi     # 0x5e9b4
leaq 0x38383(%rip), %rcx     # 0x6f523
movl $0x61, %edx
callq 0x9200
leaq 0x273a0(%rip), %rdi     # 0x5e551
leaq 0x27402(%rip), %rsi     # 0x5e5ba
leaq 0x3818d(%rip), %rcx     # 0x6f34c
movl $0x101, %edx            # imm = 0x101
callq 0x9200
nop
// File: /workspace/github_cpp_makefile_star2_O1/canzarlab[P]Trajan/src/Geno.h
// Function: SimpleJRF::gradientConstraintsTimesVector(double const*, double const*, double*)
virtual bool gradientConstraintsTimesVector(const Scalar* variablesPtr,
                                                const Scalar* dualVariablesPtr,
                                                Scalar* gradientPtr)
    {
        Vector::ConstMapType x = Vector::ConstMapType(variablesPtr, _n);
        Vector::ConstMapType y = Vector::ConstMapType(dualVariablesPtr, _m);
        Vector::MapType gradient = Vector::MapType(gradientPtr, _n);
        gradient = _A.transpose() * y;
        return true;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq 0x30(%rdi), %r15
testq %r15, %r15
js 0x372b9
movq 0x38(%rdi), %rax
testq %rax, %rax
js 0x372b9
movq %rcx, %rbx
movq 0x8(%rdi), %rcx
movb $0x0, 0x8(%rsp)
movq %rcx, 0x10(%rsp)
movq %rdx, 0x18(%rsp)
movq %rax, 0x20(%rsp)
cmpq %rax, 0x10(%rcx)
jne 0x372d8
leaq 0x30(%rsp), %r14
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x375e4
cmpq 0x8(%r14), %r15
jne 0x372f7
movq %r15, %rax
testb $0x7, %bl
jne 0x37245
movl %ebx, %eax
shrl $0x3, %eax
andl $0x1, %eax
cmpq %r15, %rax
cmovgeq %r15, %rax
movq 0x30(%rsp), %rdi
movq %r15, %rdx
subq %rax, %rdx
movq %rdx, %rcx
shrq $0x3f, %rcx
addq %rdx, %rcx
andq $-0x2, %rcx
testq %rax, %rax
jle 0x37277
xorl %esi, %esi
movsd (%rdi,%rsi,8), %xmm0
movsd %xmm0, (%rbx,%rsi,8)
incq %rsi
cmpq %rsi, %rax
jne 0x37265
addq %rax, %rcx
cmpq $0x2, %rdx
jl 0x37291
movups (%rdi,%rax,8), %xmm0
movaps %xmm0, (%rbx,%rax,8)
addq $0x2, %rax
cmpq %rcx, %rax
jl 0x37280
cmpq %r15, %rcx
jge 0x372a8
movsd (%rdi,%rcx,8), %xmm0
movsd %xmm0, (%rbx,%rcx,8)
incq %rcx
cmpq %rcx, %r15
jne 0x37296
callq 0x93c0
movb $0x1, %al
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x258c7(%rip), %rdi     # 0x5cb87
leaq 0x2563d(%rip), %rsi     # 0x5c904
leaq 0x26470(%rip), %rcx     # 0x5d73e
movl $0xa3, %edx
callq 0x9200
leaq 0x27649(%rip), %rdi     # 0x5e928
leaq 0x276ce(%rip), %rsi     # 0x5e9b4
leaq 0x3831d(%rip), %rcx     # 0x6f60a
movl $0x61, %edx
callq 0x9200
leaq 0x27253(%rip), %rdi     # 0x5e551
leaq 0x272b5(%rip), %rsi     # 0x5e5ba
leaq 0x38040(%rip), %rcx     # 0x6f34c
movl $0x101, %edx            # imm = 0x101
callq 0x9200
// File: /workspace/github_cpp_makefile_star2_O1/canzarlab[P]Trajan/src/LP.h
// Function: int LP::Add<CrossingConstraint>()
int LP::Add()
{
    int row_old = nr_rows;
    T c12(Triplets, t1, t2, K, x, false);
    nr_rows += c12.AddTriplets(nr_rows);
    T c21(Triplets, t2, t1, K, x, true);
    nr_rows += c21.AddTriplets(nr_rows);
    return nr_rows - row_old;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1d8, %rsp            # imm = 0x1D8
movq %rdi, %rbx
movl 0x108(%rdi), %ebp
leaq 0x88(%rdi), %r14
movq 0x30(%rdi), %rdx
movq 0x38(%rdi), %rcx
leaq 0xe0(%rdi), %r15
leaq 0xc0(%rdi), %r12
movl $0x0, (%rsp)
leaq 0xf0(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
movq %r15, %r8
movq %r12, %r9
callq 0x3bc9c
movl 0x108(%rbx), %esi
movq %r13, %rdi
callq 0x3bffe
movl %ebp, %r13d
addl %eax, 0x108(%rbx)
movq 0x30(%rbx), %rcx
movq 0x38(%rbx), %rdx
movl $0x1, (%rsp)
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %r15, %r8
movq %r12, %r9
callq 0x3bc9c
movl 0x108(%rbx), %esi
leaq 0x8(%rsp), %rdi
callq 0x3bffe
movl %eax, %ebp
addl 0x108(%rbx), %ebp
movl %ebp, 0x108(%rbx)
leaq 0x4e425(%rip), %r14     # 0x866c0
addq $0x10, %r14
leaq 0xd8(%rsp), %rbx
movq %r14, -0xd0(%rbx)
movq %rbx, %rdi
callq 0x30124
movq -0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x382cf
movq 0xd0(%rsp), %rsi
subq %rdi, %rsi
callq 0x9340
leaq 0x70(%rsp), %rdi
callq 0x3839c
leaq 0x1c0(%rsp), %rbx
movq %r14, -0xd0(%rbx)
movq %rbx, %rdi
callq 0x30124
movq -0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x38309
movq 0x1b8(%rsp), %rsi
subq %rdi, %rsi
callq 0x9340
subl %r13d, %ebp
leaq 0x158(%rsp), %rdi
callq 0x3839c
movl %ebp, %eax
addq $0x1d8, %rsp            # imm = 0x1D8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x38356
jmp 0x38341
jmp 0x3833e
movq %rax, %rbx
leaq 0xf0(%rsp), %rdi
callq 0x38356
movq %rbx, %rdi
callq 0x9670
// File: /workspace/github_cpp_makefile_star2_O1/canzarlab[P]Trajan/src/AntichainConstraint.cpp
// Function: AntichainConstraint::AntichainConstraint(std::vector<Eigen::Triplet<double, int>, std::allocator<Eigen::Triplet<double, int>>>&, Graph&, Graph&, std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>>&, Eigen::Matrix<double, -1, 1, 0, -1, 1>&, bool)
AntichainConstraint::AntichainConstraint(vector<ET>& Triplets, Graph& t1, Graph& t2, vvi& K, Vector& x, bool swp) : Constraint(Triplets, t1, t2, K, x, swp), G(((LDAG*)&t2)->G), ncr(0), B(t1.GetNumNodes()), pi(0)
{
    Z = t2.GetNumNodes();
    SZ = Z * 2 + 2;
    S = SZ - 2;
    T = SZ - 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
movzbl 0x40(%rsp), %eax
movl %eax, (%rsp)
callq 0x3b3e0
leaq 0x4c915(%rip), %rax     # 0x865e8
movq %rax, (%rbx)
leaq 0x78(%r14), %rax
movq %rax, 0x38(%rbx)
xorl %ebp, %ebp
movl %ebp, 0x40(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x58(%rbx)
movups %xmm0, 0x68(%rbx)
movq $0x0, 0x78(%rbx)
leaq 0x80(%rbx), %rdi
movslq 0x70(%r15), %rsi
leaq 0x17(%rsp), %rdx
movb $0x0, (%rdx)
leaq 0x16(%rsp), %rcx
callq 0x311d8
movl %ebp, 0xa8(%rbx)
movl 0x70(%r14), %eax
movl %eax, 0x50(%rbx)
leal 0x2(,%rax,2), %ecx
leal 0x1(,%rax,2), %edx
addl %eax, %eax
movl %ecx, 0x54(%rbx)
movl %eax, 0x48(%rbx)
movl %edx, 0x4c(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/canzarlab[P]Trajan/src/AntichainConstraint.cpp
// Function: AntichainConstraint::RunParallel()
void AntichainConstraint::RunParallel()
{
    vector<thread> vt;
    for (int i = 0; i < NR_THREADS; ++i)
        vt.emplace_back(&AntichainConstraint::AntichainJob, this, i);

    for (int i = 0; i < NR_THREADS; ++i)
        vt[i].join();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %r14
movaps %xmm0, (%r14)
movq $0x0, 0x10(%r14)
leaq 0x4(%rsp), %r15
movl $0x0, (%r15)
leaq 0x86(%rip), %rbp        # 0x39e14
leaq 0x10(%rsp), %r12
leaq 0x8(%rsp), %r13
movq %rbp, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movq %rbx, 0x8(%rsp)
movq %r14, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %r15, %rcx
callq 0x3ab7a
movl 0x4(%rsp), %eax
incl %eax
movl %eax, 0x4(%rsp)
cmpl $0x4, %eax
jb 0x39d98
xorl %ebx, %ebx
movq 0x20(%rsp), %rdi
addq %rbx, %rdi
callq 0x9620
addq $0x8, %rbx
cmpq $0x20, %rbx
jne 0x39dcd
leaq 0x20(%rsp), %rdi
callq 0x3abbc
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x39dff
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x3abbc
movq %rbx, %rdi
callq 0x9670
// File: /workspace/github_cpp_makefile_star2_O1/canzarlab[P]Trajan/src/AntichainConstraint.cpp
// Function: AntichainConstraint::Push(int, double, std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>>&, std::vector<int, std::allocator<int>>&)
double AntichainConstraint::Push(int x, double flow, vvd& R, vi& D)
{
    if (x == T)
        return flow;
    for (int y : G[x])
        if (R[x][y] > 0 && D[y] == D[x] + 1)
            if (double f = Push(y, min(flow, R[x][y]), R, D))
                return R[x][y] -= f, R[y][x] += f, f;
    return D[x] = -1, 0;
}

// Assembly:
movapd %xmm0, %xmm1
cmpl %esi, 0x4c(%rdi)
je 0x3a702
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq 0x38(%rdi), %rax
movslq %esi, %r15
movq (%rax), %rax
leaq (%r15,%r15,2), %r14
movq (%rax,%r14,8), %r13
movq 0x8(%rax,%r14,8), %r10
cmpq %r10, %r13
sete %bpl
je 0x3a6d9
xorpd %xmm2, %xmm2
movq %rcx, 0x20(%rsp)
movsd %xmm1, 0x18(%rsp)
movq %rdi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq %r10, 0x30(%rsp)
movslq (%r13), %r12
movq (%rdx), %rax
movq (%rax,%r14,8), %rax
movsd (%rax,%r12,8), %xmm0
movb $0x1, %bl
ucomisd %xmm2, %xmm0
jbe 0x3a6c2
movq (%rcx), %rax
movl (%rax,%r15,4), %r9d
incl %r9d
cmpl %r9d, (%rax,%r12,4)
jne 0x3a6c2
minsd %xmm1, %xmm0
movl %r12d, %esi
callq 0x3a5c2
xorpd %xmm2, %xmm2
ucomisd %xmm2, %xmm0
jne 0x3a664
jnp 0x3a69e
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq (%rax,%r14,8), %rcx
movsd (%rcx,%r12,8), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, (%rcx,%r12,8)
leaq (%r12,%r12,2), %rcx
movq (%rax,%rcx,8), %rax
movsd (%rax,%r15,8), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rax,%r15,8)
movsd %xmm0, 0x28(%rsp)
ucomisd %xmm2, %xmm0
movq 0x30(%rsp), %r10
jne 0x3a6ab
jnp 0x3a6ad
xorl %ebx, %ebx
movq 0x20(%rsp), %rcx
movsd 0x18(%rsp), %xmm1
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rdx
testb %bl, %bl
je 0x3a6d9
addq $0x4, %r13
cmpq %r10, %r13
sete %bpl
jne 0x3a61f
jmp 0x3a6d9
movsd 0x28(%rsp), %xmm1
testb $0x1, %bpl
je 0x3a6f4
movq (%rcx), %rax
movl $0xffffffff, (%rax,%r15,4) # imm = 0xFFFFFFFF
xorpd %xmm1, %xmm1
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
movapd %xmm1, %xmm0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/canzarlab[P]Trajan/src/AntichainConstraint.cpp
// Function: AntichainConstraint::LevelGraph(std::vector<int, std::allocator<int>>&, std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>>&)
bool AntichainConstraint::LevelGraph(vi& D, vvd& R)
{
    queue<int> W;
    W.push(S);
    D[S] = 0;
    while (!W.empty())
    {
        int k = W.front(); W.pop();
        if (k == T) return true;
        for (int x : G[k])
            if (D[x] == -1 && R[k][x] > 0)
                D[x] = D[k] + 1, W.push(x);
    }
    return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorpd %xmm0, %xmm0
leaq 0x10(%rsp), %r13
movapd %xmm0, 0x40(%r13)
movapd %xmm0, 0x30(%r13)
movapd %xmm0, 0x20(%r13)
movapd %xmm0, 0x10(%r13)
movapd %xmm0, (%r13)
movq %r13, %rdi
xorl %esi, %esi
callq 0x3af04
leaq 0x48(%r15), %r12
movq 0x30(%r13), %rax
movq 0x40(%r13), %rcx
addq $-0x4, %rcx
cmpq %rcx, %rax
je 0x3a776
movl (%r12), %ecx
movl %ecx, (%rax)
addq $0x4, %rax
movq %rax, 0x40(%rsp)
jmp 0x3a783
leaq 0x10(%rsp), %rdi
movq %r12, %rsi
callq 0x3b07a
movslq (%r12), %rax
movq (%r14), %rcx
movl $0x0, (%rcx,%rax,4)
movq 0x20(%rsp), %rax
cmpq %rax, 0x40(%rsp)
setne %bpl
je 0x3a89d
movq %r15, 0x60(%rsp)
movslq (%rax), %r12
movq 0x30(%rsp), %rcx
addq $-0x4, %rcx
cmpq %rcx, %rax
je 0x3a7c1
addq $0x4, %rax
jmp 0x3a7f3
movq 0x28(%rsp), %rdi
movl $0x200, %esi            # imm = 0x200
callq 0x9340
movq 0x38(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x38(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x28(%rsp)
leaq 0x200(%rax), %rcx
movq %rcx, 0x30(%rsp)
movq %rax, 0x20(%rsp)
cmpl 0x4c(%r15), %r12d
je 0x3a89d
movq 0x38(%r15), %rax
movq (%rax), %rax
leaq (%r12,%r12,2), %rbp
movq (%rax,%rbp,8), %r13
movq 0x8(%rax,%rbp,8), %r15
cmpq %r15, %r13
je 0x3a884
movslq (%r13), %rax
movl %eax, 0xc(%rsp)
movq (%r14), %rcx
cmpl $-0x1, (%rcx,%rax,4)
jne 0x3a87e
movq (%rbx), %rdx
movq (%rdx,%rbp,8), %rdx
movsd (%rdx,%rax,8), %xmm0
ucomisd 0x21b90(%rip), %xmm0    # 0x5c3d0
jbe 0x3a87e
movl (%rcx,%r12,4), %edx
incl %edx
movl %edx, (%rcx,%rax,4)
movq 0x40(%rsp), %rax
movq 0x50(%rsp), %rcx
addq $-0x4, %rcx
cmpq %rcx, %rax
je 0x3a86f
movl 0xc(%rsp), %ecx
movl %ecx, (%rax)
addq $0x4, %rax
movq %rax, 0x40(%rsp)
jmp 0x3a87e
leaq 0x10(%rsp), %rdi
leaq 0xc(%rsp), %rsi
callq 0x3b07a
addq $0x4, %r13
jmp 0x3a816
movq 0x20(%rsp), %rax
cmpq %rax, 0x40(%rsp)
setne %bpl
movq 0x60(%rsp), %r15
jne 0x3a7aa
leaq 0x10(%rsp), %rdi
callq 0x3ac32
andb $0x1, %bpl
movl %ebp, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3a8be
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x3ac32
movq %rbx, %rdi
callq 0x9670
nop
// File: /workspace/github_cpp_makefile_star2_O1/canzarlab[P]Trajan/src/AntichainConstraint.cpp
// Function: AntichainConstraint::MaxFlow(std::vector<int, std::allocator<int>>&, std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>>&)
double AntichainConstraint::MaxFlow(vi& D, vvd& R)
{
    double flow = 0;
    while (LevelGraph(D, R))
    {
        while (double f = Push(S, INF, R, D))
            flow += f;
        fill(D.begin(), D.end(), -1);
    }
    return flow;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x3a708
xorpd %xmm0, %xmm0
testb %al, %al
je 0x3a985
movapd %xmm0, (%rsp)
movl 0x48(%r15), %esi
movq %r15, %rdi
movsd 0x21aa5(%rip), %xmm0    # 0x5c3b0
movq %rbx, %rdx
movq %r14, %rcx
callq 0x3a5c2
xorpd %xmm2, %xmm2
ucomisd %xmm2, %xmm0
movapd (%rsp), %xmm3
movapd %xmm3, %xmm1
addsd %xmm0, %xmm1
cmpneqsd %xmm2, %xmm0
andpd %xmm0, %xmm1
andnpd %xmm3, %xmm0
orpd %xmm1, %xmm0
jne 0x3a8f7
jp 0x3a8f7
movapd %xmm0, (%rsp)
movq (%r14), %rdi
movq 0x8(%r14), %rdx
cmpq %rdx, %rdi
je 0x3a96a
subq %rdi, %rdx
addq $-0x4, %rdx
andq $-0x4, %rdx
addq $0x4, %rdx
movl $0xff, %esi
callq 0x91c0
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x3a708
testb %al, %al
movapd (%rsp), %xmm0
jne 0x3a8f7
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/canzarlab[P]Trajan/src/Constraint.cpp
// Function: Constraint::AddConstraint(int, std::vector<std::pair<int, int>, std::allocator<std::pair<int, int>>>&)
void Constraint::AddConstraint(int row, vii& P)
{
    for (auto k : P)
    {
        int col = GetCol(k.first, k.second);
        if (col != -1)
            Triplets.emplace_back(row, col, 1.);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, 0xc(%rsp)
movq (%rdx), %r13
movq 0x8(%rdx), %rbp
cmpq %rbp, %r13
je 0x3b495
movq %rdi, %rbx
leaq 0xc(%rsp), %r14
leaq 0x8(%rsp), %r15
leaq 0x10(%rsp), %r12
movl (%r13), %eax
cmpb $0x0, 0x30(%rbx)
movl 0x4(%r13), %ecx
movl %eax, %edx
cmovnel %ecx, %edx
cmovnel %eax, %ecx
movq 0x20(%rbx), %rax
movslq %edx, %rdx
movq (%rax), %rax
leaq (%rdx,%rdx,2), %rdx
movslq %ecx, %rcx
movq (%rax,%rdx,8), %rax
movl (%rax,%rcx,4), %eax
movl %eax, 0x8(%rsp)
cmpl $-0x1, %eax
je 0x3b48c
movq 0x8(%rbx), %rdi
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, 0x10(%rsp)
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x37e6c
addq $0x8, %r13
cmpq %rbp, %r13
jne 0x3b436
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/canzarlab[P]Trajan/src/IndependentSetConstraint.cpp
// Function: IndependentSetConstraint::AddTriplets(int)
int IndependentSetConstraint::AddTriplets(int nr_rows)
{
    DFSRight(t2.GetRoot());
    int ncr = 0;
    for (newick_node* node : t1.L)
    {
        dLN L = DFSRight(node, t2.GetRoot());
        if (L.first - EPS <= 1)
            continue;

        vii P;
        for (newick_node* noder : L.second)
            for (newick_node* nodel = node; nodel; nodel = nodel->parent ? nodel->parent->node : nullptr)
                P.emplace_back(nodel->taxoni, noder->taxoni);

        AddConstraint(nr_rows + ncr++, P);
    }
    return ncr;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, 0x30(%rsp)
movq %rdi, %r14
movq 0x18(%rdi), %rax
movq 0x68(%rax), %rsi
callq 0x3b704
movq 0x10(%r14), %rax
movq 0x8(%rax), %rbp
movq 0x10(%rax), %rax
movq %rax, 0x40(%rsp)
cmpq %rax, %rbp
je 0x3b6a3
leaq 0x50(%rsp), %r12
movq $0x0, 0x8(%rsp)
leaq 0x10(%rsp), %r13
movq %r14, 0x28(%rsp)
movq (%rbp), %r15
movq 0x18(%r14), %rax
movq 0x68(%rax), %rcx
leaq 0x48(%rsp), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x3b742
movsd 0x48(%rsp), %xmm0
addsd 0x348bf(%rip), %xmm0    # 0x6fe80
movsd 0x20ddf(%rip), %xmm1    # 0x5c3a8
ucomisd %xmm0, %xmm1
jae 0x3b673
movq %rbp, 0x38(%rsp)
xorpd %xmm0, %xmm0
movapd %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
movq 0x50(%rsp), %r14
cmpq %r12, %r14
je 0x3b62e
testq %r15, %r15
je 0x3b629
movq 0x10(%r14), %rbx
addq $0x28, %rbx
movq %r15, %rbp
leaq 0x28(%rbp), %rsi
movq %r13, %rdi
movq %rbx, %rdx
callq 0x3abf8
movq 0x30(%rbp), %rax
testq %rax, %rax
je 0x3b622
movq (%rax), %rbp
jmp 0x3b624
xorl %ebp, %ebp
testq %rbp, %rbp
jne 0x3b605
movq (%r14), %r14
jmp 0x3b5f0
movq 0x30(%rsp), %rax
movq 0x8(%rsp), %rcx
leal (%rcx,%rax), %esi
movq 0x28(%rsp), %r14
movq %r14, %rdi
movq %r13, %rdx
callq 0x3b406
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
movq 0x38(%rsp), %rbp
je 0x3b667
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x9340
movq 0x8(%rsp), %rax
incl %eax
movq %rax, 0x8(%rsp)
movq 0x50(%rsp), %rdi
cmpq %r12, %rdi
je 0x3b692
movq (%rdi), %rbx
movl $0x18, %esi
callq 0x9340
movq %rbx, %rdi
cmpq %r12, %rbx
jne 0x3b67d
addq $0x8, %rbp
cmpq 0x40(%rsp), %rbp
jne 0x3b597
jmp 0x3b6ac
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3b6c2
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x3b6dc
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x9340
movq 0x50(%rsp), %rdi
cmpq %r12, %rdi
je 0x3b6fb
movq (%rdi), %r14
movl $0x18, %esi
callq 0x9340
movq %r14, %rdi
cmpq %r12, %r14
jne 0x3b6e6
movq %rbx, %rdi
callq 0x9670
nop
// File: /workspace/github_cpp_makefile_star2_O1/canzarlab[P]Trajan/src/IndependentSetConstraint.cpp
// Function: IndependentSetConstraint::DFSLeft(newick_node*, newick_node*, double)
void IndependentSetConstraint::DFSLeft(newick_node* nodel, newick_node* noder, double w)
{
    if (!nodel->child)
        D[nodel->taxoni][noder->taxoni] = w + GetWeight(nodel, noder);
    for (newick_child* child = nodel->child; child; child = child->next)
        DFSLeft(child->node, noder, w + GetWeight(nodel, noder));
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movsd %xmm0, (%rsp)
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
cmpq $0x0, (%rsi)
jne 0x3ba4a
movslq 0x28(%r14), %rax
movslq 0x28(%rbx), %rcx
movq 0x20(%r15), %rdx
movq (%rdx), %rdx
cmpb $0x0, 0x30(%r15)
movl %eax, %esi
cmovnel %ecx, %esi
movl %ecx, %edi
cmovnel %eax, %edi
movslq %esi, %rsi
leaq (%rsi,%rsi,2), %rsi
movslq %edi, %rdi
movq (%rdx,%rsi,8), %rdx
movslq (%rdx,%rdi,4), %rdx
cmpq $-0x1, %rdx
je 0x3ba30
testl %edx, %edx
js 0x3bac8
movq 0x28(%r15), %rsi
cmpq %rdx, 0x8(%rsi)
jle 0x3bac8
movq (%rsi), %rsi
movsd (%rsi,%rdx,8), %xmm0
jmp 0x3ba34
xorpd %xmm0, %xmm0
addsd (%rsp), %xmm0
movq 0x38(%r15), %rdx
leaq (%rax,%rax,2), %rax
movq (%rdx,%rax,8), %rax
movsd %xmm0, (%rax,%rcx,8)
movq (%r14), %r12
testq %r12, %r12
je 0x3babc
movq (%r12), %rsi
movl 0x28(%r14), %eax
movl 0x28(%rbx), %ecx
cmpb $0x0, 0x30(%r15)
movl %eax, %edx
cmovnel %ecx, %edx
cmovnel %eax, %ecx
movq 0x20(%r15), %rax
movslq %edx, %rdx
movq (%rax), %rax
leaq (%rdx,%rdx,2), %rdx
movslq %ecx, %rcx
movq (%rax,%rdx,8), %rax
movslq (%rax,%rcx,4), %rax
cmpq $-0x1, %rax
je 0x3baa1
testl %eax, %eax
js 0x3bac8
movq 0x28(%r15), %rcx
cmpq %rax, 0x8(%rcx)
jle 0x3bac8
movq (%rcx), %rcx
movsd (%rcx,%rax,8), %xmm0
jmp 0x3baa5
xorpd %xmm0, %xmm0
addsd (%rsp), %xmm0
movq %r15, %rdi
movq %rbx, %rdx
callq 0x3b9be
movq 0x8(%r12), %r12
jmp 0x3ba4d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x21756(%rip), %rdi     # 0x5d225
leaq 0x2176c(%rip), %rsi     # 0x5d242
leaq 0x21788(%rip), %rcx     # 0x5d265
movl $0x1a9, %edx            # imm = 0x1A9
callq 0x9200
nop
// File: /workspace/github_cpp_makefile_star2_O1/canzarlab[P]Trajan/src/CrossingConstraint.cpp
// Function: CrossingConstraint::CrossingConstraint(std::vector<Eigen::Triplet<double, int>, std::allocator<Eigen::Triplet<double, int>>>&, Graph&, Graph&, std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>>&, Eigen::Matrix<double, -1, 1, 0, -1, 1>&, bool)
CrossingConstraint::CrossingConstraint(vector<ET>& Triplets, Graph& t1, Graph& t2, vvi& K, Vector& x, bool swp) : Constraint(Triplets, t1, t2, K, x, swp)
{
    DP.resize(t1.GetNumNodes());
    PA.resize(t1.GetNumNodes());
    for (auto& v : DP)
        v.resize(t2.GetNumNodes());

    vb C(t1.GetNumNodes());
    DFSLeft(t1.GetRoot(), C);
    Q.push(t1.GetRoot());
    RunParallel();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, %rbp
movq %rdx, %r13
movq %rdi, %rbx
movzbl 0x90(%rsp), %eax
movl %eax, (%rsp)
callq 0x3b3e0
leaq 0x4aa06(%rip), %rax     # 0x866d0
movq %rax, (%rbx)
leaq 0x68(%rbx), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rbx)
movups %xmm0, 0x50(%rbx)
movups %xmm0, 0x60(%rbx)
movups %xmm0, 0x70(%rbx)
movups %xmm0, 0x80(%rbx)
movups %xmm0, 0x90(%rbx)
movups %xmm0, 0xa0(%rbx)
movq $0x0, 0xb0(%rbx)
movq %r14, %rdi
xorl %esi, %esi
callq 0x3c6c0
leaq 0xb8(%rbx), %r15
leaq 0xd0(%rbx), %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0xd8(%rbx)
movups %xmm0, 0xc8(%rbx)
movups %xmm0, 0xb8(%rbx)
movslq 0x70(%r13), %rsi
movq %rdi, 0x40(%rsp)
movq %r15, 0x48(%rsp)
callq 0x3c5de
movslq 0x70(%r13), %rsi
movq %r15, %rdi
callq 0x3c61a
movq 0xd0(%rbx), %r15
movq 0xd8(%rbx), %r12
cmpq %r12, %r15
je 0x3bd78
movslq 0x70(%rbp), %rsi
movq %r15, %rdi
callq 0x3c64c
addq $0x18, %r15
jmp 0x3bd61
movslq 0x70(%r13), %rsi
leaq 0x50(%rsp), %rdx
movb $0x0, (%rdx)
leaq 0x18(%rsp), %rdi
leaq 0x17(%rsp), %rcx
callq 0x311d8
movq 0x68(%r13), %rsi
leaq 0x18(%rsp), %rdx
movq %rbx, %rdi
callq 0x3be74
movq 0x68(%r13), %rax
leaq 0x50(%rsp), %rsi
movq %rax, (%rsi)
movq %r14, %rdi
callq 0x3cbcc
movq %rbx, %rdi
callq 0x3bf36
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x3bdf0
movq 0x38(%rsp), %rsi
subq %rdi, %rsi
callq 0x9340
xorl %eax, %eax
movq %rax, 0x18(%rsp)
movl %eax, 0x20(%rsp)
movq %rax, 0x28(%rsp)
movl %eax, 0x30(%rsp)
movq %rax, 0x38(%rsp)
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3be01
movq %rax, %r13
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x3be3d
movq 0x38(%rsp), %rsi
subq %rdi, %rsi
callq 0x9340
xorl %eax, %eax
movq %rax, 0x18(%rsp)
movl %eax, 0x20(%rsp)
movq %rax, 0x28(%rsp)
movl %eax, 0x30(%rsp)
movq %rax, 0x38(%rsp)
jmp 0x3be3d
jmp 0x3be3a
jmp 0x3be3a
movq %rax, %r13
movq 0x40(%rsp), %rdi
callq 0x30124
movq 0x48(%rsp), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x3be63
movq 0xc8(%rbx), %rsi
subq %rdi, %rsi
callq 0x9340
movq %r14, %rdi
callq 0x3839c
movq %r13, %rdi
callq 0x9670
nop
// File: /workspace/github_cpp_makefile_star2_O1/canzarlab[P]Trajan/src/CrossingConstraint.cpp
// Function: CrossingConstraint::DFSLeft(newick_node*, std::vector<bool, std::allocator<bool>>&)
void CrossingConstraint::DFSLeft(newick_node* node, vb& C)
{
    C[node->taxoni] = true;
    for (newick_child* child = node->child; child; child = child->next)
    {
        PA[child->node->taxoni]++;
        if (!C[child->node->taxoni])
            DFSLeft(child->node, C);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movslq 0x28(%rsi), %rcx
leaq 0x3f(%rcx), %rax
testq %rcx, %rcx
cmovnsq %rcx, %rax
sarq $0x6, %rax
shlq $0x3, %rax
addq (%rdx), %rax
movabsq $-0x8000000000000000, %r15 # imm = 0x8000000000000000
leaq 0x3f(%r15), %rdx
andq %rcx, %rdx
xorl %r8d, %r8d
cmpq %r15, %rdx
setbe %r8b
movl $0x1, %edx
shlq %cl, %rdx
orq %rdx, -0x8(%rax,%r8,8)
movq (%rsi), %r12
testq %r12, %r12
je 0x3bf2c
movq %rdi, %r14
leaq 0x3f(%r15), %r13
movq (%r12), %rsi
movslq 0x28(%rsi), %rax
movq 0xb8(%r14), %rcx
incl (%rcx,%rax,4)
movslq 0x28(%rsi), %rax
leaq 0x3f(%rax), %rcx
testq %rax, %rax
cmovnsq %rax, %rcx
sarq $0x6, %rcx
shlq $0x3, %rcx
addq (%rbx), %rcx
movq %rax, %rdx
andq %r13, %rdx
xorl %edi, %edi
cmpq %r15, %rdx
setbe %dil
movq -0x8(%rcx,%rdi,8), %rcx
btq %rax, %rcx
jb 0x3bf22
movq %r14, %rdi
movq %rbx, %rdx
callq 0x3be74
movq 0x8(%r12), %r12
testq %r12, %r12
jne 0x3bed1
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/canzarlab[P]Trajan/src/CrossingConstraint.cpp
// Function: CrossingConstraint::RunParallel()
void CrossingConstraint::RunParallel()
{
    const size_t NR_THREADS = min(::NR_THREADS, size_t(64));
    ax = (NR_THREADS < 64 ? (uint64_t(1) << NR_THREADS) - 1 : ~0);
    vector<thread> vt;
    for (int i = 0; i < NR_THREADS; ++i)
        vt.emplace_back(&CrossingConstraint::CrossingJob, this, i);

    for (int i = 0; i < NR_THREADS; ++i)
        vt[i].join();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movl $0xf, %eax
xchgq %rax, 0x38(%rdi)
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %r14
movaps %xmm0, (%r14)
movq $0x0, 0x10(%r14)
leaq 0x4(%rsp), %r15
movl $0x0, (%r15)
leaq 0x377(%rip), %rbp       # 0x3c2ee
leaq 0x10(%rsp), %r12
leaq 0x8(%rsp), %r13
movq %rbp, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movq %rbx, 0x8(%rsp)
movq %r14, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %r15, %rcx
callq 0x3c67e
movl 0x4(%rsp), %eax
incl %eax
movl %eax, 0x4(%rsp)
cmpl $0x4, %eax
jb 0x3bf81
xorl %ebx, %ebx
movq 0x20(%rsp), %rdi
addq %rbx, %rdi
callq 0x9620
addq $0x8, %rbx
cmpq $0x20, %rbx
jne 0x3bfb6
leaq 0x20(%rsp), %rdi
callq 0x3abbc
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3bfe8
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x3abbc
movq %rbx, %rdi
callq 0x9670
nop
// File: /workspace/github_cpp_makefile_star2_O1/canzarlab[P]Trajan/src/CrossingConstraint.cpp
// Function: CrossingConstraint::AddTriplets(int)
int CrossingConstraint::AddTriplets(int nr_rows)
{
    int ncr = 0;
    for (auto node : t1.L)
    {
        vii P;
        Reconstruct(P, node, t2.GetRoot());

        double sum = 0;
        for (auto k : P)
            sum += GetWeight(k.first, k.second);

        if (sum - EPS > 1)
            AddConstraint(nr_rows + ncr++, P);
    }
    return ncr;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq 0x10(%rdi), %rax
movq 0x8(%rax), %r13
movq 0x10(%rax), %rbp
cmpq %rbp, %r13
je 0x3c114
movl %esi, %ebx
movq %rdi, %r14
xorl %r15d, %r15d
movq %rsp, %r12
movq (%r13), %rdx
xorpd %xmm0, %xmm0
movapd %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movq 0x18(%r14), %rax
movq 0x68(%rax), %rcx
movq %r14, %rdi
movq %r12, %rsi
callq 0x3c16c
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
cmpq %rcx, %rax
je 0x3c0ef
movb 0x30(%r14), %dl
movq 0x20(%r14), %rdi
movq 0x28(%r14), %rsi
movq (%rdi), %rdi
xorpd %xmm0, %xmm0
movl (%rax), %r8d
movl 0x4(%rax), %r9d
testb %dl, %dl
movl %r8d, %r10d
cmovnel %r9d, %r10d
cmovnel %r8d, %r9d
movslq %r10d, %r8
leaq (%r8,%r8,2), %r8
movslq %r9d, %r9
movq (%rdi,%r8,8), %r8
movslq (%r8,%r9,4), %r8
xorpd %xmm1, %xmm1
cmpq $-0x1, %r8
je 0x3c0be
testl %r8d, %r8d
js 0x3c129
cmpq %r8, 0x8(%rsi)
jle 0x3c129
movq (%rsi), %r9
movsd (%r9,%r8,8), %xmm1
addsd %xmm1, %xmm0
addq $0x8, %rax
cmpq %rcx, %rax
jne 0x3c07a
addsd 0x33dad(%rip), %xmm0    # 0x6fe80
ucomisd 0x202cd(%rip), %xmm0    # 0x5c3a8
jbe 0x3c0ef
leal (%r15,%rbx), %esi
movq %r14, %rdi
movq %r12, %rdx
callq 0x3b406
incl %r15d
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x3c105
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x9340
addq $0x8, %r13
cmpq %rbp, %r13
jne 0x3c02c
jmp 0x3c117
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x210f5(%rip), %rdi     # 0x5d225
leaq 0x2110b(%rip), %rsi     # 0x5d242
leaq 0x21127(%rip), %rcx     # 0x5d265
movl $0x1a9, %edx            # imm = 0x1A9
callq 0x9200
jmp 0x3c14a
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x3c163
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x9340
movq %rbx, %rdi
callq 0x9670
nop
// File: /workspace/github_cpp_makefile_star2_O1/canzarlab[P]Trajan/src/CrossingConstraint.cpp
// Function: CrossingConstraint::Reconstruct(std::vector<std::pair<int, int>, std::allocator<std::pair<int, int>>>&, newick_node*, newick_node*)
void CrossingConstraint::Reconstruct(vii& P, newick_node* nodel, newick_node* noder)
{
    double pw, cw;
    newick_node *child, *parent;
    tie(child, cw) = GetMaxChild(nodel, noder);
    tie(parent, pw) = GetMaxParent(noder, nodel);
    P.emplace_back(nodel->taxoni, noder->taxoni);
    if (nodel->parent && (!child || pw > cw))
        Reconstruct(P, parent, noder);
    else if (child && (!parent || cw >= pw))
        Reconstruct(P, nodel, child);
    else
        assert(!parent && !child);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %r12
movq %rdx, %rbx
movq %rsi, 0x8(%rsp)
movq %rdi, %r14
leaq 0x28(%rbx), %r13
movq (%r12), %rax
xorpd %xmm3, %xmm3
testq %rax, %rax
je 0x3c1ee
movq 0xd0(%r14), %rcx
movslq 0x28(%rbx), %rdx
leaq (%rdx,%rdx,2), %rdx
movq (%rcx,%rdx,8), %rcx
xorpd %xmm0, %xmm0
xorl %ebp, %ebp
movapd %xmm0, %xmm4
movq (%rax), %rdx
movq 0x8(%rax), %rax
movslq 0x28(%rdx), %rsi
movsd (%rcx,%rsi,8), %xmm1
ucomisd %xmm0, %xmm1
cmpnlesd %xmm1, %xmm4
movapd %xmm4, %xmm2
andnpd %xmm1, %xmm2
andpd %xmm0, %xmm4
orpd %xmm2, %xmm4
cmovaeq %rdx, %rbp
movapd %xmm4, %xmm0
testq %rax, %rax
jne 0x3c1b6
jmp 0x3c1f4
xorpd %xmm4, %xmm4
xorl %ebp, %ebp
movq 0x30(%rbx), %rax
testq %rax, %rax
movapd %xmm4, 0x10(%rsp)
je 0x3c25a
movq 0xd0(%r14), %rcx
movslq 0x28(%r12), %rdx
xorpd %xmm0, %xmm0
xorl %r15d, %r15d
movapd %xmm0, %xmm3
movq (%rax), %rsi
movq 0x8(%rax), %rax
movslq 0x28(%rsi), %rdi
leaq (%rdi,%rdi,2), %rdi
movq (%rcx,%rdi,8), %rdi
movsd (%rdi,%rdx,8), %xmm1
ucomisd %xmm0, %xmm1
cmpnlesd %xmm1, %xmm3
movapd %xmm3, %xmm2
andnpd %xmm1, %xmm2
andpd %xmm0, %xmm3
orpd %xmm2, %xmm3
cmovaeq %rsi, %r15
movapd %xmm3, %xmm0
testq %rax, %rax
jne 0x3c21a
jmp 0x3c25d
xorl %r15d, %r15d
movapd %xmm3, 0x20(%rsp)
leaq 0x28(%r12), %rdx
movq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0x3abf8
movapd 0x20(%rsp), %xmm0
cmpq $0x0, 0x30(%rbx)
movapd 0x10(%rsp), %xmm1
je 0x3c293
testq %rbp, %rbp
je 0x3c2b3
ucomisd %xmm1, %xmm0
ja 0x3c2b3
testq %rbp, %rbp
je 0x3c2bb
movq %rbp, %r12
testq %r15, %r15
je 0x3c18c
ucomisd %xmm0, %xmm1
movq %rbp, %r12
jae 0x3c18c
jmp 0x3c2bb
movq %r15, %rbx
jmp 0x3c188
orq %r15, %rbp
jne 0x3c2cf
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x33bcd(%rip), %rdi     # 0x6fea3
leaq 0x33bd8(%rip), %rsi     # 0x6feb5
leaq 0x33bec(%rip), %rcx     # 0x6fed0
movl $0x91, %edx
callq 0x9200