LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x78, %rsp
movq %rsi, %r14
movq %rdi, %rbx
incl 0x20(%rdi)
callq 0x1d7ba
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xa4d8
andl $0x0, 0x70(%r15)
leaq 0x40(%rbx), %rdi
movq %r15, %rsi
callq 0x1d7ee
movq %rax, %r14
xorl %ebp, %ebp
movq %rsp, %r15
cmpl 0x34(%rbx), %ebp
jae 0x1d371
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1d81c
testb %al, %al
jne 0x1d371
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1d846
incl %ebp
jmp 0x1d34b
movzbl 0x39(%rbx), %edx
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x1dac8
movl %eax, %ebx
movq %rsp, %rdi
callq 0x8e90
movl %ebx, %eax
addq $0x78, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1d399
movq %rax, %rbx
movq %rsp, %rdi
callq 0x8e90
movq %rbx, %rdi
callq 0x5410
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rax
movq %rdi, %rbx
movq (%rsi), %rcx
movq -0x18(%rcx), %rcx
movslq %edx, %rdx
movq %rdx, 0x10(%rsi,%rcx)
leaq 0x3b2b(%rip), %rsi      # 0x20f22
movq %rax, %rdi
callq 0x5290
leaq 0x31b6(%rip), %rsi      # 0x205bc
movq %rax, %rdi
callq 0x5290
movq %rax, %r14
movq (%rbx), %rax
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq *0x18(%rax)
movq %r14, %rdi
movq %r15, %rsi
callq 0x5250
leaq 0x319d(%rip), %rsi      # 0x205cf
movq %rax, %rdi
callq 0x5290
movl 0x20(%rbx), %esi
movq %rax, %rdi
callq 0x51c0
leaq 0x59e6(%rip), %rsi      # 0x22e32
movq %rax, %rdi
callq 0x5290
movl 0x80(%rbx), %esi
movq %rax, %rdi
callq 0x51c0
movq %rax, %rdi
callq 0x5130
movq %rsp, %rdi
callq 0x5120
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x5120
movq %rbx, %rdi
callq 0x5410
nop
// File: /workspace/github_cpp_makefile_star2_O2/bonetblai[P]mdp-engine/ctp3/../engine/online_rtdp.h
// Function: Online::Policy::RTDP::finite_horizon_lrtdp_t<state_t>::best_action(Online::Policy::RTDP::node_t<state_t> const&, bool) const
Problem::action_t best_action(const node_t<T> &node, bool random_ties) const {
        std::vector<Problem::action_t> actions;
        int nactions = problem_.number_actions(node.state());
        float best_value = std::numeric_limits<float>::max();
        actions.reserve(random_ties ? nactions : 1);
        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( p.first <= best_value ) {
                    if( p.first < best_value ) {
                        best_value = p.first;
                        actions.clear();
                    }
                    if( random_ties || actions.empty() )
                        actions.push_back(a);
                }
            }
        }
        assert(!actions.empty());
        assert(actions.size() == 1);
        return actions[Random::random(actions.size())];
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
andq $0x0, 0x20(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq 0x8(%rdi), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movl %eax, %ebp
cltq
testb %bl, %bl
pushq $0x1
popq %rsi
cmovneq %rax, %rsi
leaq 0x10(%rsp), %rdi
callq 0xa3aa
movss 0x24ff(%rip), %xmm0     # 0x20014
movss %xmm0, 0x8(%rsp)
xorl %edx, %edx
leaq 0x10(%rsp), %r12
leaq 0xc(%rsp), %r13
movl %edx, 0xc(%rsp)
cmpl %ebp, %edx
jge 0x1db9a
movq 0x8(%r15), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x30(%rax)
testb %al, %al
je 0x1db92
movl 0xc(%rsp), %edx
movq %r15, %rdi
movq %r14, %rsi
callq 0x1e6b6
movd %eax, %xmm0
movss 0x8(%rsp), %xmm1
ucomiss %xmm0, %xmm1
jb 0x1db92
jbe 0x1db77
movq 0x10(%rsp), %rax
cmpq %rax, 0x18(%rsp)
je 0x1db71
movq %rax, 0x18(%rsp)
movss %xmm0, 0x8(%rsp)
testb %bl, %bl
jne 0x1db87
movq 0x10(%rsp), %rax
cmpq 0x18(%rsp), %rax
jne 0x1db92
movq %r12, %rdi
movq %r13, %rsi
callq 0x8804
movl 0xc(%rsp), %edx
incl %edx
jmp 0x1db27
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
cmpq %rcx, %rax
je 0x1dbdd
subq %rax, %rcx
cmpq $0x4, %rcx
jne 0x1dbfc
pushq $0x1
popq %rdi
callq 0xb503
movl %eax, %eax
leaq 0x10(%rsp), %rdi
movq (%rdi), %rcx
movl (%rcx,%rax,4), %ebx
callq 0x85dc
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x545e(%rip), %rdi      # 0x23042
leaq 0x52c9(%rip), %rsi      # 0x22eb4
leaq 0x5461(%rip), %rcx      # 0x23053
movl $0xf7, %edx
callq 0x51b0
leaq 0x54d2(%rip), %rdi      # 0x230d5
leaq 0x52aa(%rip), %rsi      # 0x22eb4
leaq 0x5442(%rip), %rcx      # 0x23053
movl $0xf8, %edx
callq 0x51b0
jmp 0x1dc21
jmp 0x1dc21
jmp 0x1dc21
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x85dc
movq %rbx, %rdi
callq 0x5410
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movl %eax, %r15d
xorl %ebp, %ebp
testl %eax, %eax
cmovlel %ebp, %r15d
movss 0x1df4(%rip), %xmm0     # 0x20014
movss %xmm0, 0x4(%rsp)
pushq $-0x1
popq %r13
xorl %r12d, %r12d
cmpl %r12d, %r15d
je 0x1e27f
movq 0x8(%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
movl %r12d, %edx
callq *0x30(%rax)
testb %al, %al
je 0x1e27a
movq %r14, %rdi
movq %rbx, %rsi
movl %r12d, %edx
callq 0x1e6b6
movd %eax, %xmm0
cmpl $-0x1, %r13d
je 0x1e269
movss 0x4(%rsp), %xmm1
ucomiss %xmm0, %xmm1
jbe 0x1e27a
shrq $0x20, %rax
andb $0x1, %al
movl %r12d, %r13d
movss %xmm0, 0x4(%rsp)
movl %eax, %ebp
incl %r12d
jmp 0x1e22d
cmpl $-0x1, %r13d
je 0x1e2a7
movd 0x4(%rsp), %xmm0
movd %xmm0, %eax
shlq $0x20, %r13
orq %r13, %rax
movl %ebp, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2f24(%rip), %rdi      # 0x211d2
leaq 0x4bff(%rip), %rsi      # 0x22eb4
leaq 0x4c78(%rip), %rcx      # 0x22f34
movl $0x11d, %edx            # imm = 0x11D
callq 0x51b0
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x8(%rdi), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
testb %al, %al
je 0x1e33d
movq 0x8(%r15), %rax
movss 0xc(%rax), %xmm0
movss %xmm0, (%rbx)
jmp 0x1e34f
movq %r15, %rdi
movq %r14, %rsi
callq 0x1e1da
testb %al, %al
je 0x1e35c
andl $0x0, (%rbx)
movb $0x1, %cl
movb %cl, 0x4(%rbx)
movl %ecx, %eax
popq %rbx
popq %r14
popq %r15
retq
movq %r15, %rdi
movq %r14, %rsi
callq 0x1e1f2
movd %eax, %xmm0
movss (%rbx), %xmm1
ucomiss %xmm1, %xmm0
setne %cl
movl %edx, %esi
notb %sil
orb %cl, %sil
movb $0x1, %cl
testb $0x1, %sil
je 0x1e351
ucomiss %xmm0, %xmm1
setne %cl
andb %dl, %cl
movl %eax, (%rbx)
jmp 0x1e351
nop
// File: /workspace/github_cpp_makefile_star2_O2/bonetblai[P]mdp-engine/ctp3/../engine/online_rtdp.h
// Function: Online::Policy::RTDP::finite_horizon_lrtdp_t<state_t>::q_value(Online::Policy::RTDP::node_t<state_t> const&, int) const
std::pair<float, bool> q_value(const node_t<T> &node, Problem::action_t a) const {
        ++total_number_expansions_;
        float qvalue = 0;
        bool all_children_labeled = true;
        std::vector<std::pair<T, float> > outcomes;
        problem_.next(node.state(), a, outcomes);
        for( int i = 0, isz = outcomes.size(); i < isz; ++i ) {
            const T &state = outcomes[i].first;
            float prob = outcomes[i].second;
            node_t<T> next_node(state, 1 + node.depth());
            std::pair<float, bool> p = value(next_node);
            qvalue += prob * p.first;
            all_children_labeled = all_children_labeled && p.second;
        }
        qvalue += problem_.cost(node.state(), a);
        return std::make_pair(qvalue, all_children_labeled);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
incl 0x80(%rdi)
leaq 0x20(%rsp), %rcx
andq $0x0, 0x10(%rcx)
xorps %xmm0, %xmm0
movaps %xmm0, (%rcx)
movq %rdi, 0x18(%rsp)
movq 0x8(%rdi), %rdi
movq (%rdi), %rax
movq %rsi, %r15
movl %edx, 0x10(%rsp)
callq *0x60(%rax)
movq 0x28(%rsp), %rax
subq 0x20(%rsp), %rax
pushq $0x78
popq %rcx
cqto
idivq %rcx
xorl %r13d, %r13d
testl %eax, %eax
cmovlel %r13d, %eax
imulq $0x78, %rax, %rbx
movb $0x1, %bpl
xorps %xmm0, %xmm0
movss %xmm0, 0xc(%rsp)
leaq 0x40(%rsp), %r12
cmpq %r13, %rbx
je 0x1e797
movq 0x20(%rsp), %rsi
movss 0x70(%rsi,%r13), %xmm0
movss %xmm0, 0x14(%rsp)
addq %r13, %rsi
movl 0x70(%r15), %r14d
movq %r12, %rdi
callq 0xa4d8
incl %r14d
movl %r14d, 0xb0(%rsp)
movq 0x18(%rsp), %rdi
movq %r12, %rsi
callq 0x1e808
movd %eax, %xmm0
movss 0x14(%rsp), %xmm1
mulss %xmm0, %xmm1
movss 0xc(%rsp), %xmm0
addss %xmm1, %xmm0
movss %xmm0, 0xc(%rsp)
shrq $0x20, %rax
andl $0x1, %eax
andb %al, %bpl
movq %r12, %rdi
callq 0x8e90
addq $0x78, %r13
jmp 0x1e723
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rdi
movq (%rdi), %rax
movq %r15, %rsi
movl 0x10(%rsp), %edx
callq *0x48(%rax)
addss 0xc(%rsp), %xmm0
movd %xmm0, %ebx
movzbl %bpl, %eax
shlq $0x20, %rax
orq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xb53c
movq %rbx, %rax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1e7e3
movq %rax, %rbx
jmp 0x1e7f5
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x8e90
leaq 0x20(%rsp), %rdi
callq 0xb53c
movq %rbx, %rdi
callq 0x5410
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
addq $0x40, %rdi
callq 0x1dc36
testq %rax, %rax
je 0x1e82f
movl (%rax), %ecx
movzbl 0x4(%rax), %eax
shlq $0x20, %rax
orq %rcx, %rax
jmp 0x1e88f
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x28(%rax)
testb %al, %al
je 0x1e84b
movq 0x8(%rbx), %rax
movd 0xc(%rax), %xmm0
jmp 0x1e88b
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1e1da
pxor %xmm0, %xmm0
testb %al, %al
jne 0x1e88b
movq 0x28(%rbx), %rdi
xorps %xmm1, %xmm1
testq %rdi, %rdi
je 0x1e886
movq (%rdi), %rax
movq %r14, %rsi
callq *0x20(%rax)
movq 0x28(%rbx), %rax
testq %rax, %rax
je 0x1e883
movss 0x10(%rax), %xmm1
jmp 0x1e886
xorps %xmm1, %xmm1
movss %xmm1, 0x1c(%rbx)
movd %xmm0, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
andq $0x0, 0x10(%rsp)
movq (%rdi), %rax
movq %rdx, %rsi
callq *0x20(%rax)
testb %al, %al
jne 0x1f13e
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1f1e4
leaq 0x8(%rbx), %rcx
cmpq %rcx, %rax
je 0x1f15b
xorl %r12d, %r12d
movq %rsp, %rdi
callq 0xb53c
movq %r12, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1f316
movq %r14, %rdi
movq %r12, %rsi
callq 0xd74c
movq (%r15), %r8
movq %rsp, %rcx
movq %r15, %rdi
movq %r12, %rsi
movl %eax, %edx
callq *0x60(%r8)
movq 0x8(%rsp), %rax
subq (%rsp), %rax
pushq $0x78
popq %rcx
cqto
idivq %rcx
movl %eax, %eax
imulq $0x78, %rax, %r13
xorl %ebp, %ebp
xorl %r12d, %r12d
cmpq %rbp, %r13
je 0x1f1c2
movq (%rsp), %rdx
addq %rbp, %rdx
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rcx
callq 0x1f0f6
addq %rax, %r12
addq $0x78, %rbp
jmp 0x1f19f
incq %r12
jmp 0x1f141
jmp 0x1f1d0
jmp 0x1f1d0
jmp 0x1f1d0
movq %rax, %rbx
movq %rsp, %rdi
callq 0xb53c
movq %rbx, %rdi
callq 0x5410
nop
// File: /workspace/github_cpp_makefile_star2_O2/bonetblai[P]mdp-engine/ctp3/./ctp3.h
// Function: state_t::operator<(state_t const&) const
bool operator<(const state_t &s) const {
        return (current_ < s.current_) ||
               ((current_ == s.current_) && (info_ < s.info_)) ||
               ((current_ == s.current_) && (info_ == s.info_) &&
                (memcmp(visited_, s.visited_, words_for_nodes_ * sizeof(unsigned)) < 0));
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl (%rdi), %eax
movl (%rsi), %ecx
movb $0x1, %bpl
cmpl %ecx, %eax
jl 0x1f2c3
movq %rsi, %rbx
movq %rdi, %r14
jne 0x1f287
leaq 0x4(%r14), %rdi
leaq 0x4(%rbx), %rsi
callq 0x1f2ca
testb %al, %al
jne 0x1f2c3
movl (%r14), %eax
movl (%rbx), %ecx
cmpl %ecx, %eax
jne 0x1f2c1
leaq 0x4(%r14), %rdi
leaq 0x4(%rbx), %rsi
callq 0x9f34
testb %al, %al
je 0x1f2c1
addq $0x4c, %r14
addq $0x4c, %rbx
movslq 0x15fdd(%rip), %rdx     # 0x35288
shlq $0x2, %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5110
movl %eax, %ebp
shrl $0x1f, %ebp
jmp 0x1f2c3
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH03_StringsVectorsAndArrays/examples/add_using.cc
// Function: main
int main()
{
	cout << "Enter two numbers:" << endl;

	int v1, v2;
	cin >> v1 >> v2;

	cout << "The sum of " << v1 << " and " << v2
	     << " is " << v1 + v2 << endl;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x2df3(%rip), %r15      # 0x3fd0
leaq 0xe20(%rip), %rsi       # 0x2004
movq %r15, %rdi
callq 0x1060
movq %rax, %rdi
callq 0x1030
movq 0x2de5(%rip), %rdi      # 0x3fe0
leaq -0x20(%rbp), %rbx
movq %rbx, %rsi
callq 0x1040
leaq -0x1c(%rbp), %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0x1040
leaq 0xdfa(%rip), %rsi       # 0x2017
movq %r15, %rdi
callq 0x1060
movl (%rbx), %esi
movq %rax, %rdi
callq 0x1080
leaq 0xded(%rip), %rsi       # 0x2023
movq %rax, %rdi
callq 0x1060
movl (%r14), %esi
movq %rax, %rdi
callq 0x1080
leaq 0xdd9(%rip), %rsi       # 0x2029
movq %rax, %rdi
callq 0x1060
movl (%r14), %esi
addl (%rbx), %esi
movq %rax, %rdi
callq 0x1080
movq %rax, %rdi
callq 0x1030
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/xukmin[P]rase/sensor-placers.cc
// Function: RandomizedSensorPlacer::GeneratePositions(std::vector<Position, std::allocator<Position>>*)
void RandomizedSensorPlacer::GeneratePositions(std::vector<Position>* positions) {
  assert(positions != NULL);
  positions->clear();

  // Put the base station at the origin.
  positions->push_back(Position(0.0, 0.0));

  for (int i = 1; i < num_sensors_; i++) {
    positions->push_back(Position(DoubleRand(region_.min_x, region_.max_x),
                                  DoubleRand(region_.min_y, region_.max_y)));
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
testq %rsi, %rsi
je 0x3e06
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rax
cmpq %rax, 0x8(%rsi)
je 0x3d92
movq %rax, 0x8(%rbx)
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r15
movaps %xmm0, (%r15)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3f7c
pushq $0x1
popq %rbp
cmpl 0x8(%r14), %ebp
jge 0x3dfb
movsd 0x10(%r14), %xmm0
movsd 0x20(%r14), %xmm1
callq 0x7a00
movsd %xmm0, 0x8(%rsp)
movsd 0x18(%r14), %xmm0
movsd 0x28(%r14), %xmm1
callq 0x7a00
movsd 0x8(%rsp), %xmm1
movsd %xmm1, 0x10(%rsp)
movsd %xmm0, 0x18(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3f7c
incl %ebp
jmp 0x3dac
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x42b3(%rip), %rdi      # 0x80c0
leaq 0x42be(%rip), %rsi      # 0x80d2
leaq 0x42c9(%rip), %rcx      # 0x80e4
pushq $0x16
popq %rdx
callq 0x30f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/xukmin[P]rase/sensor-placers.cc
// Function: RegularSensorPlacer::GeneratePositions(std::vector<Position, std::allocator<Position>>*)
void RegularSensorPlacer::GeneratePositions(std::vector<Position>* positions) {
  assert(positions != NULL);
  positions->clear();

  double gap_x = (region_.max_x - region_.min_x) / num_cols_;
  double gap_y = (region_.max_y - region_.min_y) / num_rows_;

  for (int i = 0; i < num_cols_; i++) {
    for (int j = 0; j < num_rows_; j++) {
      positions->push_back(Position(region_.min_x + i * gap_x,
                                    region_.min_y + j * gap_y));
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
testq %rsi, %rsi
je 0x3ee5
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rax
cmpq %rax, 0x8(%rsi)
je 0x3e4c
movq %rax, 0x8(%rbx)
movupd 0x20(%r14), %xmm2
movupd 0x10(%r14), %xmm0
subpd %xmm0, %xmm2
movq 0x8(%r14), %rcx
movq %rcx, %xmm0
cvtdq2pd %xmm0, %xmm1
divpd %xmm1, %xmm2
movapd %xmm2, (%rsp)
pshufd $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
movd %xmm0, %eax
xorl %ebp, %ebp
leaq 0x20(%rsp), %r15
cmpl %ecx, %ebp
jge 0x3ed8
cvtsi2sd %ebp, %xmm0
movapd %xmm0, 0x10(%rsp)
xorl %r12d, %r12d
cmpl %eax, %r12d
jge 0x3ed0
cvtsi2sd %r12d, %xmm0
movupd 0x10(%r14), %xmm1
movapd 0x10(%rsp), %xmm2
unpcklpd %xmm0, %xmm2            # xmm2 = xmm2[0],xmm0[0]
mulpd (%rsp), %xmm2
addpd %xmm1, %xmm2
movapd %xmm2, 0x20(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3f7c
incl %r12d
movl 0xc(%r14), %eax
jmp 0x3e93
incl %ebp
movl 0x8(%r14), %ecx
jmp 0x3e82
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x41d4(%rip), %rdi      # 0x80c0
leaq 0x41df(%rip), %rsi      # 0x80d2
leaq 0x423a(%rip), %rcx      # 0x8134
pushq $0x23
popq %rdx
callq 0x30f0
// File: /workspace/github_cpp_makefile_star2_O2/xukmin[P]rase/sensor-placers.cc
// Function: GeneratePositionsThatCanBeConnected(double, SensorPlacer*, std::vector<Position, std::allocator<Position>>*)
void GeneratePositionsThatCanBeConnected(double communication_range,
                                         SensorPlacer* placer,
                                         std::vector<Position>* positions) {
  double min_communication_range;
  int retries = 10;
  while (retries-- > 0) {
    placer->GeneratePositions(positions);
    if (communication_range >= CalculateMinimumCommunicationRange(*positions)) {
      return;
    }
  }
  fprintf(stderr, "Failed to generate sensors with given communication range!\n");
  exit(1);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movsd %xmm0, 0x8(%rsp)
pushq $-0xb
popq %rbp
incl %ebp
je 0x3f46
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *0x10(%rax)
movq %rbx, %rdi
callq 0x4b00
movsd 0x8(%rsp), %xmm1
ucomisd %xmm0, %xmm1
jb 0x3f19
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq 0xa08b(%rip), %rax      # 0xdfd8
movq (%rax), %rcx
leaq 0x422a(%rip), %rdi      # 0x8181
pushq $0x3b
popq %rsi
pushq $0x1
popq %rdx
callq 0x32c0
pushq $0x1
popq %rdi
callq 0x31c0
// File: /workspace/github_cpp_makefile_star2_O2/xukmin[P]rase/sensor-network.cc
// Function: SensorNetwork::FindSensorsWithinRange(Position const&, double, std::vector<int, std::allocator<int>>*) const
bool SensorNetwork::FindSensorsWithinRange(const Position& position,
                                           double range,
                                           std::vector<int>* neighbors) const {
  assert(neighbors != NULL);
  neighbors->clear();

  std::vector<int> candidates;
  FindNeighborCandidates(position, range, &candidates);

  for (int i = 0; i < candidates.size(); i++) {
    int c = candidates[i];
    if (Distance(position, sensors_[c].position()) <= range) {
      neighbors->push_back(c);
    }
  }

  return !neighbors->empty();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movsd %xmm0, 0x8(%rsp)
testq %rdx, %rdx
je 0x4492
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdx), %rax
cmpq %rax, 0x8(%rdx)
je 0x43fc
movq %rax, 0x8(%rbx)
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdx
movaps %xmm0, (%rdx)
andq $0x0, 0x10(%rdx)
movq %r15, %rdi
movq %r14, %rsi
movsd 0x8(%rsp), %xmm0
callq 0x4208
xorl %r13d, %r13d
leaq 0x4(%rsp), %r12
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r13, %rcx
jbe 0x446e
movslq (%rax,%r13,4), %rax
movl %eax, 0x4(%rsp)
imulq $0x48, %rax, %rsi
addq (%r15), %rsi
movq %r14, %rdi
callq 0x6367
movsd 0x8(%rsp), %xmm1
ucomisd %xmm0, %xmm1
jb 0x4469
movq %rbx, %rdi
movq %r12, %rsi
callq 0x4d4e
incq %r13
jmp 0x4425
movq (%rbx), %rax
cmpq 0x8(%rbx), %rax
setne %bl
leaq 0x10(%rsp), %rdi
callq 0x58b2
movl %ebx, %eax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x3e03(%rip), %rdi      # 0x829c
leaq 0x3d8b(%rip), %rsi      # 0x822b
leaq 0x3e07(%rip), %rcx      # 0x82ae
pushq $0x57
popq %rdx
callq 0x30f0
jmp 0x44b1
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x58b2
movq %rbx, %rdi
callq 0x3290
// File: /workspace/github_cpp_makefile_star2_O2/xukmin[P]rase/sensor-network.cc
// Function: SensorNetwork::FindSensorsWithinRange(int, double, std::vector<int, std::allocator<int>>*) const
bool SensorNetwork::FindSensorsWithinRange(int sensor,
                                           double range,
                                           std::vector<int>* neighbors) const {
  assert(neighbors != NULL);
  neighbors->clear();

  std::vector<int> candidates;
  FindNeighborCandidates(sensors_[sensor].position(), range, &candidates);

  for (int i = 0; i < candidates.size(); i++) {
    int c = candidates[i];
    if (distances_[sensor][c] <= range) {
      neighbors->push_back(c);
    }
  }

  return !neighbors->empty();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movsd %xmm0, 0x8(%rsp)
testq %rdx, %rdx
je 0x4590
movq %rdx, %rbx
movq %rdi, %r14
movq (%rdx), %rax
cmpq %rax, 0x8(%rdx)
je 0x44f5
movq %rax, 0x8(%rbx)
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdx
movaps %xmm0, (%rdx)
andq $0x0, 0x10(%rdx)
movslq %esi, %r15
imulq $0x48, %r15, %rsi
addq (%r14), %rsi
movq %r14, %rdi
movsd 0x8(%rsp), %xmm0
callq 0x4208
xorl %r12d, %r12d
imulq $0x18, %r15, %r13
leaq 0x4(%rsp), %r15
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r12, %rcx
jbe 0x456c
movslq (%rax,%r12,4), %rax
movl %eax, 0x4(%rsp)
movq 0x78(%r14), %rcx
movq (%rcx,%r13), %rcx
movsd 0x8(%rsp), %xmm0
ucomisd (%rcx,%rax,8), %xmm0
jb 0x4567
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4d4e
incq %r12
jmp 0x4529
movq (%rbx), %rax
cmpq 0x8(%rbx), %rax
setne %bl
leaq 0x10(%rsp), %rdi
callq 0x58b2
movl %ebx, %eax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x3d05(%rip), %rdi      # 0x829c
leaq 0x3c8d(%rip), %rsi      # 0x822b
leaq 0x3d68(%rip), %rcx      # 0x830d
pushq $0x6a
popq %rdx
callq 0x30f0
jmp 0x45af
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x58b2
movq %rbx, %rdi
callq 0x3290
// File: /workspace/github_cpp_makefile_star2_O2/xukmin[P]rase/sensor-network.cc
// Function: SensorNetwork::CreateChannels(double)
void SensorNetwork::CreateChannels(double communication_range) {
  RemoveChannels();

  communication_range_ = communication_range;
  for (int i = 0; i < sensors_.size(); i++) {
    Sensor& sensor = sensors_[i];
    const Position& p = sensor.position();

    std::vector<int> neighbors;
    FindSensorsWithinRange(i, communication_range, &neighbors);
    for (int j = 0; j < neighbors.size(); j++) {
      if (neighbors[j] != i) {
        sensor.AddNeighbor(neighbors[j]);
      }
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movsd %xmm0, 0x8(%rsp)
movq %rdi, %rbx
callq 0x41c0
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x90(%rbx)
xorl %r14d, %r14d
pushq $0x48
popq %r13
leaq 0x10(%rsp), %r15
movq (%rbx), %r12
movq 0x8(%rbx), %rax
subq %r12, %rax
cqto
idivq %r13
cmpq %r14, %rax
jbe 0x4671
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
andq $0x0, 0x20(%rsp)
movq %rbx, %rdi
movl %r14d, %esi
movsd 0x8(%rsp), %xmm0
movq %r15, %rdx
callq 0x44c6
imulq $0x48, %r14, %rax
addq %rax, %r12
xorl %ebp, %ebp
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %rbp, %rcx
jbe 0x4664
movl (%rax,%rbp,4), %esi
cmpq %rsi, %r14
je 0x465f
movq %r12, %rdi
callq 0x4d6c
incq %rbp
jmp 0x4639
movq %r15, %rdi
callq 0x58b2
incq %r14
jmp 0x45fa
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4682
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x58b2
movq %rbx, %rdi
callq 0x3290
nop
// File: /workspace/github_cpp_makefile_star2_O2/xukmin[P]rase/sensor-network.cc
// Function: SensorNetwork::AddSensors(std::vector<Position, std::allocator<Position>> const&)
void SensorNetwork::AddSensors(const std::vector<Position>& positions) {
  RemoveSensors();
  for (int i = 0; i < positions.size(); i++) {
    AddSensor(positions[i]);
  }

  CalculateDistances(positions, &distances_);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x46f0
xorl %r15d, %r15d
xorl %r12d, %r12d
movq (%rbx), %rsi
movq 0x8(%rbx), %rax
subq %rsi, %rax
sarq $0x4, %rax
cmpq %r12, %rax
jbe 0x46d8
addq %r15, %rsi
movq %r14, %rdi
callq 0x40fc
incq %r12
addq $0x10, %r15
jmp 0x46b1
addq $0x78, %r14
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x470f
nop
// File: /workspace/github_cpp_makefile_star2_O2/xukmin[P]rase/sensor-network.cc
// Function: (anonymous namespace)::CalculateDistances(std::vector<Position, std::allocator<Position>> const&, std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>>*)
void CalculateDistances(const std::vector<Position>& positions,
                        std::vector<std::vector<double> >* distances) {
  distances->clear();
  distances->resize(positions.size());
  for (int i = 0; i < distances->size(); i++) {
    (*distances)[i].resize(positions.size());
  }

  for (int i = 0; i < positions.size(); i++) {
    for (int j = i + 1; j < positions.size(); j++) {
      (*distances)[i][j] = (*distances)[j][i] =
          Distance(positions[i], positions[j]);
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x4e16
movq 0x8(%r14), %rsi
subq (%r14), %rsi
sarq $0x4, %rsi
movq %rbx, %rdi
callq 0x4e1e
xorl %r15d, %r15d
pushq $0x18
popq %r12
xorl %r13d, %r13d
movq (%rbx), %rdi
movq 0x8(%rbx), %rax
subq %rdi, %rax
cqto
idivq %r12
cmpq %r13, %rax
jbe 0x4778
addq %r15, %rdi
movq 0x8(%r14), %rsi
subq (%r14), %rsi
sarq $0x4, %rsi
callq 0x4e54
incq %r13
addq $0x18, %r15
jmp 0x4748
movq (%r14), %rsi
movq 0x8(%r14), %rax
pushq $0x1
popq %r15
pushq $0x10
popq %r12
pushq $0xc
popq %r13
xorl %ebp, %ebp
movq %rax, %rcx
subq %rsi, %rcx
sarq $0x4, %rcx
movq %r13, (%rsp)
movq %r12, 0x8(%rsp)
movq %r15, 0x10(%rsp)
cmpq %rbp, %rcx
ja 0x47ea
jmp 0x481a
movq %rbp, %rdi
shlq $0x4, %rdi
addq %rsi, %rdi
addq %r12, %rsi
callq 0x6367
movq (%rbx), %rax
movq (%rax,%r13,2), %rcx
movsd %xmm0, (%rcx,%rbp,8)
imulq $0x18, %rbp, %rcx
movq (%rax,%rcx), %rax
movsd %xmm0, (%rax,%r15,8)
incq %r15
movq (%r14), %rsi
movq 0x8(%r14), %rax
addq $0x10, %r12
addq $0xc, %r13
movq %rax, %rcx
subq %rsi, %rcx
sarq $0x4, %rcx
cmpq %r15, %rcx
ja 0x47ac
incq %rbp
movq 0x10(%rsp), %r15
incq %r15
movq 0x8(%rsp), %r12
addq $0x10, %r12
movq (%rsp), %r13
addq $0xc, %r13
jmp 0x478d
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/xukmin[P]rase/routing-builders.cc
// Function: RoutingBuilder::BuildRouting(SensorNetwork*)
void RoutingBuilder::BuildRouting(SensorNetwork* network) {
  network->RemoveParents();
  std::vector<std::vector<int> > candidates;
  bool succeeded = GenerateParentCandidates(network, &candidates);
  assert(succeeded);

  // Base station does not need to and cannot select parent.
  for (int i = 1; i < network->num_sensors(); i++) {
    network->SetParent(i, selector_->SelectParent(i, candidates[i], *network));
  }
  // Make sure the routing generator works as expected.
  assert(network->IsConnectedWithRoutings());
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x49c0
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
andq $0x0, 0x10(%rsi)
movq %rbx, %rdi
callq 0x638c
testb %al, %al
je 0x6695
movq (%rbx), %rcx
pushq $0x1
popq %r15
movl $0x8c, %r12d
pushq $0x18
popq %r13
pushq $0x48
popq %rbp
movq 0x8(%rbx), %rax
subq %rcx, %rax
cqto
idivq %rbp
cltq
cmpq %rax, %r15
jge 0x6672
movq 0x48(%r14), %rdi
movq (%rsp), %rdx
addq %r13, %rdx
movq (%rdi), %rax
movl %r15d, %esi
movq %rbx, %rcx
callq *0x10(%rax)
movq (%rbx), %rcx
movl %eax, (%rcx,%r12)
incq %r15
addq $0x48, %r12
addq $0x18, %r13
jmp 0x6634
movq %rbx, %rdi
callq 0x49ea
testb %al, %al
je 0x66ae
movq %rsp, %rdi
callq 0x7058
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1ec3(%rip), %rdi      # 0x855f
leaq 0x1df9(%rip), %rsi      # 0x849c
leaq 0x1ebf(%rip), %rcx      # 0x8569
pushq $0x57
jmp 0x66c5
leaq 0x1ee7(%rip), %rdi      # 0x859c
leaq 0x1de0(%rip), %rsi      # 0x849c
leaq 0x1ea6(%rip), %rcx      # 0x8569
pushq $0x5e
popq %rdx
callq 0x30f0
jmp 0x66cd
movq %rax, %rbx
movq %rsp, %rdi
callq 0x7058
movq %rbx, %rdi
callq 0x3290
// File: /workspace/github_cpp_makefile_star2_O2/xukmin[P]rase/routing-builders.cc
// Function: NearestFirstParentSelector::SelectParent(int, std::vector<int, std::allocator<int>> const&, SensorNetwork const&)
int NearestFirstParentSelector::SelectParent(int sensor,
                                             const std::vector<int>& candidates,
                                             const SensorNetwork& network) {
  assert(!candidates.empty());
  int parent = candidates[0];
  double min_distance = network.GetDistance(sensor, parent);
  for (int i = 1; i < candidates.size(); i++) {
    double distance = network.GetDistance(sensor, candidates[i]);
    if (distance < min_distance) {
      parent = candidates[i];
      min_distance = distance;
    }
  }

  return parent;
}

// Assembly:
pushq %rax
movq (%rdx), %rdi
movq 0x8(%rdx), %rdx
cmpq %rdx, %rdi
je 0x6aa4
movslq (%rdi), %rax
movslq %esi, %rsi
movq 0x78(%rcx), %rcx
imulq $0x18, %rsi, %rsi
movq (%rcx,%rsi), %rcx
movsd (%rcx,%rax,8), %xmm0
subq %rdi, %rdx
sarq $0x2, %rdx
pushq $0x1
popq %rsi
cmpq %rsi, %rdx
jbe 0x6aa2
movslq (%rdi,%rsi,4), %r8
movsd (%rcx,%r8,8), %xmm1
ucomisd %xmm1, %xmm0
cmoval %r8d, %eax
minsd %xmm0, %xmm1
incq %rsi
movapd %xmm1, %xmm0
jmp 0x6a7e
popq %rcx
retq
leaq 0x1b14(%rip), %rdi      # 0x85bf
leaq 0x19ea(%rip), %rsi      # 0x849c
leaq 0x1d21(%rip), %rcx      # 0x87da
movl $0xc0, %edx
callq 0x30f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/xukmin[P]rase/routing-builders.cc
// Function: SecondNearestFirstParentSelector::SelectParent(int, std::vector<int, std::allocator<int>> const&, SensorNetwork const&)
int SecondNearestFirstParentSelector::SelectParent(
    int sensor,
    const std::vector<int>& candidates,
    const SensorNetwork& network) {
  assert(!candidates.empty());
  if (candidates.size() == 1) {
    return candidates[0];
  }

  int min_sensor = candidates[0];
  double min_distance = network.GetDistance(sensor, min_sensor);
  int second_min_sensor = candidates[1];
  double second_min_distance = network.GetDistance(sensor, second_min_sensor);
  if (min_distance > second_min_sensor) {
    std::swap(min_sensor, second_min_sensor);
    std::swap(min_distance, second_min_distance);
  }
  for (int i = 2; i < candidates.size(); i++) {
    double distance = network.GetDistance(sensor, candidates[i]);
    if (distance < min_distance) {
      second_min_sensor = min_sensor;
      second_min_distance = min_distance;
      min_sensor = candidates[i];
      min_distance = distance;
    } else if (distance < second_min_distance) {
      second_min_sensor = candidates[i];
      second_min_distance = distance;
    }
  }

  return second_min_sensor;
}

// Assembly:
pushq %rax
movq (%rdx), %rdi
movq 0x8(%rdx), %rdx
cmpq %rdx, %rdi
je 0x6c1a
subq %rdi, %rdx
movl (%rdi), %eax
cmpq $0x4, %rdx
jne 0x6b86
popq %rcx
retq
movslq %eax, %r8
movslq %esi, %rsi
movq 0x78(%rcx), %rcx
imulq $0x18, %rsi, %rsi
movq (%rcx,%rsi), %rcx
movsd (%rcx,%r8,8), %xmm0
movslq 0x4(%rdi), %rsi
movsd (%rcx,%rsi,8), %xmm2
cvtsi2sd %esi, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x6bba
movl %esi, %r8d
movapd %xmm2, %xmm1
jmp 0x6bc7
movl %eax, %r8d
movapd %xmm0, %xmm1
movl %esi, %eax
movapd %xmm2, %xmm0
sarq $0x2, %rdx
pushq $0x2
popq %rsi
cmpq %rsi, %rdx
jbe 0x6b84
movslq (%rdi,%rsi,4), %r9
movsd (%rcx,%r9,8), %xmm2
ucomisd %xmm2, %xmm1
jbe 0x6bf3
movl %r9d, %r10d
movapd %xmm2, %xmm3
movl %r8d, %r9d
movapd %xmm1, %xmm2
jmp 0x6c07
movl %r8d, %r10d
movapd %xmm1, %xmm3
ucomisd %xmm2, %xmm0
ja 0x6c07
movl %eax, %r9d
movapd %xmm0, %xmm2
incq %rsi
movl %r10d, %r8d
movapd %xmm3, %xmm1
movl %r9d, %eax
movapd %xmm2, %xmm0
jmp 0x6bce
leaq 0x199e(%rip), %rdi      # 0x85bf
leaq 0x1874(%rip), %rsi      # 0x849c
leaq 0x1c16(%rip), %rcx      # 0x8845
movl $0xdf, %edx
callq 0x30f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/xukmin[P]rase/routing-builders.cc
// Function: FarthestFirstParentSelector::SelectParent(int, std::vector<int, std::allocator<int>> const&, SensorNetwork const&)
int FarthestFirstParentSelector::SelectParent(int sensor,
                                              const std::vector<int>& candidates,
                                              const SensorNetwork& network) {
  assert(!candidates.empty());
  int parent = candidates[0];
  double max_distance = network.GetDistance(sensor, parent);
  for (int i = 1; i < candidates.size(); i++) {
    double distance = network.GetDistance(sensor, candidates[i]);
    if (distance > max_distance) {
      parent = candidates[i];
      max_distance = distance;
    }
  }

  return parent;
}

// Assembly:
pushq %rax
movq (%rdx), %rdi
movq 0x8(%rdx), %rdx
cmpq %rdx, %rdi
je 0x6d32
movslq (%rdi), %rax
movslq %esi, %rsi
movq 0x78(%rcx), %rcx
imulq $0x18, %rsi, %rsi
movq (%rcx,%rsi), %rcx
movsd (%rcx,%rax,8), %xmm0
subq %rdi, %rdx
sarq $0x2, %rdx
pushq $0x1
popq %rsi
cmpq %rsi, %rdx
jbe 0x6d30
movslq (%rdi,%rsi,4), %r8
movsd (%rcx,%r8,8), %xmm1
ucomisd %xmm0, %xmm1
cmoval %r8d, %eax
maxsd %xmm0, %xmm1
incq %rsi
movapd %xmm1, %xmm0
jmp 0x6d0c
popq %rcx
retq
leaq 0x1886(%rip), %rdi      # 0x85bf
leaq 0x175c(%rip), %rsi      # 0x849c
leaq 0x1ba1(%rip), %rcx      # 0x88e8
movl $0x10c, %edx            # imm = 0x10C
callq 0x30f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/xukmin[P]rase/svg-printer.cc
// Function: SvgPrinter::SvgPrinter(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Region const&, double)
SvgPrinter::SvgPrinter(const std::string& filename,
                       const std::string& title,
                       const Region& region,
                       double scale)
    : filename_(filename), title_(title), region_(region), scale_(scale) {
  file_ = std::fopen(filename_.c_str(), "w");
  if (!file_) {
    fprintf(stderr, "Failed to open file %s!\n", filename_.c_str());
    exit(1);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movsd %xmm0, 0x8(%rsp)
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
callq 0x3200
leaq 0x20(%rbx), %rdi
movq %r15, %rsi
callq 0x3200
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups %xmm1, 0x50(%rbx)
movups %xmm0, 0x40(%rbx)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x60(%rbx)
movq (%rbx), %rdi
leaq 0x15fd(%rip), %rsi      # 0x8cb8
callq 0x31b0
movq %rax, 0x68(%rbx)
testq %rax, %rax
je 0x76d3
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0x68fe(%rip), %rax      # 0xdfd8
movq (%rax), %rdi
movq (%rbx), %rdx
leaq 0x15d3(%rip), %rsi      # 0x8cba
xorl %eax, %eax
callq 0x3210
pushq $0x1
popq %rdi
callq 0x31c0
movq %rax, %r14
movq %rbx, %rdi
callq 0x30b0
movq %r14, %rdi
callq 0x3290
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk-extras/exprtk_prime_sieve.cpp
// Function: void sieve_of_eratosthenes<double>()
void sieve_of_eratosthenes()
{
   typedef exprtk::expression<T> expression_t;
   typedef exprtk::parser<T>     parser_t;

   const std::string sieve_of_eratosthenes_program =
      " var sieve[10^8] := [false];                   "
      " var m := trunc(sqrt(sieve[]));                "
      "                                               "
      " sieve[0] := true;                             "
      " sieve[1] := true;                             "
      "                                               "
      " for (var i := 0; i <= m; i += 1)              "
      " {                                             "
      "    if (false == sieve[i])                     "
      "    {                                          "
      "       for (var j := i^2; j < sieve[]; j += i) "
      "       {                                       "
      "          sieve[j] := true;                    "
      "       }                                       "
      "    }                                          "
      " };                                            "
      "                                               "
      " var prime_count := sieve[] - sum(sieve);      "
      "                                               "
      " prime_count == 5761455;                       ";

   expression_t expression;

   parser_t parser;
   parser.compile(sieve_of_eratosthenes_program,expression);

   exprtk::timer timer;
   timer.start();

   const T result = expression.value();

   timer.stop();

   printf("Result: %8.3f\n",result);

   printf("Total time: %8.3fsec\n",timer.time());
}

// Assembly:
pushq %rbx
subq $0xac0, %rsp            # imm = 0xAC0
leaq 0x129df7(%rip), %rsi    # 0x23a109
leaq 0x28(%rsp), %rdi
leaq 0x198(%rsp), %rdx
callq 0x1102c8
leaq 0x8(%rsp), %rdi
callq 0x1104e2
leaq 0x48(%rsp), %rdi
pushq $0x7f
popq %rsi
callq 0x110542
leaq 0x198(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x110652
leaq 0x48(%rsp), %rdi
callq 0x110c6a
leaq 0x198(%rsp), %rdi
leaq 0x28(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq 0x110cb2
leaq 0x48(%rsp), %rdi
movb $0x0, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movups %xmm0, 0x18(%rdi)
callq 0x111134
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, (%rsp)
leaq 0x48(%rsp), %rbx
movq %rbx, %rdi
callq 0x111142
leaq 0x12a108(%rip), %rdi    # 0x23a4b6
movsd (%rsp), %xmm0
movb $0x1, %al
callq 0x10e060
movq %rbx, %rdi
callq 0x111156
leaq 0x12a0fc(%rip), %rdi    # 0x23a4c5
movb $0x1, %al
callq 0x10e060
leaq 0x198(%rsp), %rdi
callq 0x111188
leaq 0x8(%rsp), %rdi
callq 0x1112c2
leaq 0x28(%rsp), %rdi
callq 0x10e5c8
addq $0xac0, %rsp            # imm = 0xAC0
popq %rbx
retq
jmp 0x110415
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x110c6a
jmp 0x110425
movq %rax, %rbx
jmp 0x110425
movq %rax, %rbx
jmp 0x11042f
movq %rax, %rbx
leaq 0x198(%rsp), %rdi
callq 0x111188
leaq 0x8(%rsp), %rdi
callq 0x1112c2
leaq 0x28(%rsp), %rdi
callq 0x10e5c8
movq %rbx, %rdi
callq 0x10e320
// File: /workspace/github_cpp_makefile_star2_O2/Slexis-Works[P]texture-packing/PPMImage.cpp
// Function: PPMImage::PPMImage(unsigned int, unsigned int, RGBColor)
PPMImage::PPMImage(coord width, coord height, RGBColor bgc)
: width(width)
, height(height)
, length(width*height)
, map(NULL)
{
	map = new RGBColor[length];
	assert(map);
	for (size_t i=0 ; i<length ; ++i)
		map[i] = bgc;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %ecx, %ebx
movl %edx, %r15d
movq %rdi, %r14
movl %esi, (%rdi)
movl %edx, 0x4(%rdi)
imull %esi, %r15d
movq %r15, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
leaq (%r15,%r15,2), %rdi
callq 0x2030
movq %rax, 0x10(%r14)
xorl %eax, %eax
movl %ebx, %ecx
shrl $0x10, %ecx
xorl %edx, %edx
cmpq %r15, %rdx
jae 0x289b
movq 0x10(%r14), %rsi
movw %bx, (%rsi,%rax)
movb %cl, 0x2(%rsi,%rax)
incq %rdx
movq 0x8(%r14), %r15
addq $0x3, %rax
jmp 0x287d
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Slexis-Works[P]texture-packing/PPMImage.cpp
// Function: PPMImage::saveImage(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void PPMImage::saveImage(std::string path) {
	std::ofstream file(path);

	file << "P6" << std::endl
		<< width << ' ' << height << std::endl
		<< "255" << std::endl;

	for (coord y=0 ; y<height ; ++y) {
		for (coord x=0 ; x<width ; ++x) {
			RGBColor curp = map[y*width + x];
			file << curp.r << curp.g << curp.b;
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
pushq $0x10
popq %rdx
movq %r14, %rdi
callq 0x2200
leaq 0x2722(%rip), %rsi      # 0x507d
movq %r14, %rdi
callq 0x2140
movq %rax, %rdi
callq 0x2090
movl (%rbx), %esi
movq %rax, %rdi
callq 0x20c0
pushq $0x20
popq %rsi
movq %rax, %rdi
callq 0x2170
movl 0x4(%rbx), %esi
movq %rax, %rdi
callq 0x20c0
movq %rax, %rdi
callq 0x2090
leaq 0x26e6(%rip), %rsi      # 0x5080
movq %rax, %rdi
callq 0x2140
movq %rax, %rdi
callq 0x2090
xorl %ebp, %ebp
leaq 0x8(%rsp), %r14
cmpl 0x4(%rbx), %ebp
jae 0x2a05
xorl %r15d, %r15d
movl (%rbx), %eax
cmpl %eax, %r15d
jae 0x2a01
movq 0x10(%rbx), %rcx
imull %ebp, %eax
addl %r15d, %eax
leaq (%rax,%rax,2), %rax
movsbl (%rcx,%rax), %esi
movb 0x1(%rcx,%rax), %r13b
movb 0x2(%rcx,%rax), %r12b
movq %r14, %rdi
callq 0x2170
movsbl %r13b, %esi
movq %rax, %rdi
callq 0x2170
movsbl %r12b, %esi
movq %rax, %rdi
callq 0x2170
incl %r15d
jmp 0x29b9
incl %ebp
jmp 0x29b1
leaq 0x8(%rsp), %rdi
callq 0x2180
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2a23
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2180
movq %rbx, %rdi
callq 0x21e0
// File: /workspace/github_cpp_makefile_star2_O2/Slexis-Works[P]texture-packing/PPMImage.cpp
// Function: PPMImage::saveImageASCII(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void PPMImage::saveImageASCII(std::string path) {
	std::ofstream file(path);

	file << "P3" << std::endl
		<< width << ' ' << height << std::endl
		<< "255" << std::endl;

	for (coord y=0 ; y<height ; ++y) {
		for (coord x=0 ; x<width ; ++x) {
			RGBColor curp = map[y*width + x];
			file << (int)curp.r << ' ' << (int)curp.g << ' ' << (int)curp.b << ' ';
		}
		file << std::endl;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
pushq $0x10
popq %rdx
movq %r14, %rdi
callq 0x2200
leaq 0x2621(%rip), %rsi      # 0x5084
movq %r14, %rdi
callq 0x2140
movq %rax, %rdi
callq 0x2090
movl (%rbx), %esi
movq %rax, %rdi
callq 0x20c0
pushq $0x20
popq %rsi
movq %rax, %rdi
callq 0x2170
movl 0x4(%rbx), %esi
movq %rax, %rdi
callq 0x20c0
movq %rax, %rdi
callq 0x2090
leaq 0x25de(%rip), %rsi      # 0x5080
movq %rax, %rdi
callq 0x2140
movq %rax, %rdi
callq 0x2090
xorl %r13d, %r13d
pushq $0x20
popq %rbp
cmpl 0x4(%rbx), %r13d
jae 0x2b3c
xorl %r14d, %r14d
movl (%rbx), %eax
cmpl %eax, %r14d
jae 0x2b2a
movq 0x10(%rbx), %rcx
imull %r13d, %eax
addl %r14d, %eax
leaq (%rax,%rax,2), %rax
movzbl (%rcx,%rax), %esi
movzbl 0x1(%rcx,%rax), %r12d
movzbl 0x2(%rcx,%rax), %r15d
leaq 0x8(%rsp), %rdi
callq 0x21d0
movq %rax, %rdi
movl %ebp, %esi
callq 0x2170
movq %rax, %rdi
movl %r12d, %esi
callq 0x21d0
movq %rax, %rdi
movl %ebp, %esi
callq 0x2170
movq %rax, %rdi
movl %r15d, %esi
callq 0x21d0
movq %rax, %rdi
movl %ebp, %esi
callq 0x2170
incl %r14d
jmp 0x2ac1
leaq 0x8(%rsp), %rdi
callq 0x2090
incl %r13d
jmp 0x2ab8
leaq 0x8(%rsp), %rdi
callq 0x2180
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2b5c
jmp 0x2b5c
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2180
movq %rbx, %rdi
callq 0x21e0
nop