LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: bonetblai[P]mdp-engine/ctp3/./ctp3.h
// Function: state_t::print(std::ostream&) const
void print(std::ostream &os) const {
        os << "(" << current_ << "," << info_ << ",V={";
        for( int i = 0; i < words_for_nodes_; ++i )
            os << print_bits_t<unsigned>(visited_[i], i << 5);
        os << "}";
        if( is_dead_end() ) os << ",DEAD";
        os << ")";
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
leaq 0x29f4e(%rip), %rsi     # 0x5e042
callq 0x6330
movq %rax, %rdi
movq 0x10(%rsp), %rax
movl (%rax), %esi
callq 0x6510
movq %rax, %rdi
leaq 0x29cdd(%rip), %rsi     # 0x5ddef
callq 0x6330
movq 0x10(%rsp), %rsi
movq %rax, %rdi
addq $0x4, %rsi
callq 0x341e0
movq %rax, %rdi
leaq 0x29dc6(%rip), %rsi     # 0x5def8
callq 0x6330
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
cmpl 0x4f1d7(%rip), %eax     # 0x83320
jge 0x34190
movq 0x10(%rsp), %rax
movq 0x28(%rsp), %rcx
movq %rcx, 0x8(%rsp)
movslq 0x24(%rsp), %rcx
movl 0x4c(%rax,%rcx,4), %esi
movl 0x24(%rsp), %edx
shll $0x5, %edx
leaq 0x1c(%rsp), %rdi
callq 0x34240
movq 0x8(%rsp), %rdi
leaq 0x1c(%rsp), %rsi
callq 0x34210
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x3413f
movq 0x28(%rsp), %rdi
leaq 0x29d61(%rip), %rsi     # 0x5defd
callq 0x6330
movq 0x10(%rsp), %rdi
callq 0x12500
testb $0x1, %al
jne 0x341b1
jmp 0x341c2
movq 0x28(%rsp), %rdi
leaq 0x29d42(%rip), %rsi     # 0x5deff
callq 0x6330
movq 0x28(%rsp), %rdi
leaq 0x2921f(%rip), %rsi     # 0x5d3ed
callq 0x6330
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: bonetblai[P]mdp-engine/ctp3/./ctp3.h
// Function: state_info_t::print(std::ostream&) const
void print(std::ostream &os) const {
        os << "K={";
        for( int i = 0; i < words_for_edges_; ++i )
            os << print_bits_t<unsigned>(known_[i], i << 5);
        os << "},B={";
        for( int i = 0; i < words_for_edges_; ++i )
            os << print_bits_t<unsigned>(blocked_[i], i << 5);
        os << "}";
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rdi
leaq 0x29c81(%rip), %rsi     # 0x5df05
callq 0x6330
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
cmpl 0x4f071(%rip), %eax     # 0x8330c
jge 0x342e1
movq 0x18(%rsp), %rax
movq 0x38(%rsp), %rcx
movq %rcx, 0x10(%rsp)
movslq 0x34(%rsp), %rcx
movl (%rax,%rcx,4), %esi
movl 0x34(%rsp), %edx
shll $0x5, %edx
leaq 0x2c(%rsp), %rdi
callq 0x34240
movq 0x10(%rsp), %rdi
leaq 0x2c(%rsp), %rsi
callq 0x34210
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
jmp 0x34291
movq 0x38(%rsp), %rdi
leaq 0x29c1c(%rip), %rsi     # 0x5df09
callq 0x6330
movl $0x0, 0x28(%rsp)
movl 0x28(%rsp), %eax
cmpl 0x4f008(%rip), %eax     # 0x8330c
jge 0x3434b
movq 0x18(%rsp), %rax
movq 0x38(%rsp), %rcx
movq %rcx, 0x8(%rsp)
movslq 0x28(%rsp), %rcx
movl 0x24(%rax,%rcx,4), %esi
movl 0x28(%rsp), %edx
shll $0x5, %edx
leaq 0x20(%rsp), %rdi
callq 0x34240
movq 0x8(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x34210
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0x342fa
movq 0x38(%rsp), %rdi
leaq 0x29ba6(%rip), %rsi     # 0x5defd
callq 0x6330
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: bonetblai[P]mdp-engine/ctp3/./ctp3.h
// Function: print_bits_t<unsigned int>::print(std::ostream&) const
void print(std::ostream &os) const {
        if( field_ != 0 ) {
            T aux = field_;
            for( int i = 0; aux != 0; ++i, aux = aux >> 1 ) {
                if( aux & 0x1 ) {
                    os << base_ + i << ",";
                }
            }
        }
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpl $0x0, (%rax)
je 0x343f3
movq 0x8(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x14(%rsp)
movl $0x0, 0x10(%rsp)
cmpl $0x0, 0x14(%rsp)
je 0x343f1
movl 0x14(%rsp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x343d8
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rdi
movl 0x4(%rax), %esi
addl 0x10(%rsp), %esi
callq 0x6510
movq %rax, %rdi
leaq 0x29a1c(%rip), %rsi     # 0x5ddef
callq 0x6330
jmp 0x343da
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
movl 0x14(%rsp), %eax
shrl %eax
movl %eax, 0x14(%rsp)
jmp 0x343a0
jmp 0x343f3
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: bonetblai[P]mdp-engine/ctp3/../engine/heuristic.h
// Function: Heuristic::min_min_heuristic_t<state_t>::solve_problem()
void solve_problem() {
        if( algorithm_ == 0 ) {
            std::cout << Utils::error() << "algorithm must be specified for min-min() heuristic!" << std::endl;
            exit(1);
        }
#ifdef DEBUG
        std::cout << "debug: min-min(): solving problem with algorithm=" << algorithm_->name() << std::endl;
#endif
        float start_time = Utils::read_time_in_seconds();
        algorithm_->solve(problem_.init(), *hash_);
        setup_time_ = Utils::read_time_in_seconds() - start_time;
    }

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x28(%rax)
jne 0x3449e
leaq 0x40(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x1e8e0
movq 0x18(%rsp), %rsi
movq 0x4eb97(%rip), %rdi     # 0x82fd0
callq 0x62f0
movq %rax, 0x20(%rsp)
jmp 0x34445
movq 0x20(%rsp), %rdi
leaq 0x29abe(%rip), %rsi     # 0x5df0f
callq 0x6330
movq %rax, 0x10(%rsp)
jmp 0x3445d
movq 0x10(%rsp), %rdi
movq 0x4eb4f(%rip), %rsi     # 0x82fb8
callq 0x6370
jmp 0x34470
leaq 0x40(%rsp), %rdi
callq 0x61f0
movl $0x1, %edi
callq 0x63e0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x61f0
jmp 0x344f2
callq 0x84f0
movq 0x28(%rsp), %rax
movss %xmm0, 0x30(%rsp)
movq 0x28(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x8(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x8(%rsp), %rdi
movq %rax, %rsi
movq 0x28(%rsp), %rax
movq 0x20(%rax), %rdx
movq (%rdi), %rax
callq *0x28(%rax)
callq 0x84f0
movq 0x28(%rsp), %rax
subss 0x30(%rsp), %xmm0
movss %xmm0, 0x14(%rax)
addq $0x68, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x6520
nopl (%rax)
// File: bonetblai[P]mdp-engine/ctp3/../engine/heuristic.h
// Function: Heuristic::optimal_heuristic_t<state_t>::solve_problem()
void solve_problem() {
        if( algorithm_ == 0 ) {
            std::cout << Utils::error() << "algorithm must be specified for optimal() heuristic!" << 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();
        assert(algorithm_ != 0);
        algorithm_->solve(problem_.init(), *hash_);
        setup_time_ = Utils::read_time_in_seconds() - start_time;
    }

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x28(%rax)
jne 0x352e1
leaq 0x40(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x1e8e0
movq 0x18(%rsp), %rsi
movq 0x4dd57(%rip), %rdi     # 0x82fd0
callq 0x62f0
movq %rax, 0x20(%rsp)
jmp 0x35285
movq 0x20(%rsp), %rdi
leaq 0x28d04(%rip), %rsi     # 0x5df95
callq 0x6330
movq %rax, 0x10(%rsp)
jmp 0x3529d
movq 0x10(%rsp), %rdi
movq 0x4dd0f(%rip), %rsi     # 0x82fb8
callq 0x6370
jmp 0x352b0
leaq 0x40(%rsp), %rdi
callq 0x61f0
movl $0x1, %edi
callq 0x63e0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x61f0
jmp 0x35362
callq 0x84f0
movq 0x28(%rsp), %rax
movss %xmm0, 0x30(%rsp)
cmpq $0x0, 0x28(%rax)
je 0x352fa
jmp 0x35319
leaq 0x28cc9(%rip), %rdi     # 0x5dfca
leaq 0x28cd2(%rip), %rsi     # 0x5dfda
movl $0xee, %edx
leaq 0x28cdc(%rip), %rcx     # 0x5dff0
callq 0x6220
movq 0x28(%rsp), %rax
movq 0x28(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x8(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x8(%rsp), %rdi
movq %rax, %rsi
movq 0x28(%rsp), %rax
movq 0x20(%rax), %rdx
movq (%rdi), %rax
callq *0x28(%rax)
callq 0x84f0
movq 0x28(%rsp), %rax
subss 0x30(%rsp), %xmm0
movss %xmm0, 0x14(%rax)
addq $0x68, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x6520
nopl (%rax)
// File: bonetblai[P]mdp-engine/ctp3/../engine/heuristic.h
// Function: Heuristic::scaled_heuristic_t<state_t>::value(state_t const&) const
virtual float value(const T &s) const {
        ++evaluations_;
        float hvalue = heuristic_ == 0 ? 0 : weight_ * heuristic_->value(s);
        eval_time_ = heuristic_ == 0 ? 0 : heuristic_->eval_time();
        return hvalue;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movl 0x18(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x18(%rax)
cmpq $0x0, 0x20(%rax)
jne 0x356f3
xorps %xmm0, %xmm0
movss %xmm0, 0x14(%rsp)
jmp 0x35725
movq 0x18(%rsp), %rax
movss 0x28(%rax), %xmm0
movss %xmm0, 0x10(%rsp)
movq 0x20(%rax), %rdi
movq 0x28(%rsp), %rsi
movq (%rdi), %rax
callq *0x20(%rax)
movaps %xmm0, %xmm1
movss 0x10(%rsp), %xmm0
mulss %xmm1, %xmm0
movss %xmm0, 0x14(%rsp)
movq 0x18(%rsp), %rax
movss 0x14(%rsp), %xmm0
movss %xmm0, 0x24(%rsp)
cmpq $0x0, 0x20(%rax)
jne 0x35748
xorps %xmm0, %xmm0
movss %xmm0, 0xc(%rsp)
jmp 0x3575c
movq 0x18(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x35c40
movss %xmm0, 0xc(%rsp)
movq 0x18(%rsp), %rax
movss 0xc(%rsp), %xmm0
movss %xmm0, 0x10(%rax)
movss 0x24(%rsp), %xmm0
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x28(%rax)
je 0x35f21
jmp 0x35f40
leaq 0x2812c(%rip), %rdi     # 0x5e054
leaq 0x28130(%rip), %rsi     # 0x5e05f
movl $0x5b, %edx
leaq 0x2813e(%rip), %rcx     # 0x5e079
callq 0x6220
movq 0x8(%rsp), %rax
movl 0x20(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x20(%rax)
movq 0x28(%rax), %rdi
movq 0x18(%rsp), %rsi
callq 0x22eb0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rsp)
movq 0x8(%rax), %rdi
movq 0x18(%rsp), %rsi
movl 0x10(%rsp), %edx
movq (%rdi), %rax
callq *0x30(%rax)
testb $0x1, %al
jne 0x35f82
jmp 0x35f84
jmp 0x35fa3
leaq 0x2815a(%rip), %rdi     # 0x5e0e5
leaq 0x280cd(%rip), %rsi     # 0x5e05f
movl $0x5e, %edx
leaq 0x280db(%rip), %rcx     # 0x5e079
callq 0x6220
movl 0x10(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x30(%rax)
jne 0x3670e
leaq 0x40(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x1e8e0
movq 0x18(%rsp), %rsi
movq 0x4c927(%rip), %rdi     # 0x82fd0
callq 0x62f0
movq %rax, 0x20(%rsp)
jmp 0x366b5
movq 0x20(%rsp), %rdi
leaq 0x27a44(%rip), %rsi     # 0x5e105
callq 0x6330
movq %rax, 0x10(%rsp)
jmp 0x366cd
movq 0x10(%rsp), %rdi
movq 0x4c8df(%rip), %rsi     # 0x82fb8
callq 0x6370
jmp 0x366e0
leaq 0x40(%rsp), %rdi
callq 0x61f0
movl $0x1, %edi
callq 0x63e0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x61f0
jmp 0x36762
callq 0x84f0
movq 0x28(%rsp), %rax
movss %xmm0, 0x30(%rsp)
movq 0x30(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x8(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x8(%rsp), %rdi
movq %rax, %rsi
movq 0x28(%rsp), %rax
movq 0x28(%rax), %rdx
movq (%rdi), %rax
callq *0x28(%rax)
callq 0x84f0
movq 0x28(%rsp), %rax
subss 0x30(%rsp), %xmm0
movss %xmm0, 0x14(%rax)
addq $0x68, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x6520
nopl (%rax)
// File: bonetblai[P]mdp-engine/ctp3/../engine/base_policies.h
// Function: Online::Policy::base_greedy_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( heuristic_ != 0 ) heuristic_->reset_stats();
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
xorps %xmm0, %xmm0
movss %xmm0, 0x14(%rax)
xorps %xmm0, %xmm0
movss %xmm0, 0x18(%rax)
xorps %xmm0, %xmm0
movss %xmm0, 0x1c(%rax)
movq 0x8(%rax), %rdi
callq 0x1a2e0
movq 0x8(%rsp), %rax
cmpq $0x0, 0x28(%rax)
je 0x374de
movq 0x8(%rsp), %rax
movq 0x28(%rax), %rdi
callq 0x23930
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: bonetblai[P]mdp-engine/ctp3/../engine/rollout.h
// Function: Online::Policy::Rollout::nested_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();
        nested_policies_.back()->reset_stats();
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
xorps %xmm0, %xmm0
movss %xmm0, 0x14(%rax)
xorps %xmm0, %xmm0
movss %xmm0, 0x18(%rax)
xorps %xmm0, %xmm0
movss %xmm0, 0x1c(%rax)
movq 0x8(%rax), %rdi
callq 0x1a2e0
movq 0x8(%rsp), %rdi
addq $0x30, %rdi
callq 0x3ce60
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
addq $0x18, %rsp
retq
// File: 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:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movl %edx, 0x64(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x64(%rsp), %edi
callq 0x1a300
movq 0x8(%rsp), %rdi
movl %eax, 0x60(%rsp)
movl 0x60(%rsp), %esi
callq 0x63c0
movq %rax, %rdi
leaq 0x2413c(%rip), %rsi     # 0x5def7
callq 0x6330
movq %rax, %rdi
leaq 0x237c7(%rip), %rsi     # 0x5d591
callq 0x6330
movq 0x10(%rsp), %rsi
movq %rax, 0x18(%rsp)
movq (%rsi), %rax
movq 0x18(%rax), %rax
leaq 0x40(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq *%rax
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x62f0
movq %rax, 0x28(%rsp)
jmp 0x39e02
movq 0x28(%rsp), %rdi
movq 0x491aa(%rip), %rsi     # 0x82fb8
callq 0x6370
jmp 0x39e15
leaq 0x40(%rsp), %rdi
callq 0x61f0
movl $0x0, 0x30(%rsp)
movq 0x10(%rsp), %rdi
movl 0x30(%rsp), %eax
movl %eax, 0x4(%rsp)
addq $0x30, %rdi
callq 0x3a590
movq %rax, %rcx
movl 0x4(%rsp), %eax
cmpl %ecx, %eax
jge 0x39e97
movq 0x10(%rsp), %rdi
addq $0x30, %rdi
movslq 0x30(%rsp), %rsi
callq 0x3cfd0
movq (%rax), %rdi
movq 0x68(%rsp), %rsi
movl 0x64(%rsp), %edx
addl $0x2, %edx
movq (%rdi), %rax
callq *0x30(%rax)
movl 0x30(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x30(%rsp)
jmp 0x39e27
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x61f0
jmp 0x39e9c
addq $0x78, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x6520
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x28(%rax)
jne 0x3a96a
leaq 0x60(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x1e8e0
movq 0x18(%rsp), %rsi
movq 0x486ce(%rip), %rdi     # 0x82fd0
callq 0x62f0
movq %rax, 0x20(%rsp)
jmp 0x3a90e
movq 0x20(%rsp), %rdi
leaq 0x23874(%rip), %rsi     # 0x5e18e
callq 0x6330
movq %rax, 0x10(%rsp)
jmp 0x3a926
movq 0x10(%rsp), %rdi
movq 0x48686(%rip), %rsi     # 0x82fb8
callq 0x6370
jmp 0x3a939
leaq 0x60(%rsp), %rdi
callq 0x61f0
movl $0x1, %edi
callq 0x63e0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x61f0
jmp 0x3aa69
movq 0x28(%rsp), %rax
movq %rax, %rdi
addq $0x30, %rdi
movl 0x50(%rax), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %esi
callq 0x3aa80
movq 0x28(%rsp), %rax
movq %rax, %rcx
addq $0x30, %rcx
movq %rcx, 0x8(%rsp)
movq 0x28(%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x8(%rsp), %rdi
movq %rax, 0x48(%rsp)
leaq 0x48(%rsp), %rsi
callq 0x3ab90
movl $0x0, 0x44(%rsp)
movq 0x28(%rsp), %rcx
movl 0x44(%rsp), %eax
cmpl 0x50(%rcx), %eax
jae 0x3aa61
movq 0x28(%rsp), %rdi
addq $0x30, %rdi
callq 0x3abc0
movq (%rax), %rax
movq %rax, 0x38(%rsp)
movl $0x40, %edi
callq 0x6340
movq %rax, %rdi
movq 0x28(%rsp), %rax
movq %rdi, %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rsi
movq 0x38(%rsp), %rdx
movl 0x48(%rax), %ecx
movl 0x4c(%rax), %r8d
movl 0x44(%rsp), %r9d
incl %r9d
callq 0x3ac00
jmp 0x3aa1c
movq 0x28(%rsp), %rdi
movq (%rsp), %rax
movq %rax, 0x30(%rsp)
addq $0x30, %rdi
leaq 0x30(%rsp), %rsi
callq 0x3ac70
movl 0x44(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x44(%rsp)
jmp 0x3a9bc
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
callq 0x6310
jmp 0x3aa69
addq $0x88, %rsp
retq
movq 0x58(%rsp), %rdi
callq 0x6520
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
xorps %xmm0, %xmm0
movss %xmm0, 0x14(%rax)
xorps %xmm0, %xmm0
movss %xmm0, 0x18(%rax)
xorps %xmm0, %xmm0
movss %xmm0, 0x1c(%rax)
movq 0x8(%rax), %rdi
callq 0x1a2e0
movq 0x8(%rsp), %rax
cmpq $0x0, 0x28(%rax)
je 0x3be2f
movq 0x8(%rsp), %rax
movq 0x28(%rax), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movl %edx, 0x74(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x18(%rsp)
movl 0x74(%rsp), %edi
callq 0x1a300
movq 0x18(%rsp), %rdi
movl %eax, 0x70(%rsp)
movl 0x70(%rsp), %esi
callq 0x63c0
movq %rax, %rdi
leaq 0x22063(%rip), %rsi     # 0x5def7
callq 0x6330
movq %rax, %rdi
leaq 0x216ee(%rip), %rsi     # 0x5d591
callq 0x6330
movq 0x20(%rsp), %rsi
movq %rax, 0x28(%rsp)
movq (%rsi), %rax
movq 0x18(%rax), %rax
leaq 0x50(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq *%rax
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x62f0
movq %rax, 0x38(%rsp)
jmp 0x3bedb
movq 0x38(%rsp), %rdi
leaq 0x216bd(%rip), %rsi     # 0x5d5a4
callq 0x6330
movq %rax, 0x10(%rsp)
jmp 0x3bef3
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rax
movl 0x20(%rax), %esi
callq 0x6440
movq %rax, 0x8(%rsp)
jmp 0x3bf0c
movq 0x8(%rsp), %rdi
movq 0x470a0(%rip), %rsi     # 0x82fb8
callq 0x6370
jmp 0x3bf1f
leaq 0x50(%rsp), %rdi
callq 0x61f0
movq 0x20(%rsp), %rax
cmpq $0x0, 0x28(%rax)
je 0x3bf6c
movq 0x20(%rsp), %rax
movq 0x28(%rax), %rdi
movq 0x78(%rsp), %rsi
movl 0x74(%rsp), %edx
addl $0x2, %edx
movq (%rdi), %rax
callq *0x30(%rax)
jmp 0x3bf6c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x61f0
jmp 0x3bf74
addq $0x88, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0x6520
nop
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x28(%rax)
jne 0x3c64d
leaq 0x38(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x1e8e0
movq 0x8(%rsp), %rsi
movq 0x469e6(%rip), %rdi     # 0x82fd0
callq 0x62f0
movq %rax, 0x10(%rsp)
jmp 0x3c5f6
movq 0x10(%rsp), %rdi
leaq 0x21c85(%rip), %rsi     # 0x5e287
callq 0x6330
movq %rax, (%rsp)
jmp 0x3c60d
movq (%rsp), %rdi
movq 0x469a0(%rip), %rsi     # 0x82fb8
callq 0x6370
jmp 0x3c61f
leaq 0x38(%rsp), %rdi
callq 0x61f0
movl $0x1, %edi
callq 0x63e0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x61f0
jmp 0x3c6a1
callq 0x84f0
movq 0x18(%rsp), %rax
movss %xmm0, 0x28(%rsp)
movq 0x28(%rax), %rdi
movq 0x58(%rsp), %rsi
movl 0x34(%rax), %ecx
movl $0x1, %edx
xorl %r8d, %r8d
callq 0x3c6b0
movss %xmm0, 0x24(%rsp)
callq 0x84f0
movq 0x18(%rsp), %rax
subss 0x28(%rsp), %xmm0
addss 0x18(%rax), %xmm0
movss %xmm0, 0x18(%rax)
movss 0x24(%rsp), %xmm0
addq $0x68, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x6520
nopl (%rax,%rax)
// File: bonetblai[P]mdp-engine/ctp3/../engine/policy.h
// Function: float Online::Evaluation::evaluation<state_t>(Online::Policy::policy_t<state_t> const&, state_t const&, unsigned int, unsigned int, bool)
inline float evaluation(const Policy::policy_t<T> &policy, const T &s, unsigned number_trials, unsigned max_depth, bool verbose = false) {
    float value = 0;
    if( verbose ) std::cout << "#trials=" << number_trials << ":";
    for( unsigned i = 0; i < number_trials; ++i ) {
        if( verbose ) std::cout << " " << i << std::flush;
        value += evaluation_trial(policy, s, max_depth);
    }
    if( verbose ) std::cout << std::endl;
    return value / number_trials;
}

// Assembly:
subq $0x28, %rsp
movb %r8b, %al
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movl %ecx, 0x10(%rsp)
andb $0x1, %al
movb %al, 0xf(%rsp)
xorps %xmm0, %xmm0
movss %xmm0, 0x8(%rsp)
testb $0x1, 0xf(%rsp)
je 0x3c70d
movq 0x468ea(%rip), %rdi     # 0x82fd0
leaq 0x21bd0(%rip), %rsi     # 0x5e2bd
callq 0x6330
movq %rax, %rdi
movl 0x14(%rsp), %esi
callq 0x6440
movq %rax, %rdi
leaq 0x216ea(%rip), %rsi     # 0x5ddf2
callq 0x6330
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
cmpl 0x14(%rsp), %eax
jae 0x3c780
testb $0x1, 0xf(%rsp)
je 0x3c754
movq 0x468a3(%rip), %rdi     # 0x82fd0
leaq 0x217c2(%rip), %rsi     # 0x5def6
callq 0x6330
movq %rax, %rdi
movl 0x4(%rsp), %esi
callq 0x6440
movq %rax, %rdi
movq 0x46889(%rip), %rsi     # 0x82fd8
callq 0x6370
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl 0x10(%rsp), %edx
callq 0x3c7c0
addss 0x8(%rsp), %xmm0
movss %xmm0, 0x8(%rsp)
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x3c715
testb $0x1, 0xf(%rsp)
je 0x3c79a
movq 0x46842(%rip), %rdi     # 0x82fd0
movq 0x46823(%rip), %rsi     # 0x82fb8
callq 0x6370
movss 0x8(%rsp), %xmm0
movl 0x14(%rsp), %eax
cvtsi2ss %rax, %xmm1
divss %xmm1, %xmm0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, 0x28(%rax)
je 0x3fd74
jmp 0x3fd93
leaq 0x1e893(%rip), %rdi     # 0x5e60e
leaq 0x1e7c3(%rip), %rsi     # 0x5e545
movl $0x141, %edx            # imm = 0x141
leaq 0x1e892(%rip), %rcx     # 0x5e620
callq 0x6220
callq 0x84f0
movq (%rsp), %rax
movss %xmm0, 0x10(%rsp)
movq 0x28(%rax), %rdi
movq 0x18(%rsp), %rsi
movl 0x34(%rax), %ecx
subl 0x14(%rsp), %ecx
movl $0x1, %edx
xorl %r8d, %r8d
callq 0x3c6b0
movss %xmm0, 0xc(%rsp)
callq 0x84f0
movq (%rsp), %rax
subss 0x10(%rsp), %xmm0
addss 0x18(%rax), %xmm0
movss %xmm0, 0x18(%rax)
movss 0xc(%rsp), %xmm0
addq $0x28, %rsp
retq
nopl (%rax)
// File: bonetblai[P]mdp-engine/ctp3/../engine/aot.h
// Function: Online::Policy::AOT::aot_t<state_t>::clear_leaf_selection_strategy()
void clear_leaf_selection_strategy() {
        setup_expansion_loop_ptr_ = 0;
        prepare_next_expansion_iteration_ptr_ = 0;
        exist_nodes_to_expand_ptr_ = 0;
        select_node_for_expansion_ptr_ = 0;
        clear_internal_state_ptr_ = 0;
    }

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq $0x0, 0x170(%rax)
movq $0x0, 0x168(%rax)
movq $0x0, 0x180(%rax)
movq $0x0, 0x178(%rax)
movq $0x0, 0x190(%rax)
movq $0x0, 0x188(%rax)
movq $0x0, 0x1a0(%rax)
movq $0x0, 0x198(%rax)
movq $0x0, 0x1b0(%rax)
movq $0x0, 0x1a8(%rax)
retq
nopl (%rax)
// File: bonetblai[P]mdp-engine/ctp3/../engine/aot.h
// Function: Online::Policy::AOT::aot_t<state_t>::set_leaf_selection_strategy(int)
void set_leaf_selection_strategy(int strategy) {
        if( strategy == 1 ) {
            random_setup_selection_strategy();
        } else {
            delta_setup_selection_strategy();
        }
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
cmpl $0x1, 0xc(%rsp)
jne 0x42618
movq (%rsp), %rdi
callq 0x46b40
jmp 0x42621
movq (%rsp), %rdi
callq 0x46bd0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, 0x48(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x28(%rsp)
movl $0x1b8, %edi            # imm = 0x1B8
callq 0x6340
movq %rax, %rdi
movq 0x28(%rsp), %rax
movq %rdi, %rcx
movq %rcx, 0x30(%rsp)
movq 0x8(%rax), %rsi
movq 0x28(%rax), %rdx
movl 0x30(%rax), %ecx
movl 0x34(%rax), %r8d
movss 0x38(%rax), %xmm0
movl 0x40(%rax), %r11d
movl 0x44(%rax), %ebx
movl 0x48(%rax), %ebp
movl 0x4c(%rax), %r14d
movzbl 0x3c(%rax), %r9d
movzbl 0x3d(%rax), %r10d
movq %rsp, %rax
movl %r14d, 0x20(%rax)
movl %ebp, 0x18(%rax)
movl %ebx, 0x10(%rax)
movl %r11d, 0x8(%rax)
andl $0x1, %r10d
movl %r10d, (%rax)
andl $0x1, %r9d
callq 0x4c5a0
jmp 0x42770
movq 0x30(%rsp), %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq 0x30(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
callq 0x6310
movq 0x40(%rsp), %rdi
callq 0x6520
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
xorps %xmm0, %xmm0
movss %xmm0, 0x14(%rax)
xorps %xmm0, %xmm0
movss %xmm0, 0x18(%rax)
xorps %xmm0, %xmm0
movss %xmm0, 0x1c(%rax)
movq 0x8(%rax), %rdi
callq 0x1a2e0
movq 0x8(%rsp), %rax
cmpq $0x0, 0x28(%rax)
je 0x43d7f
movq 0x8(%rsp), %rax
movq 0x28(%rax), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movq 0x8(%rsp), %rax
cmpq $0x0, 0x98(%rax)
je 0x43d9f
movq 0x8(%rsp), %rax
movq 0x98(%rax), %rdi
callq 0x23930
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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:
subq $0xc8, %rsp
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movl %edx, 0xb4(%rsp)
movq 0xc0(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0xb8(%rsp), %rax
movq %rax, 0x58(%rsp)
movl 0xb4(%rsp), %edi
callq 0x1a300
movq 0x58(%rsp), %rdi
movl %eax, 0xb0(%rsp)
movl 0xb0(%rsp), %esi
callq 0x63c0
movq %rax, %rdi
leaq 0x1a0e1(%rip), %rsi     # 0x5def7
callq 0x6330
movq %rax, %rdi
leaq 0x1976c(%rip), %rsi     # 0x5d591
callq 0x6330
movq 0x60(%rsp), %rsi
movq %rax, 0x68(%rsp)
movq (%rsi), %rax
movq 0x18(%rax), %rax
leaq 0x90(%rsp), %rdi
movq %rdi, 0x70(%rsp)
callq *%rax
movq 0x68(%rsp), %rdi
movq 0x70(%rsp), %rsi
callq 0x62f0
movq %rax, 0x78(%rsp)
jmp 0x43e60
movq 0x78(%rsp), %rdi
leaq 0x19738(%rip), %rsi     # 0x5d5a4
callq 0x6330
movq %rax, 0x50(%rsp)
jmp 0x43e78
movq 0x50(%rsp), %rdi
movq 0x60(%rsp), %rax
movl 0x20(%rax), %esi
callq 0x6440
movq %rax, 0x48(%rsp)
jmp 0x43e91
movq 0x48(%rsp), %rdi
leaq 0x1bfcf(%rip), %rsi     # 0x5fe6c
callq 0x6330
movq %rax, 0x40(%rsp)
jmp 0x43ea9
movq 0x40(%rsp), %rdi
movq 0x60(%rsp), %rax
movss 0x150(%rax), %xmm0
movss 0x154(%rax), %xmm2
movaps %xmm0, %xmm1
addss %xmm2, %xmm1
divss %xmm1, %xmm0
callq 0x6270
movq %rax, 0x38(%rsp)
jmp 0x43eda
movq 0x38(%rsp), %rdi
leaq 0x1bf8c(%rip), %rsi     # 0x5fe72
callq 0x6330
movq %rax, 0x30(%rsp)
jmp 0x43ef2
movq 0x30(%rsp), %rdi
movq 0x60(%rsp), %rax
movss 0x150(%rax), %xmm1
movss 0x154(%rax), %xmm0
addss %xmm0, %xmm1
divss %xmm1, %xmm0
callq 0x6270
movq %rax, 0x28(%rsp)
jmp 0x43f20
movq 0x28(%rsp), %rdi
leaq 0x1bf4d(%rip), %rsi     # 0x5fe79
callq 0x6330
movq %rax, 0x20(%rsp)
jmp 0x43f38
movq 0x20(%rsp), %rdi
movq 0x60(%rsp), %rax
movl 0x160(%rax), %esi
callq 0x6440
movq %rax, 0x18(%rsp)
jmp 0x43f54
movq 0x18(%rsp), %rdi
leaq 0x1bf27(%rip), %rsi     # 0x5fe87
callq 0x6330
movq %rax, 0x10(%rsp)
jmp 0x43f6c
movq 0x10(%rsp), %rdi
movq 0x60(%rsp), %rax
movl 0x164(%rax), %esi
callq 0x6440
movq %rax, 0x8(%rsp)
jmp 0x43f88
movq 0x8(%rsp), %rdi
movq 0x3f024(%rip), %rsi     # 0x82fb8
callq 0x6370
jmp 0x43f9b
leaq 0x90(%rsp), %rdi
callq 0x61f0
movq 0x60(%rsp), %rax
cmpq $0x0, 0x28(%rax)
je 0x43ffa
movq 0x60(%rsp), %rax
movq 0x28(%rax), %rdi
movq 0xb8(%rsp), %rsi
movl 0xb4(%rsp), %edx
addl $0x2, %edx
movq (%rdi), %rax
callq *0x30(%rax)
jmp 0x43ffa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
leaq 0x90(%rsp), %rdi
callq 0x61f0
jmp 0x44002
addq $0xc8, %rsp
retq
movq 0x88(%rsp), %rdi
callq 0x6520
nop
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x1, 0x1c(%rsp)
movq 0x10(%rsp), %rcx
movl 0x1c(%rsp), %eax
cmpl 0x18(%rcx), %eax
ja 0x451d5
movq 0x10(%rsp), %rdi
movq 0x8(%rdi), %rax
movq %rax, 0x8(%rsp)
addq $0x20, %rdi
movl 0x1c(%rsp), %eax
movl %eax, %esi
callq 0x46590
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rdi
movq (%rax), %rax
movq %rcx, 0x10(%rax)
addq $0x20, %rdi
movl 0x1c(%rsp), %eax
movl %eax, %esi
callq 0x46590
movq 0x10(%rsp), %rdi
movq (%rax), %rax
movq %rax, 0x8(%rdi)
addq $0x20, %rdi
movl 0x1c(%rsp), %eax
movl %eax, %esi
callq 0x46590
movq $0x0, (%rax)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x4515b
movq 0x10(%rsp), %rdi
movl $0x0, 0x18(%rdi)
addq $0x40, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x465b0
movq %rax, %rdi
movq 0x10(%rsp), %rax
movl 0x4(%rax), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edx
shlq $0x2, %rdx
xorl %esi, %esi
callq 0x61b0
movq 0x10(%rsp), %rdi
movl $0x0, 0x38(%rdi)
callq 0x465d0
testb $0x1, %al
jne 0x45222
jmp 0x45224
jmp 0x45243
leaq 0x19517(%rip), %rdi     # 0x5e742
leaq 0x19518(%rip), %rsi     # 0x5e74a
movl $0x12f, %edx            # imm = 0x12F
leaq 0x1952b(%rip), %rcx     # 0x5e769
callq 0x6220
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x1, 0x14(%rsp)
movq 0x8(%rsp), %rcx
movl 0x14(%rsp), %eax
cmpl 0x18(%rcx), %eax
ja 0x466a1
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x46850
testb $0x1, %al
jne 0x46692
movq 0x3c97e(%rip), %rdi     # 0x82fd0
leaq 0x1825d(%rip), %rsi     # 0x5e8b6
callq 0x6330
movq %rax, %rdi
movl 0x14(%rsp), %esi
callq 0x6440
movq %rax, %rdi
leaq 0x18611(%rip), %rsi     # 0x5ec85
callq 0x6330
movq %rax, %rdi
movq 0x3c935(%rip), %rsi     # 0x82fb8
callq 0x6370
movb $0x0, 0x27(%rsp)
jmp 0x46721
jmp 0x46694
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x4662b
movl $0x1, 0x10(%rsp)
movq 0x8(%rsp), %rcx
movl 0x10(%rsp), %eax
cmpl 0x18(%rcx), %eax
ja 0x4671c
movq 0x8(%rsp), %rdi
movl 0x10(%rsp), %esi
callq 0x469e0
testb $0x1, %al
jne 0x4670d
movq 0x3c900(%rip), %rdi     # 0x82fd0
leaq 0x1820a(%rip), %rsi     # 0x5e8e1
callq 0x6330
movq %rax, %rdi
movl 0x10(%rsp), %esi
callq 0x6440
movq %rax, %rdi
leaq 0x18593(%rip), %rsi     # 0x5ec85
callq 0x6330
movq %rax, %rdi
movq 0x3c8b7(%rip), %rsi     # 0x82fb8
callq 0x6370
movb $0x0, 0x27(%rsp)
jmp 0x46721
jmp 0x4670f
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x466a9
movb $0x1, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x1, 0x14(%rsp)
movq 0x8(%rsp), %rcx
movl 0x14(%rsp), %eax
cmpl 0x38(%rcx), %eax
ja 0x467c1
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x46850
testb $0x1, %al
jne 0x467b2
movq 0x3c85e(%rip), %rdi     # 0x82fd0
leaq 0x18190(%rip), %rsi     # 0x5e909
callq 0x6330
movq %rax, %rdi
movl 0x14(%rsp), %esi
callq 0x6440
movq %rax, %rdi
leaq 0x184f1(%rip), %rsi     # 0x5ec85
callq 0x6330
movq %rax, %rdi
movq 0x3c815(%rip), %rsi     # 0x82fb8
callq 0x6370
movb $0x0, 0x27(%rsp)
jmp 0x46841
jmp 0x467b4
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x4674b
movl $0x1, 0x10(%rsp)
movq 0x8(%rsp), %rcx
movl 0x10(%rsp), %eax
cmpl 0x38(%rcx), %eax
ja 0x4683c
movq 0x8(%rsp), %rdi
movl 0x10(%rsp), %esi
callq 0x46ae0
testb $0x1, %al
jne 0x4682d
movq 0x3c7e0(%rip), %rdi     # 0x82fd0
leaq 0x1813d(%rip), %rsi     # 0x5e934
callq 0x6330
movq %rax, %rdi
movl 0x10(%rsp), %esi
callq 0x6440
movq %rax, %rdi
leaq 0x18473(%rip), %rsi     # 0x5ec85
callq 0x6330
movq %rax, %rdi
movq 0x3c797(%rip), %rsi     # 0x82fb8
callq 0x6370
movb $0x0, 0x27(%rsp)
jmp 0x46841
jmp 0x4682f
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x467c9
movb $0x1, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movl %esi, 0x54(%rsp)
movq 0x58(%rsp), %rcx
movq %rcx, 0x40(%rsp)
movl 0x54(%rsp), %eax
shll %eax
movl %eax, 0x50(%rsp)
movl 0x50(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4c(%rsp)
movl 0x50(%rsp), %eax
cmpl 0x38(%rcx), %eax
ja 0x46921
movq 0x40(%rsp), %rdi
movq %rdi, %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
movq %rdi, %rax
addq $0x20, %rax
movq %rax, 0x20(%rsp)
addq $0x40, %rdi
movl 0x54(%rsp), %eax
movl %eax, %esi
callq 0x46ac0
movq 0x20(%rsp), %rdi
movl (%rax), %eax
movl %eax, %esi
callq 0x46aa0
movq 0x40(%rsp), %rdi
movq (%rax), %rax
movq (%rax), %rax
movq %rax, 0x38(%rsp)
movq %rdi, %rax
addq $0x20, %rax
movq %rax, 0x28(%rsp)
addq $0x40, %rdi
movl 0x50(%rsp), %eax
movl %eax, %esi
callq 0x46ac0
movq 0x28(%rsp), %rdi
movl (%rax), %eax
movl %eax, %esi
callq 0x46aa0
movq 0x30(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq (%rax), %rax
movq (%rax), %rdx
callq 0x46a40
testb $0x1, %al
jne 0x46917
jmp 0x46921
movb $0x0, 0x67(%rsp)
jmp 0x469cb
movq 0x40(%rsp), %rcx
movl 0x4c(%rsp), %eax
cmpl 0x38(%rcx), %eax
ja 0x469c6
movq 0x40(%rsp), %rdi
movq %rdi, %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
movq %rdi, %rax
addq $0x20, %rax
movq %rax, (%rsp)
addq $0x40, %rdi
movl 0x54(%rsp), %eax
movl %eax, %esi
callq 0x46ac0
movq (%rsp), %rdi
movl (%rax), %eax
movl %eax, %esi
callq 0x46aa0
movq 0x40(%rsp), %rdi
movq (%rax), %rax
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movq %rdi, %rax
addq $0x20, %rax
movq %rax, 0x8(%rsp)
addq $0x40, %rdi
movl 0x4c(%rsp), %eax
movl %eax, %esi
callq 0x46ac0
movq 0x8(%rsp), %rdi
movl (%rax), %eax
movl %eax, %esi
callq 0x46aa0
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq (%rax), %rax
movq (%rax), %rdx
callq 0x46a40
testb $0x1, %al
jne 0x469bf
jmp 0x469c6
movb $0x0, 0x67(%rsp)
jmp 0x469cb
movb $0x1, 0x67(%rsp)
movb 0x67(%rsp), %al
andb $0x1, %al
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: bonetblai[P]mdp-engine/ctp3/../engine/aot.h
// Function: Online::Policy::AOT::aot_t<state_t>::random_setup_selection_strategy()
void random_setup_selection_strategy() {
        setup_expansion_loop_ptr_ = &aot_t::random_setup_expansion_loop;
        prepare_next_expansion_iteration_ptr_ = &aot_t::random_prepare_next_expansion_iteration;
        exist_nodes_to_expand_ptr_ = &aot_t::random_exist_nodes_to_expand;
        select_node_for_expansion_ptr_ = &aot_t::random_select_node_for_expansion;
        clear_internal_state_ptr_ = &aot_t::random_clear_internal_state;
    }

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
leaq 0x10f(%rip), %rcx       # 0x46c60
movq %rcx, 0x168(%rax)
movq $0x0, 0x170(%rax)
leaq 0x116(%rip), %rcx       # 0x46c80
movq %rcx, 0x178(%rax)
movq $0x0, 0x180(%rax)
leaq 0x2cd(%rip), %rcx       # 0x46e50
movq %rcx, 0x188(%rax)
movq $0x0, 0x190(%rax)
leaq 0x2d4(%rip), %rcx       # 0x46e70
movq %rcx, 0x198(%rax)
movq $0x0, 0x1a0(%rax)
leaq 0x2eb(%rip), %rcx       # 0x46ea0
movq %rcx, 0x1a8(%rax)
movq $0x0, 0x1b0(%rax)
retq
nopl (%rax,%rax)
// File: bonetblai[P]mdp-engine/ctp3/../engine/aot.h
// Function: Online::Policy::AOT::aot_t<state_t>::delta_setup_selection_strategy()
void delta_setup_selection_strategy() {
        setup_expansion_loop_ptr_ = &aot_t::delta_setup_expansion_loop;
        prepare_next_expansion_iteration_ptr_ = &aot_t::delta_prepare_next_expansion_iteration;
        exist_nodes_to_expand_ptr_ = &aot_t::delta_exist_nodes_to_expand;
        select_node_for_expansion_ptr_ = &aot_t::delta_select_node_for_expansion;
        clear_internal_state_ptr_ = &aot_t::delta_clear_internal_state;
    }

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
leaq 0x5ff(%rip), %rcx       # 0x471e0
movq %rcx, 0x168(%rax)
movq $0x0, 0x170(%rax)
leaq 0x646(%rip), %rcx       # 0x47240
movq %rcx, 0x178(%rax)
movq $0x0, 0x180(%rax)
leaq 0x65d(%rip), %rcx       # 0x47270
movq %rcx, 0x188(%rax)
movq $0x0, 0x190(%rax)
leaq 0x664(%rip), %rcx       # 0x47290
movq %rcx, 0x198(%rax)
movq $0x0, 0x1a0(%rax)
leaq 0x66b(%rip), %rcx       # 0x472b0
movq %rcx, 0x1a8(%rax)
movq $0x0, 0x1b0(%rax)
retq
nopl (%rax,%rax)
// File: bonetblai[P]mdp-engine/ctp3/../engine/aot.h
// Function: Online::Policy::AOT::aot_t<state_t>::random_prepare_next_expansion_iteration(Online::Policy::AOT::state_node_t<state_t>*) const
void random_prepare_next_expansion_iteration(state_node_t<T> *node) const {
        if( node->is_leaf() ) {
            if( !node->is_goal_ && !node->is_dead_end_ && (node->depth_ < horizon_) ) {
                if( (random_leaf_ == 0) || (Random::real() < 0.5) )
                    random_leaf_ = node;
            }
        } else {
            assert(!node->children_.empty());
            for( int i = 0, isz = node->children_.size(); i < isz; ++i ) {
                action_node_t<T> *a_node = node->children_[i];
                assert(!a_node->children_.empty());
                for( int j = 0, jsz = a_node->children_.size(); j < jsz; ++j ) {
                    state_node_t<T> *s_node = a_node->children_[j].second;
                    random_prepare_next_expansion_iteration(s_node);
                }
            }
        }
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
movq 0x28(%rsp), %rdi
callq 0x46ec0
testb $0x1, %al
jne 0x46ca7
jmp 0x46d13
movq 0x28(%rsp), %rax
testb $0x1, 0x88(%rax)
jne 0x46d0e
movq 0x28(%rsp), %rax
testb $0x1, 0x89(%rax)
jne 0x46d0e
movq (%rsp), %rcx
movq 0x28(%rsp), %rax
movl 0x8c(%rax), %eax
cmpl 0x34(%rcx), %eax
jae 0x46d0e
movq (%rsp), %rax
cmpq $0x0, 0x158(%rax)
je 0x46cfc
callq 0x19b50
cvtss2sd %xmm0, %xmm1
movsd 0x16362(%rip), %xmm0    # 0x5d058
ucomisd %xmm1, %xmm0
jbe 0x46d0c
movq (%rsp), %rax
movq 0x28(%rsp), %rcx
movq %rcx, 0x158(%rax)
jmp 0x46d0e
jmp 0x46e3c
movq 0x28(%rsp), %rdi
addq $0xa8, %rdi
callq 0x46f20
xorb $-0x1, %al
testb $0x1, %al
jne 0x46d2c
jmp 0x46d2e
jmp 0x46d4d
leaq 0x17c27(%rip), %rdi     # 0x5e95c
leaq 0x17c39(%rip), %rsi     # 0x5e975
movl $0x442, %edx            # imm = 0x442
leaq 0x17c3d(%rip), %rcx     # 0x5e985
callq 0x6220
movl $0x0, 0x24(%rsp)
movq 0x28(%rsp), %rdi
addq $0xa8, %rdi
callq 0x46f70
movl %eax, 0x20(%rsp)
movl 0x24(%rsp), %eax
cmpl 0x20(%rsp), %eax
jge 0x46e3a
movq 0x28(%rsp), %rdi
addq $0xa8, %rdi
movslq 0x24(%rsp), %rsi
callq 0x46f90
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
addq $0x28, %rdi
callq 0x46fb0
xorb $-0x1, %al
testb $0x1, %al
jne 0x46dac
jmp 0x46dae
jmp 0x46dcd
leaq 0x17c49(%rip), %rdi     # 0x5e9fe
leaq 0x17bb9(%rip), %rsi     # 0x5e975
movl $0x445, %edx            # imm = 0x445
leaq 0x17bbd(%rip), %rcx     # 0x5e985
callq 0x6220
movl $0x0, 0x14(%rsp)
movq 0x18(%rsp), %rdi
addq $0x28, %rdi
callq 0x47000
movl %eax, 0x10(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x10(%rsp), %eax
jge 0x46e28
movq 0x18(%rsp), %rdi
addq $0x28, %rdi
movslq 0x14(%rsp), %rsi
callq 0x47020
movq (%rsp), %rdi
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rsi
callq 0x46c80
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x46de7
jmp 0x46e2a
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x46d6a
jmp 0x46e3c
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: bonetblai[P]mdp-engine/ctp3/../engine/aot.h
// Function: Online::Policy::AOT::aot_t<state_t>::insert_into_priority_queue(Online::Policy::AOT::node_t<state_t>*) const
void insert_into_priority_queue(node_t<T> *node) const {
        if( !node->in_pq_ ) {
            float sign = copysignf(1, node->delta_);
            if( sign == 1 ) {
#ifdef DEBUG
                std::cout << "push:in  " << node << "=";
                node->print(std::cout, false);
                std::cout << std::endl;
#endif
                insert_into_inside_priority_queue(node);
            } else {
#ifdef DEBUG
                std::cout << "push:out " << node << "=";
                node->print(std::cout, false);
                std::cout << std::endl;
#endif
                insert_into_outside_priority_queue(node);
            }
        }
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
testb $0x1, 0x16(%rax)
jne 0x47380
movq 0x18(%rsp), %rax
movss 0xc(%rax), %xmm0
movaps 0x15cfc(%rip), %xmm1    # 0x5d030
pand %xmm1, %xmm0
movaps 0x15d01(%rip), %xmm1    # 0x5d040
por %xmm1, %xmm0
movss %xmm0, 0x14(%rsp)
movss 0x14(%rsp), %xmm0
movss 0x15cad(%rip), %xmm1    # 0x5d004
ucomiss %xmm1, %xmm0
jne 0x4736f
jp 0x4736f
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x473f0
jmp 0x4737e
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x474b0
jmp 0x47380
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nop