LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x38(%rbp)
addq $0x28, %rsi
leaq -0x20(%rbp), %rdi
callq 0x73c0
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x73f0
jmp 0xd927
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq %rdx, %rsi
addq $0x20, %rsi
movl -0x14(%rbp), %ecx
callq 0xd9a0
jmp 0xd940
jmp 0xd984
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x7580
jmp 0xd993
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rdi
callq 0x30d0
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x6940
callq 0x33e0
jmp 0xd982
jmp 0xd984
leaq -0x20(%rbp), %rdi
callq 0x7580
addq $0x40, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x3410
nopl (%rax)
// File: 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_rel(dasynq::dary_heap<dasynq::timer_data, dasynq::time_val, dasynq::compare_timespec, 4>::handle_t&, dasynq::time_val const&, dasynq::time_val const&, bool, dasynq::clock_type)
void set_timer_rel(timer_handle_t & timer_id, const time_val &timeout, const time_val &interval,
            bool enable, clock_type clock = clock_type::MONOTONIC) noexcept
    {
        time_val alarmtime;
        this->get_time(alarmtime, clock, false);
        alarmtime += timeout;

        set_timer(timer_id, alarmtime, interval, enable, clock);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %r8b, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
movl %r9d, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xde10
movq -0x40(%rbp), %rdi
movl -0x28(%rbp), %edx
leaq -0x38(%rbp), %rsi
xorl %ecx, %ecx
callq 0xde20
movq -0x18(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0xde70
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rcx
movb -0x21(%rbp), %al
movl -0x28(%rbp), %r9d
leaq -0x38(%rbp), %rdx
andb $0x1, %al
movzbl %al, %r8d
callq 0xdf30
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: davmac314[P]dinit/src/../dasynq/include/dasynq/timerbase.h
// Function: dasynq::operator+=(dasynq::time_val&, dasynq::time_val const&)
inline time_val &operator+=(time_val &t1, const time_val &t2) noexcept
{
    auto nsum = t1.nseconds() + t2.nseconds();
    t1.seconds() = t1.seconds() + t2.seconds();
    if (nsum >= 1000000000) {
        nsum -= 1000000000;
        t1.seconds()++;
    }
    t1.nseconds() = nsum;
    return t1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0xe0b0
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0xe0d0
movq %rax, %rcx
movq -0x30(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0xe0f0
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0xe100
movq %rax, %rcx
movq -0x28(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0xe0f0
movq -0x20(%rbp), %rcx
movq %rcx, (%rax)
cmpq $0x3b9aca00, -0x18(%rbp) # imm = 0x3B9ACA00
jl 0xdf09
movq -0x18(%rbp), %rax
subq $0x3b9aca00, %rax       # imm = 0x3B9ACA00
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0xe0f0
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
callq 0xe0b0
movq -0x38(%rbp), %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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&, bool, dasynq::clock_type)
void set_timer(timer_handle_t & timer_id, const time_val &timeouttv, const time_val &intervaltv,
            bool enable, clock_type clock = clock_type::MONOTONIC) noexcept
    {
        timespec timeout = timeouttv;
        timespec interval = intervaltv;
        timer_queue_t &queue = this->queue_for_clock(clock);

        switch (clock) {
        case clock_type::SYSTEM:
            set_timer(timer_id, timeout, interval, queue, systemtime_fd, enable);
            break;
        case clock_type::MONOTONIC:
            set_timer(timer_id, timeout, interval, queue, timerfd_fd, enable);
            break;
        default:
            DASYNQ_UNREACHABLE;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movb %r8b, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
movl %r9d, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x18(%rbp), %rdi
callq 0xd780
movq %rax, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
movq -0x20(%rbp), %rdi
callq 0xd780
movq -0x98(%rbp), %rdi
movq %rax, -0x48(%rbp)
movq %rdx, -0x40(%rbp)
movl -0x28(%rbp), %esi
callq 0xd240
movq %rax, -0x50(%rbp)
movl -0x28(%rbp), %eax
testl %eax, %eax
je 0xdfa2
jmp 0xdfa0
jmp 0xdffa
movq -0x10(%rbp), %rax
movq %rax, -0xa0(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xdde0
leaq -0x70(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0xdde0
movq -0x98(%rbp), %rdi
movq -0xa0(%rbp), %rsi
movq -0x50(%rbp), %r8
movl 0x9c(%rdi), %r9d
movb -0x21(%rbp), %al
leaq -0x60(%rbp), %rdx
leaq -0x70(%rbp), %rcx
andb $0x1, %al
movzbl %al, %eax
movl %eax, (%rsp)
callq 0xe120
jmp 0xe058
movq -0x10(%rbp), %rax
movq %rax, -0xa8(%rbp)
leaq -0x80(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xdde0
leaq -0x90(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0xdde0
movq -0x98(%rbp), %rdi
movq -0xa8(%rbp), %rsi
movq -0x50(%rbp), %r8
movl 0x98(%rdi), %r9d
movb -0x21(%rbp), %al
leaq -0x80(%rbp), %rdx
leaq -0x90(%rbp), %rcx
andb $0x1, %al
movzbl %al, %eax
movl %eax, (%rsp)
callq 0xe120
jmp 0xe058
addq $0xb0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xc0, %rsp
movb 0x10(%rbp), %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
andb $0x1, %al
movb %al, -0x2d(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x18(%rbp), %rdi
callq 0xd780
movq %rax, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
movq -0x20(%rbp), %rdi
callq 0xd780
movq -0x98(%rbp), %rsi
movq %rax, -0x50(%rbp)
movq %rdx, -0x48(%rbp)
addq $0x28, %rsi
leaq -0x58(%rbp), %rdi
callq 0x73c0
jmp 0xe18e
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xd280
movq %rax, -0x60(%rbp)
leaq -0x70(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0xdde0
movq -0x60(%rbp), %rax
movq -0x70(%rbp), %rcx
movq %rcx, (%rax)
movq -0x68(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x60(%rbp), %rax
movl $0x0, 0x10(%rax)
movb -0x2d(%rbp), %cl
movq -0x60(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x14(%rax)
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xd2e0
testb $0x1, %al
jne 0xe1ea
jmp 0xe238
movq -0x28(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xa0(%rbp)
leaq -0x80(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0xdde0
movq -0xa8(%rbp), %rdi
movq -0xa0(%rbp), %rsi
leaq -0x80(%rbp), %rdx
callq 0xe2b0
testb $0x1, %al
jne 0xe22a
jmp 0xe236
movl -0x2c(%rbp), %edi
movq -0x28(%rbp), %rsi
callq 0xe3a0
jmp 0xe28c
movq -0x28(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xb0(%rbp)
leaq -0x90(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0xdde0
movq -0xb8(%rbp), %rdi
movq -0xb0(%rbp), %rsi
leaq -0x90(%rbp), %rdx
callq 0xe470
testb $0x1, %al
jne 0xe27e
jmp 0xe28a
movl -0x2c(%rbp), %edi
movq -0x28(%rbp), %rsi
callq 0xe3a0
jmp 0xe28c
leaq -0x58(%rbp), %rdi
callq 0x7580
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x52b0
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x50(%rbp)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movl %eax, -0x24(%rbp)
movslq -0x24(%rbp), %rsi
callq 0xd440
movq %rax, %rdi
callq 0xd780
movq %rax, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
movq -0x20(%rbp), %rdi
callq 0xd780
movq %rax, -0x48(%rbp)
movq %rdx, -0x40(%rbp)
leaq -0x25(%rbp), %rdi
leaq -0x38(%rbp), %rsi
leaq -0x48(%rbp), %rdx
callq 0xd720
testb $0x1, %al
jne 0xe318
jmp 0xe352
movq -0x50(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, -0x58(%rbp)
movslq -0x24(%rbp), %rsi
callq 0xd440
movq -0x58(%rbp), %rcx
movq -0x50(%rbp), %rdi
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movslq -0x24(%rbp), %rsi
callq 0xe4e0
movb $0x0, -0x1(%rbp)
jmp 0xe38b
movq -0x50(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, -0x60(%rbp)
movslq -0x24(%rbp), %rsi
callq 0xd440
movq -0x60(%rbp), %rcx
movq -0x50(%rbp), %rdi
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movslq -0x24(%rbp), %rsi
callq 0xe540
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xe700
testb $0x1, %al
jne 0xe3be
jmp 0xe400
movq $0x0, -0x40(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x50(%rbp)
movq $0x0, -0x48(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0xe449
movq -0x10(%rbp), %rdi
callq 0xe720
movq %rax, %rdi
callq 0xd780
movq %rax, -0x60(%rbp)
movq %rdx, -0x58(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x70(%rbp)
movq $0x0, -0x68(%rbp)
movq -0x70(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x4(%rbp), %edi
movl $0x1, %esi
leaq -0x30(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x31b0
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: davmac314[P]dinit/src/../dasynq/include/dasynq.h
// Function: dasynq::v2::event_loop<dasynq::null_mutex, dasynq::v2::default_traits<dasynq::null_mutex>>::get_pollwait_lock(dasynq::v2::dprivate::waitqueue_node<dasynq::null_mutex>&)
void get_pollwait_lock(waitqueue_node<T_Mutex> &qnode) noexcept
    {
        std::unique_lock<T_Mutex> ulock(wait_lock);
        if (attn_waitqueue.is_empty()) {
            // Queue is completely empty:
            attn_waitqueue.queue(&qnode);
        }
        else {
            wait_waitqueue.queue(&qnode);
        }
        
        while (! attn_waitqueue.check_head(qnode)) {
            qnode.wait(ulock);
        }

        long_poll_running = true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x28(%rbp)
addq $0x160, %rsi            # imm = 0x160
leaq -0x20(%rbp), %rdi
callq 0x84e0
jmp 0xe89a
movq -0x28(%rbp), %rdi
addq $0x161, %rdi            # imm = 0x161
callq 0x7170
testb $0x1, %al
jne 0xe8b0
jmp 0xe8c6
movq -0x28(%rbp), %rdi
addq $0x161, %rdi            # imm = 0x161
movq -0x10(%rbp), %rsi
callq 0x8520
jmp 0xe8da
movq -0x28(%rbp), %rdi
addq $0x162, %rdi            # imm = 0x162
movq -0x10(%rbp), %rsi
callq 0x8520
jmp 0xe8dc
movq -0x28(%rbp), %rdi
addq $0x161, %rdi            # imm = 0x161
movq -0x10(%rbp), %rsi
callq 0x8530
xorb $-0x1, %al
testb $0x1, %al
jne 0xe8f8
jmp 0xe907
movq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x8560
jmp 0xe8dc
movq -0x28(%rbp), %rax
movb $0x1, 0x160(%rax)
leaq -0x20(%rbp), %rdi
callq 0x8570
addq $0x30, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x52b0
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xe0(%rbp)
movl 0xa0(%rax), %edi
leaq -0xd0(%rbp), %rsi
movb -0x9(%rbp), %dl
xorl %ecx, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testb $0x1, %dl
cmovnel %eax, %ecx
movl $0x10, %edx
callq 0x3100
movl %eax, -0xd4(%rbp)
cmpl $-0x1, -0xd4(%rbp)
je 0xe991
cmpl $0x0, -0xd4(%rbp)
jne 0xe993
jmp 0xe9dd
jmp 0xe995
movq -0xe0(%rbp), %rdi
leaq -0xd0(%rbp), %rsi
movl -0xd4(%rbp), %edx
callq 0xeb10
movq -0xe0(%rbp), %rax
movl 0xa0(%rax), %edi
leaq -0xd0(%rbp), %rsi
movl $0x10, %edx
xorl %ecx, %ecx
callq 0x3100
movl %eax, -0xd4(%rbp)
cmpl $0x0, -0xd4(%rbp)
jg 0xe995
addq $0xe0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xd0(%rbp)
movq -0x20(%rbp), %rdi
callq 0xeee0
cmpl $0x11, %eax
jne 0xf09c
movq -0xd0(%rbp), %rdi
addq $0x58, %rdi
callq 0x6030
movl $0x0, -0x98(%rbp)
xorl %esi, %esi
leaq -0xa8(%rbp), %rdx
movl $0x5, %ecx
movl %esi, %edi
callq 0x3090
cmpl $0x0, %eax
jne 0xf086
movl -0x98(%rbp), %eax
movl %eax, -0xac(%rbp)
cmpl $0x0, -0xac(%rbp)
jne 0xf007
jmp 0xf086
movq -0xd0(%rbp), %rdi
addq $0x28, %rdi
movl -0xac(%rbp), %esi
callq 0xf2d0
movb %al, -0xc0(%rbp)
movq %rdx, -0xb8(%rbp)
testb $0x1, -0xc0(%rbp)
je 0xf077
movl -0xac(%rbp), %eax
movl %eax, -0xd4(%rbp)
movl -0xa0(%rbp), %esi
movl -0x90(%rbp), %edx
leaq -0xc8(%rbp), %rdi
callq 0xf3c0
movq -0xd0(%rbp), %rdi
movl -0xd4(%rbp), %esi
movq -0xb8(%rbp), %rcx
movq -0xc8(%rbp), %rdx
callq 0xf370
movl $0x0, -0x98(%rbp)
jmp 0xefd2
movq -0xd0(%rbp), %rdi
addq $0x58, %rdi
callq 0x5fe0
movb $0x0, -0x1(%rbp)
jmp 0xf0b9
movq -0xd0(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0xf3e0
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xe0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movq -0x18(%rbp), %rcx
movq %rcx, -0x58(%rbp)
movq -0x28(%rbp), %rax
addq $0x98, %rcx
cmpq %rcx, %rax
jne 0xf15d
movq -0x58(%rbp), %rdi
movl 0x98(%rdi), %edx
movl $0x1, %esi
callq 0xf560
movq -0x58(%rbp), %rax
movl $0x0, -0x30(%rbp)
movl 0x98(%rax), %esi
leaq -0x3c(%rbp), %rdi
callq 0xf620
leaq -0x38(%rbp), %rdi
leaq -0x30(%rbp), %rsi
leaq -0x3c(%rbp), %rdx
callq 0xf5e0
movq -0x68(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xf640
jmp 0xf1d5
movq -0x58(%rbp), %rcx
movq -0x28(%rbp), %rax
addq $0x9c, %rcx
cmpq %rcx, %rax
jne 0xf1bc
movq -0x58(%rbp), %rdi
movl 0x9c(%rdi), %edx
xorl %esi, %esi
callq 0xf560
movq -0x58(%rbp), %rax
movl $0x0, -0x40(%rbp)
movl 0x9c(%rax), %esi
leaq -0x4c(%rbp), %rdi
callq 0xf620
leaq -0x48(%rbp), %rdi
leaq -0x40(%rbp), %rsi
leaq -0x4c(%rbp), %rdx
callq 0xf5e0
movq -0x68(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0xf640
jmp 0xf1d5
movq -0x58(%rbp), %rsi
movq -0x68(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movl -0x2c(%rbp), %r8d
callq 0xf670
movq -0x60(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
movq %rdi, -0x50(%rbp)
leaq -0x1c(%rbp), %rsi
callq 0xf440
movq %rax, -0x48(%rbp)
jmp 0xf2f6
movq -0x48(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0xf326
movb $0x0, -0x29(%rbp)
movq $0x0, -0x38(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x29(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0xf500
jmp 0xf324
jmp 0xf358
movq -0x50(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x8f20
movq -0x50(%rbp), %rdi
movb $0x1, -0x39(%rbp)
movq -0x28(%rbp), %rsi
callq 0xa870
movq %rax, %rdx
leaq -0x10(%rbp), %rdi
leaq -0x39(%rbp), %rsi
callq 0xf530
jmp 0xf356
jmp 0xf358
movb -0x10(%rbp), %al
movq -0x8(%rbp), %rdx
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x52b0
nopl (%rax)
// File: davmac314[P]dinit/src/../dasynq/include/dasynq.h
// Function: dasynq::v2::dprivate::event_dispatch<dasynq::v2::epoll_traits, dasynq::v2::default_traits<dasynq::null_mutex>>::receive_child_stat(int, dasynq::v2::dprivate::proc_status, void*)
void receive_child_stat(pid_t child, typename LoopTraits::backend_traits_t::proc_status_t status, void * userdata) noexcept
        {
            base_child_watcher * watcher = static_cast<base_child_watcher *>(userdata);
            watcher->child_status = status;
            watcher->child_termd = true;
            queue_watcher(watcher);
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdx, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x8(%rbp), %rcx
movq %rcx, 0x34(%rax)
movq -0x28(%rbp), %rax
movb 0xc(%rax), %cl
andb $-0x11, %cl
orb $0x10, %cl
movb %cl, 0xc(%rax)
movq -0x28(%rbp), %rsi
callq 0x6ba0
addq $0x30, %rsp
popq %rbp
retq
nop
// File: davmac314[P]dinit/src/../dasynq/include/dasynq.h
// Function: bool 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, typename Traits::sigdata_t & siginfo, void * userdata) noexcept
        {
            base_signal_watcher * bwatcher = static_cast<base_signal_watcher *>(userdata);
            bwatcher->siginfo = siginfo;
            queue_watcher(bwatcher);
            return true;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdi
addq $0x20, %rdi
movl $0x80, %edx
callq 0x31d0
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x6ba0
movb $0x1, %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xf4ef
movl $0x0, -0x24(%rbp)
xorl %eax, %eax
cmpl $0x8, -0x24(%rbp)
movb %al, -0x25(%rbp)
jge 0xf488
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
cmpq $0x0, 0x20(%rax,%rcx,8)
setne %al
movb %al, -0x25(%rbp)
movb -0x25(%rbp), %al
testb $0x1, %al
jne 0xf491
jmp 0xf4d9
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jne 0xf4b7
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq 0x20(%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0xf4f7
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jle 0xf4cc
jmp 0xf4d9
jmp 0xf4ce
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xf469
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq 0x60(%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
jmp 0xf457
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movl -0xc(%rbp), %esi
callq 0xd240
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
testl %eax, %eax
je 0xf591
jmp 0xf58f
jmp 0xf59e
xorl %edi, %edi
leaq -0x28(%rbp), %rsi
callq 0x3220
jmp 0xf5ae
movl $0x1, %edi
leaq -0x28(%rbp), %rsi
callq 0x3220
jmp 0xf5ae
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0xf7e0
movl -0x10(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0xe3a0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: davmac314[P]dinit/src/../dasynq/include/dasynq/timerbase.h
// Function: dasynq::operator-(dasynq::time_val const&, dasynq::time_val const&)
inline time_val operator-(const time_val &t1, const time_val &t2) noexcept
{
    time_val diff;
    diff.seconds() = t1.seconds() - t2.seconds();
    if (t1.nseconds() >= t2.nseconds()) {
        diff.nseconds() = t1.nseconds() - t2.nseconds();
    }
    else {
        diff.nseconds() = 1000000000 - t2.nseconds() + t1.nseconds();
        diff.seconds()--;
    }
    return diff;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
leaq -0x10(%rbp), %rdi
callq 0xde10
movq -0x18(%rbp), %rdi
callq 0xe100
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
callq 0xe100
movq %rax, %rcx
movq -0x38(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x30(%rbp)
leaq -0x10(%rbp), %rdi
callq 0xe0f0
movq -0x30(%rbp), %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rdi
callq 0xe0d0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0xe0d0
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jl 0xfbf5
movq -0x18(%rbp), %rdi
callq 0xe0d0
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rdi
callq 0xe0d0
movq %rax, %rcx
movq -0x48(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x40(%rbp)
leaq -0x10(%rbp), %rdi
callq 0xe0b0
movq -0x40(%rbp), %rcx
movq %rcx, (%rax)
jmp 0xfc47
movq -0x20(%rbp), %rdi
callq 0xe0d0
movq %rax, %rcx
movl $0x3b9aca00, %eax       # imm = 0x3B9ACA00
subq %rcx, %rax
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rdi
callq 0xe0d0
movq %rax, %rcx
movq -0x58(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x50(%rbp)
leaq -0x10(%rbp), %rdi
callq 0xe0b0
movq -0x50(%rbp), %rcx
movq %rcx, (%rax)
leaq -0x10(%rbp), %rdi
callq 0xe0f0
movq (%rax), %rcx
addq $-0x1, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: davmac314[P]dinit/src/../dasynq/include/dasynq/timerbase.h
// Function: dasynq::operator+(dasynq::time_val const&, dasynq::time_val const&)
inline time_val operator+(const time_val &t1, const time_val &t2) noexcept
{
    auto ns = t1.nseconds() + t2.nseconds();
    auto s = t1.seconds() + t2.seconds();
    static_assert(std::numeric_limits<decltype(ns)>::max() >= 2000000000, "type too small");
    if (ns >= 1000000000) {
        ns -= 1000000000;
        s++;
    }
    return time_val(s, ns);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0xe0d0
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rdi
callq 0xe0d0
movq %rax, %rcx
movq -0x40(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0xe100
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
callq 0xe100
movq %rax, %rcx
movq -0x38(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x30(%rbp)
cmpq $0x3b9aca00, -0x28(%rbp) # imm = 0x3B9ACA00
jl 0xfcdc
movq -0x28(%rbp), %rax
subq $0x3b9aca00, %rax       # imm = 0x3B9ACA00
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
leaq -0x10(%rbp), %rdi
callq 0x53f0
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: davmac314[P]dinit/src/../dasynq/include/dasynq/timerbase.h
// Function: dasynq::operator-=(dasynq::time_val&, dasynq::time_val const&)
inline time_val &operator-=(time_val &t1, const time_val &t2) noexcept
{
    time_val diff;
    t1.seconds() = t1.seconds() - t2.seconds();
    if (t1.nseconds() >= t2.nseconds()) {
        t1.nseconds() = t1.nseconds() - t2.nseconds();
    }
    else {
        t1.nseconds() = 1000000000 - t2.nseconds() + t1.nseconds();
        t1.seconds()--;
    }
    return t1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xde10
movq -0x8(%rbp), %rdi
callq 0xe0f0
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0xe100
movq %rax, %rcx
movq -0x38(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
callq 0xe0f0
movq -0x30(%rbp), %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
callq 0xe0b0
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0xe0d0
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jl 0xfdae
movq -0x8(%rbp), %rdi
callq 0xe0b0
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
callq 0xe0d0
movq %rax, %rcx
movq -0x48(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
callq 0xe0b0
movq -0x40(%rbp), %rcx
movq %rcx, (%rax)
jmp 0xfe00
movq -0x10(%rbp), %rdi
callq 0xe0d0
movq %rax, %rcx
movl $0x3b9aca00, %eax       # imm = 0x3B9ACA00
subq %rcx, %rax
movq %rax, -0x58(%rbp)
movq -0x8(%rbp), %rdi
callq 0xe0b0
movq %rax, %rcx
movq -0x58(%rbp), %rax
addq (%rcx), %rax
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rdi
callq 0xe0b0
movq -0x50(%rbp), %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
callq 0xe0f0
movq (%rax), %rcx
addq $-0x1, %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: davmac314[P]dinit/src/../dasynq/include/dasynq/timerbase.h
// Function: dasynq::operator<<=(dasynq::time_val&, int)
inline time_val & operator<<=(time_val &t, int n) noexcept
{
    for (int i = 0; i < n; i++) {
        t.seconds() *= 2;
        t.nseconds() *= 2;
        if (t.nseconds() >= 1000000000) {
            t.nseconds() -= 1000000000;
            t.seconds()++;
        }
    }
    return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0xff3a
movq -0x8(%rbp), %rdi
callq 0xe0f0
movq (%rax), %rcx
shlq %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
callq 0xe0b0
movq (%rax), %rcx
shlq %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
callq 0xe0b0
cmpq $0x3b9aca00, (%rax)     # imm = 0x3B9ACA00
jl 0xff2d
movq -0x8(%rbp), %rdi
callq 0xe0b0
movq (%rax), %rcx
subq $0x3b9aca00, %rcx       # imm = 0x3B9ACA00
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
callq 0xe0f0
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0xff2f
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xfec6
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: davmac314[P]dinit/src/../dasynq/include/dasynq/timerbase.h
// Function: dasynq::operator>>=(dasynq::time_val&, int)
inline time_val & operator>>=(time_val &t, int n) noexcept
{
    for (int i = 0; i < n; i++) {
        bool low = t.seconds() & 1;
        t.nseconds() /= 2;
        t.nseconds() += low ? 500000000ULL : 0;
        t.seconds() /= 2;
    }
    return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x1000c
movq -0x8(%rbp), %rdi
callq 0xe0f0
movq (%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
setne %al
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rdi
callq 0xe0b0
movq %rax, -0x30(%rbp)
movq (%rax), %rax
movl $0x2, %ecx
cqto
idivq %rcx
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movb -0x11(%rbp), %dl
xorl %eax, %eax
movl $0x1dcd6500, %ecx       # imm = 0x1DCD6500
testb $0x1, %dl
cmovneq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0xe0b0
movq -0x28(%rbp), %rcx
addq (%rax), %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
callq 0xe0f0
movq %rax, -0x20(%rbp)
movq (%rax), %rax
movl $0x2, %ecx
cqto
idivq %rcx
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xff66
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: davmac314[P]dinit/src/../dasynq/include/dasynq.h
// Function: dasynq::v2::dprivate::event_dispatch<dasynq::v2::epoll_traits, dasynq::v2::default_traits<dasynq::null_mutex>>::pull_queued_event()
base_watcher * pull_queued_event() noexcept
        {
            if (event_queue.empty()) {
                return nullptr;
            }
            
            auto & rhndl = event_queue.get_root();
            base_watcher *r = dprivate::get_watcher(event_queue, rhndl);
            event_queue.pull_root();
            return r;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x10580
testb $0x1, %al
jne 0x104df
jmp 0x104e9
movq $0x0, -0x8(%rbp)
jmp 0x10522
movq -0x28(%rbp), %rdi
callq 0x105a0
movq -0x28(%rbp), %rdi
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
callq 0x105c0
movq %rax, -0x30(%rbp)
jmp 0x10509
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x105f0
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x52b0
nopw %cs:(%rax,%rax)
nop
// File: davmac314[P]dinit/src/../dasynq/include/dasynq.h
// Function: dasynq::v2::event_loop<dasynq::null_mutex, dasynq::v2::default_traits<dasynq::null_mutex>>::poll_attn_lock(dasynq::v2::dprivate::waitqueue_node<dasynq::null_mutex>&)
bool poll_attn_lock(waitqueue_node<T_Mutex> &qnode) noexcept
    {
        std::unique_lock<T_Mutex> ulock(wait_lock);
        if (long_poll_running) {
            // There are poll-waiters, bail out
            return false;
        }

        // Nobody's doing a long poll, wait until we're at the head of the attn queue and return
        // success:
        attn_waitqueue.queue(&qnode);
        while (! attn_waitqueue.check_head(qnode)) {
            qnode.wait(ulock);
        }

        return true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x38(%rbp)
addq $0x160, %rsi            # imm = 0x160
leaq -0x28(%rbp), %rdi
callq 0x84e0
jmp 0x106ca
movq -0x38(%rbp), %rax
testb $0x1, 0x160(%rax)
je 0x106e4
movb $0x0, -0x1(%rbp)
movl $0x1, -0x2c(%rbp)
jmp 0x1072e
movq -0x38(%rbp), %rdi
addq $0x161, %rdi            # imm = 0x161
movq -0x18(%rbp), %rsi
callq 0x8520
movq -0x38(%rbp), %rdi
addq $0x161, %rdi            # imm = 0x161
movq -0x18(%rbp), %rsi
callq 0x8530
xorb $-0x1, %al
testb $0x1, %al
jne 0x10714
jmp 0x10723
movq -0x18(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x8560
jmp 0x106f8
movb $0x1, -0x1(%rbp)
movl $0x1, -0x2c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x8570
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x52b0
// File: statgen[P]statgen/lib/tclap-1.2.0/examples/../include/tclap/MultiSwitchArg.h
// Function: TCLAP::MultiSwitchArg::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 MultiSwitchArg::processArg(int *i, std::vector<std::string>& args)
{
	if ( _ignoreable && Arg::ignoreRest() )
		return false;

	if ( argMatches( args[*i] ))
	{
		// so the isSet() method will work
		_alreadySet = true;

		// Matched argument: increment value.
		++_value;

		_checkWithVisitor();

		return true;
	}
	else if ( combinedSwitchesMatch( args[*i] ) )
	{
		// so the isSet() method will work
		_alreadySet = true;

		// Matched argument: increment value.
		++_value;

		// Check for more in argument and increment value.
		while ( combinedSwitchesMatch( args[*i] ) ) 
			++_value;

		_checkWithVisitor();

		return false;
	}
	else
		return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
testb $0x1, 0xa0(%rax)
je 0x5589
callq 0x4d90
testb $0x1, %al
jne 0x5580
jmp 0x5589
movb $0x0, -0x1(%rbp)
jmp 0x565a
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movslq (%rax), %rsi
callq 0x4da0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
movq (%rdi), %rax
callq *0x30(%rax)
testb $0x1, %al
jne 0x55ac
jmp 0x55d4
movq -0x28(%rbp), %rdi
movb $0x1, 0x91(%rdi)
movl 0xa8(%rdi), %eax
addl $0x1, %eax
movl %eax, 0xa8(%rdi)
callq 0x5510
movb $0x1, -0x1(%rbp)
jmp 0x565a
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movslq (%rax), %rsi
callq 0x4da0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x4dc0
testb $0x1, %al
jne 0x55f6
jmp 0x5656
movq -0x28(%rbp), %rax
movb $0x1, 0x91(%rax)
movl 0xa8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xa8(%rax)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movslq (%rax), %rsi
callq 0x4da0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x4dc0
testb $0x1, %al
jne 0x5632
jmp 0x5647
movq -0x28(%rbp), %rax
movl 0xa8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xa8(%rax)
jmp 0x5610
movq -0x28(%rbp), %rdi
callq 0x5510
movb $0x0, -0x1(%rbp)
jmp 0x565a
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x15941(%rip), %rdi     # 0x1afd0
movq 0x1591a(%rip), %rsi     # 0x1afb0
callq 0x4290
movq %rax, %rdi
leaq 0xdd81(%rip), %rsi      # 0x13426
callq 0x4250
movq %rax, %rdi
movq 0x158fc(%rip), %rsi     # 0x1afb0
callq 0x4290
movq %rax, %rdi
movq 0x158ed(%rip), %rsi     # 0x1afb0
callq 0x4290
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq 0x158f9(%rip), %rdx     # 0x1afd0
callq 0x5760
movq 0x158ed(%rip), %rdi     # 0x1afd0
movq 0x158c6(%rip), %rsi     # 0x1afb0
callq 0x4290
movq %rax, %rdi
movq 0x158b7(%rip), %rsi     # 0x1afb0
callq 0x4290
movq %rax, %rdi
leaq 0xd922(%rip), %rsi      # 0x1302a
callq 0x4250
movq %rax, %rdi
movq 0x15899(%rip), %rsi     # 0x1afb0
callq 0x4290
movq %rax, %rdi
movq 0x1588a(%rip), %rsi     # 0x1afb0
callq 0x4290
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq 0x15896(%rip), %rdx     # 0x1afd0
callq 0x5d50
movq 0x1588a(%rip), %rdi     # 0x1afd0
movq 0x15863(%rip), %rsi     # 0x1afb0
callq 0x4290
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
leaq 0x1422d(%rip), %rax     # 0x1a808
movq %rax, (%rdi)
addq $0xa0, %rdi
callq 0x6480
jmp 0x65ec
movq -0x10(%rbp), %rdi
addq $0xb8, %rdi
callq 0x64e0
jmp 0x65fe
movq -0x10(%rbp), %rax
testb $0x1, 0xd9(%rax)
jne 0x6639
movq -0x10(%rbp), %rax
movq 0xd0(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x662a
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0xd0(%rax)
movq -0x10(%rbp), %rdi
addq $0xb8, %rdi
callq 0x6530
movq -0x10(%rbp), %rdi
addq $0xa0, %rdi
callq 0x6550
movq -0x10(%rbp), %rdi
addq $0x88, %rdi
callq 0x6570
movq -0x10(%rbp), %rdi
addq $0x60, %rdi
callq 0x44d8
movq -0x10(%rbp), %rdi
addq $0x40, %rdi
callq 0x44d8
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
callq 0x44d8
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x6550
movq -0x10(%rbp), %rdi
callq 0xbec0
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x64d0
nopw %cs:(%rax,%rax)
nop
// File: 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
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xd7c0
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x6a7a
movq -0x18(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x88(%rbp)
leaq -0x59(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x4430
movq -0x88(%rbp), %rsi
movq -0x80(%rbp), %rdx
leaq -0x58(%rbp), %rdi
callq 0x5110
jmp 0x6a20
leaq -0x30(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0xd7e0
jmp 0x6a2f
leaq -0x58(%rbp), %rdi
callq 0x44d8
leaq -0x59(%rbp), %rdi
callq 0x42b0
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x69de
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x6a6f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x44d8
leaq -0x59(%rbp), %rdi
callq 0x42b0
jmp 0x6aa7
movq -0x78(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xd810
jmp 0x6a89
leaq -0x30(%rbp), %rdi
callq 0xde00
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xde00
movq -0x68(%rbp), %rdi
callq 0x4420
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x8, %rdi
leaq 0xc7ec(%rip), %rsi      # 0x1341f
callq 0x10cb0
testb $0x1, %al
jne 0x6c3e
jmp 0x6c57
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
movq -0x18(%rbp), %rsi
addq $0x8, %rsi
callq 0x88c0
testb $0x1, %al
jne 0x6c72
movq -0x20(%rbp), %rdi
addq $0x28, %rdi
movq -0x18(%rbp), %rsi
addq $0x28, %rsi
callq 0x88c0
testb $0x1, %al
jne 0x6c72
jmp 0x6c78
movb $0x1, -0x1(%rbp)
jmp 0x6c7c
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)