LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/schuyler[P]quickfix/include/quickfix/fix.h
// Function: Beacon<float, 2>::estimateError()
void Beacon<F, D>::estimateError() {
    Ranges R_hat;
    int i, j;

    // FIXME FIXME: this no longer works for RangeSolver
    //
    //std::cout << "\n\nR: " << R << "\n";
    R_hat = calculateRanges(A, X);
    //std::cout << "R_hat pre: " << R_hat << "\n";
    R.minCoeff(&i, &j);
    R_hat = (R_hat.array() - R_hat[i]).matrix(); 
    //std::cout << "R_hat post: " << R_hat << "\n";
    Err = meanSquaredError(R_hat);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
leaq 0x20(%rdi), %rdx
leaq 0x30(%rsp), %rdi
movq %rbx, %rsi
callq 0x4e460
movq 0x30(%rsp), %r15
movq 0x38(%rsp), %r14
movq %r15, 0x10(%rsp)
movq %r14, 0x18(%rsp)
leaq 0x10(%rbx), %rdi
leaq 0xc(%rsp), %rsi
leaq 0x2c(%rsp), %rdx
callq 0x4e100
movslq 0xc(%rsp), %rax
movss (%r15,%rax,4), %xmm0
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
movq %rdi, (%rsi)
movq %r14, 0x8(%rsi)
movss %xmm0, 0x14(%rsi)
callq 0x4c6e0
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x4f070
movss %xmm0, 0x40(%rbx)
movq 0x10(%rsp), %rdi
callq 0x4e5b0
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x50de4
jmp 0x50de4
movq %rax, %rbx
movq 0x10(%rsp), %rdi
callq 0x4e5b0
movq %rbx, %rdi
callq 0x4f920
nop
// File: /workspace/github_cpp_makefile_star2_O2/schuyler[P]quickfix/include/quickfix/beacon.h
// Function: Beacon<float, 2>::Reading(Eigen::Array<float, 1, 2, 1, 1, 2> const&, float)
int Beacon<F, D>::Reading(const Point &anchor, F range) {
    int i = findRow(anchor);
    Anchor(i, anchor);
    Range(i, range);
    return i;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movss %xmm0, 0xc(%rsp)
movq %rsi, %rbx
movq %rdi, %r14
callq 0x4c290
movl %eax, %ebp
movq %r14, %rdi
movl %eax, %esi
movq %rbx, %rdx
callq 0x4cc70
movq %r14, %rdi
movl %ebp, %esi
movss 0xc(%rsp), %xmm0
callq 0x4c8f0
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x70, %rsp
cmpq $0x4, 0x8(%rdi)
jge 0x5129a
xorl %ebp, %ebp
jmp 0x51363
movl %esi, %edx
movq %rdi, %rbx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
movss %xmm0, 0x8(%rsp)
movss %xmm1, 0xc(%rsp)
callq 0x4f940
movq %r14, %rdi
callq 0x4d880
movss 0xc(%rsp), %xmm1
mulss %xmm1, %xmm1
movss 0x50(%rsp), %xmm0
ucomiss %xmm0, %xmm1
seta %bpl
jbe 0x51314
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x5131b
movss 0x8(%rsp), %xmm0
subss 0x44(%rbx), %xmm0
leaq 0x30(%rsp), %rsi
movq (%rdi), %rax
callq *0x20(%rax)
movq 0x50(%rbx), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
movss (%rax), %xmm0
movss %xmm0, 0x20(%rbx)
addq $0x4, %rax
jmp 0x5132a
movss %xmm0, 0x40(%rbx)
jmp 0x51359
leaq 0x34(%rsp), %rax
movss -0x4(%rax), %xmm0
movss %xmm0, 0x20(%rbx)
movss (%rax), %xmm0
movss %xmm0, 0x24(%rbx)
movq %rbx, %rdi
callq 0x4fd80
movss 0x8(%rsp), %xmm0
movss %xmm0, 0x44(%rbx)
movss 0x50(%rsp), %xmm0
movss %xmm0, 0x40(%rbx)
movq %rbx, %rdi
callq 0x4de40
leaq 0x10(%rsp), %rdi
callq 0x4f560
movl %ebp, %eax
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x4f560
movq %rbx, %rdi
callq 0x4f920
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbx
subq $0x30, %rsp
movss %xmm0, 0x4(%rsp)
movq %rdi, %rbx
callq 0x4d4d0
movq %rbx, %rdi
callq 0x4c1a0
leaq 0x8(%rbx), %rax
cvtsi2ssq 0x10(%rbx), %xmm0
leaq 0x8(%rsp), %rsi
movq %rax, 0x8(%rsi)
movss %xmm0, 0x1c(%rsi)
leaq 0x28(%rbx), %rdi
callq 0x4fd70
movq %rbx, %rdi
movss 0x4(%rsp), %xmm0
callq 0x4d220
movb $0x1, %al
addq $0x30, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %rbx
subq $0x90, %rsp
movss %xmm0, 0x4(%rsp)
movq %rdi, %rbx
movss 0x38(%rdi), %xmm0
movss %xmm0, (%rsp)
leaq 0x8(%rdi), %rax
movq 0x10(%rdi), %rcx
leaq 0x38(%rsp), %r14
movq %rax, 0x18(%r14)
movq %rsi, 0x20(%r14)
movq %rcx, 0x28(%r14)
leaq 0x28(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x4e630
movq %r15, (%r14)
leaq 0x18(%rsp), %r14
leaq 0x38(%rsp), %rsi
movq %r14, %rdi
callq 0x4cfb0
movss (%rsp), %xmm0
mulss 0x4(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
mulsd %xmm0, %xmm0
addsd %xmm0, %xmm0
movq 0x20(%rsp), %rax
leaq 0x38(%rsp), %rsi
movq %r14, 0x10(%rsi)
movq %rax, 0x20(%rsi)
movsd %xmm0, 0x30(%rsi)
leaq 0x8(%rsp), %rdi
callq 0x4d350
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x4f100
movq 0x10(%rsp), %rax
leaq 0x38(%rsp), %rsi
movq %r14, 0x8(%rsi)
movq %rax, 0x10(%rsi)
movsd %xmm0, 0x20(%rsi)
addq $0x18, %rbx
movq %rbx, %rdi
callq 0x4dbe0
movq 0x8(%rsp), %rdi
callq 0x4e5b0
movq 0x18(%rsp), %rdi
callq 0x4e5b0
movq 0x28(%rsp), %rdi
callq 0x4e5b0
addq $0x90, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
jmp 0x5e241
movq %rax, %rbx
jmp 0x5e24b
movq %rax, %rbx
movq 0x8(%rsp), %rdi
callq 0x4e5b0
movq 0x18(%rsp), %rdi
callq 0x4e5b0
movq 0x28(%rsp), %rdi
callq 0x4e5b0
movq %rbx, %rdi
callq 0x4f920
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 $0xc8, %rsp
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
movq %rsp, %rdi
movq %r14, %rsi
callq 0x4e760
leaq 0x30(%rbx), %r12
addq $0x18, %rbx
movq %rbx, 0x10(%rsp)
xorl %r13d, %r13d
leaq 0x18(%rsp), %rbx
leaq 0x28(%rsp), %r15
cmpl (%r12), %r13d
jge 0x5e3a9
movl $0x1, 0x28(%rsp)
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x4f390
movslq (%r12), %rax
movq %rax, 0x38(%rsp)
movq %rax, 0x48(%rsp)
movl $0x3f000000, %ecx       # imm = 0x3F000000
movl %ecx, 0x54(%rsp)
movq %rax, 0x60(%rsp)
movl %ecx, 0x6c(%rsp)
leaq 0xa8(%rsp), %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x4fca0
movq %rbx, %rdi
movq 0x10(%rsp), %rsi
callq 0x4cff0
xorl %ebx, %ebx
xorl %ebp, %ebp
movslq (%r12), %rax
movq 0x18(%rsp), %rdi
cmpl %eax, %r13d
jge 0x5e39a
cmpq %rax, %rbp
jge 0x5e39a
xorps %xmm0, %xmm0
ucomiss (%rdi,%rbp,4), %xmm0
jbe 0x5e38e
movq (%rsp), %rax
addq %rbx, %rax
movq %rax, 0x28(%rsp)
movq %rsp, %rax
movq %rax, 0x38(%rsp)
movq %rbp, 0x40(%rsp)
andq $0x0, 0x48(%rsp)
pushq $0x1
popq %rdx
movq %rdx, 0x50(%rsp)
movslq %r13d, %rax
leaq (,%rax,4), %rcx
addq (%r14), %rcx
movq %rcx, 0x78(%rsp)
movq %r14, 0x88(%rsp)
movq %rax, 0x90(%rsp)
andq $0x0, 0x98(%rsp)
movq %rdx, 0xa0(%rsp)
leaq 0x78(%rsp), %rdi
movq %r15, %rsi
callq 0x4e800
incl %r13d
incq %rbp
addq $0x4, %rbx
jmp 0x5e2ff
callq 0x4e5b0
leaq 0x18(%rsp), %rbx
jmp 0x5e29b
movq (%rsp), %rdi
callq 0x4e5b0
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5e3cd
movq %rax, %rbx
jmp 0x5e3da
jmp 0x5e3cd
movq %rax, %rbx
movq 0x18(%rsp), %rdi
callq 0x4e5b0
movq (%rsp), %rdi
callq 0x4e5b0
movq %rbx, %rdi
callq 0x4f920
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4c030
movq %r14, %rdi
callq 0x4d050
leaq 0x180(%rsp), %r14
leaq 0x18(%rsp), %rsi
xorps %xmm0, %xmm0
movq %r14, %rdi
callq 0x4d5c0
movl $0x42c80000, 0x50(%rsp) # imm = 0x42C80000
movq $0x190, 0x58(%rsp)      # imm = 0x190
movsd 0xa987(%rip), %xmm0     # 0x6b430
movsd %xmm0, 0x60(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x68(%rsp)
movups %xmm0, 0x78(%rsp)
movups %xmm0, 0x88(%rsp)
movups %xmm0, 0x98(%rsp)
movups %xmm0, 0xa8(%rsp)
movups %xmm0, 0xb8(%rsp)
movq %r14, 0xf0(%rsp)
movups %xmm0, 0xc8(%rsp)
movups %xmm0, 0xd8(%rsp)
movb $0x0, 0xe8(%rsp)
movups %xmm0, 0x108(%rsp)
movups %xmm0, 0x118(%rsp)
movups %xmm0, 0x128(%rsp)
movups %xmm0, 0x138(%rsp)
leaq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x4cdc0
leaq 0x50(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x4d440
movq 0x8(%rsp), %rdi
movsd (%rdi), %xmm0
movsd %xmm0, (%rbx)
callq 0x4e5b0
leaq 0x50(%rsp), %rdi
callq 0x4fb70
leaq 0x180(%rsp), %rdi
callq 0x4f230
leaq 0x18(%rsp), %rdi
callq 0x4f230
movq %rbx, %rax
addq $0x1b8, %rsp            # imm = 0x1B8
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
callq 0x4e5b0
jmp 0x60b8d
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x4fb70
leaq 0x180(%rsp), %rdi
callq 0x4f230
jmp 0x60bab
jmp 0x60ba8
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x4f230
movq %rbx, %rdi
callq 0x4f920
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1811
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 0x137e0(%rip), %r15     # 0x14ff8
movq (%r15), %rcx
leaq 0xc9bc(%rip), %rdi      # 0xe1de
pushq $0xe
popq %rsi
pushq $0x1
popq %rdx
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
pushq $0xa
popq %rdi
callq 0x1100
pushq $0x1
popq %rdi
callq 0x11a0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x18cc
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 0x866a
leaq 0xc915(%rip), %rdi      # 0xe1ed
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 0x136ca(%rip), %rbx     # 0x14fd8
movq (%rbx), %rsi
pushq $0xa
popq %rdi
callq 0x1100
movq (%rbx), %rdi
callq 0x1130
addq $0xd8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
xorl %edx, %edx
cmpl $0x0, (%rsi,%rdx,4)
je 0x193a
incq %rdx
jmp 0x192f
movl 0x137d0(%rip), %ecx     # 0x15110
cmpl %ecx, %edx
jg 0x197e
movl 0x137ca(%rip), %esi     # 0x15114
incl %esi
movl %esi, 0x137c2(%rip)     # 0x15114
xorpd %xmm0, %xmm0
testl %ecx, %ecx
je 0x196e
cvtsi2sd %edx, %xmm0
cvtsi2sd %ecx, %xmm1
mulsd 0xc6ce(%rip), %xmm0     # 0xe038
divsd %xmm1, %xmm0
leaq 0xc8cc(%rip), %rdi      # 0xe241
movb $0x1, %al
popq %r8
jmp 0x186b
leaq 0xc884(%rip), %rdi      # 0xe209
leaq 0xc7e4(%rip), %rsi      # 0xe170
leaq 0xc88b(%rip), %rcx      # 0xe21e
pushq $0x45
popq %rdx
callq 0x10d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4667(%rip), %rax      # 0xbcf0
leaq 0x4667(%rip), %rdi      # 0xbcf7
cmoveq %rax, %rdi
xorl %eax, %eax
callq 0x3050
testl %ebp, %ebp
je 0x76b2
leaq 0x47d1(%rip), %rdi      # 0xbe77
movq %r14, %rsi
xorl %eax, %eax
callq 0x3050
jmp 0x76c9
leaq 0x4645(%rip), %rdi      # 0xbcfe
movq %r14, %rsi
movq %r12, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0x3050
testl %ebx, %ebx
sete %al
leaq 0xbb5f(%rip), %rcx      # 0x13234
leaq 0xbb5c(%rip), %rdx      # 0x13238
cmoveq %rcx, %rdx
incl (%rdx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x45eb(%rip), %rax      # 0xbcf0
leaq 0x45eb(%rip), %rdi      # 0xbcf7
cmoveq %rax, %rdi
xorl %eax, %eax
callq 0x3050
testl %r15d, %r15d
je 0x772f
leaq 0x4754(%rip), %rdi      # 0xbe77
movq %r14, %rsi
xorl %eax, %eax
callq 0x3050
jmp 0x7744
leaq 0x45d6(%rip), %rdi      # 0xbd0c
movq %r14, %rsi
movl %ebp, %edx
movl %ebx, %ecx
xorl %eax, %eax
callq 0x3050
cmpl %ebx, %ebp
sete %al
leaq 0xbae4(%rip), %rcx      # 0x13234
leaq 0xbae1(%rip), %rdx      # 0x13238
cmoveq %rcx, %rdx
incl (%rdx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x7786
movzbl (%rdi), %eax
testl %eax, %eax
je 0x7786
cmpl $0xd, %eax
je 0x7783
cmpl $0xa, %eax
je 0x7783
incq %rdi
jmp 0x7768
movb $0x0, (%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x28, %rsp
movq %rsi, %rbx
cmpl $0xc, %edi
je 0xa24d
cmpl $0xa, %edi
jne 0xa289
movl $0x80, %edi
callq 0x9340
movq %rax, %r14
movq 0x8(%rbx), %rsi
movq %rax, %rdi
callq 0x2d5e2
movl $0x80, %edi
callq 0x9340
movq %rax, %r15
movq 0x10(%rbx), %rsi
movq %rax, %rdi
callq 0x2d5e2
jmp 0xa2dd
movl $0x80, %edi
callq 0x9340
movq %rax, %r14
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
movq %rax, %rdi
callq 0x2d54c
movl $0x80, %edi
callq 0x9340
movq %rax, %r15
movq 0x18(%rbx), %rsi
movq 0x20(%rbx), %rdx
movq %rax, %rdi
callq 0x2d54c
jmp 0xa2dd
movslq %edi, %rax
movq -0x8(%rbx,%rax,8), %rsi
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xb7a6
leaq 0x8(%rsp), %rdi
pushq $0xa
popq %rdx
xorl %esi, %esi
callq 0xb789
movl %eax, %ebp
leaq 0x8(%rsp), %rdi
callq 0x9708
movq 0x8(%rbx), %rdi
movq 0x10(%rbx), %rsi
movl %ebp, %edx
callq 0xa18c
movq %rax, %r14
movq 0x18(%rbx), %rdi
xorl %esi, %esi
movl %ebp, %edx
callq 0xa18c
movq %rax, %r15
movq %r14, %rax
movq %r15, %rdx
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x9708
jmp 0xa323
jmp 0xa2ff
movq %rax, %rbx
movl $0x80, %esi
movq %r15, %rdi
jmp 0xa31e
movq %rax, %rbx
jmp 0xa323
jmp 0xa313
movq %rax, %rbx
movl $0x80, %esi
movq %r14, %rdi
callq 0x9350
movq %rbx, %rdi
callq 0x9640
// File: /workspace/github_cpp_makefile_star2_O2/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 0x44606(%rip), %rsi     # 0x51418
movq %r14, %rdi
callq 0xb7fa
testb %al, %al
je 0xce2a
movsd (%rsp), %xmm0
movsd %xmm0, 0x50(%rbx)
jmp 0xce93
leaq 0x445ed(%rip), %rsi     # 0x5141e
movq %r14, %rdi
callq 0xb7fa
testb %al, %al
je 0xce49
movsd (%rsp), %xmm0
movsd %xmm0, 0x58(%rbx)
jmp 0xce93
leaq 0x445db(%rip), %rsi     # 0x5142b
movq %r14, %rdi
callq 0xb7fa
testb %al, %al
je 0xce68
movsd (%rsp), %xmm0
movsd %xmm0, 0x8(%rbx)
jmp 0xce93
leaq 0x445cb(%rip), %rsi     # 0x5143a
movq %r14, %rdi
callq 0xb7fa
testb %al, %al
je 0xce9d
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
xorl %eax, %eax
jmp 0xce95
nop
// File: /workspace/github_cpp_makefile_star2_O2/canzarlab[P]Trajan/geno/augmentedLagrangian.cpp
// Function: AugmentedNLP::computeConstraintError()
void computeConstraintError()
  {
    _constraintError = _constraintValues;

    // for equality constraints
    _constraintError.head(_mEqualities) -= _cl.head(_mEqualities);

    for (size_t i = 0; i < _mInequalities; ++i)
    {
      if (_cType[i+_mEqualities] == 2)
      {
	// lower bound not -INF
	_constraintError(i+_mEqualities) -= _cl(i+_mEqualities);
      }
      if (_cType[i+_mEqualities] == 3)
      {
	// lower bound not -INF and upper not INF
	double err = std::max(_constraintError(i+_mEqualities) - _cu(i + _mEqualities), 0.0);
	err = std::min(_constraintError(i+_mEqualities) - _cl(i+_mEqualities), err);
	_constraintError(i+_mEqualities) = err;
	//	std::cout << "c = " << _constraintError(i+_mEqualities) << std::endl;
	//	std::cout << "e = " << err << std::endl;
	//	std::cout << "lb= " << _cl(i+_mEqualities) << std::endl;
	//	std::cout << "ub= " << _cu(i+_mEqualities) << std::endl;
      }
      if (_cType[i+_mEqualities] == 4)
      {
	// upper bound not INF
	_constraintError(i+_mEqualities) -= _cu(i+_mEqualities);
      }
    }
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x80, %rsp
movq %rdi, %rbx
leaq 0x30(%rdi), %rsi
leaq 0x90(%rdi), %r14
movq %r14, %rdi
callq 0xe787
leaq 0x58(%rbx), %r15
movq 0x20(%rbx), %rdx
leaq 0x48(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0xd304
movq 0x20(%rbx), %rdx
leaq 0x10(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
callq 0xd304
movq %r13, %rdi
movq %r12, %rsi
callq 0xdc1c
leaq 0x68(%rbx), %r12
xorl %r13d, %r13d
cmpq 0x28(%rbx), %r13
jae 0xdacd
movq 0x20(%rbx), %rsi
addq %r13, %rsi
movq 0x78(%rbx), %rax
movl (%rax,%rsi,4), %eax
cmpl $0x2, %eax
jne 0xd9ee
movq %r15, %rdi
callq 0xd27a
movsd (%rax), %xmm0
movsd %xmm0, (%rsp)
movq 0x20(%rbx), %rsi
addq %r13, %rsi
movq %r14, %rdi
callq 0xd27a
movsd (%rax), %xmm0
subsd (%rsp), %xmm0
movsd %xmm0, (%rax)
movq 0x78(%rbx), %rax
movq 0x20(%rbx), %rsi
addq %r13, %rsi
movl (%rax,%rsi,4), %eax
cmpl $0x3, %eax
jne 0xda93
movq %r14, %rdi
callq 0xd27a
movsd (%rax), %xmm0
movsd %xmm0, (%rsp)
movq 0x20(%rbx), %rsi
addq %r13, %rsi
movq %r12, %rdi
callq 0xd27a
movsd (%rsp), %xmm1
subsd (%rax), %xmm1
xorpd %xmm0, %xmm0
maxsd %xmm1, %xmm0
movsd %xmm0, (%rsp)
movq 0x20(%rbx), %rsi
addq %r13, %rsi
movq %r14, %rdi
callq 0xd27a
movsd (%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x20(%rbx), %rsi
addq %r13, %rsi
movq %r15, %rdi
callq 0xd27a
movsd 0x8(%rsp), %xmm1
subsd (%rax), %xmm1
movsd (%rsp), %xmm0
minsd %xmm1, %xmm0
movsd %xmm0, (%rsp)
movq 0x20(%rbx), %rsi
addq %r13, %rsi
movq %r14, %rdi
callq 0xd27a
movsd (%rsp), %xmm0
movsd %xmm0, (%rax)
movq 0x78(%rbx), %rax
movq 0x20(%rbx), %rsi
addq %r13, %rsi
movl (%rax,%rsi,4), %eax
cmpl $0x4, %eax
jne 0xdac5
movq %r12, %rdi
callq 0xd27a
movsd (%rax), %xmm0
movsd %xmm0, (%rsp)
movq 0x20(%rbx), %rsi
addq %r13, %rsi
movq %r14, %rdi
callq 0xd27a
movsd (%rax), %xmm0
subsd (%rsp), %xmm0
movsd %xmm0, (%rax)
incq %r13
jmp 0xd996
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x20(%rdi), %r14
movq (%rdi), %rdi
movq 0x20(%rbx), %rsi
leaq 0x30(%rbx), %r15
movq 0x30(%rbx), %rdx
movq (%rdi), %rax
callq *0x28(%rax)
movb 0x258(%rbx), %cl
xorl %r12d, %r12d
testb $0x1, %cl
jne 0xf100
cmpq %r12, 0x28(%rbx)
jle 0xf100
movq %r14, %rdi
movq %r12, %rsi
callq 0x13224
movb $0x1, %cl
movsd 0x4233b(%rip), %xmm0    # 0x51410
ucomisd (%rax), %xmm0
jb 0xf0f5
movq %r15, %rdi
movq %r12, %rsi
callq 0x13224
movsd (%rax), %xmm0
ucomisd 0x422f6(%rip), %xmm0    # 0x513e8
setb %cl
movb %cl, 0x258(%rbx)
incq %r12
jmp 0xf0b5
movb 0x259(%rbx), %al
xorl %r12d, %r12d
testb $0x1, %al
je 0xf155
cmpq %r12, 0x18(%rbx)
jle 0xf155
movq %r14, %rdi
movq %r12, %rsi
callq 0x13224
movsd 0x422ea(%rip), %xmm0    # 0x51410
ucomisd (%rax), %xmm0
jae 0xf148
movq %r15, %rdi
movq %r12, %rsi
callq 0x13224
movsd (%rax), %xmm0
ucomisd 0x422a5(%rip), %xmm0    # 0x513e8
setb %al
jmp 0xf14a
xorl %eax, %eax
movb %al, 0x259(%rbx)
incq %r12
jmp 0xf109
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/canzarlab[P]Trajan/geno/lbfgsb.cpp
// Function: LBFGSB::projectedGradient()
void LBFGSB::projectedGradient()
{
  _projectedGradient = _g.array().max((_x - _ub).array());
  _projectedGradient = _projectedGradient.array().min((_x - _lb).array());

  // Compute projected gradient.
  //  for (Index i = 0; i < _x.size(); ++i) {
  //    _projectedGradient[i] = 
  //      ((_g[i] > 0 && _x[i] == _lb[i]) || (_g[i] < 0 && _x[i] == _ub[i])) ?
  //      0 : _g[i];
  //  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
leaq 0x40(%rdi), %rax
leaq 0x8(%rsp), %r15
movq %rax, (%r15)
leaq 0x10(%rdi), %r14
leaq 0x30(%rdi), %rdx
leaq 0x28(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x1367c
movups (%r12), %xmm0
leaq 0x10(%rsp), %r12
movaps %xmm0, (%r12)
leaq 0x40(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x13d38
leaq 0x220(%rbx), %rbp
movq %rbp, %rdi
movq %r13, %rsi
callq 0x2b7ed
movq %rbp, (%r15)
addq $0x20, %rbx
leaq 0x28(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1367c
movups (%r15), %xmm0
movaps %xmm0, (%r12)
leaq 0x40(%rsp), %rbx
leaq 0x8(%rsp), %rsi
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x13d54
movq %rbp, %rdi
movq %rbx, %rsi
callq 0x2b9df
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x238(%rdi), %rsi
leaq 0x10(%rdi), %rdx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x1367c
leaq 0x88(%rbx), %rdi
movq %r14, %rsi
callq 0x2bb94
movups 0x10(%rbx), %xmm0
movups 0x238(%rbx), %xmm1
movups %xmm1, 0x10(%rbx)
movups %xmm0, 0x238(%rbx)
leaq 0x248(%rbx), %rsi
leaq 0x40(%rbx), %rdx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x1367c
leaq 0x98(%rbx), %rdi
movq %r14, %rsi
callq 0x2bb94
movups 0x40(%rbx), %xmm0
movups 0x248(%rbx), %xmm1
movups %xmm1, 0x40(%rbx)
movups %xmm0, 0x248(%rbx)
movsd 0x8(%rbx), %xmm2
movsd 0x230(%rbx), %xmm0
subsd %xmm0, %xmm2
movapd 0x3eeeb(%rip), %xmm1    # 0x513d0
andpd %xmm0, %xmm1
addsd 0x4132f(%rip), %xmm1    # 0x53820
divsd %xmm1, %xmm2
movsd %xmm2, 0x8(%rsp)
movsd %xmm0, 0x8(%rbx)
movq %rbx, %rdi
callq 0x1238a
movsd 0x8(%rsp), %xmm0
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
andq $0x0, 0x80(%rdi)
addq $0xa8, %rdi
movq 0x18(%rbx), %rsi
xorl %edx, %edx
callq 0x13d70
leaq 0xc0(%rbx), %rdi
movq 0x18(%rbx), %rsi
xorl %edx, %edx
callq 0x13d70
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, 0xd8(%rbx)
leaq 0xe0(%rbx), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x13d70
leaq 0xf8(%rbx), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x13d70
leaq 0x188(%rbx), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x13d70
leaq 0x1a0(%rbx), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x13d70
leaq 0x1b8(%rbx), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x13d70
leaq 0x110(%rbx), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x13d70
leaq 0x128(%rbx), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x13d70
leaq 0x140(%rbx), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x13d70
leaq 0x158(%rbx), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x13d70
leaq 0x170(%rbx), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x13d70
leaq 0x1e0(%rbx), %rdi
callq 0x13de8
movabsq $0x7ff0000000000000, %rax # imm = 0x7FF0000000000000
movq %rax, 0x230(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x20(%rdi), %r14
leaq 0x10(%rdi), %r15
leaq 0x30(%rdi), %r13
xorl %r12d, %r12d
movq 0x18(%rbx), %rbp
cmpq %rbp, %r12
jge 0x12738
movq %r14, %rdi
movq %r12, %rsi
callq 0x13224
movsd (%rax), %xmm0
movsd %xmm0, (%rsp)
movq %r13, %rdi
movq %r12, %rsi
callq 0x13224
movsd (%rsp), %xmm0
ucomisd (%rax), %xmm0
ja 0x12738
movq %r14, %rdi
movq %r12, %rsi
callq 0x13224
movsd (%rax), %xmm0
movsd %xmm0, (%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x13224
movsd (%rsp), %xmm0
ucomisd (%rax), %xmm0
jbe 0x126de
movq %r14, %rdi
movq %r12, %rsi
callq 0x13224
movsd (%rax), %xmm0
movsd %xmm0, (%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x13224
movsd (%rsp), %xmm0
movsd %xmm0, (%rax)
movq %r13, %rdi
movq %r12, %rsi
callq 0x13224
movsd (%rax), %xmm0
movsd %xmm0, (%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x13224
movsd (%rax), %xmm0
ucomisd (%rsp), %xmm0
jbe 0x12730
movq %r13, %rdi
movq %r12, %rsi
callq 0x13224
movsd (%rax), %xmm0
movsd %xmm0, (%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x13224
movsd (%rsp), %xmm0
movsd %xmm0, (%rax)
incq %r12
jmp 0x12651
cmpq %rbp, %r12
setge %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3e342(%rip), %rsi     # 0x51418
movq %r14, %rdi
callq 0xb7fa
testb %al, %al
je 0x130ec
pushq $0x68
popq %rax
movsd (%rsp), %xmm0
jmp 0x1310f
leaq 0x3e32b(%rip), %rsi     # 0x5141e
movq %r14, %rdi
callq 0xb7fa
testb %al, %al
je 0x13118
movsd (%rsp), %xmm0
mulsd 0x40704(%rip), %xmm0    # 0x53810
pushq $0x70
popq %rax
movsd %xmm0, (%rbx,%rax)
movb $0x1, %al
jmp 0x1311a
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x10, %rsp
cmpb $0x0, 0x79(%rdi)
je 0x1c394
movq %rdi, %rbx
movsd 0x68(%rdi), %xmm0
andpd 0x35095(%rip), %xmm0    # 0x513d0
movapd %xmm0, (%rsp)
callq 0x1c4ac
mulsd (%rsp), %xmm0
movq 0x58(%rbx), %rcx
movq (%rbx), %rdx
movq 0x8(%rbx), %rsi
xorl %eax, %eax
testq %rcx, %rcx
cmovleq %rax, %rcx
leaq 0x8(,%rsi,8), %rsi
movapd 0x35062(%rip), %xmm1    # 0x513d0
subq $0x1, %rcx
jb 0x1c38e
movsd (%rdx), %xmm2
andpd %xmm1, %xmm2
xorl %edi, %edi
ucomisd %xmm0, %xmm2
seta %dil
addq %rdi, %rax
addq %rsi, %rdx
jmp 0x1c36e
addq $0x10, %rsp
popq %rbx
retq
leaq 0x3de75(%rip), %rdi     # 0x5a210
leaq 0x3c30c(%rip), %rsi     # 0x586ae
leaq 0x3e1c7(%rip), %rcx     # 0x5a570
movl $0x14f, %edx            # imm = 0x14F
callq 0x9210
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
movb 0x7a(%rdi), %al
cmpb $0x0, 0x79(%rdi)
jne 0x1c4b9
testb $0x1, %al
je 0x1c4e0
testb $0x1, %al
je 0x1c4c3
movsd 0x70(%rdi), %xmm0
retq
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rcx
cmpq %rax, %rcx
cmovlq %rcx, %rax
cvtsi2sd %rax, %xmm0
mulsd 0x37331(%rip), %xmm0    # 0x53810
retq
pushq %rax
leaq 0x3e0f9(%rip), %rdi     # 0x5a5e1
leaq 0x3c1bf(%rip), %rsi     # 0x586ae
leaq 0x3e117(%rip), %rcx     # 0x5a60d
movl $0x13f, %edx            # imm = 0x13F
callq 0x9210
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, 0x8(%rsp)
cmpq $0x0, (%rsi)
jne 0x2cb50
leaq 0x8(%rbx), %rdi
leaq 0x8(%rsp), %r14
movq %r14, %rsi
callq 0x2dde8
movq (%r14), %rsi
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
movq (%r14), %r14
movq 0x70(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x70(%rbx)
movl %eax, 0x28(%r14)
pushq $0x10
popq %r15
movq (%r14), %r14
testq %r14, %r14
je 0x2cbc9
movq (%r14), %r12
cmpq $0x0, 0x30(%r12)
jne 0x2cb82
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2cb12
addq $0x30, %r12
movq %r12, %r13
movq (%r12), %rax
leaq 0x8(%rax), %r12
testq %rax, %rax
jne 0x2cb86
movq %r15, %rdi
callq 0x9340
movq %rax, %r12
movq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x38f0c
movq %r12, (%r13)
movq 0x8(%rsp), %rsi
movq (%r14), %rdx
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x20(%rax)
addq $0x8, %r14
jmp 0x2cb64
addq $0x20, %rbx
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x2de6e
movq %rax, %rdi
callq 0x2debe
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
pushq $0x10
popq %rsi
movq %r12, %rdi
callq 0x9350
movq %rbx, %rdi
callq 0x9640
// File: /workspace/github_cpp_makefile_star2_O2/canzarlab[P]Trajan/src/Graph.cpp
// Function: LDAG::LDAG(char const*, char const*)
LDAG::LDAG(const char* f1, const char* f2) : DAG(f1, f2)
{
    size_t SZ = _n * 2 + 2;
    G.resize(SZ);
    for (int j = 0; j < NR_THREADS; ++j)
        R[j].resize(SZ, vd(SZ));

    int S = SZ - 2, T = SZ - 1;
    for (int i = 0; i < _n; ++i)
    {
        G[S].push_back(i);
        G[i].push_back(S);
        G[T].push_back(i + _n);
        G[i + _n].push_back(T);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
callq 0x2ca88
leaq 0x6870d(%rip), %rax     # 0x95330
movq %rax, (%rbx)
leaq 0x78(%rbx), %r14
movl $0x90, %edx
movq %r14, %rdi
xorl %esi, %esi
callq 0x91d0
movq 0x70(%rbx), %r12
leaq 0x2(,%r12,2), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x2dbfc
leaq 0x90(%rbx), %rbp
addq %r12, %r12
movq %r12, 0x18(%rsp)
xorl %r13d, %r13d
leaq 0x20(%rsp), %r12
cmpq $0x60, %r13
je 0x2cc9c
movq %r12, %rdi
movq %r15, %rsi
leaq 0x10(%rsp), %rdx
callq 0x2dc6e
movq %rbp, %rdi
addq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x2dc32
movq %r12, %rdi
callq 0x2e522
addq $0x18, %r13
jmp 0x2cc67
leaq 0x20(%rsp), %r15
movq 0x18(%rsp), %rax
movl %eax, (%r15)
orl $0x1, %eax
leaq 0x10(%rsp), %r12
movl %eax, (%r12)
xorl %eax, %eax
leaq 0xc(%rsp), %r13
leaq 0x14(%rsp), %rbp
movl %eax, 0xc(%rsp)
cltq
cmpq %rax, 0x70(%rbx)
jle 0x2cd3a
movslq 0x20(%rsp), %rax
imulq $0x18, %rax, %rdi
addq (%r14), %rdi
movq %r13, %rsi
callq 0x2dcc0
movslq 0xc(%rsp), %rax
imulq $0x18, %rax, %rdi
addq (%r14), %rdi
movq %r15, %rsi
callq 0x2dcc0
movslq 0x10(%rsp), %rax
imulq $0x18, %rax, %rdi
addq 0x78(%rbx), %rdi
movl 0xc(%rsp), %eax
addl 0x70(%rbx), %eax
movl %eax, 0x14(%rsp)
movq %rbp, %rsi
callq 0x2ec6a
movslq 0xc(%rsp), %rax
imulq $0x18, 0x70(%rbx), %rcx
addq 0x78(%rbx), %rcx
imulq $0x18, %rax, %rdi
addq %rcx, %rdi
movq %r12, %rsi
callq 0x2dcc0
movl 0xc(%rsp), %eax
incl %eax
jmp 0x2ccc1
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2cd5e
jmp 0x2cd5e
jmp 0x2cd5e
movq %rax, %r15
leaq 0x20(%rsp), %rdi
callq 0x2e522
jmp 0x2cd61
movq %rax, %r15
leaq 0xf0(%rbx), %rdi
callq 0x2dcde
movl $0xd8, %r12d
leaq (%rbx,%r12), %rdi
callq 0x2dd00
addq $-0x18, %r12
cmpq $0x78, %r12
jne 0x2cd73
movq %r14, %rdi
callq 0x2dd22
movq %rbx, %rdi
callq 0xbcfe
movq %r15, %rdi
callq 0x9640
// File: /workspace/github_cpp_makefile_star2_O2/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 0x20(%rsp), %rdi
leaq 0x8(%rsp), %rdx
movq %r14, %rsi
callq 0x2dd44
leaq 0x50(%rbx), %rdi
leaq 0x20(%rsp), %rdx
movq %r14, %rsi
callq 0x2de32
leaq 0x20(%rsp), %rdi
callq 0xbdb2
movq 0x70(%rbx), %r14
leaq 0x20(%rsp), %rdi
leaq 0x7(%rsp), %rdx
movq %r14, %rsi
callq 0x2dd44
leaq 0x8(%rsp), %rdi
leaq 0x20(%rsp), %rdx
leaq 0x6(%rsp), %rcx
movq %r14, %rsi
callq 0x2dd58
leaq 0x20(%rsp), %rdi
callq 0xbdb2
movq 0x8(%rbx), %r15
movq 0x10(%rbx), %r12
leaq 0x8(%rsp), %r14
cmpq %r12, %r15
je 0x2ce4b
movq (%r15), %rdx
movq %rbx, %rdi
movq %rdx, %rsi
movq %r14, %rcx
callq 0x2d46c
addq $0x8, %r15
jmp 0x2ce2f
leaq 0x8(%rsp), %rdi
callq 0xbd44
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x2ce65
jmp 0x2ce74
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xbdb2
jmp 0x2ce86
movq %rax, %rbx
jmp 0x2ce86
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xbd44
movq %rbx, %rdi
callq 0x9640
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x38, %rsp
movq %rsi, %r14
movq %rdi, %r15
movslq 0x28(%rsi), %rsi
movq %rdx, 0x8(%rsp)
movq %rdx, %rdi
callq 0x2ddae
testq %rdx, (%rax)
je 0x2d265
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movslq 0x28(%r14), %rsi
movq 0x8(%rsp), %rdi
callq 0x2ddae
orq %rdx, (%rax)
leaq 0x10(%rsp), %r12
leaq 0x7(%rsp), %r13
movq %r14, %rbp
movq (%rbp), %rbp
testq %rbp, %rbp
je 0x2d256
movq (%rbp), %rsi
movq %r15, %rdi
movq 0x8(%rsp), %rdx
callq 0x2d22c
movq (%rbp), %rbx
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x2d2d7
movq 0x70(%r15), %rsi
movq %r12, %rdi
movq %r13, %rdx
callq 0x2dd44
movq (%rbx), %rdx
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rcx
callq 0x2d3d2
movq %r12, %rdi
callq 0xbdb2
addq $0x8, %rbx
jmp 0x2d2a1
addq $0x8, %rbp
jmp 0x2d283
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xbdb2
movq %rbx, %rdi
callq 0x9640
// File: /workspace/github_cpp_makefile_star2_O2/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
movq %rsi, %rbx
movq %rdi, %r14
orl $-0x1, 0x28(%rsi)
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x2d31f
movq (%rbx), %rsi
cmpl $-0x1, 0x28(%rsi)
je 0x2d319
movq %r14, %rdi
callq 0x2d2f2
addq $0x8, %rbx
jmp 0x2d300
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rsi, %rbx
movq %rdi, %r14
movq 0x70(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x70(%rdi)
movl %eax, 0x28(%rsi)
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x2d360
movq (%rbx), %rsi
cmpl $-0x1, 0x28(%rsi)
jne 0x2d35a
movq %r14, %rdi
callq 0x2d328
addq $0x8, %rbx
jmp 0x2d341
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rdi, %r14
leaq 0x8(%rsp), %r15
movq %rsi, (%r15)
movq %rdx, %rdi
movq %r15, %rsi
callq 0x2dde8
movq (%r15), %r15
cmpq $0x0, (%r15)
jne 0x2d3bb
leaq 0xf0(%r14), %rdi
movq %rbx, %rsi
callq 0x2de06
movq 0x8(%rsp), %r15
jmp 0x2d3bb
movq (%r15), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x2d368
addq $0x8, %r15
movq (%r15), %r15
testq %r15, %r15
jne 0x2d3a9
addq $-0x8, 0x8(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movslq 0x28(%rdx), %rsi
movq %rcx, %rdi
callq 0x2ddae
orq %rdx, (%rax)
movq %r15, %rsi
movq %r14, %rdx
callq 0x2d44c
leaq 0x30(%r14), %rsi
movq %r15, %rdx
callq 0x2d44c
movq (%r14), %r14
testq %r14, %r14
je 0x2d43f
movq (%r14), %rax
movslq 0x28(%rax), %rsi
movq %rbx, %rdi
callq 0x2ddae
testq %rdx, (%rax)
jne 0x2d439
movq (%r14), %rdx
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rcx
callq 0x2d3d2
addq $0x8, %r14
jmp 0x2d40c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2d46a
leaq 0x8(%rax), %rcx
cmpq %rdx, (%rax)
jne 0x2d465
movq (%rcx), %rax
movq %rax, (%rsi)
jmp 0x2d44f
movq %rcx, %rsi
jmp 0x2d44c
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x18, %rsp
movq %rcx, %rbx
movq %rsi, %r15
movq %rdi, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movslq 0x28(%rdx), %r13
movslq 0x28(%rsi), %r14
cmpl %r14d, %r13d
je 0x2d4c0
imulq $0x28, %r13, %rdi
movq 0x8(%rsp), %r12
addq 0x50(%r12), %rdi
movq %r14, %rsi
callq 0x2ddae
orq %rdx, (%rax)
movq (%r12), %rax
movq %r12, %rdi
movl %r13d, %esi
movl %r14d, %edx
callq *0x28(%rax)
imulq $0x28, %r14, %rdi
addq (%rbx), %rdi
movq %r13, %rsi
callq 0x2ddae
orq %rdx, (%rax)
addq $0x30, %r15
movq (%r15), %r15
testq %r15, %r15
je 0x2d53d
movq (%r15), %rbp
movslq 0x28(%rbp), %r14
imulq $0x28, %r14, %r12
movq (%rbx), %rdi
addq %r12, %rdi
movq %r13, %rsi
callq 0x2ddae
testq %rdx, (%rax)
jne 0x2d511
movq 0x8(%rsp), %rdi
movq %rbp, %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rcx
callq 0x2d46c
addq (%rbx), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x2ddae
testq %rdx, (%rax)
jne 0x2d537
movq 0x8(%rsp), %rdi
movq %rbp, %rsi
movq %rbp, %rdx
movq %rbx, %rcx
callq 0x2d46c
addq $0x8, %r15
jmp 0x2d4d6
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq