LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/bonetblai[P]mdp-engine/ctp3/../engine/base_policies.h
// Function: Online::Policy::random_t<state_t>::operator()(state_t const&) const
virtual Problem::action_t operator()(const T &s) const {
        ++policy_t<T>::decisions_;
        if( problem_.dead_end(s) ) return Problem::noop;
        std::vector<Problem::action_t> actions;
        actions.reserve(problem_.number_actions(s));
        for( Problem::action_t a = 0; a < problem_.number_actions(s); ++a ) {
            if( problem_.applicable(s, a) ) {
                actions.push_back(a);
            }
        }
        return actions.empty() ? Problem::noop : actions[Random::random(actions.size())];
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
incl 0x20(%rdi)
movq %rsi, %r14
movq 0x8(%rdi), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testb %al, %al
jne 0xce58
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x10(%rax)
movslq %eax, %rsi
leaq 0x10(%rsp), %rdi
callq 0xbe32
xorl %ebp, %ebp
leaq 0x10(%rsp), %r15
leaq 0xc(%rsp), %r12
movl %ebp, 0xc(%rsp)
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x10(%rax)
cmpl %eax, %ebp
jge 0xce13
movq 0x8(%rbx), %rdi
movl 0xc(%rsp), %edx
movq (%rdi), %rax
movq %r14, %rsi
callq *0x30(%rax)
testb %al, %al
je 0xce0b
movq 0x18(%rsp), %rsi
cmpq 0x20(%rsp), %rsi
je 0xce00
movl 0xc(%rsp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x18(%rsp)
jmp 0xce0b
movq %r15, %rdi
movq %r12, %rdx
callq 0xa316
movl 0xc(%rsp), %ebp
incl %ebp
jmp 0xcdb9
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rbx
cmpq %rbx, %rdi
je 0xce42
subq %rdi, %rbx
shrq $0x2, %rbx
cmpl $0x1, %ebx
je 0xce4e
testl %ebx, %ebx
je 0xce67
callq 0x5200
xorl %edx, %edx
divl %ebx
movq 0x10(%rsp), %rdi
jmp 0xce50
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testq %rdi, %rdi
jne 0xce53
jmp 0xce58
xorl %edx, %edx
movl (%rdi,%rdx,4), %ebp
callq 0x5260
movl %ebp, %eax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1e7ad(%rip), %rdi     # 0x2b61b
leaq 0x1e7ae(%rip), %rsi     # 0x2b623
leaq 0x1e7ba(%rip), %rcx     # 0x2b636
movl $0x3a, %edx
callq 0x51c0
jmp 0xce88
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0xce9a
callq 0x5260
movq %rbx, %rdi
callq 0x5410
// File: /workspace/github_cpp_makefile_star2_O3/bonetblai[P]mdp-engine/ctp3/../engine/problem.h
// Function: Problem::problem_t<state_t>::sample(state_t const&, int) const
std::pair<T, bool> sample(const T &s, action_t a) const {
        std::vector<std::pair<T, float> > outcomes;
        next(s, a, outcomes);
        unsigned osize = outcomes.size();
        assert(osize > 0);

        float r = Random::real();
        for( unsigned i = 0; i < osize; ++i ) {
            if( r < outcomes[i].second ) {
                return std::make_pair(outcomes[i].first, true);
            }
            r -= outcomes[i].second;
        }
        return std::make_pair(outcomes[0].first, true);
    }

// Assembly:
pushq %r14
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
sarq $0x3, %rax
movabsq $-0x1111111111111111, %r14 # imm = 0xEEEEEEEEEEEEEEEF
imulq %rax, %r14
testl %r14d, %r14d
je 0xcf8f
callq 0x5250
cvtsd2ss %xmm0, %xmm0
movq (%rsp), %rsi
movl %r14d, %eax
imulq $0x78, %rax, %rcx
xorl %eax, %eax
movss 0x70(%rsi,%rax), %xmm1
ucomiss %xmm1, %xmm0
jb 0xcf4c
subss %xmm1, %xmm0
addq $0x78, %rax
cmpq %rax, %rcx
jne 0xcf09
xorps %xmm0, %xmm0
movups %xmm0, 0x34(%rbx)
movups %xmm0, 0x24(%rbx)
movups %xmm0, 0x14(%rbx)
movups %xmm0, 0x4(%rbx)
xorl %eax, %eax
movq %rax, 0x44(%rbx)
movb $0x1, 0x5c(%rbx)
movq %rax, 0x60(%rbx)
movq %rbx, %rdi
callq 0xc30a
jmp 0xcf78
xorps %xmm0, %xmm0
movups %xmm0, 0x34(%rbx)
movups %xmm0, 0x24(%rbx)
movups %xmm0, 0x14(%rbx)
movups %xmm0, 0x4(%rbx)
xorl %ecx, %ecx
movq %rcx, 0x44(%rbx)
movb $0x1, 0x5c(%rbx)
movq %rcx, 0x60(%rbx)
addq %rax, %rsi
movq %rbx, %rdi
callq 0xc30a
movb $0x1, 0x70(%rbx)
movq %rsp, %rdi
callq 0xd12e
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
leaq 0x1e6ca(%rip), %rdi     # 0x2b660
leaq 0x1e6cd(%rip), %rsi     # 0x2b66a
leaq 0x1e6da(%rip), %rcx     # 0x2b67e
movl $0x94, %edx
callq 0x51c0
jmp 0xcfb2
jmp 0xcfb2
movq %rax, %rbx
movq %rsp, %rdi
callq 0xd12e
movq %rbx, %rdi
callq 0x5410
nop
// File: /workspace/github_cpp_makefile_star2_O3/bonetblai[P]mdp-engine/ctp3/../engine/base_policies.h
// Function: Online::Policy::random_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;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movq -0x18(%rax), %rax
movslq %edx, %rcx
movq %rcx, 0x10(%rsi,%rax)
leaq 0x1ef05(%rip), %rsi     # 0x2bf62
movq %r14, %rdi
xorl %edx, %edx
callq 0x52e0
leaq 0x1e58e(%rip), %rsi     # 0x2b5fc
movl $0x12, %edx
movq %r14, %rdi
callq 0x52e0
movq (%rbx), %rax
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq *0x18(%rax)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r14, %rdi
callq 0x52e0
movq %rax, %r14
leaq 0x1e56c(%rip), %rsi     # 0x2b60f
movl $0xb, %edx
movq %rax, %rdi
callq 0x52e0
movl 0x20(%rbx), %esi
movq %r14, %rdi
callq 0x51d0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x5270
movsbl %al, %esi
movq %rbx, %rdi
callq 0x5040
movq %rax, %rdi
callq 0x51e0
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xd0f8
callq 0x5260
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xd118
callq 0x5260
movq %rbx, %rdi
callq 0x5410
// File: /workspace/github_cpp_makefile_star2_O3/bonetblai[P]mdp-engine/ctp3/./ctp3.h
// Function: ctp_optimistic_policy_t::operator()(state_t const&) const
virtual Problem::action_t operator()(const state_t &s) const {
        float best_cost = FLT_MAX;
        Problem::action_t best_action = Problem::noop;
        for( Problem::action_t a = 0; a < problem().number_actions(s); ++a ) {
            if( problem().applicable(s, a) ) {
                float cost = problem().cost(s, a);
                cost += graph_.bfs(a, graph_.num_nodes_ - 1, s.info_.known_, s.info_.blocked_, true) * multiplier_;
                if( cost < best_cost ) {
                    best_cost = cost;
                    best_action = a;
                }
            }
        }
        return best_action;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
testl %eax, %eax
jle 0xd331
leaq 0x4(%rbx), %r15
leaq 0x28(%rbx), %r12
movss 0x1dd79(%rip), %xmm0    # 0x2b014
movss %xmm0, (%rsp)
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
xorl %r13d, %r13d
movq 0x8(%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
movl %r13d, %edx
callq *0x30(%rax)
testb %al, %al
je 0xd316
movq 0x8(%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
movl %r13d, %edx
callq *0x48(%rax)
movss %xmm0, 0x4(%rsp)
movq 0x28(%r14), %rdi
movl (%rdi), %edx
decl %edx
movl %r13d, %esi
movq %r15, %rcx
movq %r12, %r8
movl $0x1, %r9d
callq 0xae5a
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
mulss 0x30(%r14), %xmm0
addss 0x4(%rsp), %xmm0
movss (%rsp), %xmm1
ucomiss %xmm1, %xmm0
minss %xmm0, %xmm1
movss %xmm1, (%rsp)
cmovbl %r13d, %ebp
incl %r13d
movq 0x8(%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x10(%rax)
cmpl %eax, %r13d
jl 0xd2a8
jmp 0xd336
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/bonetblai[P]mdp-engine/ctp3/../engine/utils.h
// Function: Utils::split_request(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>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
inline void split_request(const std::string &request, std::string &name, std::string &parameter_str) {
    size_t first = request.find_first_of("(");
    size_t last = request.find_last_of(")");
    if( (first != std::string::npos) && (last != std::string::npos) ) {
        name = request.substr(0, first);
        parameter_str = request.substr(1 + first, last - first - 1);
    } else {
        name = request;
    }
    //std::cout << "name=" << name << ", parameters=|" << parameter_str << "|" << std::endl;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r14
leaq 0x1e120(%rip), %rsi     # 0x2c06f
movl $0x1, %ecx
xorl %edx, %edx
callq 0x5390
movq %rax, %r15
leaq 0x1d508(%rip), %rsi     # 0x2b46d
movl $0x1, %ecx
movq %r14, %rdi
movq $-0x1, %rdx
callq 0x5480
movq %rax, %r13
cmpq $-0x1, %r15
sete %al
cmpq $-0x1, %r13
sete %cl
orb %al, %cl
jne 0xe005
leaq 0x8(%rsp), %rbp
movq %rbp, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %r15, %rcx
callq 0x52b0
movq %r12, %rdi
movq %rbp, %rsi
callq 0x5320
movq (%rbp), %rdi
leaq 0x18(%rsp), %r12
cmpq %r12, %rdi
je 0xdfc1
callq 0x5260
leaq 0x1(%r15), %rdx
notq %r15
addq %r15, %r13
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movq %r13, %rcx
callq 0x52b0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5320
movq (%r15), %rdi
cmpq %r12, %rdi
je 0xdff6
callq 0x5260
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r12, %rdi
movq %r14, %rsi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x5170
// File: /workspace/github_cpp_makefile_star2_O3/bonetblai[P]mdp-engine/ctp3/../engine/hash.h
// Function: Hash::hash_map_t<state_t, Hash::hash_function_t<state_t>>::data_ptr(state_t const&)
Hash::data_t* data_ptr(const T &s) {
        iterator di = lookup(s);
        if( di == end() )
            return push(s, new Hash::data_t(default_value(s)) );
         else
            return (*di).second;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
addq $0x8, %rdi
callq 0xf446
testq %rax, %rax
je 0xefd5
movq 0x78(%rax), %rax
popq %rbx
popq %r14
popq %r15
retq
movl $0x28, %edi
callq 0x5290
movq %rax, %r15
movq 0x40(%r14), %rdi
testq %rdi, %rdi
je 0xeff6
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x10(%rax)
jmp 0xeff9
xorps %xmm0, %xmm0
movss %xmm0, (%r15)
movw $0x0, 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 0xf3a6
movq %rax, %rbx
movq %r15, %rdi
callq 0x5260
movq %rbx, %rdi
callq 0x5410
// File: /workspace/github_cpp_makefile_star2_O3/bonetblai[P]mdp-engine/ctp3/../engine/problem.h
// Function: Problem::hash_t<state_t>::best_q_value(state_t const&) const
std::pair<action_t, float> best_q_value(const T &s) const {
        action_t best_action = noop;
        float best_value = std::numeric_limits<float>::max();
        for( action_t a = 0; a < problem_.number_actions(s); ++a ) {
            if( problem_.applicable(s, a) ) {
                float value = q_value(s, a);
                if( value < best_value ) {
                    best_value = value;
                    best_action = a;
                }
            }
        }
        return std::make_pair(best_action, best_value);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x48(%rdi), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
testl %eax, %eax
jle 0xf93b
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
movss 0x1b73b(%rip), %xmm0    # 0x2b014
movss %xmm0, 0x4(%rsp)
xorl %ebp, %ebp
movq 0x48(%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
movl %ebp, %edx
callq *0x30(%rax)
testb %al, %al
je 0xf912
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq *0x10(%rax)
ucomiss 0x4(%rsp), %xmm0
jae 0xf912
movl %ebp, %r15d
movss %xmm0, 0x4(%rsp)
incl %ebp
movq 0x48(%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x10(%rax)
cmpl %eax, %ebp
jl 0xf8e1
movd 0x4(%rsp), %xmm0
movd %xmm0, %ecx
shlq $0x20, %rcx
movl %r15d, %eax
orq %rcx, %rax
jmp 0xf945
movabsq $0x7f7fffffffffffff, %rax # imm = 0x7F7FFFFFFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/bonetblai[P]mdp-engine/ctp3/../engine/improved_lao.h
// Function: Algorithm::improved_lao_t<state_t>::policy_graph_t::update(std::__cxx11::list<std::pair<state_t, Hash::data_t*>, std::allocator<std::pair<state_t, Hash::data_t*>>>&)
void update(pair_list &visited) {
            for( list_iterator si = visited.begin(); si != visited.end(); ++si ) {
                std::pair<Problem::action_t, float> p = hash_.best_q_value(si->first);
                si->second->update(p.second);
                hash_.inc_updates();
            }
        }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq (%rsi), %r15
cmpq %rsi, %r15
je 0x10dc0
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rdi
leaq 0x10(%r15), %rsi
callq 0xf8b0
shrq $0x20, %rax
movq 0x80(%r15), %rcx
movl %eax, (%rcx)
movq 0x8(%r14), %rdi
incl 0x50(%rdi)
movq (%r15), %r15
cmpq %rbx, %r15
jne 0x10d9b
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xf446
testq %rax, %rax
je 0x1127d
movq 0x78(%rax), %rax
movb $0x1, 0x4(%rax)
popq %rbx
popq %r14
popq %r15
retq
movl $0x28, %edi
callq 0x5290
movq %rax, %r15
movq 0x40(%r14), %rdi
testq %rdi, %rdi
je 0x1129e
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x10(%rax)
jmp 0x112a1
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 0xf3a6
movq %rax, %rbx
movq %r15, %rdi
callq 0x5260
movq %rbx, %rdi
callq 0x5410
// File: /workspace/github_cpp_makefile_star2_O3/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, %r12
movq (%rdi), %rax
movq %rdx, %rsi
callq *0x30(%rax)
movq 0x10(%r12), %rax
leaq 0x2a44a(%rip), %rcx     # 0x3c1a0
leaq 0x48(%rsp), %rdx
movq %rcx, (%rdx)
movq %rax, 0x8(%rdx)
movq %rdx, 0x40(%r14)
leaq 0x10(%rsp), %rcx
movq %rcx, 0x8(%rcx)
movq %rcx, (%rcx)
xorl %eax, %eax
movq %rax, 0x10(%rcx)
leaq 0x30(%rsp), %r15
movq %r15, 0x8(%r15)
movq %r15, (%r15)
movq %rax, 0x10(%r15)
movq %r14, %rdi
movq %r13, %rbx
movq %r13, %rsi
callq 0xefb2
movq %rax, %r13
cmpb $0x0, 0x4(%rax)
je 0x11da6
movq 0x30(%rsp), %rbp
jmp 0x11e08
movq $0x0, 0x28(%rsp)
movq %r15, (%rsp)
movq %r12, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movq %r13, %rcx
leaq 0x28(%rsp), %r8
leaq 0x10(%rsp), %rbp
movq %rbp, %r9
callq 0x1206a
cmpq %rbp, 0x10(%rsp)
je 0x11df7
jmp 0x11e57
movq 0x10(%rbp), %rax
movb $0x0, 0x5(%rax)
decq 0x40(%rsp)
movq %rbp, %rdi
callq 0x53d0
movq %rbp, %rdi
callq 0x5260
movq 0x30(%rsp), %rbp
cmpq %r15, %rbp
jne 0x11dda
cmpb $0x1, 0x4(%r13)
jne 0x11da6
movq $0x0, 0x40(%r14)
cmpq %r15, %rbp
je 0x11e29
movq (%rbp), %r14
movq %rbp, %rdi
callq 0x5260
movq %r14, %rbp
cmpq %r15, %r14
jne 0x11e15
movq 0x10(%rsp), %rdi
leaq 0x10(%rsp), %rbx
cmpq %rbx, %rdi
je 0x11e48
movq (%rdi), %r14
callq 0x5260
movq %r14, %rdi
cmpq %rbx, %r14
jne 0x11e38
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x19bd9(%rip), %rdi     # 0x2ba37
leaq 0x19e15(%rip), %rsi     # 0x2bc7a
leaq 0x19e1f(%rip), %rcx     # 0x2bc8b
movl $0xcf, %edx
callq 0x51c0
jmp 0x11e78
movq %rax, %r14
movq 0x30(%rsp), %rdi
cmpq %r15, %rdi
je 0x11e95
movq (%rdi), %r12
callq 0x5260
movq %r12, %rdi
cmpq %r15, %r12
jne 0x11e85
movq 0x10(%rsp), %rdi
leaq 0x10(%rsp), %rbx
cmpq %rbx, %rdi
je 0x11eb4
movq (%rdi), %r15
callq 0x5260
movq %r15, %rdi
cmpq %rbx, %r15
jne 0x11ea4
movq %r14, %rdi
callq 0x5410
// File: /workspace/github_cpp_makefile_star2_O3/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 0x287cb(%rip), %rcx     # 0x3c1a0
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 0xf446
testq %rax, %rax
je 0x13a04
movq 0x78(%rax), %rax
cmpb $0x0, 0x4(%rax)
jne 0x13a17
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x13a30
incq %r12
jmp 0x139ea
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_O3/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 (%rsp), %rax
movq 0x8(%rsp), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
imull $0xeeeeeeef, %ecx, %ebp # imm = 0xEEEEEEEF
cmpl $0x1, %ebp
je 0x13e96
testl %ebp, %ebp
je 0x13ede
callq 0x5200
xorl %edx, %edx
divl %ebp
movq (%rsp), %rax
jmp 0x13e98
xorl %edx, %edx
imulq $0x78, %rdx, %rsi
addq %rax, %rsi
xorps %xmm0, %xmm0
movups %xmm0, 0x34(%rbx)
movups %xmm0, 0x24(%rbx)
movups %xmm0, 0x14(%rbx)
movups %xmm0, 0x4(%rbx)
xorl %eax, %eax
movq %rax, 0x44(%rbx)
movb $0x1, 0x5c(%rbx)
movq %rax, 0x60(%rbx)
movq %rbx, %rdi
callq 0xc30a
movb $0x1, 0x70(%rbx)
movq %rsp, %rdi
callq 0xd12e
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
leaq 0x17736(%rip), %rdi     # 0x2b61b
leaq 0x17737(%rip), %rsi     # 0x2b623
leaq 0x17743(%rip), %rcx     # 0x2b636
movl $0x3a, %edx
callq 0x51c0
jmp 0x13eff
movq %rax, %rbx
movq %rsp, %rdi
callq 0xd12e
movq %rbx, %rdi
callq 0x5410
// File: /workspace/github_cpp_makefile_star2_O3/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 0x26f0c(%rip), %rcx     # 0x3c1a0
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 0xf446
testq %rax, %rax
je 0x152c2
movq 0x78(%rax), %rax
cmpb $0x0, 0x4(%rax)
jne 0x152d9
movq 0x8(%r15), %rdi
movss 0x1c(%r15), %xmm0
movq %r14, %rsi
movq %rbx, %rdx
callq 0x141a5
jmp 0x152a8
movq $0x0, 0x40(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x15fad(%rip), %rsi     # 0x2b7e2
leaq 0x15faf(%rip), %rdx     # 0x2b7eb
leaq 0x8(%rsp), %rdi
callq 0xd386
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0xef28
movq %rax, %r12
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x15865
callq 0x5260
leaq 0x8(%r14), %rbp
cmpq %rbp, %r12
je 0x158b6
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x1587d
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x8(%rbx), %rsi
leaq 0x20(%r12), %rdx
addq $0x40, %r12
movq %r15, %rdi
movq %r12, %rcx
callq 0x7a98
leaq 0x38(%r15), %rdi
movq %r12, %rsi
callq 0x17c4e
addq $0x40, %r15
cmpq %r15, %rax
je 0x158b0
movq 0x40(%rax), %rax
jmp 0x158b2
xorl %eax, %eax
movq %rax, 0x10(%rbx)
leaq 0x8(%rsp), %rdi
movq %r13, (%rdi)
leaq 0x1591b(%rip), %rsi     # 0x2b1e0
leaq 0x15918(%rip), %rdx     # 0x2b1e4
callq 0xd386
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0xef28
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x158f0
callq 0x5260
cmpq %rbp, %r14
je 0x15905
movq 0x40(%r14), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x5370
movl %eax, 0x18(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x15918
jmp 0x1592c
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x1592f
callq 0x5260
jmp 0x1592f
movq %rax, %rbx
movq %rbx, %rdi
callq 0x5410
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x24ba6(%rip), %rcx     # 0x3c1a0
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 0x17702
movss 0x1c(%r14), %xmm0
movss 0x139d9(%rip), %xmm1    # 0x2b008
addss %xmm0, %xmm1
ucomiss %xmm0, %xmm1
jbe 0x176bd
xorl %r15d, %r15d
movq 0x18(%rbx), %r12
xorps %xmm1, %xmm1
testq %r12, %r12
je 0x176a8
movss %xmm1, 0xc(%rsp)
leaq 0x8(%r12), %rsi
movq 0x78(%r12), %rax
movss (%rax), %xmm0
movss %xmm0, 0x8(%rsp)
movq %rbx, %rdi
callq 0xf8b0
movaps 0x13a3c(%rip), %xmm1    # 0x2b0b0
shrq $0x20, %rax
movd %eax, %xmm0
subss 0x8(%rsp), %xmm0
movq 0x78(%r12), %rcx
movl %eax, (%rcx)
incl 0x50(%rbx)
andps %xmm1, %xmm0
movss 0xc(%rsp), %xmm1
maxss %xmm0, %xmm1
movq (%r12), %r12
testq %r12, %r12
jne 0x1764b
movss 0x1c(%r14), %xmm0
ucomiss %xmm0, %xmm1
jbe 0x176bd
leaq 0x1(%r15), %rax
movl 0x20(%r14), %ecx
cmpq %rcx, %r15
movq %rax, %r15
jb 0x1763f
movq $0x0, 0x40(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5190
movq (%r15), %r13
movq 0x8(%r15), %r12
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movq %r15, %rsi
callq 0x5190
movq (%r15), %rbp
movq 0x8(%r15), %r15
incl 0x18(%rbx)
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x1800d
movq %r14, %rsi
callq 0x1250c
jmp 0x18010
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 0x5190
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 0x5190
xorps %xmm0, %xmm0
cvtsi2ssq (%r14), %xmm0
addss 0x10(%rsp), %xmm0
xorps %xmm1, %xmm1
cvtsi2ssq 0x8(%r14), %xmm1
addss 0x8(%rsp), %xmm1
mulss 0x12f53(%rip), %xmm1    # 0x2b004
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_O3/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 0x1830b
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 0x182ed
movl %eax, %eax
imulq $0x78, %rax, %r15
movss 0x12d8d(%rip), %xmm0    # 0x2b014
xorl %r12d, %r12d
movss %xmm0, 0xc(%rsp)
movq 0x10(%rsp), %rsi
addq %r12, %rsi
movq %rbx, %rdi
callq 0x1250c
movss 0xc(%rsp), %xmm1
minss %xmm0, %xmm1
movaps %xmm1, %xmm0
addq $0x78, %r12
cmpq %r12, %r15
jne 0x1828a
movss 0x12d56(%rip), %xmm1    # 0x2b014
ucomiss %xmm1, %xmm0
je 0x182f5
movss %xmm0, 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
jmp 0x182f5
movss 0x12d1f(%rip), %xmm1    # 0x2b014
movss %xmm1, 0xc(%rsp)
leaq 0x10(%rsp), %rdi
callq 0xd12e
movss 0xc(%rsp), %xmm0
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1831c
jmp 0x1831c
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xd12e
movq %rbx, %rdi
callq 0x5410
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x18440
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 0x183ff
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 0x1250c
mulss 0xc(%rsp), %xmm0
movss 0x8(%rsp), %xmm1
addss %xmm0, %xmm1
movss %xmm1, 0x8(%rsp)
addq $0x78, %r12
cmpq %r12, %r15
jne 0x183c1
jmp 0x18408
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 0xd12e
movss 0x8(%rsp), %xmm0
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x18451
jmp 0x18451
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xd12e
movq %rbx, %rdi
callq 0x5410
// File: /workspace/github_cpp_makefile_star2_O3/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 0x138a5(%rip), %rsi     # 0x2c06f
movl $0x1, %edx
movq %r14, %rdi
callq 0x52e0
cvtss2sd (%rbx), %xmm0
movq %r14, %rdi
callq 0x53b0
movq %rax, %r15
leaq 0x13773(%rip), %r14     # 0x2bf60
movl $0x2, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x52e0
movzbl 0x4(%rbx), %esi
movq %r15, %rdi
callq 0x5400
movq %rax, %r15
movl $0x2, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x52e0
movzbl 0x5(%rbx), %esi
movq %r15, %rdi
callq 0x5400
movq %rax, %r15
movl $0x2, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x52e0
movq 0x8(%rbx), %rsi
movq %r15, %rdi
callq 0x51d0
movq %rax, %r15
movl $0x2, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x52e0
movl 0x10(%rbx), %esi
movq %r15, %rdi
callq 0x5400
leaq 0x12c01(%rip), %rsi     # 0x2b46d
movl $0x1, %edx
movq %rax, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x52e0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x137d7(%rip), %rsi     # 0x2c06f
movl $0x1, %edx
movq %rbx, %rdi
callq 0x52e0
movl (%r14), %esi
movq %rbx, %rdi
callq 0x5400
movq %rax, %r15
leaq 0x135a0(%rip), %rsi     # 0x2be5a
movl $0x1, %edx
movq %rax, %rdi
callq 0x52e0
leaq 0x4(%r14), %rdi
movq %r15, %rsi
callq 0x1898a
leaq 0x13689(%rip), %rsi     # 0x2bf63
movl $0x4, %edx
movq %r15, %rdi
callq 0x52e0
cmpl $0x0, 0x2499a(%rip)     # 0x3d288
jle 0x18927
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 0x18a66
incq %r13
movslq 0x2496a(%rip), %rax     # 0x3d288
addl $0x20, %r12d
cmpq %rax, %r13
jl 0x188fb
leaq 0x1363a(%rip), %rsi     # 0x2bf68
movl $0x1, %edx
movq %rbx, %rdi
callq 0x52e0
movq %r14, %rdi
callq 0xae1e
cmpl $-0x1, (%r14)
je 0x18967
cmpl $0x7fffffff, 0x68(%r14) # imm = 0x7FFFFFFF
jne 0x18967
leaq 0x13610(%rip), %rsi     # 0x2bf6a
movl $0x5, %edx
movq %rbx, %rdi
callq 0x52e0
leaq 0x12aff(%rip), %rsi     # 0x2b46d
movl $0x1, %edx
movq %rbx, %rdi
callq 0x52e0
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x135cc(%rip), %rsi     # 0x2bf70
movl $0x3, %edx
movq %rbx, %rdi
callq 0x52e0
cmpl $0x0, 0x248bc(%rip)     # 0x3d274
jle 0x189f0
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 0x18a66
incq %r13
movslq 0x2488d(%rip), %rax     # 0x3d274
addl $0x20, %r12d
cmpq %rax, %r13
jl 0x189c5
leaq 0x1357d(%rip), %rsi     # 0x2bf74
movl $0x5, %edx
movq %rbx, %rdi
callq 0x52e0
cmpl $0x0, 0x24869(%rip)     # 0x3d274
jle 0x18a44
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 0x18a66
incq %r13
movslq 0x24839(%rip), %rax     # 0x3d274
addl $0x20, %r12d
cmpq %rax, %r13
jl 0x18a18
leaq 0x1351d(%rip), %rsi     # 0x2bf68
movl $0x1, %edx
movq %rbx, %rdi
callq 0x52e0
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x18ab7
movq %rsi, %rbx
movq %rdi, %r14
xorl %r12d, %r12d
leaq 0x133d6(%rip), %r15     # 0x2be5a
testb $0x1, %bpl
je 0x18aa9
movl 0x4(%r14), %esi
addl %r12d, %esi
movq %rbx, %rdi
callq 0x5400
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x52e0
incl %r12d
movl %ebp, %eax
shrl %eax
cmpl $0x1, %ebp
movl %eax, %ebp
ja 0x18a84
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x18bca
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
xorl %edi, %edi
movq %r14, %rsi
callq 0x5190
cvtsi2ssq (%r14), %xmm0
movss %xmm0, (%rsp)
xorps %xmm0, %xmm0
cvtsi2ssq 0x8(%r14), %xmm0
movss %xmm0, 0x4(%rsp)
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movq %r14, %rsi
callq 0x5190
xorps %xmm0, %xmm0
cvtsi2ssq (%r14), %xmm0
addss (%rsp), %xmm0
movss %xmm0, (%rsp)
xorps %xmm0, %xmm0
cvtsi2ssq 0x8(%r14), %xmm0
addss 0x4(%rsp), %xmm0
movss %xmm0, 0x4(%rsp)
movq 0x8(%rbx), %rdi
movq 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 0x5190
xorps %xmm0, %xmm0
cvtsi2ssq (%r14), %xmm0
subss (%rsp), %xmm0
movss %xmm0, (%rsp)
xorps %xmm0, %xmm0
cvtsi2ssq 0x8(%r14), %xmm0
subss 0x4(%rsp), %xmm0
movss %xmm0, 0x4(%rsp)
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movq %r14, %rsi
callq 0x5190
xorps %xmm0, %xmm0
cvtsi2ssq (%r14), %xmm0
addss (%rsp), %xmm0
cvtsi2ssq 0x8(%r14), %xmm1
addss 0x4(%rsp), %xmm1
mulss 0x1244e(%rip), %xmm1    # 0x2b004
addss %xmm0, %xmm1
movss %xmm1, 0x14(%rbx)
addq $0x98, %rsp
popq %rbx
popq %r14
retq
movb 0x24688(%rip), %al      # 0x3d258
testb %al, %al
leaq 0x12e1b(%rip), %rcx     # 0x2b9f4
leaq 0x13382(%rip), %rsi     # 0x2bf62
cmovneq %rcx, %rsi
leaq 0x12(%rsi), %rdx
testb %al, %al
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
cmoveq %rsi, %rdx
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xd386
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq 0x243c6(%rip), %rdi     # 0x3cfd8
callq 0x52e0
movq %rax, %rbx
leaq 0x13359(%rip), %rsi     # 0x2bf7a
movl $0x34, %edx
movq %rax, %rdi
callq 0x52e0
movq %rbx, %rdi
callq 0x5150
leaq 0x8(%rsp), %rdi
callq 0x5140
movl $0x1, %edi
callq 0x5310
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x18c5c
callq 0x5260
movq %rbx, %rdi
callq 0x5410
// File: /workspace/github_cpp_makefile_star2_O3/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 0x12251(%rip), %rsi     # 0x2b27d
leaq 0x12253(%rip), %rdx     # 0x2b286
movq %rsp, %r15
movq %r15, %rdi
callq 0xd386
movq %r12, %rdi
movq %r15, %rsi
callq 0xef28
movq %rax, %r15
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x1905a
callq 0x5260
addq $0x8, %r12
cmpq %r12, %r15
je 0x190aa
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x19072
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x8(%rbx), %rsi
leaq 0x20(%r15), %rdx
addq $0x40, %r15
movq %r14, %rdi
movq %r15, %rcx
callq 0x7a98
leaq 0x8(%r14), %rdi
movq %r15, %rsi
callq 0x28f46
addq $0x10, %r14
cmpq %r14, %rax
je 0x190a4
movq 0x40(%rax), %rax
jmp 0x190a6
xorl %eax, %eax
movq %rax, 0x28(%rbx)
movq %rbx, %rdi
callq 0x1922c
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x190d1
callq 0x5260
movq %rbx, %rdi
callq 0x5410
// File: /workspace/github_cpp_makefile_star2_O3/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 0x19341
movq %rdi, %rbx
leaq 0x10(%rsp), %r14
xorl %edi, %edi
movq %r14, %rsi
callq 0x5190
movq (%r14), %r13
movq 0x8(%r14), %r12
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movq %r14, %rsi
callq 0x5190
movq 0x28(%rbx), %r15
testq %r15, %r15
je 0x193c1
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 0x5190
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 0x5190
xorps %xmm0, %xmm0
cvtsi2ssq (%r14), %xmm0
addss 0x8(%rsp), %xmm0
xorps %xmm1, %xmm1
cvtsi2ssq 0x8(%r14), %xmm1
addss 0xc(%rsp), %xmm1
mulss 0x11cdd(%rip), %xmm1    # 0x2b004
addss %xmm0, %xmm1
movss %xmm1, 0x14(%rbx)
addq $0xa0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movb 0x23f11(%rip), %al      # 0x3d258
testb %al, %al
leaq 0x126a4(%rip), %rcx     # 0x2b9f4
leaq 0x12c0b(%rip), %rsi     # 0x2bf62
cmovneq %rcx, %rsi
leaq 0x12(%rsi), %rdx
testb %al, %al
leaq 0x20(%rsp), %r14
movq %r14, -0x10(%r14)
cmoveq %rsi, %rdx
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0xd386
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq 0x23c4f(%rip), %rdi     # 0x3cfd8
callq 0x52e0
movq %rax, %rbx
leaq 0x12c2a(%rip), %rsi     # 0x2bfc2
movl $0x34, %edx
movq %rax, %rdi
callq 0x52e0
movq %rbx, %rdi
callq 0x5150
leaq 0x10(%rsp), %rdi
callq 0x5140
movl $0x1, %edi
callq 0x5310
leaq 0x12c2f(%rip), %rdi     # 0x2bff7
leaq 0x12c38(%rip), %rsi     # 0x2c007
leaq 0x12c47(%rip), %rcx     # 0x2c01d
movl $0xee, %edx
callq 0x51c0
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x193f2
callq 0x5260
movq %rbx, %rdi
callq 0x5410
// File: /workspace/github_cpp_makefile_star2_O3/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 0x19848
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 0x1984d
movss 0x10(%rax), %xmm1
jmp 0x19850
xorps %xmm0, %xmm0
jmp 0x19850
xorps %xmm1, %xmm1
movss %xmm1, 0x10(%rbx)
addq $0x10, %rsp
popq %rbx
retq
nop