LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: bonetblai[P]mdp-engine/ctp3/../engine/aot.h
// Function: Online::Policy::AOT::aot_t<state_t>::insert_into_inside_priority_queue(Online::Policy::AOT::node_t<state_t>*) const
void insert_into_inside_priority_queue(node_t<T> *node) const {
#ifdef USE_BDD_PQ
        std::pair<bool, bool> p = inside_bdd_priority_queue_.push(node);
        node->in_pq_ = p.first;
        if( p.second ) {
            node_t<T> *removed = inside_bdd_priority_queue_.removed_element();
            assert(removed != 0);
            assert(removed->in_pq_);
            removed->in_pq_ = false;
        }
#else
        inside_priority_queue_.push(node);
        node->in_pq_ = true;
#endif
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
addq $0xa0, %rdi
leaq 0x18(%rsp), %rsi
callq 0x47570
movw %ax, 0x16(%rsp)
movb 0x16(%rsp), %cl
movq 0x18(%rsp), %rax
andb $0x1, %cl
movb %cl, 0x16(%rax)
testb $0x1, 0x17(%rsp)
je 0x474a6
movq (%rsp), %rdi
addq $0xa0, %rdi
callq 0x477d0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x47452
jmp 0x47471
leaq 0x17644(%rip), %rdi     # 0x5ea9d
leaq 0x17515(%rip), %rsi     # 0x5e975
movl $0x3d0, %edx            # imm = 0x3D0
leaq 0x1763e(%rip), %rcx     # 0x5eaaa
callq 0x6220
movq 0x8(%rsp), %rax
testb $0x1, 0x16(%rax)
je 0x4747e
jmp 0x4749d
leaq 0x17692(%rip), %rdi     # 0x5eb17
leaq 0x174e9(%rip), %rsi     # 0x5e975
movl $0x3d1, %edx            # imm = 0x3D1
leaq 0x17612(%rip), %rcx     # 0x5eaaa
callq 0x6220
movq 0x8(%rsp), %rax
movb $0x0, 0x16(%rax)
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: bonetblai[P]mdp-engine/ctp3/../engine/aot.h
// Function: Online::Policy::AOT::aot_t<state_t>::insert_into_outside_priority_queue(Online::Policy::AOT::node_t<state_t>*) const
void insert_into_outside_priority_queue(node_t<T> *node) const {
#ifdef USE_BDD_PQ
        std::pair<bool, bool> p = outside_bdd_priority_queue_.push(node);
        node->in_pq_ = p.first;
        if( p.second ) {
            node_t<T> *removed = outside_bdd_priority_queue_.removed_element();
            assert(removed != 0);
            assert(removed->in_pq_);
            removed->in_pq_ = false;
        }
#else
        outside_priority_queue_.push(node);
        node->in_pq_ = true;
#endif
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
addq $0xf8, %rdi
leaq 0x18(%rsp), %rsi
callq 0x47570
movw %ax, 0x16(%rsp)
movb 0x16(%rsp), %cl
movq 0x18(%rsp), %rax
andb $0x1, %cl
movb %cl, 0x16(%rax)
testb $0x1, 0x17(%rsp)
je 0x47566
movq (%rsp), %rdi
addq $0xf8, %rdi
callq 0x477d0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x47512
jmp 0x47531
leaq 0x17584(%rip), %rdi     # 0x5ea9d
leaq 0x17455(%rip), %rsi     # 0x5e975
movl $0x3df, %edx            # imm = 0x3DF
leaq 0x17b1f(%rip), %rcx     # 0x5f04b
callq 0x6220
movq 0x8(%rsp), %rax
testb $0x1, 0x16(%rax)
je 0x4753e
jmp 0x4755d
leaq 0x175d2(%rip), %rdi     # 0x5eb17
leaq 0x17429(%rip), %rsi     # 0x5e975
movl $0x3e0, %edx            # imm = 0x3E0
leaq 0x17af3(%rip), %rcx     # 0x5f04b
callq 0x6220
movq 0x8(%rsp), %rax
movb $0x0, 0x16(%rax)
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: bonetblai[P]mdp-engine/ctp3/../engine/bdd_priority_queue.h
// Function: std::bdd_priority_queue<Online::Policy::AOT::node_t<state_t>*, Online::Policy::AOT::min_priority_t<state_t>, Online::Policy::AOT::max_priority_t<state_t>>::allocate_container(Online::Policy::AOT::node_t<state_t>* const&) const
container_t* allocate_container(const T &element) const {
        if( pool_ == 0 ) {
            return new container_t(element);
        } else {
            container_t *p = pool_;
            pool_ = pool_->next_;
            p->element_ = element;
            p->next_ = 0;
            p->xref_ = 0;
            return p;
        }
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x8(%rax)
jne 0x47846
movl $0x18, %edi
callq 0x6340
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rsi
callq 0x48100
jmp 0x47820
movq 0x8(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x47893
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
callq 0x6310
jmp 0x4789d
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rcx
movq %rcx, 0x18(%rsp)
movq 0x8(%rax), %rcx
movq 0x10(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq 0x30(%rsp), %rax
movq (%rax), %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
movq 0x18(%rsp), %rax
movq $0x0, 0x10(%rax)
movq 0x18(%rsp), %rax
movl $0x0, 0x8(%rax)
movq 0x18(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x6520
nopw (%rax,%rax)
// File: bonetblai[P]mdp-engine/ctp3/../engine/bdd_priority_queue.h
// Function: std::bdd_priority_queue<Online::Policy::AOT::node_t<state_t>*, Online::Policy::AOT::min_priority_t<state_t>, Online::Policy::AOT::max_priority_t<state_t>>::push_max(unsigned int, std::bdd_priority_queue<Online::Policy::AOT::node_t<state_t>*, Online::Policy::AOT::min_priority_t<state_t>, Online::Policy::AOT::max_priority_t<state_t>>::container_t*)
void push_max(unsigned index, container_t *container) {
        unsigned parent = index >> 1;
        while( (index > 1) && max_cmpfn_(max_array_[parent]->element_, container->element_) ) {
            max_array_[index] = max_array_[parent];
            min_array_[max_array_[index]->xref_] = index;
            index = parent;
            parent = parent >> 1;
        }
        max_array_[index] = container;

        if( container->xref_ != 0 ) {
            // container is not new; it is changing location in max_array
            min_array_[container->xref_] = index;
        } else {
            push_min(1 + min_size_, index);
            ++min_size_;
        }
    }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movl %esi, 0x4c(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x30(%rsp)
movl 0x4c(%rsp), %eax
shrl %eax
movl %eax, 0x3c(%rsp)
xorl %eax, %eax
cmpl $0x1, 0x4c(%rsp)
movb %al, 0x2f(%rsp)
jbe 0x47913
movq 0x30(%rsp), %rdi
addq $0x20, %rdi
movl 0x3c(%rsp), %eax
movl %eax, %esi
callq 0x46590
movq 0x30(%rsp), %rdi
movq (%rax), %rax
movq (%rax), %rsi
movq 0x40(%rsp), %rax
movq (%rax), %rdx
callq 0x47a60
movb %al, 0x2f(%rsp)
movb 0x2f(%rsp), %al
testb $0x1, %al
jne 0x47920
jmp 0x479af
movq 0x30(%rsp), %rdi
addq $0x20, %rdi
movl 0x3c(%rsp), %eax
movl %eax, %esi
callq 0x46590
movq 0x30(%rsp), %rdi
movq (%rax), %rax
movq %rax, 0x18(%rsp)
addq $0x20, %rdi
movl 0x4c(%rsp), %eax
movl %eax, %esi
callq 0x46590
movq 0x18(%rsp), %rcx
movq 0x30(%rsp), %rdi
movq %rcx, (%rax)
movl 0x4c(%rsp), %eax
movl %eax, 0x28(%rsp)
movq %rdi, %rax
addq $0x40, %rax
movq %rax, 0x20(%rsp)
addq $0x20, %rdi
movl 0x4c(%rsp), %eax
movl %eax, %esi
callq 0x46590
movq 0x20(%rsp), %rdi
movq (%rax), %rax
movl 0x8(%rax), %eax
movl %eax, %esi
callq 0x465b0
movl 0x28(%rsp), %ecx
movl %ecx, (%rax)
movl 0x3c(%rsp), %eax
movl %eax, 0x4c(%rsp)
movl 0x3c(%rsp), %eax
shrl %eax
movl %eax, 0x3c(%rsp)
jmp 0x478d6
movq 0x30(%rsp), %rdi
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
addq $0x20, %rdi
movl 0x4c(%rsp), %eax
movl %eax, %esi
callq 0x46590
movq 0x10(%rsp), %rcx
movq %rcx, (%rax)
movq 0x40(%rsp), %rax
cmpl $0x0, 0x8(%rax)
je 0x47a08
movq 0x30(%rsp), %rdi
movl 0x4c(%rsp), %eax
movl %eax, 0xc(%rsp)
addq $0x40, %rdi
movq 0x40(%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, %esi
callq 0x465b0
movl 0xc(%rsp), %ecx
movl %ecx, (%rax)
jmp 0x47a2a
movq 0x30(%rsp), %rdi
movl 0x38(%rdi), %esi
addl $0x1, %esi
movl 0x4c(%rsp), %edx
callq 0x48130
movq 0x30(%rsp), %rax
movl 0x38(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x38(%rax)
addq $0x58, %rsp
retq
nop
// File: bonetblai[P]mdp-engine/ctp3/../engine/bdd_priority_queue.h
// Function: std::bdd_priority_queue<Online::Policy::AOT::node_t<state_t>*, Online::Policy::AOT::min_priority_t<state_t>, Online::Policy::AOT::max_priority_t<state_t>>::push_min(unsigned int, unsigned int)
void push_min(unsigned index, unsigned element) {
        unsigned parent = index >> 1;
        while( (index > 1) && min_cmpfn_(max_array_[min_array_[parent]]->element_, max_array_[element]->element_) ) {
            min_array_[index] = min_array_[parent];
            max_array_[min_array_[index]]->xref_ = index;
            index = parent;
            parent = parent >> 1;
        }
        min_array_[index] = element;
        max_array_[element]->xref_ = index;
    }

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movl %esi, 0x5c(%rsp)
movl %edx, 0x58(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x48(%rsp)
movl 0x5c(%rsp), %eax
shrl %eax
movl %eax, 0x54(%rsp)
xorl %eax, %eax
cmpl $0x1, 0x5c(%rsp)
movb %al, 0x47(%rsp)
jbe 0x481d4
movq 0x48(%rsp), %rdi
movq %rdi, %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
movq %rdi, %rax
addq $0x20, %rax
movq %rax, 0x28(%rsp)
addq $0x40, %rdi
movl 0x54(%rsp), %eax
movl %eax, %esi
callq 0x465b0
movq 0x28(%rsp), %rdi
movl (%rax), %eax
movl %eax, %esi
callq 0x46590
movq 0x48(%rsp), %rdi
movq (%rax), %rax
movq (%rax), %rax
movq %rax, 0x38(%rsp)
addq $0x20, %rdi
movl 0x58(%rsp), %eax
movl %eax, %esi
callq 0x46590
movq 0x30(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq (%rax), %rax
movq (%rax), %rdx
callq 0x46a40
movb %al, 0x47(%rsp)
movb 0x47(%rsp), %al
testb $0x1, %al
jne 0x481e1
jmp 0x4826c
movq 0x48(%rsp), %rdi
addq $0x40, %rdi
movl 0x54(%rsp), %eax
movl %eax, %esi
callq 0x465b0
movq 0x48(%rsp), %rdi
movl (%rax), %eax
movl %eax, 0x14(%rsp)
addq $0x40, %rdi
movl 0x5c(%rsp), %eax
movl %eax, %esi
callq 0x465b0
movl 0x14(%rsp), %ecx
movq 0x48(%rsp), %rdi
movl %ecx, (%rax)
movl 0x5c(%rsp), %eax
movl %eax, 0x24(%rsp)
movq %rdi, %rax
addq $0x20, %rax
movq %rax, 0x18(%rsp)
addq $0x40, %rdi
movl 0x5c(%rsp), %eax
movl %eax, %esi
callq 0x465b0
movq 0x18(%rsp), %rdi
movl (%rax), %eax
movl %eax, %esi
callq 0x46590
movl 0x24(%rsp), %ecx
movq (%rax), %rax
movl %ecx, 0x8(%rax)
movl 0x54(%rsp), %eax
movl %eax, 0x5c(%rsp)
movl 0x54(%rsp), %eax
shrl %eax
movl %eax, 0x54(%rsp)
jmp 0x48155
movq 0x48(%rsp), %rdi
movl 0x58(%rsp), %eax
movl %eax, 0xc(%rsp)
addq $0x40, %rdi
movl 0x5c(%rsp), %eax
movl %eax, %esi
callq 0x465b0
movl 0xc(%rsp), %ecx
movq 0x48(%rsp), %rdi
movl %ecx, (%rax)
movl 0x5c(%rsp), %eax
movl %eax, 0x10(%rsp)
addq $0x20, %rdi
movl 0x58(%rsp), %eax
movl %eax, %esi
callq 0x46590
movl 0x10(%rsp), %ecx
movq (%rax), %rax
movl %ecx, 0x8(%rax)
addq $0x68, %rsp
retq
nopl (%rax)
// File: bonetblai[P]mdp-engine/ctp3/../engine/aot.h
// Function: Online::Policy::AOT::aot_t<state_t>::clear(Online::Policy::AOT::bdd_priority_queue_t<state_t>&) const
void clear(bdd_priority_queue_t<T> &pq) const {
        while( !pq.empty() ) {
            node_t<T> *node = pq.top();
            pq.pop();
            assert(node->in_pq_);
            node->in_pq_ = false;
        }
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x473d0
xorb $-0x1, %al
testb $0x1, %al
jne 0x48620
jmp 0x4866d
movq 0x8(%rsp), %rdi
callq 0x48680
movq %rax, (%rsp)
movq 0x8(%rsp), %rdi
callq 0x486a0
movq (%rsp), %rax
testb $0x1, 0x16(%rax)
je 0x48644
jmp 0x48663
leaq 0x16a6e(%rip), %rdi     # 0x5f0b9
leaq 0x16323(%rip), %rsi     # 0x5e975
movl $0x3bd, %edx            # imm = 0x3BD
leaq 0x16a68(%rip), %rcx     # 0x5f0c6
callq 0x6220
movq (%rsp), %rax
movb $0x0, 0x16(%rax)
jmp 0x4860e
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: bonetblai[P]mdp-engine/ctp3/../engine/bdd_priority_queue.h
// Function: std::bdd_priority_queue<Online::Policy::AOT::node_t<state_t>*, Online::Policy::AOT::min_priority_t<state_t>, Online::Policy::AOT::max_priority_t<state_t>>::pop()
void pop() {
        assert(max_size_ > 0);
        remove_from_min(max_array_[1]->xref_);
        max_array_[1]->next_ = pool_;
        pool_ = max_array_[1];
        max_array_[1] = max_array_[max_size_];
        min_array_[max_array_[1]->xref_] = 1;
        --max_size_;

        if( max_size_ > 0 ) {
            heapify_max(1);
        }

        assert(check());
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpl $0x0, 0x18(%rax)
jbe 0x486bb
jmp 0x486da
leaq 0x16a63(%rip), %rdi     # 0x5f125
leaq 0x16081(%rip), %rsi     # 0x5e74a
movl $0x155, %edx            # imm = 0x155
leaq 0x16a5e(%rip), %rcx     # 0x5f133
callq 0x6220
movq 0x18(%rsp), %rdi
addq $0x20, %rdi
movl $0x1, %esi
callq 0x46590
movq 0x18(%rsp), %rdi
movq (%rax), %rax
movl 0x8(%rax), %esi
callq 0x48810
movq 0x18(%rsp), %rdi
movq 0x8(%rdi), %rax
movq %rax, (%rsp)
addq $0x20, %rdi
movl $0x1, %esi
callq 0x46590
movq (%rsp), %rcx
movq 0x18(%rsp), %rdi
movq (%rax), %rax
movq %rcx, 0x10(%rax)
addq $0x20, %rdi
movl $0x1, %esi
callq 0x46590
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq (%rcx), %rcx
movq %rcx, 0x8(%rax)
movq %rax, %rdi
addq $0x20, %rdi
movl 0x18(%rax), %eax
movl %eax, %esi
callq 0x46590
movq 0x18(%rsp), %rdi
movq (%rax), %rax
movq %rax, 0x8(%rsp)
addq $0x20, %rdi
movl $0x1, %esi
callq 0x46590
movq 0x8(%rsp), %rcx
movq 0x18(%rsp), %rdi
movq %rcx, (%rax)
movq %rdi, %rax
addq $0x40, %rax
movq %rax, 0x10(%rsp)
addq $0x20, %rdi
movl $0x1, %esi
callq 0x46590
movq 0x10(%rsp), %rdi
movq (%rax), %rax
movl 0x8(%rax), %eax
movl %eax, %esi
callq 0x465b0
movq %rax, %rcx
movq 0x18(%rsp), %rax
movl $0x1, (%rcx)
movl 0x18(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x18(%rax)
cmpl $0x0, 0x18(%rax)
jbe 0x487d6
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x48b60
movq 0x18(%rsp), %rdi
callq 0x465d0
testb $0x1, %al
jne 0x487e6
jmp 0x487e8
jmp 0x48807
leaq 0x15f53(%rip), %rdi     # 0x5e742
leaq 0x15f54(%rip), %rsi     # 0x5e74a
movl $0x161, %edx            # imm = 0x161
leaq 0x16931(%rip), %rcx     # 0x5f133
callq 0x6220
addq $0x28, %rsp
retq
nopl (%rax)
// File: bonetblai[P]mdp-engine/ctp3/../engine/aot.h
// Function: Online::Policy::AOT::aot_t<state_t>::select_from_priority_queue() const
node_t<T>* select_from_priority_queue() const {
        node_t<T> *node = 0;
        if( empty_inside_priority_queue() && empty_outside_priority_queue() ) {
            node = 0;
        } else if( empty_inside_priority_queue() ) {
            node = select_from_outside();
        } else if( empty_outside_priority_queue() ) {
            node = select_from_inside();
        } else {
            if( (probability_ == 1) || (Random::real() < probability_) )
                node = select_from_inside();
            else
                node = select_from_outside();
        }

#ifdef DEBUG
        std::cout << "pop " << (node == 0 ? "<null>" : "");
        if( node != 0 ) node->print(std::cout, false);
        std::cout << std::endl;
#endif

        return node;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
movq $0x0, 0x8(%rsp)
callq 0x47390
testb $0x1, %al
jne 0x4bea6
jmp 0x4bec3
movq (%rsp), %rdi
callq 0x473b0
testb $0x1, %al
jne 0x4beb5
jmp 0x4bec3
movq $0x0, 0x8(%rsp)
jmp 0x4bf55
movq (%rsp), %rdi
callq 0x47390
testb $0x1, %al
jne 0x4bed2
jmp 0x4bee2
movq (%rsp), %rdi
callq 0x4bf60
movq %rax, 0x8(%rsp)
jmp 0x4bf53
movq (%rsp), %rdi
callq 0x473b0
testb $0x1, %al
jne 0x4bef1
jmp 0x4bf01
movq (%rsp), %rdi
callq 0x4c000
movq %rax, 0x8(%rsp)
jmp 0x4bf51
movq (%rsp), %rax
movss 0x38(%rax), %xmm0
movss 0x110f2(%rip), %xmm1    # 0x5d004
ucomiss %xmm1, %xmm0
jne 0x4bf1b
jp 0x4bf1b
jmp 0x4bf31
callq 0x19b50
movq (%rsp), %rax
movaps %xmm0, %xmm1
movss 0x38(%rax), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x4bf41
movq (%rsp), %rdi
callq 0x4c000
movq %rax, 0x8(%rsp)
jmp 0x4bf4f
movq (%rsp), %rdi
callq 0x4bf60
movq %rax, 0x8(%rsp)
jmp 0x4bf51
jmp 0x4bf53
jmp 0x4bf55
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nop
// File: bonetblai[P]mdp-engine/ctp3/../engine/aot.h
// Function: Online::Policy::AOT::aot_t<state_t>::select_from_outside() const
node_t<T>* select_from_outside() const {
       node_t<T> *node = 0;
#ifdef USE_BDD_PQ
        node = outside_bdd_priority_queue_.top();
        outside_bdd_priority_queue_.pop();
#else
        node = outside_priority_queue_.top();
        outside_priority_queue_.pop();
#endif
        assert(node->in_pq_);
        node->in_pq_ = false;
        ++from_outside_;
        return node;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
movq $0x0, 0x8(%rsp)
addq $0xf8, %rdi
callq 0x48680
movq (%rsp), %rdi
movq %rax, 0x8(%rsp)
addq $0xf8, %rdi
callq 0x486a0
movq 0x8(%rsp), %rax
testb $0x1, 0x16(%rax)
je 0x4bfa9
jmp 0x4bfc8
leaq 0x13109(%rip), %rdi     # 0x5f0b9
leaq 0x129be(%rip), %rsi     # 0x5e975
movl $0x413, %edx            # imm = 0x413
leaq 0x138fa(%rip), %rcx     # 0x5f8bd
callq 0x6220
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
movb $0x0, 0x16(%rcx)
movss 0x11027(%rip), %xmm0    # 0x5d004
addss 0x154(%rax), %xmm0
movss %xmm0, 0x154(%rax)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: bonetblai[P]mdp-engine/ctp3/../engine/aot.h
// Function: Online::Policy::AOT::aot_t<state_t>::select_from_inside() const
node_t<T>* select_from_inside() const {
        node_t<T> *node = 0;
#ifdef USE_BDD_PQ
        node = inside_bdd_priority_queue_.top();
        inside_bdd_priority_queue_.pop();
#else
        node = inside_priority_queue_.top();
        inside_priority_queue_.pop();
#endif
        assert(node->in_pq_);
        node->in_pq_ = false;
        ++from_inside_;
        return node;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
movq $0x0, 0x8(%rsp)
addq $0xa0, %rdi
callq 0x48680
movq (%rsp), %rdi
movq %rax, 0x8(%rsp)
addq $0xa0, %rdi
callq 0x486a0
movq 0x8(%rsp), %rax
testb $0x1, 0x16(%rax)
je 0x4c049
jmp 0x4c068
leaq 0x13069(%rip), %rdi     # 0x5f0b9
leaq 0x1291e(%rip), %rsi     # 0x5e975
movl $0x405, %edx            # imm = 0x405
leaq 0x138b4(%rip), %rcx     # 0x5f917
callq 0x6220
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
movb $0x0, 0x16(%rcx)
movss 0x10f87(%rip), %xmm0    # 0x5d004
addss 0x150(%rax), %xmm0
movss %xmm0, 0x150(%rax)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: bonetblai[P]mdp-engine/ctp3/../engine/bdd_priority_queue.h
// Function: std::bdd_priority_queue<Online::Policy::AOT::node_t<state_t>*, Online::Policy::AOT::min_priority_t<state_t>, Online::Policy::AOT::max_priority_t<state_t>>::~bdd_priority_queue()
~bdd_priority_queue() {
        clear();
        while( pool_ != 0 ) {
            container_t *p = pool_->next_;
            delete pool_;
            pool_ = p;
        }
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x45140
jmp 0x4c0ba
jmp 0x4c0bc
movq 0x10(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x4c103
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x10(%rcx), %rcx
movq %rcx, 0x18(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x4c0f3
movq 0x8(%rsp), %rdi
callq 0x6310
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rcx, 0x8(%rax)
jmp 0x4c0bc
movq 0x10(%rsp), %rdi
addq $0x40, %rdi
callq 0x450d0
movq 0x10(%rsp), %rdi
addq $0x20, %rdi
callq 0x44f90
addq $0x28, %rsp
retq
movq %rax, %rdi
callq 0xd150
nopl (%rax)
// File: bonetblai[P]mdp-engine/ctp3/../engine/aot.h
// Function: Online::Policy::AOT::state_node_t<state_t>::best_action(bool) const
Problem::action_t best_action(bool random_ties) const {
        std::vector<Problem::action_t> actions;
        actions.reserve(random_ties ? children_.size() : 1);
        for( unsigned i = 0, isz = children_.size(); i < isz; ++i ) {
            action_node_t<T> *a_node = children_[i];
            if( (a_node->value_ == value_) && (random_ties || actions.empty()) ) {
                actions.push_back(a_node->action_);
            }
            //std::cout << "  state=" << state_ << ", value=" << a_node->value_ << std::endl;
        }
        return actions.empty() ? Problem::noop : actions[Random::random(actions.size())];
    }

// Assembly:
subq $0x68, %rsp
movb %sil, %al
movq %rdi, 0x60(%rsp)
andb $0x1, %al
movb %al, 0x5f(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x40(%rsp), %rdi
callq 0xe840
testb $0x1, 0x5f(%rsp)
je 0x4d075
movq 0x18(%rsp), %rdi
addq $0xa8, %rdi
callq 0x46f70
movq %rax, 0x10(%rsp)
jmp 0x4d081
movl $0x1, %eax
movq %rax, 0x10(%rsp)
jmp 0x4d081
movq 0x10(%rsp), %rsi
leaq 0x40(%rsp), %rdi
callq 0x163b0
jmp 0x4d092
movq 0x18(%rsp), %rdi
movl $0x0, 0x30(%rsp)
addq $0xa8, %rdi
callq 0x46f70
movl %eax, 0x2c(%rsp)
movl 0x30(%rsp), %eax
cmpl 0x2c(%rsp), %eax
jae 0x4d150
movq 0x18(%rsp), %rdi
addq $0xa8, %rdi
movl 0x30(%rsp), %eax
movl %eax, %esi
callq 0x527f0
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq (%rcx), %rcx
movq %rcx, 0x20(%rsp)
movq 0x20(%rsp), %rcx
movss 0x8(%rcx), %xmm0
ucomiss 0x8(%rax), %xmm0
jne 0x4d13e
jp 0x4d13e
testb $0x1, 0x5f(%rsp)
jne 0x4d10d
leaq 0x40(%rsp), %rdi
callq 0x1a320
testb $0x1, %al
jne 0x4d10d
jmp 0x4d13e
movq 0x20(%rsp), %rsi
addq $0x18, %rsi
leaq 0x40(%rsp), %rdi
callq 0xedb0
jmp 0x4d122
jmp 0x4d13e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x40(%rsp), %rdi
callq 0xdfb0
jmp 0x4d1b5
jmp 0x4d140
movl 0x30(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x30(%rsp)
jmp 0x4d0af
leaq 0x40(%rsp), %rdi
callq 0x1a320
testb $0x1, %al
jne 0x4d160
jmp 0x4d16b
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, 0xc(%rsp)
jmp 0x4d19a
leaq 0x40(%rsp), %rdi
callq 0xdcb0
movl %eax, %edi
callq 0x1a370
movl %eax, 0x8(%rsp)
jmp 0x4d182
movl 0x8(%rsp), %eax
movl %eax, %eax
movl %eax, %esi
leaq 0x40(%rsp), %rdi
callq 0xdcf0
movl (%rax), %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
movl %eax, 0x4(%rsp)
leaq 0x40(%rsp), %rdi
callq 0xdfb0
movl 0x4(%rsp), %eax
addq $0x68, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x6520
nop
// File: bonetblai[P]mdp-engine/ctp3/../engine/aot.h
// Function: Online::Policy::AOT::hash_t<state_t>::clear()
void clear() {
        for( const_iterator it = begin(); it != end(); ++it ) {
            state_node_t<T> *s_node = it->second;
            for( int i = 0, isz = s_node->children_.size(); i < isz; ++i ) {
                delete s_node->children_[i];
            }
            delete it->second;
        }
        base_type::clear();
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x4d350
movq %rax, 0x38(%rsp)
movq 0x18(%rsp), %rdi
callq 0x4d3a0
movq %rax, 0x30(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x4d380
testb $0x1, %al
jne 0x4d284
jmp 0x4d331
leaq 0x38(%rsp), %rdi
callq 0x4d3d0
movq 0x10(%rax), %rax
movq %rax, 0x28(%rsp)
movl $0x0, 0x24(%rsp)
movq 0x28(%rsp), %rdi
addq $0xa8, %rdi
callq 0x46f70
movl %eax, 0x20(%rsp)
movl 0x24(%rsp), %eax
cmpl 0x20(%rsp), %eax
jge 0x4d2fc
movq 0x28(%rsp), %rdi
addq $0xa8, %rdi
movslq 0x24(%rsp), %rsi
callq 0x46f90
movq (%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x4d2ed
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x4d2ef
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x4d2b4
leaq 0x38(%rsp), %rdi
callq 0x4d3d0
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x4d320
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x4d322
leaq 0x38(%rsp), %rdi
callq 0x4d3f0
jmp 0x4d25d
movq 0x18(%rsp), %rdi
addq $0x8, %rdi
callq 0x4d420
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: bonetblai[P]mdp-engine/ctp3/../engine/aot.h
// Function: Online::Policy::AOT::aot_t<state_t>::evaluate(state_t const&, unsigned int) const
float evaluate(const T &s, unsigned depth) const {
        total_evaluations_ += leaf_nsamples_;
        if( (heuristic_ != 0) && (depth < horizon_) ) {
            float value = heuristic_->value(s);
            policy_t<T>::heuristic_time_ = heuristic_->eval_time();
            return value;
        } else if( depth >= horizon_ ) {
            return 0;
        } else {
            float start_time = Utils::read_time_in_seconds();
            float value = Evaluation::evaluation(*base_policy_, s, leaf_nsamples_, horizon_ - depth);
            policy_t<T>::base_policy_time_ += Utils::read_time_in_seconds() - start_time;
            return value;
        }
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movl %edx, 0x1c(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x44(%rax), %ecx
addl 0x164(%rax), %ecx
movl %ecx, 0x164(%rax)
cmpq $0x0, 0x98(%rax)
je 0x4d7a9
movq 0x8(%rsp), %rcx
movl 0x1c(%rsp), %eax
cmpl 0x34(%rcx), %eax
jae 0x4d7a9
movq 0x8(%rsp), %rax
movq 0x98(%rax), %rdi
movq 0x20(%rsp), %rsi
movq (%rdi), %rax
callq *0x20(%rax)
movq 0x8(%rsp), %rax
movss %xmm0, 0x18(%rsp)
movq 0x98(%rax), %rdi
callq 0x35c40
movq 0x8(%rsp), %rax
movss %xmm0, 0x1c(%rax)
movss 0x18(%rsp), %xmm0
movss %xmm0, 0x34(%rsp)
jmp 0x4d819
movq 0x8(%rsp), %rcx
movl 0x1c(%rsp), %eax
cmpl 0x34(%rcx), %eax
jb 0x4d7c2
xorps %xmm0, %xmm0
movss %xmm0, 0x34(%rsp)
jmp 0x4d819
callq 0x84f0
movq 0x8(%rsp), %rax
movss %xmm0, 0x14(%rsp)
movq 0x28(%rax), %rdi
movq 0x20(%rsp), %rsi
movl 0x44(%rax), %edx
movl 0x34(%rax), %ecx
subl 0x1c(%rsp), %ecx
xorl %r8d, %r8d
callq 0x3c6b0
movss %xmm0, 0x10(%rsp)
callq 0x84f0
movq 0x8(%rsp), %rax
subss 0x14(%rsp), %xmm0
addss 0x18(%rax), %xmm0
movss %xmm0, 0x18(%rax)
movss 0x10(%rsp), %xmm0
movss %xmm0, 0x34(%rsp)
movss 0x34(%rsp), %xmm0
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: bonetblai[P]mdp-engine/ctp3/../engine/aot.h
// Function: Online::Policy::AOT::state_node_t<state_t>::print(std::ostream&, bool) const
virtual void print(std::ostream &os, bool indent = true) const {
        if( indent ) os << std::setw(2 * depth_) << "";
        os << "[state=" << state_
           << ",depth=" << depth_
           << ",#pa=" << parents_.size()
           << ",#chld=" << children_.size()
           << ",value=" << value_
           << ",delta=" << delta_
           << "]";
    }

// Assembly:
subq $0x38, %rsp
movb %dl, %al
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
andb $0x1, %al
movb %al, 0x27(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
testb $0x1, 0x27(%rsp)
je 0x4df24
movq 0x18(%rsp), %rax
movq 0x28(%rsp), %rcx
movq %rcx, 0x10(%rsp)
movl 0x8c(%rax), %edi
shll %edi
callq 0x1a300
movq 0x10(%rsp), %rdi
movl %eax, 0x20(%rsp)
movl 0x20(%rsp), %esi
callq 0x63c0
movq %rax, %rdi
leaq 0xffd8(%rip), %rsi      # 0x5def7
callq 0x6330
movq 0x28(%rsp), %rdi
leaq 0x11c5e(%rip), %rsi     # 0x5fb8e
callq 0x6330
movq 0x18(%rsp), %rsi
movq %rax, %rdi
addq $0x18, %rsi
callq 0x33f30
movq %rax, %rdi
leaq 0x10283(%rip), %rsi     # 0x5e1d3
callq 0x6330
movq %rax, %rdi
movq 0x18(%rsp), %rax
movl 0x8c(%rax), %esi
callq 0x6440
movq %rax, %rdi
leaq 0x11c24(%rip), %rsi     # 0x5fb96
callq 0x6330
movq 0x18(%rsp), %rdi
movq %rax, (%rsp)
addq $0x90, %rdi
callq 0x4bd00
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x60c0
movq %rax, %rdi
leaq 0x11bfa(%rip), %rsi     # 0x5fb9c
callq 0x6330
movq 0x18(%rsp), %rdi
movq %rax, 0x8(%rsp)
addq $0xa8, %rdi
callq 0x46f70
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x60c0
movq %rax, %rdi
leaq 0x11bd0(%rip), %rsi     # 0x5fba4
callq 0x6330
movq %rax, %rdi
movq 0x18(%rsp), %rax
movss 0x8(%rax), %xmm0
callq 0x6270
movq %rax, %rdi
leaq 0x11bb7(%rip), %rsi     # 0x5fbac
callq 0x6330
movq %rax, %rdi
movq 0x18(%rsp), %rax
movss 0xc(%rax), %xmm0
callq 0x6270
movq %rax, %rdi
leaq 0x10c6f(%rip), %rsi     # 0x5ec85
callq 0x6330
addq $0x38, %rsp
retq
// File: bonetblai[P]mdp-engine/ctp3/../engine/aot.h
// Function: Online::Policy::AOT::aot_t<state_t>::evaluate(state_t const&, int, unsigned int) const
float evaluate(const T &state, Problem::action_t action, unsigned depth) const {
        // CHECK: this need to be revised when using heuristics
        float value = 0;
        for( unsigned i = 0; i < delayed_evaluation_nsamples_; ++i ) {
            std::pair<T, bool> sample = problem_.sample(state, action);
            value += evaluate(sample.first, depth);
        }
        return value / delayed_evaluation_nsamples_;
    }

// Assembly:
subq $0xc8, %rsp
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movl %edx, 0xb4(%rsp)
movl %ecx, 0xb0(%rsp)
movq 0xc0(%rsp), %rax
movq %rax, 0x18(%rsp)
xorps %xmm0, %xmm0
movss %xmm0, 0xac(%rsp)
movl $0x0, 0xa8(%rsp)
movq 0x18(%rsp), %rcx
movl 0xa8(%rsp), %eax
cmpl 0x48(%rcx), %eax
jae 0x4f0f5
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rsi
movq 0xb8(%rsp), %rdx
movl 0xb4(%rsp), %ecx
leaq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x19da0
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movl 0xb0(%rsp), %edx
callq 0x4d720
movss %xmm0, 0x14(%rsp)
jmp 0x4f0a3
movss 0x14(%rsp), %xmm0
addss 0xac(%rsp), %xmm0
movss %xmm0, 0xac(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x19f70
movl 0xa8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xa8(%rsp)
jmp 0x4f049
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x19f70
jmp 0x4f117
movq 0x18(%rsp), %rax
movss 0xac(%rsp), %xmm0
movl 0x48(%rax), %eax
cvtsi2ss %rax, %xmm1
divss %xmm1, %xmm0
addq $0xc8, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x6520
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: bonetblai[P]mdp-engine/ctp3/../engine/aot.h
// Function: Online::Policy::AOT::action_node_t<state_t>::print(std::ostream&, bool) const
virtual void print(std::ostream &os, bool indent = true) const {
        if( indent ) os << std::setw(2 * parent_->depth_) << "";
        os << "[action=" << action_
           << ",value=" << value_
           << ",delta=" << delta_
           << "]";
    }

// Assembly:
subq $0x28, %rsp
movb %dl, %al
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
andb $0x1, %al
movb %al, 0x17(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
testb $0x1, 0x17(%rsp)
je 0x4f476
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rcx, (%rsp)
movq 0x20(%rax), %rax
movl 0x8c(%rax), %edi
shll %edi
callq 0x1a300
movq (%rsp), %rdi
movl %eax, 0x10(%rsp)
movl 0x10(%rsp), %esi
callq 0x63c0
movq %rax, %rdi
leaq 0xea86(%rip), %rsi      # 0x5def7
callq 0x6330
movq 0x18(%rsp), %rdi
leaq 0x107b8(%rip), %rsi     # 0x5fc3a
callq 0x6330
movq %rax, %rdi
movq 0x8(%rsp), %rax
movl 0x18(%rax), %esi
callq 0x6510
movq %rax, %rdi
leaq 0x10703(%rip), %rsi     # 0x5fba4
callq 0x6330
movq %rax, %rdi
movq 0x8(%rsp), %rax
movss 0x8(%rax), %xmm0
callq 0x6270
movq %rax, %rdi
leaq 0x106ea(%rip), %rsi     # 0x5fbac
callq 0x6330
movq %rax, %rdi
movq 0x8(%rsp), %rax
movss 0xc(%rax), %xmm0
callq 0x6270
movq %rax, %rdi
leaq 0xf7a2(%rip), %rsi      # 0x5ec85
callq 0x6330
addq $0x28, %rsp
retq
nopl (%rax)
// File: bonetblai[P]mdp-engine/ctp3/../engine/aot.h
// Function: Online::Policy::AOT::state_node_t<state_t>::update_value()
void update_value() {
        assert(!is_goal_);
        if( !is_dead_end_ ) {
            value_ = std::numeric_limits<float>::max();
            for( unsigned i = 0, isz = children_.size(); i < isz; ++i ) {
                float child_value = children_[i]->value_;
                if( child_value < value_ ) {
                    value_ = child_value;
                }
            }
            assert(value_ < std::numeric_limits<float>::max());
        }
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movb 0x88(%rax), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x4fb21
jmp 0x4fb23
jmp 0x4fb42
leaq 0x101e5(%rip), %rdi     # 0x5fd0f
leaq 0xee44(%rip), %rsi      # 0x5e975
movl $0x9c, %edx
leaq 0x101dc(%rip), %rcx     # 0x5fd19
callq 0x6220
movq 0x8(%rsp), %rax
testb $0x1, 0x89(%rax)
jne 0x4fc24
callq 0x23160
movq 0x8(%rsp), %rdi
movss %xmm0, 0x8(%rdi)
movl $0x0, 0x1c(%rsp)
addq $0xa8, %rdi
callq 0x46f70
movl %eax, 0x18(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x18(%rsp), %eax
jae 0x4fbe1
movq 0x8(%rsp), %rdi
addq $0xa8, %rdi
movl 0x1c(%rsp), %eax
movl %eax, %esi
callq 0x46f90
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq (%rcx), %rcx
movss 0x8(%rcx), %xmm0
movss %xmm0, 0x14(%rsp)
movss 0x14(%rsp), %xmm1
movss 0x8(%rax), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x4fbd2
movq 0x8(%rsp), %rax
movss 0x14(%rsp), %xmm0
movss %xmm0, 0x8(%rax)
jmp 0x4fbd4
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x4fb7b
movq 0x8(%rsp), %rax
movss 0x8(%rax), %xmm0
movss %xmm0, 0x4(%rsp)
callq 0x23160
movss 0x4(%rsp), %xmm1
ucomiss %xmm1, %xmm0
jbe 0x4fc03
jmp 0x4fc22
leaq 0x1015d(%rip), %rdi     # 0x5fd67
leaq 0xed64(%rip), %rsi      # 0x5e975
movl $0xa5, %edx
leaq 0x100fc(%rip), %rcx     # 0x5fd19
callq 0x6220
jmp 0x4fc24
addq $0x28, %rsp
retq
nopl (%rax)
// File: bonetblai[P]mdp-engine/ctp3/../engine/aot.h
// Function: Online::Policy::AOT::action_node_t<state_t>::update_value(float)
void update_value(float discount) {
        value_ = 0;
        for( unsigned i = 0, isz = children_.size(); i < isz; ++i ) {
            value_ += children_[i].first * children_[i].second->value_;
        }
        value_ = action_cost_ + discount * value_;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movss %xmm0, 0x1c(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
xorps %xmm0, %xmm0
movss %xmm0, 0x8(%rdi)
movl $0x0, 0x18(%rsp)
addq $0x28, %rdi
callq 0x47000
movl %eax, 0x14(%rsp)
movl 0x18(%rsp), %eax
cmpl 0x14(%rsp), %eax
jae 0x4fcd0
movq 0x8(%rsp), %rdi
addq $0x28, %rdi
movl 0x18(%rsp), %eax
movl %eax, %esi
callq 0x47020
movq 0x8(%rsp), %rdi
movss (%rax), %xmm0
movss %xmm0, 0x4(%rsp)
addq $0x28, %rdi
movl 0x18(%rsp), %eax
movl %eax, %esi
callq 0x47020
movss 0x4(%rsp), %xmm0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq 0x8(%rcx), %rcx
mulss 0x8(%rcx), %xmm0
addss 0x8(%rax), %xmm0
movss %xmm0, 0x8(%rax)
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x4fc66
movq 0x8(%rsp), %rax
movss 0x1c(%rax), %xmm0
movss 0x1c(%rsp), %xmm1
mulss 0x8(%rax), %xmm1
addss %xmm1, %xmm0
movss %xmm0, 0x8(%rax)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: bonetblai[P]mdp-engine/ctp3/../engine/online_rtdp.h
// Function: Online::Policy::RTDP::finite_horizon_lrtdp_t<state_t>::operator()(state_t const&) const
virtual Problem::action_t operator()(const T &s) const {
        // initialize
        ++policy_t<T>::decisions_;
        clear_table();
        node_t<T> root(s, 0);
        data_t *root_dptr = table_.get_data_ptr(root);

        // perform trials
        for( unsigned trial = 0; (trial < max_trials_) && !labeled(root_dptr); ++trial ) {
            lrtdp_trial(root, root_dptr);
        }
#ifdef DEBUG
        std::cout << "finite_horizon_lrtdp_t: root-value=" << root_dptr->value_
                  << ", labeled=" << (root_dptr->labeled_ ? "true" : "false")
                  << std::endl;
#endif
        return best_action(root, random_ties_);
    }

// Assembly:
subq $0xc8, %rsp
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movq 0xc0(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movl 0x20(%rdi), %eax
incl %eax
movl %eax, 0x20(%rdi)
callq 0x53f50
movq 0xb8(%rsp), %rsi
leaq 0x40(%rsp), %rdi
movq %rdi, 0x18(%rsp)
xorl %edx, %edx
callq 0x53fe0
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
addq $0x40, %rdi
callq 0x54010
movq %rax, 0x20(%rsp)
jmp 0x52e24
movq 0x20(%rsp), %rax
movq %rax, 0x38(%rsp)
movl $0x0, 0x28(%rsp)
movq 0x10(%rsp), %rdx
movl 0x28(%rsp), %ecx
xorl %eax, %eax
cmpl 0x34(%rdx), %ecx
movb %al, 0xf(%rsp)
jae 0x52e69
movq 0x10(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x54070
movb %al, 0xe(%rsp)
jmp 0x52e5f
movb 0xe(%rsp), %al
xorb $-0x1, %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x52e73
jmp 0x52eb2
movq 0x10(%rsp), %rdi
movq 0x38(%rsp), %rdx
leaq 0x40(%rsp), %rsi
callq 0x540c0
jmp 0x52e89
jmp 0x52e8b
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0x52e36
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x53c50
jmp 0x52ee4
movq 0x10(%rsp), %rdi
movzbl 0x39(%rdi), %edx
andl $0x1, %edx
leaq 0x40(%rsp), %rsi
callq 0x54660
movl %eax, 0x8(%rsp)
jmp 0x52ece
leaq 0x40(%rsp), %rdi
callq 0x53c50
movl 0x8(%rsp), %eax
addq $0xc8, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x6520
nop
// File: bonetblai[P]mdp-engine/ctp3/../engine/online_rtdp.h
// Function: Online::Policy::RTDP::finite_horizon_lrtdp_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_
           << " #expansions=" << total_number_expansions_
           << std::endl;
    }

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movl %edx, 0x84(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x28(%rsp)
movl 0x84(%rsp), %edi
callq 0x1a300
movq 0x28(%rsp), %rdi
movl %eax, 0x80(%rsp)
movl 0x80(%rsp), %esi
callq 0x63c0
movq %rax, %rdi
leaq 0xaf41(%rip), %rsi      # 0x5def7
callq 0x6330
movq %rax, %rdi
leaq 0xa5cc(%rip), %rsi      # 0x5d591
callq 0x6330
movq 0x30(%rsp), %rsi
movq %rax, 0x38(%rsp)
movq (%rsi), %rax
movq 0x18(%rax), %rax
leaq 0x60(%rsp), %rdi
movq %rdi, 0x40(%rsp)
callq *%rax
movq 0x38(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x62f0
movq %rax, 0x48(%rsp)
jmp 0x52ffd
movq 0x48(%rsp), %rdi
leaq 0xa59b(%rip), %rsi      # 0x5d5a4
callq 0x6330
movq %rax, 0x20(%rsp)
jmp 0x53015
movq 0x20(%rsp), %rdi
movq 0x30(%rsp), %rax
movl 0x20(%rax), %esi
callq 0x6440
movq %rax, 0x18(%rsp)
jmp 0x5302e
movq 0x18(%rsp), %rdi
leaq 0xce3f(%rip), %rsi      # 0x5fe79
callq 0x6330
movq %rax, 0x10(%rsp)
jmp 0x53046
movq 0x10(%rsp), %rdi
movq 0x30(%rsp), %rax
movl 0x80(%rax), %esi
callq 0x6440
movq %rax, 0x8(%rsp)
jmp 0x53062
movq 0x8(%rsp), %rdi
movq 0x2ff4a(%rip), %rsi     # 0x82fb8
callq 0x6370
jmp 0x53075
leaq 0x60(%rsp), %rdi
callq 0x61f0
addq $0x98, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x61f0
movq 0x58(%rsp), %rdi
callq 0x6520
nopl (%rax)
// File: bonetblai[P]mdp-engine/ctp3/../engine/online_rtdp.h
// Function: Online::Policy::RTDP::finite_horizon_lrtdp_t<state_t>::best_q_value(Online::Policy::RTDP::node_t<state_t> const&) const
std::pair<std::pair<float, Problem::action_t>, bool> best_q_value(const node_t<T> &node) const {
        bool all_labeled = false;
        Problem::action_t best_action = Problem::noop;
        float best_value = std::numeric_limits<float>::max();
        int nactions = problem_.number_actions(node.state());
        for( Problem::action_t a = 0; a < nactions; ++a ) {
            if( problem_.applicable(node.state(), a) ) {
                std::pair<float, bool> p = q_value(node, a);
                if( (best_action == Problem::noop) || (p.first < best_value) ) {
                    all_labeled = p.second;
                    best_value = p.first;
                    best_action = a;
                }
            }
        }
        assert(best_action != Problem::noop);
        return std::make_pair(std::make_pair(best_value, best_action), all_labeled);
    }

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x10(%rsp)
movb $0x0, 0x67(%rsp)
movl $0xffffffff, 0x60(%rsp) # imm = 0xFFFFFFFF
callq 0x23160
movq 0x10(%rsp), %rax
movss %xmm0, 0x5c(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x68(%rsp), %rdi
callq 0x54f00
movq 0x18(%rsp), %rdi
movq %rax, %rsi
movq (%rdi), %rax
callq *0x10(%rax)
movl %eax, 0x58(%rsp)
movl $0x0, 0x54(%rsp)
movl 0x54(%rsp), %eax
cmpl 0x58(%rsp), %eax
jge 0x562ce
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x68(%rsp), %rdi
callq 0x54f00
movq 0x8(%rsp), %rdi
movq %rax, %rsi
movl 0x54(%rsp), %edx
movq (%rdi), %rax
callq *0x30(%rax)
testb $0x1, %al
jne 0x56263
jmp 0x562bc
movq 0x10(%rsp), %rdi
movq 0x68(%rsp), %rsi
movl 0x54(%rsp), %edx
callq 0x572e0
movl %eax, %ecx
movl %ecx, 0x4c(%rsp)
shrq $0x20, %rax
movb %al, 0x50(%rsp)
cmpl $-0x1, 0x60(%rsp)
je 0x5629c
movss 0x4c(%rsp), %xmm1
movss 0x5c(%rsp), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x562ba
movb 0x50(%rsp), %al
andb $0x1, %al
movb %al, 0x67(%rsp)
movss 0x4c(%rsp), %xmm0
movss %xmm0, 0x5c(%rsp)
movl 0x54(%rsp), %eax
movl %eax, 0x60(%rsp)
jmp 0x562bc
jmp 0x562be
movl 0x54(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x54(%rsp)
jmp 0x56225
cmpl $-0x1, 0x60(%rsp)
je 0x562d7
jmp 0x562f6
leaq 0x7f07(%rip), %rdi      # 0x5e1e5
leaq 0x9c16(%rip), %rsi      # 0x5fefb
movl $0x11d, %edx            # imm = 0x11D
leaq 0x9c8a(%rip), %rcx      # 0x5ff7b
callq 0x6220
leaq 0x5c(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x57600
movq %rax, 0x44(%rsp)
leaq 0x44(%rsp), %rdi
leaq 0x67(%rsp), %rsi
callq 0x575b0
movb %dl, 0x38(%rsp)
movq %rax, 0x30(%rsp)
movb 0x38(%rsp), %al
movb %al, 0x80(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x78(%rsp)
movl 0x80(%rsp), %eax
movl %eax, 0x28(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movb 0x28(%rsp), %dl
addq $0x88, %rsp
retq
nopl (%rax)
// File: bonetblai[P]mdp-engine/ctp3/../engine/online_rtdp.h
// Function: Online::Policy::RTDP::finite_horizon_lrtdp_t<state_t>::try_label(Online::Policy::RTDP::node_t<state_t> const&, Online::Policy::RTDP::data_t*) const
bool try_label(const node_t<T> &node, data_t *dptr) const {
        bool labeled = true;
        if( dead_end(node) ) {
            dptr->value_ = problem_.dead_end_value();
        } else if( terminal(node) ) {
            dptr->value_ = 0;
        } else {
            std::pair<std::pair<float, Problem::action_t>, bool> p = best_q_value(node);
            if( (p.first.first == dptr->value_) && p.second ) {
                labeled = true;
            } else {
                dptr->value_ = p.first.first;
                labeled = p.second;
            }
        }
        dptr->labeled_ = labeled;
        return labeled;
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movb $0x1, 0x2f(%rsp)
movq 0x38(%rsp), %rsi
callq 0x56110
testb $0x1, %al
jne 0x564a2
jmp 0x564be
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x3cbe0
movq 0x30(%rsp), %rax
movss %xmm0, (%rax)
jmp 0x56548
movq 0x8(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x56150
testb $0x1, %al
jne 0x564d3
jmp 0x564e1
movq 0x30(%rsp), %rax
xorps %xmm0, %xmm0
movss %xmm0, (%rax)
jmp 0x56546
movq 0x8(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x561c0
movb %dl, 0x18(%rsp)
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp)
movb 0x18(%rsp), %al
movb %al, 0x28(%rsp)
movss 0x20(%rsp), %xmm0
movq 0x30(%rsp), %rax
ucomiss (%rax), %xmm0
jne 0x5652b
jp 0x5652b
testb $0x1, 0x28(%rsp)
je 0x5652b
movb $0x1, 0x2f(%rsp)
jmp 0x56544
movss 0x20(%rsp), %xmm0
movq 0x30(%rsp), %rax
movss %xmm0, (%rax)
movb 0x28(%rsp), %al
andb $0x1, %al
movb %al, 0x2f(%rsp)
jmp 0x56546
jmp 0x56548
movb 0x2f(%rsp), %cl
movq 0x30(%rsp), %rax
andb $0x1, %cl
movb %cl, 0x4(%rax)
movb 0x2f(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: bonetblai[P]mdp-engine/ctp3/../engine/online_rtdp.h
// Function: Online::Policy::RTDP::finite_horizon_lrtdp_t<state_t>::value(Online::Policy::RTDP::node_t<state_t> const&) const
std::pair<float, bool> value(const node_t<T> &node) const {
        const data_t *dptr = table_.data_ptr(node);
        if( dptr != 0 ) {
            return std::make_pair(dptr->value_, dptr->labeled_);
        } else {
            float hvalue = 0; // default value for terminal node
            if( dead_end(node) ) {
                hvalue = problem_.dead_end_value();
            } else if( !terminal(node) ) {
                hvalue = heuristic_ == 0 ? 0 : heuristic_->value(node.state());
                policy_t<T>::heuristic_time_ = heuristic_ == 0 ? 0 : heuristic_->eval_time();
            }
            return std::make_pair(hvalue, false);
        }
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rdi
movq %rdi, 0x18(%rsp)
addq $0x40, %rdi
movq 0x30(%rsp), %rsi
callq 0x54b30
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
je 0x57687
movq 0x28(%rsp), %rdi
movq %rdi, %rsi
addq $0x4, %rsi
callq 0x577c0
movl %eax, %ecx
movl %ecx, 0x40(%rsp)
shrq $0x20, %rax
movb %al, 0x44(%rsp)
jmp 0x57783
movq 0x18(%rsp), %rdi
xorps %xmm0, %xmm0
movss %xmm0, 0x24(%rsp)
movq 0x30(%rsp), %rsi
callq 0x56110
testb $0x1, %al
jne 0x576a5
jmp 0x576be
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x3cbe0
movss %xmm0, 0x24(%rsp)
jmp 0x57761
movq 0x18(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x56150
testb $0x1, %al
jne 0x5775f
movq 0x18(%rsp), %rax
cmpq $0x0, 0x28(%rax)
jne 0x576ec
xorps %xmm0, %xmm0
movss %xmm0, 0x14(%rsp)
jmp 0x57718
movq 0x18(%rsp), %rax
movq 0x28(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
callq 0x54f00
movq 0x8(%rsp), %rdi
movq %rax, %rsi
movq (%rdi), %rax
callq *0x20(%rax)
movss %xmm0, 0x14(%rsp)
movq 0x18(%rsp), %rax
movss 0x14(%rsp), %xmm0
movss %xmm0, 0x24(%rsp)
cmpq $0x0, 0x28(%rax)
jne 0x5773b
xorps %xmm0, %xmm0
movss %xmm0, 0x4(%rsp)
jmp 0x5774f
movq 0x18(%rsp), %rax
movq 0x28(%rax), %rdi
callq 0x35c40
movss %xmm0, 0x4(%rsp)
movq 0x18(%rsp), %rax
movss 0x4(%rsp), %xmm0
movss %xmm0, 0x1c(%rax)
jmp 0x57761
movb $0x0, 0x23(%rsp)
leaq 0x24(%rsp), %rdi
leaq 0x23(%rsp), %rsi
callq 0x577f0
movl %eax, %ecx
movl %ecx, 0x40(%rsp)
shrq $0x20, %rax
movb %al, 0x44(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopl (%rax)
// File: bonetblai[P]mdp-engine/ctp3/../engine/problem.h
// Function: Problem::problem_t<state_t>::policy_size_aux(Problem::hash_t<state_t> const&, state_t const&, std::set<state_t, std::less<state_t>, std::allocator<state_t>>&) const
size_t policy_size_aux(const hash_t<T> &hash, const T &s, std::set<T> &marked_states) const {
        std::vector<std::pair<T, float> > outcomes;
        size_t size = 0;
        if( !terminal(s) && (marked_states.find(s) == marked_states.end()) ) {
            marked_states.insert(s);
            std::pair<action_t, float> p = hash.best_q_value(s);
            next(s, p.first, outcomes);
            unsigned osize = outcomes.size();
            for( unsigned i = 0; i < osize; ++i )
                size += policy_size_aux(hash, outcomes[i].first, marked_states);
            ++size;
        }
        return size;
    }

// Assembly:
subq $0xd8, %rsp
movq %rdi, 0xd0(%rsp)
movq %rsi, 0xc8(%rsp)
movq %rdx, 0xc0(%rsp)
movq %rcx, 0xb8(%rsp)
movq 0xd0(%rsp), %rax
movq %rax, 0x48(%rsp)
leaq 0xa0(%rsp), %rdi
callq 0x1a4a0
movq 0x48(%rsp), %rdi
movq $0x0, 0x98(%rsp)
movq 0xc0(%rsp), %rsi
movq (%rdi), %rax
movq 0x20(%rax), %rax
callq *%rax
movb %al, 0x57(%rsp)
jmp 0x59c79
movb 0x57(%rsp), %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0x47(%rsp)
jne 0x59cdb
jmp 0x59c8a
movq 0xb8(%rsp), %rdi
movq 0xc0(%rsp), %rsi
callq 0x59f10
movq %rax, 0x38(%rsp)
jmp 0x59ca6
movq 0x38(%rsp), %rax
movq %rax, 0x80(%rsp)
movq 0xb8(%rsp), %rdi
callq 0x59f50
movq %rax, 0x78(%rsp)
leaq 0x80(%rsp), %rdi
leaq 0x78(%rsp), %rsi
callq 0x59ef0
movb %al, 0x47(%rsp)
movb 0x47(%rsp), %al
testb $0x1, %al
jne 0x59ce8
jmp 0x59e25
movq 0xb8(%rsp), %rdi
movq 0xc0(%rsp), %rsi
callq 0x59f80
movb %dl, 0x2f(%rsp)
movq %rax, 0x30(%rsp)
jmp 0x59d08
movb 0x2f(%rsp), %al
movq 0x30(%rsp), %rcx
movq %rcx, 0x68(%rsp)
movb %al, 0x70(%rsp)
movq 0xc8(%rsp), %rdi
movq 0xc0(%rsp), %rsi
callq 0x22eb0
movq %rax, 0x20(%rsp)
jmp 0x59d36
movq 0x48(%rsp), %rdi
movq 0x20(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0xc0(%rsp), %rsi
movl 0x60(%rsp), %edx
movq (%rdi), %rax
movq 0x60(%rax), %rax
leaq 0xa0(%rsp), %rcx
callq *%rax
jmp 0x59d64
leaq 0xa0(%rsp), %rdi
callq 0x17030
movl %eax, 0x5c(%rsp)
movl $0x0, 0x58(%rsp)
movl 0x58(%rsp), %eax
cmpl 0x5c(%rsp), %eax
jae 0x59e11
movq 0xc8(%rsp), %rax
movq %rax, 0x10(%rsp)
movl 0x58(%rsp), %eax
movl %eax, %esi
leaq 0xa0(%rsp), %rdi
callq 0x1a4b0
movq 0x48(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %rax, %rdx
movq 0xb8(%rsp), %rcx
callq 0x59c10
movq %rax, 0x18(%rsp)
jmp 0x59dcc
movq 0x18(%rsp), %rax
addq 0x98(%rsp), %rax
movq %rax, 0x98(%rsp)
movl 0x58(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x58(%rsp)
jmp 0x59d7d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
leaq 0xa0(%rsp), %rdi
callq 0x1a510
jmp 0x59e4c
movq 0x98(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x98(%rsp)
movq 0x98(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0xa0(%rsp), %rdi
callq 0x1a510
movq 0x8(%rsp), %rax
addq $0xd8, %rsp
retq
movq 0x90(%rsp), %rdi
callq 0x6520
nopl (%rax)