LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/bonetblai[P]mdp-engine/ctp3/../engine/hash.h
// Function: Hash::hash_map_t<state_t, Hash::hash_function_t<state_t>>::solve(state_t const&)
void solve(const T &s) {
        iterator di = lookup(s);
        if( di == end() )
            push(s, new Hash::data_t(default_value(s), true, false));
        else
            (*di).second->solve();
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
addq $0x8, %rdi
callq 0x1069e
testq %rax, %rax
je 0x12529
movq 0x78(%rax), %rax
movb $0x1, 0x4(%rax)
popq %rbx
popq %r14
popq %r15
retq
movl $0x28, %edi
callq 0x6290
movq %rax, %r15
movq 0x40(%r14), %rdi
testq %rdi, %rdi
je 0x1254a
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x10(%rax)
jmp 0x1254d
xorps %xmm0, %xmm0
movss %xmm0, (%r15)
movw $0x1, 0x4(%r15)
movq $0x0, 0x8(%r15)
movl $0xffffffff, 0x10(%r15) # imm = 0xFFFFFFFF
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movq %rax, 0x18(%r15)
movq %rax, 0x20(%r15)
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x105fe
movq %rax, %rbx
movq %r15, %rdi
callq 0x6260
movq %rbx, %rdi
callq 0x6410
// File: /workspace/github_cpp_makefile_star2_O1/bonetblai[P]mdp-engine/ctp3/../engine/ldfs.h
// Function: Algorithm::ldfs_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);

        std::list<Hash::data_t*> stack, visited;
        size_t trials = 0;
        Hash::data_t *dptr = hash.data_ptr(s);
        while( !dptr->solved() ) {
            size_t index = 0;
            ldfs_base_t<T>::ldfs(s, hash, dptr, index, stack, visited);
            assert(stack.empty());
            while( !visited.empty() ) {
                visited.front()->unmark();
                visited.pop_front();
            }
            ++trials;
        }
        hash.set_eval_function(0);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r14
movq %rsi, %r13
movq %rdi, %rbx
movq (%rdi), %rax
movq %rdx, %rsi
callq *0x30(%rax)
movq %rbx, 0x8(%rsp)
movq 0x10(%rbx), %rax
leaq 0x2afbc(%rip), %rcx     # 0x3dff0
leaq 0x48(%rsp), %rdx
movq %rcx, (%rdx)
movq %rax, 0x8(%rdx)
movq %rdx, 0x40(%r14)
leaq 0x30(%rsp), %rbp
movq %rbp, 0x8(%rbp)
movq %rbp, (%rbp)
xorl %eax, %eax
movq %rax, 0x10(%rbp)
leaq 0x18(%rsp), %r15
movq %r15, 0x8(%r15)
movq %r15, (%r15)
movq %rax, 0x10(%r15)
movq %r14, %rdi
movq %r13, %rbx
movq %r13, %rsi
callq 0x1020a
movq %rax, %r13
cmpb $0x0, 0x4(%rax)
jne 0x130e7
movq $0x0, 0x10(%rsp)
movq %r15, (%rsp)
movq 0x8(%rsp), %rdi
movq %rbx, %rsi
movq %r14, %rdx
movq %r13, %rcx
leaq 0x10(%rsp), %r8
movq %rbp, %r9
callq 0x13340
cmpq %rbp, 0x30(%rsp)
jne 0x13132
movq %rbp, %r12
movq 0x18(%rsp), %rbp
cmpq %r15, %rbp
je 0x130dd
movq 0x10(%rbp), %rax
movb $0x0, 0x5(%rax)
decq 0x28(%rsp)
movq %rbp, %rdi
callq 0x63d0
movq %rbp, %rdi
callq 0x6260
jmp 0x130b4
cmpb $0x1, 0x4(%r13)
movq %r12, %rbp
jne 0x1307e
movq $0x0, 0x40(%r14)
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x13109
movq (%rdi), %r14
callq 0x6260
movq %r14, %rdi
cmpq %r15, %r14
jne 0x130f9
movq 0x30(%rsp), %rdi
cmpq %rbp, %rdi
je 0x13123
movq (%rdi), %r14
callq 0x6260
movq %r14, %rdi
cmpq %rbp, %r14
jne 0x13113
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1a903(%rip), %rdi     # 0x2da3c
leaq 0x1ab3f(%rip), %rsi     # 0x2dc7f
leaq 0x1ab49(%rip), %rcx     # 0x2dc90
movl $0xcf, %edx
callq 0x61c0
jmp 0x13153
movq %rax, %r14
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x13170
movq (%rdi), %r12
callq 0x6260
movq %r12, %rdi
cmpq %r15, %r12
jne 0x13160
movq 0x30(%rsp), %rdi
cmpq %rbp, %rdi
je 0x1318a
movq (%rdi), %r15
callq 0x6260
movq %r15, %rdi
cmpq %rbp, %r15
jne 0x1317a
movq %r14, %rdi
callq 0x6410
// File: /workspace/github_cpp_makefile_star2_O1/bonetblai[P]mdp-engine/ctp3/../engine/lrtdp.h
// Function: Algorithm::lrtdp_base_t<state_t>::lrtdp(state_t const&, Problem::hash_t<state_t>&) const
size_t lrtdp(const T &s, Problem::hash_t<T> &hash) const {
        Heuristic::wrapper_t<T> eval_function(heuristic_);
        hash.set_eval_function(&eval_function);

        size_t trials = 0, max_steps = 0;
        while( !hash.solved(s) ) {
            size_t steps = lrtdp_trial(s, hash);
            max_steps = Utils::max(max_steps, steps);
            ++trials;
        }

        hash.set_eval_function(0);
        return trials;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x10(%rdi), %rax
leaq 0x292b9(%rip), %rcx     # 0x3dff0
movq %rsp, %rdx
movq %rcx, (%rdx)
movq %rax, 0x8(%rdx)
movq %rdx, 0x40(%rbx)
leaq 0x8(%rbx), %r13
xorl %r12d, %r12d
movq %r13, %rdi
movq %r14, %rsi
callq 0x1069e
testq %rax, %rax
je 0x14d66
movq 0x78(%rax), %rax
cmpb $0x0, 0x4(%rax)
jne 0x14d79
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x14d92
incq %r12
jmp 0x14d4c
movq $0x0, 0x40(%rbx)
movq %r12, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/bonetblai[P]mdp-engine/ctp3/../engine/problem.h
// Function: Problem::problem_t<state_t>::usample(state_t const&, int) const
std::pair<T, bool> usample(const T &s, action_t a) const {
        std::vector<std::pair<T, float> > outcomes;
        next(s, a, outcomes);
        unsigned osize = outcomes.size();
        return std::make_pair(outcomes[Random::random(osize)].first, true);
    }

// Assembly:
pushq %rbp
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %rax
movaps %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq (%rsi), %r8
movq %rsi, %rdi
movq %rdx, %rsi
movl %ecx, %edx
movq %rax, %rcx
callq *0x60(%r8)
movq 0x8(%rsp), %rax
subq (%rsp), %rax
shrq $0x3, %rax
imull $0xeeeeeeef, %eax, %ebp # imm = 0xEEEEEEEF
cmpl $0x1, %ebp
je 0x15221
testl %ebp, %ebp
je 0x1526a
callq 0x6200
xorl %edx, %edx
divl %ebp
jmp 0x15223
xorl %edx, %edx
imulq $0x78, %rdx, %rsi
addq (%rsp), %rsi
xorl %eax, %eax
movq %rax, 0x44(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x34(%rbx)
movups %xmm0, 0x24(%rbx)
movups %xmm0, 0x14(%rbx)
movups %xmm0, 0x4(%rbx)
movb $0x1, 0x5c(%rbx)
movq %rax, 0x60(%rbx)
movq %rbx, %rdi
callq 0xd546
movb $0x1, 0x70(%rbx)
movq %rsp, %rdi
callq 0xe35c
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
leaq 0x183af(%rip), %rdi     # 0x2d620
leaq 0x183b0(%rip), %rsi     # 0x2d628
leaq 0x183bc(%rip), %rcx     # 0x2d63b
movl $0x3a, %edx
callq 0x61c0
jmp 0x1528b
movq %rax, %rbx
movq %rsp, %rdi
callq 0xe35c
movq %rbx, %rdi
callq 0x6410
// File: /workspace/github_cpp_makefile_star2_O1/bonetblai[P]mdp-engine/ctp3/../engine/plain_check.h
// Function: Algorithm::plain_check_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);

        size_t trials = 0;
        while( !hash.solved(s) ) {
            check_solved(problem_, s, hash, epsilon_);
            ++trials;
        }
        hash.set_eval_function(0);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rax
movq %rdx, %rsi
callq *0x30(%rax)
movq 0x10(%r15), %rax
leaq 0x2791c(%rip), %rcx     # 0x3dff0
leaq 0x8(%rsp), %rdx
movq %rcx, (%rdx)
movq %rax, 0x8(%rdx)
movq %rdx, 0x40(%rbx)
leaq 0x8(%rbx), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x1069e
testq %rax, %rax
je 0x16702
movq 0x78(%rax), %rax
cmpb $0x0, 0x4(%rax)
jne 0x16719
movq 0x8(%r15), %rdi
movss 0x1c(%r15), %xmm0
movq %r14, %rsi
movq %rbx, %rdx
callq 0x15583
jmp 0x166e8
movq $0x0, 0x40(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/bonetblai[P]mdp-engine/ctp3/../engine/simple_astar.h
// Function: Algorithm::simple_astar_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("seed");
        if( it != parameters.end() ) seed_ = strtol(it->second.c_str(), 0, 0);
#ifdef DEBUG
        std::cout << "debug: simple-a*(): params:"
                  << " heuristic=" << (heuristic_ == 0 ? std::string("null") : heuristic_->name())
                  << " seed=" << seed_
                  << std::endl;
#endif
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x16b58(%rip), %rsi     # 0x2d7e7
leaq 0x16b5a(%rip), %rdx     # 0x2d7f0
leaq 0x8(%rsp), %rdi
callq 0xe5ba
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x10180
movq %rax, %r12
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x16cbf
callq 0x6260
leaq 0x8(%r14), %rbp
cmpq %rbp, %r12
je 0x16d10
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x16cd7
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x8(%rbx), %rsi
leaq 0x20(%r12), %rdx
addq $0x40, %r12
movq %r15, %rdi
movq %r12, %rcx
callq 0x8c62
leaq 0x38(%r15), %rdi
movq %r12, %rsi
callq 0x190ac
addq $0x40, %r15
cmpq %r15, %rax
je 0x16d0a
movq 0x40(%rax), %rax
jmp 0x16d0c
xorl %eax, %eax
movq %rax, 0x10(%rbx)
leaq 0x8(%rsp), %rdi
movq %r13, (%rdi)
leaq 0x164b1(%rip), %rsi     # 0x2d1d0
leaq 0x164ae(%rip), %rdx     # 0x2d1d4
callq 0xe5ba
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x10180
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x16d4a
callq 0x6260
cmpq %rbp, %r14
je 0x16d5f
movq 0x40(%r14), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x6370
movl %eax, 0x18(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x16d72
jmp 0x16d86
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x16d89
callq 0x6260
jmp 0x16d89
movq %rax, %rbx
movq %rbx, %rdi
callq 0x6410
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq (%rdi), %rax
movq %rdx, %rsi
callq *0x30(%rax)
movq 0x10(%r14), %rax
leaq 0x255a0(%rip), %rcx     # 0x3dff0
leaq 0x18(%rsp), %rdx
movq %rcx, (%rdx)
movq %rax, 0x8(%rdx)
movq %rdx, 0x40(%rbx)
movq 0x8(%r14), %rax
leaq 0x10(%rsp), %rdi
movq %rax, (%rdi)
movq %r15, %rsi
movq %rbx, %rdx
callq 0x18b60
movss 0x1c(%r14), %xmm0
movss 0x14583(%rip), %xmm1    # 0x2d008
addss %xmm0, %xmm1
ucomiss %xmm0, %xmm1
jbe 0x18b1c
xorl %r15d, %r15d
movq 0x18(%rbx), %r12
xorps %xmm0, %xmm0
testq %r12, %r12
je 0x18b01
movss %xmm0, 0x8(%rsp)
leaq 0x8(%r12), %rsi
movq 0x78(%r12), %rax
movss (%rax), %xmm0
movss %xmm0, 0xc(%rsp)
movq %rbx, %rdi
callq 0x10b16
movaps 0x145d6(%rip), %xmm1    # 0x2d0a0
shrq $0x20, %rax
movd %eax, %xmm0
subss 0xc(%rsp), %xmm0
movq 0x78(%r12), %rcx
movl %eax, (%rcx)
incl 0x50(%rbx)
andps %xmm1, %xmm0
movss 0x8(%rsp), %xmm1
maxss %xmm0, %xmm1
movss %xmm1, 0x8(%rsp)
movss 0x8(%rsp), %xmm0
movq (%r12), %r12
jmp 0x18a9c
ucomiss 0x1c(%r14), %xmm0
jbe 0x18b1c
leaq 0x1(%r15), %rax
movl 0x20(%r14), %ecx
cmpq %rcx, %r15
movq %rax, %r15
jb 0x18a95
movq $0x0, 0x40(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %r15
xorl %edi, %edi
movq %r15, %rsi
callq 0x6190
movq (%r15), %r13
movq 0x8(%r15), %r12
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movq %r15, %rsi
callq 0x6190
movq (%r15), %rbp
movq 0x8(%r15), %r15
incl 0x18(%rbx)
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x1946d
movq %r14, %rsi
callq 0x13814
jmp 0x19470
xorps %xmm0, %xmm0
movss %xmm0, 0xc(%rsp)
xorps %xmm0, %xmm0
cvtsi2ss %rbp, %xmm0
cvtsi2ss %r13, %xmm1
addss %xmm0, %xmm1
movss %xmm1, 0x8(%rsp)
xorps %xmm0, %xmm0
cvtsi2ss %r15, %xmm0
xorps %xmm1, %xmm1
cvtsi2ss %r12, %xmm1
addss %xmm0, %xmm1
movss %xmm1, 0x14(%rsp)
leaq 0x18(%rsp), %r14
xorl %edi, %edi
movq %r14, %rsi
callq 0x6190
xorps %xmm0, %xmm0
cvtsi2ssq (%r14), %xmm0
subss 0x8(%rsp), %xmm0
movss %xmm0, 0x10(%rsp)
xorps %xmm0, %xmm0
cvtsi2ssq 0x8(%r14), %xmm0
subss 0x14(%rsp), %xmm0
movss %xmm0, 0x8(%rsp)
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movq %r14, %rsi
callq 0x6190
xorps %xmm0, %xmm0
cvtsi2ssq (%r14), %xmm0
addss 0x10(%rsp), %xmm0
xorps %xmm1, %xmm1
cvtsi2ssq 0x8(%r14), %xmm1
addss 0x8(%rsp), %xmm1
mulss 0x13af3(%rip), %xmm1    # 0x2d004
addss 0x10(%rbx), %xmm0
addss %xmm1, %xmm0
movss %xmm0, 0x10(%rbx)
movss 0xc(%rsp), %xmm0
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1976d
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rcx
movaps %xmm0, (%rcx)
movq $0x0, 0x10(%rcx)
movq 0x48(%rbx), %rdi
movq (%rdi), %rax
movq %r14, %rsi
movl %ebp, %edx
callq *0x60(%rax)
movq 0x18(%rsp), %rcx
subq 0x10(%rsp), %rcx
sarq $0x3, %rcx
movabsq $-0x1111111111111111, %rax # imm = 0xEEEEEEEEEEEEEEEF
imulq %rcx, %rax
movss 0x13933(%rip), %xmm1    # 0x2d014
testl %eax, %eax
je 0x1971f
movl %eax, %eax
imulq $0x78, %rax, %r15
movss 0x13921(%rip), %xmm1    # 0x2d014
xorl %r12d, %r12d
movss %xmm1, 0xc(%rsp)
movq 0x10(%rsp), %rsi
addq %r12, %rsi
movq %rbx, %rdi
callq 0x13814
movss 0xc(%rsp), %xmm1
minss %xmm0, %xmm1
addq $0x78, %r12
cmpq %r12, %r15
jne 0x196f6
movss 0x138ed(%rip), %xmm0    # 0x2d014
ucomiss %xmm0, %xmm1
je 0x19757
movss %xmm1, 0xc(%rsp)
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
movaps %xmm1, %xmm0
movss %xmm0, 0xc(%rsp)
leaq 0x10(%rsp), %rdi
callq 0xe35c
movss 0xc(%rsp), %xmm0
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1977e
jmp 0x1977e
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xe35c
movq %rbx, %rdi
callq 0x6410
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x198a2
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rcx
movaps %xmm0, (%rcx)
movq $0x0, 0x10(%rcx)
movq 0x48(%rbx), %rdi
movq (%rdi), %rax
movq %r14, %rsi
movl %ebp, %edx
callq *0x60(%rax)
movq 0x18(%rsp), %rcx
subq 0x10(%rsp), %rcx
sarq $0x3, %rcx
movabsq $-0x1111111111111111, %rax # imm = 0xEEEEEEEEEEEEEEEF
imulq %rcx, %rax
testl %eax, %eax
je 0x19861
movl %eax, %eax
imulq $0x78, %rax, %r15
xorps %xmm0, %xmm0
movss %xmm0, 0x8(%rsp)
xorl %r12d, %r12d
movq 0x10(%rsp), %rsi
movss 0x70(%rsi,%r12), %xmm0
movss %xmm0, 0xc(%rsp)
addq %r12, %rsi
movq %rbx, %rdi
callq 0x13814
mulss 0xc(%rsp), %xmm0
movss 0x8(%rsp), %xmm1
addss %xmm0, %xmm1
movss %xmm1, 0x8(%rsp)
addq $0x78, %r12
cmpq %r12, %r15
jne 0x19823
jmp 0x1986a
xorps %xmm0, %xmm0
movss %xmm0, 0x8(%rsp)
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 0xe35c
movss 0x8(%rsp), %xmm0
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x198b3
jmp 0x198b3
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xe35c
movq %rbx, %rdi
callq 0x6410
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x14462(%rip), %rsi     # 0x2e0b2
movl $0x1, %edx
movq %r14, %rdi
callq 0x62e0
cvtss2sd (%rbx), %xmm0
movq %r14, %rdi
callq 0x63b0
movq %rax, %r15
leaq 0x142f2(%rip), %r14     # 0x2df65
movl $0x2, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x62e0
movzbl 0x4(%rbx), %esi
movq %r15, %rdi
callq 0x6400
movq %rax, %r15
movl $0x2, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x62e0
movzbl 0x5(%rbx), %esi
movq %r15, %rdi
callq 0x6400
movq %rax, %r15
movl $0x2, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x62e0
movq 0x8(%rbx), %rsi
movq %r15, %rdi
callq 0x61d0
movq %rax, %r15
movl $0x2, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x62e0
movl 0x10(%rbx), %esi
movq %r15, %rdi
callq 0x6400
leaq 0x1376b(%rip), %rsi     # 0x2d45d
movl $0x1, %edx
movq %rax, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x62e0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x14394(%rip), %rsi     # 0x2e0b2
movl $0x1, %edx
movq %rbx, %rdi
callq 0x62e0
movl (%r14), %esi
movq %rbx, %rdi
callq 0x6400
movq %rax, %r15
leaq 0x1411f(%rip), %rsi     # 0x2de5f
movl $0x1, %edx
movq %rax, %rdi
callq 0x62e0
leaq 0x4(%r14), %rdi
movq %r15, %rsi
callq 0x19e10
leaq 0x14208(%rip), %rsi     # 0x2df68
movl $0x4, %edx
movq %r15, %rdi
callq 0x62e0
cmpl $0x0, 0x25514(%rip)     # 0x3f288
jle 0x19dad
xorl %r12d, %r12d
leaq 0x8(%rsp), %r15
xorl %r13d, %r13d
movl 0x4c(%r14,%r13,4), %eax
movl %eax, 0x8(%rsp)
movl %r12d, 0xc(%rsp)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x19eec
incq %r13
movslq 0x254e4(%rip), %rax     # 0x3f288
addl $0x20, %r12d
cmpq %rax, %r13
jl 0x19d81
leaq 0x141b9(%rip), %rsi     # 0x2df6d
movl $0x1, %edx
movq %rbx, %rdi
callq 0x62e0
movq %r14, %rdi
callq 0xbfea
cmpl $-0x1, (%r14)
je 0x19ded
cmpl $0x7fffffff, 0x68(%r14) # imm = 0x7FFFFFFF
jne 0x19ded
leaq 0x1418f(%rip), %rsi     # 0x2df6f
movl $0x5, %edx
movq %rbx, %rdi
callq 0x62e0
leaq 0x13669(%rip), %rsi     # 0x2d45d
movl $0x1, %edx
movq %rbx, %rdi
callq 0x62e0
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x1414b(%rip), %rsi     # 0x2df75
movl $0x3, %edx
movq %rbx, %rdi
callq 0x62e0
cmpl $0x0, 0x25436(%rip)     # 0x3f274
jle 0x19e76
xorl %r12d, %r12d
leaq 0x8(%rsp), %r15
xorl %r13d, %r13d
movl (%r14,%r13,4), %eax
movl %eax, 0x8(%rsp)
movl %r12d, 0xc(%rsp)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x19eec
incq %r13
movslq 0x25407(%rip), %rax     # 0x3f274
addl $0x20, %r12d
cmpq %rax, %r13
jl 0x19e4b
leaq 0x140fc(%rip), %rsi     # 0x2df79
movl $0x5, %edx
movq %rbx, %rdi
callq 0x62e0
cmpl $0x0, 0x253e3(%rip)     # 0x3f274
jle 0x19eca
xorl %r12d, %r12d
leaq 0x8(%rsp), %r15
xorl %r13d, %r13d
movl 0x24(%r14,%r13,4), %eax
movl %eax, 0x8(%rsp)
movl %r12d, 0xc(%rsp)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x19eec
incq %r13
movslq 0x253b3(%rip), %rax     # 0x3f274
addl $0x20, %r12d
cmpq %rax, %r13
jl 0x19e9e
leaq 0x1409c(%rip), %rsi     # 0x2df6d
movl $0x1, %edx
movq %rbx, %rdi
callq 0x62e0
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x19f3d
movq %rsi, %rbx
movq %rdi, %r14
xorl %r12d, %r12d
leaq 0x13f55(%rip), %r15     # 0x2de5f
testb $0x1, %bpl
je 0x19f2f
movl 0x4(%r14), %esi
addl %r12d, %esi
movq %rbx, %rdi
callq 0x6400
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x62e0
incl %r12d
movl %ebp, %eax
shrl %eax
cmpl $0x1, %ebp
movl %eax, %ebp
ja 0x19f0a
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x98, %rsp
cmpq $0x0, 0x28(%rdi)
je 0x1a050
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
xorl %edi, %edi
movq %r14, %rsi
callq 0x6190
cvtsi2ssq (%r14), %xmm0
movss %xmm0, (%rsp)
xorps %xmm0, %xmm0
cvtsi2ssq 0x8(%r14), %xmm0
movss %xmm0, 0x4(%rsp)
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movq %r14, %rsi
callq 0x6190
xorps %xmm0, %xmm0
cvtsi2ssq (%r14), %xmm0
addss (%rsp), %xmm0
movss %xmm0, (%rsp)
xorps %xmm0, %xmm0
cvtsi2ssq 0x8(%r14), %xmm0
addss 0x4(%rsp), %xmm0
movss %xmm0, 0x4(%rsp)
movq 0x8(%rbx), %rdi
movq 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)
leaq 0x8(%rsp), %r14
xorl %edi, %edi
movq %r14, %rsi
callq 0x6190
xorps %xmm0, %xmm0
cvtsi2ssq (%r14), %xmm0
subss (%rsp), %xmm0
movss %xmm0, (%rsp)
xorps %xmm0, %xmm0
cvtsi2ssq 0x8(%r14), %xmm0
subss 0x4(%rsp), %xmm0
movss %xmm0, 0x4(%rsp)
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movq %r14, %rsi
callq 0x6190
xorps %xmm0, %xmm0
cvtsi2ssq (%r14), %xmm0
addss (%rsp), %xmm0
cvtsi2ssq 0x8(%r14), %xmm1
addss 0x4(%rsp), %xmm1
mulss 0x12fc8(%rip), %xmm1    # 0x2d004
addss %xmm0, %xmm1
movss %xmm1, 0x14(%rbx)
addq $0x98, %rsp
popq %rbx
popq %r14
retq
movb 0x25202(%rip), %al      # 0x3f258
testb %al, %al
leaq 0x1399a(%rip), %rcx     # 0x2d9f9
leaq 0x13f01(%rip), %rsi     # 0x2df67
cmovneq %rcx, %rsi
leaq 0x12(%rsi), %rdx
testb %al, %al
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
cmoveq %rsi, %rdx
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xe5ba
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq 0x24f40(%rip), %rdi     # 0x3efd8
callq 0x62e0
movq %rax, %rbx
leaq 0x13ed8(%rip), %rsi     # 0x2df7f
movl $0x34, %edx
movq %rax, %rdi
callq 0x62e0
movq %rbx, %rdi
callq 0x6150
leaq 0x8(%rsp), %rdi
callq 0x6140
movl $0x1, %edi
callq 0x6310
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x1a0e2
callq 0x6260
movq %rbx, %rdi
callq 0x6410
// File: /workspace/github_cpp_makefile_star2_O1/bonetblai[P]mdp-engine/ctp3/../engine/heuristic.h
// Function: Heuristic::optimal_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: optimal(): params:"
                  << " algorithm=" << (algorithm_ == 0 ? std::string("null") : algorithm_->name())
                  << std::endl;
#endif
        solve_problem();
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x12db9(%rip), %rsi     # 0x2d26d
leaq 0x12dbb(%rip), %rdx     # 0x2d276
movq %rsp, %r15
movq %r15, %rdi
callq 0xe5ba
movq %r12, %rdi
movq %r15, %rsi
callq 0x10180
movq %rax, %r15
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x1a4e2
callq 0x6260
addq $0x8, %r12
cmpq %r12, %r15
je 0x1a532
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x1a4fa
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x8(%rbx), %rsi
leaq 0x20(%r15), %rdx
addq $0x40, %r15
movq %r14, %rdi
movq %r15, %rcx
callq 0x8c62
leaq 0x8(%r14), %rdi
movq %r15, %rsi
callq 0x2ad28
addq $0x10, %r14
cmpq %r14, %rax
je 0x1a52c
movq 0x40(%rax), %rax
jmp 0x1a52e
xorl %eax, %eax
movq %rax, 0x28(%rbx)
movq %rbx, %rdi
callq 0x1aacc
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x1a559
callq 0x6260
movq %rbx, %rdi
callq 0x6410
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa0, %rsp
cmpq $0x0, 0x28(%rdi)
je 0x1abe1
movq %rdi, %rbx
leaq 0x10(%rsp), %r14
xorl %edi, %edi
movq %r14, %rsi
callq 0x6190
movq (%r14), %r13
movq 0x8(%r14), %r12
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movq %r14, %rsi
callq 0x6190
movq 0x28(%rbx), %r15
testq %r15, %r15
je 0x1ac61
leaq 0x10(%rsp), %r14
cvtsi2ssq (%r14), %xmm0
cvtsi2ss %r13, %xmm2
cvtsi2ssq 0x8(%r14), %xmm1
cvtsi2ss %r12, %xmm3
addss %xmm0, %xmm2
movss %xmm2, 0x8(%rsp)
addss %xmm1, %xmm3
movss %xmm3, 0xc(%rsp)
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x20(%rbx), %rdx
movq (%r15), %rcx
movq %r15, %rdi
movq %rax, %rsi
callq *0x28(%rcx)
xorl %edi, %edi
movq %r14, %rsi
callq 0x6190
xorps %xmm0, %xmm0
cvtsi2ssq (%r14), %xmm0
subss 0x8(%rsp), %xmm0
movss %xmm0, 0x8(%rsp)
xorps %xmm0, %xmm0
cvtsi2ssq 0x8(%r14), %xmm0
subss 0xc(%rsp), %xmm0
movss %xmm0, 0xc(%rsp)
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movq %r14, %rsi
callq 0x6190
xorps %xmm0, %xmm0
cvtsi2ssq (%r14), %xmm0
addss 0x8(%rsp), %xmm0
xorps %xmm1, %xmm1
cvtsi2ssq 0x8(%r14), %xmm1
addss 0xc(%rsp), %xmm1
mulss 0x1243d(%rip), %xmm1    # 0x2d004
addss %xmm0, %xmm1
movss %xmm1, 0x14(%rbx)
addq $0xa0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movb 0x24671(%rip), %al      # 0x3f258
testb %al, %al
leaq 0x12e09(%rip), %rcx     # 0x2d9f9
leaq 0x13370(%rip), %rsi     # 0x2df67
cmovneq %rcx, %rsi
leaq 0x12(%rsi), %rdx
testb %al, %al
leaq 0x20(%rsp), %r14
movq %r14, -0x10(%r14)
cmoveq %rsi, %rdx
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0xe5ba
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq 0x243af(%rip), %rdi     # 0x3efd8
callq 0x62e0
movq %rax, %rbx
leaq 0x133cd(%rip), %rsi     # 0x2e005
movl $0x34, %edx
movq %rax, %rdi
callq 0x62e0
movq %rbx, %rdi
callq 0x6150
leaq 0x10(%rsp), %rdi
callq 0x6140
movl $0x1, %edi
callq 0x6310
leaq 0x133d2(%rip), %rdi     # 0x2e03a
leaq 0x133db(%rip), %rsi     # 0x2e04a
leaq 0x133ea(%rip), %rcx     # 0x2e060
movl $0xee, %edx
callq 0x61c0
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x1ac92
callq 0x6260
movq %rbx, %rdi
callq 0x6410
// File: /workspace/github_cpp_makefile_star2_O1/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
xorps %xmm0, %xmm0
testq %rdi, %rdi
je 0x1b0e0
movss 0x28(%rbx), %xmm0
movss %xmm0, 0xc(%rsp)
movq (%rdi), %rax
callq *0x20(%rax)
xorps %xmm1, %xmm1
mulss 0xc(%rsp), %xmm0
movq 0x20(%rbx), %rax
testq %rax, %rax
je 0x1b0ee
movss 0x10(%rax), %xmm1
movss %xmm1, 0x10(%rbx)
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1b52b
movq %rsi, %rbx
incl 0x20(%r15)
callq 0x10b16
movq %rax, %r14
movq 0x8(%r15), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
movl %r14d, %edx
callq *0x30(%rax)
testb %al, %al
je 0x1b54a
movl %r14d, %eax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x12b92(%rip), %rdi     # 0x2e0c4
leaq 0x12b96(%rip), %rsi     # 0x2e0cf
leaq 0x12ba9(%rip), %rcx     # 0x2e0e9
movl $0x5b, %edx
callq 0x61c0
leaq 0x12c04(%rip), %rdi     # 0x2e155
leaq 0x12b77(%rip), %rsi     # 0x2e0cf
leaq 0x12b8a(%rip), %rcx     # 0x2e0e9
movl $0x5e, %edx
callq 0x61c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/bonetblai[P]mdp-engine/ctp3/../engine/base_policies.h
// Function: Online::Policy::optimal_policy_t<state_t>::solve_problem()
void solve_problem() {
        if( algorithm_ == 0 ) {
            std::cout << Utils::error() << "algorithm must be specified for optimal() policy!" << std::endl;
            exit(1);
        }
#ifdef DEBUG
        std::cout << "debug: optimal(): solving problem with algorithm=" << algorithm_->name() << std::endl;
#endif
        float start_time = Utils::read_time_in_seconds();
        algorithm_->solve(problem_.init(), *hash_);
        policy_t<T>::setup_time_ = Utils::read_time_in_seconds() - start_time;
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x98, %rsp
cmpq $0x0, 0x30(%rdi)
je 0x1bbc8
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
xorl %edi, %edi
movq %r14, %rsi
callq 0x6190
cvtsi2ssq (%r14), %xmm0
movss %xmm0, (%rsp)
xorps %xmm0, %xmm0
cvtsi2ssq 0x8(%r14), %xmm0
movss %xmm0, 0x4(%rsp)
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movq %r14, %rsi
callq 0x6190
xorps %xmm0, %xmm0
cvtsi2ssq (%r14), %xmm0
addss (%rsp), %xmm0
movss %xmm0, (%rsp)
xorps %xmm0, %xmm0
cvtsi2ssq 0x8(%r14), %xmm0
addss 0x4(%rsp), %xmm0
movss %xmm0, 0x4(%rsp)
movq 0x8(%rbx), %rdi
movq 0x30(%rbx), %r14
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x28(%rbx), %rdx
movq (%r14), %rcx
movq %r14, %rdi
movq %rax, %rsi
callq *0x28(%rcx)
leaq 0x8(%rsp), %r14
xorl %edi, %edi
movq %r14, %rsi
callq 0x6190
xorps %xmm0, %xmm0
cvtsi2ssq (%r14), %xmm0
subss (%rsp), %xmm0
movss %xmm0, (%rsp)
xorps %xmm0, %xmm0
cvtsi2ssq 0x8(%r14), %xmm0
subss 0x4(%rsp), %xmm0
movss %xmm0, 0x4(%rsp)
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movq %r14, %rsi
callq 0x6190
xorps %xmm0, %xmm0
cvtsi2ssq (%r14), %xmm0
addss (%rsp), %xmm0
cvtsi2ssq 0x8(%r14), %xmm1
addss 0x4(%rsp), %xmm1
mulss 0x11450(%rip), %xmm1    # 0x2d004
addss %xmm0, %xmm1
movss %xmm1, 0x14(%rbx)
addq $0x98, %rsp
popq %rbx
popq %r14
retq
movb 0x2368a(%rip), %al      # 0x3f258
testb %al, %al
leaq 0x11e22(%rip), %rcx     # 0x2d9f9
leaq 0x12389(%rip), %rsi     # 0x2df67
cmovneq %rcx, %rsi
leaq 0x12(%rsi), %rdx
testb %al, %al
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
cmoveq %rsi, %rdx
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xe5ba
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq 0x233c8(%rip), %rdi     # 0x3efd8
callq 0x62e0
movq %rax, %rbx
leaq 0x12556(%rip), %rsi     # 0x2e175
movl $0x31, %edx
movq %rax, %rdi
callq 0x62e0
movq %rbx, %rdi
callq 0x6150
leaq 0x8(%rsp), %rdi
callq 0x6140
movl $0x1, %edi
callq 0x6310
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x1bc5a
callq 0x6260
movq %rbx, %rdi
callq 0x6410
// File: /workspace/github_cpp_makefile_star2_O1/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:
xorl %eax, %eax
movq %rax, 0x14(%rdi)
movl $0x0, 0x1c(%rdi)
movq 0x8(%rdi), %rcx
movq %rax, 0x10(%rcx)
movq 0x28(%rdi), %rax
testq %rax, %rax
je 0x1c985
movq $0x0, 0x10(%rax)
movl $0x0, 0x18(%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
xorl %eax, %eax
movq %rax, 0x14(%rdi)
movl $0x0, 0x1c(%rdi)
movq 0x8(%rdi), %rcx
movq %rax, 0x10(%rcx)
movq 0x38(%rdi), %rax
movq -0x8(%rax), %rdi
movq (%rdi), %rax
jmpq *0x28(%rax)
nop
// File: /workspace/github_cpp_makefile_star2_O1/bonetblai[P]mdp-engine/ctp3/../engine/rollout.h
// Function: Online::Policy::Rollout::nested_rollout_t<state_t>::print_other_stats(std::ostream&, int) const
virtual void print_other_stats(std::ostream &os, int indent) const {
        os << std::setw(indent) << ""
           << "other-stats: name=" << name() << std::endl;
        for( int i = 0; i < int(nested_policies_.size()); ++i )
            nested_policies_[i]->print_other_stats(os, 2 + indent);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq (%rsi), %rax
movq -0x18(%rax), %rax
movslq %edx, %rcx
movq %rcx, 0x10(%rsi,%rax)
leaq 0x101c4(%rip), %rsi     # 0x2df67
movq %r14, %rdi
xorl %edx, %edx
callq 0x62e0
leaq 0xf84d(%rip), %rsi      # 0x2d601
movl $0x12, %edx
movq %r14, %rdi
callq 0x62e0
movq (%r15), %rax
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq *0x18(%rax)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %r14, %rdi
callq 0x62e0
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x6270
movsbl %al, %esi
movq %r12, %rdi
callq 0x6040
movq %rax, %rdi
callq 0x61e0
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1de20
callq 0x6260
movq 0x30(%r15), %rax
movq 0x38(%r15), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
testl %ecx, %ecx
jle 0x1de62
addl $0x2, %ebx
xorl %r12d, %r12d
movq (%rax,%r12,8), %rdi
movq (%rdi), %rax
movq %r14, %rsi
movl %ebx, %edx
callq *0x30(%rax)
incq %r12
movq 0x30(%r15), %rax
movq 0x38(%r15), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
movslq %ecx, %rcx
cmpq %rcx, %r12
jl 0x1de39
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1de84
callq 0x6260
movq %rbx, %rdi
callq 0x6410
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1e20e
movq %rdi, %rbx
leaq 0x30(%rdi), %r14
movl 0x50(%rdi), %esi
incl %esi
movq %r14, %rdi
callq 0x1e2a8
movq 0x28(%rbx), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, 0x8(%rsp)
movq 0x38(%rbx), %rsi
cmpq 0x40(%rbx), %rsi
movq %r14, (%rsp)
je 0x1e16e
movq %rax, (%rsi)
addq $0x8, 0x38(%rbx)
jmp 0x1e17b
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
callq 0x1e352
cmpl $0x0, 0x50(%rbx)
je 0x1e1ff
xorl %ebp, %ebp
leaq 0x1fbae(%rip), %r13     # 0x3dd38
leaq 0x20847(%rip), %r15     # 0x3e9d8
movq 0x38(%rbx), %r12
movq -0x8(%r12), %r14
movl $0x40, %edi
callq 0x6290
movq 0x8(%rbx), %rcx
incl %ebp
movq %r13, (%rax)
movq %rcx, 0x8(%rax)
movl 0x21109(%rip), %ecx     # 0x3f2c0
movl %ecx, 0x10(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x14(%rax)
movq %r14, 0x28(%rax)
movq %r15, (%rax)
movq 0x48(%rbx), %rcx
movq %rcx, 0x30(%rax)
movl %ebp, 0x38(%rax)
movq %rax, 0x8(%rsp)
cmpq 0x40(%rbx), %r12
je 0x1e1e9
movq %rax, (%r12)
addq $0x8, 0x38(%rbx)
jmp 0x1e1fa
movq (%rsp), %rdi
movq %r12, %rsi
leaq 0x8(%rsp), %rdx
callq 0x1f8a2
cmpl 0x50(%rbx), %ebp
jb 0x1e191
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movb 0x21044(%rip), %al      # 0x3f258
testb %al, %al
leaq 0xf7dc(%rip), %rcx      # 0x2d9f9
leaq 0xfd43(%rip), %rsi      # 0x2df67
cmovneq %rcx, %rsi
leaq 0x12(%rsi), %rdx
testb %al, %al
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
cmoveq %rsi, %rdx
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xe5ba
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq 0x20d82(%rip), %rdi     # 0x3efd8
callq 0x62e0
movq %rax, %rbx
leaq 0xff99(%rip), %rsi      # 0x2e1fe
movl $0x3c, %edx
movq %rax, %rdi
callq 0x62e0
movq %rbx, %rdi
callq 0x6150
leaq 0x8(%rsp), %rdi
callq 0x6140
movl $0x1, %edi
callq 0x6310
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x1e2a0
callq 0x6260
movq %rbx, %rdi
callq 0x6410
// File: /workspace/github_cpp_makefile_star2_O1/bonetblai[P]mdp-engine/ctp3/../engine/rollout.h
// Function: Online::Policy::Rollout::rollout_t<state_t>::operator()(state_t const&) const
virtual Problem::action_t operator()(const T &s) const {
        ++policy_t<T>::decisions_;
        Problem::action_t best_action = Problem::noop;
        float best_value = std::numeric_limits<float>::max();
        for( Problem::action_t a = 0; a < problem_.number_actions(s); ++a ) {
            if( problem_.applicable(s, a) ) {
                float value = 0;
                for( unsigned trial = 0; trial < width_; ++trial ) {
                    std::pair<T, bool> p = problem_.sample(s, a);
                    value += problem_.cost(s, a) + problem_.discount() * evaluate(p.first);
                }
                value /= width_;
                if( value < best_value ) {
                    best_value = value;
                    best_action = a;
                }
            }
        }
        assert(best_action != Problem::noop);
        return best_action;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
incl 0x20(%rdi)
movq %rsi, %r14
movq 0x8(%rdi), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
testl %eax, %eax
jle 0x1f100
xorl %r15d, %r15d
movss 0xe01f(%rip), %xmm0     # 0x2d014
movss %xmm0, 0xc(%rsp)
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
leaq 0x20(%rsp), %r12
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
movq %r14, %rsi
movl %r15d, %edx
callq *0x30(%rax)
testb %al, %al
je 0x1f0e5
movl 0x30(%rbx), %eax
xorps %xmm1, %xmm1
testl %eax, %eax
je 0x1f0c0
xorl %r13d, %r13d
movss %xmm1, 0x1c(%rsp)
movq 0x8(%rbx), %rsi
movq %r12, %rdi
movq %r14, %rdx
movl %r15d, %ecx
callq 0xe0cc
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
movq %r14, %rsi
movl %r15d, %edx
callq *0x48(%rax)
movss %xmm0, 0x18(%rsp)
movq 0x8(%rbx), %rax
movss 0x8(%rax), %xmm0
movss %xmm0, 0x14(%rsp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1f48a
cmpb $0x0, 0x7c(%rsp)
jne 0x1f09b
movq 0x80(%rsp), %rdi
testq %rdi, %rdi
je 0x1f09b
movss %xmm0, 0x10(%rsp)
callq 0x6340
movss 0x10(%rsp), %xmm0
mulss 0x14(%rsp), %xmm0
movss 0x1c(%rsp), %xmm1
addss 0x18(%rsp), %xmm1
addss %xmm0, %xmm1
incl %r13d
movl 0x30(%rbx), %eax
cmpl %eax, %r13d
jb 0x1f02e
movl %eax, %eax
xorps %xmm0, %xmm0
cvtsi2ss %rax, %xmm0
divss %xmm0, %xmm1
movss 0xc(%rsp), %xmm0
ucomiss %xmm0, %xmm1
minss %xmm1, %xmm0
movss %xmm0, 0xc(%rsp)
cmovbl %r15d, %ebp
incl %r15d
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x10(%rax)
cmpl %eax, %r15d
jl 0x1f005
jmp 0x1f105
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
cmpl $-0x1, %ebp
je 0x1f11e
movl %ebp, %eax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xf130(%rip), %rdi      # 0x2e255
leaq 0xf146(%rip), %rsi      # 0x2e272
leaq 0xf153(%rip), %rcx      # 0x2e286
movl $0x5b, %edx
callq 0x61c0
movq %rax, %rbx
cmpb $0x0, 0x7c(%rsp)
jne 0x1f159
movq 0x80(%rsp), %rdi
testq %rdi, %rdi
je 0x1f159
callq 0x6340
movq %rbx, %rdi
callq 0x6410
nop
// File: /workspace/github_cpp_makefile_star2_O1/bonetblai[P]mdp-engine/ctp3/../engine/rollout.h
// Function: Online::Policy::Rollout::rollout_t<state_t>::reset_stats() const
virtual void reset_stats() const {
        policy_t<T>::setup_time_ = 0;
        policy_t<T>::base_policy_time_ = 0;
        policy_t<T>::heuristic_time_ = 0;
        problem_.clear_expansions();
        if( base_policy_ != 0 ) base_policy_->reset_stats();
    }

// Assembly:
xorl %eax, %eax
movq %rax, 0x14(%rdi)
movl $0x0, 0x1c(%rdi)
movq 0x8(%rdi), %rcx
movq %rax, 0x10(%rcx)
movq 0x28(%rdi), %rdi
testq %rdi, %rdi
je 0x1f186
movq (%rdi), %rax
jmpq *0x28(%rax)
retq
nop