LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/davmac314[P]dinit/src/../dasynq/include/dasynq/btree_set.h
// Function: dasynq::btree_set<void*, int, std::less<int>, 8>::septnode::shift_elems_right(int, int, int)
void shift_elems_right(int pos, int newpos, int num)
        {
            int diff = newpos - pos;
            int end = pos + num;

            children[end + diff] = children[end];
            for (int i = (end - 1); i >= pos; i--) {
                prio[i + diff] = prio[i];
                hn_p[i + diff] = hn_p[i];
                children[i + diff] = children[i];
            }
        }

// Assembly:
leal (%rcx,%rsi), %eax
cltq
movq 0x60(%rdi,%rax,8), %rax
leal (%rcx,%rdx), %r8d
subl %esi, %edx
movslq %r8d, %r8
movq %rax, 0x60(%rdi,%r8,8)
movslq %ecx, %rcx
movslq %esi, %rax
addq %rax, %rcx
movslq %edx, %rsi
leaq (%rdi,%rsi,4), %rdx
addq $-0x4, %rdx
leaq (%rdi,%rsi,8), %rsi
addq $0x58, %rsi
cmpq %rax, %rcx
jle 0x5afa
movl -0x4(%rdi,%rcx,4), %r8d
movl %r8d, (%rdx,%rcx,4)
movq 0x18(%rdi,%rcx,8), %r8
movq %r8, -0x40(%rsi,%rcx,8)
movq 0x58(%rdi,%rcx,8), %r8
movq %r8, (%rsi,%rcx,8)
decq %rcx
jmp 0x5ad4
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/davmac314[P]dinit/src/../dasynq/include/dasynq/btree_set.h
// Function: dasynq::btree_set<void*, int, std::less<int>, 8>::deallocate(dasynq::btree_set<void*, int, std::less<int>, 8>::heapnode&)
void deallocate(handle_t & hn) noexcept
    {
        hn.nodedata.data.T::~T();
        num_alloced--;

        // Potentially release reserved sept node
        if (DASYNQ_EXPECT(num_alloced < next_sept - N/2, 0)) {
            next_sept -= N/2;
            num_septs_needed--;
            if (num_septs_needed < num_septs - 1) {
                // Note the "-1" margin is to alleviate bouncing allocation/deallocation
                septnode * r = sn_reserve;
                sn_reserve = r->parent;
                delete r;
                num_septs--;
            }
        }
    }

// Assembly:
movq 0x18(%rdi), %rcx
decq %rcx
movq %rcx, 0x18(%rdi)
movl 0x28(%rdi), %eax
addl $-0x4, %eax
cmpq %rax, %rcx
jb 0x5bc3
retq
pushq %rbx
movq %rdi, %rbx
movl %eax, 0x28(%rdi)
movl 0x20(%rdi), %eax
movl 0x24(%rdi), %ecx
decl %ecx
movl %ecx, 0x24(%rdi)
decl %eax
cmpl %eax, %ecx
jae 0x5bf7
movq 0x10(%rbx), %rdi
movq 0xa8(%rdi), %rax
movq %rax, 0x10(%rbx)
movl $0xb0, %esi
callq 0x3290
decl 0x20(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/davmac314[P]dinit/src/shutdown.cc
// Function: subproc_out_watch::fd_event(dasynq::v2::event_loop<dasynq::null_mutex, dasynq::v2::default_traits<dasynq::null_mutex>>&, int, int)
rearm fd_event(loop_t &, int fd, int flags)
    {
        // if current status is reading overflow, read and discard until newline
        if (in_overflow) {
            return read_overflow(fd);
        }

        auto r = sub_buf.fill(fd);
        if (r == subproc_buffer::fill_status::FULL) {
            sub_buf.mark_overflow();
            in_overflow = true;
            return read_overflow(fd);
        }
        else if (r == subproc_buffer::fill_status::ENDFILE) {
            return rearm::NOOP;
        }

        return rearm::REARM;  // re-enable watcher
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rdi, %r14
cmpb $0x1, 0x30(%rdi)
je 0x5c9a
movq 0x28(%r14), %rdi
movl %ebx, %esi
callq 0x5d52
cmpl $0x1, %eax
je 0x5cab
cmpl $0x2, %eax
jne 0x5cb0
movq 0x28(%r14), %rdi
callq 0x5090
movb $0x1, 0x30(%r14)
movq %r14, %rdi
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x5cba
pushq $0x2
popq %rax
jmp 0x5cb2
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/davmac314[P]dinit/src/shutdown.cc
// Function: subproc_out_watch::read_overflow(int)
rearm read_overflow(int fd)
    {
        char buf[128];
        int r = read(fd, buf, 128);
        if (r == 0 || (r == -1 && errno != EAGAIN)) {
            return rearm::NOOP; // leave disarmed
        }
        if (r == -1) {
            return rearm::REARM;
        }

        // How much space is available?
        int fr = sub_buf.get_free();
        for (int b = r - std::min(r, fr); b < r; b++) {
            if (buf[b] == '\n') {
                // Copy the (partial) line into sub_buf and leave overflow mode
                sub_buf.append(buf + b, r - b);
                in_overflow = false;
            }
        }
        return rearm::REARM;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x88, %rsp
movl %esi, %eax
movq %rdi, %rbx
movq %rsp, %rsi
movl $0x80, %edx
movl %eax, %edi
callq 0x3370
testl %eax, %eax
je 0x5cf8
cmpl $-0x1, %eax
jne 0x5cfd
callq 0x3030
movq %rax, %rcx
xorl %eax, %eax
cmpl $0xb, (%rcx)
setne %al
addl %eax, %eax
jmp 0x5d43
pushq $0x2
popq %rax
jmp 0x5d43
movq 0x28(%rbx), %rcx
movl $0x1000, %ebp           # imm = 0x1000
subl 0x1004(%rcx), %ebp
cmpl %eax, %ebp
cmovgel %eax, %ebp
movl %eax, %ecx
subl %ebp, %ecx
movslq %ecx, %r14
movslq %eax, %r15
cmpq %r15, %r14
jge 0x5d41
cmpb $0xa, (%rsp,%r14)
jne 0x5d3a
leaq (%rsp,%r14), %rsi
movq 0x28(%rbx), %rdi
movl %ebp, %edx
callq 0x5daa
movb $0x0, 0x30(%rbx)
incq %r14
decl %ebp
jmp 0x5d1b
xorl %eax, %eax
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/davmac314[P]dinit/src/includes/cpbuffer.h
// Function: cpbuffer<4096u>::fill(int, unsigned int)
int fill(int fd, unsigned limit) noexcept
    {
        unsigned pos = cur_idx + length;
        if (pos >= SIZE) pos -= SIZE;
        unsigned max_count = std::min(SIZE - pos, SIZE - length);
        max_count = std::min(max_count, limit);
        ssize_t r = bp_sys::read(fd, buf + pos, max_count);
        if (r >= 0) {
            length += r;
        }
        return r;
    }

// Assembly:
pushq %rbx
movl %esi, %eax
movq %rdi, %rbx
movl 0x1000(%rdi), %ecx
movl 0x1004(%rdi), %edi
leal (%rdi,%rcx), %r8d
movl $0x1000, %r9d           # imm = 0x1000
cmpl %r9d, %r8d
leal -0x1000(%rdi,%rcx), %esi
cmovbl %r8d, %esi
movl $0x1000, %ecx           # imm = 0x1000
subl %esi, %ecx
subl %edi, %r9d
cmpl %ecx, %r9d
cmovael %ecx, %r9d
cmpl %edx, %r9d
cmovbl %r9d, %edx
addq %rbx, %rsi
movl %eax, %edi
callq 0x3370
testq %rax, %rax
js 0x5e37
addl %eax, 0x1004(%rbx)
popq %rbx
retq
movq %rax, %rdi
callq 0x42c3
nop
// File: /workspace/github_cpp_makefile_star2_O2/davmac314[P]dinit/src/../dasynq/include/dasynq.h
// Function: dasynq::v2::event_loop<dasynq::null_mutex, dasynq::v2::default_traits<dasynq::null_mutex>>::reserve_child_watch(dasynq::v2::dprivate::base_child_watcher<dasynq::v2::dprivate::proc_status>*)
void reserve_child_watch(base_child_watcher *callback)
    {
        std::lock_guard<mutex_t> guard(loop_mech.lock);

        loop_mech.prepare_watcher(callback);
        try {
            loop_mech.reserve_child_watch_nolock(callback->watch_handle);
        }
        catch (...) {
            loop_mech.release_watcher(callback);
            throw;
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x10(%rsi), %rbx
movq %rbx, %rsi
callq 0x4e2a
leaq 0x28(%r14), %rdi
callq 0x5eb0
andq $0x0, 0x20(%r15)
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rdi
callq 0x30d0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4a8c
callq 0x3380
movq %rax, %rbx
callq 0x33d0
movq %rbx, %rdi
callq 0x3400
movq %rax, %rdi
callq 0x42c3
nop
// File: /workspace/github_cpp_makefile_star2_O2/davmac314[P]dinit/src/../dasynq/include/dasynq/btree_set.h
// Function: dasynq::btree_set<void*, int, std::less<int>, 8>::alloc_slot()
void alloc_slot()
    {
        num_alloced++;
        // No need to be concerned for overflow in num_alloced: if we've maxed out size_t then
        // allocation would have failed much earlier on.

        if (DASYNQ_EXPECT(num_alloced == next_sept, 0)) {
            if (++num_septs_needed > num_septs) {
                try {
                    septnode *new_res = new septnode();
                    new_res->parent = sn_reserve;
                    sn_reserve = new_res;
                    num_septs++;
                }
                catch (...) {
                    num_septs_needed--;
                    num_alloced--;
                    throw;
                }
            }
            if (num_septs_needed == 0) {
                // wrapped around
                num_septs_needed--;
                num_alloced--;
                throw std::bad_alloc();
            }
            next_sept += N/2;
        }
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq 0x18(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x18(%rdi)
movl 0x28(%rdi), %r14d
cmpq %r14, %rcx
je 0x5ece
popq %rbx
popq %r14
popq %rbp
retq
movq %rdi, %rbx
movl 0x20(%rdi), %ebp
movl 0x24(%rdi), %ecx
incl %ecx
movl %ecx, 0x24(%rdi)
cmpl %ebp, %ecx
jbe 0x5f00
movl $0xb0, %edi
callq 0x3280
movq 0x10(%rbx), %rcx
movq %rcx, 0xa8(%rax)
movq %rax, 0x10(%rbx)
incl %ebp
movl %ebp, 0x20(%rbx)
jmp 0x5f04
testl %ecx, %ecx
je 0x5f0e
addl $0x4, %r14d
movl %r14d, 0x28(%rbx)
jmp 0x5ec9
orl $-0x1, 0x24(%rbx)
movq %rax, 0x18(%rbx)
pushq $0x8
popq %rdi
callq 0x3130
movq 0x7083(%rip), %rcx      # 0xcfa8
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x708d(%rip), %rsi      # 0xcfc0
movq 0x705e(%rip), %rdx      # 0xcf98
movq %rax, %rdi
callq 0x33f0
movq %rax, %rdi
callq 0x30d0
decl 0x24(%rbx)
decq 0x18(%rbx)
callq 0x3380
movq %rax, %rbx
callq 0x33d0
movq %rbx, %rdi
callq 0x3400
movq %rax, %rdi
callq 0x42c3
// File: /workspace/github_cpp_makefile_star2_O2/davmac314[P]dinit/src/../dasynq/include/dasynq/btree_set.h
// Function: dasynq::btree_set<void*, int, std::less<int>, 8>::alloc_sept()
septnode * alloc_sept()
    {
        septnode * r = sn_reserve;
        sn_reserve = r->parent;
        r->init();
        return r;
    }

// Assembly:
pushq %rbx
movq 0x10(%rdi), %rbx
movq 0xa8(%rbx), %rax
movq %rax, 0x10(%rdi)
movq %rbx, %rdi
callq 0x6300
movq %rbx, %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/davmac314[P]dinit/src/../dasynq/include/dasynq/btree_set.h
// Function: dasynq::btree_set<void*, int, std::less<int>, 8>::septnode::init()
void init()
        {
            for (int i = 0; i < N; i++) {
                hn_p[i] = nullptr;
                children[i] = nullptr;
            }
            children[N] = nullptr;
            parent = nullptr;
        }

// Assembly:
pushq $-0x40
popq %rax
testq %rax, %rax
je 0x631d
andq $0x0, 0x60(%rdi,%rax)
andq $0x0, 0xa0(%rdi,%rax)
addq $0x8, %rax
jmp 0x6303
xorps %xmm0, %xmm0
movups %xmm0, 0xa0(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/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>>::init()
void init()
    {
        epfd = epoll_create1(EPOLL_CLOEXEC);
        if (epfd == -1) {
            throw std::system_error(errno, std::system_category());
        }
        sigemptyset(&sigmask);
        try {
            Base::init(this);
        }
        catch (...) {
            close(epfd);
            throw;
        }
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x80000, %edi          # imm = 0x80000
callq 0x3310
movl %eax, 0xa0(%rbx)
cmpl $-0x1, %eax
je 0x6402
leaq 0xa8(%rbx), %rdi
callq 0x32c0
movq %rbx, %rdi
movq %rbx, %rsi
callq 0x647a
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x20
popq %rdi
callq 0x3130
movq %rax, %rbx
callq 0x3030
movl (%rax), %ebp
callq 0x3160
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x4f30
movq 0x6b5b(%rip), %rsi      # 0xcf88
movq 0x6b7c(%rip), %rdx      # 0xcfb0
movq %rbx, %rdi
callq 0x33f0
movq %rax, %r14
movq %rbx, %rdi
callq 0x31a0
jmp 0x6469
movq %rax, %rdi
callq 0x30d0
movl 0xa0(%rbx), %edi
callq 0x3430
callq 0x3380
movq %rax, %r14
callq 0x33d0
movq %r14, %rdi
callq 0x3400
movq %rax, %rdi
callq 0x42c3
nop
// File: /workspace/github_cpp_makefile_star2_O2/davmac314[P]dinit/src/../dasynq/include/dasynq/timerfd.h
// Function: void 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>>>>::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)
    {
        timerfd_fd = timerfd_create(CLOCK_MONOTONIC, TFD_CLOEXEC | TFD_NONBLOCK);
        if (timerfd_fd == -1) {
            throw std::system_error(errno, std::system_category());
        }
        systemtime_fd = timerfd_create(CLOCK_REALTIME, TFD_CLOEXEC | TFD_NONBLOCK);
        if (systemtime_fd == -1) {
            close (timerfd_fd);
            throw std::system_error(errno, std::system_category());
        }

        try {
            loop_mech->add_fd_watch(timerfd_fd, &timerfd_fd, IN_EVENTS);
            loop_mech->add_fd_watch(systemtime_fd, &systemtime_fd, IN_EVENTS);
            Base::init(loop_mech);
        }
        catch (...) {
            close(timerfd_fd);
            close(systemtime_fd);
            throw;
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x1
popq %rdi
movl $0x80800, %esi          # imm = 0x80800
callq 0x3410
movl %eax, 0x98(%r14)
cmpl $-0x1, %eax
je 0x650d
xorl %edi, %edi
movl $0x80800, %esi          # imm = 0x80800
callq 0x3410
movl %eax, 0x9c(%r14)
movl 0x98(%r14), %esi
cmpl $-0x1, %eax
je 0x6533
leaq 0x98(%r14), %r12
leaq 0x9c(%r14), %r15
pushq $0x1
popq %rcx
movq %rbx, %rdi
movq %r12, %rdx
movl %ecx, %r8d
xorl %r9d, %r9d
callq 0x4d68
movl (%r15), %esi
pushq $0x1
popq %rcx
movq %rbx, %rdi
movq %r15, %rdx
movl %ecx, %r8d
xorl %r9d, %r9d
callq 0x4d68
movq %r14, %rdi
movq %rbx, %rsi
callq 0x65ba
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
pushq $0x20
popq %rdi
callq 0x3130
movq %rax, %rbx
callq 0x3030
movl (%rax), %ebp
callq 0x3160
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x4f30
jmp 0x655e
movl %esi, %edi
callq 0x3430
pushq $0x20
popq %rdi
callq 0x3130
movq %rax, %rbx
callq 0x3030
movl (%rax), %ebp
callq 0x3160
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x4f30
movq 0x6a23(%rip), %rsi      # 0xcf88
movq 0x6a44(%rip), %rdx      # 0xcfb0
movq %rbx, %rdi
callq 0x33f0
jmp 0x6576
movq %rax, %r14
movq %rbx, %rdi
callq 0x31a0
jmp 0x65a9
movq %rax, %rdi
callq 0x30d0
movl (%r12), %edi
callq 0x3430
movl (%r15), %edi
callq 0x3430
callq 0x3380
movq %rax, %r14
callq 0x33d0
movq %r14, %rdi
callq 0x3400
movq %rax, %rdi
callq 0x42c3
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
movq %rsi, %rbx
pushq $0x1
popq %rdi
leaq 0x98(%rsp), %r14
xorl %esi, %esi
movq %r14, %rdx
callq 0x3100
pushq $0x11
popq %rbp
movq %r14, %rdi
movl %ebp, %esi
callq 0x3390
pushq $0x2
popq %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x3100
leaq 0x40(%rip), %r14        # 0x6640
leaq 0x8(%rsp), %r15
movq %r14, -0x8(%r15)
movq %r15, %rdi
callq 0x32c0
andl $0x0, 0x80(%r15)
movq %rsp, %rsi
movl %ebp, %edi
xorl %edx, %edx
callq 0x32e0
movq %rbx, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0x6642
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x675e
movq %r14, (%rax)
movl 0xa4(%rbx), %ebp
leaq 0xa8(%rbx), %r14
movl (%r15), %esi
movq %r14, %rdi
callq 0x3390
movl 0xa4(%rbx), %edi
movq %r14, %rsi
movl $0x80800, %edx          # imm = 0x80800
callq 0x3150
movl %eax, 0xa4(%rbx)
cmpl $-0x1, %eax
je 0x66dd
cmpl $-0x1, %ebp
jne 0x66d2
leaq 0xa4(%rbx), %r14
leaq 0xc(%rsp), %rcx
movq %r14, 0x4(%rcx)
movl $0x1, (%rcx)
movl 0xa0(%rbx), %edi
pushq $0x1
popq %rsi
movl %eax, %edx
callq 0x3330
cmpl $-0x1, %eax
je 0x6703
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x20
popq %rdi
callq 0x3130
movq %rax, %rbx
callq 0x3030
movl (%rax), %ebp
callq 0x3160
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x4f30
jmp 0x6733
movl (%r14), %edi
callq 0x3430
orl $-0x1, (%r14)
pushq $0x20
popq %rdi
callq 0x3130
movq %rax, %rbx
callq 0x3030
movl (%rax), %ebp
callq 0x3160
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x4f30
movq 0x684e(%rip), %rsi      # 0xcf88
movq 0x686f(%rip), %rdx      # 0xcfb0
movq %rbx, %rdi
callq 0x33f0
jmp 0x674b
movq %rax, %r14
movq %rbx, %rdi
callq 0x31a0
movq %r14, %rdi
callq 0x3400
// File: /workspace/github_cpp_makefile_star2_O2/davmac314[P]dinit/src/../dasynq/include/dasynq.h
// Function: dasynq::v2::dprivate::timer<dasynq::v2::event_loop<dasynq::null_mutex, dasynq::v2::default_traits<dasynq::null_mutex>>>::add_timer(dasynq::v2::event_loop<dasynq::null_mutex, dasynq::v2::default_traits<dasynq::null_mutex>>&, dasynq::clock_type, int)
void add_timer(event_loop_t &eloop, clock_type clock = clock_type::MONOTONIC, int prio = DEFAULT_PRIORITY)
    {
        base_watcher::init();
        this->priority = prio;
        this->clock = clock;
        this->intervals = 0;
        eloop.register_timer(this, clock);
    }

// Assembly:
movq %rdi, %rax
andb $-0x20, 0xc(%rdi)
movl %ecx, 0x18(%rdi)
movl %edx, 0x4c(%rdi)
andl $0x0, 0x48(%rdi)
movq %rsi, %rdi
movq %rax, %rsi
jmp 0x6d78
// File: /workspace/github_cpp_makefile_star2_O2/davmac314[P]dinit/src/../dasynq/include/dasynq.h
// Function: dasynq::v2::event_loop<dasynq::null_mutex, dasynq::v2::default_traits<dasynq::null_mutex>>::process_timer_rearm(dasynq::v2::dprivate::base_timer_watcher*, dasynq::rearm)
void process_timer_rearm(base_timer_watcher *btw, rearm rearm_type) noexcept
    {
        // Called with lock held
        if (rearm_type == rearm::REARM) {
            loop_mech.enable_timer_nolock(btw->timer_handle, true, btw->clock);
        }
        else if (rearm_type == rearm::REMOVE) {
            loop_mech.remove_timer_nolock(btw->timer_handle, btw->clock);
        }
        else if (rearm_type == rearm::DISARM) {
            loop_mech.enable_timer_nolock(btw->timer_handle, false, btw->clock);
        }
    }

// Assembly:
cmpl $0x3, %edx
je 0x6b26
cmpl $0x1, %edx
je 0x6b21
testl %edx, %edx
jne 0x6b25
movl 0x4c(%rsi), %ecx
addq $0x20, %rsi
pushq $0x1
popq %rdx
jmp 0x6b32
movb $0x0, 0x34(%rsi)
retq
movl 0x4c(%rsi), %edx
addq $0x20, %rsi
jmp 0x6b56
// File: /workspace/github_cpp_makefile_star2_O2/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>>>>::enable_timer_nolock(dasynq::dary_heap<dasynq::timer_data, dasynq::time_val, dasynq::compare_timespec, 4>::handle_t&, bool, dasynq::clock_type)
void enable_timer_nolock(timer_handle_t &timer_id, bool enable, clock_type clock = clock_type::MONOTONIC) noexcept
    {
        auto &timer_queue = this->queue_for_clock(clock);
        auto &node_data = timer_queue.node_data(timer_id);
        auto expiry_count = node_data.expiry_count;
        if (expiry_count != 0 && enable) {
            node_data.expiry_count = 0;
            Base::receive_timer_expiry(timer_id, node_data.userdata, expiry_count);
        }
        else {
            timer_queue.node_data(timer_id).enabled = enable;
        }
    }

// Assembly:
movl %edx, %eax
xorb $0x1, %al
movl 0x10(%rsi), %ecx
testl %ecx, %ecx
sete %r8b
orb %al, %r8b
jne 0x6b51
andl $0x0, 0x10(%rsi)
movq 0x18(%rsi), %rdx
jmp 0x6b94
movb %dl, 0x14(%rsi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
cmpq $-0x1, 0x20(%rsi)
je 0x6b82
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6ba0
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6baa
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4e2a
leaq 0x20(%r15), %rsi
movq %r14, %rdi
movq %r15, %rdx
movl %ebp, %ecx
callq 0x6dd2
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rdi
callq 0x30d0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4a8c
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x33d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, %ebx
movl %r8d, 0x4(%rsp)
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
xorl %edi, %edi
cmpl $0x1, %r9d
sete %dil
leaq 0x8(%rsp), %rbp
movq %rbp, %rsi
callq 0x3230
movq %rbp, %rdi
movq %r15, %rsi
callq 0x7000
movq %r13, %rdi
movq %r12, %rsi
movq %rbp, %rdx
movq %r14, %rcx
movl 0x4(%rsp), %r8d
movl %ebx, %r9d
callq 0x703a
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
movq %rdi, %rax
movq 0x8(%rdi), %rcx
movq (%rsi), %rdx
movq 0x8(%rsi), %rsi
leaq (%rsi,%rcx), %rdi
addq (%rax), %rdx
xorl %r8d, %r8d
cmpq $0x3b9aca00, %rdi       # imm = 0x3B9ACA00
setge %r8b
leaq -0x3b9aca00(%rsi,%rcx), %rcx
cmovlq %rdi, %rcx
addq %rdx, %r8
movq %r8, (%rax)
movq %rcx, 0x8(%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
movq (%rdx), %rdi
movq 0x8(%rdx), %rax
movups (%rcx), %xmm0
movups %xmm0, (%rsi)
andl $0x0, 0x10(%rsi)
movb 0x30(%rsp), %cl
movb %cl, 0x14(%rsi)
cmpq $-0x1, 0x20(%rsi)
je 0x70fb
leaq 0x8(%rsp), %rdx
movq %rdi, (%rdx)
movq %rax, 0x8(%rdx)
movq %rbx, %rdi
callq 0x7124
jmp 0x710f
leaq 0x8(%rsp), %rdx
movq %rdi, (%rdx)
movq %rax, 0x8(%rdx)
movq %rbx, %rdi
callq 0x7194
testb %al, %al
je 0x711d
movl %ebp, %edi
movq %rbx, %rsi
callq 0x7164
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
movslq 0x20(%rsi), %rsi
movq (%rdi), %rcx
imulq $0x18, %rsi, %r8
leaq (%rcx,%r8), %rax
movq (%rdx), %r9
cmpq %r9, (%rcx,%r8)
jl 0x7148
jne 0x7158
movq 0x8(%rdx), %rcx
cmpq %rcx, 0x8(%rax)
jge 0x7158
pushq %rax
movups (%rdx), %xmm0
movups %xmm0, (%rax)
callq 0x71d2
xorl %eax, %eax
popq %rcx
retq
movups (%rdx), %xmm0
movups %xmm0, (%rax)
jmp 0x71f6
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x7177
movq (%rsi), %rax
movups (%rax), %xmm1
subq $0x28, %rsp
movq %rsp, %rdx
movaps %xmm1, 0x10(%rdx)
movaps %xmm0, (%rdx)
pushq $0x1
popq %rsi
xorl %ecx, %ecx
callq 0x31c0
addq $0x28, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x10, %rsp
movq %rdi, %rbx
addq $0x160, %rbx            # imm = 0x160
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x5454
movb $0x1, (%rbx)
movq %rsp, %rdi
callq 0x546a
addq $0x10, %rsp
popq %rbx
retq
movq %rax, %rdi
callq 0x42c3
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0xc0, %rsp
movl %esi, %ecx
movq %rdi, %rbx
movl 0xa0(%rdi), %edi
negl %ecx
movq %rsp, %rsi
pushq $0x10
popq %rdx
callq 0x3110
leal 0x1(%rax), %ecx
cmpl $0x2, %ecx
jb 0x735a
movq %rsp, %r14
pushq $0x10
popq %rbp
movq %rbx, %rdi
movq %r14, %rsi
movl %eax, %edx
callq 0x73d0
movl 0xa0(%rbx), %edi
movq %r14, %rsi
movl %ebp, %edx
xorl %ecx, %ecx
callq 0x3110
testl %eax, %eax
jg 0x7337
addq $0xc0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
movl (%rdx), %r13d
cmpl $0x11, %r13d
je 0x7569
movq %rcx, %rax
leaq 0x20(%rcx), %rdi
pushq $0x10
popq %rcx
movq %rdx, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x4b2e
cmpl $0x11, %r13d
setne %al
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x28(%rbx), %r14
leaq 0x8(%rsp), %r15
pushq $0x5
popq %rbp
andl $0x0, 0x18(%rsp)
xorl %edi, %edi
xorl %esi, %esi
movq %r15, %rdx
movl %ebp, %ecx
callq 0x3090
testl %eax, %eax
jne 0x7550
movl 0x18(%rsp), %r12d
testl %r12d, %r12d
je 0x7550
movq %r14, %rdi
movl %r12d, %esi
callq 0x7656
testb $0x1, %al
je 0x7575
movq %rdx, %rcx
movl 0x10(%rsp), %eax
movl 0x20(%rsp), %edx
shlq $0x20, %rdx
orq %rax, %rdx
movq %rbx, %rdi
movl %r12d, %esi
callq 0x7692
jmp 0x7575
// File: /workspace/github_cpp_makefile_star2_O2/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 0x75f3
leaq 0x9c(%r14), %rax
cmpq %rcx, %rax
je 0x760e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7732
jmp 0x762c
movl 0x98(%r14), %edx
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x76d4
movl 0x98(%r14), %eax
jmp 0x7626
movl 0x9c(%r14), %edx
movq %r14, %rdi
xorl %esi, %esi
callq 0x76d4
movl 0x9c(%r14), %eax
movl %eax, (%rbx)
andl $0x0, 0x4(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x76a2
testq %rax, %rax
je 0x7686
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5662
movq (%r14), %rdx
movb $0x1, %al
jmp 0x768a
xorl %eax, %eax
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
movl (%rsi), %ecx
movq (%rdi), %rdx
testq %rdx, %rdx
je 0x76d1
leaq 0x60(%rdx), %rdi
xorl %esi, %esi
cmpq $0x8, %rsi
je 0x76a4
movq -0x40(%rdi), %rax
testq %rax, %rax
je 0x76a4
cmpl %ecx, (%rdx,%rsi,4)
je 0x76d3
jg 0x76a4
incq %rsi
addq $0x8, %rdi
jmp 0x76b2
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3230
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 0x77b2
movl %ebx, %edi
movq %r12, %rsi
callq 0x7164
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
movq %rdi, %rax
movq (%rdi), %rcx
movq 0x8(%rdi), %rdi
xorl %edx, %edx
testl %esi, %esi
cmovgl %esi, %edx
subl $0x1, %edx
jb 0x7ac8
addq %rcx, %rcx
movq %rcx, (%rax)
leaq (%rdi,%rdi), %rsi
movq %rsi, 0x8(%rax)
cmpq $0x1dcd6500, %rdi       # imm = 0x1DCD6500
jl 0x7ac3
addq $-0x3b9aca00, %rsi      # imm = 0xC4653600
movq %rsi, 0x8(%rax)
orq $0x1, %rcx
movq %rcx, (%rax)
movq %rsi, %rdi
jmp 0x7a95
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
movq (%rdi), %rcx
movq 0x8(%rdi), %rdx
xorl %r8d, %r8d
testl %esi, %esi
cmovgl %esi, %r8d
pushq $0x2
popq %rsi
subl $0x1, %r8d
jb 0x7b15
movl %ecx, %r9d
andl $0x1, %r9d
negl %r9d
movq %rdx, %rax
cqto
idivq %rsi
andl $0x1dcd6500, %r9d       # imm = 0x1DCD6500
addq %rax, %r9
movq %r9, 0x8(%rdi)
movq %rcx, %rax
cqto
idivq %rsi
movq %r9, %rdx
movq %rax, %rcx
movq %rax, (%rdi)
jmp 0x7adc
movq %rdi, %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x10, %rsp
movq %rdi, %rbx
addq $0x160, %rbx            # imm = 0x160
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x5454
movb (%rbx), %bl
xorb $0x1, %bl
movq %rsp, %rdi
callq 0x546a
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
retq
movq %rax, %rdi
callq 0x42c3
// File: /workspace/github_cpp_makefile_star2_O2/statgen[P]statgen/lib/tclap-1.2.0/examples/test11.cpp
// Function: main
int main(int argc, char *argv[])
{
    CmdLine cmd("Command description message", ' ', "0.9");
    ValueArg<Vect3D> vec("v", "vect", "vector", 
			 true, Vect3D(), "3D vector", cmd);
    
    try {
	cmd.parse(argc, argv);
    } catch(std::exception &e) {
	std::cout << e.what() << std::endl;
	return EXIT_FAILURE;
    }

    vec.getValue().print(std::cout);
    std::cout << std::endl;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x2b0, %rsp            # imm = 0x2B0
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x5b9f(%rip), %rsi      # 0x9022
leaq 0xd0(%rsp), %rdi
leaq 0x90(%rsp), %rdx
callq 0x39b2
leaq 0x5b9f(%rip), %rsi      # 0x903e
leaq 0x30(%rsp), %rdi
leaq 0x70(%rsp), %rdx
callq 0x39b2
leaq 0x1d0(%rsp), %r14
leaq 0xd0(%rsp), %rsi
pushq $0x20
popq %rdx
leaq 0x30(%rsp), %rcx
pushq $0x1
popq %r8
movq %r14, %rdi
callq 0x43d6
leaq 0x30(%rsp), %rdi
callq 0x3348
leaq 0xd0(%rsp), %rdi
callq 0x3348
leaq 0x5b52(%rip), %rsi      # 0x9042
leaq 0x30(%rsp), %rdi
leaq 0x2f(%rsp), %rdx
callq 0x39b2
leaq 0x5b3e(%rip), %rsi      # 0x9044
leaq 0x90(%rsp), %rdi
leaq 0x2e(%rsp), %rdx
callq 0x39b2
leaq 0x5ebe(%rip), %rsi      # 0x93dd
leaq 0x70(%rsp), %rdi
leaq 0x2d(%rsp), %rdx
callq 0x39b2
xorps %xmm0, %xmm0
movaps %xmm0, 0x50(%rsp)
andq $0x0, 0x60(%rsp)
leaq 0x5e97(%rip), %rsi      # 0x93da
leaq 0xb0(%rsp), %rdi
leaq 0x2c(%rsp), %rdx
callq 0x39b2
movq 0x60(%rsp), %rax
movq %rax, 0x10(%rsp)
movaps 0x50(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %r14, 0x18(%rsp)
andq $0x0, 0x20(%rsp)
leaq 0xd0(%rsp), %rdi
leaq 0x30(%rsp), %rsi
leaq 0x90(%rsp), %rdx
leaq 0x70(%rsp), %rcx
pushq $0x1
popq %r14
leaq 0xb0(%rsp), %r9
movl %r14d, %r8d
callq 0x4544
leaq 0xb0(%rsp), %rdi
callq 0x3348
leaq 0x70(%rsp), %rdi
callq 0x3348
leaq 0x90(%rsp), %rdi
callq 0x3348
leaq 0x30(%rsp), %rdi
callq 0x3348
leaq 0x1d0(%rsp), %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x45f2
leaq 0x178(%rsp), %rdi
movq 0xa9e0(%rip), %rsi      # 0xdfd0
callq 0x46aa
xorl %r14d, %r14d
movq 0xa9d1(%rip), %rdi      # 0xdfd0
callq 0x30d0
leaq 0xd0(%rsp), %rdi
callq 0x46de
leaq 0x1d0(%rsp), %rdi
callq 0x4332
movl %r14d, %eax
addq $0x2b0, %rsp            # imm = 0x2B0
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
cmpl $0x1, %edx
jne 0x36ec
movq %rbx, %rdi
callq 0x3090
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
movq 0xa97f(%rip), %rdi      # 0xdfd0
movq %rax, %rsi
callq 0x3190
movq %rax, %rdi
callq 0x30d0
callq 0x3290
jmp 0x3604
jmp 0x36e9
movq %rax, %rbx
callq 0x3290
jmp 0x36ec
movq %rax, %rdi
callq 0x42dc
movq %rax, %rbx
leaq 0xb0(%rsp), %rdi
callq 0x3348
jmp 0x3691
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0x3348
jmp 0x36a0
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0x3348
jmp 0x36b2
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x3348
jmp 0x36f9
movq %rax, %rbx
jmp 0x36f9
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x3348
jmp 0x36d5
movq %rax, %rbx
leaq 0xd0(%rsp), %rdi
callq 0x3348
jmp 0x3706
movq %rax, %rbx
jmp 0x3706
movq %rax, %rbx
leaq 0xd0(%rsp), %rdi
callq 0x46de
leaq 0x1d0(%rsp), %rdi
callq 0x4332
movq %rbx, %rdi
callq 0x32c0