LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/bonetblai[P]mdp-engine/ctp3/../engine/rollout.h
// Function: Online::Policy::Rollout::rollout_t<state_t>::print_other_stats(std::ostream&, int) const
virtual void print_other_stats(std::ostream &os, int indent) const {
        os << std::setw(indent) << ""
           << "other-stats: name=" << name()
           << " decisions=" << policy_t<T>::decisions_
           << std::endl;
        if( base_policy_ != 0 ) base_policy_->print_other_stats(os, 2 + indent);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq (%rsi), %rax
movq -0x18(%rax), %rax
movslq %edx, %rcx
movq %rcx, 0x10(%rsi,%rax)
leaq 0xedb6(%rip), %rsi      # 0x2df67
movq %r14, %rdi
xorl %edx, %edx
callq 0x62e0
leaq 0xe43f(%rip), %rsi      # 0x2d601
movl $0x12, %edx
movq %r14, %rdi
callq 0x62e0
movq (%r15), %rax
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq *0x18(%rax)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %r14, %rdi
callq 0x62e0
movq %rax, %r12
leaq 0xe419(%rip), %rsi      # 0x2d614
movl $0xb, %edx
movq %rax, %rdi
callq 0x62e0
movl 0x20(%r15), %esi
movq %r12, %rdi
callq 0x61d0
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x6270
movsbl %al, %esi
movq %r12, %rdi
callq 0x6040
movq %rax, %rdi
callq 0x61e0
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1f251
callq 0x6260
movq 0x28(%r15), %rdi
testq %rdi, %rdi
je 0x1f268
addl $0x2, %ebx
movq (%rdi), %rax
movq %r14, %rsi
movl %ebx, %edx
callq *0x30(%rax)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1f28a
callq 0x6260
movq %rbx, %rdi
callq 0x6410
// File: /workspace/github_cpp_makefile_star2_O1/bonetblai[P]mdp-engine/ctp3/../engine/rollout.h
// Function: Online::Policy::Rollout::rollout_t<state_t>::evaluate(state_t const&) const
float evaluate(const T &s) const {
        if( base_policy_ == 0 ) {
            std::cout << Utils::error() << "(base) policy must be specified for rollout() policy!" << std::endl;
            exit(1);
        }
        float start_time = Utils::read_time_in_seconds();
        float value = Evaluation::evaluation(*base_policy_, s, 1, depth_);
        policy_t<T>::base_policy_time_ += Utils::read_time_in_seconds() - start_time;
        return value;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xa0, %rsp
cmpq $0x0, 0x28(%rdi)
je 0x1f5a3
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
xorl %edi, %edi
movq %r15, %rsi
callq 0x6190
cvtsi2ssq (%r15), %xmm0
movss %xmm0, 0x4(%rsp)
xorps %xmm0, %xmm0
cvtsi2ssq 0x8(%r15), %xmm0
movss %xmm0, 0xc(%rsp)
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movq %r15, %rsi
callq 0x6190
cvtsi2ssq (%r15), %xmm1
xorps %xmm0, %xmm0
cvtsi2ssq 0x8(%r15), %xmm0
addss 0x4(%rsp), %xmm1
movss %xmm1, 0x8(%rsp)
addss 0xc(%rsp), %xmm0
movss %xmm0, 0x4(%rsp)
movl 0x34(%rbx), %edx
movq 0x28(%rbx), %rdi
movq %r14, %rsi
callq 0x1f63d
movss %xmm0, 0xc(%rsp)
leaq 0x10(%rsp), %r14
xorl %edi, %edi
movq %r14, %rsi
callq 0x6190
xorps %xmm0, %xmm0
cvtsi2ssq (%r14), %xmm0
subss 0x8(%rsp), %xmm0
movss %xmm0, 0x8(%rsp)
xorps %xmm0, %xmm0
cvtsi2ssq 0x8(%r14), %xmm0
subss 0x4(%rsp), %xmm0
movss %xmm0, 0x4(%rsp)
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movq %r14, %rsi
callq 0x6190
xorps %xmm0, %xmm0
cvtsi2ssq (%r14), %xmm0
addss 0x8(%rsp), %xmm0
xorps %xmm1, %xmm1
cvtsi2ssq 0x8(%r14), %xmm1
addss 0x4(%rsp), %xmm1
mulss 0xda82(%rip), %xmm1     # 0x2d004
addss 0x18(%rbx), %xmm0
addss %xmm1, %xmm0
movss %xmm0, 0x18(%rbx)
movss 0xc(%rsp), %xmm0
addq $0xa0, %rsp
popq %rbx
popq %r14
popq %r15
retq
movb 0x1fcaf(%rip), %al      # 0x3f258
testb %al, %al
leaq 0xe447(%rip), %rcx      # 0x2d9f9
leaq 0xe9ae(%rip), %rsi      # 0x2df67
cmovneq %rcx, %rsi
leaq 0x12(%rsi), %rdx
testb %al, %al
leaq 0x20(%rsp), %r14
movq %r14, -0x10(%r14)
cmoveq %rsi, %rdx
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0xe5ba
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq 0x1f9ed(%rip), %rdi     # 0x3efd8
callq 0x62e0
movq %rax, %rbx
leaq 0xecfd(%rip), %rsi      # 0x2e2f7
movl $0x35, %edx
movq %rax, %rdi
callq 0x62e0
movq %rbx, %rdi
callq 0x6150
leaq 0x10(%rsp), %rdi
callq 0x6140
movl $0x1, %edi
callq 0x6310
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x1f635
callq 0x6260
movq %rbx, %rdi
callq 0x6410
// File: /workspace/github_cpp_makefile_star2_O1/bonetblai[P]mdp-engine/ctp3/../engine/uct.h
// Function: Online::Policy::UCT::uct_t<state_t>::evaluate(state_t const&, unsigned int) const
float evaluate(const T &s, unsigned depth) const {
        assert(base_policy_ != 0);
        float start_time = Utils::read_time_in_seconds();
        float value = Evaluation::evaluation(*base_policy_, s, 1, horizon_ - depth);
        policy_t<T>::base_policy_time_ += Utils::read_time_in_seconds() - start_time;
        return value;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xa8, %rsp
cmpq $0x0, 0x28(%rdi)
je 0x219ff
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %r15
xorl %edi, %edi
movq %r15, %rsi
callq 0x6190
cvtsi2ssq (%r15), %xmm0
movss %xmm0, 0xc(%rsp)
xorps %xmm0, %xmm0
cvtsi2ssq 0x8(%r15), %xmm0
movss %xmm0, 0x14(%rsp)
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movq %r15, %rsi
callq 0x6190
xorps %xmm0, %xmm0
cvtsi2ssq (%r15), %xmm0
addss 0xc(%rsp), %xmm0
movss %xmm0, 0x10(%rsp)
xorps %xmm0, %xmm0
cvtsi2ssq 0x8(%r15), %xmm0
addss 0x14(%rsp), %xmm0
movss %xmm0, 0xc(%rsp)
movl 0x34(%rbx), %edx
subl %ebp, %edx
movq 0x28(%rbx), %rdi
movq %r14, %rsi
callq 0x1f63d
movss %xmm0, 0x14(%rsp)
leaq 0x18(%rsp), %r14
xorl %edi, %edi
movq %r14, %rsi
callq 0x6190
xorps %xmm0, %xmm0
cvtsi2ssq (%r14), %xmm0
subss 0x10(%rsp), %xmm0
movss %xmm0, 0x10(%rsp)
xorps %xmm0, %xmm0
cvtsi2ssq 0x8(%r14), %xmm0
subss 0xc(%rsp), %xmm0
movss %xmm0, 0xc(%rsp)
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movq %r14, %rsi
callq 0x6190
xorps %xmm0, %xmm0
cvtsi2ssq (%r14), %xmm0
addss 0x10(%rsp), %xmm0
cvtsi2ssq 0x8(%r14), %xmm1
addss 0xc(%rsp), %xmm1
mulss 0xb627(%rip), %xmm1     # 0x2d004
addss 0x18(%rbx), %xmm0
addss %xmm1, %xmm0
movss %xmm0, 0x18(%rbx)
movss 0x14(%rsp), %xmm0
addq $0xa8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0xcc78(%rip), %rdi      # 0x2e67e
leaq 0xcba8(%rip), %rsi      # 0x2e5b5
leaq 0xcc7c(%rip), %rcx      # 0x2e690
movl $0x141, %edx            # imm = 0x141
callq 0x61c0
// File: /workspace/github_cpp_makefile_star2_O1/bonetblai[P]mdp-engine/ctp3/../engine/bdd_priority_queue.h
// Function: std::bdd_priority_queue<Online::Policy::AOT::node_t<state_t>*, Online::Policy::AOT::min_priority_t<state_t>, Online::Policy::AOT::max_priority_t<state_t>>::~bdd_priority_queue()
~bdd_priority_queue() {
        clear();
        while( pool_ != 0 ) {
            container_t *p = pool_->next_;
            delete pool_;
            pool_ = p;
        }
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x24b08
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x220ec
movq 0x10(%rdi), %r14
callq 0x6260
movq %r14, 0x8(%rbx)
movq %r14, %rdi
testq %r14, %r14
jne 0x220d7
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x220fa
callq 0x6260
movq 0x20(%rbx), %rdi
addq $0x8, %rsp
testq %rdi, %rdi
je 0x2210f
popq %rbx
popq %r14
jmp 0x6260
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0xaf0a
nop
// File: /workspace/github_cpp_makefile_star2_O1/bonetblai[P]mdp-engine/ctp3/../engine/aot.h
// Function: Online::Policy::AOT::aot_t<state_t>::clone() const
virtual policy_t<T>* clone() const {
        return new aot_t(problem_,
                         base_policy_,
                         width_,
                         horizon_,
                         probability_,
                         random_ties_,
                         delayed_evaluation_,
                         expansions_per_iteration_,
                         leaf_nsamples_,
                         delayed_evaluation_nsamples_,
                         leaf_selection_strategy_);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movl $0x1b8, %edi            # imm = 0x1B8
callq 0x6290
movq %rax, %rbx
movq 0x8(%r14), %rsi
movq 0x28(%r14), %rdx
movl 0x30(%r14), %ecx
movl 0x34(%r14), %r8d
movss 0x38(%r14), %xmm0
movzbl 0x3c(%r14), %r9d
movzbl 0x3d(%r14), %eax
movl 0x40(%r14), %r10d
movl 0x44(%r14), %r11d
movl 0x48(%r14), %r15d
movl 0x4c(%r14), %r14d
subq $0x8, %rsp
movq %rbx, %rdi
pushq %r14
pushq %r15
pushq %r11
pushq %r10
pushq %rax
callq 0x26b90
addq $0x30, %rsp
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x6260
movq %r14, %rdi
callq 0x6410
// File: /workspace/github_cpp_makefile_star2_O1/bonetblai[P]mdp-engine/ctp3/../engine/aot.h
// Function: Online::Policy::AOT::aot_t<state_t>::reset_stats() const
virtual void reset_stats() const {
        policy_t<T>::setup_time_ = 0;
        policy_t<T>::base_policy_time_ = 0;
        policy_t<T>::heuristic_time_ = 0;
        problem_.clear_expansions();
        if( base_policy_ != 0 ) base_policy_->reset_stats();
        if( heuristic_ != 0 ) heuristic_->reset_stats();
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
xorl %eax, %eax
movq %rax, 0x14(%rdi)
movl $0x0, 0x1c(%rdi)
movq 0x8(%rdi), %rcx
movq %rax, 0x10(%rcx)
movq 0x28(%rdi), %rdi
testq %rdi, %rdi
je 0x241d2
movq (%rdi), %rax
callq *0x28(%rax)
movq 0x98(%rbx), %rax
testq %rax, %rax
je 0x241ed
movq $0x0, 0x10(%rax)
movl $0x0, 0x18(%rax)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/bonetblai[P]mdp-engine/ctp3/../engine/aot.h
// Function: Online::Policy::AOT::aot_t<state_t>::print_other_stats(std::ostream&, int) const
virtual void print_other_stats(std::ostream &os, int indent) const {
        os << std::setw(indent) << ""
           << "other-stats: name=" << name()
           << " decisions=" << policy_t<T>::decisions_
           << " %in=" << from_inside_ / (from_inside_ + from_outside_)
           << " %out=" << from_outside_ / (from_inside_ + from_outside_)
           << " #expansions=" << total_number_expansions_
           << " #evaluations=" << total_evaluations_
           << std::endl;
        if( base_policy_ != 0 ) base_policy_->print_other_stats(os, 2 + indent);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq (%rsi), %rax
movq -0x18(%rax), %rax
movslq %edx, %rcx
movq %rcx, 0x10(%rsi,%rax)
leaq 0x9d4e(%rip), %rsi      # 0x2df67
movq %r14, %rdi
xorl %edx, %edx
callq 0x62e0
leaq 0x93d7(%rip), %rsi      # 0x2d601
movl $0x12, %edx
movq %r14, %rdi
callq 0x62e0
movq (%r15), %rax
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq *0x18(%rax)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %r14, %rdi
callq 0x62e0
movq %rax, %r12
leaq 0x93b1(%rip), %rsi      # 0x2d614
movl $0xb, %edx
movq %rax, %rdi
callq 0x62e0
movl 0x20(%r15), %esi
movq %r12, %rdi
callq 0x61d0
movq %rax, %r12
leaq 0xbc2c(%rip), %rsi      # 0x2feb2
movl $0x5, %edx
movq %rax, %rdi
callq 0x62e0
movss 0x150(%r15), %xmm0
movss 0x154(%r15), %xmm1
addss %xmm0, %xmm1
divss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
movq %r12, %rdi
callq 0x63b0
movq %rax, %r12
leaq 0xbbf5(%rip), %rsi      # 0x2feb8
movl $0x6, %edx
movq %rax, %rdi
callq 0x62e0
movss 0x154(%r15), %xmm0
movss 0x150(%r15), %xmm1
addss %xmm0, %xmm1
divss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
movq %r12, %rdi
callq 0x63b0
movq %rax, %r12
leaq 0xbbbf(%rip), %rsi      # 0x2febf
movl $0xd, %edx
movq %rax, %rdi
callq 0x62e0
movl 0x160(%r15), %esi
movq %r12, %rdi
callq 0x61d0
movq %rax, %r12
leaq 0xbba7(%rip), %rsi      # 0x2fecd
movl $0xe, %edx
movq %rax, %rdi
callq 0x62e0
movl 0x164(%r15), %esi
movq %r12, %rdi
callq 0x61d0
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x6270
movsbl %al, %esi
movq %r12, %rdi
callq 0x6040
movq %rax, %rdi
callq 0x61e0
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2437f
callq 0x6260
movq 0x28(%r15), %rdi
testq %rdi, %rdi
je 0x24396
addl $0x2, %ebx
movq (%rdi), %rax
movq %r14, %rsi
movl %ebx, %edx
callq *0x30(%rax)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x243b8
callq 0x6260
movq %rbx, %rdi
callq 0x6410
// File: /workspace/github_cpp_makefile_star2_O1/bonetblai[P]mdp-engine/ctp3/../engine/bdd_priority_queue.h
// Function: std::bdd_priority_queue<Online::Policy::AOT::node_t<state_t>*, Online::Policy::AOT::min_priority_t<state_t>, Online::Policy::AOT::max_priority_t<state_t>>::clear()
void clear() {
        for( unsigned index = 1; index <= max_size_; ++index ) {
            max_array_[index]->next_ = pool_;
            pool_ = max_array_[index];
            max_array_[index] = 0;
        }
        max_size_ = 0;

        memset(&min_array_[0], 0, (1 + capacity_) * sizeof(unsigned));
        min_size_ = 0;

        assert(check());
    }

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x18(%rdi), %ecx
testl %ecx, %ecx
je 0x24b4f
incl %ecx
cmpl $0x3, %ecx
movl $0x2, %eax
cmovael %ecx, %eax
movl $0x1, %ecx
movq 0x8(%rbx), %rdx
movq 0x20(%rbx), %rsi
movq (%rsi,%rcx,8), %rdi
movq %rdx, 0x10(%rdi)
movq (%rsi,%rcx,8), %rdx
movq %rdx, 0x8(%rbx)
movq $0x0, (%rsi,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0x24b27
xorl %ebp, %ebp
movl %ebp, 0x18(%rbx)
movq 0x40(%rbx), %rdi
movl 0x4(%rbx), %edx
incl %edx
shlq $0x2, %rdx
xorl %esi, %esi
callq 0x6180
movl %ebp, 0x38(%rbx)
movq %rbx, %rdi
callq 0x24be2
testb %al, %al
je 0x24b8a
movq %rbx, %rdi
callq 0x24d5a
testb %al, %al
je 0x24b8a
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x9c21(%rip), %rdi      # 0x2e7b2
leaq 0x9c22(%rip), %rsi      # 0x2e7ba
leaq 0x9c3a(%rip), %rcx      # 0x2e7d9
movl $0x12f, %edx            # imm = 0x12F
callq 0x61c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/bonetblai[P]mdp-engine/ctp3/../engine/bdd_priority_queue.h
// Function: std::bdd_priority_queue<Online::Policy::AOT::node_t<state_t>*, Online::Policy::AOT::min_priority_t<state_t>, Online::Policy::AOT::max_priority_t<state_t>>::check_max() const
bool check_max() const {
        // check heap property
        for( unsigned index = 1; index <= max_size_; ++index ) {
            if( !check_min_heap_property(index) ) {
                std::cout << "heap property violated at max_array[index=" << index << "]" << std::endl;
                return false;
            }
        }

        // check invariants for xrefs
        for( unsigned index = 1; index <= max_size_; ++index ) {
            if( !check_max_invariant(index) ) {
                std::cout << "invariant violated for max_array[index=" << index << "]" << std::endl;
                return false;
            }
        }

        // all tests passed, declare it sound
        return true;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0x18(%rdi)
sete %r12b
je 0x24ca0
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x24ed2
movl $0x1, %r14d
testb %al, %al
je 0x24c33
incl %ebp
cmpl 0x18(%rbx), %ebp
seta %r12b
ja 0x24ca0
movq %rbx, %rdi
movl %ebp, %esi
callq 0x24ed2
testb %al, %al
jne 0x24c17
movl %ebp, %r14d
movq 0x1a39e(%rip), %r15     # 0x3efd8
leaq 0x9ce5(%rip), %rsi      # 0x2e926
movl $0x2a, %edx
movq %r15, %rdi
callq 0x62e0
movq %r15, %rdi
movq %r14, %rsi
callq 0x61d0
movq %rax, %r14
leaq 0xa092(%rip), %rsi      # 0x2ecf5
movl $0x1, %edx
movq %rax, %rdi
callq 0x62e0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x6270
movsbl %al, %esi
movq %r14, %rdi
callq 0x6040
movq %rax, %rdi
callq 0x61e0
testb %r12b, %r12b
je 0x24d4c
movl 0x18(%rbx), %eax
testl %eax, %eax
sete %bpl
je 0x24d4e
movq 0x20(%rbx), %rcx
movq 0x40(%rbx), %rdx
movq 0x8(%rcx), %rsi
movl 0x8(%rsi), %esi
movl $0x1, %ebx
cmpl $0x1, (%rdx,%rsi,4)
jne 0x24ce6
movl $0x1, %esi
incl %esi
cmpl %eax, %esi
seta %bpl
ja 0x24d4e
movl %esi, %ebx
movq (%rcx,%rbx,8), %rdi
movl 0x8(%rdi), %edi
cmpl (%rdx,%rdi,4), %esi
je 0x24cce
movq 0x1a2eb(%rip), %r14     # 0x3efd8
leaq 0x9c5d(%rip), %rsi      # 0x2e951
movl $0x27, %edx
movq %r14, %rdi
callq 0x62e0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x61d0
movq %rax, %rbx
leaq 0x9fdf(%rip), %rsi      # 0x2ecf5
movl $0x1, %edx
movq %rax, %rdi
callq 0x62e0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x6270
movsbl %al, %esi
movq %rbx, %rdi
callq 0x6040
movq %rax, %rdi
callq 0x61e0
jmp 0x24d4e
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/bonetblai[P]mdp-engine/ctp3/../engine/bdd_priority_queue.h
// Function: std::bdd_priority_queue<Online::Policy::AOT::node_t<state_t>*, Online::Policy::AOT::min_priority_t<state_t>, Online::Policy::AOT::max_priority_t<state_t>>::check_min() const
bool check_min() const {
        // check heap property in min_array
        for( unsigned index = 1; index <= min_size_; ++index ) {
            if( !check_min_heap_property(index) ) {
                std::cout << "heap property violated at min_array[index=" << index << "]" << std::endl;
                return false;
            }
        }

        // check invariants for xrefs in min_array
        for( unsigned index = 1; index <= min_size_; ++index ) {
            if( !check_min_invariant(index) ) {
                std::cout << "invariant violated for min_array[index=" << index << "]" << std::endl;
                return false;
            }
        }

        // all tests passed, declare it sound
        return true;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0x38(%rdi)
sete %r12b
je 0x24e18
movl $0x1, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x24ed2
movl $0x1, %r14d
testb %al, %al
je 0x24dab
incl %ebp
cmpl 0x38(%rbx), %ebp
seta %r12b
ja 0x24e18
movq %rbx, %rdi
movl %ebp, %esi
callq 0x24ed2
testb %al, %al
jne 0x24d8f
movl %ebp, %r14d
movq 0x1a226(%rip), %r15     # 0x3efd8
leaq 0x9bc0(%rip), %rsi      # 0x2e979
movl $0x2a, %edx
movq %r15, %rdi
callq 0x62e0
movq %r15, %rdi
movq %r14, %rsi
callq 0x61d0
movq %rax, %r14
leaq 0x9f1a(%rip), %rsi      # 0x2ecf5
movl $0x1, %edx
movq %rax, %rdi
callq 0x62e0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x6270
movsbl %al, %esi
movq %r14, %rdi
callq 0x6040
movq %rax, %rdi
callq 0x61e0
testb %r12b, %r12b
je 0x24ec4
movl 0x38(%rbx), %eax
testl %eax, %eax
sete %bpl
je 0x24ec6
movq 0x20(%rbx), %rcx
movq 0x40(%rbx), %rdx
movl 0x4(%rdx), %esi
movq (%rcx,%rsi,8), %rsi
movl $0x1, %ebx
cmpl $0x1, 0x8(%rsi)
jne 0x24e5e
movl $0x1, %esi
incl %esi
cmpl %eax, %esi
seta %bpl
ja 0x24ec6
movl %esi, %ebx
movl (%rdx,%rbx,4), %edi
movq (%rcx,%rdi,8), %rdi
cmpl 0x8(%rdi), %esi
je 0x24e46
movq 0x1a173(%rip), %r14     # 0x3efd8
leaq 0x9b38(%rip), %rsi      # 0x2e9a4
movl $0x27, %edx
movq %r14, %rdi
callq 0x62e0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x61d0
movq %rax, %rbx
leaq 0x9e67(%rip), %rsi      # 0x2ecf5
movl $0x1, %edx
movq %rax, %rdi
callq 0x62e0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x6270
movsbl %al, %esi
movq %rbx, %rdi
callq 0x6040
movq %rax, %rdi
callq 0x61e0
jmp 0x24ec6
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/bonetblai[P]mdp-engine/ctp3/../engine/bdd_priority_queue.h
// Function: std::bdd_priority_queue<Online::Policy::AOT::node_t<state_t>*, Online::Policy::AOT::min_priority_t<state_t>, Online::Policy::AOT::max_priority_t<state_t>>::check_min_heap_property(unsigned int) const
bool check_min_heap_property(unsigned index) const {
        unsigned left = index << 1, right = 1 + left;
        if( (left <= min_size_) &&
            min_cmpfn_(max_array_[min_array_[index]]->element_, max_array_[min_array_[left]]->element_) ) {
            return false;
        }
        if( (right <= min_size_) &&
            min_cmpfn_(max_array_[min_array_[index]]->element_, max_array_[min_array_[right]]->element_) ) {
            return false;
        }
        return true;
    }

// Assembly:
leal (%rsi,%rsi), %eax
movl 0x38(%rdi), %ecx
cmpl %ecx, %eax
ja 0x24f1c
movl %esi, %edx
movq 0x20(%rdi), %r8
movq 0x40(%rdi), %r9
movl (%r9,%rdx,4), %edx
movq (%r8,%rdx,8), %rdx
movq (%rdx), %rdx
movl %eax, %r10d
movl (%r9,%r10,4), %r9d
movq (%r8,%r9,8), %r8
movq (%r8), %r8
movss 0xc(%rdx), %xmm0
movaps 0x8195(%rip), %xmm1     # 0x2d0a0
andps %xmm1, %xmm0
movss 0xc(%r8), %xmm2
andps %xmm1, %xmm2
ucomiss %xmm0, %xmm2
ja 0x24f63
cmpl %ecx, %eax
jae 0x24f66
leal 0x1(,%rsi,2), %eax
movl %esi, %ecx
movq 0x20(%rdi), %rdx
movq 0x40(%rdi), %rsi
movl (%rsi,%rcx,4), %ecx
movq (%rdx,%rcx,8), %rcx
movq (%rcx), %rcx
movl %eax, %eax
movl (%rsi,%rax,4), %eax
movq (%rdx,%rax,8), %rax
movq (%rax), %rax
movss 0xc(%rcx), %xmm0
movaps 0x814d(%rip), %xmm1     # 0x2d0a0
andps %xmm1, %xmm0
movss 0xc(%rax), %xmm2
andps %xmm1, %xmm2
ucomiss %xmm0, %xmm2
jbe 0x24f66
xorl %eax, %eax
retq
movb $0x1, %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/bonetblai[P]mdp-engine/ctp3/../engine/aot.h
// Function: Online::Policy::AOT::aot_t<state_t>::random_prepare_next_expansion_iteration(Online::Policy::AOT::state_node_t<state_t>*) const
void random_prepare_next_expansion_iteration(state_node_t<T> *node) const {
        if( node->is_leaf() ) {
            if( !node->is_goal_ && !node->is_dead_end_ && (node->depth_ < horizon_) ) {
                if( (random_leaf_ == 0) || (Random::real() < 0.5) )
                    random_leaf_ = node;
            }
        } else {
            assert(!node->children_.empty());
            for( int i = 0, isz = node->children_.size(); i < isz; ++i ) {
                action_node_t<T> *a_node = node->children_[i];
                assert(!a_node->children_.empty());
                for( int j = 0, jsz = a_node->children_.size(); j < jsz; ++j ) {
                    state_node_t<T> *s_node = a_node->children_[j].second;
                    random_prepare_next_expansion_iteration(s_node);
                }
            }
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
movb 0x89(%rsi), %al
testb %al, %al
jne 0x25040
cmpb $0x0, 0x88(%r15)
jne 0x25040
movq 0xa8(%r15), %rcx
cmpq 0xb0(%r15), %rcx
je 0x25040
movq 0xa8(%r15), %rax
movq 0xb0(%r15), %rbx
cmpq %rbx, %rax
je 0x250a7
subq %rax, %rbx
shrq $0x3, %rbx
testl %ebx, %ebx
jle 0x25079
andl $0x7fffffff, %ebx       # imm = 0x7FFFFFFF
xorl %r12d, %r12d
movq %r15, (%rsp)
movq 0xa8(%r15), %rax
movq (%rax,%r12,8), %r13
movq 0x28(%r13), %rax
movq 0x30(%r13), %rbp
cmpq %rbp, %rax
je 0x25088
subq %rax, %rbp
shrq $0x4, %rbp
testl %ebp, %ebp
jle 0x25032
andl $0x7fffffff, %ebp       # imm = 0x7FFFFFFF
movl $0x8, %r15d
movq 0x28(%r13), %rax
movq (%rax,%r15), %rsi
movq %r14, %rdi
callq 0x24f72
addq $0x10, %r15
decq %rbp
jne 0x25019
incq %r12
cmpq %rbx, %r12
movq (%rsp), %r15
jne 0x24fe6
jmp 0x25079
orb 0x88(%r15), %al
jne 0x25079
movl 0x8c(%r15), %eax
cmpl 0x34(%r14), %eax
jae 0x25079
cmpq $0x0, 0x158(%r14)
je 0x25072
callq 0x6250
cvtsd2ss %xmm0, %xmm0
ucomiss 0x7fac(%rip), %xmm0     # 0x2d01c
jae 0x25079
movq %r15, 0x158(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x99df(%rip), %rdi      # 0x2ea6e
leaq 0x994f(%rip), %rsi      # 0x2e9e5
leaq 0x9958(%rip), %rcx      # 0x2e9f5
movl $0x445, %edx            # imm = 0x445
callq 0x61c0
leaq 0x991e(%rip), %rdi      # 0x2e9cc
leaq 0x9930(%rip), %rsi      # 0x2e9e5
leaq 0x9939(%rip), %rcx      # 0x2e9f5
movl $0x442, %edx            # imm = 0x442
callq 0x61c0
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsp, %r14
movq %rsi, (%r14)
addq $0xa0, %rdi
movq %r14, %rsi
callq 0x252d2
movq (%r14), %rcx
movl %eax, %edx
andb $0x1, %dl
movb %dl, 0x16(%rcx)
btl $0x8, %eax
jae 0x25201
movq 0xb0(%rbx), %rax
testq %rax, %rax
je 0x25209
cmpb $0x0, 0x16(%rax)
je 0x25228
movb $0x0, 0x16(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x98fd(%rip), %rdi      # 0x2eb0d
leaq 0x97ce(%rip), %rsi      # 0x2e9e5
leaq 0x98fc(%rip), %rcx      # 0x2eb1a
movl $0x3d0, %edx            # imm = 0x3D0
callq 0x61c0
leaq 0x9958(%rip), %rdi      # 0x2eb87
leaq 0x97af(%rip), %rsi      # 0x2e9e5
leaq 0x98dd(%rip), %rcx      # 0x2eb1a
movl $0x3d1, %edx            # imm = 0x3D1
callq 0x61c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsp, %r14
movq %rsi, (%r14)
addq $0xf8, %rdi
movq %r14, %rsi
callq 0x252d2
movq (%r14), %rcx
movl %eax, %edx
andb $0x1, %dl
movb %dl, 0x16(%rcx)
btl $0x8, %eax
jae 0x2528b
movq 0x108(%rbx), %rax
testq %rax, %rax
je 0x25293
cmpb $0x0, 0x16(%rax)
je 0x252b2
movb $0x0, 0x16(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x9873(%rip), %rdi      # 0x2eb0d
leaq 0x9744(%rip), %rsi      # 0x2e9e5
leaq 0x9dfe(%rip), %rcx      # 0x2f0a6
movl $0x3df, %edx            # imm = 0x3DF
callq 0x61c0
leaq 0x98ce(%rip), %rdi      # 0x2eb87
leaq 0x9725(%rip), %rsi      # 0x2e9e5
leaq 0x9ddf(%rip), %rcx      # 0x2f0a6
movl $0x3e0, %edx            # imm = 0x3E0
callq 0x61c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbx
movq %rsi, %rbx
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x2546c
movq 0x10(%rax), %rcx
movq %rcx, 0x8(%rdi)
movq (%rbx), %rcx
movq %rcx, (%rax)
movq $0x0, 0x10(%rax)
movl $0x0, 0x8(%rax)
jmp 0x2548b
movl $0x18, %edi
callq 0x6290
movq (%rbx), %rcx
movq %rcx, (%rax)
movl $0x0, 0x8(%rax)
movq $0x0, 0x10(%rax)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbx
movq %rdx, %rax
movq %rdi, %rbx
cmpl $0x2, %esi
jb 0x254ec
movaps 0x7bff(%rip), %xmm0     # 0x2d0a0
movl %esi, %edx
shrl %edx
movq 0x20(%rbx), %rcx
movq (%rcx,%rdx,8), %rdi
movq (%rdi), %r8
movq (%rax), %r9
movss 0xc(%r8), %xmm1
andps %xmm0, %xmm1
movss 0xc(%r9), %xmm2
andps %xmm0, %xmm2
ucomiss %xmm2, %xmm1
jbe 0x254ec
movl %esi, %r8d
movq %rdi, (%rcx,%r8,8)
movq 0x20(%rbx), %rcx
movq 0x40(%rbx), %rdi
movq (%rcx,%r8,8), %rcx
movl 0x8(%rcx), %ecx
movl %esi, (%rdi,%rcx,4)
cmpl $0x3, %esi
movl %edx, %esi
ja 0x254a3
jmp 0x254ee
movl %esi, %edx
movl %edx, %ecx
movq 0x20(%rbx), %rsi
movq %rax, (%rsi,%rcx,8)
movl 0x8(%rax), %eax
testq %rax, %rax
je 0x25509
movq 0x40(%rbx), %rcx
movl %edx, (%rcx,%rax,4)
jmp 0x25519
movl 0x38(%rbx), %esi
incl %esi
movq %rbx, %rdi
callq 0x25764
incl 0x38(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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>>::heapify_min(unsigned int)
void heapify_min(unsigned index) {
        assert((index > 0) && (index <= min_size_));
        unsigned left = index << 1, right = 1 + left, largest = 0;

        if( (left <= min_size_) &&
            min_cmpfn_(max_array_[min_array_[index]]->element_, max_array_[min_array_[left]]->element_) ) {
            largest = left;
        } else {
            largest = index;
        }
        if( (right <= min_size_) &&
            min_cmpfn_(max_array_[min_array_[largest]]->element_, max_array_[min_array_[right]]->element_) ) {
            largest = right;
        }

        if( largest != index ) {
            unsigned tmp = min_array_[largest];
            min_array_[largest] = min_array_[index];
            min_array_[index] = tmp;
            max_array_[min_array_[largest]]->xref_ = largest;
            max_array_[min_array_[index]]->xref_ = index;
            heapify_min(largest);
        }
    }

// Assembly:
pushq %rax
movaps 0x7b7c(%rip), %xmm0     # 0x2d0a0
testl %esi, %esi
je 0x25606
movl 0x38(%rdi), %edx
cmpl %esi, %edx
jb 0x25606
leal (%rsi,%rsi), %r8d
movl %esi, %eax
cmpl %edx, %r8d
ja 0x2557c
movq 0x20(%rdi), %rcx
movq 0x40(%rdi), %r9
movl (%r9,%rax,4), %r10d
movq (%rcx,%r10,8), %r10
movq (%r10), %r10
movl %r8d, %r11d
movl (%r9,%r11,4), %r9d
movq (%rcx,%r9,8), %rcx
movq (%rcx), %rcx
movss 0xc(%r10), %xmm1
andps %xmm0, %xmm1
movss 0xc(%rcx), %xmm2
andps %xmm0, %xmm2
ucomiss %xmm1, %xmm2
movl %r8d, %ecx
ja 0x2557e
movl %esi, %ecx
cmpl %edx, %r8d
jae 0x255c9
leal 0x1(,%rsi,2), %edx
movl %ecx, %r8d
movq 0x20(%rdi), %r9
movq 0x40(%rdi), %r10
movl (%r10,%r8,4), %r8d
movq (%r9,%r8,8), %r8
movq (%r8), %r8
movl %edx, %r11d
movl (%r10,%r11,4), %r10d
movq (%r9,%r10,8), %r9
movq (%r9), %r9
movss 0xc(%r8), %xmm1
andps %xmm0, %xmm1
movss 0xc(%r9), %xmm2
andps %xmm0, %xmm2
ucomiss %xmm1, %xmm2
ja 0x255c7
movl %ecx, %edx
movl %edx, %ecx
cmpl %esi, %ecx
je 0x25604
movl %ecx, %edx
movq 0x40(%rdi), %r8
movl (%r8,%rdx,4), %r9d
movl (%r8,%rax,4), %r10d
movl %r10d, (%r8,%rdx,4)
movl %r9d, (%r8,%rax,4)
movl (%r8,%rdx,4), %edx
movq 0x20(%rdi), %r9
movq (%r9,%rdx,8), %rdx
movl %ecx, 0x8(%rdx)
movl (%r8,%rax,4), %eax
movq (%r9,%rax,8), %rax
movl %esi, 0x8(%rax)
movl %ecx, %esi
jmp 0x25524
popq %rax
retq
leaq 0x970b(%rip), %rdi      # 0x2ed18
leaq 0x91a6(%rip), %rsi      # 0x2e7ba
leaq 0x9721(%rip), %rcx      # 0x2ed3c
movl $0xf7, %edx
callq 0x61c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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>>::remove_from_max(unsigned int)
void remove_from_max(unsigned index) {
        if( !is_leaf_in_max(index) ) {
            unsigned leaf = max_subtree_leaf(index);
            assert(is_leaf_in_max(leaf));
            assert(!max_cmpfn_(max_array_[index]->element_, max_array_[leaf]->element_));
            assert(!min_cmpfn_(max_array_[index]->element_, max_array_[leaf]->element_));
            assert(max_array_[index]->xref_ == 1);
            max_array_[index]->xref_ = max_array_[leaf]->xref_;
            min_array_[max_array_[index]->xref_] = index;
            index = leaf;
        }

        // link pool of available containers
        max_array_[index]->next_ = pool_;
        pool_ = max_array_[index];

        // remove container from heap
        if( index != max_size_ ) {
            push_max(index, max_array_[max_size_]);
        }
        --max_size_;
        assert(check());
    }

// Assembly:
pushq %rbx
movl %esi, %eax
movq %rdi, %rbx
leal (%rax,%rax), %edx
movl 0x18(%rdi), %ecx
cmpl %ecx, %edx
jbe 0x2563a
movl %eax, %esi
jmp 0x2569d
movl %eax, %edx
movl %edx, %esi
leal (%rsi,%rsi), %edx
cmpl %ecx, %edx
jbe 0x2563c
movl %eax, %ecx
movq 0x20(%rbx), %rdx
movq (%rdx,%rcx,8), %rcx
movq (%rcx), %rdi
movl %esi, %r8d
movq (%rdx,%r8,8), %rdx
movq (%rdx), %r8
movss 0xc(%rdi), %xmm0
movaps 0x7a38(%rip), %xmm2     # 0x2d0a0
andps %xmm2, %xmm0
movss 0xc(%r8), %xmm1
andps %xmm2, %xmm1
ucomiss %xmm1, %xmm0
ja 0x25706
ucomiss %xmm0, %xmm1
ja 0x25725
cmpl $0x1, 0x8(%rcx)
jne 0x25744
movl 0x8(%rdx), %edx
movl %edx, 0x8(%rcx)
movq 0x40(%rbx), %rcx
movl %eax, (%rcx,%rdx,4)
movl %esi, %ecx
movq 0x8(%rbx), %rdx
movq 0x20(%rbx), %rax
movq (%rax,%rcx,8), %rdi
movq %rdx, 0x10(%rdi)
movq (%rax,%rcx,8), %rcx
movq %rcx, 0x8(%rbx)
movl 0x18(%rbx), %ecx
cmpl %ecx, %esi
je 0x256ca
movq (%rax,%rcx,8), %rdx
movq %rbx, %rdi
callq 0x2548e
decl 0x18(%rbx)
movq %rbx, %rdi
callq 0x24be2
testb %al, %al
je 0x256e7
movq %rbx, %rdi
callq 0x24d5a
testb %al, %al
je 0x256e7
popq %rbx
retq
leaq 0x90c4(%rip), %rdi      # 0x2e7b2
leaq 0x90c5(%rip), %rsi      # 0x2e7ba
leaq 0x979f(%rip), %rcx      # 0x2ee9b
movl $0xb7, %edx
callq 0x61c0
leaq 0x98f1(%rip), %rdi      # 0x2effe
leaq 0x90a6(%rip), %rsi      # 0x2e7ba
leaq 0x9780(%rip), %rcx      # 0x2ee9b
movl $0xa6, %edx
callq 0x61c0
leaq 0x9917(%rip), %rdi      # 0x2f043
leaq 0x9087(%rip), %rsi      # 0x2e7ba
leaq 0x9761(%rip), %rcx      # 0x2ee9b
movl $0xa7, %edx
callq 0x61c0
leaq 0x993d(%rip), %rdi      # 0x2f088
leaq 0x9068(%rip), %rsi      # 0x2e7ba
leaq 0x9742(%rip), %rcx      # 0x2ee9b
movl $0xa8, %edx
callq 0x61c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbx
movl %edx, %eax
cmpl $0x2, %esi
jb 0x257bd
movq 0x20(%rdi), %r8
movq 0x40(%rdi), %r9
movq (%r8,%rax,8), %rcx
movq (%rcx), %rcx
movss 0xc(%rcx), %xmm0
andps 0x7919(%rip), %xmm0     # 0x2d0a0
movaps 0x7912(%rip), %xmm1     # 0x2d0a0
movl %esi, %ecx
shrl %ecx
movl (%r9,%rcx,4), %r10d
movq (%r8,%r10,8), %r11
movq (%r11), %rbx
movss 0xc(%rbx), %xmm2
andps %xmm1, %xmm2
ucomiss %xmm2, %xmm0
jbe 0x257bd
movl %esi, %ebx
movl %r10d, (%r9,%rbx,4)
movl %esi, 0x8(%r11)
cmpl $0x3, %esi
movl %ecx, %esi
ja 0x25790
jmp 0x257bf
movl %esi, %ecx
movl %ecx, %esi
movq 0x40(%rdi), %r8
movl %edx, (%r8,%rsi,4)
movq 0x20(%rdi), %rdx
movq (%rdx,%rax,8), %rax
movl %ecx, 0x8(%rax)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbx
cmpl $0x0, 0x18(%rdi)
je 0x25b5a
movq %rdi, %rbx
movq 0x20(%rdi), %rax
movq 0x8(%rax), %rax
movl 0x8(%rax), %esi
callq 0x25b7a
movq 0x8(%rbx), %rax
movq 0x20(%rbx), %rcx
movq 0x8(%rcx), %rdx
movq %rax, 0x10(%rdx)
movq 0x8(%rcx), %rax
movq %rax, 0x8(%rbx)
movl 0x18(%rbx), %eax
movq (%rcx,%rax,8), %rax
movq %rax, 0x8(%rcx)
movq 0x20(%rbx), %rax
movq 0x40(%rbx), %rcx
movq 0x8(%rax), %rax
movl 0x8(%rax), %eax
movl $0x1, (%rcx,%rax,4)
decl 0x18(%rbx)
je 0x25b21
movq %rbx, %rdi
movl $0x1, %esi
callq 0x25c84
movq %rbx, %rdi
callq 0x24be2
testb %al, %al
je 0x25b3b
movq %rbx, %rdi
callq 0x24d5a
testb %al, %al
je 0x25b3b
popq %rbx
retq
leaq 0x8c70(%rip), %rdi      # 0x2e7b2
leaq 0x8c71(%rip), %rsi      # 0x2e7ba
leaq 0x963e(%rip), %rcx      # 0x2f18e
movl $0x161, %edx            # imm = 0x161
callq 0x61c0
leaq 0x961f(%rip), %rdi      # 0x2f180
leaq 0x8c52(%rip), %rsi      # 0x2e7ba
leaq 0x961f(%rip), %rcx      # 0x2f18e
movl $0x155, %edx            # imm = 0x155
callq 0x61c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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>>::remove_from_min(unsigned int)
void remove_from_min(unsigned index) {
        if( !is_leaf_in_min(index) ) {
            unsigned leaf = min_subtree_leaf(index);
            assert(is_leaf_in_min(leaf));
            assert(!max_cmpfn_(max_array_[min_array_[index]]->element_, max_array_[min_array_[leaf]]->element_));
            assert(!min_cmpfn_(max_array_[min_array_[index]]->element_, max_array_[min_array_[leaf]]->element_));
            max_array_[min_array_[index]]->xref_ = leaf;
            max_array_[min_array_[leaf]]->xref_ = index;
            unsigned aux_index = min_array_[index];
            min_array_[index] = min_array_[leaf];
            min_array_[leaf] = aux_index;
            index = leaf;
        }

        if( index != min_size_ ) {
            push_min(index, min_array_[min_size_]);
        }
        --min_size_;
        assert(check_min());
    }

// Assembly:
pushq %rbx
movl %esi, %eax
movq %rdi, %rbx
leal (%rax,%rax), %edx
movl 0x38(%rdi), %ecx
cmpl %ecx, %edx
jbe 0x25b8e
movl %eax, %esi
jmp 0x25c00
movl %eax, %edx
movl %edx, %esi
leal (%rsi,%rsi), %edx
cmpl %ecx, %edx
jbe 0x25b90
movl %eax, %ecx
movq 0x20(%rbx), %rdi
movq 0x40(%rbx), %rdx
movl (%rdx,%rcx,4), %r8d
movq (%rdi,%r8,8), %r9
movq (%r9), %r10
movl %esi, %r8d
movl (%rdx,%r8,4), %r11d
movq (%rdi,%r11,8), %r11
movq (%r11), %r11
movss 0xc(%r10), %xmm0
movaps 0x74d7(%rip), %xmm2     # 0x2d0a0
andps %xmm2, %xmm0
movss 0xc(%r11), %xmm1
andps %xmm2, %xmm1
ucomiss %xmm1, %xmm0
ja 0x25c46
ucomiss %xmm0, %xmm1
ja 0x25c65
movl %esi, 0x8(%r9)
movl (%rdx,%r8,4), %r9d
movq (%rdi,%r9,8), %rdi
movl %eax, 0x8(%rdi)
movl (%rdx,%rcx,4), %eax
movl (%rdx,%r8,4), %edi
movl %edi, (%rdx,%rcx,4)
movl %eax, (%rdx,%r8,4)
movl 0x38(%rbx), %eax
cmpl %eax, %esi
je 0x25c16
movq 0x40(%rbx), %rcx
movl (%rcx,%rax,4), %edx
movq %rbx, %rdi
callq 0x25764
decl 0x38(%rbx)
movq %rbx, %rdi
callq 0x24d5a
testb %al, %al
je 0x25c27
popq %rbx
retq
leaq 0x98c8(%rip), %rdi      # 0x2f4f6
leaq 0x8b85(%rip), %rsi      # 0x2e7ba
leaq 0x969d(%rip), %rcx      # 0x2f2d9
movl $0xf3, %edx
callq 0x61c0
leaq 0x97ef(%rip), %rdi      # 0x2f43c
leaq 0x8b66(%rip), %rsi      # 0x2e7ba
leaq 0x967e(%rip), %rcx      # 0x2f2d9
movl $0xe5, %edx
callq 0x61c0
leaq 0x982d(%rip), %rdi      # 0x2f499
leaq 0x8b47(%rip), %rsi      # 0x2e7ba
leaq 0x965f(%rip), %rcx      # 0x2f2d9
movl $0xe6, %edx
callq 0x61c0
// File: /workspace/github_cpp_makefile_star2_O1/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>>::heapify_max(unsigned int)
void heapify_max(unsigned index) {
        assert((index > 0) && (index <= max_size_));
        unsigned left = index << 1, right = 1 + left, largest = 0;

        if( (left <= max_size_) && max_cmpfn_(max_array_[index]->element_, max_array_[left]->element_) ) {
            largest = left;
        } else {
            largest = index;
        }
        if( (right <= max_size_) && max_cmpfn_(max_array_[largest]->element_, max_array_[right]->element_) ) {
            largest = right;
        }

        if( largest != index ) {
            container_t *tmp = max_array_[largest];
            max_array_[largest] = max_array_[index];
            max_array_[index] = tmp;
            min_array_[max_array_[largest]->xref_] = largest;
            min_array_[max_array_[index]->xref_] = index;
            heapify_max(largest);
        }
    }

// Assembly:
pushq %rax
movaps 0x7414(%rip), %xmm0     # 0x2d0a0
testl %esi, %esi
je 0x25d5e
movl 0x18(%rdi), %edx
cmpl %esi, %edx
jb 0x25d5e
leal (%rsi,%rsi), %r8d
movl %esi, %eax
cmpl %edx, %r8d
ja 0x25cd8
movq 0x20(%rdi), %rcx
movq (%rcx,%rax,8), %r9
movq (%r9), %r9
movl %r8d, %r10d
movq (%rcx,%r10,8), %rcx
movq (%rcx), %rcx
movss 0xc(%r9), %xmm1
andps %xmm0, %xmm1
movss 0xc(%rcx), %xmm2
andps %xmm0, %xmm2
ucomiss %xmm2, %xmm1
movl %r8d, %ecx
ja 0x25cda
movl %esi, %ecx
cmpl %edx, %r8d
jae 0x25d19
leal 0x1(,%rsi,2), %edx
movl %ecx, %r8d
movq 0x20(%rdi), %r9
movq (%r9,%r8,8), %r8
movq (%r8), %r8
movl %edx, %r10d
movq (%r9,%r10,8), %r9
movq (%r9), %r9
movss 0xc(%r8), %xmm1
andps %xmm0, %xmm1
movss 0xc(%r9), %xmm2
andps %xmm0, %xmm2
ucomiss %xmm2, %xmm1
ja 0x25d17
movl %ecx, %edx
movl %edx, %ecx
cmpl %esi, %ecx
je 0x25d5c
movl %ecx, %edx
movq 0x20(%rdi), %r8
movq (%r8,%rdx,8), %r9
movq (%r8,%rax,8), %r10
movq %r10, (%r8,%rdx,8)
movq 0x20(%rdi), %r8
movq %r9, (%r8,%rax,8)
movq 0x20(%rdi), %r8
movq 0x40(%rdi), %r9
movq (%r8,%rdx,8), %rdx
movl 0x8(%rdx), %edx
movl %ecx, (%r9,%rdx,4)
movq (%r8,%rax,8), %rax
movl 0x8(%rax), %eax
movl %esi, (%r9,%rax,4)
movl %ecx, %esi
jmp 0x25c8c
popq %rax
retq
leaq 0x979d(%rip), %rdi      # 0x2f502
leaq 0x8a4e(%rip), %rsi      # 0x2e7ba
leaq 0x97b3(%rip), %rcx      # 0x2f526
movl $0xbb, %edx
callq 0x61c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0xf8, %rdi
movq 0x118(%rbx), %rax
movq 0x8(%rax), %rax
movq (%rax), %r14
callq 0x25ab8
cmpb $0x0, 0x16(%r14)
je 0x26a9e
movb $0x0, 0x16(%r14)
movss 0x154(%rbx), %xmm0
addss 0x657d(%rip), %xmm0     # 0x2d008
movss %xmm0, 0x154(%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x866f(%rip), %rdi      # 0x2f114
leaq 0x7f39(%rip), %rsi      # 0x2e9e5
leaq 0x8e50(%rip), %rcx      # 0x2f903
movl $0x413, %edx            # imm = 0x413
callq 0x61c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0xa0, %rdi
movq 0xc0(%rbx), %rax
movq 0x8(%rax), %rax
movq (%rax), %r14
callq 0x25ab8
cmpb $0x0, 0x16(%r14)
je 0x26b0e
movb $0x0, 0x16(%r14)
movss 0x150(%rbx), %xmm0
addss 0x650d(%rip), %xmm0     # 0x2d008
movss %xmm0, 0x150(%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x85ff(%rip), %rdi      # 0x2f114
leaq 0x7ec9(%rip), %rsi      # 0x2e9e5
leaq 0x8e3a(%rip), %rcx      # 0x2f95d
movl $0x405, %edx            # imm = 0x405
callq 0x61c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %esi, %ebx
movq %rdi, %r14
xorps %xmm0, %xmm0
movq %rsp, %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0xb0(%r14), %rax
subq 0xa8(%r14), %rax
sarq $0x3, %rax
testl %esi, %esi
movl $0x1, %esi
cmovneq %rax, %rsi
callq 0xd076
movq 0xb0(%r14), %rax
subq 0xa8(%r14), %rax
shrq $0x3, %rax
testl %eax, %eax
je 0x27189
movl %eax, %r12d
xorl %r13d, %r13d
movq %rsp, %r15
movq 0xa8(%r14), %rax
movq (%rax,%r13,8), %rdx
movss 0x8(%rdx), %xmm0
ucomiss 0x8(%r14), %xmm0
jne 0x27181
testb %bl, %bl
jne 0x2715a
movq (%rsp), %rax
cmpq 0x8(%rsp), %rax
jne 0x27181
addq $0x18, %rdx
movq 0x8(%rsp), %rsi
cmpq 0x10(%rsp), %rsi
je 0x27179
movl (%rdx), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rsp)
jmp 0x27181
movq %r15, %rdi
callq 0xb4a0
incq %r13
cmpq %r13, %r12
jne 0x27134
movq (%rsp), %rax
movq 0x8(%rsp), %rbx
cmpq %rbx, %rax
je 0x271b2
subq %rax, %rbx
shrq $0x2, %rbx
cmpl $0x1, %ebx
je 0x271b9
testl %ebx, %ebx
je 0x271e0
callq 0x6200
xorl %edx, %edx
divl %ebx
jmp 0x271bb
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0x271c2
xorl %edx, %edx
movq (%rsp), %rax
movl (%rax,%rdx,4), %ebx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x271d0
callq 0x6260
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x6439(%rip), %rdi      # 0x2d620
leaq 0x643a(%rip), %rsi      # 0x2d628
leaq 0x6446(%rip), %rcx      # 0x2d63b
movl $0x3a, %edx
callq 0x61c0
jmp 0x27201
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x27212
callq 0x6260
movq %rbx, %rdi
callq 0x6410