LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/bonetblai[P]mdp-engine/ctp3/../engine/value_iteration.h
// Function: Algorithm::value_iteration_t<state_t>::solve(state_t const&, Problem::hash_t<state_t>&) const
virtual void solve(const T &s, Problem::hash_t<T> &hash) const {
        reset_stats(hash);
        Heuristic::wrapper_t<T> eval_function(heuristic_);
        hash.set_eval_function(&eval_function);

        state_space_t<T> state_space(problem_);
        state_space.generate_space(s, hash);

#ifdef DEBUG
        std::cout << "debug: value-iteration(): state-space-size = " << hash.size() << std::endl;
#endif

        size_t iters = 0;
        float residual = 1 + epsilon_;
        while( residual > epsilon_ ) {
            if( iters > max_number_iterations_ ) break;
            residual = 0;
            for( hash_iterator hi = hash.begin(); hi != hash.end(); ++hi ) {
                float hv = hi->second->value();
                std::pair<Problem::action_t, float> p = hash.best_q_value(hi->first);
                float res = (float)fabs(p.second - hv);
                residual = Utils::max(residual, res);
                hi->second->update(p.second);
                hash.inc_updates();

#ifdef DEBUG
                if( res > epsilon_ ) {
                    std::cout << "debug: value-iteration(): value for " << hi->first
                              << " changed from " << hv
                              << " to " << p.second
                              << std::endl;
                }
#endif
            }
            ++iters;

#ifdef DEBUG
            std::cout << "debug: value-iteration(): residual=" << residual << std::endl;
#endif
        }
        hash.set_eval_function(0);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq (%rdi), %rax
movq %rdx, %rsi
callq *0x30(%rax)
movq 0x10(%r14), %rax
leaq 0x21cec(%rip), %rcx     # 0x341a0
leaq 0x10(%rsp), %rdx
movq %rcx, (%rdx)
movq %rax, 0x8(%rdx)
movq %rdx, 0x40(%rbx)
movq 0x8(%r14), %rax
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
movq %r15, %rsi
movq %rbx, %rdx
callq 0x125a2
movss 0x1c(%r14), %xmm0
movss 0xdb23(%rip), %xmm1     # 0x2000c
addss %xmm0, %xmm1
leaq 0x18(%rbx), %r15
xorl %r12d, %r12d
ucomiss %xmm0, %xmm1
jbe 0x12564
movl 0x20(%r14), %eax
cmpq %rax, %r12
ja 0x12564
xorps %xmm1, %xmm1
movq %r15, %r13
movq (%r13), %r13
testq %r13, %r13
je 0x12559
leaq 0x8(%r13), %rsi
movq 0x78(%r13), %rax
movss (%rax), %xmm0
movss %xmm0, (%rsp)
movq %rbx, %rdi
movss %xmm1, 0x4(%rsp)
callq 0xd74c
movss 0x4(%rsp), %xmm1
shrq $0x20, %rax
movd %eax, %xmm0
subss (%rsp), %xmm0
andps 0xdb16(%rip), %xmm0     # 0x20060
maxss %xmm0, %xmm1
movq 0x78(%r13), %rcx
movl %eax, (%rcx)
incl 0x50(%rbx)
jmp 0x12508
incq %r12
movss 0x1c(%r14), %xmm0
jmp 0x124f4
andq $0x0, 0x40(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/bonetblai[P]mdp-engine/ctp3/../engine/heuristic.h
// Function: Heuristic::min_min_heuristic_t<state_t>::value(state_t const&) const
virtual float value(const T &s) const {
        float start_time = Utils::read_time_in_seconds();
        ++evaluations_;
        float hvalue = hash_ == 0 ? 0 : hash_->value(s);
        eval_time_ += Utils::read_time_in_seconds() - start_time;
        return hvalue;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x62f2
incl 0x18(%rbx)
movss %xmm0, 0x4(%rsp)
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x12c0f
movq %r14, %rsi
callq 0xf4b0
jmp 0x12c12
xorps %xmm0, %xmm0
movss %xmm0, (%rsp)
callq 0x62f2
subss 0x4(%rsp), %xmm0
addss 0x10(%rbx), %xmm0
movss %xmm0, 0x10(%rbx)
movss (%rsp), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/bonetblai[P]mdp-engine/ctp3/../engine/heuristic.h
// Function: Heuristic::min_min_heuristic_t<state_t>::set_parameters(std::multimap<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>> const&, Dispatcher::dispatcher_t<state_t>&)
virtual void set_parameters(const std::multimap<std::string, std::string> &parameters, Dispatcher::dispatcher_t<T> &dispatcher) {
        std::multimap<std::string, std::string>::const_iterator it = parameters.find("algorithm");
        if( it != parameters.end() ) {
            delete algorithm_;
            dispatcher.create_request(problem_, it->first, it->second);
            algorithm_ = dispatcher.fetch_algorithm(it->second);
        }
#ifdef DEBUG
        std::cout << "debug: min-min(): params:"
                  << " algorithm=" << (algorithm_ == 0 ? std::string("null") : algorithm_->name())
                  << std::endl;
#endif
        solve_problem();
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
leaq 0xd5d4(%rip), %rsi      # 0x2023d
leaq 0x8(%rsp), %r15
leaq 0x7(%rsp), %rdx
movq %r15, %rdi
callq 0x50e0
movq %r12, %rdi
movq %r15, %rsi
callq 0xcea2
movq %rax, %r15
leaq 0x8(%rsp), %rdi
callq 0x5120
addq $0x8, %r12
cmpq %r12, %r15
je 0x12cd1
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x12cab
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x8(%rbx), %rsi
leaq 0x20(%r15), %rdx
addq $0x40, %r15
movq %r14, %rdi
movq %r15, %rcx
callq 0x6dfe
movq %r14, %rdi
movq %r15, %rsi
callq 0x775e
movq %rax, 0x28(%rbx)
movq %rbx, %rdi
callq 0x13514
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5120
movq %rbx, %rdi
callq 0x5410
// File: /workspace/github_cpp_makefile_star2_O2/bonetblai[P]mdp-engine/ctp3/../engine/problem.h
// Function: Problem::min_hash_t<state_t>::q_value(state_t const&, int) const
inline float min_hash_t<T>::q_value(const T &s, action_t a) const {
    if( hash_t<T>::problem_.terminal(s) ) return 0;

    std::vector<std::pair<T, float> > outcomes;
    hash_t<T>::problem_.next(s, a, outcomes);
    unsigned osize = outcomes.size();

    float qv = std::numeric_limits<float>::max();
    for( unsigned i = 0; i < osize; ++i ) {
        qv = Utils::min(qv, this->value(outcomes[i].first));
    }
    return qv == std::numeric_limits<float>::max() ? std::numeric_limits<float>::max() : hash_t<T>::problem_.cost(s, a) + hash_t<T>::problem_.discount() * qv;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x48(%rdi), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
xorps %xmm0, %xmm0
testb %al, %al
jne 0x12e26
leaq 0x10(%rsp), %rcx
andq $0x0, 0x10(%rcx)
xorps %xmm0, %xmm0
movaps %xmm0, (%rcx)
movq 0x48(%rbx), %rdi
movq (%rdi), %rax
movq %r14, %rsi
movl %ebp, %edx
callq *0x60(%rax)
movq 0x18(%rsp), %rax
subq 0x10(%rsp), %rax
pushq $0x78
popq %rcx
cqto
idivq %rcx
movl %eax, %eax
imulq $0x78, %rax, %r15
movss 0xd264(%rip), %xmm0     # 0x20014
xorl %r12d, %r12d
cmpq %r12, %r15
movss %xmm0, 0xc(%rsp)
je 0x12de1
movq 0x10(%rsp), %rsi
addq %r12, %rsi
movq %rbx, %rdi
callq 0xf4b0
movss 0xc(%rsp), %xmm1
minss %xmm0, %xmm1
movaps %xmm1, %xmm0
addq $0x78, %r12
jmp 0x12db3
movss 0xd22b(%rip), %xmm1     # 0x20014
ucomiss %xmm1, %xmm0
je 0x12e10
movq 0x48(%rbx), %rdi
movq (%rdi), %rax
movq %r14, %rsi
movl %ebp, %edx
callq *0x48(%rax)
movq 0x48(%rbx), %rax
movss 0xc(%rsp), %xmm1
mulss 0x8(%rax), %xmm1
addss %xmm0, %xmm1
movss %xmm1, 0xc(%rsp)
leaq 0x10(%rsp), %rdi
callq 0xb53c
movss 0xc(%rsp), %xmm0
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x12e37
jmp 0x12e37
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xb53c
movq %rbx, %rdi
callq 0x5410
// File: /workspace/github_cpp_makefile_star2_O2/bonetblai[P]mdp-engine/ctp3/../engine/problem.h
// Function: Problem::hash_t<state_t>::q_value(state_t const&, int) const
inline float hash_t<T>::q_value(const T &s, action_t a) const {
    if( problem_.terminal(s) ) return 0;

    std::vector<std::pair<T, float> > outcomes;
    problem_.next(s, a, outcomes);
    unsigned osize = outcomes.size();

    float qv = 0.0;
    for( unsigned i = 0; i < osize; ++i ) {
        qv += outcomes[i].second * this->value(outcomes[i].first);
    }
    return problem_.cost(s, a) + problem_.discount() * qv;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x48(%rdi), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
xorps %xmm0, %xmm0
testb %al, %al
jne 0x12f3d
leaq 0x10(%rsp), %rcx
andq $0x0, 0x10(%rcx)
xorps %xmm0, %xmm0
movaps %xmm0, (%rcx)
movq 0x48(%rbx), %rdi
movq (%rdi), %rax
movq %r14, %rsi
movl %ebp, %edx
callq *0x60(%rax)
movq 0x18(%rsp), %rax
subq 0x10(%rsp), %rax
pushq $0x78
popq %rcx
cqto
idivq %rcx
movl %eax, %eax
imulq $0x78, %rax, %r15
xorps %xmm0, %xmm0
xorl %r12d, %r12d
movss %xmm0, 0x8(%rsp)
cmpq %r12, %r15
je 0x12f05
movq 0x10(%rsp), %rsi
movss 0x70(%rsi,%r12), %xmm0
movss %xmm0, 0xc(%rsp)
addq %r12, %rsi
movq %rbx, %rdi
callq 0xf4b0
mulss 0xc(%rsp), %xmm0
movss 0x8(%rsp), %xmm1
addss %xmm0, %xmm1
movaps %xmm1, %xmm0
addq $0x78, %r12
jmp 0x12ec4
movq 0x48(%rbx), %rdi
movq (%rdi), %rax
movq %r14, %rsi
movl %ebp, %edx
callq *0x48(%rax)
movq 0x48(%rbx), %rax
movss 0x8(%rsp), %xmm1
mulss 0x8(%rax), %xmm1
addss %xmm0, %xmm1
movss %xmm1, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
callq 0xb53c
movss 0x8(%rsp), %xmm0
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x12f4e
jmp 0x12f4e
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xb53c
movq %rbx, %rdi
callq 0x5410
nop
// File: /workspace/github_cpp_makefile_star2_O2/bonetblai[P]mdp-engine/ctp3/../engine/hash.h
// Function: Hash::data_t::print(std::ostream&) const
void print(std::ostream &os) const {
        os << "(" << value_
           << ", " << (solved_ ? 1 : 0)
           << ", " << (marked_ ? 1 : 0)
           << ", " << count_
           << ", " << action_
           << ")";
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rax
movq %rdi, %rbx
leaq 0xdd94(%rip), %rsi      # 0x2102f
movq %rax, %rdi
callq 0x5290
movss (%rbx), %xmm0
movq %rax, %rdi
callq 0x51f0
leaq 0xdc6a(%rip), %r14      # 0x20f20
movq %rax, %rdi
movq %r14, %rsi
callq 0x5290
movzbl 0x4(%rbx), %esi
movq %rax, %rdi
callq 0x5400
movq %rax, %rdi
movq %r14, %rsi
callq 0x5290
movzbl 0x5(%rbx), %esi
movq %rax, %rdi
callq 0x5400
movq %rax, %rdi
movq %r14, %rsi
callq 0x5290
movq 0x8(%rbx), %rsi
movq %rax, %rdi
callq 0x51c0
movq %rax, %rdi
movq %r14, %rsi
callq 0x5290
movl 0x10(%rbx), %esi
movq %rax, %rdi
callq 0x5400
leaq 0xd115(%rip), %rsi      # 0x2042d
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x5290
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xdced(%rip), %rsi      # 0x2102f
movq %rbx, %rdi
callq 0x5290
movl (%r14), %esi
movq %rax, %rdi
callq 0x5400
leaq 0xdabe(%rip), %rsi      # 0x20e1a
movq %rax, %rdi
callq 0x5290
movq %rax, %r15
leaq 0x4(%r14), %rdi
movq %rax, %rsi
callq 0x13402
leaq 0xdba9(%rip), %rsi      # 0x20f23
movq %r15, %rdi
callq 0x5290
xorl %r12d, %r12d
leaq 0x8(%rsp), %r15
xorl %r13d, %r13d
movslq 0x21ef4(%rip), %rax     # 0x35288
cmpq %rax, %r13
jge 0x133bb
movl 0x4c(%r14,%r13,4), %eax
movl %eax, 0x8(%rsp)
movl %r12d, 0xc(%rsp)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x134c2
incq %r13
addl $0x20, %r12d
jmp 0x1338d
leaq 0xdb66(%rip), %rsi      # 0x20f28
movq %rbx, %rdi
callq 0x5290
movq %r14, %rdi
callq 0x93c2
testb %al, %al
je 0x133e5
leaq 0xdb4d(%rip), %rsi      # 0x20f2a
movq %rbx, %rdi
callq 0x5290
leaq 0xd041(%rip), %rsi      # 0x2042d
movq %rbx, %rdi
callq 0x5290
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl (%rdi), %ebp
testl %ebp, %ebp
je 0x1350b
movq %rsi, %rbx
movq %rdi, %r14
xorl %r12d, %r12d
leaq 0xd93a(%rip), %r15      # 0x20e1a
testl %ebp, %ebp
je 0x1350b
testb $0x1, %bpl
je 0x13504
movl 0x4(%r14), %esi
addl %r12d, %esi
movq %rbx, %rdi
callq 0x5400
movq %rax, %rdi
movq %r15, %rsi
callq 0x5290
incl %r12d
shrl %ebp
jmp 0x134e0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r14
pushq %rbx
subq $0x28, %rsp
cmpq $0x0, 0x28(%rdi)
je 0x13566
movq %rdi, %rbx
callq 0x62f2
movss %xmm0, 0x4(%rsp)
movq 0x8(%rbx), %rdi
movq 0x28(%rbx), %r14
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x20(%rbx), %rdx
movq (%r14), %rcx
movq %r14, %rdi
movq %rax, %rsi
callq *0x28(%rcx)
callq 0x62f2
subss 0x4(%rsp), %xmm0
movss %xmm0, 0x14(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r14
retq
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xc1ab
movq 0x21a5e(%rip), %rdi     # 0x34fd8
movq %rbx, %rsi
callq 0x5250
leaq 0xd9b1(%rip), %rsi      # 0x20f3a
movq %rax, %rdi
callq 0x5290
movq %rax, %rdi
callq 0x5130
leaq 0x8(%rsp), %rdi
callq 0x5120
pushq $0x1
popq %rdi
callq 0x5300
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5120
movq %rbx, %rdi
callq 0x5410
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r14
pushq %rbx
subq $0x28, %rsp
cmpq $0x0, 0x28(%rdi)
je 0x139fd
movq %rdi, %rbx
callq 0x62f2
movss %xmm0, 0x4(%rsp)
movq 0x28(%rbx), %r14
testq %r14, %r14
je 0x13a42
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x20(%rbx), %rdx
movq (%r14), %rcx
movq %r14, %rdi
movq %rax, %rsi
callq *0x28(%rcx)
callq 0x62f2
subss 0x4(%rsp), %xmm0
movss %xmm0, 0x14(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r14
retq
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xc1ab
movq 0x215c7(%rip), %rdi     # 0x34fd8
movq %rbx, %rsi
callq 0x5250
leaq 0xd562(%rip), %rsi      # 0x20f82
movq %rax, %rdi
callq 0x5290
movq %rax, %rdi
callq 0x5130
leaq 0x8(%rsp), %rdi
callq 0x5120
pushq $0x1
popq %rdi
callq 0x5300
leaq 0xd56e(%rip), %rdi      # 0x20fb7
leaq 0xd577(%rip), %rsi      # 0x20fc7
leaq 0xd586(%rip), %rcx      # 0x20fdd
movl $0xee, %edx
callq 0x51b0
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5120
movq %rbx, %rdi
callq 0x5410
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
incl 0x18(%rdi)
movq 0x20(%rdi), %rdi
xorps %xmm1, %xmm1
testq %rdi, %rdi
je 0x13c7c
movss 0x28(%rbx), %xmm0
movss %xmm0, 0xc(%rsp)
movq (%rdi), %rax
callq *0x20(%rax)
mulss 0xc(%rsp), %xmm0
movq 0x20(%rbx), %rax
testq %rax, %rax
je 0x13c81
movss 0x10(%rax), %xmm1
jmp 0x13c84
xorps %xmm0, %xmm0
jmp 0x13c84
xorps %xmm1, %xmm1
movss %xmm1, 0x10(%rbx)
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/bonetblai[P]mdp-engine/ctp3/../engine/heuristic.h
// Function: Heuristic::scaled_heuristic_t<state_t>::set_parameters(std::multimap<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>> const&, Dispatcher::dispatcher_t<state_t>&)
virtual void set_parameters(const std::multimap<std::string, std::string> &parameters, Dispatcher::dispatcher_t<T> &dispatcher) {
        std::multimap<std::string, std::string>::const_iterator it = parameters.find("heuristic");
        if( it != parameters.end() ) {
            delete heuristic_;
            dispatcher.create_request(problem_, it->first, it->second);
            heuristic_ = dispatcher.fetch_heuristic(it->second);
        }
        it = parameters.find("weight");
        if( it != parameters.end() ) weight_ = strtof(it->second.c_str(), 0);
        it = parameters.find("heuristic");
#ifdef DEBUG
        std::cout << "debug: scaled(): params:"
                  << " heuristic=" << (heuristic_ == 0 ? std::string("null") : heuristic_->name())
                  << " weight=" << weight_
                  << std::endl;
#endif
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xcad5(%rip), %rsi      # 0x207a2
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x50e0
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0xcea2
movq %rax, %r12
leaq 0x10(%rsp), %rdi
callq 0x5120
leaq 0x8(%rbx), %r13
cmpq %r13, %r12
je 0x13d35
movq 0x20(%r14), %rdi
testq %rdi, %rdi
je 0x13d0e
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x8(%r14), %rsi
leaq 0x20(%r12), %rdx
addq $0x40, %r12
movq %r15, %rdi
movq %r12, %rcx
callq 0x6dfe
movq %r15, %rdi
movq %r12, %rsi
callq 0xc328
movq %rax, 0x20(%r14)
leaq 0xd2fe(%rip), %rsi      # 0x2103a
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x50e0
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0xcea2
movq %rax, %r15
leaq 0x10(%rsp), %rdi
callq 0x5120
cmpq %r13, %r15
je 0x13d7b
movq 0x40(%r15), %rdi
xorl %esi, %esi
callq 0x5360
movss %xmm0, 0x28(%r14)
leaq 0xca20(%rip), %rsi      # 0x207a2
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x50e0
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0xcea2
leaq 0x10(%rsp), %rdi
callq 0x5120
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x13dbe
jmp 0x13dcd
jmp 0x13dbe
jmp 0x13dcd
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x5120
jmp 0x13dd0
movq %rax, %rbx
movq %rbx, %rdi
callq 0x5410
// File: /workspace/github_cpp_makefile_star2_O2/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 0x13f61
movq %rsi, %rbx
incl 0x20(%r15)
callq 0xd74c
movq %rax, %r14
movq 0x8(%r15), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
movl %r14d, %edx
callq *0x30(%rax)
testb %al, %al
je 0x13f7a
movl %r14d, %eax
popq %rbx
popq %r14
popq %r15
retq
leaq 0xd0d9(%rip), %rdi      # 0x21041
leaq 0xd0dd(%rip), %rsi      # 0x2104c
leaq 0xd0f0(%rip), %rcx      # 0x21066
pushq $0x5b
jmp 0x13f91
leaq 0xd151(%rip), %rdi      # 0x210d2
leaq 0xd0c4(%rip), %rsi      # 0x2104c
leaq 0xd0d7(%rip), %rcx      # 0x21066
pushq $0x5e
popq %rdx
callq 0x51b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x28, %rsp
cmpq $0x0, 0x30(%rdi)
je 0x141ce
movq %rdi, %rbx
callq 0x62f2
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)
callq 0x62f2
subss 0x4(%rsp), %xmm0
movss %xmm0, 0x14(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r14
retq
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xc1ab
movq 0x20df6(%rip), %rdi     # 0x34fd8
movq %rbx, %rsi
callq 0x5250
leaq 0xcf01(%rip), %rsi      # 0x210f2
movq %rax, %rdi
callq 0x5290
movq %rax, %rdi
callq 0x5130
leaq 0x8(%rsp), %rdi
callq 0x5120
pushq $0x1
popq %rdi
callq 0x5300
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5120
movq %rbx, %rdi
callq 0x5410
// File: /workspace/github_cpp_makefile_star2_O2/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:
andq $0x0, 0x14(%rdi)
andl $0x0, 0x1c(%rdi)
movq 0x8(%rdi), %rax
andq $0x0, 0x10(%rax)
movq 0x28(%rdi), %rax
testq %rax, %rax
je 0x148aa
andq $0x0, 0x10(%rax)
andl $0x0, 0x18(%rax)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
andq $0x0, 0x14(%rdi)
andl $0x0, 0x1c(%rdi)
movq 0x8(%rdi), %rax
andq $0x0, 0x10(%rax)
movq 0x38(%rdi), %rax
movq -0x8(%rax), %rdi
movq (%rdi), %rax
jmpq *0x28(%rax)
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
subq $0x20, %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 0xba3f(%rip), %rsi      # 0x20f22
movq %r14, %rdi
callq 0x5290
leaq 0xb0ca(%rip), %rsi      # 0x205bc
movq %rax, %rdi
callq 0x5290
movq %rax, %r12
movq (%r15), %rax
movq %rsp, %r13
movq %r13, %rdi
movq %r15, %rsi
callq *0x18(%rax)
movq %r12, %rdi
movq %r13, %rsi
callq 0x5250
movq %rax, %rdi
callq 0x5130
movq %rsp, %rdi
callq 0x5120
addl $0x2, %ebx
xorl %r12d, %r12d
movq 0x30(%r15), %rax
movq 0x38(%r15), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
movslq %ecx, %rcx
cmpq %rcx, %r12
jge 0x15558
movq (%rax,%r12,8), %rdi
movq (%rdi), %rax
movq %r14, %rsi
movl %ebx, %edx
callq *0x30(%rax)
incq %r12
jmp 0x1552d
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x5120
movq %rbx, %rdi
callq 0x5410
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1587c
movq %rdi, %rbx
leaq 0x30(%rdi), %r14
movl 0x50(%rdi), %esi
incl %esi
movq %r14, %rdi
callq 0x158d6
movq 0x28(%rbx), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %r14, %rdi
callq 0x159c0
pushq $0x1
popq %r13
pushq $0x40
popq %r12
leaq 0x1f1c6(%rip), %rbp     # 0x349d8
leal -0x1(%r13), %eax
cmpl 0x50(%rbx), %eax
jae 0x1586d
movq 0x38(%rbx), %rax
movq -0x8(%rax), %r15
movq %r12, %rdi
callq 0x52a0
movq 0x8(%rbx), %rcx
movq %rcx, 0x8(%rax)
movl 0x1fa87(%rip), %ecx     # 0x352c0
movl %ecx, 0x10(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x14(%rax)
movq %r15, 0x28(%rax)
movq %rbp, (%rax)
movq 0x48(%rbx), %rcx
movq %rcx, 0x30(%rax)
movl %r13d, 0x38(%rax)
movq %rax, 0x8(%rsp)
movq %r14, %rdi
leaq 0x8(%rsp), %rsi
callq 0x15966
incl %r13d
jmp 0x15812
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xc1ab
movq 0x1f748(%rip), %rdi     # 0x34fd8
movq %rbx, %rsi
callq 0x5250
leaq 0xb8dc(%rip), %rsi      # 0x2117b
movq %rax, %rdi
callq 0x5290
movq %rax, %rdi
callq 0x5130
leaq 0x8(%rsp), %rdi
callq 0x5120
pushq $0x1
popq %rdi
callq 0x5300
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5120
movq %rbx, %rdi
callq 0x5410
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x88, %rsp
movq %rsi, %r14
movq %rdi, %r15
incl 0x20(%rdi)
pushq $-0x1
popq %rbx
movss 0xa139(%rip), %xmm0     # 0x20014
movss %xmm0, 0x4(%rsp)
xorl %ebp, %ebp
leaq 0x10(%rsp), %r12
movq 0x8(%r15), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x10(%rax)
cmpl %eax, %ebp
jge 0x15fbc
movq 0x8(%r15), %rdi
movq (%rdi), %rax
movq %r14, %rsi
movl %ebp, %edx
callq *0x30(%rax)
testb %al, %al
je 0x15fb5
xorl %r13d, %r13d
xorps %xmm1, %xmm1
movl 0x30(%r15), %eax
cmpl %eax, %r13d
jae 0x15f94
movss %xmm1, 0xc(%rsp)
movq 0x8(%r15), %rsi
movq %r12, %rdi
movq %r14, %rdx
movl %ebp, %ecx
callq 0xb318
movq 0x8(%r15), %rdi
movq (%rdi), %rax
movq %r14, %rsi
movl %ebp, %edx
callq *0x48(%rax)
movss %xmm0, (%rsp)
movq 0x8(%r15), %rax
movss 0x8(%rax), %xmm0
movss %xmm0, 0x8(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x1629a
mulss 0x8(%rsp), %xmm0
movss (%rsp), %xmm1
addss 0xc(%rsp), %xmm1
addss %xmm0, %xmm1
movss %xmm1, (%rsp)
movq %r12, %rdi
callq 0x8e90
incl %r13d
movss (%rsp), %xmm1
jmp 0x15f1a
movl %eax, %eax
cvtsi2ss %rax, %xmm0
divss %xmm0, %xmm1
movss 0x4(%rsp), %xmm0
ucomiss %xmm0, %xmm1
minss %xmm1, %xmm0
movss %xmm0, 0x4(%rsp)
cmovbl %ebp, %ebx
incl %ebp
jmp 0x15ee8
cmpl $-0x1, %ebx
je 0x15fd5
movl %ebx, %eax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xb1f6(%rip), %rdi      # 0x211d2
leaq 0xb20c(%rip), %rsi      # 0x211ef
leaq 0xb219(%rip), %rcx      # 0x21203
pushq $0x5b
popq %rdx
callq 0x51b0
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x8e90
movq %rbx, %rdi
callq 0x5410
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
andq $0x0, 0x14(%rdi)
andl $0x0, 0x1c(%rdi)
movq 0x8(%rdi), %rax
andq $0x0, 0x10(%rax)
movq 0x28(%rdi), %rdi
testq %rdi, %rdi
je 0x16029
movq (%rdi), %rax
jmpq *0x28(%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
subq $0x20, %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 0xaecd(%rip), %rsi      # 0x20f22
movq %r14, %rdi
callq 0x5290
leaq 0xa558(%rip), %rsi      # 0x205bc
movq %rax, %rdi
callq 0x5290
movq %rax, %r12
movq (%r15), %rax
movq %rsp, %r13
movq %r13, %rdi
movq %r15, %rsi
callq *0x18(%rax)
movq %r12, %rdi
movq %r13, %rsi
callq 0x5250
leaq 0xa53f(%rip), %rsi      # 0x205cf
movq %rax, %rdi
callq 0x5290
movl 0x20(%r15), %esi
movq %rax, %rdi
callq 0x51c0
movq %rax, %rdi
callq 0x5130
movq %rsp, %rdi
callq 0x5120
movq 0x28(%r15), %rdi
testq %rdi, %rdi
je 0x160cb
addl $0x2, %ebx
movq (%rdi), %rax
movq %r14, %rsi
movl %ebx, %edx
callq *0x30(%rax)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x5120
movq %rbx, %rdi
callq 0x5410
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x28, %rsp
cmpq $0x0, 0x28(%rdi)
je 0x162f5
movq %rsi, %r14
movq %rdi, %rbx
callq 0x62f2
movss %xmm0, 0x4(%rsp)
movq 0x28(%rbx), %rdi
movl 0x34(%rbx), %ecx
pushq $0x1
popq %rdx
movq %r14, %rsi
xorl %r8d, %r8d
callq 0x1634f
movss %xmm0, (%rsp)
callq 0x62f2
subss 0x4(%rsp), %xmm0
addss 0x18(%rbx), %xmm0
movss %xmm0, 0x18(%rbx)
movss (%rsp), %xmm0
addq $0x28, %rsp
popq %rbx
popq %r14
retq
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xc1ab
movq 0x1eccf(%rip), %rdi     # 0x34fd8
movq %rbx, %rsi
callq 0x5250
leaq 0xaf5c(%rip), %rsi      # 0x21274
movq %rax, %rdi
callq 0x5290
movq %rax, %rdi
callq 0x5130
leaq 0x8(%rsp), %rdi
callq 0x5120
pushq $0x1
popq %rdi
callq 0x5300
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5120
movq %rbx, %rdi
callq 0x5410
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebp
movl %ecx, %r14d
movq %rsi, %r15
movq %rdi, %r12
movl %edx, %ebx
testl %r8d, %r8d
je 0x1639a
movq 0x1ec64(%rip), %rdi     # 0x34fd8
leaq 0xaf2f(%rip), %rsi      # 0x212aa
callq 0x5290
movq %rax, %rdi
movq %rbx, %rsi
callq 0x51c0
leaq 0xaa8b(%rip), %rsi      # 0x20e1d
movq %rax, %rdi
callq 0x5290
xorps %xmm1, %xmm1
xorl %r13d, %r13d
cmpq %r13, %rbx
movss %xmm1, 0x4(%rsp)
je 0x163f3
testb %bpl, %bpl
je 0x163d6
movq 0x1ec21(%rip), %rdi     # 0x34fd8
leaq 0xab63(%rip), %rsi      # 0x20f21
callq 0x5290
movq %rax, %rdi
movq %r13, %rsi
callq 0x51c0
movq %rax, %rdi
callq 0x51d0
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
callq 0x16425
movss 0x4(%rsp), %xmm1
addss %xmm0, %xmm1
incq %r13
jmp 0x163a0
testb %bpl, %bpl
je 0x1640a
movq 0x1ebd9(%rip), %rdi     # 0x34fd8
callq 0x5130
movss 0x4(%rsp), %xmm1
cvtsi2ss %rbx, %xmm0
divss %xmm0, %xmm1
movaps %xmm1, %xmm0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/bonetblai[P]mdp-engine/ctp3/../engine/uct.h
// Function: Online::Policy::UCT::uct_t<state_t>::operator()(state_t const&) const
virtual Problem::action_t operator()(const T &s) const {
        if( base_policy_ == 0 ) {
            std::cout << Utils::error() << "(base) policy must be specified for uct() policy!" << std::endl;
            exit(1);
        }

        ++policy_t<T>::decisions_;
        if( horizon_ == 0 ) {
            return (*base_policy_)(s);
        } else {
            table_.clear();
            for( unsigned i = 0; i < width_; ++i )
                search_tree(s, 0);
            typename hash_t<T>::iterator it = table_.find(std::make_pair(0, s));
            assert(it != table_.end());
            Problem::action_t action = select_action(s, it->second, 0, false, random_ties_);
            assert(problem_.applicable(s, action));
            return action;
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xf0, %rsp
movq %rdi, %r14
movq 0x28(%rdi), %rdi
testq %rdi, %rdi
je 0x16ca8
movq %rsi, %rbx
incl 0x20(%r14)
cmpl $0x0, 0x34(%r14)
je 0x16c8d
leaq 0x48(%r14), %r12
movq %r12, %rdi
callq 0x17076
xorl %ebp, %ebp
cmpl 0x30(%r14), %ebp
jae 0x16bf8
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x1719e
incl %ebp
jmp 0x16be1
leaq 0x80(%rsp), %r15
andl $0x0, -0x8(%r15)
movq %r15, %rdi
movq %rbx, %rsi
callq 0xa4d8
movq %rsp, %rdi
leaq 0x78(%rsp), %rsi
callq 0x1749c
movq %rsp, %rsi
movq %r12, %rdi
callq 0x17e9e
movq %rax, %r12
leaq 0x8(%rsp), %rdi
callq 0x8e90
movq %r15, %rdi
callq 0x8e90
testq %r12, %r12
je 0x16ce9
subq $-0x80, %r12
movzbl 0x3c(%r14), %r9d
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x174ae
movl %eax, %ebp
movq 0x8(%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
movl %ebp, %edx
callq *0x30(%rax)
testb %al, %al
je 0x16d08
movl %ebp, %eax
addq $0xf0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq (%rdi), %rax
movq 0x20(%rax), %rax
movq %rbx, %rsi
addq $0xf0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
movq %rsp, %rbx
movq %rbx, %rdi
callq 0xc1ab
movq 0x1e31e(%rip), %rdi     # 0x34fd8
movq %rbx, %rsi
callq 0x5250
leaq 0xa824(%rip), %rsi      # 0x214ed
movq %rax, %rdi
callq 0x5290
movq %rax, %rdi
callq 0x5130
movq %rsp, %rdi
callq 0x5120
pushq $0x1
popq %rdi
callq 0x5300
leaq 0xa82f(%rip), %rdi      # 0x2151f
leaq 0xa83b(%rip), %rsi      # 0x21532
leaq 0xa844(%rip), %rcx      # 0x21542
movl $0x9f, %edx
callq 0x51b0
leaq 0xa89c(%rip), %rdi      # 0x215ab
leaq 0xa81c(%rip), %rsi      # 0x21532
leaq 0xa825(%rip), %rcx      # 0x21542
movl $0xa1, %edx
callq 0x51b0
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x8e90
jmp 0x16d39
movq %rax, %rbx
movq %r15, %rdi
callq 0x8e90
jmp 0x16d4e
movq %rax, %rbx
movq %rsp, %rdi
callq 0x5120
movq %rbx, %rdi
callq 0x5410
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x10, %rsp
cmpq $0x0, 0x28(%rdi)
je 0x17807
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x62f2
movss %xmm0, 0xc(%rsp)
movq 0x28(%rbx), %rdi
movl 0x34(%rbx), %ecx
subl %ebp, %ecx
pushq $0x1
popq %rdx
movq %r14, %rsi
xorl %r8d, %r8d
callq 0x1634f
movss %xmm0, 0x8(%rsp)
callq 0x62f2
subss 0xc(%rsp), %xmm0
addss 0x18(%rbx), %xmm0
movss %xmm0, 0x18(%rbx)
movss 0x8(%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x9ded(%rip), %rdi      # 0x215fb
leaq 0x9d1d(%rip), %rsi      # 0x21532
leaq 0x9df1(%rip), %rcx      # 0x2160d
movl $0x141, %edx            # imm = 0x141
callq 0x51b0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x191e6
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x17f05
movq 0x10(%rdi), %r14
callq 0x5270
movq %r14, 0x8(%rbx)
movq %r14, %rdi
jmp 0x17eee
leaq 0x40(%rbx), %rdi
callq 0x193a2
addq $0x20, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1928c
movq %rax, %rdi
callq 0x8412
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x52a0
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 0x1b39c
addq $0x30, %rsp
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x5270
movq %r14, %rdi
callq 0x5410
// File: /workspace/github_cpp_makefile_star2_O2/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
andq $0x0, 0x14(%rdi)
andl $0x0, 0x1c(%rdi)
movq 0x8(%rdi), %rax
andq $0x0, 0x10(%rax)
movq 0x28(%rdi), %rdi
testq %rdi, %rdi
je 0x18bfb
movq (%rdi), %rax
callq *0x28(%rax)
movq 0x98(%rbx), %rax
testq %rax, %rax
je 0x18c10
andq $0x0, 0x10(%rax)
andl $0x0, 0x18(%rax)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
subq $0x20, %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 0x82e5(%rip), %rsi      # 0x20f22
movq %r14, %rdi
callq 0x5290
leaq 0x7970(%rip), %rsi      # 0x205bc
movq %rax, %rdi
callq 0x5290
movq %rax, %r12
movq (%r15), %rax
movq %rsp, %r13
movq %r13, %rdi
movq %r15, %rsi
callq *0x18(%rax)
movq %r12, %rdi
movq %r13, %rsi
callq 0x5250
leaq 0x7957(%rip), %rsi      # 0x205cf
movq %rax, %rdi
callq 0x5290
movl 0x20(%r15), %esi
movq %rax, %rdi
callq 0x51c0
leaq 0xa192(%rip), %rsi      # 0x22e25
movq %rax, %rdi
callq 0x5290
movss 0x150(%r15), %xmm0
movss 0x154(%r15), %xmm1
addss %xmm0, %xmm1
divss %xmm1, %xmm0
movq %rax, %rdi
callq 0x51f0
leaq 0xa167(%rip), %rsi      # 0x22e2b
movq %rax, %rdi
callq 0x5290
movss 0x154(%r15), %xmm0
movss 0x150(%r15), %xmm1
addss %xmm0, %xmm1
divss %xmm1, %xmm0
movq %rax, %rdi
callq 0x51f0
leaq 0xa13d(%rip), %rsi      # 0x22e32
movq %rax, %rdi
callq 0x5290
movl 0x160(%r15), %esi
movq %rax, %rdi
callq 0x51c0
leaq 0xa12d(%rip), %rsi      # 0x22e40
movq %rax, %rdi
callq 0x5290
movl 0x164(%r15), %esi
movq %rax, %rdi
callq 0x51c0
movq %rax, %rdi
callq 0x5130
movq %rsp, %rdi
callq 0x5120
movq 0x28(%r15), %rdi
testq %rdi, %rdi
je 0x18d51
addl $0x2, %ebx
movq (%rdi), %rax
movq %r14, %rsi
movl %ebx, %edx
callq *0x30(%rax)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x5120
movq %rbx, %rdi
callq 0x5410
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
movl 0x18(%rdi), %eax
pushq $0x1
popq %rcx
cmpl %eax, %ecx
ja 0x19216
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)
andq $0x0, (%rsi,%rcx,8)
incq %rcx
jmp 0x191f0
andl $0x0, 0x18(%rbx)
movq 0x40(%rbx), %rdi
movl 0x4(%rbx), %edx
incl %edx
shlq $0x2, %rdx
xorl %esi, %esi
callq 0x5170
andl $0x0, 0x38(%rbx)
movq %rbx, %rdi
callq 0x1948a
testb %al, %al
je 0x19240
popq %rbx
retq
leaq 0x84e8(%rip), %rdi      # 0x2172f
leaq 0x84e9(%rip), %rsi      # 0x21737
leaq 0x8501(%rip), %rcx      # 0x21756
movl $0x12f, %edx            # imm = 0x12F
callq 0x51b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
pushq $0x1
popq %rbx
movl 0x18(%r14), %eax
cmpl %eax, %ebx
ja 0x194c8
movq %r14, %rdi
movl %ebx, %esi
callq 0x195e4
testb %al, %al
je 0x19501
incl %ebx
jmp 0x194ae
movq 0x20(%r14), %rcx
movq 0x40(%r14), %rdx
xorl %esi, %esi
incl %esi
cmpl %eax, %esi
ja 0x19539
movl %esi, %ebx
movq (%rcx,%rbx,8), %rdi
movl 0x8(%rdi), %edi
cmpl (%rdx,%rdi,4), %esi
je 0x194d2
movq 0x1baeb(%rip), %rdi     # 0x34fd8
leaq 0x83da(%rip), %rsi      # 0x218ce
callq 0x5290
movq %rax, %rdi
movq %rbx, %rsi
jmp 0x19519
movq 0x1bad0(%rip), %rdi     # 0x34fd8
leaq 0x8394(%rip), %rsi      # 0x218a3
callq 0x5290
movl %ebx, %esi
movq %rax, %rdi
callq 0x51c0
leaq 0x8734(%rip), %rsi      # 0x21c59
movq %rax, %rdi
callq 0x5290
movq %rax, %rdi
callq 0x5130
xorl %eax, %eax
jmp 0x1953b
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop