LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/schuyler[P]quickfix/include/quickfix/particle_filter.h
// Function: ParticleFilter<float, 2>::shuffle()
void ParticleFilter<F,D>::shuffle() {
    int i = 0, total = 0;
    Particles p_ = P;
    while (i < N) {
        // FIXME: this seems heavy handed
        Weights select(N, 1);
        select << Weights::Random(N, 1).array() * 0.5 + 0.5;
        select -= W;
        for (int j = 0; i < N && j < N; j++) {
            //std::cout << i << ": " << j << " " << W[j] << " > " << select[j] << "\n";
            if (select[j] < 0.) {
                P.row(i)= p_.row(j);
                i++;
            }
            total++;
        }
        //j = (j + 1) % N;
    }
    qfdebug("Particle shuffle took " << total << " iterations");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x8(%rdi), %rsi
leaq 0x18(%rsp), %rdi
callq 0xd770
movl 0x30(%rbx), %eax
testl %eax, %eax
jle 0x1a1be
xorl %r15d, %r15d
movq %rsp, %r14
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movslq %eax, %rsi
movl $0x1, %edx
movq %r14, %rdi
callq 0xdc00
movslq 0x30(%rbx), %r12
testq %r12, %r12
jle 0x1a0e3
movq (%rsp), %r13
xorl %ebp, %ebp
callq 0xd100
movss 0xaf4f(%rip), %xmm1     # 0x25018
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
mulss %xmm1, %xmm0
movss %xmm0, (%r13,%rbp,4)
incq %rbp
cmpq %rbp, %r12
jne 0x1a0bc
movq 0x18(%rbx), %rax
movq (%rsp), %rcx
movq 0x8(%rsp), %rdx
leaq 0x3(%rdx), %rsi
testq %rdx, %rdx
cmovnsq %rdx, %rsi
andq $-0x4, %rsi
cmpq $0x4, %rdx
jl 0x1a11c
xorl %edi, %edi
movaps (%rcx,%rdi,4), %xmm0
subps (%rax,%rdi,4), %xmm0
movaps %xmm0, (%rcx,%rdi,4)
addq $0x4, %rdi
cmpq %rsi, %rdi
jl 0x1a107
cmpq %rdx, %rsi
xorps %xmm1, %xmm1
jge 0x1a13b
movss (%rcx,%rsi,4), %xmm0
subss (%rax,%rsi,4), %xmm0
movss %xmm0, (%rcx,%rsi,4)
incq %rsi
cmpq %rsi, %rdx
jne 0x1a124
movl 0x30(%rbx), %eax
cmpl %eax, %r15d
setge %cl
testl %eax, %eax
setle %dl
orb %cl, %dl
jne 0x1a1a9
movq (%rsp), %rcx
movq 0x18(%rsp), %rdx
movq 0x20(%rsp), %r8
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdi
leaq (%rdx,%r8,4), %r8
movl $0x1, %r9d
ucomiss -0x4(%rcx,%r9,4), %xmm1
jbe 0x1a198
movslq %r15d, %r15
leaq (%rsi,%r15,4), %r10
movss -0x4(%rdx,%r9,4), %xmm0
movss %xmm0, (%r10)
movss -0x4(%r8,%r9,4), %xmm0
movss %xmm0, (%r10,%rdi,4)
incl %r15d
cmpl %eax, %r15d
jge 0x1a1a9
leaq 0x1(%r9), %r10
cmpq %rax, %r9
movq %r10, %r9
jb 0x1a16d
movq (%rsp), %rdi
callq 0xd740
movl 0x30(%rbx), %eax
cmpl %eax, %r15d
jl 0x1a096
movq 0x18(%rsp), %rdi
callq 0xd740
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
callq 0xd740
movq 0x18(%rsp), %rdi
callq 0xd740
movq %rbx, %rdi
callq 0xdb50
nop
// File: /workspace/github_cpp_makefile_star2_O1/schuyler[P]quickfix/include/quickfix/fix.h
// Function: Eigen::Array<float, 1, 2, 1, 1, 2> Beacon<float, 2>::solveNonLinear<Beacon<float, 2>::DifferenceSolver>(Beacon<float, 2> const&, float)
typename Beacon<F, D>::Point Beacon<F, D>::solveNonLinear(const Beacon &B, F time) {
    Functor functor(B, time);
    functor.setCoefficients();

    NumericalDiff<Functor> numDiff(functor);
    LevenbergMarquardt<NumericalDiff<Functor>, F> lm(numDiff);

    typename Functor::InputType x = functor.solveLinear();
    lm.minimize(x);
    // Turn the [D+1, 1] solution matrix into a [1, D] vector
    Map<Point> y(x.data(), x.size() - 1);
    return y;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x1b8, %rsp            # imm = 0x1B8
movq %rdi, %rbx
leaq 0x18(%rsp), %r14
movq %r14, %rdi
callq 0xd030
movq %r14, %rdi
callq 0xd300
leaq 0x50(%rsp), %r14
leaq 0x18(%rsp), %rsi
xorps %xmm0, %xmm0
movq %r14, %rdi
callq 0xd480
movl $0x42c80000, 0x88(%rsp) # imm = 0x42C80000
movq $0x190, 0x90(%rsp) # imm = 0x190
movsd 0x9cfc(%rip), %xmm0     # 0x25480
movsd %xmm0, 0x98(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0xa0(%rsp)
movups %xmm0, 0xb0(%rsp)
movups %xmm0, 0xc0(%rsp)
movups %xmm0, 0xd0(%rsp)
movups %xmm0, 0xe0(%rsp)
movups %xmm0, 0xf0(%rsp)
movq %r14, 0x128(%rsp)
movups %xmm0, 0x100(%rsp)
movups %xmm0, 0x110(%rsp)
movb $0x0, 0x120(%rsp)
movups %xmm0, 0x140(%rsp)
movups %xmm0, 0x150(%rsp)
movups %xmm0, 0x160(%rsp)
movups %xmm0, 0x170(%rsp)
leaq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0xd240
leaq 0x88(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xd3f0
movq 0x8(%rsp), %rdi
movsd (%rdi), %xmm0
movsd %xmm0, (%rbx)
callq 0xd740
movq 0x170(%rsp), %rdi
callq 0xd740
movq 0x160(%rsp), %rdi
callq 0xd740
movq 0x150(%rsp), %rdi
callq 0xd740
movq 0x140(%rsp), %rdi
callq 0xd740
movq 0xf0(%rsp), %rdi
callq 0xd740
movq 0xd8(%rsp), %rdi
callq 0xd740
movq 0xc8(%rsp), %rdi
callq 0xd740
movq 0xb8(%rsp), %rdi
callq 0xd740
movq 0xa8(%rsp), %rdi
callq 0xd740
movq 0xf6a9(%rip), %r14      # 0x2af58
addq $0x10, %r14
movq %r14, 0x50(%rsp)
movq 0x70(%rsp), %rdi
callq 0xd740
movq 0x60(%rsp), %rdi
callq 0xd740
movq %r14, 0x18(%rsp)
movq 0x38(%rsp), %rdi
callq 0xd740
movq 0x28(%rsp), %rdi
callq 0xd740
movq %rbx, %rax
addq $0x1b8, %rsp            # imm = 0x1B8
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
callq 0xd740
jmp 0x1b905
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0xdbb0
movq 0xf63f(%rip), %rax      # 0x2af58
addq $0x10, %rax
movq %rax, 0x50(%rsp)
movq 0x70(%rsp), %rdi
callq 0xd740
movq 0x60(%rsp), %rdi
callq 0xd740
jmp 0x1b93d
jmp 0x1b93a
movq %rax, %rbx
movq 0xf614(%rip), %rax      # 0x2af58
addq $0x10, %rax
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rdi
callq 0xd740
movq 0x28(%rsp), %rdi
callq 0xd740
movq %rbx, %rdi
callq 0xdb50
nop
// File: /workspace/github_cpp_makefile_star2_O1/biotomas[P]ipasir/sat/picosat961/picosat-961/picogcnf.c
// Function: die
static void die (const char * fmt, ...) {
  va_list ap;
  fprintf (stderr, "*** picogcnf: ");
  va_start (ap, fmt);
  vfprintf (stderr, fmt, ap);
  va_end (ap);
  fputc ('\n', stderr);
  exit (1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %r14
movq %rsi, 0x8(%r14)
movq %rdx, 0x10(%r14)
movq %rcx, 0x18(%r14)
movq %r8, 0x20(%r14)
movq %r9, 0x28(%r14)
testb %al, %al
je 0x1c22
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq 0x153cf(%rip), %r15     # 0x16ff8
movq (%r15), %rcx
leaq 0xe5ab(%rip), %rdi      # 0x101de
movl $0xe, %esi
movl $0x1, %edx
callq 0x11b0
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rsp, %rdx
movq %rax, (%rdx)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rdx)
movq %r14, 0x10(%rdx)
movq (%r15), %rdi
movq %rbx, %rsi
callq 0x1180
movq (%r15), %rsi
movl $0xa, %edi
callq 0x1100
movl $0x1, %edi
callq 0x11a0
// File: /workspace/github_cpp_makefile_star2_O1/biotomas[P]ipasir/sat/picosat961/picosat-961/picogcnf.c
// Function: msg
static void msg (const char * fmt, ...) {
  va_list ap;
  printf ("c [picogcnf] %.2f seconds: ", picosat_time_stamp ());
  va_start (ap, fmt);
  vprintf (fmt, ap);
  va_end (ap);
  fputc ('\n', stdout);
  fflush (stdout);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xd8, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %r14
movq %rsi, 0x8(%r14)
movq %rdx, 0x10(%r14)
movq %rcx, 0x18(%r14)
movq %r8, 0x20(%r14)
movq %r9, 0x28(%r14)
testb %al, %al
je 0x1ce5
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
callq 0x9022
leaq 0xe4fc(%rip), %rdi      # 0x101ed
movb $0x1, %al
callq 0x10c0
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rsp, %rsi
movq %rax, (%rsi)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rsi)
movq %r14, 0x10(%rsi)
movq %rbx, %rdi
callq 0x1140
movq 0x152b1(%rip), %rbx     # 0x16fd8
movq (%rbx), %rsi
movl $0xa, %edi
callq 0x1100
movq (%rbx), %rdi
callq 0x1130
addq $0xd8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/biotomas[P]ipasir/sat/picosat961/picosat-961/picogcnf.c
// Function: callback
static void callback (void * dummy, const int * mus) {
  int remaining;
  const int * p;
  (void) dummy;
  remaining = 0;
  for (p = mus; *p; p++) remaining++;
  assert (remaining <= ngroups);
  msg ("<%d> reduction to %d out of %d (%.0f%%)",
       ++reductions, remaining, ngroups, percent (remaining, ngroups));
}

// Assembly:
pushq %rax
cmpl $0x0, (%rsi)
je 0x1d5c
xorl %edx, %edx
cmpl $0x0, 0x4(%rsi,%rdx,4)
leaq 0x1(%rdx), %rdx
jne 0x1d4f
jmp 0x1d5e
xorl %edx, %edx
movl 0x153ac(%rip), %ecx     # 0x17110
cmpl %ecx, %edx
jg 0x1da5
movl 0x153a6(%rip), %esi     # 0x17114
incl %esi
movl %esi, 0x1539e(%rip)     # 0x17114
xorpd %xmm0, %xmm0
testl %ecx, %ecx
je 0x1d95
xorps %xmm0, %xmm0
cvtsi2sd %edx, %xmm0
cvtsi2sd %ecx, %xmm1
mulsd 0xe2a7(%rip), %xmm0     # 0x10038
divsd %xmm1, %xmm0
leaq 0xe4a5(%rip), %rdi      # 0x10241
movb $0x1, %al
popq %r8
jmp 0x1c84
leaq 0xe45d(%rip), %rdi      # 0x10209
leaq 0xe3bd(%rip), %rsi      # 0x10170
leaq 0xe464(%rip), %rcx      # 0x1021e
movl $0x45, %edx
callq 0x10d0
// File: /workspace/github_cpp_makefile_star2_O1/rcolomina[P]the_charmed_house/3rdParty/tinyxml/xmltest.cpp
// Function: XmlTest(char const*, char const*, char const*, bool)
bool XmlTest (const char* testString, const char* expected, const char* found, bool noEcho )
{
	bool pass = !strcmp( expected, found );
	if ( pass )
		printf ("[pass]");
	else
		printf ("[fail]");

	if ( noEcho )
		printf (" %s\n", testString);
	else
		printf (" %s [%s][%s]\n", testString, expected, found);

	if ( pass )
		++gPass;
	else
		++gFail;
	return pass;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x31a0
movl %eax, %ebx
testl %eax, %eax
leaq 0x534f(%rip), %rax      # 0xdcb8
leaq 0x534f(%rip), %rdi      # 0xdcbf
cmoveq %rax, %rdi
xorl %eax, %eax
callq 0x3050
testl %ebp, %ebp
je 0x8992
leaq 0x54b9(%rip), %rdi      # 0xde3f
movq %r14, %rsi
xorl %eax, %eax
callq 0x3050
jmp 0x89a9
leaq 0x532d(%rip), %rdi      # 0xdcc6
movq %r14, %rsi
movq %r12, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0x3050
testl %ebx, %ebx
sete %al
leaq 0xc87f(%rip), %rcx      # 0x15234
leaq 0xc87c(%rip), %rdx      # 0x15238
cmoveq %rcx, %rdx
incl (%rdx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/rcolomina[P]the_charmed_house/3rdParty/tinyxml/xmltest.cpp
// Function: XmlTest(char const*, int, int, bool)
bool XmlTest( const char* testString, int expected, int found, bool noEcho )
{
	bool pass = ( expected == found );
	if ( pass )
		printf ("[pass]");
	else
		printf ("[fail]");

	if ( noEcho )
		printf (" %s\n", testString);
	else
		printf (" %s [%d][%d]\n", testString, expected, found);

	if ( pass )
		++gPass;
	else
		++gFail;
	return pass;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %r15d
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
cmpl %edx, %esi
leaq 0x52d3(%rip), %rax      # 0xdcb8
leaq 0x52d3(%rip), %rdi      # 0xdcbf
cmoveq %rax, %rdi
xorl %eax, %eax
callq 0x3050
testl %r15d, %r15d
je 0x8a0f
leaq 0x543c(%rip), %rdi      # 0xde3f
movq %r14, %rsi
xorl %eax, %eax
callq 0x3050
jmp 0x8a24
leaq 0x52be(%rip), %rdi      # 0xdcd4
movq %r14, %rsi
movl %ebp, %edx
movl %ebx, %ecx
xorl %eax, %eax
callq 0x3050
cmpl %ebx, %ebp
sete %al
leaq 0xc804(%rip), %rcx      # 0x15234
leaq 0xc801(%rip), %rdx      # 0x15238
cmoveq %rcx, %rdx
incl (%rdx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/rcolomina[P]the_charmed_house/3rdParty/tinyxml/xmltest.cpp
// Function: NullLineEndings(char*)
void NullLineEndings( char* p )
{
	while( p && *p ) {
		if ( *p == '\n' || *p == '\r' ) {
			*p = 0;
			return;
		}
		++p;
	}
}

// Assembly:
testq %rdi, %rdi
je 0x8a66
movzbl (%rdi), %eax
testl %eax, %eax
je 0x8a66
cmpl $0xd, %eax
je 0x8a63
cmpl $0xa, %eax
je 0x8a63
incq %rdi
jmp 0x8a4d
movb $0x0, (%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/canzarlab[P]Trajan/src/main.cpp
// Function: MakeGraphs(int, char**)
pair<Graph*, Graph*> MakeGraphs(int argc, char** argv)
{
    if (argc == 10)
        return {new Tree(argv[1]), new Tree(argv[2])};
    else if (argc == 12)
        return {new Tree(argv[1], argv[2]), new Tree(argv[3], argv[4])};

    int s = stoi(argv[argc - 1]);
    return {MakeDAG(argv[1], argv[2], s), MakeDAG(argv[3], nullptr, s)};
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
cmpl $0xc, %edi
je 0xad55
cmpl $0xa, %edi
jne 0xad94
movl $0x80, %edi
callq 0x9330
movq %rax, %r14
movq 0x8(%rbx), %rsi
movq %rax, %rdi
callq 0x2f7d0
movl $0x80, %edi
callq 0x9330
movq %rax, %r15
movq 0x10(%rbx), %rsi
movq %rax, %rdi
callq 0x2f7d0
jmp 0xae34
movl $0x80, %edi
callq 0x9330
movq %rax, %r14
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
movq %rax, %rdi
callq 0x2f718
movl $0x80, %edi
callq 0x9330
movq %rax, %r15
movq 0x18(%rbx), %rsi
movq 0x20(%rbx), %rdx
movq %rax, %rdi
callq 0x2f718
jmp 0xae34
movslq %edi, %rax
movq -0x8(%rbx,%rax,8), %rsi
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0xd630
movq 0x10(%rsp), %r12
callq 0x9060
movq %rax, %r14
movl (%rax), %ebp
movl $0x0, (%rax)
leaq 0x30(%rsp), %r13
movq %r12, %rdi
movq %r13, %rsi
movl $0xa, %edx
callq 0x9490
cmpq %r12, (%r13)
je 0xae49
movq %rax, %r15
movslq %r15d, %rax
cmpq %r15, %rax
jne 0xae55
movl (%r14), %eax
cmpl $0x22, %eax
je 0xae55
testl %eax, %eax
jne 0xadf5
movl %ebp, (%r14)
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xae10
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x9340
movq 0x8(%rbx), %rdi
movq 0x10(%rbx), %rsi
movl %r15d, %edx
callq 0xac8c
movq %rax, %r14
movq 0x18(%rbx), %rdi
xorl %esi, %esi
movl %r15d, %edx
callq 0xac8c
movq %rax, %r15
movq %r14, %rax
movq %r15, %rdx
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x51442(%rip), %rdi     # 0x5c292
callq 0x91d0
leaq 0x51436(%rip), %rdi     # 0x5c292
callq 0x94c0
jmp 0xae63
movq %rax, %rbx
movl $0x80, %esi
movq %r15, %rdi
jmp 0xaea6
movq %rax, %rbx
jmp 0xaeab
jmp 0xae77
movq %rax, %rbx
movl $0x80, %esi
movq %r14, %rdi
jmp 0xaea6
movq %rax, %rbx
cmpl $0x0, (%r14)
jne 0xae90
movl %ebp, (%r14)
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xaeab
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x9340
movq %rbx, %rdi
callq 0x9670
// File: /workspace/github_cpp_makefile_star2_O1/canzarlab[P]Trajan/geno/augmentedLagrangian.cpp
// Function: AugmentedLagrangian::setParameter(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, double)
bool AugmentedLagrangian::setParameter(std::string parameter, Scalar value)
{
	// TODO
	// lower case parameter

	if (parameter == "pgtol")
	{
		_tol = value;
		return true;
	}

	if (parameter == "factr")
	{
		_tolFun = value;
		return true;
	}

	if (parameter == "constraintsTol")
	{
		_constraintsTol = value;
		return true;
	}
	if (parameter == "verbose")
	{
	        _verbose = value;
	        return true;
        }
	        

	return false;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movsd %xmm0, (%rsp)
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x4d5a0(%rip), %rsi     # 0x5c410
movq %r14, %rdi
callq 0x90e0
testl %eax, %eax
je 0xeeb9
leaq 0x4d593(%rip), %rsi     # 0x5c416
movq %r14, %rdi
callq 0x90e0
testl %eax, %eax
je 0xeec5
leaq 0x4d58d(%rip), %rsi     # 0x5c423
movq %r14, %rdi
callq 0x90e0
testl %eax, %eax
je 0xeed1
leaq 0x4d589(%rip), %rsi     # 0x5c432
movq %r14, %rdi
callq 0x90e0
testl %eax, %eax
je 0xeedd
xorl %eax, %eax
jmp 0xeef7
movsd (%rsp), %xmm0
movsd %xmm0, 0x50(%rbx)
jmp 0xeef5
movsd (%rsp), %xmm0
movsd %xmm0, 0x58(%rbx)
jmp 0xeef5
movsd (%rsp), %xmm0
movsd %xmm0, 0x8(%rbx)
jmp 0xeef5
xorpd %xmm0, %xmm0
movsd (%rsp), %xmm1
ucomisd %xmm0, %xmm1
setp %al
setne %cl
orb %al, %cl
movb %cl, 0x60(%rbx)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/canzarlab[P]Trajan/geno/lbfgsb.cpp
// Function: LBFGSB::boundInit()
void LBFGSB::boundInit() {
  _genoNLP.getBounds(_lb.data(), _ub.data());
  Scalar const INF = std::numeric_limits<Scalar>::infinity();
  for (int i = 0; !_constrained && i < _lb.size(); ++i)
    _constrained = (_lb[i] != -INF || _ub[i] != INF);
  for (int i = 0; _boxed && i < _x.size(); ++i)
    _boxed = (_lb[i] != -INF && _ub[i] != INF);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
movq 0x20(%rbx), %rsi
movq 0x30(%rbx), %rdx
movq (%rdi), %rax
callq *0x28(%rax)
testb $0x1, 0x258(%rbx)
jne 0x1059f
movq 0x20(%rbx), %rax
movq 0x28(%rbx), %rcx
movq 0x38(%rbx), %rdx
movq 0x30(%rbx), %rsi
xorl %edi, %edi
testq %rcx, %rcx
cmovleq %rdi, %rcx
movsd 0x4be75(%rip), %xmm0    # 0x5c3d8
movsd 0x4be45(%rip), %xmm1    # 0x5c3b0
cmpq %rdi, %rcx
je 0x1059f
movb $0x1, %r8b
ucomisd (%rax,%rdi,8), %xmm0
jb 0x10590
cmpq %rdi, %rdx
jle 0x10618
movsd (%rsi,%rdi,8), %xmm2
ucomisd %xmm1, %xmm2
setb %r8b
movb %r8b, 0x258(%rbx)
incq %rdi
testb %r8b, %r8b
je 0x1056b
testb $0x1, 0x259(%rbx)
je 0x10616
movq 0x28(%rbx), %rax
movq 0x18(%rbx), %rcx
movq 0x20(%rbx), %rdx
movq 0x38(%rbx), %rsi
movq 0x30(%rbx), %rdi
xorl %r8d, %r8d
testq %rcx, %rcx
cmovleq %r8, %rcx
testq %rax, %rax
cmovleq %r8, %rax
movsd 0x4be03(%rip), %xmm0    # 0x5c3d8
movsd 0x4bdd3(%rip), %xmm1    # 0x5c3b0
cmpq %r8, %rcx
je 0x10616
cmpq %r8, %rax
je 0x10618
ucomisd (%rdx,%r8,8), %xmm0
jae 0x10604
cmpq %r8, %rsi
jle 0x10618
movsd (%rdi,%r8,8), %xmm2
ucomisd %xmm1, %xmm2
setb %r9b
jmp 0x10607
xorl %r9d, %r9d
movb %r9b, 0x259(%rbx)
incq %r8
testb %r9b, %r9b
jne 0x105dd
popq %rbx
retq
leaq 0x4cc06(%rip), %rdi     # 0x5d225
leaq 0x4cc1c(%rip), %rsi     # 0x5d242
leaq 0x4d6a2(%rip), %rcx     # 0x5dccf
movl $0x198, %edx            # imm = 0x198
callq 0x9200
nop
// File: /workspace/github_cpp_makefile_star2_O1/canzarlab[P]Trajan/geno/lbfgsb.cpp
// Function: LBFGSB::initFeasible()
bool LBFGSB::initFeasible() {
  for (Index i = 0; i < _x.size(); ++i) {
    if (_lb[i] > _ub[i])
      return false;    // infeasible
    if (_lb[i] > _x[i])
      _x[i] = _lb[i];
    if (_ub[i] < _x[i])
      _x[i] = _ub[i];
  }
  return true;
}

// Assembly:
pushq %rax
movq 0x18(%rdi), %rcx
testq %rcx, %rcx
setle %al
jle 0x18639
movq 0x10(%rdi), %rdx
movq 0x20(%rdi), %rsi
movq 0x38(%rdi), %r8
movq 0x30(%rdi), %r9
xorl %r10d, %r10d
testq %r8, %r8
cmovleq %r10, %r8
cmpq %r10, 0x28(%rdi)
jle 0x1863d
cmpq %r10, %r8
je 0x1863d
movsd (%rsi,%r10,8), %xmm0
ucomisd (%r9,%r10,8), %xmm0
ja 0x18639
ucomisd (%rdx,%r10,8), %xmm0
jbe 0x18616
movsd %xmm0, (%rdx,%r10,8)
movsd (%r9,%r10,8), %xmm0
movsd (%rdx,%r10,8), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x1862e
movsd %xmm0, (%rdx,%r10,8)
incq %r10
cmpq %rcx, %r10
setge %al
jne 0x185ef
andb $0x1, %al
popq %rcx
retq
leaq 0x44be1(%rip), %rdi     # 0x5d225
leaq 0x44bf7(%rip), %rsi     # 0x5d242
leaq 0x4567d(%rip), %rcx     # 0x5dccf
movl $0x198, %edx            # imm = 0x198
callq 0x9200
// File: /workspace/github_cpp_makefile_star2_O1/canzarlab[P]Trajan/geno/lbfgsb.cpp
// Function: LBFGSB::setParameter(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, double)
bool LBFGSB::setParameter(std::string parameter, Scalar value)
{
  // TODO
  // lower case parameter

  if (parameter == "pgtol")
  {
    _tol = value;
    return true;
  }

  if (parameter == "factr")
  {
    _tolFun = value * std::numeric_limits<Scalar>::epsilon();
    return true;
  }

  return false;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movsd %xmm0, (%rsp)
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x42d08(%rip), %rsi     # 0x5c410
movq %r14, %rdi
callq 0x90e0
testl %eax, %eax
je 0x1972b
leaq 0x42cfb(%rip), %rsi     # 0x5c416
movq %r14, %rdi
callq 0x90e0
testl %eax, %eax
je 0x19737
xorl %eax, %eax
jmp 0x19750
movl $0x68, %eax
movsd (%rsp), %xmm0
jmp 0x19749
movsd (%rsp), %xmm0
mulsd 0x441ac(%rip), %xmm0    # 0x5d8f0
movl $0x70, %eax
movsd %xmm0, (%rbx,%rax)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/canzarlab[P]Trajan/./Eigen/src/Core/PlainObjectBase.h
// Function: void Eigen::PlainObjectBase<Eigen::Matrix<double, -1, -1, 0, -1, -1>>::resizeLike<Eigen::Product<Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0>>(Eigen::EigenBase<Eigen::Product<Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<double, -1, -1, 0, -1, -1>, 0>> const&)
EIGEN_DEVICE_FUNC 
    EIGEN_STRONG_INLINE void resizeLike(const EigenBase<OtherDerived>& _other)
    {
      const OtherDerived& other = _other.derived();
      internal::check_rows_cols_for_overflow<MaxSizeAtCompileTime>::run(other.rows(), other.cols());
      const Index othersize = other.rows()*other.cols();
      if(RowsAtCompileTime == 1)
      {
        eigen_assert(other.rows() == 1 || other.cols() == 1);
        resize(1, othersize);
      }
      else if(ColsAtCompileTime == 1)
      {
        eigen_assert(other.rows() == 1 || other.cols() == 1);
        resize(othersize, 1);
      }
      else resize(other.rows(), other.cols());
    }

// Assembly:
pushq %rax
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
movq 0x8(%rax), %r8
movq 0x10(%rcx), %rcx
testq %r8, %r8
sete %al
testq %rcx, %rcx
sete %sil
orb %al, %sil
jne 0x1e4a6
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
xorl %edx, %edx
idivq %rcx
cmpq %r8, %rax
jl 0x1e4f6
movq %rcx, %rax
orq %r8, %rax
js 0x1e4d7
testb %sil, %sil
jne 0x1e4c7
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
xorl %edx, %edx
idivq %rcx
cmpq %r8, %rax
jl 0x1e4f6
movq %rcx, %rsi
imulq %r8, %rsi
movq %r8, %rdx
popq %rax
jmp 0x2d684
leaq 0x3e97a(%rip), %rdi     # 0x5ce58
leaq 0x3e7d2(%rip), %rsi     # 0x5ccb7
leaq 0x509e0(%rip), %rcx     # 0x6eecc
movl $0x11d, %edx            # imm = 0x11D
callq 0x9200
movl $0x8, %edi
callq 0x9180
movq 0x69aa9(%rip), %rcx     # 0x87fb0
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x69ab3(%rip), %rsi     # 0x87fc8
movq 0x69a74(%rip), %rdx     # 0x87f90
movq %rax, %rdi
callq 0x9630
// File: /workspace/github_cpp_makefile_star2_O1/canzarlab[P]Trajan/./Eigen/src/LU/FullPivLU.h
// Function: Eigen::FullPivLU<Eigen::Matrix<double, -1, -1, 0, -1, -1>>::threshold() const
RealScalar threshold() const
    {
      eigen_assert(m_isInitialized || m_usePrescribedThreshold);
      return m_usePrescribedThreshold ? m_prescribedThreshold
      // this formula comes from experimenting (see "LU precision tuning" thread on the list)
      // and turns out to be identical to Higham's formula used already in LDLt.
                                      : NumTraits<Scalar>::epsilon() * m_lu.diagonalSize();
    }

// Assembly:
cmpb $0x0, 0x79(%rdi)
jne 0x215f4
cmpb $0x0, 0x7a(%rdi)
je 0x2161d
cmpb $0x1, 0x7a(%rdi)
jne 0x21600
movsd 0x70(%rdi), %xmm0
retq
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rcx
cmpq %rax, %rcx
cmovlq %rcx, %rax
cvtsi2sd %rax, %xmm0
mulsd 0x3c2d4(%rip), %xmm0    # 0x5d8f0
retq
pushq %rax
leaq 0x41432(%rip), %rdi     # 0x62a57
leaq 0x3ffc1(%rip), %rsi     # 0x615ed
leaq 0x41450(%rip), %rcx     # 0x62a83
movl $0x13f, %edx            # imm = 0x13F
callq 0x9200
nop
// File: /workspace/github_cpp_makefile_star2_O1/canzarlab[P]Trajan/./Eigen/src/Core/products/GeneralMatrixMatrix.h
// Function: void Eigen::internal::generic_product_impl<Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Transpose<Eigen::Matrix<double, -1, -1, 0, -1, -1>>, Eigen::DenseShape, Eigen::DenseShape, 8>::addTo<Eigen::Matrix<double, -1, -1, 0, -1, -1>>(Eigen::Matrix<double, -1, -1, 0, -1, -1>&, Eigen::Matrix<double, -1, -1, 0, -1, -1> const&, Eigen::Transpose<Eigen::Matrix<double, -1, -1, 0, -1, -1>> const&)
static void addTo(Dst& dst, const Lhs& lhs, const Rhs& rhs)
  {
    if((rhs.rows()+dst.rows()+dst.cols())<20 && rhs.rows()>0)
      lazyproduct::addTo(dst, lhs, rhs);
    else
      scaleAndAddTo(dst,lhs, rhs, Scalar(1));
  }

// Assembly:
pushq %rbx
subq $0x80, %rsp
movq %rdi, %rbx
movq (%rdx), %rax
movq 0x10(%rax), %rax
testq %rax, %rax
jle 0x29f04
addq 0x8(%rbx), %rax
addq 0x10(%rbx), %rax
cmpq $0x13, %rax
jg 0x29f04
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x2a0a4
movq %rax, 0x10(%rsp)
movq %rdx, 0x18(%rsp)
movq (%rax), %rcx
movq %rcx, 0x20(%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x28(%rsp)
movq (%rdx), %rsi
movq %rsi, 0x38(%rsp)
movq 0x8(%rdx), %rsi
movq %rsi, 0x40(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x48(%rsp)
movq 0x8(%rbx), %rax
cmpq %rcx, %rax
jne 0x29f27
movq 0x10(%rbx), %rcx
cmpq 0x8(%rdx), %rcx
jne 0x29f27
movq (%rbx), %rcx
leaq 0x50(%rsp), %rdx
movq %rcx, (%rdx)
movq %rax, 0x8(%rdx)
leaq 0x60(%rsp), %rdi
movq %rdx, (%rdi)
leaq 0x10(%rsp), %rax
movq %rax, 0x8(%rdi)
leaq 0xf(%rsp), %rax
movq %rax, 0x10(%rdi)
movq %rbx, 0x18(%rdi)
callq 0x2a0d8
jmp 0x29f1e
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
leaq 0x10(%rsp), %rcx
movq %rax, (%rcx)
movq %rbx, %rdi
callq 0x29f46
addq $0x80, %rsp
popq %rbx
retq
leaq 0x37de9(%rip), %rdi     # 0x61d17
leaq 0x325e4(%rip), %rsi     # 0x5c519
leaq 0x3d19e(%rip), %rcx     # 0x670da
movl $0x2c6, %edx            # imm = 0x2C6
callq 0x9200
// File: /workspace/github_cpp_makefile_star2_O1/canzarlab[P]Trajan/./Eigen/src/Core/AssignEvaluator.h
// Function: Eigen::internal::Assignment<Eigen::Matrix<double, -1, 1, 0, -1, 1>, Eigen::CwiseBinaryOp<Eigen::internal::scalar_product_op<double, double>, Eigen::CwiseNullaryOp<Eigen::internal::scalar_constant_op<double>, Eigen::Matrix<double, -1, 1, 0, -1, 1> const> const, Eigen::Transpose<Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 1, -1, false>> const>, Eigen::internal::assign_op<double, double>, Eigen::internal::Dense2Dense, void>::run(Eigen::Matrix<double, -1, 1, 0, -1, 1>&, Eigen::CwiseBinaryOp<Eigen::internal::scalar_product_op<double, double>, Eigen::CwiseNullaryOp<Eigen::internal::scalar_constant_op<double>, Eigen::Matrix<double, -1, 1, 0, -1, 1> const> const, Eigen::Transpose<Eigen::Block<Eigen::Matrix<double, -1, -1, 0, -1, -1>, 1, -1, false>> const> const&, Eigen::internal::assign_op<double, double> const&)
void run(Kernel &kernel)
  {
    typedef typename Kernel::DstEvaluatorType::XprType DstXprType;
    typedef typename Kernel::PacketType PacketType;

    enum { size = DstXprType::InnerSizeAtCompileTime,
           packetSize =unpacket_traits<PacketType>::size,
           vectorizableSize = (size/packetSize)*packetSize };

    for(Index outer = 0; outer < kernel.outerSize(); ++outer)
    {
      copy_using_evaluator_innervec_InnerUnrolling<Kernel, 0, vectorizableSize, 0, 0>::run(kernel, outer);
      copy_using_evaluator_DefaultTraversal_InnerUnrolling<Kernel, vectorizableSize, size>::run(kernel, outer);
    }
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq (%rdi), %rax
testq %rax, %rax
setne %cl
movq 0x20(%rsi), %r15
cmpq %rax, %r15
sete %al
andb %cl, %al
cmpb $0x1, %al
je 0x2aa3a
cmpq $0x1, 0x50(%rsi)
jne 0x2aa59
movq %rdi, %rbx
movsd 0x18(%rsi), %xmm1
movq 0x38(%rsi), %rax
movq 0x8(%rax), %r12
movq 0x30(%rsi), %r14
cmpq %r14, 0x8(%rdi)
je 0x2a9fe
movsd %xmm1, (%rsp)
testq %r14, %r14
js 0x2aa97
movl $0x1, %ecx
movq %rbx, %rdi
movq %r14, %rsi
movq %r14, %rdx
callq 0x10056
movsd (%rsp), %xmm1
movq 0x8(%rbx), %rax
cmpq %r14, %rax
jne 0x2aa78
testq %rax, %rax
jle 0x2aa2e
movq (%rbx), %rcx
shlq $0x3, %r12
xorl %edx, %edx
movsd (%r15), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, (%rcx,%rdx,8)
incq %rdx
addq %r12, %r15
cmpq %rdx, %rax
jne 0x2aa15
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x34286(%rip), %rdi     # 0x5ecc7
leaq 0x34392(%rip), %rsi     # 0x5edda
leaq 0x3ce09(%rip), %rcx     # 0x67858
movl $0x17a, %edx            # imm = 0x17A
callq 0x9200
leaq 0x332f6(%rip), %rdi     # 0x5dd56
leaq 0x332fd(%rip), %rsi     # 0x5dd64
leaq 0x33a87(%rip), %rcx     # 0x5e4f5
movl $0x6e, %edx
callq 0x9200
leaq 0x325e1(%rip), %rdi     # 0x5d060
leaq 0x31a93(%rip), %rsi     # 0x5c519
leaq 0x3d099(%rip), %rcx     # 0x67b26
movl $0x2d1, %edx            # imm = 0x2D1
callq 0x9200
leaq 0x323ba(%rip), %rdi     # 0x5ce58
leaq 0x32212(%rip), %rsi     # 0x5ccb7
leaq 0x3253b(%rip), %rcx     # 0x5cfe7
movl $0x11d, %edx            # imm = 0x11D
callq 0x9200
// File: /workspace/github_cpp_makefile_star2_O1/canzarlab[P]Trajan/src/Graph.cpp
// Function: Graph::Init(newick_node*)
void Graph::Init(newick_node* node)
{
    if (!node->child)
    {
        L.push_back(node);
        Leaf(node);
    }

    node->taxoni = _n++;
    for (newick_child* child = node->child; child; child = child->next)
    {
        newick_node* cnode = child->node;
        newick_parent** parentptr = &cnode->parent;
        if (!cnode->parent)
            Init(cnode);

        while (*parentptr) parentptr = &(*parentptr)->next;
        *parentptr = new newick_parent(node);
        Child(node, child->node);
    }
    clade[node].sort();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsi, (%rsp)
cmpq $0x0, (%rsi)
jne 0x2e84d
movq 0x10(%rbx), %rax
cmpq 0x18(%rbx), %rax
je 0x2e831
movq %rsi, (%rax)
addq $0x8, 0x10(%rbx)
jmp 0x2e840
leaq 0x8(%rbx), %rdi
movq %rsp, %rdx
movq %rax, %rsi
callq 0x3177a
movq (%rsp), %rsi
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
movq 0x70(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x70(%rbx)
movq (%rsp), %rcx
movl %eax, 0x28(%rcx)
movq (%rcx), %r15
testq %r15, %r15
je 0x2e8c3
movq (%r15), %r14
cmpq $0x0, 0x30(%r14)
jne 0x2e87d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2e808
addq $0x30, %r14
movq %r14, %r12
movq (%r14), %rax
leaq 0x8(%rax), %r14
testq %rax, %rax
jne 0x2e881
movl $0x10, %edi
callq 0x9330
movq %rax, %r14
movq (%rsp), %rsi
movq %rax, %rdi
callq 0x3d160
movq %r14, (%r12)
movq (%rsp), %rsi
movq (%r15), %rdx
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x20(%rax)
movq 0x8(%r15), %r15
jmp 0x2e863
addq $0x20, %rbx
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x302c6
movq %rax, %rdi
callq 0x3032c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movl $0x10, %esi
movq %r14, %rdi
callq 0x9340
movq %rbx, %rdi
callq 0x9670
// File: /workspace/github_cpp_makefile_star2_O1/canzarlab[P]Trajan/src/Graph.cpp
// Function: Graph::TransitiveClosure()
void Graph::TransitiveClosure()
{
    D.resize(_n, vb(_n));
    vvb C(_n, vb(_n));
    for (newick_node* leaf : L)
        TransitiveClosure(leaf, leaf, C);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq 0x70(%rdi), %r14
leaq 0x30(%rsp), %rdx
movb $0x0, (%rdx)
leaq 0x8(%rsp), %rdi
leaq 0x6(%rsp), %rcx
movq %r14, %rsi
callq 0x311d8
leaq 0x50(%rbx), %rdi
leaq 0x8(%rsp), %rdx
movq %r14, %rsi
callq 0x30284
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x2ebf5
movq 0x28(%rsp), %rsi
subq %rdi, %rsi
callq 0x9340
xorl %eax, %eax
movq %rax, 0x8(%rsp)
movl %eax, 0x10(%rsp)
movq %rax, 0x18(%rsp)
movl %eax, 0x20(%rsp)
movq %rax, 0x28(%rsp)
movq 0x70(%rbx), %r14
leaq 0x6(%rsp), %rdx
movb $0x0, (%rdx)
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rcx
movq %r14, %rsi
callq 0x311d8
leaq 0x30(%rsp), %rdi
leaq 0x8(%rsp), %rdx
leaq 0x6(%rsp), %rcx
movq %r14, %rsi
callq 0x301c0
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x2ec5a
movq 0x28(%rsp), %rsi
subq %rdi, %rsi
callq 0x9340
xorl %eax, %eax
movq %rax, 0x8(%rsp)
movl %eax, 0x10(%rsp)
movq %rax, 0x18(%rsp)
movl %eax, 0x20(%rsp)
movq %rax, 0x28(%rsp)
movq 0x8(%rbx), %r15
movq 0x10(%rbx), %r12
cmpq %r12, %r15
je 0x2ec86
leaq 0x30(%rsp), %r14
movq (%r15), %rdx
movq %rbx, %rdi
movq %rdx, %rsi
movq %r14, %rcx
callq 0x2f56e
addq $0x8, %r15
cmpq %r12, %r15
jne 0x2ec6c
leaq 0x30(%rsp), %rdi
callq 0xd968
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rsi
testq %rsi, %rsi
je 0x2ece2
leaq 0x8(%rsp), %rdi
callq 0x9780
jmp 0x2ece2
jmp 0x2ecd0
movq %rax, %rbx
movq 0x8(%rsp), %rsi
testq %rsi, %rsi
je 0x2ece2
leaq 0x8(%rsp), %rdi
callq 0x9752
jmp 0x2ece2
movq %rax, %rbx
jmp 0x2ece2
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0xd968
movq %rbx, %rdi
callq 0x9670
// File: /workspace/github_cpp_makefile_star2_O1/canzarlab[P]Trajan/src/Graph.cpp
// Function: LDAG::TransitiveReduction(newick_node*, std::vector<bool, std::allocator<bool>>&)
void LDAG::TransitiveReduction(newick_node* node, vb& C)
{
    if (C[node->taxoni])
        return;

    C[node->taxoni] = true;
    for (newick_child* child = node->child; child; child = child->next)
    {
        TransitiveReduction(child->node, C);
        for (newick_child* cchild = child->node->child; cchild; cchild = cchild->next)
        {
            vb CC(_n);
            TransitiveReduction(node, cchild->node, CC);
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movslq 0x28(%rsi), %rcx
leaq 0x3f(%rcx), %rax
testq %rcx, %rcx
cmovnsq %rcx, %rax
sarq $0x6, %rax
shlq $0x3, %rax
movq %rdx, 0x10(%rsp)
addq (%rdx), %rax
movabsq $-0x8000000000000000, %rsi # imm = 0x8000000000000000
leaq 0x3f(%rsi), %r8
andq %rcx, %r8
xorl %edx, %edx
cmpq %rsi, %r8
setbe %dl
movl $0x1, %esi
shlq %cl, %rsi
movq %rdi, %r15
movq -0x8(%rax,%rdx,8), %rdi
btq %rcx, %rdi
jb 0x2f331
leaq -0x8(,%rdx,8), %rcx
orq %rdi, %rsi
movq %rsi, (%rax,%rcx)
movq (%r14), %r13
testq %r13, %r13
je 0x2f331
leaq 0x20(%rsp), %r12
leaq 0xf(%rsp), %rbp
xorl %ebx, %ebx
movq (%r13), %rsi
movq %r15, %rdi
movq 0x10(%rsp), %rdx
callq 0x2f214
movq %r13, 0x18(%rsp)
movq (%r13), %rax
movq (%rax), %r13
testq %r13, %r13
je 0x2f31f
movq 0x70(%r15), %rsi
movb $0x0, 0xe(%rsp)
movq %r12, %rdi
leaq 0xe(%rsp), %rdx
movq %rbp, %rcx
callq 0x311d8
movq (%r13), %rdx
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rcx
callq 0x2f43a
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x2f319
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x9340
movq %rbx, 0x20(%rsp)
movl %ebx, 0x28(%rsp)
movq %rbx, 0x30(%rsp)
movl %ebx, 0x38(%rsp)
movq %rbx, 0x40(%rsp)
movq 0x8(%r13), %r13
jmp 0x2f2bb
movq 0x18(%rsp), %r13
movq 0x8(%r13), %r13
testq %r13, %r13
jne 0x2f29e
addq $0x48, %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/Graph.cpp
// Function: LDAG::Wipe(newick_node*)
void LDAG::Wipe(newick_node* node)
{
    node->taxoni = -1;
    for (newick_child* child = node->child; child; child = child->next)
        if (child->node->taxoni != -1)
            Wipe(child->node);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl $0xffffffff, 0x28(%rsi) # imm = 0xFFFFFFFF
movq (%rsi), %r14
testq %r14, %r14
je 0x2f370
movq %rdi, %rbx
movq (%r14), %rsi
cmpl $-0x1, 0x28(%rsi)
je 0x2f367
movq %rbx, %rdi
callq 0x2f340
movq 0x8(%r14), %r14
testq %r14, %r14
jne 0x2f356
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/canzarlab[P]Trajan/src/Graph.cpp
// Function: LDAG::Renumerate(newick_node*)
void LDAG::Renumerate(newick_node* node)
{
    node->taxoni = _n++;
    for (newick_child* child = node->child; child; child = child->next)
        if (child->node->taxoni == -1)
            Renumerate(child->node);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x70(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x70(%rdi)
movl %eax, 0x28(%rsi)
movq (%rsi), %r14
testq %r14, %r14
je 0x2f3b0
movq %rdi, %rbx
movq (%r14), %rsi
cmpl $-0x1, 0x28(%rsi)
jne 0x2f3a7
movq %rbx, %rdi
callq 0x2f378
movq 0x8(%r14), %r14
testq %r14, %r14
jne 0x2f396
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/canzarlab[P]Trajan/src/Graph.cpp
// Function: LDAG::GenPaths(newick_node*, std::vector<newick_node*, std::allocator<newick_node*>>&)
void LDAG::GenPaths(newick_node* node, vn& T)
{
    T.push_back(node);
    if (!node->child)
        P.push_back(T);
    for (newick_child* child = node->child; child; child = child->next)
        GenPaths(child->node, T);
    T.pop_back();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %rax
movq %rdi, %r14
movq %rsi, 0x8(%rsp)
movq 0x8(%rdx), %rsi
cmpq 0x10(%rdx), %rsi
je 0x2f3e3
movq %rax, (%rsi)
addq $0x8, 0x8(%rbx)
jmp 0x2f3f0
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x3177a
movq 0x8(%rsp), %rax
cmpq $0x0, (%rax)
jne 0x2f40a
leaq 0xf0(%r14), %rdi
movq %rbx, %rsi
callq 0x30258
movq 0x8(%rsp), %rax
movq (%rax), %r15
testq %r15, %r15
je 0x2f42b
movq (%r15), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x2f3b8
movq 0x8(%r15), %r15
jmp 0x2f412
addq $-0x8, 0x8(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/canzarlab[P]Trajan/src/Graph.cpp
// Function: LDAG::TransitiveReduction(newick_node*, newick_node*, std::vector<bool, std::allocator<bool>>&)
void LDAG::TransitiveReduction(newick_node* parent, newick_node* node, vb& C)
{
    C[node->taxoni] = true;
    Reduce(&parent->child, node);
    Reduce(&node->parent, parent);
    for (newick_child* child = node->child; child; child = child->next)
        if (!C[child->node->taxoni])
            TransitiveReduction(parent, child->node, C);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movslq 0x28(%rdx), %rcx
leaq 0x3f(%rcx), %rax
testq %rcx, %rcx
cmovnsq %rcx, %rax
sarq $0x6, %rax
shlq $0x3, %rax
addq (%rbx), %rax
movabsq $-0x8000000000000000, %r12 # imm = 0x8000000000000000
leaq 0x3f(%r12), %r8
andq %rcx, %r8
xorl %r9d, %r9d
cmpq %r12, %r8
setbe %r9b
movl $0x1, %r8d
shlq %cl, %r8
orq %r8, -0x8(%rax,%r9,8)
movq %rsi, %r14
movq %rdi, %r15
movq (%rsi), %rcx
testq %rcx, %rcx
je 0x2f4b9
movq %r14, %rax
leaq 0x8(%rcx), %rsi
cmpq %rdx, (%rcx)
je 0x2f4ab
movq %rsi, %rax
jmp 0x2f4b1
movq (%rsi), %rcx
movq %rcx, (%rax)
movq (%rax), %rcx
testq %rcx, %rcx
jne 0x2f49d
movq 0x30(%rdx), %rcx
testq %rcx, %rcx
je 0x2f4e2
leaq 0x30(%rdx), %rax
leaq 0x8(%rcx), %rsi
cmpq %r14, (%rcx)
je 0x2f4d4
movq %rsi, %rax
jmp 0x2f4da
movq (%rsi), %rcx
movq %rcx, (%rax)
movq (%rax), %rcx
testq %rcx, %rcx
jne 0x2f4c6
movq (%rdx), %r13
testq %r13, %r13
je 0x2f53e
leaq 0x3f(%r12), %rbp
movq (%r13), %rdx
movslq 0x28(%rdx), %rax
leaq 0x3f(%rax), %rcx
testq %rax, %rax
cmovnsq %rax, %rcx
sarq $0x6, %rcx
shlq $0x3, %rcx
addq (%rbx), %rcx
movq %rax, %rsi
andq %rbp, %rsi
xorl %edi, %edi
cmpq %r12, %rsi
setbe %dil
movq -0x8(%rcx,%rdi,8), %rcx
btq %rax, %rcx
jb 0x2f535
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rcx
callq 0x2f43a
movq 0x8(%r13), %r13
testq %r13, %r13
jne 0x2f4ef
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/canzarlab[P]Trajan/src/Graph.cpp
// Function: LDAG::Reduce(newick_child**, newick_node*)
void LDAG::Reduce(newick_child** childptr, newick_node* node)
{
    while (*childptr)
    {
        if ((*childptr)->node == node)
            *childptr = (*childptr)->next;
        else childptr = &(*childptr)->next;
    }
}

// Assembly:
movq (%rsi), %rax
testq %rax, %rax
je 0x2f56c
leaq 0x8(%rax), %rcx
cmpq %rdx, (%rax)
je 0x2f564
movq %rcx, %rsi
jmp 0x2f54e
movq (%rcx), %rax
movq %rax, (%rsi)
jmp 0x2f54e
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/canzarlab[P]Trajan/src/Graph.cpp
// Function: Graph::TransitiveClosure(newick_node*, newick_node*, std::vector<std::vector<bool, std::allocator<bool>>, std::allocator<std::vector<bool, std::allocator<bool>>>>&)
void Graph::TransitiveClosure(newick_node* node, newick_node* rnode, vvb& C)
{
    int l = rnode->taxoni;
    int i = node->taxoni;
    if (l != i)
    {
        D[l][i] = true;
        Relation(l, i);
    }

    C[i][l] = true;
    for (newick_parent* parent = node->parent; parent; parent = parent->next)
    {
        newick_node* pn = parent->node;
        int pnt = pn->taxoni;
        if (!C[pnt][l])
            TransitiveClosure(pn, rnode, C);
        if (!C[pnt][pnt])
            TransitiveClosure(pn, pn, C);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movq %rsi, %r14
movq %rdi, (%rsp)
movabsq $-0x8000000000000000, %r8 # imm = 0x8000000000000000
movq %rdx, 0x8(%rsp)
movslq 0x28(%rdx), %r12
movslq 0x28(%rsi), %rbp
cmpl %ebp, %r12d
je 0x2f5f9
movq (%rsp), %rdi
movq 0x50(%rdi), %rax
leaq (%r12,%r12,4), %rcx
leaq 0x3f(%rbp), %rdx
testq %rbp, %rbp
cmovnsq %rbp, %rdx
sarq $0x6, %rdx
shlq $0x3, %rdx
addq (%rax,%rcx,8), %rdx
leaq 0x3f(%r8), %rax
andq %rbp, %rax
xorl %esi, %esi
cmpq %r8, %rax
setbe %sil
movl $0x1, %eax
movl %ebp, %ecx
shlq %cl, %rax
orq %rax, -0x8(%rdx,%rsi,8)
movq (%rdi), %rax
movl %r12d, %esi
movl %ebp, %edx
callq *0x28(%rax)
movabsq $-0x8000000000000000, %r8 # imm = 0x8000000000000000
movq (%rbx), %rax
leaq (,%rbp,4), %rcx
addq %rbp, %rcx
leaq 0x3f(%r12), %rsi
testq %r12, %r12
cmovnsq %r12, %rsi
sarq $0x6, %rsi
shlq $0x3, %rsi
movq (%rax,%rcx,8), %rdx
movq %rsi, 0x20(%rsp)
addq %rsi, %rdx
leaq 0x3f(%r8), %rax
movq %r12, %rcx
movq %rax, 0x18(%rsp)
andq %rax, %rcx
xorl %eax, %eax
cmpq %r8, %rcx
setbe %al
movl $0x1, %r13d
movl %r12d, %ecx
shlq %cl, %r13
orq %r13, -0x8(%rdx,%rax,8)
movq 0x30(%r14), %r15
testq %r15, %r15
je 0x2f708
leaq -0x8(,%rax,8), %rax
movq %rax, 0x10(%rsp)
movq (%r15), %r12
movslq 0x28(%r12), %r14
movq (%rbx), %rax
leaq (%r14,%r14,4), %rbp
movq (%rax,%rbp,8), %rax
addq 0x20(%rsp), %rax
movq 0x10(%rsp), %rcx
testq %r13, (%rcx,%rax)
jne 0x2f6aa
movq (%rsp), %rdi
movq %r12, %rsi
movq 0x8(%rsp), %rdx
movq %rbx, %rcx
callq 0x2f56e
movabsq $-0x8000000000000000, %r8 # imm = 0x8000000000000000
movq (%rbx), %rax
leaq 0x3f(%r14), %rcx
testq %r14, %r14
cmovnsq %r14, %rcx
sarq $0x6, %rcx
shlq $0x3, %rcx
addq (%rax,%rbp,8), %rcx
movq %r14, %rax
andq 0x18(%rsp), %rax
xorl %edx, %edx
cmpq %r8, %rax
setbe %dl
movq -0x8(%rcx,%rdx,8), %rax
btq %r14, %rax
jb 0x2f6fb
movq (%rsp), %rdi
movq %r12, %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x2f56e
movabsq $-0x8000000000000000, %r8 # imm = 0x8000000000000000
movq 0x8(%r15), %r15
testq %r15, %r15
jne 0x2f669
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/canzarlab[P]Trajan/src/Graph.cpp
// Function: LDAG::Relation(int, int)
void LDAG::Relation(int l, int i)
{
    for (int j = 0; j < NR_THREADS; ++j)
        R[j][l][i + _n] = INF;
    G[l].push_back(i + _n);
    G[i + _n].push_back(l);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %esi, (%rsp)
movslq %esi, %rcx
movslq %edx, %r14
movq 0x70(%rdi), %rax
xorl %esi, %esi
leaq (%rcx,%rcx,2), %rcx
shlq $0x3, %rax
movabsq $0x7ff0000000000000, %rdi # imm = 0x7FF0000000000000
movq 0x90(%rbx,%rsi), %r8
movq (%r8,%rcx,8), %r8
addq %rax, %r8
movq %rdi, (%r8,%r14,8)
addq $0x18, %rsi
cmpq $0x60, %rsi
jne 0x2f8fa
movq 0x78(%rbx), %rax
leaq (%rax,%rcx,8), %rdi
addl 0x70(%rbx), %edx
movl %edx, 0x4(%rsp)
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x2f93c
movl %edx, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rdi)
jmp 0x2f946
leaq 0x4(%rsp), %rdx
callq 0x310fc
movq 0x70(%rbx), %rax
leaq (%rax,%rax,2), %rax
shlq $0x3, %rax
addq 0x78(%rbx), %rax
leaq (%r14,%r14,2), %rcx
leaq (%rax,%rcx,8), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x2f977
movl (%rsp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rdi)
jmp 0x2f97f
movq %rsp, %rdx
callq 0x30fdc
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/canzarlab[P]Trajan/src/Solver.h
// Function: void Solver::DFSLeft<Greedy::Greedy(Graph&, Graph&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, double, bool)::$_0>(newick_node*, std::vector<bool, std::allocator<bool>>&, Greedy::Greedy(Graph&, Graph&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, double, bool)::$_0)
void Solver::DFSLeft(newick_node* node, vb& P, F f)
{
    P[node->taxoni] = true;
    {
        vb Q(t2.GetNumNodes());
        DFSRight(node, t2.GetRoot(), Q, f);
    }
    for (newick_child* child = node->child; child; child = child->next)
        if (!P[child->node->taxoni])
            DFSLeft(child->node, P, f);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r13
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, %rbp # imm = 0x8000000000000000
leaq 0x3f(%rbp), %rdx
andq %rcx, %rdx
xorl %esi, %esi
cmpq %rbp, %rdx
setbe %sil
movl $0x1, %edx
shlq %cl, %rdx
movq %rdi, %r12
orq %rdx, -0x8(%rax,%rsi,8)
movq 0x38(%rdi), %rax
movslq 0x70(%rax), %rsi
leaq 0x7(%rsp), %rdx
movb $0x0, (%rdx)
leaq 0x8(%rsp), %rdi
leaq 0x6(%rsp), %rcx
callq 0x311d8
movq 0x38(%r12), %rax
movq 0x68(%rax), %rdx
movq %r12, %rdi
movq %r13, %rsi
leaq 0x8(%rsp), %rcx
movq %r14, 0x30(%rsp)
movq %r14, %r8
movq %rbx, %r14
movq %rbx, %r9
callq 0x32df6
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x32456
movq 0x28(%rsp), %rsi
subq %rdi, %rsi
callq 0x9340
xorl %eax, %eax
movq %rax, 0x8(%rsp)
movl %eax, 0x10(%rsp)
movq %rax, 0x18(%rsp)
movl %eax, 0x20(%rsp)
movq %rax, 0x28(%rsp)
movq (%r13), %r13
testq %r13, %r13
je 0x324b7
leaq 0x3f(%rbp), %rbx
movq (%r13), %rsi
movslq 0x28(%rsi), %rax
leaq 0x3f(%rax), %rcx
testq %rax, %rax
cmovnsq %rax, %rcx
sarq $0x6, %rcx
shlq $0x3, %rcx
addq (%r15), %rcx
movq %rax, %rdx
andq %rbx, %rdx
xorl %edi, %edi
cmpq %rbp, %rdx
setbe %dil
movq -0x8(%rcx,%rdi,8), %rcx
btq %rax, %rcx
jb 0x324ae
movq %r12, %rdi
movq %r15, %rdx
movq 0x30(%rsp), %rcx
movq %r14, %r8
callq 0x32382
movq 0x8(%r13), %r13
testq %r13, %r13
jne 0x32463
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rsi
testq %rsi, %rsi
je 0x324dd
leaq 0x8(%rsp), %rdi
callq 0x98b8
movq %rbx, %rdi
callq 0x9670
nop
// File: /workspace/github_cpp_makefile_star2_O1/canzarlab[P]Trajan/src/Greedy.cpp
// Function: Greedy::Solve(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Greedy::Solve(string filename, string outScoreFile)
{
    for (const iid& e : E)
        if (all_of(M.begin(), M.end(), bind(&Greedy::CC, this, _1, cref(e))))
            M.push_back(e), A[get<0>(e)][get<1>(e)] = get<2>(e);
    if (filename != "") WriteSolution(filename);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, 0x8(%rsp)
movq %rdi, %rbx
movq 0xa0(%rdi), %r15
movq 0xa8(%rdi), %r14
cmpq %r14, %r15
je 0x329dc
leaq 0xb8(%rbx), %rax
movq %rax, 0x10(%rsp)
leaq 0x38(%rsp), %r13
movq %r15, %r12
movq 0xb8(%rbx), %rdi
movq 0xc0(%rbx), %rbp
leaq 0x114(%rip), %rax       # 0x32a68
movq %rax, 0x38(%rsp)
movq $0x0, 0x40(%rsp)
movq %r12, 0x48(%rsp)
movq %rbx, 0x50(%rsp)
movq %rbp, %rsi
movq %r13, %rdx
callq 0x33f8b
cmpq %rbp, %rax
jne 0x329cb
movq 0xc0(%rbx), %rsi
cmpq 0xc8(%rbx), %rsi
je 0x3299d
movups (%r15), %xmm0
movups %xmm0, (%rsi)
addq $0x10, 0xc0(%rbx)
jmp 0x329aa
movq 0x10(%rsp), %rdi
movq %r15, %rdx
callq 0x34118
movsd (%r15), %xmm0
movslq 0xc(%r15), %rax
movq 0x88(%rbx), %rcx
leaq (%rax,%rax,2), %rax
movslq 0x8(%r15), %rdx
movq (%rcx,%rax,8), %rax
movsd %xmm0, (%rax,%rdx,8)
addq $0x10, %r15
addq $0x10, %r12
cmpq %r14, %r15
jne 0x3293f
leaq 0x3c8d3(%rip), %rsi     # 0x6f2b6
movq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x90e0
testl %eax, %eax
je 0x32a37
leaq 0x28(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x18(%rsp), %r14
movq %r14, %rdi
callq 0xda94
movq (%rbx), %rax
movq %rbx, %rdi
movq %r14, %rsi
callq *0x18(%rax)
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x32a37
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x9340
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x32a60
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x9340
movq %rbx, %rdi
callq 0x9670