LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: schuyler[P]quickfix/include/quickfix/fix.h
// Function: bool Beacon<float, 2>::Update<Beacon<float, 2>::DifferenceSolver>(float, float, int)
bool Beacon<F, D>::Update(F time, F rmsThreshold, int maxTries) {
    if (A.rows() <= D + 1) {
        qfdebug("Not enough readings for a fix");
        return false;
    }
    Beacon b = Fix<Solver>(time, rmsThreshold, maxTries);
    rmsThreshold *= rmsThreshold;
    b.estimateError();
    if (b.Err < rmsThreshold) {
        if (Filter != NULL) {
            Filter->Update(time-Time, b.X);
            X = Filter->Position();
        } else {
            X = b.X;
        }
        qfdebug("Δt=" << (time-Time) << ": " << X << " (" << Err << ") filtered vs " << b.X << " (" << b.Err << ") estimate on " << b.A.rows());
        clipToBound();
        Time = time;
        Err = b.Err;
        Clear();
        return true;
    } else {
        qfdebug("MSE " << b.Err << " exceeded threshold " << rmsThreshold);
        Err = b.Err;
        return false;
    }
}

// Assembly:
subq $0xb8, %rsp
movq %rdi, 0xa8(%rsp)
movss %xmm0, 0xa4(%rsp)
movss %xmm1, 0xa0(%rsp)
movl %esi, 0x9c(%rsp)
movq 0xa8(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x2b9410
cmpq $0x3, %rax
jg 0x2bfe9d
movb $0x0, 0xb7(%rsp)
jmp 0x2c000c
movq 0x18(%rsp), %rsi
movss 0xa4(%rsp), %xmm0
movss 0xa0(%rsp), %xmm1
movl 0x9c(%rsp), %edx
leaq 0x30(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x2b65b0
movq 0x10(%rsp), %rdi
movss 0xa0(%rsp), %xmm0
mulss %xmm0, %xmm0
movss %xmm0, 0xa0(%rsp)
callq 0x29ff30
jmp 0x2bfeec
movss 0x70(%rsp), %xmm1
movss 0xa0(%rsp), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x2bffe2
movq 0x18(%rsp), %rax
cmpq $0x0, 0x50(%rax)
je 0x2bff88
movq 0x18(%rsp), %rax
movq 0x50(%rax), %rdi
movss 0xa4(%rsp), %xmm0
movss 0x44(%rax), %xmm1
subss %xmm1, %xmm0
leaq 0x50(%rsp), %rsi
movq (%rdi), %rax
movq 0x20(%rax), %rax
callq *%rax
jmp 0x2bff3b
movq 0x18(%rsp), %rax
movq 0x50(%rax), %rdi
movq (%rdi), %rax
movq 0x30(%rax), %rax
callq *%rax
movq %rax, 0x8(%rsp)
jmp 0x2bff54
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rdi
addq $0x20, %rdi
callq 0x2b4cd0
jmp 0x2bff69
jmp 0x2bff9f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x2b39e0
jmp 0x2c001d
movq 0x18(%rsp), %rdi
leaq 0x50(%rsp), %rsi
addq $0x20, %rdi
callq 0x2b4cd0
jmp 0x2bff9d
jmp 0x2bff9f
movq 0x18(%rsp), %rdi
callq 0x2b8a00
jmp 0x2bffab
movq 0x18(%rsp), %rdi
movss 0xa4(%rsp), %xmm0
movss %xmm0, 0x44(%rdi)
movss 0x70(%rsp), %xmm0
movss %xmm0, 0x40(%rdi)
callq 0x2a3d50
jmp 0x2bffd0
movb $0x1, 0xb7(%rsp)
movl $0x1, 0x20(%rsp)
jmp 0x2c0002
movq 0x18(%rsp), %rax
movss 0x70(%rsp), %xmm0
movss %xmm0, 0x40(%rax)
movb $0x0, 0xb7(%rsp)
movl $0x1, 0x20(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x2b39e0
movb 0xb7(%rsp), %al
andb $0x1, %al
addq $0xb8, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x2b6590
nopw (%rax,%rax)
// File: schuyler[P]quickfix/include/quickfix/particle_filter.h
// Function: ParticleFilter<float, 2>::Update(float, Eigen::Array<float, 1, 2, 1, 1, 2> const&)
bool ParticleFilter<F,D>::Update(F dT, const Point &p) {
    weigh(dT, p);
    shuffle();
    X = P.colwise().mean();
    perturb(dT);
    return true;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movss %xmm0, 0x4c(%rsp)
movq %rsi, 0x40(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movss 0x4c(%rsp), %xmm0
movq 0x40(%rsp), %rsi
callq 0x29d710
movq 0x8(%rsp), %rdi
callq 0x290e10
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
callq 0x29d1e0
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x2a0b50
movq 0x8(%rsp), %rdi
addq $0x28, %rdi
leaq 0x18(%rsp), %rsi
callq 0x2ab280
movq 0x8(%rsp), %rdi
movss 0x4c(%rsp), %xmm0
callq 0x29bdc0
movb $0x1, %al
andb $0x1, %al
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: schuyler[P]quickfix/include/quickfix/particle_filter.h
// Function: ParticleFilter<float, 2>::weigh(float, Eigen::Array<float, 1, 2, 1, 1, 2> const&)
void ParticleFilter<F,D>::weigh(F dT, const Point &x) {
    double variance = 2. * pow(momentum * dT, 2);
    Weights dx_ = (P.rowwise() - x.matrix()).rowwise().norm();
    Matrix<double, Dynamic, 1> dx = dx_.template cast<double>();
    //std::cout << "dx: " << dx << "\n";

    Matrix<double, Dynamic, 1> w = (-dx.array() / variance).exp();
    //std::cout << "weights: " << w << "\n";
    // FIXME: check for the situation where w.sum() == 0
    W = (w / w.sum()).matrix().cast<F>();
    //std::cout << "normalized: " << W << "\n";
}

// Assembly:
subq $0x268, %rsp            # imm = 0x268
movq %rdi, 0x260(%rsp)
movss %xmm0, 0x25c(%rsp)
movq %rsi, 0x250(%rsp)
movq 0x260(%rsp), %rax
movq %rax, 0x18(%rsp)
movss 0x38(%rax), %xmm0
movss 0x25c(%rsp), %xmm1
mulss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x61275(%rip), %xmm1    # 0x386000
callq 0x2b5e90
movq 0x18(%rsp), %rdi
addsd %xmm0, %xmm0
movsd %xmm0, 0x248(%rsp)
addq $0x8, %rdi
callq 0x2b6ce0
movq %rax, 0x188(%rsp)
movq 0x250(%rsp), %rdi
callq 0x2965c0
movq %rax, 0x180(%rsp)
leaq 0x190(%rsp), %rdi
movq %rdi, 0x20(%rsp)
leaq 0x188(%rsp), %rsi
leaq 0x180(%rsp), %rdx
callq 0x2996b0
movq 0x20(%rsp), %rsi
leaq 0x1b8(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x2999a0
movq 0x28(%rsp), %rsi
leaq 0x1e0(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0x29c130
movq 0x30(%rsp), %rsi
leaq 0x238(%rsp), %rdi
movq %rdi, 0x38(%rsp)
callq 0x2ad520
movq 0x38(%rsp), %rsi
leaq 0x160(%rsp), %rdi
callq 0x2b26c0
jmp 0x324e43
leaq 0x170(%rsp), %rdi
leaq 0x160(%rsp), %rsi
callq 0x2ab020
jmp 0x324e5a
leaq 0x170(%rsp), %rdi
callq 0x2a8970
movq %rax, 0x10(%rsp)
jmp 0x324e6e
movq 0x10(%rsp), %rax
movq %rax, 0xa8(%rsp)
leaq 0xb0(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
callq 0x2aeef0
jmp 0x324e92
leaq 0xc0(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
leaq 0x248(%rsp), %rdx
callq 0x2b2330
jmp 0x324eb1
leaq 0xf8(%rsp), %rdi
leaq 0xc0(%rsp), %rsi
callq 0x2a7a20
jmp 0x324ec8
leaq 0x140(%rsp), %rdi
leaq 0xf8(%rsp), %rsi
callq 0x29d510
jmp 0x324edf
leaq 0x140(%rsp), %rdi
callq 0x2b0840
movsd %xmm0, 0x8(%rsp)
jmp 0x324ef4
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x40(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x140(%rsp), %rsi
leaq 0x40(%rsp), %rdx
callq 0x2b7100
jmp 0x324f19
leaq 0x48(%rsp), %rdi
callq 0x29e080
movq %rax, (%rsp)
jmp 0x324f29
movq (%rsp), %rsi
leaq 0x70(%rsp), %rdi
callq 0x2b12b0
jmp 0x324f39
movq 0x18(%rsp), %rdi
addq $0x18, %rdi
leaq 0x70(%rsp), %rsi
callq 0x29f130
jmp 0x324f4e
leaq 0x140(%rsp), %rdi
callq 0x2a62b0
leaq 0x170(%rsp), %rdi
callq 0x2a62b0
leaq 0x238(%rsp), %rdi
callq 0x2b19b0
addq $0x268, %rsp            # imm = 0x268
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x158(%rsp)
movl %eax, 0x154(%rsp)
jmp 0x324fd7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x158(%rsp)
movl %eax, 0x154(%rsp)
jmp 0x324fca
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x158(%rsp)
movl %eax, 0x154(%rsp)
leaq 0x140(%rsp), %rdi
callq 0x2a62b0
leaq 0x170(%rsp), %rdi
callq 0x2a62b0
leaq 0x238(%rsp), %rdi
callq 0x2b19b0
movq 0x158(%rsp), %rdi
callq 0x2b6590
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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:
subq $0x218, %rsp            # imm = 0x218
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x210(%rsp)
movq %rsi, 0x208(%rsp)
movss %xmm0, 0x204(%rsp)
movq 0x208(%rsp), %rsi
movss 0x204(%rsp), %xmm0
leaq 0x1c8(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x2900e0
movq 0x20(%rsp), %rdi
callq 0x29aae0
jmp 0x33904c
leaq 0x180(%rsp), %rdi
leaq 0x1c8(%rsp), %rsi
xorps %xmm0, %xmm0
callq 0x29e0d0
jmp 0x339066
leaq 0x50(%rsp), %rdi
leaq 0x180(%rsp), %rsi
callq 0x2a9a50
jmp 0x33907a
leaq 0x40(%rsp), %rdi
leaq 0x1c8(%rsp), %rsi
callq 0x2991a0
jmp 0x33908e
leaq 0x50(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x29d190
jmp 0x33909f
leaq 0x40(%rsp), %rdi
callq 0x299560
movq %rax, 0x8(%rsp)
jmp 0x3390b0
leaq 0x40(%rsp), %rdi
callq 0x2a9e40
decq %rax
movq %rax, (%rsp)
leaq 0x2e(%rsp), %rdi
callq 0x297c90
jmp 0x3390cd
movq (%rsp), %rdx
movq 0x8(%rsp), %rsi
leaq 0x30(%rsp), %rdi
leaq 0x2e(%rsp), %rcx
callq 0x2a7e50
jmp 0x3390e7
movq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x2ae3a0
jmp 0x3390f8
leaq 0x40(%rsp), %rdi
callq 0x2b19b0
leaq 0x50(%rsp), %rdi
callq 0x2b7600
leaq 0x180(%rsp), %rdi
callq 0x2a6a90
leaq 0x1c8(%rsp), %rdi
callq 0x295370
movq 0x18(%rsp), %rax
addq $0x218, %rsp            # imm = 0x218
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1c0(%rsp)
movl %eax, 0x1bc(%rsp)
jmp 0x3391aa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1c0(%rsp)
movl %eax, 0x1bc(%rsp)
jmp 0x33919d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1c0(%rsp)
movl %eax, 0x1bc(%rsp)
jmp 0x339193
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1c0(%rsp)
movl %eax, 0x1bc(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x2b19b0
leaq 0x50(%rsp), %rdi
callq 0x2b7600
leaq 0x180(%rsp), %rdi
callq 0x2a6a90
leaq 0x1c8(%rsp), %rdi
callq 0x295370
movq 0x1c0(%rsp), %rdi
callq 0x2b6590
nopw %cs:(%rax,%rax)
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
testb %al, %al
je 0x18a5
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %r9, -0xa8(%rbp)
movq %r8, -0xb0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
movq 0x1f725(%rip), %rax     # 0x20ff8
movq (%rax), %rdi
leaq 0x1892c(%rip), %rsi     # 0x1a209
movb $0x0, %al
callq 0x10f0
leaq -0x20(%rbp), %rax
leaq -0xd0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq 0x1f6e9(%rip), %rax     # 0x20ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x1160
leaq -0x20(%rbp), %rax
movq 0x1f6ce(%rip), %rax     # 0x20ff8
movq (%rax), %rsi
movl $0xa, %edi
callq 0x10e0
movl $0x1, %edi
callq 0x1180
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0x1985
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %r9, -0xa8(%rbp)
movq %r8, -0xb0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
callq 0x92a0
leaq 0x18860(%rip), %rdi     # 0x1a218
movb $0x1, %al
callq 0x10a0
leaq -0xd0(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x30, -0x1c(%rbp)
movl $0x8, -0x20(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x1120
movq 0x1f5e4(%rip), %rax     # 0x20fd8
movq %rax, -0xd8(%rbp)
movq (%rax), %rsi
movl $0xa, %edi
callq 0x10e0
movq -0xd8(%rbp), %rax
movq (%rax), %rdi
callq 0x1110
addq $0xe0, %rsp
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x1a5f
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x20(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x20(%rbp)
jmp 0x1a3f
movl -0x14(%rbp), %eax
cmpl 0x1f690(%rip), %eax     # 0x210f8
jg 0x1a6c
jmp 0x1a8b
leaq 0x187c1(%rip), %rdi     # 0x1a234
leaq 0x18721(%rip), %rsi     # 0x1a19b
movl $0x45, %edx
leaq 0x187c3(%rip), %rcx     # 0x1a249
callq 0x10b0
movl 0x1f66b(%rip), %eax     # 0x210fc
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movl %eax, 0x1f65f(%rip)     # 0x210fc
movl -0x14(%rbp), %eax
movl %eax, -0x28(%rbp)
movl 0x1f64f(%rip), %eax     # 0x210f8
movl %eax, -0x24(%rbp)
cvtsi2sdl -0x14(%rbp), %xmm0
cvtsi2sdl 0x1f63f(%rip), %xmm1 # 0x210f8
callq 0x1ae0
movl -0x2c(%rbp), %esi
movl -0x28(%rbp), %edx
movl -0x24(%rbp), %ecx
leaq 0x1879e(%rip), %rdi     # 0x1a26c
movb $0x1, %al
callq 0x1950
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x31c0
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
andb $0x1, %al
movb %al, -0x1a(%rbp)
testb $0x1, -0x1a(%rbp)
je 0xbafb
leaq 0x72c6(%rip), %rdi      # 0x12db8
movb $0x0, %al
callq 0x3050
jmp 0xbb09
leaq 0x72bd(%rip), %rdi      # 0x12dbf
movb $0x0, %al
callq 0x3050
testb $0x1, -0x19(%rbp)
je 0xbb23
movq -0x8(%rbp), %rsi
leaq 0x7425(%rip), %rdi      # 0x12f3f
movb $0x0, %al
callq 0x3050
jmp 0xbb3d
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
leaq 0x7290(%rip), %rdi      # 0x12dc6
movb $0x0, %al
callq 0x3050
testb $0x1, -0x1a(%rbp)
je 0xbb54
movl 0xe6eb(%rip), %eax      # 0x1a234
addl $0x1, %eax
movl %eax, 0xe6e2(%rip)      # 0x1a234
jmp 0xbb63
movl 0xe6de(%rip), %eax      # 0x1a238
addl $0x1, %eax
movl %eax, 0xe6d5(%rip)      # 0x1a238
movb -0x1a(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
sete %al
andb $0x1, %al
movb %al, -0x12(%rbp)
testb $0x1, -0x12(%rbp)
je 0xbbad
leaq 0x7214(%rip), %rdi      # 0x12db8
movb $0x0, %al
callq 0x3050
jmp 0xbbbb
leaq 0x720b(%rip), %rdi      # 0x12dbf
movb $0x0, %al
callq 0x3050
testb $0x1, -0x11(%rbp)
je 0xbbd5
movq -0x8(%rbp), %rsi
leaq 0x7373(%rip), %rdi      # 0x12f3f
movb $0x0, %al
callq 0x3050
jmp 0xbbed
movq -0x8(%rbp), %rsi
movl -0xc(%rbp), %edx
movl -0x10(%rbp), %ecx
leaq 0x71ee(%rip), %rdi      # 0x12dd4
movb $0x0, %al
callq 0x3050
testb $0x1, -0x12(%rbp)
je 0xbc04
movl 0xe63b(%rip), %eax      # 0x1a234
addl $0x1, %eax
movl %eax, 0xe632(%rip)      # 0x1a234
jmp 0xbc13
movl 0xe62e(%rip), %eax      # 0x1a238
addl $0x1, %eax
movl %eax, 0xe625(%rip)      # 0x1a238
movb -0x12(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x8(%rbp)
movb %al, -0x9(%rbp)
je 0xbc41
movq -0x8(%rbp), %rax
cmpb $0x0, (%rax)
setne %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
testb $0x1, %al
jne 0xbc4a
jmp 0xbc79
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
je 0xbc62
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xd, %eax
jne 0xbc6b
movq -0x8(%rbp), %rax
movb $0x0, (%rax)
jmp 0xbc79
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0xbc28
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x38(%rbp)
movq %rdi, %rax
movq -0x38(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq %rax, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movsd %xmm0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq 0xf79d5(%rip), %rsi     # 0x10b3e8
callq 0xeaa0
testb $0x1, %al
jne 0x13a1e
jmp 0x13a35
movq -0x28(%rbp), %rax
movsd -0x20(%rbp), %xmm0
movsd %xmm0, 0x50(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x13ac7
movq -0x30(%rbp), %rdi
leaq 0xf79ae(%rip), %rsi     # 0x10b3ee
callq 0xeaa0
testb $0x1, %al
jne 0x13a4b
jmp 0x13a5f
movq -0x28(%rbp), %rax
movsd -0x20(%rbp), %xmm0
movsd %xmm0, 0x58(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x13ac7
movq -0x30(%rbp), %rdi
leaq 0xf7991(%rip), %rsi     # 0x10b3fb
callq 0xeaa0
testb $0x1, %al
jne 0x13a75
jmp 0x13a89
movq -0x28(%rbp), %rax
movsd -0x20(%rbp), %xmm0
movsd %xmm0, 0x8(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x13ac7
movq -0x30(%rbp), %rdi
leaq 0xf7976(%rip), %rsi     # 0x10b40a
callq 0xeaa0
testb $0x1, %al
jne 0x13a9f
jmp 0x13ac3
movq -0x28(%rbp), %rax
movsd -0x20(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
setne %cl
setp %dl
orb %dl, %cl
andb $0x1, %cl
movb %cl, 0x60(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x13ac7
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq (%rdi), %rax
movq %rax, -0x28(%rbp)
addq $0x20, %rdi
callq 0x13cd0
movq -0x30(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x30, %rdi
callq 0x13cd0
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq %rax, %rdx
movq (%rdi), %rax
callq *0x28(%rax)
callq 0x26640
movsd %xmm0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x30(%rbp), %rcx
xorl %eax, %eax
testb $0x1, 0x258(%rcx)
movb %al, -0x31(%rbp)
jne 0x1ec7e
movq -0x30(%rbp), %rdi
movslq -0x14(%rbp), %rax
movq %rax, -0x40(%rbp)
addq $0x20, %rdi
callq 0x14700
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
setl %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x1ec87
jmp 0x1ecfb
movq -0x30(%rbp), %rdi
addq $0x20, %rdi
movslq -0x14(%rbp), %rsi
callq 0x26650
movsd (%rax), %xmm0
movb $0x1, %al
movsd 0xec70a(%rip), %xmm1    # 0x10b3b0
ucomisd %xmm1, %xmm0
movb %al, -0x41(%rbp)
jne 0x1ecdd
jp 0x1ecdd
movq -0x30(%rbp), %rdi
addq $0x30, %rdi
movslq -0x14(%rbp), %rsi
callq 0x26650
movsd (%rax), %xmm0
movsd 0xec6d2(%rip), %xmm1    # 0x10b3a0
ucomisd %xmm1, %xmm0
setne %al
setp %cl
orb %cl, %al
movb %al, -0x41(%rbp)
movq -0x30(%rbp), %rax
movb -0x41(%rbp), %cl
andb $0x1, %cl
movb %cl, 0x258(%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1ec47
movl $0x0, -0x18(%rbp)
movq -0x30(%rbp), %rcx
xorl %eax, %eax
testb $0x1, 0x259(%rcx)
movb %al, -0x42(%rbp)
je 0x1ed39
movq -0x30(%rbp), %rdi
movslq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
addq $0x10, %rdi
callq 0x14700
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
setl %al
movb %al, -0x42(%rbp)
movb -0x42(%rbp), %al
testb $0x1, %al
jne 0x1ed42
jmp 0x1edb8
movq -0x30(%rbp), %rdi
addq $0x20, %rdi
movslq -0x18(%rbp), %rsi
callq 0x26650
movsd (%rax), %xmm0
xorl %eax, %eax
movsd 0xec64f(%rip), %xmm1    # 0x10b3b0
ucomisd %xmm1, %xmm0
movb %al, -0x51(%rbp)
jne 0x1ed6e
jp 0x1ed6e
jmp 0x1ed9a
movq -0x30(%rbp), %rdi
addq $0x30, %rdi
movslq -0x18(%rbp), %rsi
callq 0x26650
movsd (%rax), %xmm0
movsd 0xec615(%rip), %xmm1    # 0x10b3a0
ucomisd %xmm1, %xmm0
setne %al
setp %cl
orb %cl, %al
movb %al, -0x51(%rbp)
movq -0x30(%rbp), %rax
movb -0x51(%rbp), %cl
andb $0x1, %cl
movb %cl, 0x259(%rax)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1ed02
addq $0x60, %rsp
popq %rbp
retq
nop
// File: canzarlab[P]Trajan/geno/lbfgsb.cpp
// Function: LBFGSB::helper()
Scalar LBFGSB::helper() {
  _s = _xNew - _x;
  _x.swap(_xNew);
  _y = _gNew - _g;
  _g.swap(_gNew);

  Scalar deltaF = (_f - _fNew) / (fabs(_fNew) + 1);  
  // (f^k - f^{k+1})/max{|f^k|,|f^{k+1}|,1} in original implementation
  //  Scalar deltaF = (_f - _fNew) / std::max(std::abs(_f), std::max(std::abs(_fNew), 1.0));
  _f = _fNew;

  projectedGradient();
  return deltaF;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdx
movq %rdx, -0x48(%rbp)
movq %rdx, %rsi
addq $0x238, %rsi            # imm = 0x238
addq $0x10, %rdx
leaq -0x20(%rbp), %rdi
callq 0x27be0
movq -0x48(%rbp), %rdi
addq $0x88, %rdi
leaq -0x20(%rbp), %rsi
callq 0x297c0
movq -0x48(%rbp), %rsi
movq %rsi, %rdi
addq $0x10, %rdi
addq $0x238, %rsi            # imm = 0x238
callq 0x297f0
movq -0x48(%rbp), %rdx
movq %rdx, %rsi
addq $0x248, %rsi            # imm = 0x248
addq $0x40, %rdx
leaq -0x38(%rbp), %rdi
callq 0x27be0
movq -0x48(%rbp), %rdi
addq $0x98, %rdi
leaq -0x38(%rbp), %rsi
callq 0x297c0
movq -0x48(%rbp), %rsi
movq %rsi, %rdi
addq $0x40, %rdi
addq $0x248, %rsi            # imm = 0x248
callq 0x297f0
movq -0x48(%rbp), %rdi
movsd 0x8(%rdi), %xmm0
subsd 0x230(%rdi), %xmm0
movsd 0x230(%rdi), %xmm1
movaps 0xe6d84(%rip), %xmm2    # 0x10b3d0
pand %xmm2, %xmm1
movsd 0xe9610(%rip), %xmm2    # 0x10dc68
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x40(%rbp)
movsd 0x230(%rdi), %xmm0
movsd %xmm0, 0x8(%rdi)
callq 0x24490
movsd -0x40(%rbp), %xmm0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: canzarlab[P]Trajan/geno/lbfgsb.cpp
// Function: LBFGSB::refresh()
void LBFGSB::refresh() {
  _index = 0;
  _S.resize(_x.size(), 0);
  _Y.resize(_x.size(), 0);
  _theta = 1;
  _SY.resize(0, 0);
  _SS.resize(0, 0);
  _SYws.resize(0, 0);
  _SSws.resize(0, 0);
  _YYws.resize(0, 0);
  _M.resize(0, 0);
  _Q.resize(0, 0);
  _K.resize(0, 0);
  _L.resize(0, 0);
  _E.resize(0, 0);
  _workingSet.setOnes();
  _fNew = (std::numeric_limits<Scalar>::infinity());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
movq $0x0, 0x80(%rdi)
movq %rdi, %rax
addq $0xa8, %rax
movq %rax, -0x20(%rbp)
addq $0x10, %rdi
callq 0x14700
movq -0x20(%rbp), %rdi
movq %rax, %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x29830
movq -0x10(%rbp), %rdi
movq %rdi, %rax
addq $0xc0, %rax
movq %rax, -0x18(%rbp)
addq $0x10, %rdi
callq 0x14700
movq -0x18(%rbp), %rdi
movq %rax, %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x29830
movq -0x10(%rbp), %rdi
movsd 0xe951d(%rip), %xmm0    # 0x10dc68
movsd %xmm0, 0xd8(%rdi)
addq $0xe0, %rdi
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x29830
movq -0x10(%rbp), %rdi
addq $0xf8, %rdi
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x29830
movq -0x10(%rbp), %rdi
addq $0x188, %rdi            # imm = 0x188
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x29830
movq -0x10(%rbp), %rdi
addq $0x1a0, %rdi            # imm = 0x1A0
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x29830
movq -0x10(%rbp), %rdi
addq $0x1b8, %rdi            # imm = 0x1B8
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x29830
movq -0x10(%rbp), %rdi
addq $0x110, %rdi            # imm = 0x110
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x29830
movq -0x10(%rbp), %rdi
addq $0x128, %rdi            # imm = 0x128
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x29830
movq -0x10(%rbp), %rdi
addq $0x140, %rdi            # imm = 0x140
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x29830
movq -0x10(%rbp), %rdi
addq $0x158, %rdi            # imm = 0x158
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x29830
movq -0x10(%rbp), %rdi
addq $0x170, %rdi            # imm = 0x170
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x29830
movq -0x10(%rbp), %rdi
addq $0x1e0, %rdi            # imm = 0x1E0
callq 0x29920
callq 0x26640
movq -0x10(%rbp), %rax
movsd %xmm0, 0x230(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
addq $0x10, %rdi
callq 0x14700
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jge 0x249cb
movq -0x20(%rbp), %rdi
addq $0x20, %rdi
movq -0x18(%rbp), %rsi
callq 0x26650
movq -0x20(%rbp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
addq $0x30, %rdi
movq -0x18(%rbp), %rsi
callq 0x26650
movsd -0x30(%rbp), %xmm0
ucomisd (%rax), %xmm0
jbe 0x248e0
movb $0x0, -0x1(%rbp)
jmp 0x249cf
movq -0x20(%rbp), %rdi
addq $0x20, %rdi
movq -0x18(%rbp), %rsi
callq 0x26650
movq -0x20(%rbp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, -0x38(%rbp)
addq $0x10, %rdi
movq -0x18(%rbp), %rsi
callq 0x26650
movsd -0x38(%rbp), %xmm0
ucomisd (%rax), %xmm0
jbe 0x2494a
movq -0x20(%rbp), %rdi
addq $0x20, %rdi
movq -0x18(%rbp), %rsi
callq 0x26650
movq -0x20(%rbp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, -0x40(%rbp)
addq $0x10, %rdi
movq -0x18(%rbp), %rsi
callq 0x26650
movsd -0x40(%rbp), %xmm0
movsd %xmm0, (%rax)
movq -0x20(%rbp), %rdi
addq $0x30, %rdi
movq -0x18(%rbp), %rsi
callq 0x26650
movq -0x20(%rbp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, -0x48(%rbp)
addq $0x10, %rdi
movq -0x18(%rbp), %rsi
callq 0x26650
movsd -0x48(%rbp), %xmm1
movsd (%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x249b8
movq -0x20(%rbp), %rdi
addq $0x30, %rdi
movq -0x18(%rbp), %rsi
callq 0x26650
movq -0x20(%rbp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, -0x50(%rbp)
addq $0x10, %rdi
movq -0x18(%rbp), %rsi
callq 0x26650
movsd -0x50(%rbp), %xmm0
movsd %xmm0, (%rax)
jmp 0x249ba
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x2487c
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x38(%rbp)
movq %rdi, %rax
movq -0x38(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq %rax, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movsd %xmm0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq 0xe5835(%rip), %rsi     # 0x10b3e8
callq 0xeaa0
testb $0x1, %al
jne 0x25bbe
jmp 0x25bd2
movq -0x28(%rbp), %rax
movsd -0x20(%rbp), %xmm0
movsd %xmm0, 0x68(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x25c16
movq -0x30(%rbp), %rdi
leaq 0xe5811(%rip), %rsi     # 0x10b3ee
callq 0xeaa0
testb $0x1, %al
jne 0x25be8
jmp 0x25c12
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
callq 0x26750
movq -0x28(%rbp), %rax
movaps %xmm0, %xmm1
movsd -0x40(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, 0x70(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x25c16
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: canzarlab[P]Trajan/./Eigen/src/LU/FullPivLU.h
// Function: Eigen::FullPivLU<Eigen::Matrix<double, -1, -1, 0, -1, -1>>::rank() const
inline Index rank() const
    {
      using std::abs;
      eigen_assert(m_isInitialized && "LU is not initialized.");
      RealScalar premultiplied_threshold = abs(m_maxpivot) * threshold();
      Index result = 0;
      for(Index i = 0; i < m_nonzero_pivots; ++i)
        result += (abs(m_lu.coeff(i,i)) > premultiplied_threshold);
      return result;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x30(%rbp)
xorl %eax, %eax
testb $0x1, 0x79(%rcx)
movb %al, -0x21(%rbp)
je 0x4e8c6
movb $0x1, %al
movb %al, -0x21(%rbp)
jmp 0x4e8c6
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x4e8cf
jmp 0x4e8d1
jmp 0x4e8f0
leaq 0xc69ba(%rip), %rdi     # 0x115292
leaq 0xc49ae(%rip), %rsi     # 0x11328d
movl $0x14f, %edx            # imm = 0x14F
leaq 0xc6d3a(%rip), %rcx     # 0x115625
callq 0xa2b0
movq -0x30(%rbp), %rax
movsd 0x68(%rax), %xmm0
callq 0x14980
movq -0x30(%rbp), %rdi
movsd %xmm0, -0x38(%rbp)
callq 0x4eea0
movaps %xmm0, %xmm1
movsd -0x38(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
cmpq 0x58(%rcx), %rax
jge 0x4e978
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x47980
movsd (%rax), %xmm0
callq 0x14980
ucomisd -0x10(%rbp), %xmm0
seta %al
andb $0x1, %al
movzbl %al, %eax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x4e92d
movq -0x18(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movb $0x1, %al
testb $0x1, 0x79(%rcx)
movb %al, -0x9(%rbp)
jne 0x4eec9
movq -0x18(%rbp), %rax
movb 0x7a(%rax), %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
testb $0x1, %al
jne 0x4eed2
jmp 0x4eed4
jmp 0x4eef3
leaq 0xc67bb(%rip), %rdi     # 0x115696
leaq 0xc43ab(%rip), %rsi     # 0x11328d
movl $0x13f, %edx            # imm = 0x13F
leaq 0xc67d4(%rip), %rcx     # 0x1156c2
callq 0xa2b0
movq -0x18(%rbp), %rax
testb $0x1, 0x7a(%rax)
je 0x4ef0d
movq -0x18(%rbp), %rax
movsd 0x70(%rax), %xmm0
movsd %xmm0, -0x20(%rbp)
jmp 0x4ef33
callq 0x4ef40
movq -0x18(%rbp), %rdi
movsd %xmm0, -0x28(%rbp)
callq 0x47580
movsd -0x28(%rbp), %xmm0
cvtsi2sd %rax, %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x968f1
movq -0x40(%rbp), %rdi
addq $0x8, %rdi
leaq -0x10(%rbp), %rsi
callq 0x99890
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
callq *0x18(%rax)
movq -0x40(%rbp), %rcx
movq 0x70(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x70(%rcx)
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x28(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x969db
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x30, %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x30(%rax)
jne 0x96952
movq -0x40(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x968b0
jmp 0x96954
movq -0x28(%rbp), %rax
cmpq $0x0, (%rax)
je 0x9696f
movq -0x28(%rbp), %rax
movq (%rax), %rax
addq $0x8, %rax
movq %rax, -0x28(%rbp)
jmp 0x96954
movl $0x10, %edi
callq 0xa450
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rsi
callq 0xc5f70
jmp 0x9698e
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movq (%rax), %rdx
movq (%rdi), %rax
callq *0x20(%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x96918
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
movl $0x10, %esi
callq 0xa460
jmp 0x969fa
movq -0x40(%rbp), %rdi
addq $0x20, %rdi
leaq -0x10(%rbp), %rsi
callq 0x99b50
movq %rax, %rdi
callq 0x99c30
addq $0x50, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0xa7c0
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xd0(%rbp)
movq %rax, %rcx
addq $0x50, %rcx
movq %rcx, -0xc8(%rbp)
movq 0x70(%rax), %rax
movq %rax, -0xc0(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x995b0
movq -0xc0(%rbp), %rsi
movq -0xb8(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0x995d0
jmp 0x96d8c
movq -0xc0(%rbp), %rsi
movq -0xc8(%rbp), %rdi
leaq -0x30(%rbp), %rdx
callq 0x999a0
jmp 0x96da5
leaq -0x30(%rbp), %rdi
callq 0x10160
leaq -0x31(%rbp), %rdi
callq 0x99610
movq -0xd0(%rbp), %rax
movq 0x70(%rax), %rax
movq %rax, -0xe0(%rbp)
leaq -0x89(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
callq 0x995b0
movq -0xe0(%rbp), %rsi
movq -0xd8(%rbp), %rdx
leaq -0x88(%rbp), %rdi
callq 0x995d0
jmp 0x96df8
leaq -0x8a(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
callq 0x99690
movq -0xe0(%rbp), %rsi
movq -0xe8(%rbp), %rcx
leaq -0x60(%rbp), %rdi
leaq -0x88(%rbp), %rdx
callq 0x996b0
jmp 0x96e2b
leaq -0x8a(%rbp), %rdi
callq 0x104c0
leaq -0x88(%rbp), %rdi
callq 0x10160
leaq -0x89(%rbp), %rdi
callq 0x99610
movq -0xd0(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x98(%rbp)
movq -0x98(%rbp), %rdi
callq 0x99a50
movq %rax, -0xa0(%rbp)
movq -0x98(%rbp), %rdi
callq 0x99a80
movq %rax, -0xa8(%rbp)
leaq -0xa0(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x99ab0
testb $0x1, %al
jne 0x96ea3
jmp 0x96f6a
leaq -0xa0(%rbp), %rdi
callq 0x99af0
movq -0xd0(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0xb0(%rbp)
movq -0xb0(%rbp), %rdx
leaq -0x60(%rbp), %rcx
movq %rdx, %rsi
callq 0x97880
jmp 0x96ed5
jmp 0x96ed7
leaq -0xa0(%rbp), %rdi
callq 0x99b10
jmp 0x96e87
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x96f08
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x10160
leaq -0x31(%rbp), %rdi
callq 0x99610
jmp 0x96f7c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x96f45
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x8a(%rbp), %rdi
callq 0x104c0
leaq -0x88(%rbp), %rdi
callq 0x10160
leaq -0x89(%rbp), %rdi
callq 0x99610
jmp 0x96f7c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x60(%rbp), %rdi
callq 0xff60
jmp 0x96f7c
leaq -0x60(%rbp), %rdi
callq 0xff60
addq $0xf0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0xa7c0
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq 0x28(%rax), %rsi
callq 0x997b0
movq %rax, -0x28(%rbp)
movq %rdx, -0x20(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x99810
testb $0x1, %al
jne 0x9736a
jmp 0x9736f
jmp 0x9749e
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq 0x28(%rax), %rsi
callq 0x997b0
movq %rax, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
leaq -0x38(%rbp), %rdi
movl $0x1, %esi
callq 0x99840
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0x9749e
movq -0x90(%rbp), %rdi
movq -0x40(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0x97320
movq -0x40(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
je 0x9748b
movq -0x90(%rbp), %rax
movq 0x70(%rax), %rax
movq %rax, -0xa0(%rbp)
leaq -0x71(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x995b0
movq -0xa0(%rbp), %rsi
movq -0x98(%rbp), %rdx
leaq -0x70(%rbp), %rdi
callq 0x995d0
jmp 0x97417
leaq -0x71(%rbp), %rdi
callq 0x99610
movq -0x90(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x48(%rbp), %rax
movq (%rax), %rdx
leaq -0x70(%rbp), %rcx
callq 0x97740
jmp 0x9743d
leaq -0x70(%rbp), %rdi
callq 0x10160
movq -0x48(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x48(%rbp)
jmp 0x973d1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x71(%rbp), %rdi
callq 0x99610
jmp 0x974a7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x10160
jmp 0x974a7
jmp 0x9748d
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x40(%rbp)
jmp 0x973a1
addq $0xa0, %rsp
popq %rbp
retq
movq -0x80(%rbp), %rdi
callq 0xa7c0
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl $0xffffffff, 0x28(%rax) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x97512
movq -0x18(%rbp), %rax
movq (%rax), %rax
cmpl $-0x1, 0x28(%rax)
je 0x97502
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x974b0
jmp 0x97504
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x974de
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movq 0x70(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x70(%rcx)
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x28(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x9758f
movq -0x18(%rbp), %rax
movq (%rax), %rax
cmpl $-0x1, 0x28(%rax)
jne 0x9757f
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x97520
jmp 0x97581
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x9755b
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x99890
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x975e7
movq -0x28(%rbp), %rdi
addq $0xf0, %rdi
movq -0x18(%rbp), %rsi
callq 0x99900
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x9761b
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0x975a0
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x975f2
movq -0x18(%rbp), %rdi
callq 0x99970
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movslq 0x28(%rax), %rsi
callq 0x997b0
movq %rax, -0x30(%rbp)
movq %rdx, -0x28(%rbp)
leaq -0x30(%rbp), %rdi
movl $0x1, %esi
callq 0x99840
movq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x97820
movq -0x50(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x30, %rsi
movq -0x10(%rbp), %rdx
callq 0x97820
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x97814
movq -0x20(%rbp), %rdi
movq -0x38(%rbp), %rax
movq (%rax), %rax
movslq 0x28(%rax), %rsi
callq 0x997b0
movq %rax, -0x48(%rbp)
movq %rdx, -0x40(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x99810
xorb $-0x1, %al
testb $0x1, %al
jne 0x977ec
jmp 0x97804
movq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x38(%rbp), %rax
movq (%rax), %rdx
movq -0x20(%rbp), %rcx
callq 0x97740
jmp 0x97806
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x977b8
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x9786f
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0x9785e
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0x9786d
movq -0x10(%rbp), %rax
movq (%rax), %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
jmp 0x97830
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x18(%rbp), %rax
movl 0x28(%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movl 0x28(%rax), %eax
movl %eax, -0x28(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x28(%rbp), %eax
je 0x9790b
movq -0x88(%rbp), %rdi
addq $0x50, %rdi
movslq -0x24(%rbp), %rsi
callq 0x99b30
movq %rax, %rdi
movslq -0x28(%rbp), %rsi
callq 0x997b0
movq %rax, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
leaq -0x38(%rbp), %rdi
movl $0x1, %esi
callq 0x99840
movq -0x88(%rbp), %rdi
movl -0x24(%rbp), %esi
movl -0x28(%rbp), %edx
movq (%rdi), %rax
callq *0x28(%rax)
movq -0x20(%rbp), %rdi
movslq -0x28(%rbp), %rsi
callq 0x99b30
movq %rax, %rdi
movslq -0x24(%rbp), %rsi
callq 0x997b0
movq %rax, -0x48(%rbp)
movq %rdx, -0x40(%rbp)
leaq -0x48(%rbp), %rdi
movl $0x1, %esi
callq 0x99840
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, -0x50(%rbp)
je 0x97a0d
movq -0x50(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movl 0x28(%rax), %eax
movl %eax, -0x5c(%rbp)
movq -0x20(%rbp), %rdi
movslq -0x5c(%rbp), %rsi
callq 0x99b30
movq %rax, %rdi
movslq -0x24(%rbp), %rsi
callq 0x997b0
movq %rax, -0x70(%rbp)
movq %rdx, -0x68(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x99810
xorb $-0x1, %al
testb $0x1, %al
jne 0x97998
jmp 0x979b0
movq -0x88(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x97880
movq -0x20(%rbp), %rdi
movslq -0x5c(%rbp), %rsi
callq 0x99b30
movq %rax, %rdi
movslq -0x5c(%rbp), %rsi
callq 0x997b0
movq %rax, -0x80(%rbp)
movq %rdx, -0x78(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x99810
xorb $-0x1, %al
testb $0x1, %al
jne 0x979e2
jmp 0x979fa
movq -0x88(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq -0x58(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x97880
jmp 0x979fc
movq -0x50(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x50(%rbp)
jmp 0x97946
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)