LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: bonetblai[P]mdp-engine/ctp3/./ctp3.h
// Function: state_info_t::hash() const
size_t hash() const {
        unsigned rv = 0;
        for( int i = 0; i < words_for_edges_; ++i )
            rv = rv ^ known_[i];
        for( int i = 0; i < words_for_edges_; ++i )
            rv = rv ^ rotation(blocked_[i]);
        return rv;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x1c(%rsp)
movl $0x0, 0x18(%rsp)
movl 0x18(%rsp), %eax
cmpl 0x6e49f(%rip), %eax     # 0x8330c
jge 0x14e91
movq 0x8(%rsp), %rcx
movl 0x1c(%rsp), %eax
movslq 0x18(%rsp), %rdx
xorl (%rcx,%rdx,4), %eax
movl %eax, 0x1c(%rsp)
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x14e63
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x6e469(%rip), %eax     # 0x8330c
jge 0x14ed9
movq 0x8(%rsp), %rax
movl 0x1c(%rsp), %ecx
movl %ecx, 0x4(%rsp)
movslq 0x14(%rsp), %rcx
movl 0x24(%rax,%rcx,4), %edi
callq 0x14ef0
movl %eax, %ecx
movl 0x4(%rsp), %eax
xorl %ecx, %eax
movl %eax, 0x1c(%rsp)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x14e99
movl 0x1c(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: bonetblai[P]mdp-engine/ctp3/./ctp3.h
// Function: next_cache_t::lookup(state_t const&, int) const
const std::vector<std::pair<state_t, float> >* lookup(const state_t &state,
                                                          Problem::action_t a) const {
        ++lookups_;
        next_cache_item_t *item = items_[a];
        next_cache_item_t::const_iterator it = item->find(state);
        if( it != item->end() ) {
            ++hits_;
            return it->second;
        } else
            return 0;
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movl %edx, 0x2c(%rsp)
movq 0x38(%rsp), %rax
movq %rax, (%rsp)
movl 0x18(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x18(%rax)
movq 0x8(%rax), %rax
movslq 0x2c(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x169a0
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x169d0
movq 0x20(%rsp), %rdi
callq 0x16a20
movq %rax, 0x8(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x16a00
testb $0x1, %al
jne 0x160ad
jmp 0x160cf
movq (%rsp), %rax
movl 0x1c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x1c(%rax)
leaq 0x18(%rsp), %rdi
callq 0x16a50
movq 0x70(%rax), %rax
movq %rax, 0x40(%rsp)
jmp 0x160d8
movq $0x0, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: bonetblai[P]mdp-engine/ctp3/./ctp3.h
// Function: state_info_t::set_edge_status(int, bool)
void set_edge_status(int edge, bool blocked) {
        int n = edge >> 5, offset = edge & 0x1F;
        int mask = 1 << offset;
        known_[n] |= mask;
        if( blocked )
            blocked_[n] |= mask;
        else
            blocked_[n] &= ~mask;
    }

// Assembly:
movb %dl, %al
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
andb $0x1, %al
movb %al, -0xd(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x28(%rsp)
movl -0xc(%rsp), %ecx
sarl $0x5, %ecx
movl %ecx, -0x14(%rsp)
movl -0xc(%rsp), %ecx
andl $0x1f, %ecx
movl %ecx, -0x18(%rsp)
movl -0x18(%rsp), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
movl %ecx, -0x1c(%rsp)
movl -0x1c(%rsp), %edx
movslq -0x14(%rsp), %rcx
orl (%rax,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
testb $0x1, -0xd(%rsp)
je 0x16760
movq -0x28(%rsp), %rax
movl -0x1c(%rsp), %edx
movslq -0x14(%rsp), %rcx
orl 0x24(%rax,%rcx,4), %edx
movl %edx, 0x24(%rax,%rcx,4)
jmp 0x16779
movq -0x28(%rsp), %rax
movl -0x1c(%rsp), %edx
xorl $-0x1, %edx
movslq -0x14(%rsp), %rcx
andl 0x24(%rax,%rcx,4), %edx
movl %edx, 0x24(%rax,%rcx,4)
retq
nopw (%rax,%rax)
// File: bonetblai[P]mdp-engine/ctp3/./ctp3.h
// Function: state_t::move_to(int)
void move_to(int node) {
        int n = node >> 5, offset = node & 0x1F;
        int mask = 1 << offset;
        current_ = node;
        visited_[n] |= mask;
    }

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movq -0x8(%rsp), %rax
movl -0xc(%rsp), %ecx
sarl $0x5, %ecx
movl %ecx, -0x10(%rsp)
movl -0xc(%rsp), %ecx
andl $0x1f, %ecx
movl %ecx, -0x14(%rsp)
movl -0x14(%rsp), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
movl %ecx, -0x18(%rsp)
movl -0xc(%rsp), %ecx
movl %ecx, (%rax)
movl -0x18(%rsp), %edx
movslq -0x10(%rsp), %rcx
orl 0x4c(%rax,%rcx,4), %edx
movl %edx, 0x4c(%rax,%rcx,4)
retq
nopl (%rax)
// File: bonetblai[P]mdp-engine/ctp3/./ctp3.h
// Function: next_cache_t::insert(state_t const&, int, std::vector<std::pair<state_t, float>, std::allocator<std::pair<state_t, float>>>&)
void insert(const state_t &state,
                Problem::action_t a,
                std::vector<std::pair<state_t, float> > &next) {
        if( size_ < capacity_ ) {
            ++size_;
            next_cache_item_t *item = items_[a];
            std::vector<std::pair<state_t, float> > *ptr
              = new std::vector<std::pair<state_t, float> >(next);
            item->insert(std::make_pair(state, ptr));
        }
    }

// Assembly:
subq $0xf8, %rsp
movq %rdi, 0xf0(%rsp)
movq %rsi, 0xe8(%rsp)
movl %edx, 0xe4(%rsp)
movq %rcx, 0xd8(%rsp)
movq 0xf0(%rsp), %rcx
movq %rcx, 0x28(%rsp)
movl 0x14(%rcx), %eax
cmpl 0x10(%rcx), %eax
jae 0x16987
movq 0x28(%rsp), %rax
movl 0x14(%rax), %ecx
incl %ecx
movl %ecx, 0x14(%rax)
movq 0x8(%rax), %rax
movslq 0xe4(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0xd0(%rsp)
movl $0x18, %edi
callq 0x6340
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq 0xd8(%rsp), %rsi
callq 0x18a80
jmp 0x168d8
movq 0x20(%rsp), %rax
movq %rax, 0xc8(%rsp)
movq 0xd0(%rsp), %rax
movq %rax, (%rsp)
movq 0xe8(%rsp), %rsi
leaq 0x40(%rsp), %rdi
movq %rdi, 0x8(%rsp)
leaq 0xc8(%rsp), %rdx
callq 0x18bd0
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x18b80
movb %dl, 0x17(%rsp)
movq %rax, 0x18(%rsp)
jmp 0x16929
movb 0x17(%rsp), %al
movq 0x18(%rsp), %rcx
movq %rcx, 0x30(%rsp)
movb %al, 0x38(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x18c10
jmp 0x16987
movq 0x20(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xc0(%rsp)
movl %eax, 0xbc(%rsp)
callq 0x6310
jmp 0x1698f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xc0(%rsp)
movl %eax, 0xbc(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x18c10
jmp 0x1698f
addq $0xf8, %rsp
retq
movq 0xc0(%rsp), %rdi
callq 0x6520
nopl (%rax)
// File: bonetblai[P]mdp-engine/ctp3/./ctp3.h
// Function: state_t::operator=(state_t const&)
const state_t& operator=(const state_t &s) {
        current_ = s.current_;
        info_ = s.info_;
        memcpy(visited_, s.visited_, words_for_nodes_ * sizeof(unsigned));
        if( s.shared_ ) {
            if( !shared_ ) delete[] distances_;
            distances_ = s.distances_;
            shared_ = true;
        } else {
            if( shared_ ) {
                distances_ = new int[num_nodes_];
                shared_ = false;
            }
            assert(distances_ != 0);
            memcpy(const_cast<int*>(distances_), s.distances_, num_nodes_ * sizeof(int));
        }
        heuristic_ = s.heuristic_;
        return *this;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movl (%rax), %eax
movl %eax, (%rdi)
movq 0x18(%rsp), %rsi
addq $0x4, %rsi
addq $0x4, %rdi
callq 0x17d70
movq 0x10(%rsp), %rdi
addq $0x4c, %rdi
movq 0x18(%rsp), %rsi
addq $0x4c, %rsi
movslq 0x6b6b4(%rip), %rdx     # 0x83320
shlq $0x2, %rdx
callq 0x62c0
movq 0x18(%rsp), %rax
testb $0x1, 0x5c(%rax)
je 0x17cc6
movq 0x10(%rsp), %rax
testb $0x1, 0x5c(%rax)
jne 0x17cab
movq 0x10(%rsp), %rax
movq 0x60(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x17ca9
movq 0x8(%rsp), %rdi
callq 0x6420
jmp 0x17cab
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
movq 0x60(%rcx), %rcx
movq %rcx, 0x60(%rax)
movb $0x1, 0x5c(%rax)
jmp 0x17d58
movq 0x10(%rsp), %rax
testb $0x1, 0x5c(%rax)
je 0x17d09
movslq 0x6b640(%rip), %rax     # 0x83318
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x6030
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x60(%rax)
movb $0x0, 0x5c(%rax)
movq 0x10(%rsp), %rax
cmpq $0x0, 0x60(%rax)
je 0x17d17
jmp 0x17d36
leaq 0x45802(%rip), %rdi     # 0x5d520
leaq 0x45745(%rip), %rsi     # 0x5d46a
movl $0x18f, %edx            # imm = 0x18F
leaq 0x45814(%rip), %rcx     # 0x5d545
callq 0x6220
movq 0x10(%rsp), %rax
movq 0x60(%rax), %rdi
movq 0x18(%rsp), %rax
movq 0x60(%rax), %rsi
movslq 0x6b5c9(%rip), %rdx     # 0x83318
shlq $0x2, %rdx
callq 0x62c0
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
movl 0x68(%rcx), %ecx
movl %ecx, 0x68(%rax)
addq $0x28, %rsp
retq
nopl (%rax)
// File: bonetblai[P]mdp-engine/ctp3/./ctp3.h
// Function: sample_weather(CTP::graph_t const&, state_t&)
inline void sample_weather(const CTP::graph_t &graph, state_t &state) {
    state.clear();
    int num_edges = graph.with_shortcut_ ? graph.num_edges_ - 1 : graph.num_edges_;
    for( int e = 0; e < num_edges; ++e ) {
        float p = graph.prob(e);
        if( Random::real() < p ) {
            state.info_.set_edge_status(e, false);
        } else {
            state.info_.set_edge_status(e, true);
        }
    }
    if( graph.with_shortcut_ ) state.info_.set_edge_status(graph.num_edges_ - 1, true);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x19ac0
movq 0x20(%rsp), %rax
testb $0x1, 0x8(%rax)
je 0x19a04
movq 0x20(%rsp), %rax
movl 0x4(%rax), %eax
subl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x19a10
movq 0x20(%rsp), %rax
movl 0x4(%rax), %eax
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %eax
movl %eax, 0x14(%rsp)
movl $0x0, 0x10(%rsp)
movl 0x10(%rsp), %eax
cmpl 0x14(%rsp), %eax
jge 0x19a8d
movq 0x20(%rsp), %rdi
movl 0x10(%rsp), %esi
callq 0x166c0
movss %xmm0, 0xc(%rsp)
callq 0x19b50
movaps %xmm0, %xmm1
movss 0xc(%rsp), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x19a67
movq 0x18(%rsp), %rdi
addq $0x4, %rdi
movl 0x10(%rsp), %esi
xorl %edx, %edx
callq 0x166f0
jmp 0x19a7e
movq 0x18(%rsp), %rdi
addq $0x4, %rdi
movl 0x10(%rsp), %esi
movl $0x1, %edx
callq 0x166f0
jmp 0x19a80
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x19a20
movq 0x20(%rsp), %rax
testb $0x1, 0x8(%rax)
je 0x19ab6
movq 0x18(%rsp), %rdi
addq $0x4, %rdi
movq 0x20(%rsp), %rax
movl 0x4(%rax), %esi
subl $0x1, %esi
movl $0x1, %edx
callq 0x166f0
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: bonetblai[P]mdp-engine/ctp3/./ctp3.h
// Function: state_t::clear()
void clear() {
        current_ = 0;
        info_.clear();
        memset(visited_, 0, words_for_nodes_ * sizeof(unsigned));
        if( !shared_ ) {
            delete[] distances_;
            shared_ = true;
        }
        distances_ = 0;
        heuristic_ = -1;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movl $0x0, (%rdi)
addq $0x4, %rdi
callq 0x19b60
movq 0x8(%rsp), %rdi
addq $0x4c, %rdi
movslq 0x6982e(%rip), %rdx     # 0x83320
shlq $0x2, %rdx
xorl %esi, %esi
callq 0x61b0
movq 0x8(%rsp), %rax
testb $0x1, 0x5c(%rax)
jne 0x19b2d
movq 0x8(%rsp), %rax
movq 0x60(%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x19b24
movq (%rsp), %rdi
callq 0x6420
movq 0x8(%rsp), %rax
movb $0x1, 0x5c(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x60(%rax)
movl $0xffffffff, 0x68(%rax) # imm = 0xFFFFFFFF
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x20(%rsp)
movl 0x20(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x20(%rax)
movq 0x8(%rax), %rdi
movq 0x50(%rsp), %rsi
movq (%rdi), %rax
callq *0x28(%rax)
testb $0x1, %al
jne 0x19c46
jmp 0x19c53
movl $0xffffffff, 0x64(%rsp) # imm = 0xFFFFFFFF
jmp 0x19d8c
leaq 0x38(%rsp), %rdi
callq 0xe840
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x50(%rsp), %rsi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movl %eax, 0x1c(%rsp)
jmp 0x19c7a
movl 0x1c(%rsp), %eax
movslq %eax, %rsi
leaq 0x38(%rsp), %rdi
callq 0x163b0
jmp 0x19c8d
movl $0x0, 0x28(%rsp)
movq 0x20(%rsp), %rax
movl 0x28(%rsp), %ecx
movl %ecx, 0x14(%rsp)
movq 0x8(%rax), %rdi
movq 0x50(%rsp), %rsi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movl %eax, 0x18(%rsp)
jmp 0x19cba
movl 0x14(%rsp), %eax
movl 0x18(%rsp), %ecx
cmpl %ecx, %eax
jge 0x19d30
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x50(%rsp), %rsi
movl 0x28(%rsp), %edx
movq (%rdi), %rax
movq 0x30(%rax), %rax
callq *%rax
movb %al, 0x13(%rsp)
jmp 0x19ce7
movb 0x13(%rsp), %al
testb $0x1, %al
jne 0x19cf1
jmp 0x19d1e
leaq 0x38(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xedb0
jmp 0x19d02
jmp 0x19d1e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0xdfb0
jmp 0x19d95
jmp 0x19d20
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0x19c95
leaq 0x38(%rsp), %rdi
callq 0x1a320
testb $0x1, %al
jne 0x19d40
jmp 0x19d4b
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, 0xc(%rsp)
jmp 0x19d7a
leaq 0x38(%rsp), %rdi
callq 0xdcb0
movl %eax, %edi
callq 0x1a370
movl %eax, 0x8(%rsp)
jmp 0x19d62
movl 0x8(%rsp), %eax
movl %eax, %eax
movl %eax, %esi
leaq 0x38(%rsp), %rdi
callq 0xdcf0
movl (%rax), %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
movl %eax, 0x64(%rsp)
leaq 0x38(%rsp), %rdi
callq 0xdfb0
movl 0x64(%rsp), %eax
addq $0x68, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x6520
nop
// File: 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:
subq $0x88, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movl %ecx, 0x6c(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x50(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x1a4a0
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rcx
movq 0x70(%rsp), %rsi
movl 0x6c(%rsp), %edx
movq (%rdi), %rax
movq 0x60(%rax), %rax
callq *%rax
jmp 0x19e01
leaq 0x50(%rsp), %rdi
callq 0x17030
movl %eax, 0x40(%rsp)
cmpl $0x0, 0x40(%rsp)
jbe 0x19e18
jmp 0x19e54
leaq 0x437d6(%rip), %rdi     # 0x5d5f5
leaq 0x437d9(%rip), %rsi     # 0x5d5ff
movl $0x94, %edx
leaq 0x437e1(%rip), %rcx     # 0x5d613
callq 0x6220
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x1a510
jmp 0x19f5b
callq 0x19b50
movss %xmm0, 0x4(%rsp)
jmp 0x19e61
movss 0x4(%rsp), %xmm0
movss %xmm0, 0x3c(%rsp)
movl $0x0, 0x38(%rsp)
movl 0x38(%rsp), %eax
cmpl 0x40(%rsp), %eax
jae 0x19f15
movss 0x3c(%rsp), %xmm0
movss %xmm0, (%rsp)
movl 0x38(%rsp), %eax
movl %eax, %esi
leaq 0x50(%rsp), %rdi
callq 0x1a4b0
movss (%rsp), %xmm1
movss 0x70(%rax), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x19ee0
movl 0x38(%rsp), %eax
movl %eax, %esi
leaq 0x50(%rsp), %rdi
callq 0x1a4b0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
movb $0x1, 0x37(%rsp)
leaq 0x37(%rsp), %rdx
callq 0x1a4d0
jmp 0x19ed6
movl $0x1, 0x30(%rsp)
jmp 0x19f44
movl 0x38(%rsp), %eax
movl %eax, %esi
leaq 0x50(%rsp), %rdi
callq 0x1a4b0
movss 0x70(%rax), %xmm1
movss 0x3c(%rsp), %xmm0
subss %xmm1, %xmm0
movss %xmm0, 0x3c(%rsp)
movl 0x38(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x38(%rsp)
jmp 0x19e75
xorl %eax, %eax
movl %eax, %esi
leaq 0x50(%rsp), %rdi
callq 0x1a4b0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
movb $0x1, 0x2f(%rsp)
leaq 0x2f(%rsp), %rdx
callq 0x1a4d0
jmp 0x19f3c
movl $0x1, 0x30(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x1a510
movq 0x10(%rsp), %rax
addq $0x88, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0x6520
nopw %cs:(%rax,%rax)
nop
// File: bonetblai[P]mdp-engine/ctp3/../engine/base_policies.h
// Function: Online::Policy::random_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();
    }

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x14(%rax)
xorps %xmm0, %xmm0
movss %xmm0, 0x18(%rax)
xorps %xmm0, %xmm0
movss %xmm0, 0x1c(%rax)
movq 0x8(%rax), %rdi
callq 0x1a2e0
popq %rax
retq
nopl (%rax)
// File: 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:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movl %edx, 0x74(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x18(%rsp)
movl 0x74(%rsp), %edi
callq 0x1a300
movq 0x18(%rsp), %rdi
movl %eax, 0x70(%rsp)
movl 0x70(%rsp), %esi
callq 0x63c0
movq %rax, %rdi
leaq 0x43d43(%rip), %rsi     # 0x5def7
callq 0x6330
movq %rax, %rdi
leaq 0x433ce(%rip), %rsi     # 0x5d591
callq 0x6330
movq 0x20(%rsp), %rsi
movq %rax, 0x28(%rsp)
movq (%rsi), %rax
movq 0x18(%rax), %rax
leaq 0x50(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq *%rax
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x62f0
movq %rax, 0x38(%rsp)
jmp 0x1a1fb
movq 0x38(%rsp), %rdi
leaq 0x4339d(%rip), %rsi     # 0x5d5a4
callq 0x6330
movq %rax, 0x10(%rsp)
jmp 0x1a213
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rax
movl 0x20(%rax), %esi
callq 0x6440
movq %rax, 0x8(%rsp)
jmp 0x1a22c
movq 0x8(%rsp), %rdi
movq 0x68d80(%rip), %rsi     # 0x82fb8
callq 0x6370
jmp 0x1a23f
leaq 0x50(%rsp), %rdi
callq 0x61f0
addq $0x88, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x61f0
movq 0x48(%rsp), %rdi
callq 0x6520
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movss 0x42520(%rip), %xmm0    # 0x5d010
movss %xmm0, 0x24(%rsp)
movl $0xffffffff, 0x20(%rsp) # imm = 0xFFFFFFFF
movl $0x0, 0x1c(%rsp)
movq 0x10(%rsp), %rdi
movl 0x1c(%rsp), %eax
movl %eax, 0xc(%rsp)
callq 0x1ac80
movq %rax, %rdi
movq 0x28(%rsp), %rsi
movq (%rdi), %rax
callq *0x10(%rax)
movl %eax, %ecx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jge 0x1ac07
movq 0x10(%rsp), %rdi
callq 0x1ac80
movq %rax, %rdi
movq 0x28(%rsp), %rsi
movl 0x1c(%rsp), %edx
movq (%rdi), %rax
callq *0x30(%rax)
testb $0x1, %al
jne 0x1ab59
jmp 0x1abf5
movq 0x10(%rsp), %rdi
callq 0x1ac80
movq %rax, %rdi
movq 0x28(%rsp), %rsi
movl 0x1c(%rsp), %edx
movq (%rdi), %rax
callq *0x48(%rax)
movq 0x10(%rsp), %rax
movss %xmm0, 0x18(%rsp)
movq 0x28(%rax), %rdi
movl 0x1c(%rsp), %esi
movq 0x28(%rax), %rax
movl (%rax), %edx
subl $0x1, %edx
movq 0x28(%rsp), %rcx
addq $0x4, %rcx
movq 0x28(%rsp), %r8
addq $0x4, %r8
addq $0x24, %r8
movl $0x1, %r9d
callq 0x125e0
movl %eax, %ecx
movq 0x10(%rsp), %rax
cvtsi2ss %ecx, %xmm0
mulss 0x30(%rax), %xmm0
addss 0x18(%rsp), %xmm0
movss %xmm0, 0x18(%rsp)
movss 0x18(%rsp), %xmm1
movss 0x24(%rsp), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x1abf3
movss 0x18(%rsp), %xmm0
movss %xmm0, 0x24(%rsp)
movl 0x1c(%rsp), %eax
movl %eax, 0x20(%rsp)
jmp 0x1abf5
jmp 0x1abf7
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x1ab06
movl 0x20(%rsp), %eax
addq $0x38, %rsp
retq
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq 0x60(%rsp), %rdi
leaq 0x3f6a3(%rip), %rsi     # 0x5e042
xorl %eax, %eax
movl %eax, %edx
callq 0x6190
movq %rax, 0x48(%rsp)
movq 0x60(%rsp), %rdi
leaq 0x3ea34(%rip), %rsi     # 0x5d3ed
movq $-0x1, %rdx
callq 0x6320
movq %rax, 0x40(%rsp)
cmpq $-0x1, 0x48(%rsp)
je 0x1ea46
cmpq $-0x1, 0x40(%rsp)
je 0x1ea46
movq 0x60(%rsp), %rsi
movq 0x48(%rsp), %rcx
leaq 0x20(%rsp), %rdi
xorl %eax, %eax
movl %eax, %edx
callq 0x6350
movq 0x58(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x63f0
leaq 0x20(%rsp), %rdi
callq 0x61f0
movq 0x60(%rsp), %rsi
movq 0x48(%rsp), %rdx
addq $0x1, %rdx
movq 0x40(%rsp), %rcx
subq 0x48(%rsp), %rcx
subq $0x1, %rcx
movq %rsp, %rdi
callq 0x6350
movq 0x50(%rsp), %rdi
movq %rsp, %rsi
callq 0x63f0
movq %rsp, %rdi
callq 0x61f0
jmp 0x1ea55
movq 0x60(%rsp), %rsi
movq 0x58(%rsp), %rdi
callq 0x6060
addq $0x68, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq 0x48(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movq 0x40(%rsp), %rsi
callq 0x21790
movq 0x18(%rsp), %rdi
movq %rax, 0x38(%rsp)
callq 0x217e0
movq %rax, 0x30(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x217c0
testb $0x1, %al
jne 0x20ceb
jmp 0x20d66
movq 0x40(%rsp), %rax
movq %rax, (%rsp)
movl $0x28, %edi
callq 0x6340
movq 0x18(%rsp), %rdi
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rsi
callq 0x218d0
movss %xmm0, 0x14(%rsp)
jmp 0x20d1a
movss 0x14(%rsp), %xmm0
movq 0x8(%rsp), %rdi
xorl %edx, %edx
movl %edx, %ecx
movl %edx, %esi
callq 0x21920
jmp 0x20d32
movq 0x8(%rsp), %rdx
movq (%rsp), %rsi
movq 0x18(%rsp), %rdi
callq 0x21810
movq %rax, 0x50(%rsp)
jmp 0x20d79
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
callq 0x6310
jmp 0x20d83
leaq 0x38(%rsp), %rdi
callq 0x219b0
movq 0x70(%rax), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
addq $0x58, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x6520
nopl (%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0xffffffff, 0x1c(%rsp) # imm = 0xFFFFFFFF
callq 0x23160
movss %xmm0, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movq 0x8(%rsp), %rax
movl 0x14(%rsp), %ecx
movl %ecx, 0x4(%rsp)
movq 0x48(%rax), %rdi
movq 0x20(%rsp), %rsi
movq (%rdi), %rax
callq *0x10(%rax)
movl %eax, %ecx
movl 0x4(%rsp), %eax
cmpl %ecx, %eax
jge 0x22f7a
movq 0x8(%rsp), %rax
movq 0x48(%rax), %rdi
movq 0x20(%rsp), %rsi
movl 0x14(%rsp), %edx
movq (%rdi), %rax
callq *0x30(%rax)
testb $0x1, %al
jne 0x22f27
jmp 0x22f68
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl 0x14(%rsp), %edx
movq (%rdi), %rax
callq *0x10(%rax)
movss %xmm0, 0x10(%rsp)
movss 0x10(%rsp), %xmm1
movss 0x18(%rsp), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x22f66
movss 0x10(%rsp), %xmm0
movss %xmm0, 0x18(%rsp)
movl 0x14(%rsp), %eax
movl %eax, 0x1c(%rsp)
jmp 0x22f68
jmp 0x22f6a
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x22ee3
leaq 0x1c(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x23170
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: bonetblai[P]mdp-engine/ctp3/../engine/hash.h
// Function: Hash::hash_map_t<state_t, Hash::hash_function_t<state_t>>::scc_low(state_t const&) const
size_t scc_low(const T &s) const {
        const_iterator di = lookup(s);
        if( di == end() )
            return std::numeric_limits<unsigned>::max();
        else
            return (*di).second->scc_low();
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x20(%rsp), %rsi
callq 0x235c0
movq 0x8(%rsp), %rdi
movq %rax, 0x18(%rsp)
callq 0x23600
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x217c0
testb $0x1, %al
jne 0x2312b
jmp 0x23139
callq 0x215d0
movl %eax, %eax
movq %rax, 0x30(%rsp)
jmp 0x23151
leaq 0x18(%rsp), %rdi
callq 0x23630
movq 0x70(%rax), %rdi
callq 0x215c0
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
callq 0x264d0
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0x26520
movq %rax, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x26500
testb $0x1, %al
jne 0x2546b
jmp 0x254c6
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, (%rsp)
leaq 0x20(%rsp), %rdi
callq 0x26550
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x22eb0
movq %rax, 0x10(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x26550
movq 0x70(%rax), %rdi
movss 0x14(%rsp), %xmm0
callq 0x22fd0
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x22ff0
leaq 0x20(%rsp), %rdi
callq 0x26570
jmp 0x25447
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x20(%rsp)
movq 0x48(%rsp), %rsi
callq 0x21790
movq 0x20(%rsp), %rdi
movq %rax, 0x40(%rsp)
callq 0x217e0
movq %rax, 0x38(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x217c0
testb $0x1, %al
jne 0x26e1b
jmp 0x26e96
movq 0x48(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x28, %edi
callq 0x6340
movq 0x20(%rsp), %rdi
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %rsi
callq 0x218d0
movss %xmm0, 0x1c(%rsp)
jmp 0x26e4b
movss 0x1c(%rsp), %xmm0
movq 0x10(%rsp), %rdi
xorl %edx, %edx
movl %edx, %ecx
movl $0x1, %esi
callq 0x21920
jmp 0x26e66
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rsi
movq 0x20(%rsp), %rdi
callq 0x21810
jmp 0x26ea9
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
callq 0x6310
jmp 0x26eae
leaq 0x40(%rsp), %rdi
callq 0x219b0
movq 0x70(%rax), %rdi
callq 0x22e90
addq $0x58, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x6520
nopl (%rax,%rax)
// File: 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:
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq %rdx, 0x90(%rsp)
movq 0xa0(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movq 0x90(%rsp), %rsi
movq (%rdi), %rax
movq 0x30(%rax), %rax
callq *%rax
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rsi
leaq 0x80(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x20c30
movq 0x18(%rsp), %rsi
movq 0x90(%rsp), %rdi
callq 0x20c70
leaq 0x68(%rsp), %rdi
callq 0x20c90
leaq 0x50(%rsp), %rdi
callq 0x20c90
movq $0x0, 0x48(%rsp)
movq 0x90(%rsp), %rdi
movq 0x98(%rsp), %rsi
callq 0x20ca0
movq %rax, 0x20(%rsp)
jmp 0x27843
movq 0x20(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rdi
callq 0x20d90
xorb $-0x1, %al
testb $0x1, %al
jne 0x27862
jmp 0x27948
movq 0x10(%rsp), %rdi
movq $0x0, 0x28(%rsp)
movq 0x98(%rsp), %rsi
movq 0x90(%rsp), %rdx
movq 0x40(%rsp), %rcx
movq %rsp, %rax
leaq 0x50(%rsp), %r8
movq %r8, (%rax)
leaq 0x28(%rsp), %r8
leaq 0x68(%rsp), %r9
callq 0x27f10
jmp 0x278a1
leaq 0x68(%rsp), %rdi
callq 0x21560
testb $0x1, %al
jne 0x278b1
jmp 0x278b3
jmp 0x27903
leaq 0x36112(%rip), %rdi     # 0x5d9cc
leaq 0x3634e(%rip), %rsi     # 0x5dc0f
movl $0xcf, %edx
leaq 0x36353(%rip), %rcx     # 0x5dc20
callq 0x6220
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x21620
leaq 0x68(%rsp), %rdi
callq 0x21620
leaq 0x80(%rsp), %rdi
callq 0x21630
jmp 0x27982
jmp 0x27905
leaq 0x50(%rsp), %rdi
callq 0x21560
xorb $-0x1, %al
testb $0x1, %al
jne 0x27917
jmp 0x27935
leaq 0x50(%rsp), %rdi
callq 0x21580
movq (%rax), %rdi
callq 0x215b0
leaq 0x50(%rsp), %rdi
callq 0x215f0
jmp 0x27905
movq 0x48(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x48(%rsp)
jmp 0x2784d
movq 0x90(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x20c70
leaq 0x50(%rsp), %rdi
callq 0x21620
leaq 0x68(%rsp), %rdi
callq 0x21620
leaq 0x80(%rsp), %rdi
callq 0x21630
addq $0xa8, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x6520
nopl (%rax)
// File: 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:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x10(%rax), %rsi
leaq 0x50(%rsp), %rdi
callq 0x20c30
movq 0x60(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x20c70
movq $0x0, 0x48(%rsp)
movq $0x0, 0x40(%rsp)
movq 0x60(%rsp), %rdi
movq 0x68(%rsp), %rsi
callq 0x26410
movb %al, 0x1f(%rsp)
jmp 0x2a0c1
movb 0x1f(%rsp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x2a0cd
jmp 0x2a13c
movq 0x20(%rsp), %rdi
movq 0x68(%rsp), %rsi
movq 0x60(%rsp), %rdx
callq 0x2a170
movq %rax, 0x10(%rsp)
jmp 0x2a0e8
movq 0x10(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x40(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x2a760
movq %rax, 0x8(%rsp)
jmp 0x2a108
movq 0x8(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x48(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x48(%rsp)
jmp 0x2a0ac
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x21630
jmp 0x2a166
movq 0x60(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x20c70
movq 0x48(%rsp), %rax
movq %rax, (%rsp)
leaq 0x50(%rsp), %rdi
callq 0x21630
movq (%rsp), %rax
addq $0x78, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x6520
// File: 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:
subq $0x78, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movl %ecx, 0x5c(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x40(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x1a4a0
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rcx
movq 0x60(%rsp), %rsi
movl 0x5c(%rsp), %edx
movq (%rdi), %rax
movq 0x60(%rax), %rax
callq *%rax
jmp 0x2a8ab
leaq 0x40(%rsp), %rdi
callq 0x17030
movl %eax, 0x30(%rsp)
movl 0x30(%rsp), %edi
callq 0x1a370
movl %eax, 0x4(%rsp)
jmp 0x2a8c8
movl 0x4(%rsp), %eax
movl %eax, %eax
movl %eax, %esi
leaq 0x40(%rsp), %rdi
callq 0x1a4b0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
movb $0x1, 0x2f(%rsp)
leaq 0x2f(%rsp), %rdx
callq 0x1a4d0
jmp 0x2a8f3
leaq 0x40(%rsp), %rdi
callq 0x1a510
movq 0x10(%rsp), %rax
addq $0x78, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x1a510
movq 0x38(%rsp), %rdi
callq 0x6520
nopl (%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movq 0x40(%rsp), %rsi
movq (%rdi), %rax
callq *0x30(%rax)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rsi
leaq 0x30(%rsp), %rdi
callq 0x20c30
movq 0x40(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x20c70
movq $0x0, 0x28(%rsp)
movq 0x40(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x26410
movb %al, 0xf(%rsp)
jmp 0x2d488
movb 0xf(%rsp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x2d494
jmp 0x2d4dd
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x48(%rsp), %rsi
movq 0x40(%rsp), %rdx
movss 0x1c(%rax), %xmm0
callq 0x2af90
jmp 0x2d4b3
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0x2d473
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x21630
jmp 0x2d4fa
movq 0x40(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x20c70
leaq 0x30(%rsp), %rdi
callq 0x21630
addq $0x58, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x6520
nopw %cs:(%rax,%rax)
nop
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x84f0
movq 0x8(%rsp), %rax
movss %xmm0, 0x14(%rsp)
movl 0x18(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x18(%rax)
cmpq $0x0, 0x20(%rax)
jne 0x32bc3
xorps %xmm0, %xmm0
movss %xmm0, 0x4(%rsp)
jmp 0x32bdc
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rdi
movq 0x18(%rsp), %rsi
callq 0x288f0
movss %xmm0, 0x4(%rsp)
movss 0x4(%rsp), %xmm0
movss %xmm0, 0x10(%rsp)
callq 0x84f0
movq 0x8(%rsp), %rax
subss 0x14(%rsp), %xmm0
addss 0x10(%rax), %xmm0
movss %xmm0, 0x10(%rax)
movss 0x10(%rsp), %xmm0
addq $0x28, %rsp
retq
nopl (%rax)
// File: bonetblai[P]mdp-engine/ctp3/../engine/heuristic.h
// Function: Heuristic::min_min_heuristic_t<state_t>::set_parameters(std::multimap<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>> const&, Dispatcher::dispatcher_t<state_t>&)
virtual void set_parameters(const std::multimap<std::string, std::string> &parameters, Dispatcher::dispatcher_t<T> &dispatcher) {
        std::multimap<std::string, std::string>::const_iterator it = parameters.find("algorithm");
        if( it != parameters.end() ) {
            delete algorithm_;
            dispatcher.create_request(problem_, it->first, it->second);
            algorithm_ = dispatcher.fetch_algorithm(it->second);
        }
#ifdef DEBUG
        std::cout << "debug: min-min(): params:"
                  << " algorithm=" << (algorithm_ == 0 ? std::string("null") : algorithm_->name())
                  << std::endl;
#endif
        solve_problem();
    }

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq %rdx, 0x90(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x98(%rsp), %rax
movq %rax, 0x38(%rsp)
leaq 0x67(%rsp), %rdi
movq %rdi, 0x40(%rsp)
callq 0x6530
movq 0x40(%rsp), %rdx
leaq 0x2a549(%rip), %rsi     # 0x5d1fd
leaq 0x68(%rsp), %rdi
callq 0x6460
jmp 0x32cc0
movq 0x38(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x209d0
movq %rax, 0x28(%rsp)
jmp 0x32cd6
movq 0x28(%rsp), %rax
movq %rax, 0x88(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x61f0
leaq 0x67(%rsp), %rdi
callq 0x6390
movq 0x98(%rsp), %rdi
callq 0x20a00
movq %rax, 0x48(%rsp)
leaq 0x88(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x9c90
testb $0x1, %al
jne 0x32d24
jmp 0x32e03
movq 0x30(%rsp), %rax
movq 0x28(%rax), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, %rax
je 0x32d43
movq 0x20(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x30(%rsp), %rax
movq 0x90(%rsp), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
leaq 0x88(%rsp), %rdi
callq 0xb0d0
movq %rax, 0x10(%rsp)
leaq 0x88(%rsp), %rdi
callq 0xb0d0
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rax, %rcx
addq $0x20, %rcx
callq 0x9ce0
movq 0x90(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x88(%rsp), %rdi
callq 0xb0d0
movq 0x18(%rsp), %rdi
movq %rax, %rsi
addq $0x20, %rsi
callq 0xb0f0
movq %rax, %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x28(%rax)
jmp 0x32e03
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
jmp 0x32df7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x61f0
leaq 0x67(%rsp), %rdi
callq 0x6390
jmp 0x32e15
movq 0x30(%rsp), %rdi
callq 0x34400
addq $0xa8, %rsp
retq
movq 0x58(%rsp), %rdi
callq 0x6520
nop
// File: 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:
subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movl %edx, 0x5c(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x48(%rax), %rdi
movq 0x60(%rsp), %rsi
movq (%rdi), %rax
callq *0x20(%rax)
testb $0x1, %al
jne 0x32e91
jmp 0x32e9f
xorps %xmm0, %xmm0
movss %xmm0, 0x74(%rsp)
jmp 0x32ffb
leaq 0x40(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x1a4a0
movq 0x20(%rsp), %rax
movq 0x18(%rsp), %rcx
movq 0x48(%rax), %rdi
movq 0x60(%rsp), %rsi
movl 0x5c(%rsp), %edx
movq (%rdi), %rax
movq 0x60(%rax), %rax
callq *%rax
jmp 0x32ed0
leaq 0x40(%rsp), %rdi
callq 0x17030
movl %eax, 0x30(%rsp)
callq 0x23160
movss %xmm0, 0x2c(%rsp)
movl $0x0, 0x28(%rsp)
movl 0x28(%rsp), %eax
cmpl 0x30(%rsp), %eax
jae 0x32f6d
movss 0x2c(%rsp), %xmm0
movss %xmm0, 0x10(%rsp)
movl 0x28(%rsp), %eax
movl %eax, %esi
leaq 0x40(%rsp), %rdi
callq 0x1a4b0
movq 0x20(%rsp), %rdi
movq %rax, %rsi
callq 0x288f0
movss %xmm0, 0x14(%rsp)
jmp 0x32f2c
movss 0x14(%rsp), %xmm1
movss 0x10(%rsp), %xmm0
callq 0x28990
movss %xmm0, 0x2c(%rsp)
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0x32ef1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x1a510
jmp 0x33006
movss 0x2c(%rsp), %xmm0
movss %xmm0, 0xc(%rsp)
callq 0x23160
movaps %xmm0, %xmm1
movss 0xc(%rsp), %xmm0
ucomiss %xmm1, %xmm0
jne 0x32f9b
jp 0x32f9b
callq 0x23160
movss %xmm0, 0x8(%rsp)
jmp 0x32fe5
movq 0x20(%rsp), %rax
movq 0x48(%rax), %rdi
movq 0x60(%rsp), %rsi
movl 0x5c(%rsp), %edx
movq (%rdi), %rax
movq 0x48(%rax), %rax
callq *%rax
movss %xmm0, 0x4(%rsp)
jmp 0x32fbe
movq 0x20(%rsp), %rax
movq 0x48(%rax), %rdi
callq 0x28980
movaps %xmm0, %xmm1
movss 0x4(%rsp), %xmm0
mulss 0x2c(%rsp), %xmm1
addss %xmm1, %xmm0
movss %xmm0, 0x8(%rsp)
movss 0x8(%rsp), %xmm0
movss %xmm0, 0x74(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x1a510
movss 0x74(%rsp), %xmm0
addq $0x78, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x6520
// File: 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:
subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movl %edx, 0x5c(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x48(%rax), %rdi
movq 0x60(%rsp), %rsi
movq (%rdi), %rax
callq *0x20(%rax)
testb $0x1, %al
jne 0x330c1
jmp 0x330cf
xorps %xmm0, %xmm0
movss %xmm0, 0x74(%rsp)
jmp 0x33209
leaq 0x40(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x1a4a0
movq 0x20(%rsp), %rax
movq 0x18(%rsp), %rcx
movq 0x48(%rax), %rdi
movq 0x60(%rsp), %rsi
movl 0x5c(%rsp), %edx
movq (%rdi), %rax
movq 0x60(%rax), %rax
callq *%rax
jmp 0x33100
leaq 0x40(%rsp), %rdi
callq 0x17030
movl %eax, 0x30(%rsp)
xorps %xmm0, %xmm0
movss %xmm0, 0x2c(%rsp)
movl $0x0, 0x28(%rsp)
movl 0x28(%rsp), %eax
cmpl 0x30(%rsp), %eax
jae 0x331b5
movl 0x28(%rsp), %eax
movl %eax, %esi
leaq 0x40(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x1a4b0
movq 0x8(%rsp), %rdi
movss 0x70(%rax), %xmm0
movss %xmm0, 0x10(%rsp)
movl 0x28(%rsp), %eax
movl %eax, %esi
callq 0x1a4b0
movq 0x20(%rsp), %rdi
movq %rax, %rsi
callq 0x288f0
movss %xmm0, 0x14(%rsp)
jmp 0x33172
movss 0x14(%rsp), %xmm1
movss 0x10(%rsp), %xmm0
mulss %xmm1, %xmm0
addss 0x2c(%rsp), %xmm0
movss %xmm0, 0x2c(%rsp)
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0x3311f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x1a510
jmp 0x33214
movq 0x20(%rsp), %rax
movq 0x48(%rax), %rdi
movq 0x60(%rsp), %rsi
movl 0x5c(%rsp), %edx
movq (%rdi), %rax
movq 0x48(%rax), %rax
callq *%rax
movss %xmm0, 0x4(%rsp)
jmp 0x331d8
movq 0x20(%rsp), %rax
movq 0x48(%rax), %rdi
callq 0x28980
movaps %xmm0, %xmm1
movss 0x4(%rsp), %xmm0
mulss 0x2c(%rsp), %xmm1
addss %xmm1, %xmm0
movss %xmm0, 0x74(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x1a510
movss 0x74(%rsp), %xmm0
addq $0x78, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x6520
nop
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rdi
leaq 0x2a02f(%rip), %rsi     # 0x5e042
callq 0x6330
movq %rax, %rdi
movq (%rsp), %rax
movss (%rax), %xmm0
callq 0x6270
movq %rax, %rdi
leaq 0x29ec3(%rip), %rsi     # 0x5def5
callq 0x6330
movq %rax, %rdi
movq (%rsp), %rax
movb 0x4(%rax), %cl
xorl %esi, %esi
movl $0x1, %eax
testb $0x1, %cl
cmovnel %eax, %esi
callq 0x6510
movq %rax, %rdi
leaq 0x29e98(%rip), %rsi     # 0x5def5
callq 0x6330
movq %rax, %rdi
movq (%rsp), %rax
movb 0x5(%rax), %cl
xorl %esi, %esi
movl $0x1, %eax
testb $0x1, %cl
cmovnel %eax, %esi
callq 0x6510
movq %rax, %rdi
leaq 0x29e6d(%rip), %rsi     # 0x5def5
callq 0x6330
movq %rax, %rdi
movq (%rsp), %rax
movq 0x8(%rax), %rsi
callq 0x60c0
movq %rax, %rdi
leaq 0x29e4e(%rip), %rsi     # 0x5def5
callq 0x6330
movq %rax, %rdi
movq (%rsp), %rax
movl 0x10(%rax), %esi
callq 0x6510
movq %rax, %rdi
leaq 0x29328(%rip), %rsi     # 0x5d3ed
callq 0x6330
addq $0x18, %rsp
retq
nop