LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/jc-kim[P]swaptions/HJM_Securities.cpp
// Function: getFactors()
FTYPE* getFactors() {
  // initialize input dataset
  FTYPE* factors = dmatrix(iFactors, iN - 1);
  //the three rows store vol data for the three factors
  factors[0]= .01;
  factors[1]= .01;
  factors[2]= .01;
  factors[3]= .01;
  factors[4]= .01;
  factors[5]= .01;
  factors[6]= .01;
  factors[7]= .01;
  factors[8]= .01;
  factors[9]= .01;

  factors[(iN - 1)]= .009048;
  factors[(iN - 1) + 1]= .008187;
  factors[(iN - 1) + 2]= .007408;
  factors[(iN - 1) + 3]= .006703;
  factors[(iN - 1) + 4]= .006065;
  factors[(iN - 1) + 5]= .005488;
  factors[(iN - 1) + 6]= .004966;
  factors[(iN - 1) + 7]= .004493;
  factors[(iN - 1) + 8]= .004066;
  factors[(iN - 1) + 9]= .003679;

  factors[(iN - 1) * 2]= .001000;
  factors[(iN - 1) * 2 + 1]= .000750;
  factors[(iN - 1) * 2 + 2]= .000500;
  factors[(iN - 1) * 2 + 3]= .000250;
  factors[(iN - 1) * 2 + 4]= .000000;
  factors[(iN - 1) * 2 + 5]= -.000250;
  factors[(iN - 1) * 2 + 6]= -.000500;
  factors[(iN - 1) * 2 + 7]= -.000750;
  factors[(iN - 1) * 2 + 8]= -.001000;
  factors[(iN - 1) * 2 + 9]= -.001250;

  return factors;
}

// Assembly:
pushq %rax
movslq 0x2b1a(%rip), %rdi      # 0x50e8
movslq 0x2b07(%rip), %rsi      # 0x50dc
decq %rsi
callq 0x152b
movaps 0xbcc(%rip), %xmm0      # 0x31b0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x40(%rax)
movslq 0x2ade(%rip), %rcx      # 0x50dc
movaps 0xbbb(%rip), %xmm0      # 0x31c0
movups %xmm0, -0x8(%rax,%rcx,8)
movaps 0xbbf(%rip), %xmm0      # 0x31d0
movups %xmm0, 0x8(%rax,%rcx,8)
movaps 0xbc3(%rip), %xmm0      # 0x31e0
movups %xmm0, 0x18(%rax,%rcx,8)
movaps 0xbc7(%rip), %xmm0      # 0x31f0
movups %xmm0, 0x28(%rax,%rcx,8)
movaps 0xbcb(%rip), %xmm0      # 0x3200
movups %xmm0, 0x38(%rax,%rcx,8)
leal (%rcx,%rcx), %edx
leal -0x2(%rcx,%rcx), %esi
movslq %esi, %rsi
movaps 0xbc5(%rip), %xmm0      # 0x3210
movups %xmm0, (%rax,%rsi,8)
movslq %edx, %rdx
movaps 0xbc7(%rip), %xmm0      # 0x3220
movups %xmm0, (%rax,%rdx,8)
leal 0x2(%rcx,%rcx), %edx
movslq %edx, %rdx
xorps %xmm0, %xmm0
movhps 0xb2a(%rip), %xmm0      # xmm0 = xmm0[0,1],mem[0,1]
movups %xmm0, (%rax,%rdx,8)
leal 0x4(%rcx,%rcx), %edx
movslq %edx, %rdx
movaps 0xbb0(%rip), %xmm0      # 0x3230
movups %xmm0, (%rax,%rdx,8)
leal 0x6(%rcx,%rcx), %ecx
movslq %ecx, %rcx
movaps 0xbae(%rip), %xmm0      # 0x3240
movups %xmm0, (%rax,%rcx,8)
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O2/jc-kim[P]swaptions/timers.c
// Function: timer_init()
void timer_init() {
  int i;
  for (i = 0; i < NUM_TIMERS; i++) {
    t_start[i] = 0.0;
    t_elapsed[i] = 0.0;
    t_count[i] = 0;
  }
}

// Assembly:
leaq 0x2b8d(%rip), %rax      # 0x5510
xorl %ecx, %ecx
leaq 0x2784(%rip), %rdx      # 0x5110
leaq 0x297d(%rip), %rsi      # 0x5310
cmpq $0x200, %rcx            # imm = 0x200
je 0x29b3
andq $0x0, (%rcx,%rdx)
andq $0x0, (%rcx,%rsi)
andl $0x0, (%rax)
addq $0x8, %rcx
addq $0x4, %rax
jmp 0x2993
retq
// File: /workspace/github_cpp_makefile_star2_O2/davmac314[P]dinit/src/includes/dinit-client.h
// Function: get_passed_cfd()
inline int get_passed_cfd()
{
    int socknum = -1;
    char * dinit_cs_fd_env = getenv("DINIT_CS_FD");
    if (dinit_cs_fd_env != nullptr) {
        char * endptr;
        long int cfdnum = strtol(dinit_cs_fd_env, &endptr, 10);
        if (endptr != dinit_cs_fd_env) {
            socknum = (int) cfdnum;
            // Set blocking mode (and validate file descriptor):
            errno = 0;
            int sock_flags = fcntl(socknum, F_GETFL, 0);
            if (sock_flags == -1 && errno != 0) {
                socknum = 0;
            }
            else {
                fcntl(socknum, F_SETFL, sock_flags & ~O_NONBLOCK);
            }
        }
    }
    return socknum;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leaq 0x482b(%rip), %rdi      # 0x88c0
callq 0x32b0
testq %rax, %rax
je 0x40f2
movq %rax, %r14
movq %rsp, %r15
pushq $0xa
popq %rdx
movq %rax, %rdi
movq %r15, %rsi
callq 0x3350
cmpq %r14, (%r15)
je 0x40f2
movq %rax, %rbx
callq 0x3030
movq %rax, %r14
andl $0x0, (%rax)
xorl %ebp, %ebp
pushq $0x3
popq %rsi
movl %ebx, %edi
xorl %edx, %edx
xorl %eax, %eax
callq 0x3170
cmpl $-0x1, %eax
je 0x4102
andl $0xfffff7ff, %eax       # imm = 0xFFFFF7FF
pushq $0x4
popq %rsi
movl %ebx, %edi
movl %eax, %edx
xorl %eax, %eax
callq 0x3170
movl %ebx, %ebp
jmp 0x40f5
pushq $-0x1
popq %rbp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x0, (%r14)
jne 0x40f5
jmp 0x40db
// File: /workspace/github_cpp_makefile_star2_O2/davmac314[P]dinit/src/includes/dinit-client.h
// Function: check_protocol_version(int, int, cpbuffer<1024u>&, int)
inline uint16_t check_protocol_version(int minversion, int version, cpbuffer_t &rbuffer, int fd)
{
    using namespace dinit_cptypes;
    constexpr int bufsize = 1;
    char buf[bufsize] = { (char)cp_cmd::QUERYVERSION };
    write_all_x(fd, buf, bufsize);

    wait_for_reply(rbuffer, fd);
    if (rbuffer[0] != (char)cp_rply::CPVERSION) {
        throw cp_read_exception{0};
    }

    // cp_rply::CVERSION, (2 byte) minimum compatible version, (2 byte) actual version
    constexpr int rbufsize = 1 + 2 * sizeof(uint16_t);
    fill_buffer_to(rbuffer, fd, rbufsize);
    uint16_t rminversion;
    uint16_t cpversion;

    rbuffer.extract(reinterpret_cast<char *>(&rminversion), 1, sizeof(uint16_t));
    rbuffer.extract(reinterpret_cast<char *>(&cpversion), 1 + sizeof(uint16_t), sizeof(uint16_t));
    rbuffer.consume(rbufsize);

    if (rminversion > version) {
        // We are too old
        throw cp_old_client_exception();
    }
    if (cpversion < minversion) {
        // Server is too old
        throw cp_old_server_exception();
    }

    return cpversion;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %r15d
movq %rdx, %r14
movl %esi, %ebp
movl %edi, %ebx
leaq 0x5(%rsp), %rsi
movb $0x0, (%rsi)
pushq $0x1
popq %rdx
movl %ecx, %edi
callq 0x4200
movq %r14, %rdi
movl %r15d, %esi
callq 0x4232
movl 0x400(%r14), %eax
leal -0x400(%rax), %ecx
cmpl $0x400, %eax            # imm = 0x400
cmovbl %eax, %ecx
cmpb $0x3a, (%r14,%rcx)
jne 0x41c2
pushq $0x5
popq %r12
movq %r14, %rdi
movl %r15d, %esi
movl %r12d, %edx
callq 0x443d
leaq 0x6(%rsp), %r15
pushq $0x1
popq %rdx
pushq $0x2
popq %r13
movq %r14, %rdi
movq %r15, %rsi
movl %r13d, %ecx
callq 0x44a4
leaq 0x2(%rsp), %rsi
pushq $0x3
popq %rdx
movq %r14, %rdi
movl %r13d, %ecx
callq 0x44a4
movq %r14, %rdi
movl %r12d, %esi
callq 0x4520
movzwl (%r15), %eax
cmpl %ebp, %eax
jg 0x41d6
movzwl 0x2(%rsp), %eax
cmpl %ebx, %eax
jl 0x41e7
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x4
popq %rdi
callq 0x3130
andl $0x0, (%rax)
leaq 0x88bc(%rip), %rsi      # 0xca90
jmp 0x41f6
pushq $0x1
popq %rdi
callq 0x3130
leaq 0x887b(%rip), %rsi      # 0xca60
jmp 0x41f6
pushq $0x1
popq %rdi
callq 0x3130
leaq 0x8882(%rip), %rsi      # 0xca78
movq %rax, %rdi
xorl %edx, %edx
callq 0x33f0
// File: /workspace/github_cpp_makefile_star2_O2/davmac314[P]dinit/src/includes/dinit-client.h
// Function: wait_for_reply(cpbuffer<1024u>&, int)
inline void wait_for_reply(cpbuffer_t &rbuffer, int fd)
{
    fill_buffer_to(rbuffer, fd, 1);

    while (rbuffer[0] >= 100) {
        // Information packet; discard.
        fill_buffer_to(rbuffer, fd, 2);
        int pktlen = (unsigned char) rbuffer[1];

        rbuffer.consume(1);  // Consume one byte so we'll read one byte of the next packet
        fill_buffer_to(rbuffer, fd, pktlen);
        rbuffer.consume(pktlen - 1);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
pushq $0x1
popq %rbp
movl %ebp, %edx
callq 0x443d
pushq $0x2
popq %r15
movl 0x400(%r14), %eax
leal -0x400(%rax), %ecx
cmpl $0x400, %eax            # imm = 0x400
cmovbl %eax, %ecx
cmpb $0x64, (%r14,%rcx)
jl 0x42ba
movq %r14, %rdi
movl %ebx, %esi
movl %r15d, %edx
callq 0x443d
movl 0x400(%r14), %eax
leal 0x1(%rax), %ecx
addl $0xfffffc01, %eax       # imm = 0xFFFFFC01
cmpl $0x400, %ecx            # imm = 0x400
cmovbl %ecx, %eax
movzbl (%r14,%rax), %r12d
movq %r14, %rdi
movl %ebp, %esi
callq 0x4520
movq %r14, %rdi
movl %ebx, %esi
movl %r12d, %edx
callq 0x443d
decl %r12d
movq %r14, %rdi
movl %r12d, %esi
callq 0x4520
jmp 0x424d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/davmac314[P]dinit/src/shutdown.cc
// Function: subproc_buffer::subproc_buffer(dasynq::v2::event_loop<dasynq::null_mutex, dasynq::v2::default_traits<dasynq::null_mutex>>&, int)
subproc_buffer(dasynq::event_loop_n &loop_p, int out_fd) : loop(loop_p)
    {
        using loop_t = dasynq::event_loop_n;
        using rearm = dasynq::rearm;

        out_watch = loop_t::fd_watcher::add_watch(loop, out_fd, dasynq::OUT_EVENTS,
                [&](loop_t &eloop, int fd, int flags) -> rearm {

            auto fstatus = flush(STDOUT_FILENO);
            if (fstatus == subproc_buffer::fill_status::ENDFILE) {
                return rearm::DISARM;
            }

            return rearm::REARM;
        });
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movaps 0x3d25(%rip), %xmm0     # 0x8010
movups %xmm0, 0x1000(%rdi)
andq $0x0, 0x1010(%rdi)
movq %rsi, 0x1018(%rdi)
pushq $0x2
popq %rax
movq %rsi, %rdi
movl %edx, %esi
movl %eax, %edx
movq %rbx, %rcx
callq 0x462e
movq %rax, 0x1020(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/davmac314[P]dinit/src/shutdown.cc
// Function: subproc_buffer::append(char const*)
void append(const char *msg)
    {
        out_watch->set_enabled(loop, true);
        unsigned len = strlen(msg);
        if (subproc_bufsize - get_length() >= len) {
            base::append(msg, len);
        }
        else {
            mark_overflow();
        }
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x1018(%rdi), %rsi
movq 0x1020(%rdi), %rdi
pushq $0x1
popq %rdx
callq 0x4fa0
movq %rbx, %rdi
callq 0x30e0
movl $0x1000, %ecx           # imm = 0x1000
subl 0x1004(%r14), %ecx
movq %r14, %rdi
cmpl %eax, %ecx
jae 0x4363
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x5090
movq %rbx, %rsi
movl %eax, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x501a
// 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>>::run(int)
void run(int limit = -1) noexcept
    {
        // Poll the mechanism first, in case high-priority events are pending:
        waitqueue_node<T_Mutex> qnode;
        get_pollwait_lock(qnode);
        loop_mech.pull_events(false);
        release_lock(qnode);

        while (! process_events(limit)) {
            // Pull events from the AEN mechanism and insert them in our internal queue:
            get_pollwait_lock(qnode);
            loop_mech.pull_events(true);
            release_lock(qnode);
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
leaq 0x7(%rsp), %rsi
callq 0x72d2
movq %r14, %rdi
xorl %esi, %esi
callq 0x7306
leaq 0x7(%rsp), %r15
pushq $0x1
popq %rbp
movq %r14, %rdi
movq %r15, %rsi
callq 0x5420
movq %r14, %rdi
movl %ebx, %esi
callq 0x7366
testb %al, %al
jne 0x43cc
movq %r14, %rdi
movq %r15, %rsi
callq 0x72d2
movq %r14, %rdi
movl %ebp, %esi
callq 0x7306
jmp 0x439c
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x43d9
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>>::poll(int)
void poll(int limit = -1) noexcept
    {
        waitqueue_node<T_Mutex> qnode;
        if (poll_attn_lock(qnode)) {
            loop_mech.pull_events(false);
            release_lock(qnode);
        }

        process_events(limit);
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
leaq 0x7(%rsp), %rsi
callq 0x7b44
testb %al, %al
je 0x4410
movq %r14, %rdi
xorl %esi, %esi
callq 0x7306
leaq 0x7(%rsp), %rsi
movq %r14, %rdi
callq 0x5420
movq %r14, %rdi
movl %ebx, %esi
callq 0x7366
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0x42c3
// File: /workspace/github_cpp_makefile_star2_O2/davmac314[P]dinit/src/includes/dinit-client.h
// Function: fill_buffer_to(cpbuffer<1024u>&, int, int)
inline void fill_buffer_to(cpbuffer_t &buf, int fd, int rlength)
{
    do {
        int r = buf.fill_to(fd, rlength);
        if (r == -1) {
            if (errno != EINTR) {
                throw cp_read_exception(errno);
            }
        }
        else if (r == 0) {
            throw cp_read_exception(0);
        }
        else {
            return;
        }
    }
    while (true);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
movq %r14, %rdi
movl %ebp, %esi
movl %ebx, %edx
callq 0x4546
cmpl $-0x1, %eax
jne 0x4478
callq 0x3030
cmpl $0x4, (%rax)
je 0x444b
movq %rax, %r15
pushq $0x4
popq %rdi
callq 0x3130
movl (%r15), %ecx
movl %ecx, (%rax)
jmp 0x4492
testl %eax, %eax
je 0x4487
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x4
popq %rdi
callq 0x3130
andl $0x0, (%rax)
leaq 0x85f7(%rip), %rsi      # 0xca90
movq %rax, %rdi
xorl %edx, %edx
callq 0x33f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/davmac314[P]dinit/src/includes/cpbuffer.h
// Function: cpbuffer<1024u>::extract(void*, unsigned int, unsigned int)
void extract(void *dest, unsigned index, unsigned length) noexcept
    {
        index += cur_idx;
        if (index >= SIZE) index -= SIZE;
        if (index + length > SIZE) {
            // wrap-around copy
            unsigned half = SIZE - index;
            std::memcpy(dest, buf + index, half);
            std::memcpy(reinterpret_cast<char *>(dest) + half, buf, length - half);
        }
        else {
            std::memcpy(dest, buf + index, length);
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rsi, %r15
movq %rdi, %r14
movl 0x400(%rdi), %eax
leal (%rax,%rdx), %ecx
cmpl $0x400, %ecx            # imm = 0x400
leal -0x400(%rax,%rdx), %eax
cmovbl %ecx, %eax
leal (%rax,%rbx), %ecx
cmpl $0x401, %ecx            # imm = 0x401
jb 0x4502
movl $0x400, %r12d           # imm = 0x400
subl %eax, %r12d
movl %eax, %esi
addq %r14, %rsi
movq %r15, %rdi
movq %r12, %rdx
callq 0x31e0
addq %r12, %r15
subl %r12d, %ebx
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
jmp 0x450f
movl %eax, %eax
addq %rax, %r14
movl %ebx, %edx
movq %r15, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x31e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/davmac314[P]dinit/src/includes/cpbuffer.h
// Function: cpbuffer<1024u>::fill(int)
int fill(int fd) noexcept
    {
        unsigned pos = cur_idx + length;
        if (pos >= SIZE) pos -= SIZE;
        unsigned max_count = std::min(SIZE - pos, SIZE - length);
        ssize_t r = bp_sys::read(fd, buf + pos, max_count);
        if (r >= 0) {
            length += r;
        }
        return r;
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl 0x400(%rdi), %eax
movl 0x404(%rdi), %ecx
leal (%rcx,%rax), %edi
movl $0x400, %edx            # imm = 0x400
cmpl %edx, %edi
leal -0x400(%rcx,%rax), %eax
cmovbl %edi, %eax
movl %esi, %edi
movl $0x400, %esi            # imm = 0x400
subl %eax, %esi
subl %ecx, %edx
cmpl %esi, %edx
cmovael %esi, %edx
addq %rbx, %rax
movq %rax, %rsi
callq 0x3370
testq %rax, %rax
js 0x45ca
addl %eax, 0x404(%rbx)
popq %rbx
retq
movq %rax, %rdi
callq 0x42c3
// File: /workspace/github_cpp_makefile_star2_O2/davmac314[P]dinit/src/includes/dinit-client.h
// Function: write_all(int, void const*, int)
inline int write_all(int fd, const void *buf, int count)
{
    const char *cbuf = static_cast<const char *>(buf);
    int w = 0;
    while (count > 0) {
        int r = write(fd, cbuf, count);
        if (r == -1) {
            if (errno == EINTR) continue;
            return (w > 0) ? w : r;
        }
        w += r;
        cbuf += r;
        count -= r;
    }
    return w;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r14d
movq %rsi, %r15
movl %edi, %ebp
xorl %ebx, %ebx
movl %r14d, %r14d
testl %r14d, %r14d
jle 0x4620
movl %ebp, %edi
movq %r15, %rsi
movq %r14, %rdx
callq 0x30b0
cmpl $-0x1, %eax
jne 0x460b
callq 0x3030
cmpl $0x4, (%rax)
je 0x45e8
jmp 0x4618
addl %eax, %ebx
movslq %eax, %rcx
addq %rcx, %r15
subl %eax, %r14d
jmp 0x45e5
testl %ebx, %ebx
pushq $-0x1
popq %rax
cmovlel %eax, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/davmac314[P]dinit/src/../dasynq/include/dasynq.h
// Function: dasynq::v2::dprivate::fd_watcher<dasynq::v2::event_loop<dasynq::null_mutex, dasynq::v2::default_traits<dasynq::null_mutex>>>* dasynq::v2::dprivate::fd_watcher<dasynq::v2::event_loop<dasynq::null_mutex, dasynq::v2::default_traits<dasynq::null_mutex>>>::add_watch<subproc_buffer::subproc_buffer(dasynq::v2::event_loop<dasynq::null_mutex, dasynq::v2::default_traits<dasynq::null_mutex>>&, int)::'lambda'(dasynq::v2::event_loop<dasynq::null_mutex, dasynq::v2::default_traits<dasynq::null_mutex>>&, int, int)>(dasynq::v2::event_loop<dasynq::null_mutex, dasynq::v2::default_traits<dasynq::null_mutex>>&, int, int, subproc_buffer::subproc_buffer(dasynq::v2::event_loop<dasynq::null_mutex, dasynq::v2::default_traits<dasynq::null_mutex>>&, int)::'lambda'(dasynq::v2::event_loop<dasynq::null_mutex, dasynq::v2::default_traits<dasynq::null_mutex>>&, int, int))
static fd_watcher<EventLoop> *add_watch(event_loop_t &eloop, int fd, int flags, T watchHndlr)
    {
        class lambda_fd_watcher : public fd_watcher_impl<event_loop_t, lambda_fd_watcher>
        {
            private:
            T watchHndlr;

            public:
            lambda_fd_watcher(T watchHandlr_a) : watchHndlr(watchHandlr_a)
            {
                //
            }

            rearm fd_event(event_loop_t &eloop, int fd, int flags)
            {
                return watchHndlr(eloop, fd, flags);
            }

            void watch_removed() noexcept override
            {
                delete this;
            }
        };
        
        lambda_fd_watcher * lfd = new lambda_fd_watcher(watchHndlr);
        lfd->add_watch(eloop, fd, flags);
        return lfd;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %r15
pushq $0x30
popq %rdi
callq 0x3280
movq %rax, %r12
movl $0x1, 0x8(%rax)
leaq 0x8586(%rip), %rax      # 0xcbe0
movq %rax, (%r12)
movq %rbx, 0x28(%r12)
pushq $0x1
popq %r8
pushq $0x32
popq %r9
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
callq 0x4688
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/davmac314[P]dinit/src/../dasynq/include/dasynq.h
// Function: dasynq::v2::dprivate::fd_watcher<dasynq::v2::event_loop<dasynq::null_mutex, dasynq::v2::default_traits<dasynq::null_mutex>>>::add_watch(dasynq::v2::event_loop<dasynq::null_mutex, dasynq::v2::default_traits<dasynq::null_mutex>>&, int, int, bool, int)
void add_watch(event_loop_t &eloop, int fd, int flags, bool enabled = true, int prio = DEFAULT_PRIORITY)
    {
        base_watcher::init();
        this->priority = prio;
        this->watch_fd = fd;
        this->watch_flags = flags;
        eloop.register_fd(this, fd, flags, enabled, true);
    }

// Assembly:
movq %rdi, %rax
andb $-0x20, 0xc(%rdi)
movq %rsi, %rdi
movl %r9d, 0x18(%rax)
movl %edx, 0x1c(%rax)
movl %ecx, 0x20(%rax)
pushq $0x1
popq %r9
movq %rax, %rsi
jmp 0x4ca4
// File: /workspace/github_cpp_makefile_star2_O2/davmac314[P]dinit/src/../dasynq/include/dasynq.h
// Function: dasynq::v2::dprivate::fd_watcher_impl<dasynq::v2::event_loop<dasynq::null_mutex, dasynq::v2::default_traits<dasynq::null_mutex>>, dasynq::v2::dprivate::fd_watcher<dasynq::v2::event_loop<dasynq::null_mutex, dasynq::v2::default_traits<dasynq::null_mutex>>>* dasynq::v2::dprivate::fd_watcher<dasynq::v2::event_loop<dasynq::null_mutex, dasynq::v2::default_traits<dasynq::null_mutex>>>::add_watch<subproc_buffer::subproc_buffer(dasynq::v2::event_loop<dasynq::null_mutex, dasynq::v2::default_traits<dasynq::null_mutex>>&, int)::'lambda'(dasynq::v2::event_loop<dasynq::null_mutex, dasynq::v2::default_traits<dasynq::null_mutex>>&, int, int)>(dasynq::v2::event_loop<dasynq::null_mutex, dasynq::v2::default_traits<dasynq::null_mutex>>&, int, int, subproc_buffer::subproc_buffer(dasynq::v2::event_loop<dasynq::null_mutex, dasynq::v2::default_traits<dasynq::null_mutex>>&, int)::'lambda'(dasynq::v2::event_loop<dasynq::null_mutex, dasynq::v2::default_traits<dasynq::null_mutex>>&, int, int))::lambda_fd_watcher>::dispatch(void*)
void dispatch(void *loop_ptr) noexcept override
    {
        EventLoop &loop = *static_cast<EventLoop *>(loop_ptr);

        // In case emulating, clear enabled here; REARM or explicit set_enabled will re-enable.
        this->emulate_enabled = false;

        loop_access::get_base_lock(loop).unlock();

        auto rearm_type = static_cast<Derived *>(this)->fd_event(loop, this->watch_fd, this->event_flags);

        loop_access::get_base_lock(loop).lock();

        if (rearm_type != rearm::REMOVED) {
            this->event_flags = 0;
            this->active = false;
            if (this->deleteme) {
                // We don't want a watch that is marked "deleteme" to re-arm itself.
                rearm_type = rearm::REMOVE;
            }

            rearm_type = loop_access::process_fd_rearm(loop, this, rearm_type);

            post_dispatch(loop, this, rearm_type);
        }
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
andb $-0x9, 0xc(%rdi)
movq %rsi, %r14
movl 0x1c(%rdi), %edx
movl 0x24(%rdi), %ecx
addq $0x28, %rdi
callq 0x4750
cmpl $0x4, %eax
jne 0x46d2
addq $0x8, %rsp
popq %rbx
popq %r14
retq
andl $0x0, 0x24(%rbx)
movb 0xc(%rbx), %cl
movl %ecx, %edx
andb $-0x2, %dl
movb %dl, 0xc(%rbx)
testb $0x2, %cl
pushq $0x3
popq %rdx
cmovel %eax, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4974
movq %r14, %rdi
movq %rbx, %rsi
movl %eax, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4723
movq %rax, %rdi
callq 0x42c3
nop
// File: /workspace/github_cpp_makefile_star2_O2/davmac314[P]dinit/src/../dasynq/include/dasynq.h
// Function: void dasynq::v2::dprivate::post_dispatch<dasynq::v2::event_loop<dasynq::null_mutex, dasynq::v2::default_traits<dasynq::null_mutex>>>(dasynq::v2::event_loop<dasynq::null_mutex, dasynq::v2::default_traits<dasynq::null_mutex>>&, dasynq::v2::dprivate::base_watcher*, dasynq::rearm)
void post_dispatch(Loop &loop, base_watcher *watcher, rearm rearm_type)
    {
        if (rearm_type == rearm::REMOVE) {
            loop_access::get_base_lock(loop).unlock();
            loop_access::release_watcher(loop, watcher);
            watcher->watch_removed();
            loop_access::get_base_lock(loop).lock();
        }
        else if (rearm_type == rearm::REQUEUE) {
            loop_access::requeue_watcher(loop, watcher);
        }
    }

// Assembly:
pushq %rbx
movq %rsi, %rbx
cmpl $0x5, %edx
je 0x4744
cmpl $0x3, %edx
jne 0x474d
leaq 0x10(%rbx), %rsi
callq 0x4a8c
movq (%rbx), %rax
movq %rbx, %rdi
popq %rbx
jmpq *0x20(%rax)
movq %rbx, %rsi
popq %rbx
jmp 0x4b2e
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/davmac314[P]dinit/src/includes/cpbuffer.h
// Function: cpbuffer<4096u>::get_contiguous_length(char*)
unsigned get_contiguous_length(char *ptr)
    {
        if (length == 0) return 0;

        unsigned eidx = cur_idx + length;
        if (eidx >= SIZE) eidx -= SIZE;
        
        if (buf + eidx > ptr) {
            return (buf + eidx) - ptr;
        }
        else {
            return (buf + SIZE) - ptr;
        }
    }

// Assembly:
movl 0x1004(%rdi), %ecx
testl %ecx, %ecx
je 0x48cf
leaq 0x1000(%rdi), %rax
movl 0x1000(%rdi), %edx
leal (%rdx,%rcx), %r8d
cmpl $0x1000, %r8d           # imm = 0x1000
leal -0x1000(%rdx,%rcx), %ecx
cmovbl %r8d, %ecx
addq %rdi, %rcx
cmpq %rsi, %rcx
cmoval %ecx, %eax
subl %esi, %eax
retq
xorl %eax, %eax
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>>::process_fd_rearm(dasynq::v2::dprivate::base_fd_watcher*, dasynq::rearm)
rearm process_fd_rearm(base_fd_watcher * bfw, rearm rearm_type) noexcept
    {
        bool emulatedfd = static_cast<base_watcher *>(bfw)->emulatefd;

        if (emulatedfd) {
            if (rearm_type == rearm::REARM) {
                bfw->emulate_enabled = true;
                rearm_type = rearm::REQUEUE;
            }
            else if (rearm_type == rearm::DISARM) {
                bfw->emulate_enabled = false;
            }
            else if (rearm_type == rearm::NOOP) {
                if (bfw->emulate_enabled) {
                    rearm_type = rearm::REQUEUE;
                }
            }
        }
        else  if (rearm_type == rearm::REARM) {
            set_fd_enabled_nolock(bfw, bfw->watch_fd,
                    bfw->watch_flags & (IN_EVENTS | OUT_EVENTS), true);
        }
        else if (rearm_type == rearm::DISARM) {
            loop_mech.disable_fd_watch_nolock(bfw->watch_fd, bfw->watch_flags);
        }
        else if (rearm_type == rearm::REMOVE) {
            loop_mech.remove_fd_watch_nolock(bfw->watch_fd, bfw->watch_flags);
        }
        return rearm_type;
    }

// Assembly:
pushq %rax
movl %edx, %eax
movq %rsi, %rdx
movb 0xc(%rsi), %cl
testb $0x4, %cl
jne 0x49a5
cmpl $0x3, %eax
je 0x49d4
cmpl $0x1, %eax
je 0x49bd
testl %eax, %eax
jne 0x49e2
movl 0x1c(%rdx), %esi
movl 0x20(%rdx), %ecx
andl $0x3, %ecx
orl $0x8, %ecx
callq 0x4a14
xorl %eax, %eax
jmp 0x49e2
cmpl $0x2, %eax
je 0x49e4
cmpl $0x1, %eax
je 0x49ca
testl %eax, %eax
jne 0x49e2
orb $0x8, %cl
movb %cl, 0xc(%rdx)
pushq $0x5
jmp 0x49e1
movl 0x1c(%rdx), %esi
movl 0x20(%rdx), %edx
callq 0x4a54
jmp 0x49d0
andb $-0x9, %cl
movb %cl, 0xc(%rdx)
pushq $0x1
jmp 0x49e1
movl 0x1c(%rdx), %esi
movl 0x20(%rdx), %edx
callq 0x4a7a
pushq $0x3
popq %rax
popq %rcx
retq
andb $0x8, %cl
shrb $0x3, %cl
movzbl %cl, %eax
leal (%rax,%rax,2), %eax
addl $0x2, %eax
jmp 0x49e2
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>>::enable_fd_watch(int, void*, int)
void enable_fd_watch(int fd, void *userdata, int flags) noexcept
    {
        struct epoll_event epevent;
        // epevent.data.fd = fd;
        epevent.data.ptr = userdata;
        epevent.events = 0;
        
        if (flags & ONE_SHOT) {
            epevent.events = EPOLLONESHOT;
        }
        if (flags & IN_EVENTS) {
            epevent.events |= EPOLLIN;
        }
        if (flags & OUT_EVENTS) {
            epevent.events |= EPOLLOUT;
        }
        
        if (epoll_ctl(epfd, EPOLL_CTL_MOD, fd, &epevent) == -1) {
            // Shouldn't be able to fail
            // throw std::system_error(errno, std::system_category());
        }
    }

// Assembly:
subq $0x18, %rsp
movl %esi, %eax
leaq 0xc(%rsp), %r8
movq %rdx, 0x4(%r8)
movl %ecx, %edx
andl $0x8, %edx
shll $0x1b, %edx
movl %ecx, %esi
andl $0x1, %esi
orl %edx, %esi
andl $0x2, %ecx
leal (%rsi,%rcx,2), %ecx
movl %ecx, (%r8)
movl 0xa0(%rdi), %edi
pushq $0x3
popq %rsi
movl %eax, %edx
movq %r8, %rcx
callq 0x3330
addq $0x18, %rsp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/davmac314[P]dinit/src/../dasynq/include/dasynq/svec.h
// Function: dasynq::svector<dasynq::dary_heap<dasynq::v2::dprivate::empty_node, dasynq::stable_prio<int>, dasynq::compare_stable_prio<int, std::less<int>>, 4>::heap_node>::change_capacity(unsigned long)
bool change_capacity(size_type c)
            noexcept(std::is_nothrow_move_constructible<T>::value || std::is_nothrow_copy_constructible<T>::value)
    {
        _Pragma ("GCC diagnostic push")
        _Pragma ("GCC diagnostic ignored \"-Walloc-size-larger-than=\"")

        T *new_storage = (T *)(new (std::nothrow) char[c * sizeof(T)]);
        if (new_storage == nullptr) return false;

        _Pragma ("GCC diagnostic pop")

        // To transfer, we prefer move unless it is throwing and copy exists
        svec_helper::move_helper<T>::move(array, new_storage, size_v);

        delete[] (char *)array;
        array = new_storage;
        capacity_v = c;

        return true;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
imulq $0x18, %rsi, %rdi
movq 0x84b0(%rip), %rsi      # 0xcf80
callq 0x33e0
movq %rax, %r15
testq %rax, %rax
je 0x4b00
movq (%r14), %rdi
movq 0x8(%r14), %rdx
movq %r15, %rsi
callq 0x4b0c
movq (%r14), %rdi
testq %rdi, %rdi
je 0x4af9
callq 0x3300
movq %r15, (%r14)
movq %rbx, 0x10(%r14)
testq %r15, %r15
setne %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/davmac314[P]dinit/src/../dasynq/include/dasynq/daryheap.h
// Function: dasynq::dary_heap<dasynq::v2::dprivate::empty_node, dasynq::stable_prio<int>, dasynq::compare_stable_prio<int, std::less<int>>, 4>::insert(dasynq::dary_heap<dasynq::v2::dprivate::empty_node, dasynq::stable_prio<int>, dasynq::compare_stable_prio<int, std::less<int>>, 4>::handle_t&, dasynq::stable_prio<int> const&)
bool insert(handle_t & hnd, const P &pval) noexcept
    {
        hnd.heap_index = hvec.size();
        // emplace an empty node; data/prio will be stored via bubble_down.
        hvec.emplace_back();
        return bubble_down(hvec.size() - 1, &hnd, pval);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x8(%rdi), %rax
movq %rax, (%rsi)
callq 0x4b9e
movq 0x8(%r15), %rsi
decq %rsi
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %rcx
popq %rbx
popq %r14
popq %r15
jmp 0x4be6
movq %rax, %rdi
callq 0x42c3
// File: /workspace/github_cpp_makefile_star2_O2/davmac314[P]dinit/src/../dasynq/include/dasynq/svec.h
// Function: void dasynq::svector<dasynq::dary_heap<dasynq::v2::dprivate::empty_node, dasynq::stable_prio<int>, dasynq::compare_stable_prio<int, std::less<int>>, 4>::heap_node>::emplace_back<>()
void emplace_back(U... args)
    {
        if (!ensure_capacity(size_v + 1)) {
            throw std::bad_alloc();
        }
        new (&array[size_v]) T(args...);
        size_v++;
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rsi
incq %rsi
xorl %edx, %edx
callq 0x4c56
testb %al, %al
je 0x4bba
incq 0x8(%rbx)
popq %rbx
retq
pushq $0x8
popq %rdi
callq 0x3130
movq 0x83df(%rip), %rcx      # 0xcfa8
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x83e9(%rip), %rsi      # 0xcfc0
movq 0x83ba(%rip), %rdx      # 0xcf98
movq %rax, %rdi
callq 0x33f0
// 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_fd(dasynq::v2::dprivate::base_fd_watcher*, int, int, bool, bool)
void register_fd(base_fd_watcher *callback, int fd, int eventmask, bool enabled, bool emulate = false)
    {
        std::lock_guard<mutex_t> guard(loop_mech.lock);

        loop_mech.prepare_watcher(callback);

        try {
            if (! loop_mech.add_fd_watch(fd, callback, eventmask | ONE_SHOT, enabled, emulate)) {
                callback->emulatefd = true;
                callback->emulate_enabled = enabled;
                if (enabled) {
                    callback->event_flags = eventmask & IO_EVENTS;
                    if (eventmask & IO_EVENTS) {
                        requeue_watcher(callback);
                    }
                }
            }
            else if (enabled && backend_traits_t::interrupt_after_fd_add) {
                interrupt_if_necessary();
            }
        }
        catch (...) {
            loop_mech.release_watcher(callback);
            throw;
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %r13d
movl %r8d, %r15d
movl %ecx, %ebp
movl %edx, %r12d
movq %rsi, %r14
movq %rdi, %rbx
addq $0x10, %rsi
movq %rsi, (%rsp)
callq 0x4e2a
movl %ebp, %ecx
orl $0x8, %ecx
movq %rbx, %rdi
movl %r12d, %esi
movq %r14, %rdx
movl %r15d, %r8d
movl %r13d, %r9d
callq 0x4d68
testb %al, %al
jne 0x4d28
movb 0xc(%r14), %al
andb $-0xd, %al
leal (,%r15,8), %ecx
orb %al, %cl
orb $0x4, %cl
movb %cl, 0xc(%r14)
testb %r15b, %r15b
je 0x4d28
andl $0x3, %ebp
movl %ebp, 0x24(%r14)
je 0x4d28
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4b2e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rdi
callq 0x30d0
movq %rbx, %rdi
movq (%rsp), %rsi
callq 0x4a8c
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/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_fd_watch(int, void*, int, bool, bool)
bool add_fd_watch(int fd, void *userdata, int flags, bool enabled = true, bool soft_fail = false)
    {
        struct epoll_event epevent;
        // epevent.data.fd = fd;
        epevent.data.ptr = userdata;
        epevent.events = 0;
        
        if (flags & ONE_SHOT) {
            epevent.events = EPOLLONESHOT;
        }
        if ((flags & IN_EVENTS) && enabled) {
            epevent.events |= EPOLLIN;
        }
        if ((flags & OUT_EVENTS) && enabled) {
            epevent.events |= EPOLLOUT;
        }

        if (epoll_ctl(epfd, EPOLL_CTL_ADD, fd, &epevent) == -1) {
            if (soft_fail && errno == EPERM) {
                return false;
            }
            throw std::system_error(errno, std::system_category());
        }
        return true;
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %r9d, %ebx
movl %esi, %eax
leaq 0x4(%rsp), %r9
movq %rdx, 0x4(%r9)
movl %ecx, %edx
andl $0x8, %edx
shll $0x1b, %edx
movl %ecx, %esi
andl %r8d, %esi
leal (%rdx,%rsi), %r10d
addl %esi, %edx
addl $0x4, %edx
testl %r8d, %r8d
cmovel %r10d, %edx
testb $0x2, %cl
cmovel %r10d, %edx
movl %edx, (%r9)
movl 0xa0(%rdi), %edi
pushq $0x1
popq %rsi
movl %eax, %edx
movq %r9, %rcx
callq 0x3330
movl %eax, %ebp
cmpl $-0x1, %eax
jne 0x4dcd
testb %bl, %bl
je 0x4ddc
callq 0x3030
cmpl $0x1, (%rax)
jne 0x4ddc
cmpl $-0x1, %ebp
setne %al
addq $0x10, %rsp
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 0x8181(%rip), %rsi      # 0xcf88
movq 0x81a2(%rip), %rdx      # 0xcfb0
movq %rbx, %rdi
callq 0x33f0
movq %rax, %r14
movq %rbx, %rdi
callq 0x31a0
movq %r14, %rdi
callq 0x3400
nop
// File: /workspace/github_cpp_makefile_star2_O2/davmac314[P]dinit/src/../dasynq/include/dasynq/daryheap.h
// Function: void dasynq::dary_heap<dasynq::timer_data, dasynq::time_val, dasynq::compare_timespec, 4>::allocate<void*&>(dasynq::dary_heap<dasynq::timer_data, dasynq::time_val, dasynq::compare_timespec, 4>::handle_t&, void*&)
void allocate(handle_t & hnd, U&&... u)
    {
        // Note: this can be constexpr in C++20
        const hindex_t max_allowed = hvec.max_size();

        if (num_nodes == max_allowed) {
            throw std::bad_alloc();
        }

        num_nodes++;

        if (DASYNQ_EXPECT(hvec.capacity() < num_nodes, 0)) {
            hindex_t half_point = max_allowed / 2;
            try {
                if (DASYNQ_EXPECT(num_nodes < half_point, 1)) {
                    hvec.reserve(num_nodes * 2);
                }
                else {
                    hvec.reserve(max_allowed);
                }
            }
            catch (...) {
                // try with just the needed number of nodes:
                try {
                    hvec.reserve(num_nodes);
                }
                catch (...) {
                    num_nodes--;
                    throw;
                }
            }
        }

        new (& hnd.hd_u.hd) T(std::forward<U>(u)...);
        hnd.heap_index = -1;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movabsq $0xaaaaaaaaaaaaaaa, %rsi # imm = 0xAAAAAAAAAAAAAAA
movq 0x18(%rdi), %rax
cmpq %rsi, %rax
je 0x6e63
movq %rdx, %r14
movq %rdi, %r15
incq %rax
movq %rax, 0x18(%rdi)
cmpq %rax, 0x10(%rdi)
jb 0x6e44
movq (%r14), %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
andl $0x0, 0x10(%rbx)
movb $0x1, 0x14(%rbx)
movq %rax, 0x18(%rbx)
orq $-0x1, 0x20(%rbx)
popq %rbx
popq %r14
popq %r15
retq
leaq (%rax,%rax), %rcx
movabsq $0x555555555555555, %rdx # imm = 0x555555555555555
cmpq %rdx, %rax
cmovbq %rcx, %rsi
movq %r15, %rdi
callq 0x6edc
jmp 0x6e24
pushq $0x8
popq %rdi
callq 0x3130
movq 0x6136(%rip), %rcx      # 0xcfa8
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x6140(%rip), %rsi      # 0xcfc0
movq 0x6111(%rip), %rdx      # 0xcf98
movq %rax, %rdi
callq 0x33f0
movq %rax, %rdi
callq 0x30d0
movq 0x18(%r15), %rsi
movq %r15, %rdi
callq 0x6edc
callq 0x33d0
jmp 0x6e24
movq %rax, %rdi
callq 0x30d0
decq 0x18(%r15)
callq 0x3380
movq %rax, %rbx
callq 0x33d0
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/svec.h
// Function: dasynq::svector<dasynq::dary_heap<dasynq::v2::dprivate::empty_node, dasynq::stable_prio<int>, dasynq::compare_stable_prio<int, std::less<int>>, 4>::heap_node>::reserve(unsigned long)
void reserve(size_t amount)
    {
        // Note that std::vector would throw length_error if amount > max_size(). We don't bother;
        // allocation will certainly fail in that case, so we'll throw bad_alloc instead.
        if (!ensure_capacity(amount, true)) {
            throw std::bad_alloc();
        }
    }

// Assembly:
pushq %rax
pushq $0x1
popq %rdx
callq 0x4c56
testb %al, %al
je 0x4f03
popq %rax
retq
pushq $0x8
popq %rdi
callq 0x3130
movq 0x8096(%rip), %rcx      # 0xcfa8
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x80a0(%rip), %rsi      # 0xcfc0
movq 0x8071(%rip), %rdx      # 0xcf98
movq %rax, %rdi
callq 0x33f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/davmac314[P]dinit/src/../dasynq/include/dasynq.h
// Function: dasynq::v2::dprivate::fd_watcher<dasynq::v2::event_loop<dasynq::null_mutex, dasynq::v2::default_traits<dasynq::null_mutex>>>::set_enabled(dasynq::v2::event_loop<dasynq::null_mutex, dasynq::v2::default_traits<dasynq::null_mutex>>&, bool)
void set_enabled(event_loop_t &eloop, bool enable) noexcept
    {
        std::lock_guard<mutex_t> guard(eloop.get_base_lock());
        if (this->emulatefd) {
            if (enable && ! this->emulate_enabled) {
                loop_access::requeue_watcher(eloop, this);
            }
            this->emulate_enabled = enable;
        }
        else {
            eloop.set_fd_enabled_nolock(this, this->watch_fd, this->watch_flags, enable);
        }

        if (! enable) {
            eloop.dequeue_watcher(this);
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movb 0xc(%rdi), %al
testb $0x4, %al
jne 0x4fcd
movl 0x1c(%rbx), %edx
movl 0x20(%rbx), %ecx
movzbl %bpl, %r8d
movq %r14, %rdi
movq %rbx, %rsi
callq 0x49f6
jmp 0x4ff4
testb %bpl, %bpl
je 0x4fe9
movb $0x8, %r15b
testb $0x8, %al
jne 0x4fec
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4b2e
movb 0xc(%rbx), %al
jmp 0x4fec
xorl %r15d, %r15d
andb $-0x9, %al
orb %r15b, %al
movb %al, 0xc(%rbx)
testb %bpl, %bpl
je 0x5004
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x51ea
nop
// File: /workspace/github_cpp_makefile_star2_O2/davmac314[P]dinit/src/includes/cpbuffer.h
// Function: cpbuffer<4096u>::append(char const*, unsigned int)
void append(const char * s, unsigned len) noexcept
    {
        unsigned index = cur_idx + length;
        if (index >= SIZE) index -= SIZE;

        length += len; // (before we destroy len)
        
        unsigned max = SIZE - index;
        std::memcpy(buf + index, s, std::min(max, len));
        if (len > max) {
            // Wrapped around buffer: copy the rest
            s += max;
            len -= max;
            std::memcpy(buf, s, len);
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movl 0x1000(%rdi), %eax
movl 0x1004(%rdi), %ecx
leal (%rcx,%rax), %edx
movl $0x1000, %ebp           # imm = 0x1000
cmpl %ebp, %edx
leal -0x1000(%rcx,%rax), %edi
cmovbl %edx, %edi
addl %ebx, %ecx
movl %ecx, 0x1004(%r15)
subl %edi, %ebp
addq %r15, %rdi
cmpl %ebx, %ebp
movl %ebx, %edx
cmovbl %ebp, %edx
callq 0x31e0
subl %ebp, %ebx
jbe 0x5084
movl %ebp, %eax
addq %rax, %r14
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x31e0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/davmac314[P]dinit/src/../dasynq/include/dasynq/daryheap.h
// Function: dasynq::dary_heap<dasynq::v2::dprivate::empty_node, dasynq::stable_prio<int>, dasynq::compare_stable_prio<int, std::less<int>>, 4>::remove_h(unsigned long)
void remove_h(hindex_t hidx) noexcept
    {
        hvec[hidx].hnd->heap_index = -1;
        if (hvec.size() != hidx + 1) {
            bubble_up(hidx, *(hvec.back().hnd), hvec.back().prio);
            hvec.pop_back();
        }
        else {
            hvec.pop_back();
        }
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rcx
imulq $0x18, %rsi, %rax
movq 0x10(%rcx,%rax), %rax
orq $-0x1, (%rax)
movq 0x8(%rdi), %rax
leaq 0x1(%rsi), %rdx
cmpq %rdx, %rax
je 0x5240
imulq $0x18, %rax, %rax
addq %rax, %rcx
addq $-0x18, %rcx
movq 0x10(%rcx), %rdx
movq %rbx, %rdi
callq 0x524a
movq 0x8(%rbx), %rax
decq %rax
movq %rax, 0x8(%rbx)
popq %rbx
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>>::deregister(dasynq::v2::dprivate::base_fd_watcher*, int)
void deregister(base_fd_watcher *callback, int fd) noexcept
    {
        if (callback->emulatefd) {
            auto & ed = (dispatch_t &) loop_mech;
            ed.issue_delete(callback);
            return;
        }
        
        loop_mech.remove_fd_watch(fd, callback->watch_flags);

        waitqueue_node<T_Mutex> qnode;
        get_attn_lock(qnode);
        
        auto & ed = (dispatch_t &) loop_mech;
        ed.issue_delete(callback);
        
        release_lock(qnode);        
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
testb $0x4, 0xc(%rsi)
jne 0x539d
movl 0x20(%r14), %eax
movq %rbx, %rdi
movl %edx, %esi
movl %eax, %edx
callq 0x4a7a
leaq 0xf(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x53f4
movq %rbx, %rdi
movq %r14, %rsi
callq 0x53b2
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5420
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rbx, %rdi
movq %r14, %rsi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x53b2
nop
// File: /workspace/github_cpp_makefile_star2_O2/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>>::issue_delete(dasynq::v2::dprivate::base_watcher*)
void issue_delete(base_watcher *watcher) noexcept
        {
            // This is only called when the attention lock is held, so if the watcher is not
            // active/queued now, it cannot become active (and will not be reported with an event)
            // during execution of this function.
            
            lock.lock();
            
            if (watcher->active) {
                // If the watcher is active, set deleteme true; the watcher will be removed
                // at the end of current processing (i.e. when active is set false).
                watcher->deleteme = true;
                lock.unlock();
            }
            else {
                // Actually do the delete.
                dequeue_watcher(watcher);
                release_watcher(watcher);
                
                lock.unlock();
                watcher->watch_removed();
            }
        }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movb 0xc(%rsi), %al
testb $0x1, %al
jne 0x53e7
movq %rdi, %r14
movq %rbx, %rsi
callq 0x51ea
leaq 0x10(%rbx), %rsi
movq %r14, %rdi
callq 0x4a8c
movq (%rbx), %rax
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *0x20(%rax)
orb $0x2, %al
movb %al, 0xc(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
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>>::~epoll_loop()
~epoll_loop() noexcept
    {
        if (epfd != -1) {
            Base::cleanup();
            close(epfd);
            if (sigfd != -1) {
                close(sigfd);
            }
        }
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpl $-0x1, 0xa0(%rdi)
je 0x54ea
movq %rbx, %rdi
callq 0x5508
movl 0xa0(%rbx), %edi
callq 0x3430
movl 0xa4(%rbx), %edi
cmpl $-0x1, %edi
je 0x54ea
callq 0x3430
leaq 0x128(%rbx), %rdi
callq 0x554c
movq %rbx, %rdi
popq %rbx
jmp 0x552c
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>::~btree_set()
~btree_set()
    {
        while (left_sept != nullptr) {
            remove(*(left_sept->hn_p[0]));
        }

        while (sn_reserve != nullptr) {
            auto *next = sn_reserve->parent;
            delete sn_reserve;
            sn_reserve = next;
        }
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x5636
movq 0x20(%rax), %rsi
movq %rbx, %rdi
callq 0x5662
jmp 0x561f
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x5659
movq 0xa8(%rdi), %r14
movl $0xb0, %esi
callq 0x3290
movq %r14, 0x10(%rbx)
movq %r14, %rdi
jmp 0x563a
addq $0x8, %rsp
popq %rbx
popq %r14
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::shift_elems_left(int, int, int)
void shift_elems_left(int pos, int newpos, int num)
        {
            int diff = pos - newpos;
            int end = pos + num;

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

// Assembly:
pushq %rbx
addl %esi, %ecx
movslq %esi, %r8
subl %edx, %esi
movslq %ecx, %rax
leaq (%rdi,%r8,4), %rcx
leaq (%rdi,%r8,8), %r9
addq $0x60, %r9
movslq %edx, %r10
leaq (%rdi,%r10,4), %rdx
leaq (%rdi,%r10,8), %r10
addq $0x60, %r10
xorl %r11d, %r11d
leaq (%r8,%r11), %rbx
cmpq %rax, %rbx
jge 0x5a8f
movl (%rcx,%r11,4), %ebx
movl %ebx, (%rdx,%r11,4)
movq -0x40(%r9,%r11,8), %rbx
movq %rbx, -0x40(%r10,%r11,8)
movq (%r9,%r11,8), %rbx
movq %rbx, (%r10,%r11,8)
incq %r11
jmp 0x5a67
movq 0x60(%rdi,%rax,8), %rcx
subl %esi, %eax
cltq
movq %rcx, 0x60(%rdi,%rax,8)
popq %rbx
retq
nop