LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/davmac314[P]dinit/src/../dasynq/include/dasynq/childproc.h
// Function: void dasynq::v2::child_proc_events<dasynq::v2::dprivate::event_dispatch<dasynq::v2::epoll_traits, dasynq::v2::default_traits<dasynq::null_mutex>>>::init<dasynq::v2::epoll_loop<dasynq::interrupt_channel<dasynq::timer_fd_events<dasynq::v2::child_proc_events<dasynq::v2::dprivate::event_dispatch<dasynq::v2::epoll_traits, dasynq::v2::default_traits<dasynq::null_mutex>>>>, dasynq::null_mutex>>>(dasynq::v2::epoll_loop<dasynq::interrupt_channel<dasynq::timer_fd_events<dasynq::v2::child_proc_events<dasynq::v2::dprivate::event_dispatch<dasynq::v2::epoll_traits, dasynq::v2::default_traits<dasynq::null_mutex>>>>, dasynq::null_mutex>>*)
void init(T *loop_mech)
    {
        // Mask SIGCHLD:
        sigset_t sigmask;
        this->sigmaskf(SIG_UNBLOCK, nullptr, &sigmask);
        sigaddset(&sigmask, SIGCHLD);
        this->sigmaskf(SIG_SETMASK, &sigmask, nullptr);

        // On some systems a SIGCHLD handler must be established, or SIGCHLD will not be
        // generated:
        struct sigaction chld_action;
        chld_action.sa_handler = dasynq::dprivate::sigchld_handler;
        sigemptyset(&chld_action.sa_mask);
        chld_action.sa_flags = 0;
        sigaction(SIGCHLD, &chld_action, nullptr);

        // Specify a dummy user data value - sigchld_handler
        loop_mech->add_signal_watch(SIGCHLD, (void *) dasynq::dprivate::sigchld_handler);
        Base::init(loop_mech);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x120, %rsp            # imm = 0x120
movq %rsi, %rbx
leaq 0xa0(%rsp), %r14
movl $0x1, %edi
xorl %esi, %esi
movq %r14, %rdx
callq 0x3100
movq %r14, %rdi
movl $0x11, %esi
callq 0x33c0
movl $0x2, %edi
movq %r14, %rsi
xorl %edx, %edx
callq 0x3100
leaq 0x4a(%rip), %r14        # 0x699d
leaq 0x10(%rsp), %r15
movq %r14, -0x8(%r15)
movq %r15, %rdi
callq 0x32f0
movl $0x0, 0x80(%r15)
leaq 0x8(%rsp), %rsi
movl $0x11, %edi
xorl %edx, %edx
callq 0x3310
movq %rbx, %rdi
movl $0x11, %esi
movq %r14, %rdx
callq 0x699e
addq $0x120, %rsp            # imm = 0x120
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/davmac314[P]dinit/src/../dasynq/include/dasynq/epoll.h
// Function: dasynq::v2::epoll_loop<dasynq::interrupt_channel<dasynq::timer_fd_events<dasynq::v2::child_proc_events<dasynq::v2::dprivate::event_dispatch<dasynq::v2::epoll_traits, dasynq::v2::default_traits<dasynq::null_mutex>>>>, dasynq::null_mutex>>::add_signal_watch_nolock(int, void*)
void add_signal_watch_nolock(int signo, void *userdata)
    {
        sigdataMap[signo] = userdata;

        // Modify the signal fd to watch the new signal
        bool was_no_sigfd = (sigfd == -1);
        sigaddset(&sigmask, signo);
        sigfd = signalfd(sigfd, &sigmask, SFD_NONBLOCK | SFD_CLOEXEC);
        if (sigfd == -1) {
            throw std::system_error(errno, std::system_category());
        }
        
        if (was_no_sigfd) {
            // Add the signalfd to the epoll set.
            struct epoll_event epevent;
            epevent.data.ptr = &sigfd;
            epevent.events = EPOLLIN;
            // No need for EPOLLONESHOT - we can pull the signals out
            // as we see them.
            if (epoll_ctl(epfd, EPOLL_CTL_ADD, sigfd, &epevent) == -1) {
                close(sigfd);
                sigfd = -1;
                throw std::system_error(errno, std::system_category());
            }
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movl %esi, (%r15)
addq $0x128, %rdi            # imm = 0x128
movq %r15, %rsi
callq 0x6ac4
movq %r14, (%rax)
movl 0xa4(%rbx), %ebp
leaq 0xa8(%rbx), %r14
movl (%r15), %esi
movq %r14, %rdi
callq 0x33c0
movl 0xa4(%rbx), %edi
movq %r14, %rsi
movl $0x80800, %edx          # imm = 0x80800
callq 0x3150
movl %eax, 0xa4(%rbx)
cmpl $-0x1, %eax
je 0x6a3b
cmpl $-0x1, %ebp
jne 0x6a30
leaq 0xa4(%rbx), %r14
leaq 0xc(%rsp), %rcx
movq %r14, 0x4(%rcx)
movl $0x1, (%rcx)
movl 0xa0(%rbx), %edi
movl $0x1, %esi
movl %eax, %edx
callq 0x3360
cmpl $-0x1, %eax
je 0x6a63
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x3130
movq %rax, %rbx
callq 0x3040
movl (%rax), %ebp
callq 0x3160
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x52dc
jmp 0x6a98
movl (%r14), %edi
callq 0x3470
movl $0xffffffff, (%r14)     # imm = 0xFFFFFFFF
movl $0x20, %edi
callq 0x3130
movq %rax, %rbx
callq 0x3040
movl (%rax), %ebp
callq 0x3160
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x52dc
movq 0x54e9(%rip), %rsi      # 0xbf88
movq 0x550a(%rip), %rdx      # 0xbfb0
movq %rbx, %rdi
callq 0x3430
jmp 0x6ab0
movq %rax, %r14
movq %rbx, %rdi
callq 0x31b0
movq %r14, %rdi
callq 0x3440
nop
// File: /workspace/github_cpp_makefile_star2_O3/davmac314[P]dinit/src/../dasynq/include/dasynq/timerbase.h
// Function: dasynq::timer_base<dasynq::v2::child_proc_events<dasynq::v2::dprivate::event_dispatch<dasynq::v2::epoll_traits, dasynq::v2::default_traits<dasynq::null_mutex>>>>::remove_timer_nolock(dasynq::dary_heap<dasynq::timer_data, dasynq::time_val, dasynq::compare_timespec, 4>::handle_t&, dasynq::clock_type)
void remove_timer_nolock(timer_handle_t &timer_id, clock_type clock = clock_type::MONOTONIC) noexcept
    {
        auto &timer_queue = this->queue_for_clock(clock);
        if (timer_queue.is_queued(timer_id)) {
            timer_queue.remove(timer_id);
        }
        timer_queue.deallocate(timer_id);
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
xorl %eax, %eax
cmpl $0x1, %edx
sete %al
shll $0x5, %eax
leaq (%rdi,%rax), %r14
addq $0x58, %r14
movq 0x20(%rsi), %rsi
cmpq $-0x1, %rsi
je 0x6d9e
movq %r14, %rdi
callq 0x6dd8
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6db0
// File: /workspace/github_cpp_makefile_star2_O3/davmac314[P]dinit/src/../dasynq/include/dasynq.h
// Function: dasynq::v2::event_loop<dasynq::null_mutex, dasynq::v2::default_traits<dasynq::null_mutex>>::register_timer(dasynq::v2::dprivate::base_timer_watcher*, dasynq::clock_type)
void register_timer(base_timer_watcher *callback, clock_type clock)
    {
        std::lock_guard<mutex_t> guard(loop_mech.lock);
    
        loop_mech.prepare_watcher(callback);
        try {
            loop_mech.add_timer_nolock(callback->timer_handle, callback, clock);
        }
        catch (...) {
            loop_mech.release_watcher(callback);
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r14
leaq 0x10(%rsi), %rbx
movq %rbx, %rsi
callq 0x51bc
movq %rsp, %rdx
movq %r15, (%rdx)
addq $0x20, %r15
xorl %eax, %eax
cmpl $0x1, %ebp
sete %al
shll $0x5, %eax
leaq (%r14,%rax), %rdi
addq $0x58, %rdi
movq %r15, %rsi
callq 0x6ffe
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rdi
callq 0x30e0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4e34
callq 0x3400
jmp 0x6fd8
nop
// File: /workspace/github_cpp_makefile_star2_O3/davmac314[P]dinit/src/../dasynq/include/dasynq/timerfd.h
// Function: dasynq::timer_fd_events<dasynq::v2::child_proc_events<dasynq::v2::dprivate::event_dispatch<dasynq::v2::epoll_traits, dasynq::v2::default_traits<dasynq::null_mutex>>>>::set_timer(dasynq::dary_heap<dasynq::timer_data, dasynq::time_val, dasynq::compare_timespec, 4>::handle_t&, dasynq::time_val const&, dasynq::time_val const&, dasynq::dary_heap<dasynq::timer_data, dasynq::time_val, dasynq::compare_timespec, 4>&, int, bool)
void set_timer(timer_handle_t & timer_id, const time_val &timeouttv, const time_val &intervaltv,
            timer_queue_t &queue, int fd, bool enable) noexcept
    {
        timespec timeout = timeouttv;
        timespec interval = intervaltv;

        std::lock_guard<decltype(Base::lock)> guard(Base::lock);

        auto &ts = queue.node_data(timer_id);
        ts.interval_time = interval;
        ts.expiry_count = 0;
        ts.enabled = enable;

        if (queue.is_queued(timer_id)) {
            // Already queued; alter timeout
            if (queue.set_priority(timer_id, timeout)) {
                set_timer_from_queue(fd, queue);
            }
        }
        else {
            if (queue.insert(timer_id, timeout)) {
                set_timer_from_queue(fd, queue);
            }
        }
    }

// Assembly:
pushq %rbp
pushq %rbx
subq $0x18, %rsp
movl %r9d, %ebp
movq %r8, %rbx
movb 0x30(%rsp), %r8b
movq (%rdx), %rdi
movq 0x8(%rdx), %rax
movups (%rcx), %xmm0
movups %xmm0, (%rsi)
movl $0x0, 0x10(%rsi)
movb %r8b, 0x14(%rsi)
cmpq $-0x1, 0x20(%rsi)
je 0x729c
leaq 0x8(%rsp), %rdx
movq %rdi, (%rdx)
movq %rax, 0x8(%rdx)
movq %rbx, %rdi
callq 0x72c6
jmp 0x72b0
leaq 0x8(%rsp), %rdx
movq %rdi, (%rdx)
movq %rax, 0x8(%rdx)
movq %rbx, %rdi
callq 0x7362
testb %al, %al
je 0x72be
movl %ebp, %edi
movq %rbx, %rsi
callq 0x7330
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/davmac314[P]dinit/src/../dasynq/include/dasynq/daryheap.h
// Function: dasynq::dary_heap<dasynq::timer_data, dasynq::time_val, dasynq::compare_timespec, 4>::set_priority(dasynq::dary_heap<dasynq::timer_data, dasynq::time_val, dasynq::compare_timespec, 4>::handle_t&, dasynq::time_val const&)
bool set_priority(handle_t & hnd, const P& p) noexcept
    {
        int heap_index = hnd.heap_index;

        Compare lt;
        if (lt(hvec[heap_index].prio, p)) {
            // Increase key
            hvec[heap_index].prio = p;
            bubble_up(heap_index);
            return false;
        }
        else {
            // Decrease key
            hvec[heap_index].prio = p;
            return bubble_down(heap_index);
        }
    }

// Assembly:
subq $0x18, %rsp
movslq 0x20(%rsi), %rsi
movq (%rdi), %rcx
leaq (%rsi,%rsi,2), %rax
leaq (%rcx,%rax,8), %rcx
movq (%rdx), %r8
cmpq %r8, (%rcx)
jl 0x72ed
jne 0x730e
movq 0x8(%rdx), %r8
cmpq %r8, 0x8(%rcx)
jge 0x730e
movups (%rdx), %xmm0
movups %xmm0, (%rcx)
movq (%rdi), %rdx
movups (%rdx,%rax,8), %xmm0
movq %rsp, %rcx
movaps %xmm0, (%rcx)
movq 0x10(%rdx,%rax,8), %rdx
callq 0x6e22
xorl %eax, %eax
jmp 0x732b
movups (%rdx), %xmm0
movups %xmm0, (%rcx)
movq (%rdi), %rcx
movq 0x10(%rcx,%rax,8), %rdx
movups (%rcx,%rax,8), %xmm0
movq %rsp, %rcx
movaps %xmm0, (%rcx)
callq 0x73a0
addq $0x18, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O3/davmac314[P]dinit/src/../dasynq/include/dasynq/timerfd.h
// Function: dasynq::timer_fd_events<dasynq::v2::child_proc_events<dasynq::v2::dprivate::event_dispatch<dasynq::v2::epoll_traits, dasynq::v2::default_traits<dasynq::null_mutex>>>>::set_timer_from_queue(int, dasynq::dary_heap<dasynq::timer_data, dasynq::time_val, dasynq::compare_timespec, 4>&)
static void set_timer_from_queue(int fd, timer_queue_t &queue) noexcept
    {
        struct itimerspec newtime;
        if (queue.empty()) {
            newtime.it_value = {0, 0};
            newtime.it_interval = {0, 0};
        }
        else {
            newtime.it_value = queue.get_root_priority();
            newtime.it_interval = {0, 0};
        }
        timerfd_settime(fd, TFD_TIMER_ABSTIME, &newtime, nullptr);
    }

// Assembly:
xorps %xmm0, %xmm0
cmpq $0x0, 0x8(%rsi)
xorps %xmm1, %xmm1
je 0x7343
movq (%rsi), %rax
movups (%rax), %xmm1
subq $0x28, %rsp
movq %rsp, %rdx
movaps %xmm1, 0x10(%rdx)
movaps %xmm0, (%rdx)
movl $0x1, %esi
xorl %ecx, %ecx
callq 0x31d0
addq $0x28, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O3/davmac314[P]dinit/src/../dasynq/include/dasynq/epoll.h
// Function: dasynq::v2::epoll_loop<dasynq::interrupt_channel<dasynq::timer_fd_events<dasynq::v2::child_proc_events<dasynq::v2::dprivate::event_dispatch<dasynq::v2::epoll_traits, dasynq::v2::default_traits<dasynq::null_mutex>>>>, dasynq::null_mutex>>::pull_events(bool)
void pull_events(bool do_wait)
    {
        epoll_event events[16];
        int r = epoll_wait(epfd, events, 16, do_wait ? -1 : 0);
        if (r == -1 || r == 0) {
            // signal or no events
            return;
        }
    
        do {
            process_events(events, r);
            r = epoll_wait(epfd, events, 16, 0);
        } while (r > 0);
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0xc8, %rsp
movl %esi, %ecx
movq %rdi, %rbx
movl 0xa0(%rdi), %edi
negl %ecx
movq %rsp, %rsi
movl $0x10, %edx
callq 0x3110
leal 0x1(%rax), %ecx
cmpl $0x2, %ecx
jb 0x753b
movq %rsp, %r14
movq %rbx, %rdi
movq %r14, %rsi
movl %eax, %edx
callq 0x75f2
movl 0xa0(%rbx), %edi
movq %r14, %rsi
movl $0x10, %edx
xorl %ecx, %ecx
callq 0x3110
testl %eax, %eax
jg 0x7515
addq $0xc8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/davmac314[P]dinit/src/../dasynq/include/dasynq/childproc.h
// Function: bool dasynq::v2::child_proc_events<dasynq::v2::dprivate::event_dispatch<dasynq::v2::epoll_traits, dasynq::v2::default_traits<dasynq::null_mutex>>>::receive_signal<dasynq::v2::epoll_loop<dasynq::interrupt_channel<dasynq::timer_fd_events<dasynq::v2::child_proc_events<dasynq::v2::dprivate::event_dispatch<dasynq::v2::epoll_traits, dasynq::v2::default_traits<dasynq::null_mutex>>>>, dasynq::null_mutex>>>(dasynq::v2::epoll_loop<dasynq::interrupt_channel<dasynq::timer_fd_events<dasynq::v2::child_proc_events<dasynq::v2::dprivate::event_dispatch<dasynq::v2::epoll_traits, dasynq::v2::default_traits<dasynq::null_mutex>>>>, dasynq::null_mutex>>&, dasynq::v2::epoll_traits::sigdata_t&, void*)
bool receive_signal(T & loop_mech, sigdata_t &siginfo, void *userdata)
    {
        if (siginfo.get_signo() == SIGCHLD) {
            reaper_lock.lock();

            siginfo_t child_info;
            child_info.si_pid = 0; // for portability inc. MacOS
            while (waitid(P_ALL, 0 /* ignored */, &child_info, WNOHANG | WEXITED) == 0) {
                pid_t child = child_info.si_pid;
                if (child == 0) break;
                auto ent = child_waiters.remove(child);
                if (ent.first) {
                    Base::receive_child_stat(child, { child_info.si_code, child_info.si_status },
                            ent.second);
                }
                child_info.si_pid = 0;
            }

            reaper_lock.unlock();
            return false; // leave signal watch enabled
        }
        else {
            return Base::receive_signal(loop_mech, siginfo, userdata);
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x90, %rsp
movq %rdi, %rbx
movl (%rdx), %ebp
cmpl $0x11, %ebp
je 0x77d5
movq %rcx, %rax
leaq 0x20(%rcx), %rdi
movl $0x10, %ecx
movq %rdx, %rsi
rep  movsq (%rsi), %es:(%rdi)
movl 0x18(%rax), %ecx
addq $0x10, %rax
movq 0x20(%rbx), %rsi
leaq 0x1(%rsi), %rdx
movq %rdx, 0x20(%rbx)
leaq 0x10(%rsp), %rdx
movl %ecx, (%rdx)
movq %rsi, 0x8(%rdx)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x4ed0
jmp 0x7870
leaq 0x10(%rsp), %rdx
movl $0x0, 0x10(%rdx)
xorl %edi, %edi
xorl %esi, %esi
movl $0x5, %ecx
callq 0x30a0
testl %eax, %eax
jne 0x7870
leaq 0x28(%rbx), %r14
movq %rsp, %r15
leaq 0x10(%rsp), %r12
movl 0x20(%rsp), %esi
testl %esi, %esi
je 0x7870
movq %r14, %rdi
callq 0x795a
testb $0x1, %al
je 0x7853
movl 0x18(%rsp), %eax
movl 0x28(%rsp), %ecx
shlq $0x20, %rcx
orq %rax, %rcx
movq %rcx, 0x34(%rdx)
orb $0x10, 0xc(%rdx)
movq %rdx, %rsi
addq $0x10, %rsi
movl 0x18(%rdx), %eax
movq 0x20(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x20(%rbx)
movl %eax, (%rsp)
movq %rcx, 0x8(%rsp)
movq %rbx, %rdi
movq %r15, %rdx
callq 0x4ed0
movl $0x0, 0x20(%rsp)
xorl %edi, %edi
xorl %esi, %esi
movq %r12, %rdx
movl $0x5, %ecx
callq 0x30a0
testl %eax, %eax
je 0x77ff
cmpl $0x11, %ebp
setne %al
addq $0x90, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/davmac314[P]dinit/src/../dasynq/include/dasynq/timerfd.h
// Function: std::tuple<int, dasynq::v2::epoll_traits::fd_s> dasynq::timer_fd_events<dasynq::v2::child_proc_events<dasynq::v2::dprivate::event_dispatch<dasynq::v2::epoll_traits, dasynq::v2::default_traits<dasynq::null_mutex>>>>::receive_fd_event<dasynq::v2::epoll_loop<dasynq::interrupt_channel<dasynq::timer_fd_events<dasynq::v2::child_proc_events<dasynq::v2::dprivate::event_dispatch<dasynq::v2::epoll_traits, dasynq::v2::default_traits<dasynq::null_mutex>>>>, dasynq::null_mutex>>>(dasynq::v2::epoll_loop<dasynq::interrupt_channel<dasynq::timer_fd_events<dasynq::v2::child_proc_events<dasynq::v2::dprivate::event_dispatch<dasynq::v2::epoll_traits, dasynq::v2::default_traits<dasynq::null_mutex>>>>, dasynq::null_mutex>>&, dasynq::v2::epoll_traits::fd_r, void*, int)
std::tuple<int, typename traits_t::fd_s>
    receive_fd_event(T &loop_mech, typename traits_t::fd_r fd_r_a, void * userdata, int flags)
    {
        if (userdata == &timerfd_fd) {
            process_timer(clock_type::MONOTONIC, timerfd_fd);
            unsigned re_enable = (Base::traits_t::supports_non_oneshot_fd ? 0 : IN_EVENTS);
            return std::make_tuple(re_enable, typename traits_t::fd_s(timerfd_fd));
        }
        else if (userdata == &systemtime_fd) {
            process_timer(clock_type::SYSTEM, systemtime_fd);
            unsigned re_enable = (Base::traits_t::supports_non_oneshot_fd ? 0 : IN_EVENTS);
            return std::make_tuple(re_enable, typename traits_t::fd_s(systemtime_fd));
        }
        else {
            return Base::receive_fd_event(loop_mech, fd_r_a, userdata, flags);
        }
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x98(%rsi), %rax
cmpq %rcx, %rax
je 0x78b5
leaq 0x9c(%r14), %rax
cmpq %rcx, %rax
je 0x78d2
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7a2e
jmp 0x78f3
movl 0x98(%r14), %edx
movq %r14, %rdi
movl $0x1, %esi
callq 0x79d0
movl 0x98(%r14), %eax
jmp 0x78ea
movl 0x9c(%r14), %edx
movq %r14, %rdi
xorl %esi, %esi
callq 0x79d0
movl 0x9c(%r14), %eax
movl %eax, (%rbx)
movl $0x0, 0x4(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/davmac314[P]dinit/src/../dasynq/include/dasynq/childproc.h
// Function: dasynq::dprivate::pid_map::remove(int)
entry remove(pid_t key) noexcept
    {
        auto it = b_map.find(key);
        if (it == nullptr) {
            return entry(false, nullptr);
        }
        b_map.remove(*it);
        return entry(true, b_map.node_data(*it));
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x4(%rsp), %rax
movl %esi, (%rax)
movq %rax, %rsi
callq 0x7996
testq %rax, %rax
je 0x798a
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x59a0
movq (%r14), %rdx
movb $0x1, %al
jmp 0x798e
xorl %eax, %eax
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/davmac314[P]dinit/src/../dasynq/include/dasynq/btree_set.h
// Function: dasynq::btree_set<void*, int, std::less<int>, 8>::find(int const&)
handle_t *find(const P &pval)
    {
        septnode * cursept = root_sept;
        while (cursept != nullptr) {
            int i;
            for (i = 0; i < N && cursept->hn_p[i] != nullptr; i++) {
                if (cursept->prio[i] == pval) {
                    return cursept->hn_p[i];
                }
                if (cursept->prio[i] > pval) {
                    break;
                }
            }
            cursept = cursept->children[i];
        }

        return nullptr;
    }

// Assembly:
movq (%rdi), %rcx
testq %rcx, %rcx
je 0x79cd
movl (%rsi), %edx
xorl %esi, %esi
movq 0x20(%rcx,%rsi,8), %rax
testq %rax, %rax
je 0x79c1
cmpl %edx, (%rcx,%rsi,4)
je 0x79cf
jg 0x79c1
incq %rsi
cmpq $0x8, %rsi
jne 0x79a2
movl $0x8, %esi
movl %esi, %eax
movq 0x60(%rcx,%rax,8), %rcx
testq %rcx, %rcx
jne 0x79a0
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/davmac314[P]dinit/src/../dasynq/include/dasynq/timerfd.h
// Function: dasynq::timer_fd_events<dasynq::v2::child_proc_events<dasynq::v2::dprivate::event_dispatch<dasynq::v2::epoll_traits, dasynq::v2::default_traits<dasynq::null_mutex>>>>::process_timer(dasynq::clock_type, int)
void process_timer(clock_type clock, int fd) noexcept
    {
        timer_queue_t &queue = this->queue_for_clock(clock);
        struct timespec curtime;
        switch (clock) {
        case clock_type::SYSTEM:
            clock_gettime(CLOCK_REALTIME, &curtime);
            break;
        case clock_type::MONOTONIC:
            clock_gettime(CLOCK_MONOTONIC, &curtime);
            break;
        default:
            DASYNQ_UNREACHABLE;
        }

        timer_base<Base>::process_timer_queue(queue, curtime);

        // arm timerfd with timeout from head of queue
        set_timer_from_queue(fd, queue);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
xorl %edi, %edi
testl %esi, %esi
setne %dil
movq %rsp, %r15
movq %r15, %rsi
callq 0x3240
xorl %eax, %eax
cmpl $0x1, %ebp
sete %al
shll $0x5, %eax
leaq (%r14,%rax), %r12
addq $0x58, %r12
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x7b0e
movl %ebx, %edi
movq %r12, %rsi
callq 0x7330
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/statgen[P]statgen/lib/tclap-1.2.0/examples/../include/tclap/SwitchArg.h
// Function: TCLAP::SwitchArg::processArg(int*, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&)
inline bool SwitchArg::processArg(int *i, std::vector<std::string>& args)
{
	if ( _ignoreable && Arg::ignoreRest() )
		return false;

	if ( argMatches( args[*i] ) || combinedSwitchesMatch( args[*i] ) )
	{
		// If we match on a combined switch, then we want to return false
		// so that other switches in the combination will also have a
		// chance to match.
		bool ret = false;
		if ( argMatches( args[*i] ) )
			ret = true;

		if ( _alreadySet || ( !ret && combinedSwitchesMatch( args[*i] ) ) )
			throw(CmdLineParseException("Argument already set!", toString()));	

		_alreadySet = true;

		if ( _value == true )
			_value = false;
		else
			_value = true;

		_checkWithVisitor();

		return ret;
	}
	else
		return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
cmpb $0x1, 0xa0(%rdi)
jne 0x3a1b
cmpb $0x0, 0xb7d5(%rip)      # 0xf1ea
jne 0x3aa5
movslq (%r15), %rsi
shlq $0x5, %rsi
addq (%rbx), %rsi
movq (%r14), %rax
movq %r14, %rdi
callq *0x30(%rax)
testb %al, %al
jne 0x3a48
movslq (%r15), %rsi
shlq $0x5, %rsi
addq (%rbx), %rsi
movq %r14, %rdi
callq 0x3b88
testb %al, %al
je 0x3aa5
movslq (%r15), %rsi
shlq $0x5, %rsi
addq (%rbx), %rsi
movq (%r14), %rax
movq %r14, %rdi
callq *0x30(%rax)
cmpb $0x0, 0x91(%r14)
jne 0x3ab4
movl %eax, %ebp
testb %al, %al
jne 0x3a81
movslq (%r15), %rsi
shlq $0x5, %rsi
addq (%rbx), %rsi
movq %r14, %rdi
callq 0x3b88
testb %al, %al
jne 0x3ab4
movb $0x1, 0x91(%r14)
xorb $0x1, 0xa3(%r14)
movq 0x98(%r14), %rdi
testq %rdi, %rdi
je 0x3aa7
movq (%rdi), %rax
callq *0x10(%rax)
jmp 0x3aa7
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x68, %edi
callq 0x30e0
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x7533(%rip), %rsi      # 0xb004
leaq 0x7541(%rip), %rdx      # 0xb019
leaq 0x8(%rsp), %rdi
callq 0x6ef2
movq (%r14), %rax
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq *0x38(%rax)
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
leaq 0x28(%rsp), %rdx
movq %rbx, %rdi
callq 0x3d26
xorl %ebp, %ebp
leaq 0xae6a(%rip), %rsi      # 0xe978
leaq 0x64f3(%rip), %rdx      # 0xa008
movq %rbx, %rdi
callq 0x32e0
movq %rax, %r14
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3b3b
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x31c0
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x3b52
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x31c0
testb %bpl, %bpl
jne 0x3b78
jmp 0x3b80
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x3b78
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x31c0
jmp 0x3b78
movq %rax, %r14
movq %rbx, %rdi
callq 0x3150
movq %r14, %rdi
callq 0x3300
// File: /workspace/github_cpp_makefile_star2_O3/statgen[P]statgen/lib/tclap-1.2.0/examples/../include/tclap/SwitchArg.h
// Function: TCLAP::SwitchArg::combinedSwitchesMatch(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
inline bool SwitchArg::combinedSwitchesMatch(std::string& combinedSwitches )
{
	// make sure this is actually a combined switch
	if ( combinedSwitches.length() > 0 &&
	     combinedSwitches[0] != Arg::flagStartString()[0] )
		return false;

	// make sure it isn't a long name 
	if ( combinedSwitches.substr( 0, Arg::nameStartString().length() ) == 
		 Arg::nameStartString() )
		return false;

	// make sure the delimiter isn't in the string 
	if ( combinedSwitches.find_first_of( Arg::delimiter() ) != std::string::npos )
		return false;

	// ok, we're not specifying a ValueArg, so we know that we have
	// a combined switch list.  
	for ( unsigned int i = 1; i < combinedSwitches.length(); i++ )
		if ( _flag.length() > 0 && 
		     combinedSwitches[i] == _flag[0] &&
		     _flag[0] != Arg::flagStartString()[0] ) 
		{
			// update the combined switches so this one is no longer present
			// this is necessary so that no unlabeled args are matched
			// later in the processing.
			//combinedSwitches.erase(i,1);
			combinedSwitches[i] = Arg::blankChar(); 
			return true;
		}

	// none of the switches passed in the list match. 
	return false;	
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x0, 0x8(%rsi)
je 0x3bab
movq (%rbx), %rax
cmpb $0x2d, (%rax)
jne 0x3c45
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movw $0x2d2d, (%r15)         # imm = 0x2D2D
movq $0x2, -0x8(%r15)
movb $0x0, 0x2(%r15)
leaq 0x28(%rsp), %rdi
movl $0x2, %ecx
movq %rbx, %rsi
xorl %edx, %edx
callq 0x31e0
leaq 0x58(%rsp), %rax
movq %rax, -0x10(%rax)
movw $0x2d2d, (%rax)         # imm = 0x2D2D
movq $0x2, -0x8(%rax)
movb $0x0, 0x2(%rax)
movq 0x28(%rsp), %rdi
cmpq $0x2, 0x30(%rsp)
jne 0x3c10
movzwl (%rdi), %eax
cmpw 0x58(%rsp), %ax
sete %bpl
jmp 0x3c12
xorl %ebp, %ebp
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x3c29
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x31c0
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x3c40
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x31c0
testb %bpl, %bpl
je 0x3c4a
xorl %r15d, %r15d
jmp 0x3c64
movsbl 0xb567(%rip), %esi      # 0xf1b8
xorl %r15d, %r15d
movq %rbx, %rdi
xorl %edx, %edx
callq 0x3240
cmpq $-0x1, %rax
je 0x3c72
movl %r15d, %eax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%rbx), %rax
cmpq $0x2, %rax
jb 0x3c45
movq 0x8(%r14), %rcx
movq 0x10(%r14), %rsi
movq (%rbx), %rdx
movl $0x1, %edi
movl $0x2, %r8d
testq %rsi, %rsi
je 0x3caf
movb (%rdx,%rdi), %r9b
cmpb (%rcx), %r9b
setne %r10b
cmpb $0x2d, %r9b
sete %r9b
orb %r10b, %r9b
je 0x3cbc
movl %r8d, %edi
incl %r8d
cmpq %rdi, %rax
ja 0x3c92
jmp 0x3c45
movb $0x7, (%rdx,%rdi)
movb $0x1, %r15b
jmp 0x3c64
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x3cdf
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x31c0
movq %rbx, %rdi
callq 0x3300
nop
// File: /workspace/github_cpp_makefile_star2_O3/statgen[P]statgen/lib/tclap-1.2.0/examples/../include/tclap/StdOutput.h
// Function: TCLAP::StdOutput::usage(TCLAP::CmdLineInterface&)
inline void StdOutput::usage(CmdLineInterface& _cmd ) 
{
	std::cout << std::endl << "USAGE: " << std::endl << std::endl; 

	_shortUsage( _cmd, std::cout );

	std::cout << std::endl << std::endl << "Where: " << std::endl << std::endl;

	_longUsage( _cmd, std::cout );

	std::cout << std::endl; 

}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
movq 0xadf5(%rip), %rbx      # 0xefd0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3190
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3130
movq %rax, %r12
leaq 0x7214(%rip), %rsi      # 0xb420
movl $0x7, %edx
movq %rax, %rdi
callq 0x3200
movq (%r12), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x3190
movsbl %al, %esi
movq %r12, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3130
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x3190
movsbl %al, %esi
movq %r12, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3130
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x4374
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3190
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3130
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x3190
movsbl %al, %esi
movq %r12, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3130
movq %rax, %r12
leaq 0x6d46(%rip), %rsi      # 0xb01a
movl $0x7, %edx
movq %rax, %rdi
callq 0x3200
movq (%r12), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x3190
movsbl %al, %esi
movq %r12, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3130
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x3190
movsbl %al, %esi
movq %r12, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3130
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x4a04
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3190
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3130
nop
// File: /workspace/github_cpp_makefile_star2_O3/statgen[P]statgen/lib/tclap-1.2.0/examples/../include/tclap/CmdLine.h
// Function: TCLAP::CmdLine::~CmdLine()
inline CmdLine::~CmdLine()
{
	ClearContainer(_argDeleteOnExitList);
	ClearContainer(_visitorDeleteOnExitList);

	if ( !_userSetOutput ) {
		delete _output;
		_output = 0;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x9914(%rip), %rax      # 0xe9a0
movq %rax, (%rdi)
leaq 0xa0(%rdi), %r14
movq %r14, %rdi
callq 0x4fed
leaq 0xb8(%rbx), %r15
movq %r15, %rdi
callq 0x502d
cmpb $0x0, 0xd9(%rbx)
jne 0x50d3
movq 0xd0(%rbx), %rdi
testq %rdi, %rdi
je 0x50c8
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0xd0(%rbx)
movq (%r15), %rdi
cmpq %r15, %rdi
je 0x50f0
movq (%rdi), %r12
movl $0x18, %esi
callq 0x31c0
movq %r12, %rdi
cmpq %r15, %r12
jne 0x50db
movq (%r14), %rdi
cmpq %r14, %rdi
je 0x510d
movq (%rdi), %r15
movl $0x18, %esi
callq 0x31c0
movq %r15, %rdi
cmpq %r14, %r15
jne 0x50f8
leaq 0x88(%rbx), %rdi
callq 0x76e4
movq 0x60(%rbx), %rdi
leaq 0x70(%rbx), %rax
cmpq %rax, %rdi
je 0x5131
movq (%rax), %rsi
incq %rsi
callq 0x31c0
movq 0x40(%rbx), %rdi
leaq 0x50(%rbx), %rax
cmpq %rax, %rdi
je 0x5149
movq (%rax), %rsi
incq %rsi
callq 0x31c0
movq 0x20(%rbx), %rdi
leaq 0x30(%rbx), %rax
cmpq %rax, %rdi
je 0x5161
movq (%rax), %rsi
incq %rsi
callq 0x31c0
movq 0x8(%rbx), %rdi
addq $0x8, %rbx
cmpq %rbx, %rdi
je 0x5183
movq (%rdi), %r14
movl $0x18, %esi
callq 0x31c0
movq %r14, %rdi
cmpq %rbx, %r14
jne 0x516e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rdi
callq 0x5022
nop
// File: /workspace/github_cpp_makefile_star2_O3/statgen[P]statgen/lib/tclap-1.2.0/examples/../include/tclap/CmdLine.h
// Function: TCLAP::CmdLine::parse(int, char const* const*)
inline void CmdLine::parse(int argc, const char * const * argv)
{
		// this step is necessary so that we have easy access to
		// mutable strings.
		std::vector<std::string> args;
		for (int i = 0; i < argc; i++)
			args.push_back(argv[i]);

		parse(args);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, 0x30(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
testl %esi, %esi
jle 0x5500
movq %rdx, %r14
movl %esi, %ebx
xorl %ebp, %ebp
leaq 0x38(%rsp), %r15
leaq 0xf(%rsp), %r12
leaq 0x10(%rsp), %r13
movq (%r14,%rbp,8), %rsi
movq %r15, %rdi
movq %r12, %rdx
callq 0x3ce8
movq %r13, %rdi
movq %r15, %rsi
callq 0x93ca
movq 0x38(%rsp), %rdi
leaq 0x48(%rsp), %rax
cmpq %rax, %rdi
je 0x54f8
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x31c0
incq %rbp
cmpq %rbp, %rbx
jne 0x54c2
leaq 0x10(%rsp), %rsi
movq 0x30(%rsp), %rdi
callq 0x8f3e
leaq 0x10(%rsp), %rdi
callq 0x936c
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x552a
movq %rax, %rbx
jmp 0x554e
movq %rax, %rbx
movq 0x38(%rsp), %rdi
leaq 0x48(%rsp), %rax
cmpq %rax, %rdi
je 0x554e
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x31c0
leaq 0x10(%rsp), %rdi
callq 0x936c
movq %rbx, %rdi
callq 0x3300
// File: /workspace/github_cpp_makefile_star2_O3/statgen[P]statgen/lib/tclap-1.2.0/examples/../include/tclap/Arg.h
// Function: TCLAP::Arg::operator==(TCLAP::Arg const&) const
inline bool Arg::operator==(const Arg& a) const
{
	if ( ( _flag != "" && _flag == a._flag ) || _name == a._name)
		return true;
	else
		return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rdi), %r15
leaq 0x5dd3(%rip), %rsi      # 0xb419
movq %r15, %rdi
callq 0x3070
testl %eax, %eax
je 0x5674
movq 0x10(%rbx), %rdx
cmpq 0x10(%r14), %rdx
jne 0x5674
movb $0x1, %bpl
testq %rdx, %rdx
je 0x569f
movq 0x8(%r14), %rsi
movq (%r15), %rdi
callq 0x31d0
testl %eax, %eax
je 0x569f
movq 0x30(%rbx), %rdx
cmpq 0x30(%r14), %rdx
jne 0x5698
testq %rdx, %rdx
je 0x569c
movq 0x28(%r14), %rsi
movq 0x28(%rbx), %rdi
callq 0x31d0
testl %eax, %eax
sete %bpl
jmp 0x569f
xorl %ebp, %ebp
jmp 0x569f
movb $0x1, %bpl
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/statgen[P]statgen/lib/tclap-1.2.0/examples/../include/tclap/Arg.h
// Function: TCLAP::Arg::argMatches(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
inline bool Arg::argMatches( const std::string& argFlag ) const
{
	if ( ( argFlag == Arg::flagStartString() + _flag && _flag != "" ) ||
		 argFlag == Arg::nameStartString() + _name )
		return true;
	else
		return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x80, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x70(%rsp), %r12
movq %r12, -0x10(%r12)
movw $0x2d, (%r12)
movq $0x1, -0x8(%r12)
leaq 0x8(%rdi), %r15
movq %rsp, %rdi
leaq 0x60(%rsp), %rsi
movq %r15, %rdx
callq 0xa504
movq 0x8(%rbx), %rdx
cmpq 0x8(%rsp), %rdx
jne 0x572d
testq %rdx, %rdx
je 0x5713
movq (%rsp), %rsi
movq (%rbx), %rdi
callq 0x31d0
testl %eax, %eax
jne 0x572d
leaq 0x5cff(%rip), %rsi      # 0xb419
movq %r15, %rdi
callq 0x3070
movb $0x1, %bpl
testl %eax, %eax
jne 0x57c4
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
movw $0x2d2d, (%r15)         # imm = 0x2D2D
movq $0x2, -0x8(%r15)
movb $0x0, 0x2(%r15)
addq $0x28, %r14
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rsi
movq %r14, %rdx
callq 0xa504
movq 0x8(%rbx), %rdx
cmpq 0x48(%rsp), %rdx
jne 0x5787
movq 0x40(%rsp), %r14
testq %rdx, %rdx
je 0x5790
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x31d0
testl %eax, %eax
sete %bpl
jmp 0x5793
movq 0x40(%rsp), %r14
xorl %ebp, %ebp
jmp 0x5793
movb $0x1, %bpl
leaq 0x50(%rsp), %rax
cmpq %rax, %r14
je 0x57ad
movq 0x50(%rsp), %rsi
incq %rsi
movq %r14, %rdi
callq 0x31c0
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x57c4
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x31c0
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x57df
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x31c0
movq 0x60(%rsp), %rdi
cmpq %r12, %rdi
je 0x57f6
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x31c0
movl %ebp, %eax
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x5822
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x31c0
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5842
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x31c0
jmp 0x5842
movq %rax, %rbx
movq 0x60(%rsp), %rdi
cmpq %r12, %rdi
je 0x5859
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x31c0
movq %rbx, %rdi
callq 0x3300
nop
// File: /workspace/github_cpp_makefile_star2_O3/statgen[P]statgen/lib/tclap-1.2.0/examples/../include/tclap/Arg.h
// Function: TCLAP::Arg::trimFlag(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) const
inline void Arg::trimFlag(std::string& flag, std::string& value) const
{
	int stop = 0;
	for ( int i = 0; static_cast<unsigned int>(i) < flag.length(); i++ )
		if ( flag[i] == Arg::delimiter() )
		{
			stop = i;
			break;
		}

	if ( stop > 1 )
	{
		value = flag.substr(stop+1);
		flag = flag.substr(0,stop);
	}

}

// Assembly:
movq 0x8(%rsi), %rax
testq %rax, %rax
je 0x665d
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq (%rsi), %rcx
movb 0x8bf5(%rip), %dl       # 0xf1b8
xorl %r12d, %r12d
cmpb %dl, (%rcx,%r12)
je 0x65d6
incq %r12
cmpq %r12, %rax
jne 0x65c6
jmp 0x6652
cmpq $0x2, %r12
jb 0x6652
leal 0x1(%r12), %edx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
movq $-0x1, %rcx
callq 0x31e0
movq %r14, %rdi
movq %r15, %rsi
callq 0x3230
movq (%r15), %rdi
leaq 0x18(%rsp), %r15
cmpq %r15, %rdi
je 0x661d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x31c0
movl %r12d, %ecx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x31e0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3230
movq (%r14), %rdi
cmpq %r15, %rdi
je 0x6652
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x31c0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/statgen[P]statgen/lib/tclap-1.2.0/examples/../include/tclap/StdOutput.h
// Function: TCLAP::StdOutput::version(TCLAP::CmdLineInterface&)
inline void StdOutput::version(CmdLineInterface& _cmd) 
{
	std::string progName = _cmd.getProgramName();
	std::string version = _cmd.getVersion();

	std::cout << std::endl << progName << "  version: " 
			  << version << std::endl << std::endl;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq (%rsi), %rax
movq %rsi, %rdi
callq *0x50(%rax)
leaq 0x30(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
leaq 0x20(%rsp), %rdi
callq 0x7250
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x48(%rax)
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
movq %rsp, %rdi
callq 0x7250
movq 0x87dd(%rip), %rdi      # 0xefd0
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0xa, %esi
callq 0x3190
movsbl %al, %esi
movq 0x87c2(%rip), %rdi      # 0xefd0
callq 0x3030
movq %rax, %rdi
callq 0x3130
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq %rax, %rdi
callq 0x3200
movq %rax, %rbx
leaq 0x4bbb(%rip), %rsi      # 0xb3f2
movl $0xb, %edx
movq %rax, %rdi
callq 0x3200
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x3200
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3190
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3130
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3190
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3130
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x68bf
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x31c0
movq 0x20(%rsp), %rdi
cmpq %r14, %rdi
je 0x68d6
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x31c0
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
jmp 0x68fe
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x68fe
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x31c0
movq 0x20(%rsp), %rdi
cmpq %r14, %rdi
je 0x6915
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x31c0
movq %rbx, %rdi
callq 0x3300
nop
// File: /workspace/github_cpp_makefile_star2_O3/statgen[P]statgen/lib/tclap-1.2.0/examples/../include/tclap/CmdLine.h
// Function: TCLAP::CmdLine::add(TCLAP::Arg*)
inline void CmdLine::add( Arg* a )
{
	for( ArgListIterator it = _argList.begin(); it != _argList.end(); it++ )
		if ( *a == *(*it) )
			throw( SpecificationException(
			       	"Argument with same flag/name already exists!",
					a->longID() ) );

	a->addToList( _argList );

	if ( a->isRequired() )
		_numRequired++;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rdi), %r15
movq %r15, %r12
movq (%r12), %r12
cmpq %r15, %r12
je 0x6c6a
movq 0x10(%r12), %rsi
movq (%r14), %rax
movq %r14, %rdi
callq *0x20(%rax)
testb %al, %al
je 0x6bbf
movl $0x68, %edi
callq 0x30e0
movq %rax, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x4863(%rip), %rsi      # 0xb45e
leaq 0x4888(%rip), %rdx      # 0xb48a
movq %rsp, %rdi
callq 0x6ef2
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x44c9(%rip), %rsi      # 0xb0e4
leaq 0x44c5(%rip), %rdx      # 0xb0e7
leaq 0x20(%rsp), %rdi
callq 0x6ef2
movq (%r14), %rax
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rdx
movq %r14, %rsi
callq *0x48(%rax)
movb $0x1, %bpl
movq %rsp, %rsi
leaq 0x40(%rsp), %rdx
movq %rbx, %rdi
callq 0x8ba8
xorl %ebp, %ebp
leaq 0x7fad(%rip), %rsi      # 0xec08
leaq 0x33a6(%rip), %rdx      # 0xa008
movq %rbx, %rdi
callq 0x32e0
movq (%r14), %rax
movq %r14, %rdi
movq %r15, %rsi
callq *0x10(%rax)
movq (%r14), %rax
movq %r14, %rdi
callq *0x28(%rax)
testb %al, %al
je 0x6c89
incl 0x80(%rbx)
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6cbc
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x31c0
jmp 0x6cbc
movq %rax, %r14
movb $0x1, %bpl
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x6cd3
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x31c0
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x6ce9
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x31c0
testb %bpl, %bpl
jne 0x6d0e
jmp 0x6d16
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x6d0e
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x31c0
jmp 0x6d0e
movq %rax, %r14
movq %rbx, %rdi
callq 0x3150
movq %r14, %rdi
callq 0x3300
// File: /workspace/github_cpp_makefile_star2_O3/statgen[P]statgen/lib/tclap-1.2.0/examples/../include/tclap/CmdLine.h
// Function: TCLAP::CmdLine::xorAdd(TCLAP::Arg&, TCLAP::Arg&)
inline void CmdLine::xorAdd( Arg& a, Arg& b )
{
    std::vector<Arg*> ors;
    ors.push_back( &a );
    ors.push_back( &b );
	xorAdd( ors );
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
leaq 0x20(%rsp), %rax
movq %rsi, (%rax)
movq %rax, %rsi
callq 0xa5bc
leaq 0x20(%rsp), %rsi
movq %r14, (%rsi)
movq %rsp, %rdi
callq 0xa5bc
movq (%rbx), %rax
movq %rsp, %rsi
movq %rbx, %rdi
callq *0x28(%rax)
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x6d7e
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x31c0
addq $0x28, %rsp
popq %rbx
popq %r14
retq
jmp 0x6d8a
jmp 0x6d8a
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x6da3
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x31c0
movq %rbx, %rdi
callq 0x3300
nop
// File: /workspace/github_cpp_makefile_star2_O3/statgen[P]statgen/lib/tclap-1.2.0/examples/../include/tclap/CmdLine.h
// Function: TCLAP::CmdLine::xorAdd(std::vector<TCLAP::Arg*, std::allocator<TCLAP::Arg*>>&)
inline void CmdLine::xorAdd( std::vector<Arg*>& ors )
{
	_xorHandler.add( ors );

	for (ArgVectorIterator it = ors.begin(); it != ors.end(); it++)
	{
		(*it)->forceRequired();
		(*it)->setRequireLabel( "OR required" );

		add( *it );
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
addq $0x88, %rdi
callq 0xa714
movq (%rbx), %r12
cmpq 0x8(%rbx), %r12
je 0x6e3f
leaq 0x18(%rsp), %r15
leaq 0x8(%rsp), %r13
movq (%r12), %rbp
movb $0x1, 0x68(%rbp)
movq %r15, 0x8(%rsp)
movq %r13, %rdi
leaq 0x4695(%rip), %rsi      # 0xb48b
leaq 0x4699(%rip), %rdx      # 0xb496
callq 0x6ef2
addq $0x70, %rbp
movq %rbp, %rdi
movq %r13, %rsi
callq 0x3100
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x6e28
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x31c0
movq (%r12), %rsi
movq (%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
addq $0x8, %r12
cmpq 0x8(%rbx), %r12
jne 0x6ddf
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x6e68
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x31c0
movq %rbx, %rdi
callq 0x3300
// File: /workspace/github_cpp_makefile_star2_O3/statgen[P]statgen/lib/tclap-1.2.0/examples/../include/tclap/Arg.h
// Function: TCLAP::Arg::getDescription[abi:cxx11]() const
inline std::string Arg::getDescription() const
{
	std::string desc = "";
	if ( _required )
		desc = "(" + _requireLabel + ")  ";

//	if ( _valueRequired )
//		desc += "(value required)  ";

	desc += _description;
	return desc;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
leaq 0x3b12(%rip), %rdx      # 0xb419
movq %rdx, %rsi
callq 0x6ef2
cmpb $0x1, 0x68(%r14)
jne 0x79c2
leaq 0x70(%r14), %rdx
leaq 0x37ce(%rip), %rsi      # 0xb0f3
movq %rsp, %rdi
callq 0x7a24
leaq 0x37c1(%rip), %rsi      # 0xb0f5
movq %rsp, %rdi
callq 0x3340
leaq 0x30(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x7963
movq %rdx, 0x20(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x30(%rsp)
jmp 0x796b
movups (%rcx), %xmm0
movups %xmm0, (%r13)
movq 0x8(%rax), %rdx
leaq 0x20(%rsp), %r15
movq %rdx, 0x8(%r15)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3230
movq (%r15), %rdi
cmpq %r13, %rdi
je 0x79a7
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x31c0
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x79c2
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x31c0
movq 0x48(%r14), %rsi
movq 0x50(%r14), %rdx
movq %rbx, %rdi
callq 0x3080
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7a08
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x31c0
jmp 0x7a08
jmp 0x7a05
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x7a1c
movq (%r12), %rsi
incq %rsi
callq 0x31c0
movq %r14, %rdi
callq 0x3300