LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/bonetblai[P]mdp-engine/ctp3/../engine/base_policies.h
// Function: Online::Policy::hash_policy_t<state_t>::operator()(state_t const&) const
virtual Problem::action_t operator()(const T &s) const {
        assert(hash_ != 0);
        ++policy_t<T>::decisions_;
        std::pair<Problem::action_t, float> p = hash_->best_q_value(s);
        assert(problem_.applicable(s, p.first));
        return p.first;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r15
movq 0x28(%rdi), %rdi
testq %rdi, %rdi
je 0x19c8b
movq %rsi, %rbx
incl 0x20(%r15)
callq 0xf8b0
movq %rax, %r14
movq 0x8(%r15), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
movl %r14d, %edx
callq *0x30(%rax)
testb %al, %al
je 0x19caa
movl %r14d, %eax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x123ef(%rip), %rdi     # 0x2c081
leaq 0x123f3(%rip), %rsi     # 0x2c08c
leaq 0x12406(%rip), %rcx     # 0x2c0a6
movl $0x5b, %edx
callq 0x51c0
leaq 0x12461(%rip), %rdi     # 0x2c112
leaq 0x123d4(%rip), %rsi     # 0x2c08c
leaq 0x123e7(%rip), %rcx     # 0x2c0a6
movl $0x5e, %edx
callq 0x51c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/bonetblai[P]mdp-engine/ctp3/../engine/base_policies.h
// Function: Online::Policy::optimal_policy_t<state_t>::solve_problem()
void solve_problem() {
        if( algorithm_ == 0 ) {
            std::cout << Utils::error() << "algorithm must be specified for optimal() policy!" << std::endl;
            exit(1);
        }
#ifdef DEBUG
        std::cout << "debug: optimal(): solving problem with algorithm=" << algorithm_->name() << std::endl;
#endif
        float start_time = Utils::read_time_in_seconds();
        algorithm_->solve(problem_.init(), *hash_);
        policy_t<T>::setup_time_ = Utils::read_time_in_seconds() - start_time;
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x98, %rsp
cmpq $0x0, 0x30(%rdi)
je 0x1a08a
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
xorl %edi, %edi
movq %r14, %rsi
callq 0x5190
cvtsi2ssq (%r14), %xmm0
movss %xmm0, (%rsp)
xorps %xmm0, %xmm0
cvtsi2ssq 0x8(%r14), %xmm0
movss %xmm0, 0x4(%rsp)
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movq %r14, %rsi
callq 0x5190
xorps %xmm0, %xmm0
cvtsi2ssq (%r14), %xmm0
addss (%rsp), %xmm0
movss %xmm0, (%rsp)
xorps %xmm0, %xmm0
cvtsi2ssq 0x8(%r14), %xmm0
addss 0x4(%rsp), %xmm0
movss %xmm0, 0x4(%rsp)
movq 0x8(%rbx), %rdi
movq 0x30(%rbx), %r14
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x28(%rbx), %rdx
movq (%r14), %rcx
movq %r14, %rdi
movq %rax, %rsi
callq *0x28(%rcx)
leaq 0x8(%rsp), %r14
xorl %edi, %edi
movq %r14, %rsi
callq 0x5190
xorps %xmm0, %xmm0
cvtsi2ssq (%r14), %xmm0
subss (%rsp), %xmm0
movss %xmm0, (%rsp)
xorps %xmm0, %xmm0
cvtsi2ssq 0x8(%r14), %xmm0
subss 0x4(%rsp), %xmm0
movss %xmm0, 0x4(%rsp)
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movq %r14, %rsi
callq 0x5190
xorps %xmm0, %xmm0
cvtsi2ssq (%r14), %xmm0
addss (%rsp), %xmm0
cvtsi2ssq 0x8(%r14), %xmm1
addss 0x4(%rsp), %xmm1
mulss 0x10f8e(%rip), %xmm1    # 0x2b004
addss %xmm0, %xmm1
movss %xmm1, 0x14(%rbx)
addq $0x98, %rsp
popq %rbx
popq %r14
retq
movb 0x231c8(%rip), %al      # 0x3d258
testb %al, %al
leaq 0x1195b(%rip), %rcx     # 0x2b9f4
leaq 0x11ec2(%rip), %rsi     # 0x2bf62
cmovneq %rcx, %rsi
leaq 0x12(%rsi), %rdx
testb %al, %al
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
cmoveq %rsi, %rdx
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xd386
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq 0x22f06(%rip), %rdi     # 0x3cfd8
callq 0x52e0
movq %rax, %rbx
leaq 0x12051(%rip), %rsi     # 0x2c132
movl $0x31, %edx
movq %rax, %rdi
callq 0x52e0
movq %rbx, %rdi
callq 0x5150
leaq 0x8(%rsp), %rdi
callq 0x5140
movl $0x1, %edi
callq 0x5310
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x1a11c
callq 0x5260
movq %rbx, %rdi
callq 0x5410
// File: /workspace/github_cpp_makefile_star2_O3/bonetblai[P]mdp-engine/ctp3/../engine/rollout.h
// Function: Online::Policy::Rollout::nested_rollout_t<state_t>::print_other_stats(std::ostream&, int) const
virtual void print_other_stats(std::ostream &os, int indent) const {
        os << std::setw(indent) << ""
           << "other-stats: name=" << name() << std::endl;
        for( int i = 0; i < int(nested_policies_.size()); ++i )
            nested_policies_[i]->print_other_stats(os, 2 + indent);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq (%rsi), %rax
movq -0x18(%rax), %rax
movslq %edx, %rcx
movq %rcx, 0x10(%rsi,%rax)
leaq 0xfd05(%rip), %rsi      # 0x2bf62
movq %r14, %rdi
xorl %edx, %edx
callq 0x52e0
leaq 0xf38e(%rip), %rsi      # 0x2b5fc
movl $0x12, %edx
movq %r14, %rdi
callq 0x52e0
movq (%r15), %rax
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq *0x18(%rax)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %r14, %rdi
callq 0x52e0
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x5270
movsbl %al, %esi
movq %r12, %rdi
callq 0x5040
movq %rax, %rdi
callq 0x51e0
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1c2da
callq 0x5260
movq 0x30(%r15), %rax
movq 0x38(%r15), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
testl %ecx, %ecx
jle 0x1c31c
addl $0x2, %ebx
xorl %r12d, %r12d
movq (%rax,%r12,8), %rdi
movq (%rdi), %rax
movq %r14, %rsi
movl %ebx, %edx
callq *0x30(%rax)
incq %r12
movq 0x30(%r15), %rax
movq 0x38(%r15), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
movslq %ecx, %rcx
cmpq %rcx, %r12
jl 0x1c2f3
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1c33e
callq 0x5260
movq %rbx, %rdi
callq 0x5410
// File: /workspace/github_cpp_makefile_star2_O3/bonetblai[P]mdp-engine/ctp3/../engine/rollout.h
// Function: Online::Policy::Rollout::nested_rollout_t<state_t>::make_nested_policies()
void make_nested_policies() {
        if( base_policy_ == 0 ) {
            std::cout << Utils::error() << "(base) policy must be specified for nested-rollout() policy!" << std::endl;
            exit(1);
        }
        nested_policies_.reserve(1 + nesting_);
        nested_policies_.push_back(base_policy_->clone());
        for( unsigned level = 0; level < nesting_; ++level ) {
            const policy_t<T> *policy = nested_policies_.back();
            policy_t<T> *rollout = new Rollout::rollout_t<T>(problem_, policy, width_, depth_, 1 + level);
            nested_policies_.push_back(rollout);
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
cmpq $0x0, 0x28(%rdi)
je 0x1c6bb
movq %rdi, %rbx
leaq 0x30(%rdi), %r14
movl 0x50(%rdi), %esi
incl %esi
movq %r14, %rdi
callq 0x1c756
movq 0x28(%rbx), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, 0x8(%rsp)
movq 0x38(%rbx), %rsi
cmpq 0x40(%rbx), %rsi
movq %r14, (%rsp)
je 0x1c61e
movq %rax, (%rsi)
addq $0x8, 0x38(%rbx)
jmp 0x1c62b
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
callq 0x1c804
movl 0x50(%rbx), %r13d
testl %r13d, %r13d
je 0x1c6ac
xorl %ebp, %ebp
leaq 0x2039b(%rip), %r15     # 0x3c9d8
movq 0x38(%rbx), %r12
movq -0x8(%r12), %r14
movl $0x40, %edi
callq 0x5290
movq 0x8(%rbx), %rcx
incl %ebp
movq %rcx, 0x8(%rax)
movl 0x20c60(%rip), %ecx     # 0x3d2c0
movl %ecx, 0x10(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x14(%rax)
movq %r14, 0x28(%rax)
movq %r15, (%rax)
movq 0x48(%rbx), %rcx
movq %rcx, 0x30(%rax)
movl %ebp, 0x38(%rax)
movq %rax, 0x8(%rsp)
cmpq 0x40(%rbx), %r12
je 0x1c692
movq %rax, (%r12)
addq $0x8, 0x38(%rbx)
jmp 0x1c6a7
movq (%rsp), %rdi
movq %r12, %rsi
leaq 0x8(%rsp), %rdx
callq 0x1dd18
movl 0x50(%rbx), %r13d
cmpl %r13d, %ebp
jb 0x1c63d
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movb 0x20b97(%rip), %al      # 0x3d258
testb %al, %al
leaq 0xf32a(%rip), %rcx      # 0x2b9f4
leaq 0xf891(%rip), %rsi      # 0x2bf62
cmovneq %rcx, %rsi
leaq 0x12(%rsi), %rdx
testb %al, %al
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
cmoveq %rsi, %rdx
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xd386
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq 0x208d5(%rip), %rdi     # 0x3cfd8
callq 0x52e0
movq %rax, %rbx
leaq 0xfaa9(%rip), %rsi      # 0x2c1bb
movl $0x3c, %edx
movq %rax, %rdi
callq 0x52e0
movq %rbx, %rdi
callq 0x5150
leaq 0x8(%rsp), %rdi
callq 0x5140
movl $0x1, %edi
callq 0x5310
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x1c74d
callq 0x5260
movq %rbx, %rdi
callq 0x5410
nop
// File: /workspace/github_cpp_makefile_star2_O3/bonetblai[P]mdp-engine/ctp3/../engine/rollout.h
// Function: Online::Policy::Rollout::rollout_t<state_t>::operator()(state_t const&) const
virtual Problem::action_t operator()(const T &s) const {
        ++policy_t<T>::decisions_;
        Problem::action_t best_action = Problem::noop;
        float best_value = std::numeric_limits<float>::max();
        for( Problem::action_t a = 0; a < problem_.number_actions(s); ++a ) {
            if( problem_.applicable(s, a) ) {
                float value = 0;
                for( unsigned trial = 0; trial < width_; ++trial ) {
                    std::pair<T, bool> p = problem_.sample(s, a);
                    value += problem_.cost(s, a) + problem_.discount() * evaluate(p.first);
                }
                value /= width_;
                if( value < best_value ) {
                    best_value = value;
                    best_action = a;
                }
            }
        }
        assert(best_action != Problem::noop);
        return best_action;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
incl 0x20(%rdi)
movq %rsi, %r14
movq 0x8(%rdi), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
testl %eax, %eax
jle 0x1d5b4
xorl %r15d, %r15d
movss 0xdb89(%rip), %xmm0     # 0x2b014
movss %xmm0, 0xc(%rsp)
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
leaq 0x20(%rsp), %r12
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
movq %r14, %rsi
movl %r15d, %edx
callq *0x30(%rax)
testb %al, %al
je 0x1d582
cmpl $0x0, 0x30(%rbx)
movss 0xdb5d(%rip), %xmm1     # 0x2b01c
je 0x1d56b
xorps %xmm1, %xmm1
xorl %r13d, %r13d
movss %xmm1, 0x1c(%rsp)
movq 0x8(%rbx), %rsi
movq %r12, %rdi
movq %r14, %rdx
movl %r15d, %ecx
callq 0xcea2
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
movq %r14, %rsi
movl %r15d, %edx
callq *0x48(%rax)
movss %xmm0, 0x18(%rsp)
movq 0x8(%rbx), %rax
movss 0x8(%rax), %xmm0
movss %xmm0, 0x14(%rsp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1d91c
cmpb $0x0, 0x7c(%rsp)
jne 0x1d538
movq 0x80(%rsp), %rdi
testq %rdi, %rdi
je 0x1d538
movss %xmm0, 0x10(%rsp)
callq 0x5340
movss 0x10(%rsp), %xmm0
mulss 0x14(%rsp), %xmm0
movss 0x1c(%rsp), %xmm1
addss 0x18(%rsp), %xmm1
addss %xmm0, %xmm1
incl %r13d
movl 0x30(%rbx), %eax
cmpl %eax, %r13d
jb 0x1d4cb
movl %eax, %eax
xorps %xmm0, %xmm0
cvtsi2ss %rax, %xmm0
divss %xmm0, %xmm1
movss 0xc(%rsp), %xmm0
ucomiss %xmm0, %xmm1
minss %xmm1, %xmm0
movss %xmm0, 0xc(%rsp)
cmovbl %r15d, %ebp
incl %r15d
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x10(%rax)
cmpl %eax, %r15d
jl 0x1d49b
cmpl $-0x1, %ebp
je 0x1d5b4
movl %ebp, %eax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xec57(%rip), %rdi      # 0x2c212
leaq 0xec6d(%rip), %rsi      # 0x2c22f
leaq 0xec7a(%rip), %rcx      # 0x2c243
movl $0x5b, %edx
callq 0x51c0
movq %rax, %rbx
cmpb $0x0, 0x7c(%rsp)
jne 0x1d5ef
movq 0x80(%rsp), %rdi
testq %rdi, %rdi
je 0x1d5ef
callq 0x5340
movq %rbx, %rdi
callq 0x5410
nop
// File: /workspace/github_cpp_makefile_star2_O3/bonetblai[P]mdp-engine/ctp3/../engine/rollout.h
// Function: Online::Policy::Rollout::rollout_t<state_t>::reset_stats() const
virtual void reset_stats() const {
        policy_t<T>::setup_time_ = 0;
        policy_t<T>::base_policy_time_ = 0;
        policy_t<T>::heuristic_time_ = 0;
        problem_.clear_expansions();
        if( base_policy_ != 0 ) base_policy_->reset_stats();
    }

// Assembly:
xorl %eax, %eax
movq %rax, 0x14(%rdi)
movl $0x0, 0x1c(%rdi)
movq 0x8(%rdi), %rcx
movq %rax, 0x10(%rcx)
movq 0x28(%rdi), %rdi
testq %rdi, %rdi
je 0x1d61c
movq (%rdi), %rax
jmpq *0x28(%rax)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/bonetblai[P]mdp-engine/ctp3/../engine/rollout.h
// Function: Online::Policy::Rollout::rollout_t<state_t>::print_other_stats(std::ostream&, int) const
virtual void print_other_stats(std::ostream &os, int indent) const {
        os << std::setw(indent) << ""
           << "other-stats: name=" << name()
           << " decisions=" << policy_t<T>::decisions_
           << std::endl;
        if( base_policy_ != 0 ) base_policy_->print_other_stats(os, 2 + indent);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq (%rsi), %rax
movq -0x18(%rax), %rax
movslq %edx, %rcx
movq %rcx, 0x10(%rsi,%rax)
leaq 0xe91b(%rip), %rsi      # 0x2bf62
movq %r14, %rdi
xorl %edx, %edx
callq 0x52e0
leaq 0xdfa4(%rip), %rsi      # 0x2b5fc
movl $0x12, %edx
movq %r14, %rdi
callq 0x52e0
movq (%r15), %rax
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq *0x18(%rax)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %r14, %rdi
callq 0x52e0
movq %rax, %r12
leaq 0xdf7e(%rip), %rsi      # 0x2b60f
movl $0xb, %edx
movq %rax, %rdi
callq 0x52e0
movl 0x20(%r15), %esi
movq %r12, %rdi
callq 0x51d0
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x5270
movsbl %al, %esi
movq %r12, %rdi
callq 0x5040
movq %rax, %rdi
callq 0x51e0
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1d6e7
callq 0x5260
movq 0x28(%r15), %rdi
testq %rdi, %rdi
je 0x1d6fe
addl $0x2, %ebx
movq (%rdi), %rax
movq %r14, %rsi
movl %ebx, %edx
callq *0x30(%rax)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1d720
callq 0x5260
movq %rbx, %rdi
callq 0x5410
// File: /workspace/github_cpp_makefile_star2_O3/bonetblai[P]mdp-engine/ctp3/../engine/rollout.h
// Function: Online::Policy::Rollout::rollout_t<state_t>::evaluate(state_t const&) const
float evaluate(const T &s) const {
        if( base_policy_ == 0 ) {
            std::cout << Utils::error() << "(base) policy must be specified for rollout() policy!" << std::endl;
            exit(1);
        }
        float start_time = Utils::read_time_in_seconds();
        float value = Evaluation::evaluation(*base_policy_, s, 1, depth_);
        policy_t<T>::base_policy_time_ += Utils::read_time_in_seconds() - start_time;
        return value;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xa0, %rsp
cmpq $0x0, 0x28(%rdi)
je 0x1da35
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
xorl %edi, %edi
movq %r15, %rsi
callq 0x5190
cvtsi2ssq (%r15), %xmm0
movss %xmm0, 0x4(%rsp)
xorps %xmm0, %xmm0
cvtsi2ssq 0x8(%r15), %xmm0
movss %xmm0, 0xc(%rsp)
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movq %r15, %rsi
callq 0x5190
cvtsi2ssq (%r15), %xmm1
xorps %xmm0, %xmm0
cvtsi2ssq 0x8(%r15), %xmm0
addss 0x4(%rsp), %xmm1
movss %xmm1, 0x8(%rsp)
addss 0xc(%rsp), %xmm0
movss %xmm0, 0x4(%rsp)
movq 0x28(%rbx), %rdi
movl 0x34(%rbx), %edx
movq %r14, %rsi
callq 0x1dacf
movss %xmm0, 0xc(%rsp)
leaq 0x10(%rsp), %r14
xorl %edi, %edi
movq %r14, %rsi
callq 0x5190
xorps %xmm0, %xmm0
cvtsi2ssq (%r14), %xmm0
subss 0x8(%rsp), %xmm0
movss %xmm0, 0x8(%rsp)
xorps %xmm0, %xmm0
cvtsi2ssq 0x8(%r14), %xmm0
subss 0x4(%rsp), %xmm0
movss %xmm0, 0x4(%rsp)
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movq %r14, %rsi
callq 0x5190
xorps %xmm0, %xmm0
cvtsi2ssq (%r14), %xmm0
addss 0x8(%rsp), %xmm0
xorps %xmm1, %xmm1
cvtsi2ssq 0x8(%r14), %xmm1
addss 0x4(%rsp), %xmm1
mulss 0xd5f0(%rip), %xmm1     # 0x2b004
addss 0x18(%rbx), %xmm0
addss %xmm1, %xmm0
movss %xmm0, 0x18(%rbx)
movss 0xc(%rsp), %xmm0
addq $0xa0, %rsp
popq %rbx
popq %r14
popq %r15
retq
movb 0x1f81d(%rip), %al      # 0x3d258
testb %al, %al
leaq 0xdfb0(%rip), %rcx      # 0x2b9f4
leaq 0xe517(%rip), %rsi      # 0x2bf62
cmovneq %rcx, %rsi
leaq 0x12(%rsi), %rdx
testb %al, %al
leaq 0x20(%rsp), %r14
movq %r14, -0x10(%r14)
cmoveq %rsi, %rdx
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0xd386
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq 0x1f55b(%rip), %rdi     # 0x3cfd8
callq 0x52e0
movq %rax, %rbx
leaq 0xe828(%rip), %rsi      # 0x2c2b4
movl $0x35, %edx
movq %rax, %rdi
callq 0x52e0
movq %rbx, %rdi
callq 0x5150
leaq 0x10(%rsp), %rdi
callq 0x5140
movl $0x1, %edi
callq 0x5310
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x1dac7
callq 0x5260
movq %rbx, %rdi
callq 0x5410
// File: /workspace/github_cpp_makefile_star2_O3/bonetblai[P]mdp-engine/ctp3/../engine/uct.h
// Function: Online::Policy::UCT::uct_t<state_t>::evaluate(state_t const&, unsigned int) const
float evaluate(const T &s, unsigned depth) const {
        assert(base_policy_ != 0);
        float start_time = Utils::read_time_in_seconds();
        float value = Evaluation::evaluation(*base_policy_, s, 1, horizon_ - depth);
        policy_t<T>::base_policy_time_ += Utils::read_time_in_seconds() - start_time;
        return value;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xa8, %rsp
cmpq $0x0, 0x28(%rdi)
je 0x1fe6b
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %r15
xorl %edi, %edi
movq %r15, %rsi
callq 0x5190
cvtsi2ssq (%r15), %xmm0
movss %xmm0, 0xc(%rsp)
xorps %xmm0, %xmm0
cvtsi2ssq 0x8(%r15), %xmm0
movss %xmm0, 0x14(%rsp)
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movq %r15, %rsi
callq 0x5190
xorps %xmm0, %xmm0
cvtsi2ssq (%r15), %xmm0
addss 0xc(%rsp), %xmm0
movss %xmm0, 0x10(%rsp)
xorps %xmm0, %xmm0
cvtsi2ssq 0x8(%r15), %xmm0
addss 0x14(%rsp), %xmm0
movss %xmm0, 0xc(%rsp)
movq 0x28(%rbx), %rdi
movl 0x34(%rbx), %edx
subl %ebp, %edx
movq %r14, %rsi
callq 0x1dacf
movss %xmm0, 0x14(%rsp)
leaq 0x18(%rsp), %r14
xorl %edi, %edi
movq %r14, %rsi
callq 0x5190
xorps %xmm0, %xmm0
cvtsi2ssq (%r14), %xmm0
subss 0x10(%rsp), %xmm0
movss %xmm0, 0x10(%rsp)
xorps %xmm0, %xmm0
cvtsi2ssq 0x8(%r14), %xmm0
subss 0xc(%rsp), %xmm0
movss %xmm0, 0xc(%rsp)
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movq %r14, %rsi
callq 0x5190
xorps %xmm0, %xmm0
cvtsi2ssq (%r14), %xmm0
addss 0x10(%rsp), %xmm0
cvtsi2ssq 0x8(%r14), %xmm1
addss 0xc(%rsp), %xmm1
mulss 0xb1bb(%rip), %xmm1     # 0x2b004
addss 0x18(%rbx), %xmm0
addss %xmm1, %xmm0
movss %xmm0, 0x18(%rbx)
movss 0x14(%rsp), %xmm0
addq $0xa8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0xc7c9(%rip), %rdi      # 0x2c63b
leaq 0xc6f9(%rip), %rsi      # 0x2c572
leaq 0xc7cd(%rip), %rcx      # 0x2c64d
movl $0x141, %edx            # imm = 0x141
callq 0x51c0
// File: /workspace/github_cpp_makefile_star2_O3/bonetblai[P]mdp-engine/ctp3/../engine/bdd_priority_queue.h
// Function: std::bdd_priority_queue<Online::Policy::AOT::node_t<state_t>*, Online::Policy::AOT::min_priority_t<state_t>, Online::Policy::AOT::max_priority_t<state_t>>::~bdd_priority_queue()
~bdd_priority_queue() {
        clear();
        while( pool_ != 0 ) {
            container_t *p = pool_->next_;
            delete pool_;
            pool_ = p;
        }
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x22e88
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x204a4
movq 0x10(%rdi), %r14
callq 0x5260
movq %r14, 0x8(%rbx)
movq %r14, %rdi
testq %r14, %r14
jne 0x2048f
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x204b2
callq 0x5260
movq 0x20(%rbx), %rdi
addq $0x8, %rsp
testq %rdi, %rdi
je 0x204c7
popq %rbx
popq %r14
jmp 0x5260
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0x9d80
nop
// File: /workspace/github_cpp_makefile_star2_O3/bonetblai[P]mdp-engine/ctp3/../engine/aot.h
// Function: Online::Policy::AOT::aot_t<state_t>::clone() const
virtual policy_t<T>* clone() const {
        return new aot_t(problem_,
                         base_policy_,
                         width_,
                         horizon_,
                         probability_,
                         random_ties_,
                         delayed_evaluation_,
                         expansions_per_iteration_,
                         leaf_nsamples_,
                         delayed_evaluation_nsamples_,
                         leaf_selection_strategy_);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movl $0x1b8, %edi            # imm = 0x1B8
callq 0x5290
movq %rax, %rbx
movq 0x8(%r14), %rsi
movq 0x28(%r14), %rdx
movl 0x30(%r14), %ecx
movl 0x34(%r14), %r8d
movss 0x38(%r14), %xmm0
movzbl 0x3c(%r14), %r9d
movzbl 0x3d(%r14), %eax
movl 0x40(%r14), %r10d
movl 0x44(%r14), %r11d
movl 0x48(%r14), %r15d
movl 0x4c(%r14), %r14d
subq $0x8, %rsp
movq %rbx, %rdi
pushq %r14
pushq %r15
pushq %r11
pushq %r10
pushq %rax
callq 0x24d50
addq $0x30, %rsp
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x5260
movq %r14, %rdi
callq 0x5410
// File: /workspace/github_cpp_makefile_star2_O3/bonetblai[P]mdp-engine/ctp3/../engine/aot.h
// Function: Online::Policy::AOT::aot_t<state_t>::reset_stats() const
virtual void reset_stats() const {
        policy_t<T>::setup_time_ = 0;
        policy_t<T>::base_policy_time_ = 0;
        policy_t<T>::heuristic_time_ = 0;
        problem_.clear_expansions();
        if( base_policy_ != 0 ) base_policy_->reset_stats();
        if( heuristic_ != 0 ) heuristic_->reset_stats();
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
xorl %eax, %eax
movq %rax, 0x14(%rdi)
movl $0x0, 0x1c(%rdi)
movq 0x8(%rdi), %rcx
movq %rax, 0x10(%rcx)
movq 0x28(%rdi), %rdi
testq %rdi, %rdi
je 0x22550
movq (%rdi), %rax
callq *0x28(%rax)
movq 0x98(%rbx), %rax
testq %rax, %rax
je 0x2256b
movq $0x0, 0x10(%rax)
movl $0x0, 0x18(%rax)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/bonetblai[P]mdp-engine/ctp3/../engine/aot.h
// Function: Online::Policy::AOT::aot_t<state_t>::print_other_stats(std::ostream&, int) const
virtual void print_other_stats(std::ostream &os, int indent) const {
        os << std::setw(indent) << ""
           << "other-stats: name=" << name()
           << " decisions=" << policy_t<T>::decisions_
           << " %in=" << from_inside_ / (from_inside_ + from_outside_)
           << " %out=" << from_outside_ / (from_inside_ + from_outside_)
           << " #expansions=" << total_number_expansions_
           << " #evaluations=" << total_evaluations_
           << std::endl;
        if( base_policy_ != 0 ) base_policy_->print_other_stats(os, 2 + indent);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq (%rsi), %rax
movq -0x18(%rax), %rax
movslq %edx, %rcx
movq %rcx, 0x10(%rsi,%rax)
leaq 0x99cb(%rip), %rsi      # 0x2bf62
movq %r14, %rdi
xorl %edx, %edx
callq 0x52e0
leaq 0x9054(%rip), %rsi      # 0x2b5fc
movl $0x12, %edx
movq %r14, %rdi
callq 0x52e0
movq (%r15), %rax
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq *0x18(%rax)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %r14, %rdi
callq 0x52e0
movq %rax, %r12
leaq 0x902e(%rip), %rsi      # 0x2b60f
movl $0xb, %edx
movq %rax, %rdi
callq 0x52e0
movl 0x20(%r15), %esi
movq %r12, %rdi
callq 0x51d0
movq %rax, %r12
leaq 0xb837(%rip), %rsi      # 0x2de3b
movl $0x5, %edx
movq %rax, %rdi
callq 0x52e0
movss 0x150(%r15), %xmm0
movss 0x154(%r15), %xmm1
addss %xmm0, %xmm1
divss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
movq %r12, %rdi
callq 0x53b0
movq %rax, %r12
leaq 0xb800(%rip), %rsi      # 0x2de41
movl $0x6, %edx
movq %rax, %rdi
callq 0x52e0
movss 0x154(%r15), %xmm0
movss 0x150(%r15), %xmm1
addss %xmm0, %xmm1
divss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
movq %r12, %rdi
callq 0x53b0
movq %rax, %r12
leaq 0xb7ca(%rip), %rsi      # 0x2de48
movl $0xd, %edx
movq %rax, %rdi
callq 0x52e0
movl 0x160(%r15), %esi
movq %r12, %rdi
callq 0x51d0
movq %rax, %r12
leaq 0xb7b2(%rip), %rsi      # 0x2de56
movl $0xe, %edx
movq %rax, %rdi
callq 0x52e0
movl 0x164(%r15), %esi
movq %r12, %rdi
callq 0x51d0
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x5270
movsbl %al, %esi
movq %r12, %rdi
callq 0x5040
movq %rax, %rdi
callq 0x51e0
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x226fd
callq 0x5260
movq 0x28(%r15), %rdi
testq %rdi, %rdi
je 0x22714
addl $0x2, %ebx
movq (%rdi), %rax
movq %r14, %rsi
movl %ebx, %edx
callq *0x30(%rax)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x22736
callq 0x5260
movq %rbx, %rdi
callq 0x5410
// File: /workspace/github_cpp_makefile_star2_O3/bonetblai[P]mdp-engine/ctp3/../engine/bdd_priority_queue.h
// Function: std::bdd_priority_queue<Online::Policy::AOT::node_t<state_t>*, Online::Policy::AOT::min_priority_t<state_t>, Online::Policy::AOT::max_priority_t<state_t>>::clear()
void clear() {
        for( unsigned index = 1; index <= max_size_; ++index ) {
            max_array_[index]->next_ = pool_;
            pool_ = max_array_[index];
            max_array_[index] = 0;
        }
        max_size_ = 0;

        memset(&min_array_[0], 0, (1 + capacity_) * sizeof(unsigned));
        min_size_ = 0;

        assert(check());
    }

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x18(%rdi), %ecx
testl %ecx, %ecx
je 0x22ecf
incl %ecx
cmpl $0x3, %ecx
movl $0x2, %eax
cmovael %ecx, %eax
movl $0x1, %ecx
movq 0x8(%rbx), %rdx
movq 0x20(%rbx), %rsi
movq (%rsi,%rcx,8), %rdi
movq %rdx, 0x10(%rdi)
movq (%rsi,%rcx,8), %rdx
movq %rdx, 0x8(%rbx)
movq $0x0, (%rsi,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0x22ea7
xorl %ebp, %ebp
movl %ebp, 0x18(%rbx)
movq 0x40(%rbx), %rdi
movl 0x4(%rbx), %edx
incl %edx
shlq $0x2, %rdx
xorl %esi, %esi
callq 0x5180
movl %ebp, 0x38(%rbx)
movq %rbx, %rdi
callq 0x22f62
testb %al, %al
je 0x22f0a
movq %rbx, %rdi
callq 0x23052
testb %al, %al
je 0x22f0a
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x985e(%rip), %rdi      # 0x2c76f
leaq 0x985f(%rip), %rsi      # 0x2c777
leaq 0x9877(%rip), %rcx      # 0x2c796
movl $0x12f, %edx            # imm = 0x12F
callq 0x51c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/bonetblai[P]mdp-engine/ctp3/../engine/bdd_priority_queue.h
// Function: std::bdd_priority_queue<Online::Policy::AOT::node_t<state_t>*, Online::Policy::AOT::min_priority_t<state_t>, Online::Policy::AOT::max_priority_t<state_t>>::check_max() const
bool check_max() const {
        // check heap property
        for( unsigned index = 1; index <= max_size_; ++index ) {
            if( !check_min_heap_property(index) ) {
                std::cout << "heap property violated at max_array[index=" << index << "]" << std::endl;
                return false;
            }
        }

        // check invariants for xrefs
        for( unsigned index = 1; index <= max_size_; ++index ) {
            if( !check_max_invariant(index) ) {
                std::cout << "invariant violated for max_array[index=" << index << "]" << std::endl;
                return false;
            }
        }

        // all tests passed, declare it sound
        return true;
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movb $0x1, %bl
cmpl $0x0, 0x18(%rdi)
je 0x2304a
movq %rdi, %r14
movl $0x1, %ebp
movq %r14, %rdi
movl %ebp, %esi
callq 0x23142
testb %al, %al
je 0x22fc6
incl %ebp
movl 0x18(%r14), %eax
cmpl %eax, %ebp
jbe 0x22f7a
testl %eax, %eax
je 0x2304a
movq 0x20(%r14), %rcx
movq 0x40(%r14), %rdx
movl $0x1, %esi
movl %esi, %r14d
movq (%rcx,%r14,8), %rdi
movl 0x8(%rdi), %edi
cmpl (%rdx,%rdi,4), %esi
jne 0x22fe3
incl %r14d
movl %r14d, %esi
cmpl %eax, %r14d
jbe 0x22fa7
jmp 0x2304a
movq 0x1a00b(%rip), %rdi     # 0x3cfd8
leaq 0x990f(%rip), %rsi      # 0x2c8e3
movl $0x2a, %edx
callq 0x52e0
movl %ebp, %r14d
jmp 0x22ffb
movq 0x19fee(%rip), %rdi     # 0x3cfd8
leaq 0x991d(%rip), %rsi      # 0x2c90e
movl $0x27, %edx
callq 0x52e0
movq 0x19fd6(%rip), %rdi     # 0x3cfd8
movq %r14, %rsi
callq 0x51d0
movq %rax, %rbx
leaq 0x9c85(%rip), %rsi      # 0x2cc99
movl $0x1, %edx
movq %rax, %rdi
callq 0x52e0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x5270
movsbl %al, %esi
movq %rbx, %rdi
callq 0x5040
movq %rax, %rdi
callq 0x51e0
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/bonetblai[P]mdp-engine/ctp3/../engine/bdd_priority_queue.h
// Function: std::bdd_priority_queue<Online::Policy::AOT::node_t<state_t>*, Online::Policy::AOT::min_priority_t<state_t>, Online::Policy::AOT::max_priority_t<state_t>>::check_min() const
bool check_min() const {
        // check heap property in min_array
        for( unsigned index = 1; index <= min_size_; ++index ) {
            if( !check_min_heap_property(index) ) {
                std::cout << "heap property violated at min_array[index=" << index << "]" << std::endl;
                return false;
            }
        }

        // check invariants for xrefs in min_array
        for( unsigned index = 1; index <= min_size_; ++index ) {
            if( !check_min_invariant(index) ) {
                std::cout << "invariant violated for min_array[index=" << index << "]" << std::endl;
                return false;
            }
        }

        // all tests passed, declare it sound
        return true;
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movb $0x1, %bl
cmpl $0x0, 0x38(%rdi)
je 0x2313b
movq %rdi, %r14
movl $0x1, %ebp
movq %r14, %rdi
movl %ebp, %esi
callq 0x23142
testb %al, %al
je 0x230b7
incl %ebp
movl 0x38(%r14), %eax
cmpl %eax, %ebp
jbe 0x2306a
testl %eax, %eax
je 0x2313b
movq 0x20(%r14), %rcx
movq 0x40(%r14), %rdx
movl $0x1, %esi
movl %esi, %r14d
movl (%rdx,%r14,4), %edi
movq (%rcx,%rdi,8), %rdi
cmpl 0x8(%rdi), %esi
jne 0x230d4
incl %r14d
movl %r14d, %esi
cmpl %eax, %r14d
jbe 0x23097
jmp 0x2313b
movq 0x19f1a(%rip), %rdi     # 0x3cfd8
leaq 0x9871(%rip), %rsi      # 0x2c936
movl $0x2a, %edx
callq 0x52e0
movl %ebp, %r14d
jmp 0x230ec
movq 0x19efd(%rip), %rdi     # 0x3cfd8
leaq 0x987f(%rip), %rsi      # 0x2c961
movl $0x27, %edx
callq 0x52e0
movq 0x19ee5(%rip), %rdi     # 0x3cfd8
movq %r14, %rsi
callq 0x51d0
movq %rax, %rbx
leaq 0x9b94(%rip), %rsi      # 0x2cc99
movl $0x1, %edx
movq %rax, %rdi
callq 0x52e0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x5270
movsbl %al, %esi
movq %rbx, %rdi
callq 0x5040
movq %rax, %rdi
callq 0x51e0
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/bonetblai[P]mdp-engine/ctp3/../engine/bdd_priority_queue.h
// Function: std::bdd_priority_queue<Online::Policy::AOT::node_t<state_t>*, Online::Policy::AOT::min_priority_t<state_t>, Online::Policy::AOT::max_priority_t<state_t>>::check_min_heap_property(unsigned int) const
bool check_min_heap_property(unsigned index) const {
        unsigned left = index << 1, right = 1 + left;
        if( (left <= min_size_) &&
            min_cmpfn_(max_array_[min_array_[index]]->element_, max_array_[min_array_[left]]->element_) ) {
            return false;
        }
        if( (right <= min_size_) &&
            min_cmpfn_(max_array_[min_array_[index]]->element_, max_array_[min_array_[right]]->element_) ) {
            return false;
        }
        return true;
    }

// Assembly:
leal (%rsi,%rsi), %eax
movl 0x38(%rdi), %ecx
cmpl %ecx, %eax
ja 0x2318c
movl %esi, %edx
movq 0x20(%rdi), %r8
movq 0x40(%rdi), %r9
movl (%r9,%rdx,4), %edx
movq (%r8,%rdx,8), %rdx
movq (%rdx), %rdx
movl %eax, %r10d
movl (%r9,%r10,4), %r9d
movq (%r8,%r9,8), %r8
movq (%r8), %r8
movss 0xc(%rdx), %xmm0
movaps 0x7f35(%rip), %xmm1     # 0x2b0b0
andps %xmm1, %xmm0
movss 0xc(%r8), %xmm2
andps %xmm1, %xmm2
ucomiss %xmm0, %xmm2
ja 0x231d3
cmpl %ecx, %eax
jae 0x231d6
leal 0x1(,%rsi,2), %eax
movl %esi, %ecx
movq 0x20(%rdi), %rdx
movq 0x40(%rdi), %rsi
movl (%rsi,%rcx,4), %ecx
movq (%rdx,%rcx,8), %rcx
movq (%rcx), %rcx
movl %eax, %eax
movl (%rsi,%rax,4), %eax
movq (%rdx,%rax,8), %rax
movq (%rax), %rax
movss 0xc(%rcx), %xmm0
movaps 0x7eed(%rip), %xmm1     # 0x2b0b0
andps %xmm1, %xmm0
movss 0xc(%rax), %xmm2
andps %xmm1, %xmm2
ucomiss %xmm0, %xmm2
jbe 0x231d6
xorl %eax, %eax
retq
movb $0x1, %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/bonetblai[P]mdp-engine/ctp3/../engine/aot.h
// Function: Online::Policy::AOT::aot_t<state_t>::insert_into_inside_priority_queue(Online::Policy::AOT::node_t<state_t>*) const
void insert_into_inside_priority_queue(node_t<T> *node) const {
#ifdef USE_BDD_PQ
        std::pair<bool, bool> p = inside_bdd_priority_queue_.push(node);
        node->in_pq_ = p.first;
        if( p.second ) {
            node_t<T> *removed = inside_bdd_priority_queue_.removed_element();
            assert(removed != 0);
            assert(removed->in_pq_);
            removed->in_pq_ = false;
        }
#else
        inside_priority_queue_.push(node);
        node->in_pq_ = true;
#endif
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsp, %r14
movq %rsi, (%r14)
addq $0xa0, %rdi
movq %r14, %rsi
callq 0x234fc
movq (%r14), %rcx
movl %eax, %edx
andb $0x1, %dl
movb %dl, 0x16(%rcx)
btl $0x8, %eax
jae 0x2342b
movq 0xb0(%rbx), %rax
testq %rax, %rax
je 0x23433
cmpb $0x0, 0x16(%rax)
je 0x23452
movb $0x0, 0x16(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x9677(%rip), %rdi      # 0x2cab1
leaq 0x9548(%rip), %rsi      # 0x2c989
leaq 0x9676(%rip), %rcx      # 0x2cabe
movl $0x3d0, %edx            # imm = 0x3D0
callq 0x51c0
leaq 0x96d2(%rip), %rdi      # 0x2cb2b
leaq 0x9529(%rip), %rsi      # 0x2c989
leaq 0x9657(%rip), %rcx      # 0x2cabe
movl $0x3d1, %edx            # imm = 0x3D1
callq 0x51c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/bonetblai[P]mdp-engine/ctp3/../engine/aot.h
// Function: Online::Policy::AOT::aot_t<state_t>::insert_into_outside_priority_queue(Online::Policy::AOT::node_t<state_t>*) const
void insert_into_outside_priority_queue(node_t<T> *node) const {
#ifdef USE_BDD_PQ
        std::pair<bool, bool> p = outside_bdd_priority_queue_.push(node);
        node->in_pq_ = p.first;
        if( p.second ) {
            node_t<T> *removed = outside_bdd_priority_queue_.removed_element();
            assert(removed != 0);
            assert(removed->in_pq_);
            removed->in_pq_ = false;
        }
#else
        outside_priority_queue_.push(node);
        node->in_pq_ = true;
#endif
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsp, %r14
movq %rsi, (%r14)
addq $0xf8, %rdi
movq %r14, %rsi
callq 0x234fc
movq (%r14), %rcx
movl %eax, %edx
andb $0x1, %dl
movb %dl, 0x16(%rcx)
btl $0x8, %eax
jae 0x234b5
movq 0x108(%rbx), %rax
testq %rax, %rax
je 0x234bd
cmpb $0x0, 0x16(%rax)
je 0x234dc
movb $0x0, 0x16(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x95ed(%rip), %rdi      # 0x2cab1
leaq 0x94be(%rip), %rsi      # 0x2c989
leaq 0x9b78(%rip), %rcx      # 0x2d04a
movl $0x3df, %edx            # imm = 0x3DF
callq 0x51c0
leaq 0x9648(%rip), %rdi      # 0x2cb2b
leaq 0x949f(%rip), %rsi      # 0x2c989
leaq 0x9b59(%rip), %rcx      # 0x2d04a
movl $0x3e0, %edx            # imm = 0x3E0
callq 0x51c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/bonetblai[P]mdp-engine/ctp3/../engine/bdd_priority_queue.h
// Function: std::bdd_priority_queue<Online::Policy::AOT::node_t<state_t>*, Online::Policy::AOT::min_priority_t<state_t>, Online::Policy::AOT::max_priority_t<state_t>>::push(Online::Policy::AOT::node_t<state_t>*&)
std::pair<bool, bool> push(T &element) {
        if( max_size_ < capacity_ ) {
            container_t *container = allocate_container(element);
            push_max(1 + max_size_, container);
            ++max_size_;
            assert(check());
            return std::make_pair(true, false);
        } else {
            unsigned min = min_array_[1];
            if( max_cmpfn_(max_array_[min]->element_, element) ) {
                min_array_[1] = min_array_[min_size_];
                max_array_[min_array_[1]]->xref_ = 1;
                --min_size_;
                if( min_size_ > 0 ) {
                    heapify_min(1);
                }

                remove_from_max(min);
                assert(pool_ != 0);
                removed_element_ = pool_->element_;

                assert(max_size_ < capacity_);
                push(element);
                return std::make_pair(true, true);
            } else {
                return std::make_pair(false, false);
            }
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl 0x4(%rdi), %ebp
movl 0x18(%rdi), %r12d
cmpl %ebp, %r12d
jb 0x235a1
movq 0x20(%rbx), %rax
movq 0x40(%rbx), %rcx
movl 0x4(%rcx), %r15d
movq (%rax,%r15,8), %rdx
movq (%rdx), %rdx
movq (%r14), %rsi
movss 0xc(%rdx), %xmm0
movaps 0x7b74(%rip), %xmm1     # 0x2b0b0
andps %xmm1, %xmm0
movss 0xc(%rsi), %xmm2
andps %xmm1, %xmm2
ucomiss %xmm2, %xmm0
jbe 0x235e6
movl 0x38(%rbx), %edx
movl (%rcx,%rdx,4), %edx
movl %edx, 0x4(%rcx)
movq (%rax,%rdx,8), %rax
movl $0x1, 0x8(%rax)
decl 0x38(%rbx)
je 0x23576
movq %rbx, %rdi
movl $0x1, %esi
callq 0x23726
movq %rbx, %rdi
movl %r15d, %esi
callq 0x2382e
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x23610
movq (%rax), %rax
movq %rax, 0x10(%rbx)
movl 0x18(%rbx), %eax
cmpl 0x4(%rbx), %eax
jae 0x2362f
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2364e
movl 0x18(%rbx), %esi
incl %esi
movq %rbx, %rdi
movq %rax, %rdx
callq 0x2369c
incl 0x18(%rbx)
movq %rbx, %rdi
callq 0x22f62
testb %al, %al
je 0x235f1
movq %rbx, %rdi
callq 0x23052
testb %al, %al
je 0x235f1
xorl %eax, %eax
cmpl %ebp, %r12d
setae %al
shll $0x8, %eax
incl %eax
jmp 0x235e8
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x9177(%rip), %rdi      # 0x2c76f
leaq 0x9178(%rip), %rsi      # 0x2c777
leaq 0x9535(%rip), %rcx      # 0x2cb3b
movl $0x13b, %edx            # imm = 0x13B
callq 0x51c0
leaq 0x9684(%rip), %rdi      # 0x2cc9b
leaq 0x9159(%rip), %rsi      # 0x2c777
leaq 0x9516(%rip), %rcx      # 0x2cb3b
movl $0x148, %edx            # imm = 0x148
callq 0x51c0
leaq 0x9670(%rip), %rdi      # 0x2cca6
leaq 0x913a(%rip), %rsi      # 0x2c777
leaq 0x94f7(%rip), %rcx      # 0x2cb3b
movl $0x14b, %edx            # imm = 0x14B
callq 0x51c0
// File: /workspace/github_cpp_makefile_star2_O3/bonetblai[P]mdp-engine/ctp3/../engine/bdd_priority_queue.h
// Function: std::bdd_priority_queue<Online::Policy::AOT::node_t<state_t>*, Online::Policy::AOT::min_priority_t<state_t>, Online::Policy::AOT::max_priority_t<state_t>>::allocate_container(Online::Policy::AOT::node_t<state_t>* const&) const
container_t* allocate_container(const T &element) const {
        if( pool_ == 0 ) {
            return new container_t(element);
        } else {
            container_t *p = pool_;
            pool_ = pool_->next_;
            p->element_ = element;
            p->next_ = 0;
            p->xref_ = 0;
            return p;
        }
    }

// Assembly:
pushq %rbx
movq %rsi, %rbx
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x2367a
movq 0x10(%rax), %rcx
movq %rcx, 0x8(%rdi)
movq (%rbx), %rcx
movq %rcx, (%rax)
movq $0x0, 0x10(%rax)
movl $0x0, 0x8(%rax)
jmp 0x23699
movl $0x18, %edi
callq 0x5290
movq (%rbx), %rcx
movq %rcx, (%rax)
movl $0x0, 0x8(%rax)
movq $0x0, 0x10(%rax)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/bonetblai[P]mdp-engine/ctp3/../engine/bdd_priority_queue.h
// Function: std::bdd_priority_queue<Online::Policy::AOT::node_t<state_t>*, Online::Policy::AOT::min_priority_t<state_t>, Online::Policy::AOT::max_priority_t<state_t>>::push_max(unsigned int, std::bdd_priority_queue<Online::Policy::AOT::node_t<state_t>*, Online::Policy::AOT::min_priority_t<state_t>, Online::Policy::AOT::max_priority_t<state_t>>::container_t*)
void push_max(unsigned index, container_t *container) {
        unsigned parent = index >> 1;
        while( (index > 1) && max_cmpfn_(max_array_[parent]->element_, container->element_) ) {
            max_array_[index] = max_array_[parent];
            min_array_[max_array_[index]->xref_] = index;
            index = parent;
            parent = parent >> 1;
        }
        max_array_[index] = container;

        if( container->xref_ != 0 ) {
            // container is not new; it is changing location in max_array
            min_array_[container->xref_] = index;
        } else {
            push_min(1 + min_size_, index);
            ++min_size_;
        }
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %rcx
cmpl $0x2, %esi
jb 0x236f9
movaps 0x7a00(%rip), %xmm0     # 0x2b0b0
movl %esi, %eax
shrl %eax
movq (%rcx,%rax,8), %rdi
movq (%rdi), %r8
movq (%rdx), %r9
movss 0xc(%r8), %xmm1
andps %xmm0, %xmm1
movss 0xc(%r9), %xmm2
andps %xmm0, %xmm2
ucomiss %xmm2, %xmm1
jbe 0x236f9
movl %esi, %r8d
movq %rdi, (%rcx,%r8,8)
movq 0x20(%rbx), %rcx
movq 0x40(%rbx), %rdi
movq (%rcx,%r8,8), %r8
movl 0x8(%r8), %r8d
movl %esi, (%rdi,%r8,4)
cmpl $0x3, %esi
movl %eax, %esi
ja 0x236b2
jmp 0x236fb
movl %esi, %eax
movl %eax, %esi
movq %rdx, (%rcx,%rsi,8)
movl 0x8(%rdx), %ecx
testq %rcx, %rcx
je 0x23712
movq 0x40(%rbx), %rdx
movl %eax, (%rdx,%rcx,4)
jmp 0x23724
movl 0x38(%rbx), %esi
incl %esi
movq %rbx, %rdi
movl %eax, %edx
callq 0x23974
incl 0x38(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/bonetblai[P]mdp-engine/ctp3/../engine/bdd_priority_queue.h
// Function: std::bdd_priority_queue<Online::Policy::AOT::node_t<state_t>*, Online::Policy::AOT::min_priority_t<state_t>, Online::Policy::AOT::max_priority_t<state_t>>::heapify_min(unsigned int)
void heapify_min(unsigned index) {
        assert((index > 0) && (index <= min_size_));
        unsigned left = index << 1, right = 1 + left, largest = 0;

        if( (left <= min_size_) &&
            min_cmpfn_(max_array_[min_array_[index]]->element_, max_array_[min_array_[left]]->element_) ) {
            largest = left;
        } else {
            largest = index;
        }
        if( (right <= min_size_) &&
            min_cmpfn_(max_array_[min_array_[largest]]->element_, max_array_[min_array_[right]]->element_) ) {
            largest = right;
        }

        if( largest != index ) {
            unsigned tmp = min_array_[largest];
            min_array_[largest] = min_array_[index];
            min_array_[index] = tmp;
            max_array_[min_array_[largest]]->xref_ = largest;
            max_array_[min_array_[index]]->xref_ = index;
            heapify_min(largest);
        }
    }

// Assembly:
pushq %rax
testl %esi, %esi
je 0x2380c
movq 0x20(%rdi), %rax
movq 0x40(%rdi), %rcx
movaps 0x7972(%rip), %xmm0     # 0x2b0b0
movl 0x38(%rdi), %r9d
cmpl %esi, %r9d
jb 0x2380c
leal (%rsi,%rsi), %r10d
movl %esi, %edx
cmpl %r9d, %r10d
ja 0x23789
movl (%rcx,%rdx,4), %r8d
movq (%rax,%r8,8), %r8
movq (%r8), %r8
movl %r10d, %r11d
movl (%rcx,%r11,4), %r11d
movq (%rax,%r11,8), %r11
movq (%r11), %r11
movss 0xc(%r8), %xmm1
andps %xmm0, %xmm1
movss 0xc(%r11), %xmm2
andps %xmm0, %xmm2
ucomiss %xmm1, %xmm2
movl %r10d, %r8d
ja 0x2378c
movl %esi, %r8d
cmpl %r9d, %r10d
jae 0x237d2
leal 0x1(,%rsi,2), %r9d
movl %r8d, %r10d
movl (%rcx,%r10,4), %r10d
movq (%rax,%r10,8), %r10
movq (%r10), %r10
movl %r9d, %r11d
movl (%rcx,%r11,4), %r11d
movq (%rax,%r11,8), %r11
movq (%r11), %r11
movss 0xc(%r10), %xmm1
andps %xmm0, %xmm1
movss 0xc(%r11), %xmm2
andps %xmm0, %xmm2
ucomiss %xmm1, %xmm2
ja 0x237cf
movl %r8d, %r9d
movl %r9d, %r8d
cmpl %esi, %r8d
je 0x2382b
movl %r8d, %r9d
movl (%rcx,%r9,4), %r10d
movl (%rcx,%rdx,4), %r11d
movl %r11d, (%rcx,%r9,4)
movl %r10d, (%rcx,%rdx,4)
movl (%rcx,%r9,4), %r9d
movq (%rax,%r9,8), %r9
movl %r8d, 0x8(%r9)
movl (%rcx,%rdx,4), %edx
movq (%rax,%rdx,8), %rdx
movl %esi, 0x8(%rdx)
movl %r8d, %esi
testl %r8d, %r8d
jne 0x2373e
leaq 0x94a9(%rip), %rdi      # 0x2ccbc
leaq 0x8f5d(%rip), %rsi      # 0x2c777
leaq 0x94bf(%rip), %rcx      # 0x2cce0
movl $0xf7, %edx
callq 0x51c0
popq %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/bonetblai[P]mdp-engine/ctp3/../engine/bdd_priority_queue.h
// Function: std::bdd_priority_queue<Online::Policy::AOT::node_t<state_t>*, Online::Policy::AOT::min_priority_t<state_t>, Online::Policy::AOT::max_priority_t<state_t>>::remove_from_max(unsigned int)
void remove_from_max(unsigned index) {
        if( !is_leaf_in_max(index) ) {
            unsigned leaf = max_subtree_leaf(index);
            assert(is_leaf_in_max(leaf));
            assert(!max_cmpfn_(max_array_[index]->element_, max_array_[leaf]->element_));
            assert(!min_cmpfn_(max_array_[index]->element_, max_array_[leaf]->element_));
            assert(max_array_[index]->xref_ == 1);
            max_array_[index]->xref_ = max_array_[leaf]->xref_;
            min_array_[max_array_[index]->xref_] = index;
            index = leaf;
        }

        // link pool of available containers
        max_array_[index]->next_ = pool_;
        pool_ = max_array_[index];

        // remove container from heap
        if( index != max_size_ ) {
            push_max(index, max_array_[max_size_]);
        }
        --max_size_;
        assert(check());
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
leal (%rsi,%rsi), %eax
movl 0x18(%rdi), %edx
cmpl %edx, %eax
jbe 0x23848
movq 0x20(%rbx), %rax
movl %esi, %ecx
movq (%rax,%rcx,8), %r8
jmp 0x238b3
movl %esi, %eax
movl %eax, %edi
leal (%rdi,%rdi), %eax
cmpl %edx, %eax
jbe 0x2384a
movl %esi, %ecx
movq 0x20(%rbx), %rax
movq (%rax,%rcx,8), %rdx
movq (%rdx), %r9
movl %edi, %ecx
movq (%rax,%rcx,8), %r8
movq (%r8), %r10
movss 0xc(%r9), %xmm0
movaps 0x783a(%rip), %xmm2     # 0x2b0b0
andps %xmm2, %xmm0
movss 0xc(%r10), %xmm1
andps %xmm2, %xmm1
ucomiss %xmm1, %xmm0
ja 0x23916
ucomiss %xmm0, %xmm1
ja 0x23935
cmpl $0x1, 0x8(%rdx)
jne 0x23954
movl 0x8(%r8), %r9d
movl %r9d, 0x8(%rdx)
movq 0x40(%rbx), %rdx
movl %esi, (%rdx,%r9,4)
movl 0x18(%rbx), %edx
movl %edi, %esi
movq 0x8(%rbx), %rdi
movq %rdi, 0x10(%r8)
movq (%rax,%rcx,8), %rcx
movq %rcx, 0x8(%rbx)
cmpl %edx, %esi
je 0x238d8
movl %edx, %ecx
movq (%rax,%rcx,8), %rdx
movq %rbx, %rdi
callq 0x2369c
movl 0x18(%rbx), %edx
decl %edx
movl %edx, 0x18(%rbx)
movq %rbx, %rdi
callq 0x22f62
testb %al, %al
je 0x238f7
movq %rbx, %rdi
callq 0x23052
testb %al, %al
je 0x238f7
popq %rbx
retq
leaq 0x8e71(%rip), %rdi      # 0x2c76f
leaq 0x8e72(%rip), %rsi      # 0x2c777
leaq 0x9533(%rip), %rcx      # 0x2ce3f
movl $0xb7, %edx
callq 0x51c0
leaq 0x9685(%rip), %rdi      # 0x2cfa2
leaq 0x8e53(%rip), %rsi      # 0x2c777
leaq 0x9514(%rip), %rcx      # 0x2ce3f
movl $0xa6, %edx
callq 0x51c0
leaq 0x96ab(%rip), %rdi      # 0x2cfe7
leaq 0x8e34(%rip), %rsi      # 0x2c777
leaq 0x94f5(%rip), %rcx      # 0x2ce3f
movl $0xa7, %edx
callq 0x51c0
leaq 0x96d1(%rip), %rdi      # 0x2d02c
leaq 0x8e15(%rip), %rsi      # 0x2c777
leaq 0x94d6(%rip), %rcx      # 0x2ce3f
movl $0xa8, %edx
callq 0x51c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/bonetblai[P]mdp-engine/ctp3/../engine/bdd_priority_queue.h
// Function: std::bdd_priority_queue<Online::Policy::AOT::node_t<state_t>*, Online::Policy::AOT::min_priority_t<state_t>, Online::Policy::AOT::max_priority_t<state_t>>::push_min(unsigned int, unsigned int)
void push_min(unsigned index, unsigned element) {
        unsigned parent = index >> 1;
        while( (index > 1) && min_cmpfn_(max_array_[min_array_[parent]]->element_, max_array_[element]->element_) ) {
            min_array_[index] = min_array_[parent];
            max_array_[min_array_[index]]->xref_ = index;
            index = parent;
            parent = parent >> 1;
        }
        min_array_[index] = element;
        max_array_[element]->xref_ = index;
    }

// Assembly:
movl %edx, %ecx
cmpl $0x1, %esi
jbe 0x239d0
movq 0x20(%rdi), %r8
movq 0x40(%rdi), %rax
movq (%r8,%rcx,8), %rcx
movq (%rcx), %rdi
movss 0xc(%rdi), %xmm0
andps 0x771a(%rip), %xmm0     # 0x2b0b0
movaps 0x7713(%rip), %xmm1     # 0x2b0b0
movl %esi, %edi
shrl %edi
movl (%rax,%rdi,4), %r9d
movq (%r8,%r9,8), %r10
movq (%r10), %r11
movss 0xc(%r11), %xmm2
andps %xmm1, %xmm2
ucomiss %xmm2, %xmm0
jbe 0x239dc
movl %esi, %r11d
movl %r9d, (%rax,%r11,4)
movl %esi, 0x8(%r10)
cmpl $0x3, %esi
movl %edi, %esi
ja 0x2399f
movl %edi, %esi
jmp 0x239dc
movq 0x20(%rdi), %r8
movq 0x40(%rdi), %rax
movq (%r8,%rcx,8), %rcx
movl %esi, %edi
movl %edx, (%rax,%rdi,4)
movl %esi, 0x8(%rcx)
retq
nop