LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/aremmell[P]libsir/tests/tests.c
// Function: threadpool_pseudojob
static bool threadpool_pseudojob(void* arg) {
    char thread_name[SIR_MAXPID] = {0};

    _sir_snprintf_trunc(thread_name, SIR_MAXPID, "pool.%p", arg);
    (void)_sir_setthreadname(thread_name);

    (void)sir_debug("start of pseudo job that does nothing (arg: %p)", arg);
    sir_sleep_msec(1000);
    (void)sir_debug("end of pseudo job that does nothing (arg: %p)", arg);

    return true;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x4210
movq $0x10, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x20(%rsp), %rcx
leaq 0x12268(%rip), %rdx     # 0x20f31
movb $0x0, %al
callq 0x41b0
cmpl $0x0, %eax
jne 0xecda
movq 0x8(%rsp), %rax
jmp 0xecdc
leaq 0x10(%rsp), %rdi
callq 0x19320
movq 0x20(%rsp), %rsi
leaq 0x12247(%rip), %rdi     # 0x20f39
movb $0x0, %al
callq 0xf5f0
movl $0x3e8, %edi            # imm = 0x3E8
callq 0x53e0
movq 0x20(%rsp), %rsi
leaq 0x1225a(%rip), %rdi     # 0x20f69
movb $0x0, %al
callq 0xf5f0
movb $0x1, %al
andb $0x1, %al
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/aremmell[P]libsir/src/sirthreadpool.c
// Function: sir_threadpool_add_job
bool _sir_threadpool_add_job(sir_threadpool* pool, sir_threadpool_job* job) {
    bool retval = false;

    if (pool && pool->jobs && job && job->fn && job->data) {
        bool locked = _sir_mutexlock(&pool->mutex);
        SIR_ASSERT(locked);

        if (locked) {
            if (_sir_queue_push(pool->jobs, job)) {
                retval = _sir_condbroadcast(&pool->cond);
                _sir_selflog("added job; new size: %zu", _sir_queue_size(pool->jobs));
            }

            bool unlocked = _sir_mutexunlock(&pool->mutex);
            SIR_ASSERT_UNUSED(unlocked, unlocked);
        }
    }

    return retval;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movb $0x0, 0x7(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x1c413
movq 0x10(%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0x1c413
cmpq $0x0, 0x8(%rsp)
je 0x1c413
movq 0x8(%rsp), %rax
cmpq $0x0, (%rax)
je 0x1c413
movq 0x8(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x1c413
movq 0x10(%rsp), %rdi
addq $0x48, %rdi
callq 0x196b0
andb $0x1, %al
movb %al, 0x6(%rsp)
testb $0x1, 0x6(%rsp)
je 0x1c411
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x8(%rsp), %rsi
callq 0x1cca0
testb $0x1, %al
jne 0x1c3ca
jmp 0x1c3fd
movq 0x10(%rsp), %rdi
addq $0x18, %rdi
callq 0x1c540
andb $0x1, %al
movb %al, 0x7(%rsp)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x1cbf0
movq %rax, %rsi
leaq 0x6a0a(%rip), %rdi      # 0x22e00
movb $0x0, %al
callq 0x1c420
movq 0x10(%rsp), %rdi
addq $0x48, %rdi
callq 0x197f0
andb $0x1, %al
movb %al, 0x5(%rsp)
jmp 0x1c413
movb 0x7(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/aremmell[P]libsir/src/sircondition.c
// Function: sir_condcreate
bool _sir_condcreate(sir_condition* cond) {
    bool valid = _sir_validptr(cond);

    if (valid) {
#if !defined(__WIN__)
        int op = pthread_cond_init(cond, NULL);
        valid = 0 == op ? true : _sir_handleerr(op);
#else
        InitializeConditionVariable(cond);
#endif
    }

    return valid;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x1, %esi
leaq 0x6a6a(%rip), %rdx      # 0x22eb4
leaq 0x6a73(%rip), %rcx      # 0x22ec4
movl $0x25, %r8d
callq 0x1c4d0
andb $0x1, %al
movb %al, 0xf(%rsp)
testb $0x1, 0xf(%rsp)
je 0x1c4c3
movq 0x10(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4390
movl %eax, 0x8(%rsp)
xorl %eax, %eax
cmpl 0x8(%rsp), %eax
jne 0x1c48e
movl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x1c4b3
movl 0x8(%rsp), %edi
leaq 0x6a1b(%rip), %rsi      # 0x22eb4
leaq 0x6a24(%rip), %rdx      # 0x22ec4
movl $0x2a, %ecx
callq 0x10780
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/aremmell[P]libsir/src/sircondition.c
// Function: sir_condbroadcast
bool _sir_condbroadcast(sir_condition* cond) {
    bool valid = _sir_validptr(cond);

    if (valid) {
#if !defined(__WIN__)
        int op = pthread_cond_broadcast(cond);
        valid = 0 == op ? true : _sir_handleerr(op);
#else
        WakeAllConditionVariable(cond);
#endif
    }

    return valid;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x1, %esi
leaq 0x6979(%rip), %rdx      # 0x22ed3
leaq 0x6963(%rip), %rcx      # 0x22ec4
movl $0x45, %r8d
callq 0x1c4d0
andb $0x1, %al
movb %al, 0xf(%rsp)
testb $0x1, 0xf(%rsp)
je 0x1c5cf
movq 0x10(%rsp), %rdi
callq 0x40b0
movl %eax, 0x8(%rsp)
xorl %eax, %eax
cmpl 0x8(%rsp), %eax
jne 0x1c59a
movl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x1c5bf
movl 0x8(%rsp), %edi
leaq 0x692e(%rip), %rsi      # 0x22ed3
leaq 0x6918(%rip), %rdx      # 0x22ec4
movl $0x4a, %ecx
callq 0x10780
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aremmell[P]libsir/src/sircondition.c
// Function: sir_conddestroy
bool _sir_conddestroy(sir_condition* cond) {
    bool valid = _sir_validptr(cond);

    if (valid) {
#if !defined(__WIN__)
        int op = pthread_cond_destroy(cond);
        valid = 0 == op ? true : _sir_handleerr(op);
#else
        SIR_UNUSED(cond);
#endif
    }

    return valid;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x1, %esi
leaq 0x68ec(%rip), %rdx      # 0x22ee6
leaq 0x68c3(%rip), %rcx      # 0x22ec4
movl $0x54, %r8d
callq 0x1c4d0
andb $0x1, %al
movb %al, 0xf(%rsp)
testb $0x1, 0xf(%rsp)
je 0x1c66f
movq 0x10(%rsp), %rdi
callq 0x4490
movl %eax, 0x8(%rsp)
xorl %eax, %eax
cmpl 0x8(%rsp), %eax
jne 0x1c63a
movl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x1c65f
movl 0x8(%rsp), %edi
leaq 0x68a1(%rip), %rsi      # 0x22ee6
leaq 0x6878(%rip), %rdx      # 0x22ec4
movl $0x59, %ecx
callq 0x10780
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aremmell[P]libsir/src/sircondition.c
// Function: sir_condwait_timeout
bool _sir_condwait_timeout(sir_condition* cond, sir_mutex* mutex,
    const sir_wait* howlong) {
    bool valid = _sir_validptr(cond) && _sir_validptr(mutex) && _sir_validptr(howlong);

    if (valid) {
#if !defined(__WIN__)
        int op = pthread_cond_timedwait(cond, mutex, howlong);
        valid = 0 == op ? true : ETIMEDOUT == op ? false : _sir_handleerr(op);
#else
        valid = (FALSE != SleepConditionVariableCS(cond, mutex, *howlong))
            ? true : _sir_handlewin32err(GetLastError());
#endif
    }

    return valid;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rdi
movl $0x1, %esi
leaq 0x6853(%rip), %rdx      # 0x22ef7
leaq 0x6819(%rip), %rcx      # 0x22ec4
movl $0x76, %r8d
callq 0x1c4d0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0x17(%rsp)
jne 0x1c6c5
jmp 0x1c71e
movq 0x28(%rsp), %rdi
movl $0x1, %esi
leaq 0x6821(%rip), %rdx      # 0x22ef7
leaq 0x67e7(%rip), %rcx      # 0x22ec4
movl $0x76, %r8d
callq 0x1c4d0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0x17(%rsp)
jne 0x1c6f7
jmp 0x1c71e
movq 0x20(%rsp), %rdi
movl $0x1, %esi
leaq 0x67ef(%rip), %rdx      # 0x22ef7
leaq 0x67b5(%rip), %rcx      # 0x22ec4
movl $0x76, %r8d
callq 0x1c4d0
movb %al, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
movb %al, 0x1f(%rsp)
testb $0x1, 0x1f(%rsp)
je 0x1c7aa
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0x4460
movl %eax, 0x18(%rsp)
xorl %eax, %eax
cmpl 0x18(%rsp), %eax
jne 0x1c75a
movl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x1c79a
movl $0x6e, %eax
cmpl 0x18(%rsp), %eax
jne 0x1c76d
xorl %eax, %eax
movl %eax, 0xc(%rsp)
jmp 0x1c792
movl 0x18(%rsp), %edi
leaq 0x677f(%rip), %rsi      # 0x22ef7
leaq 0x6745(%rip), %rdx      # 0x22ec4
movl $0x7b, %ecx
callq 0x10780
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
movl %eax, 0x10(%rsp)
movl 0x10(%rsp), %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, 0x1f(%rsp)
movb 0x1f(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/aremmell[P]libsir/src/sirqueue.c
// Function: sir_queue_node_create
sir_queue_node* _sir_queue_node_create(void* data) {
    sir_queue_node* retval = calloc(1, sizeof(sir_queue_node));
    if (!retval)
        (void)_sir_handleerr(errno);
    else
        retval->data = data;

    return retval;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x1, %edi
movl $0x10, %esi
callq 0x42d0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x1c876
callq 0x4070
movl (%rax), %edi
leaq 0x66c8(%rip), %rsi      # 0x22f2b
leaq 0x66d8(%rip), %rdx      # 0x22f42
movl $0x27, %ecx
callq 0x10780
jmp 0x1c884
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/aremmell[P]libsir/src/sirqueue.c
// Function: sir_queue_node_destroy
bool _sir_queue_node_destroy(sir_queue_node** node, void** data) {
    bool valid = _sir_validptrptr(node) && _sir_validptr(*node);

    if (valid) {
        if (data)
            *data = (*node)->data;

        _sir_safefree(node);
    }

    return valid;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movl $0x1, %esi
leaq 0x669e(%rip), %rdx      # 0x22f4d
leaq 0x668c(%rip), %rcx      # 0x22f42
movl $0x2f, %r8d
callq 0x1c940
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0x6(%rsp)
jne 0x1c8d0
jmp 0x1c8fa
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movl $0x1, %esi
leaq 0x6669(%rip), %rdx      # 0x22f4d
leaq 0x6657(%rip), %rcx      # 0x22f42
movl $0x2f, %r8d
callq 0x1c9b0
movb %al, 0x6(%rsp)
movb 0x6(%rsp), %al
andb $0x1, %al
movb %al, 0x7(%rsp)
testb $0x1, 0x7(%rsp)
je 0x1c931
cmpq $0x0, 0x8(%rsp)
je 0x1c927
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rdi
callq 0x14490
movb 0x7(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/aremmell[P]libsir/src/sirqueue.c
// Function: sir_queue_create
bool _sir_queue_create(sir_queue** q) {
    bool valid = _sir_validptrptr(q);

    if (valid) {
        *q = calloc(1, sizeof(sir_queue));
        if (!_sir_validptrnofail(*q))
            (void)_sir_handleerr(errno);
    }

    return valid && _sir_validptrnofail(*q);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x1, %esi
leaq 0x652b(%rip), %rdx      # 0x22f65
leaq 0x6501(%rip), %rcx      # 0x22f42
movl $0x3c, %r8d
callq 0x1c940
andb $0x1, %al
movb %al, 0xf(%rsp)
testb $0x1, 0xf(%rsp)
je 0x1cabb
movl $0x1, %edi
movl $0x8, %esi
callq 0x42d0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
xorl %esi, %esi
leaq 0x64e1(%rip), %rdx      # 0x22f65
leaq 0x64b7(%rip), %rcx      # 0x22f42
movl $0x40, %r8d
callq 0x1c9b0
testb $0x1, %al
jne 0x1cab9
callq 0x4070
movl (%rax), %edi
leaq 0x64bd(%rip), %rsi      # 0x22f65
leaq 0x6493(%rip), %rdx      # 0x22f42
movl $0x41, %ecx
callq 0x10780
jmp 0x1cabb
xorl %eax, %eax
testb $0x1, 0xf(%rsp)
movb %al, 0xe(%rsp)
je 0x1caef
movq 0x10(%rsp), %rax
movq (%rax), %rdi
xorl %esi, %esi
leaq 0x648c(%rip), %rdx      # 0x22f65
leaq 0x6462(%rip), %rcx      # 0x22f42
movl $0x44, %r8d
callq 0x1c9b0
movb %al, 0xe(%rsp)
movb 0xe(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aremmell[P]libsir/src/sirqueue.c
// Function: sir_queue_destroy
bool _sir_queue_destroy(sir_queue** q) {
    bool valid = _sir_validptrptr(q) && _sir_validptr(*q);

    if (valid) {
        sir_queue_node* next = (*q)->head;
        while (next) {
            sir_queue_node* this_node = next;
            void* data                = NULL;
            next                      = this_node->next;

            if (_sir_queue_node_destroy(&this_node, &data))
                _sir_safefree(&data);
        }

        _sir_safefree(q);
    }

    return valid;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movl $0x1, %esi
leaq 0x645d(%rip), %rdx      # 0x22f77
leaq 0x6421(%rip), %rcx      # 0x22f42
movl $0x48, %r8d
callq 0x1c940
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0xf(%rsp)
jne 0x1cb3b
jmp 0x1cb65
movq 0x30(%rsp), %rax
movq (%rax), %rdi
movl $0x1, %esi
leaq 0x6428(%rip), %rdx      # 0x22f77
leaq 0x63ec(%rip), %rcx      # 0x22f42
movl $0x48, %r8d
callq 0x1c9b0
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
andb $0x1, %al
movb %al, 0x2f(%rsp)
testb $0x1, 0x2f(%rsp)
je 0x1cbd9
movq 0x30(%rsp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x1cbcf
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x20(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1c890
testb $0x1, %al
jne 0x1cbc3
jmp 0x1cbcd
leaq 0x10(%rsp), %rdi
callq 0x14490
jmp 0x1cb86
movq 0x30(%rsp), %rdi
callq 0x14490
movb 0x2f(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aremmell[P]libsir/src/sirqueue.c
// Function: sir_queue_size
size_t _sir_queue_size(sir_queue* q) {
    if (_sir_queue_isempty(q))
        return 0;

    sir_queue_node* next = q->head->next;
    size_t idx           = 1;
    while (next) {
        idx++;
        next = next->next;
    }

    return idx;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x1cc70
testb $0x1, %al
jne 0x1cc09
jmp 0x1cc14
movq $0x0, 0x20(%rsp)
jmp 0x1cc5c
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq $0x1, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x1cc52
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x1cc2d
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aremmell[P]libsir/src/sirqueue.c
// Function: sir_queue_push
bool _sir_queue_push(sir_queue* q, void* data) {
    bool retval = false;

    if (_sir_validptr(q)) {
        if (!q->head) {
            q->head = _sir_queue_node_create(data);
            retval = NULL != q->head;
        } else {
            sir_queue_node* next = q->head;
            while (next) {
                if (!next->next) {
                    next->next = _sir_queue_node_create(data);
                    if (next->next) {
                        retval = true;
                        break;
                    }
                }
                next = next->next;
            }
        }
    }

    return retval;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movb $0x0, 0x17(%rsp)
movq 0x20(%rsp), %rdi
movl $0x1, %esi
leaq 0x62c6(%rip), %rdx      # 0x22f8a
leaq 0x6277(%rip), %rcx      # 0x22f42
movl $0x70, %r8d
callq 0x1c9b0
testb $0x1, %al
jne 0x1ccdf
jmp 0x1cd70
movq 0x20(%rsp), %rax
cmpq $0x0, (%rax)
jne 0x1cd14
movq 0x18(%rsp), %rdi
callq 0x1c830
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, (%rax)
movq 0x20(%rsp), %rcx
xorl %eax, %eax
cmpq (%rcx), %rax
setne %al
andb $0x1, %al
movb %al, 0x17(%rsp)
jmp 0x1cd6e
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x1cd6c
movq 0x8(%rsp), %rax
cmpq $0x0, (%rax)
jne 0x1cd5d
movq 0x18(%rsp), %rdi
callq 0x1c830
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
cmpq $0x0, (%rax)
je 0x1cd5b
movb $0x1, 0x17(%rsp)
jmp 0x1cd6c
jmp 0x1cd5d
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x1cd21
jmp 0x1cd6e
jmp 0x1cd70
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aremmell[P]libsir/src/sirqueue.c
// Function: sir_queue_pop
bool _sir_queue_pop(sir_queue* q, void** data) {
    bool retval = false;

    if (!_sir_queue_isempty(q) && _sir_validptrptr(data)) {
        sir_queue_node* old_head = q->head;
        q->head                  = old_head->next;

        retval = _sir_queue_node_destroy(&old_head, data);
    }

    return retval;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movb $0x0, 0x17(%rsp)
movq 0x20(%rsp), %rdi
callq 0x1cc70
testb $0x1, %al
jne 0x1cdfc
movq 0x18(%rsp), %rdi
movl $0x1, %esi
leaq 0x61e8(%rip), %rdx      # 0x22f9a
leaq 0x6189(%rip), %rcx      # 0x22f42
movl $0x89, %r8d
callq 0x1c940
testb $0x1, %al
jne 0x1cdca
jmp 0x1cdfc
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rcx
movq 0x20(%rsp), %rax
movq %rcx, (%rax)
movq 0x18(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x1c890
andb $0x1, %al
movb %al, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/giometti[P]mastering_UNIX_programming/chapter_09/scdu.c
// Function: crypt_std
void crypt_std(char *text, size_t n)
{
	int i, c;
	char base;

	for (i = 0; i < n; i++) {
		if ((text[i] >= 'a') && (text[i] <= 'z'))
			base = 'a';
		else if ((text[i] >= 'A') && (text[i] <= 'Z'))
			base = 'A';
		else
			continue;
		
		c = text[i] - base;
		c = (c + 1) % 26;
		text[i] = c + base;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x126f
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x61, %eax
jl 0x11f9
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x7a, %eax
jg 0x11f9
movb $0x61, -0x19(%rbp)
jmp 0x1225
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x41, %eax
jl 0x1221
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x5a, %eax
jg 0x1221
movb $0x41, -0x19(%rbp)
jmp 0x1223
jmp 0x1261
jmp 0x1225
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movsbl -0x19(%rbp), %ecx
subl %ecx, %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl $0x1a, %ecx
cltd
idivl %ecx
movl %edx, -0x18(%rbp)
movl -0x18(%rbp), %eax
movsbl -0x19(%rbp), %ecx
addl %ecx, %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x11c3
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/giometti[P]mastering_UNIX_programming/chapter_09/scdu.c
// Function: load_funcs
void load_funcs(char *module, func_t *crypt, func_t *decrypt)
{
	void *handler;

	if (module == NULL) {
		/* Use standard functions */
		*crypt = crypt_std;
		*decrypt = decrypt_std;

		return;
	}

	/* Try to load external functions */
	handler = dlopen(module, RTLD_NOW | RTLD_GLOBAL);
	if (!handler) {
		fprintf(stderr,
			"cannot load module %s\n", module);
		exit(EXIT_FAILURE);
	}

	*crypt = (func_t) dlsym(handler, "mod_crypt");
	if (!*crypt) {
		fprintf(stderr,
			"cannot find crypt() function: %s\n", dlerror());
		exit(EXIT_FAILURE);
	}

	*decrypt = (func_t) dlsym(handler, "mod_decrypt");
	if (!*crypt) {
		fprintf(stderr,
			"cannot find decrypt() function: %s\n", dlerror());
		exit(EXIT_FAILURE);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x138c
movq -0x10(%rbp), %rax
leaq -0x1c6(%rip), %rcx      # 0x11b0
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
leaq -0x104(%rip), %rcx      # 0x1280
movq %rcx, (%rax)
jmp 0x1477
movq -0x8(%rbp), %rdi
movl $0x102, %esi            # imm = 0x102
callq 0x1060
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x13cb
movq 0x2c4c(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0xd06(%rip), %rsi       # 0x20c0
movb $0x0, %al
callq 0x1070
movl $0x1, %edi
callq 0x10a0
movq -0x20(%rbp), %rdi
leaq 0xd01(%rip), %rsi       # 0x20d7
callq 0x1090
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x1421
movq 0x2c02(%rip), %rax      # 0x3ff8
movq (%rax), %rax
movq %rax, -0x28(%rbp)
callq 0x1030
movq -0x28(%rbp), %rdi
movq %rax, %rdx
leaq 0xcd1(%rip), %rsi       # 0x20e1
movb $0x0, %al
callq 0x1070
movl $0x1, %edi
callq 0x10a0
movq -0x20(%rbp), %rdi
leaq 0xcd7(%rip), %rsi       # 0x2103
callq 0x1090
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x1477
movq 0x2bac(%rip), %rax      # 0x3ff8
movq (%rax), %rax
movq %rax, -0x30(%rbp)
callq 0x1030
movq -0x30(%rbp), %rdi
movq %rax, %rdx
leaq 0xca9(%rip), %rsi       # 0x210f
movb $0x0, %al
callq 0x1070
movl $0x1, %edi
callq 0x10a0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mikeakohn[P]print_pe/build/../src/minidump.c
// Function: read_minidump_header
int read_minidump_header(struct minidump_header_t *minidump_header, FILE *in)
{
  read_chars(in, minidump_header->magic1, 4);
  read_chars_bin(in, minidump_header->magic2, 2);
  minidump_header->version = read_uint16(in);
  minidump_header->num_streams = read_uint32(in);
  minidump_header->ofs_streams = read_uint32(in);
  minidump_header->checksum = read_uint32(in);
  minidump_header->timestamp = read_uint32(in);
  minidump_header->flags = read_uint64(in);

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl $0x4, %edx
callq 0x1ad0
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x4, %rsi
movl $0x2, %edx
callq 0x1b30
movq -0x10(%rbp), %rdi
callq 0x1a60
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, 0x6(%rax)
movq -0x10(%rbp), %rdi
callq 0x1a00
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rdi
callq 0x1a00
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x10(%rbp), %rdi
callq 0x1a00
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rdi
callq 0x1a00
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x10(%rbp), %rdi
callq 0x1930
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mikeakohn[P]print_pe/build/../src/minidump.c
// Function: read_minidump_dir
int read_minidump_dir(struct minidump_dir_t *minidump_dir, FILE *in)
{
  minidump_dir->stream_type = read_uint32(in);
  minidump_dir->len_data = read_uint32(in);
  minidump_dir->ofs_data = read_uint32(in);

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1a00
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x1a00
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rdi
callq 0x1a00
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x8(%rax)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mikeakohn[P]print_pe/build/../src/minidump.c
// Function: print_minidump_header
void print_minidump_header(struct minidump_header_t *minidump_header)
{
  printf(" -------- MiniDump header -------\n");
  printf("     magic1: %.4s\n", minidump_header->magic1);
  printf("     magic2: 0x%02x 0x%02x\n", minidump_header->magic2[0],
                                         minidump_header->magic2[1]);
  printf("    version: %d\n", minidump_header->version);
  printf("num_streams: %d\n", minidump_header->num_streams);
  printf("ofs_streams: %d\n", minidump_header->ofs_streams);
  printf("   checksum: %d\n", minidump_header->checksum);
  printf("  timestamp: %d\n", minidump_header->timestamp);
  printf("      flags: 0x%lx\n", minidump_header->flags);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x23ec(%rip), %rdi      # 0x42ff
movb $0x0, %al
callq 0x1050
movq -0x8(%rbp), %rsi
leaq 0x23fd(%rip), %rdi      # 0x4322
movb $0x0, %al
callq 0x1050
movq -0x8(%rbp), %rax
movzbl 0x4(%rax), %esi
movq -0x8(%rbp), %rax
movzbl 0x5(%rax), %edx
leaq 0x23f2(%rip), %rdi      # 0x4335
movb $0x0, %al
callq 0x1050
movq -0x8(%rbp), %rax
movzwl 0x6(%rax), %esi
leaq 0x23f8(%rip), %rdi      # 0x4351
movb $0x0, %al
callq 0x1050
movq -0x8(%rbp), %rax
movl 0x8(%rax), %esi
leaq 0x23f4(%rip), %rdi      # 0x4362
movb $0x0, %al
callq 0x1050
movq -0x8(%rbp), %rax
movl 0xc(%rax), %esi
leaq 0x23f0(%rip), %rdi      # 0x4373
movb $0x0, %al
callq 0x1050
movq -0x8(%rbp), %rax
movl 0x10(%rax), %esi
leaq 0x23ec(%rip), %rdi      # 0x4384
movb $0x0, %al
callq 0x1050
movq -0x8(%rbp), %rax
movl 0x14(%rax), %esi
leaq 0x23e8(%rip), %rdi      # 0x4395
movb $0x0, %al
callq 0x1050
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rsi
leaq 0x23e3(%rip), %rdi      # 0x43a6
movb $0x0, %al
callq 0x1050
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mikeakohn[P]print_pe/build/../src/minidump.c
// Function: print_minidump_dir
void print_minidump_dir(struct minidump_dir_t *minidump_dir, int index)
{
  printf(" -------- MiniDump dir %d -------\n", index);
  printf("stream_type: %d (%s)\n",
    minidump_dir->stream_type,
    get_minidump_stream_type(minidump_dir->stream_type));
  printf("   len_data: %u\n", minidump_dir->len_data);
  printf("   ofs_data: %u\n", minidump_dir->ofs_data);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %esi
leaq 0x23d1(%rip), %rdi      # 0x43ba
movb $0x0, %al
callq 0x1050
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %edi
callq 0x3ce0
movl -0x10(%rbp), %esi
movq %rax, %rdx
leaq 0x23cc(%rip), %rdi      # 0x43dd
movb $0x0, %al
callq 0x1050
movq -0x8(%rbp), %rax
movl 0x4(%rax), %esi
leaq 0x23cd(%rip), %rdi      # 0x43f3
movb $0x0, %al
callq 0x1050
movq -0x8(%rbp), %rax
movl 0x8(%rax), %esi
leaq 0x23c9(%rip), %rdi      # 0x4404
movb $0x0, %al
callq 0x1050
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mikeakohn[P]print_pe/build/../src/minidump.c
// Function: print_minidump_thread_list
void print_minidump_thread_list(FILE *in, uint32_t cpu_arch)
{
  uint32_t n;
  uint32_t num_threads = read_uint32(in);

  printf("  - num_threads: %d\n", num_threads);

  for (n = 0; n < num_threads; n++)
  {
    printf("  -- Thread %d --\n", n);

    printf("        thread_id: %u\n", read_uint32(in));
    printf("    suspend_count: %u\n", read_uint32(in));
    printf("   priority_class: %u\n", read_uint32(in));
    printf("         priority: %u\n", read_uint32(in));
    printf("              teb: %" PRIx64 "\n", read_uint64(in));
    printf("            stack:\n");
    print_minidump_memory_descriptor(in);
    printf("   thread_context:\n");
    print_minidump_thread(in, cpu_arch);
  }

  printf("\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1a00
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %esi
leaq 0x23a0(%rip), %rdi      # 0x4415
movb $0x0, %al
callq 0x1050
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x215d
movl -0x10(%rbp), %esi
leaq 0x2391(%rip), %rdi      # 0x442a
movb $0x0, %al
callq 0x1050
movq -0x8(%rbp), %rdi
callq 0x1a00
movl %eax, %esi
leaq 0x238b(%rip), %rdi      # 0x443d
movb $0x0, %al
callq 0x1050
movq -0x8(%rbp), %rdi
callq 0x1a00
movl %eax, %esi
leaq 0x2389(%rip), %rdi      # 0x4454
movb $0x0, %al
callq 0x1050
movq -0x8(%rbp), %rdi
callq 0x1a00
movl %eax, %esi
leaq 0x2387(%rip), %rdi      # 0x446b
movb $0x0, %al
callq 0x1050
movq -0x8(%rbp), %rdi
callq 0x1a00
movl %eax, %esi
leaq 0x2385(%rip), %rdi      # 0x4482
movb $0x0, %al
callq 0x1050
movq -0x8(%rbp), %rdi
callq 0x1930
movq %rax, %rsi
leaq 0x2382(%rip), %rdi      # 0x4499
movb $0x0, %al
callq 0x1050
leaq 0x238c(%rip), %rdi      # 0x44b1
movb $0x0, %al
callq 0x1050
movq -0x8(%rbp), %rdi
callq 0x2180
leaq 0x2389(%rip), %rdi      # 0x44c5
movb $0x0, %al
callq 0x1050
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x21e0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x2083
leaq 0x1f97(%rip), %rdi      # 0x40fb
movb $0x0, %al
callq 0x1050
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mikeakohn[P]print_pe/build/../src/minidump.c
// Function: print_minidump_memory_descriptor
static void print_minidump_memory_descriptor(FILE *in)
{
  struct minidump_location_desc_t minidump_location_desc;

  printf("    start_of_memory_range: 0x%" PRIx64 "\n", read_uint64(in));
  printf("                   memory:\n");

  read_minidump_location_desc(&minidump_location_desc, in);

  printf("              [ len_data: %u, ofs_data: %u ]\n",
     minidump_location_desc.len_data,
     minidump_location_desc.ofs_data);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1930
movq %rax, %rsi
leaq 0x2485(%rip), %rdi      # 0x4624
movb $0x0, %al
callq 0x1050
leaq 0x2b90(%rip), %rdi      # 0x4d3d
movb $0x0, %al
callq 0x1050
movq -0x8(%rbp), %rsi
leaq -0x10(%rbp), %rdi
callq 0x1ec0
movl -0x10(%rbp), %esi
movl -0xc(%rbp), %edx
leaq 0x23c3(%rip), %rdi      # 0x4591
movb $0x0, %al
callq 0x1050
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mikeakohn[P]print_pe/build/../src/minidump.c
// Function: print_minidump_thread
static void print_minidump_thread(FILE *in, uint32_t cpu_arch)
{
  struct minidump_location_desc_t minidump_location_desc;

  read_minidump_location_desc(&minidump_location_desc, in);

  printf("              [ len_data: %u, ofs_data: %u ]\n",
     minidump_location_desc.len_data,
     minidump_location_desc.ofs_data);

  long marker = ftell(in);
  fseek(in, minidump_location_desc.ofs_data, SEEK_SET);

  if (cpu_arch == 0)
  {
    print_minidump_thread_context_x86(in);
  }
    else
  {
    print_minidump_thread_context_x86_64(in);
  }

  fseek(in, marker, SEEK_SET);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x14(%rbp), %rdi
callq 0x1ec0
movl -0x14(%rbp), %esi
movl -0x10(%rbp), %edx
leaq 0x2388(%rip), %rdi      # 0x4591
movb $0x0, %al
callq 0x1050
movq -0x8(%rbp), %rdi
callq 0x1090
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x10b0
cmpl $0x0, -0xc(%rbp)
jne 0x223e
movq -0x8(%rbp), %rdi
callq 0x30e0
jmp 0x2247
movq -0x8(%rbp), %rdi
callq 0x3630
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
xorl %edx, %edx
callq 0x10b0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mikeakohn[P]print_pe/build/../src/minidump.c
// Function: print_minidump_string
static void print_minidump_string(FILE *in, uint32_t offset)
{
  uint32_t n;

  if (offset == 0)
  {
    printf("length=0\n");
    return;
  }

  long marker = ftell(in);
  fseek(in, offset, SEEK_SET);

  uint32_t length = read_uint32(in);

  printf(",length=%d\n", length);

  for (n = 0; n < length; n += 2)
  {
    uint16_t c = read_uint16(in);

    putchar(c);
  }

  fseek(in, marker, SEEK_SET);

  printf("\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x2418
leaq 0x30e8(%rip), %rdi      # 0x54f4
movb $0x0, %al
callq 0x1050
jmp 0x249f
movq -0x8(%rbp), %rdi
callq 0x1090
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x10b0
movq -0x8(%rbp), %rdi
callq 0x1a00
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %esi
leaq 0x30b3(%rip), %rdi      # 0x54fe
movb $0x0, %al
callq 0x1050
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jae 0x2482
movq -0x8(%rbp), %rdi
callq 0x1a60
movw %ax, -0x1e(%rbp)
movzwl -0x1e(%rbp), %edi
callq 0x1030
movl -0x10(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x10(%rbp)
jmp 0x2459
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %edx, %edx
callq 0x10b0
leaq 0x1c63(%rip), %rdi      # 0x40fb
movb $0x0, %al
callq 0x1050
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mikeakohn[P]print_pe/build/../src/minidump.c
// Function: print_minidump_vs_fixed_file_info
static void print_minidump_vs_fixed_file_info(FILE *in)
{
    printf("           Signature: 0x%x\n", read_uint32(in));
    printf("       StructVersion: %u\n", read_uint32(in));
    printf("       FileVersionMS: %u\n", read_uint32(in));
    printf("       FileVersionLS: %u\n", read_uint32(in));
    printf("    ProductVersionMS: %u\n", read_uint32(in));
    printf("    ProductVersionLS: %u\n", read_uint32(in));
    printf("       FileFlagsMask: %u\n", read_uint32(in));
    printf("           FileFlags: %u\n", read_uint32(in));
    printf("              FileOS: %u\n", read_uint32(in));
    printf("            FileType: %u\n", read_uint32(in));
    printf("         FileSubtype: %u\n", read_uint32(in));
    printf("          FileDateMS: %u\n", read_uint32(in));
    printf("          FileDateLS: %u\n", read_uint32(in));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1a00
movl %eax, %esi
leaq 0x303c(%rip), %rdi      # 0x550a
movb $0x0, %al
callq 0x1050
movq -0x8(%rbp), %rdi
callq 0x1a00
movl %eax, %esi
leaq 0x303f(%rip), %rdi      # 0x5526
movb $0x0, %al
callq 0x1050
movq -0x8(%rbp), %rdi
callq 0x1a00
movl %eax, %esi
leaq 0x3040(%rip), %rdi      # 0x5540
movb $0x0, %al
callq 0x1050
movq -0x8(%rbp), %rdi
callq 0x1a00
movl %eax, %esi
leaq 0x3041(%rip), %rdi      # 0x555a
movb $0x0, %al
callq 0x1050
movq -0x8(%rbp), %rdi
callq 0x1a00
movl %eax, %esi
leaq 0x3042(%rip), %rdi      # 0x5574
movb $0x0, %al
callq 0x1050
movq -0x8(%rbp), %rdi
callq 0x1a00
movl %eax, %esi
leaq 0x3043(%rip), %rdi      # 0x558e
movb $0x0, %al
callq 0x1050
movq -0x8(%rbp), %rdi
callq 0x1a00
movl %eax, %esi
leaq 0x3044(%rip), %rdi      # 0x55a8
movb $0x0, %al
callq 0x1050
movq -0x8(%rbp), %rdi
callq 0x1a00
movl %eax, %esi
leaq 0x3045(%rip), %rdi      # 0x55c2
movb $0x0, %al
callq 0x1050
movq -0x8(%rbp), %rdi
callq 0x1a00
movl %eax, %esi
leaq 0x3046(%rip), %rdi      # 0x55dc
movb $0x0, %al
callq 0x1050
movq -0x8(%rbp), %rdi
callq 0x1a00
movl %eax, %esi
leaq 0x3047(%rip), %rdi      # 0x55f6
movb $0x0, %al
callq 0x1050
movq -0x8(%rbp), %rdi
callq 0x1a00
movl %eax, %esi
leaq 0x3048(%rip), %rdi      # 0x5610
movb $0x0, %al
callq 0x1050
movq -0x8(%rbp), %rdi
callq 0x1a00
movl %eax, %esi
leaq 0x3049(%rip), %rdi      # 0x562a
movb $0x0, %al
callq 0x1050
movq -0x8(%rbp), %rdi
callq 0x1a00
movl %eax, %esi
leaq 0x304a(%rip), %rdi      # 0x5644
movb $0x0, %al
callq 0x1050
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mikeakohn[P]print_pe/build/../src/minidump.c
// Function: print_minidump_memory_list
void print_minidump_memory_list(FILE *in)
{
  uint32_t number_of_memory_ranges = read_uint32(in);
  uint64_t start_of_memory_range = read_uint64(in);
  uint32_t data_size = read_uint32(in);
  uint64_t relative_virtual_address = read_uint64(in);

  printf("   number_of_memory_ranges: %u\n", number_of_memory_ranges);
  printf("     start_of_memory_range: 0x%lx\n", start_of_memory_range);
  printf("                 data_size: %d\n", data_size);
  printf("  relative_virtual_address: 0x%lx\n", relative_virtual_address);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1a00
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1930
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1a00
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1930
movq %rax, -0x28(%rbp)
movl -0xc(%rbp), %esi
leaq 0x1fab(%rip), %rdi      # 0x4603
movb $0x0, %al
callq 0x1050
movq -0x18(%rbp), %rsi
leaq 0x1fb9(%rip), %rdi      # 0x4623
movb $0x0, %al
callq 0x1050
movl -0x1c(%rbp), %esi
leaq 0x1fcb(%rip), %rdi      # 0x4646
movb $0x0, %al
callq 0x1050
movq -0x28(%rbp), %rsi
leaq 0x1fd9(%rip), %rdi      # 0x4666
movb $0x0, %al
callq 0x1050
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mikeakohn[P]print_pe/build/../src/minidump.c
// Function: print_minidump_exception
void print_minidump_exception(FILE *in)
{
  uint32_t n;

  printf("         thread_id: %d\n", read_uint32(in));
  printf("            unused: %d\n", read_uint32(in));
  printf("    exception_code: 0x%08x\n", read_uint32(in));
  printf("   exception_flags: 0x%08x\n", read_uint32(in));
  printf("  exception_record: 0x%" PRIx64 "\n", read_uint64(in));
  printf(" exception_address: 0x%" PRIx64 "\n", read_uint64(in));

  uint32_t number_parameters = read_uint32(in);
  printf("  number_paramters: %d\n", number_parameters);
  printf("            unused: %d\n", read_uint32(in));
  printf("       information:\n");

  for (n = 0; n < number_parameters; n++)
  {
    printf("      ---- %d ----\n", n);
    printf("            thread_id: %d\n", read_uint32(in));
    printf("    excpetion_pointer: %d\n", read_uint32(in));
    printf("      client_pointers: %d\n", read_uint32(in));
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1a00
movl %eax, %esi
leaq 0x1fef(%rip), %rdi      # 0x489d
movb $0x0, %al
callq 0x1050
movq -0x8(%rbp), %rdi
callq 0x1a00
movl %eax, %esi
leaq 0x1f0c(%rip), %rdi      # 0x47d3
movb $0x0, %al
callq 0x1050
movq -0x8(%rbp), %rdi
callq 0x1a00
movl %eax, %esi
leaq 0x1f0b(%rip), %rdi      # 0x47eb
movb $0x0, %al
callq 0x1050
movq -0x8(%rbp), %rdi
callq 0x1a00
movl %eax, %esi
leaq 0x1f0e(%rip), %rdi      # 0x4807
movb $0x0, %al
callq 0x1050
movq -0x8(%rbp), %rdi
callq 0x1930
movq %rax, %rsi
leaq 0x1f10(%rip), %rdi      # 0x4823
movb $0x0, %al
callq 0x1050
movq -0x8(%rbp), %rdi
callq 0x1930
movq %rax, %rsi
leaq 0x1f11(%rip), %rdi      # 0x483e
movb $0x0, %al
callq 0x1050
movq -0x8(%rbp), %rdi
callq 0x1a00
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %esi
leaq 0x1f0f(%rip), %rdi      # 0x4859
movb $0x0, %al
callq 0x1050
movq -0x8(%rbp), %rdi
callq 0x1a00
movl %eax, %esi
leaq 0x1e70(%rip), %rdi      # 0x47d3
movb $0x0, %al
callq 0x1050
leaq 0x1f00(%rip), %rdi      # 0x4871
movb $0x0, %al
callq 0x1050
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jae 0x29ee
movl -0xc(%rbp), %esi
leaq 0x1ef5(%rip), %rdi      # 0x4886
movb $0x0, %al
callq 0x1050
movq -0x8(%rbp), %rdi
callq 0x1a00
movl %eax, %esi
leaq 0x1ef0(%rip), %rdi      # 0x489a
movb $0x0, %al
callq 0x1050
movq -0x8(%rbp), %rdi
callq 0x1a00
movl %eax, %esi
leaq 0x1ef2(%rip), %rdi      # 0x48b5
movb $0x0, %al
callq 0x1050
movq -0x8(%rbp), %rdi
callq 0x1a00
movl %eax, %esi
leaq 0x1ef4(%rip), %rdi      # 0x48d0
movb $0x0, %al
callq 0x1050
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x297f
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mikeakohn[P]print_pe/build/../src/minidump.c
// Function: print_minidump_memory64_list
void print_minidump_memory64_list(FILE *in, struct memory_print_t *memory_print)
{
  uint64_t number_of_memory_ranges = read_uint64(in);
  uint64_t offset = read_uint64(in);
  uint64_t n;

  printf("\n");
  printf("  num_memory_ranges: %" PRId64 "\n", number_of_memory_ranges);
  printf("             offset: 0x%" PRIx64 "\n", offset);

  for (n = 0; n < number_of_memory_ranges; n++)
  {
    uint64_t start = read_uint64(in);
    uint64_t size = read_uint64(in);
    char mark = ' ';

    if (memory_print->start >= start &&
        memory_print->start < start + size)
    {
      memory_print->file_offset = offset + (memory_print->start - start);
      memory_print->region_start = start;
      memory_print->region_end = start + size - 1;
      mark = '*';
    }

    printf("         %c  0x%08" PRIx64 ": size=%" PRId64 "\n", mark, start, size);

    offset += size;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1930
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1930
movq %rax, -0x20(%rbp)
leaq 0x14da(%rip), %rdi      # 0x40fb
movb $0x0, %al
callq 0x1050
movq -0x18(%rbp), %rsi
leaq 0x1df0(%rip), %rdi      # 0x4a23
movb $0x0, %al
callq 0x1050
movq -0x20(%rbp), %rsi
leaq 0x1df8(%rip), %rdi      # 0x4a3d
movb $0x0, %al
callq 0x1050
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x2d18
movq -0x8(%rbp), %rdi
callq 0x1930
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1930
movq %rax, -0x38(%rbp)
movb $0x20, -0x39(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x30(%rbp), %rax
jb 0x2ce1
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x30(%rbp), %rcx
addq -0x38(%rbp), %rcx
cmpq %rcx, %rax
jae 0x2ce1
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
subq -0x30(%rbp), %rax
addq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x30(%rbp), %rcx
addq -0x38(%rbp), %rcx
subq $0x1, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
movb $0x2a, -0x39(%rbp)
movsbl -0x39(%rbp), %esi
movq -0x30(%rbp), %rdx
movq -0x38(%rbp), %rcx
leaq 0x1d65(%rip), %rdi      # 0x4a59
movb $0x0, %al
callq 0x1050
movq -0x38(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x2c54
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mikeakohn[P]print_pe/build/../src/minidump.c
// Function: print_minidump_misc_info
void print_minidump_misc_info(FILE *in)
{
  printf("\n");
  printf("           len_info: %u\n", read_uint32(in));
  printf("             flags1: %u\n", read_uint32(in));
  printf("         process_id: %u\n", read_uint32(in));
  printf("process_create_time: %u\n", read_uint32(in));
  printf("  process_user_time: %u\n", read_uint32(in));
  printf("process_kernel_time: %u\n", read_uint32(in));
  printf("        cpu_max_mhz: %u\n", read_uint32(in));
  printf("        cpu_cur_mhz: %u\n", read_uint32(in));
  printf("      cpu_limit_mhz: %u\n", read_uint32(in));
  printf(" cpu_max_idle_state: %u\n", read_uint32(in));
  printf(" cpu_cur_idle_state: %u\n", read_uint32(in));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x11b8(%rip), %rdi      # 0x40fb
movb $0x0, %al
callq 0x1050
movq -0x8(%rbp), %rdi
callq 0x1a00
movl %eax, %esi
leaq 0x1c9c(%rip), %rdi      # 0x4bf8
movb $0x0, %al
callq 0x1050
movq -0x8(%rbp), %rdi
callq 0x1a00
movl %eax, %esi
leaq 0x1c9c(%rip), %rdi      # 0x4c11
movb $0x0, %al
callq 0x1050
movq -0x8(%rbp), %rdi
callq 0x1a00
movl %eax, %esi
leaq 0x1c9c(%rip), %rdi      # 0x4c2a
movb $0x0, %al
callq 0x1050
movq -0x8(%rbp), %rdi
callq 0x1a00
movl %eax, %esi
leaq 0x1c9c(%rip), %rdi      # 0x4c43
movb $0x0, %al
callq 0x1050
movq -0x8(%rbp), %rdi
callq 0x1a00
movl %eax, %esi
leaq 0x1c9c(%rip), %rdi      # 0x4c5c
movb $0x0, %al
callq 0x1050
movq -0x8(%rbp), %rdi
callq 0x1a00
movl %eax, %esi
leaq 0x1c9c(%rip), %rdi      # 0x4c75
movb $0x0, %al
callq 0x1050
movq -0x8(%rbp), %rdi
callq 0x1a00
movl %eax, %esi
leaq 0x1c9c(%rip), %rdi      # 0x4c8e
movb $0x0, %al
callq 0x1050
movq -0x8(%rbp), %rdi
callq 0x1a00
movl %eax, %esi
leaq 0x1c9c(%rip), %rdi      # 0x4ca7
movb $0x0, %al
callq 0x1050
movq -0x8(%rbp), %rdi
callq 0x1a00
movl %eax, %esi
leaq 0x1c9c(%rip), %rdi      # 0x4cc0
movb $0x0, %al
callq 0x1050
movq -0x8(%rbp), %rdi
callq 0x1a00
movl %eax, %esi
leaq 0x1c9c(%rip), %rdi      # 0x4cd9
movb $0x0, %al
callq 0x1050
movq -0x8(%rbp), %rdi
callq 0x1a00
movl %eax, %esi
leaq 0x1c9c(%rip), %rdi      # 0x4cf2
movb $0x0, %al
callq 0x1050
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mikeakohn[P]print_pe/build/../src/minidump.c
// Function: print_minidump_thread_info_list
void print_minidump_thread_info_list(FILE *in)
{
  printf("\n");
  printf("     size_of_header: %u\n", read_uint32(in));
  printf("      size_of_entry: %u\n", read_uint32(in));
  printf("  number_of_entries: %u\n", read_uint32(in));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x1078(%rip), %rdi      # 0x40fb
movb $0x0, %al
callq 0x1050
movq -0x8(%rbp), %rdi
callq 0x1a00
movl %eax, %esi
leaq 0x19dd(%rip), %rdi      # 0x4a79
movb $0x0, %al
callq 0x1050
movq -0x8(%rbp), %rdi
callq 0x1a00
movl %eax, %esi
leaq 0x1c56(%rip), %rdi      # 0x4d0b
movb $0x0, %al
callq 0x1050
movq -0x8(%rbp), %rdi
callq 0x1a00
movl %eax, %esi
leaq 0x1c56(%rip), %rdi      # 0x4d24
movb $0x0, %al
callq 0x1050
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/util.c
// Function: janet_core_cfuns_ext
void janet_core_cfuns_ext(JanetTable *env, const char *regprefix, const JanetRegExt *cfuns) {
    (void) regprefix;
    while (cfuns->name) {
        Janet fun = janet_wrap_cfunction(cfuns->cfun);
        janet_table_put(env, janet_csymbolv(cfuns->name), fun);
        janet_registry_put(cfuns->cfun, cfuns->name, regprefix, cfuns->source_file, cfuns->source_line);
        cfuns++;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x17d41
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movabsq $-0x1800000000000, %rsi # imm = 0xFFFE800000000000
callq 0x163b0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x19e00
movq %rax, %rdi
movabsq $-0x5800000000000, %rsi # imm = 0xFFFA800000000000
callq 0x19dd0
movq -0x30(%rbp), %rdi
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x16120
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x18(%rbp), %rax
movl 0x20(%rax), %r8d
callq 0x39b80
movq -0x18(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x18(%rbp)
jmp 0x17ca4
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/util.c
// Function: janet_core_def_sm
void janet_core_def_sm(JanetTable *env, const char *name, Janet x, const void *p, const void *sf, int32_t sl) {
    (void) sf;
    (void) sl;
    (void) p;
    Janet key = janet_csymbolv(name);
    janet_table_put(env, key, x);
    if (janet_checktype(x, JANET_CFUNCTION)) {
        janet_registry_put(janet_unwrap_cfunction(x), name, NULL, NULL, 0);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdx, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x19e00
movq %rax, %rdi
movabsq $-0x5800000000000, %rsi # imm = 0xFFFA800000000000
callq 0x19dd0
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x8(%rbp), %rdx
callq 0x16120
xorl %eax, %eax
testb $0x1, %al
jne 0x402d8
jmp 0x402fe
movsd -0x8(%rbp), %xmm0
ucomisd %xmm0, %xmm0
setp %al
testb $0x1, %al
jne 0x402ea
jmp 0x4031b
movq -0x8(%rbp), %rax
shrq $0x2f, %rax
andq $0xf, %rax
cmpq $0x0, %rax
je 0x4031b
jmp 0x4033a
movabsq $-0x800000000000, %rax  # imm = 0xFFFF800000000000
andq -0x8(%rbp), %rax
movabsq $-0x1800000000000, %rcx # imm = 0xFFFE800000000000
cmpq %rcx, %rax
jne 0x4033a
movq -0x8(%rbp), %rdi
callq 0x1f9e0
movq %rax, %rdi
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %ecx
xorl %r8d, %r8d
movq %rcx, %rdx
callq 0x39b80
addq $0x40, %rsp
popq %rbp
retq