LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/fiber.c
// Function: janet_fiber_setcapacity
void janet_fiber_setcapacity(JanetFiber *fiber, int32_t n) {
    int32_t old_size = fiber->capacity;
    int32_t diff = n - old_size;
    Janet *newData = janet_realloc(fiber->data, sizeof(Janet) * n);
    if (NULL == newData) {
        JANET_OUT_OF_MEMORY;
    }
    fiber->data = newData;
    fiber->capacity = n;
    janet_vm.next_collection += sizeof(Janet) * diff;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
subl -0x10(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
movslq -0xc(%rbp), %rsi
shlq $0x3, %rsi
callq 0x12840
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq -0x20(%rbp), %rax
jne 0x36113
jmp 0x360e5
movq 0x79f04(%rip), %rax     # 0xafff0
movq (%rax), %rdi
leaq 0x47f0e(%rip), %rsi     # 0x7e004
leaq 0x53e05(%rip), %rdx     # 0x89f02
movl $0x7a, %ecx
movb $0x0, %al
callq 0x125f0
movl $0x1, %edi
callq 0x12a70
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x30(%rax)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x20(%rax)
movslq -0x14(%rbp), %rax
shlq $0x3, %rax
movq %rax, -0x28(%rbp)
movq %fs:0x0, %rax
leaq -0x348(%rax), %rax
movq -0x28(%rbp), %rcx
addq 0xa8(%rax), %rcx
movq %rcx, 0xa8(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/fiber.c
// Function: fiber_alloc
static JanetFiber *fiber_alloc(int32_t capacity) {
    Janet *data;
    JanetFiber *fiber = janet_gcalloc(JANET_MEMORY_FIBER, sizeof(JanetFiber));
    if (capacity < 32) {
        capacity = 32;
    }
    fiber->capacity = capacity;
    data = janet_malloc(sizeof(Janet) * (size_t) capacity);
    if (NULL == data) {
        JANET_OUT_OF_MEMORY;
    }
    janet_vm.next_collection += sizeof(Janet) * capacity;
    fiber->data = data;
    return fiber;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl $0x7, %edi
movl $0x70, %esi
callq 0x39e40
movq %rax, -0x18(%rbp)
cmpl $0x20, -0x4(%rbp)
jge 0x364bb
movl $0x20, -0x4(%rbp)
movl -0x4(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x20(%rax)
movslq -0x4(%rbp), %rdi
shlq $0x3, %rdi
callq 0x12770
movq %rax, -0x10(%rbp)
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
jne 0x3650e
jmp 0x364e0
movq 0x79b09(%rip), %rax     # 0xafff0
movq (%rax), %rdi
leaq 0x47b13(%rip), %rsi     # 0x7e004
leaq 0x53a0a(%rip), %rdx     # 0x89f02
movl $0x3c, %ecx
movb $0x0, %al
callq 0x125f0
movl $0x1, %edi
callq 0x12a70
movslq -0x4(%rbp), %rax
shlq $0x3, %rax
movq %rax, -0x20(%rbp)
movq %fs:0x0, %rax
leaq -0x348(%rax), %rax
movq -0x20(%rbp), %rcx
addq 0xa8(%rax), %rcx
movq %rcx, 0xa8(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/fiber.c
// Function: janet_fiber_push
void janet_fiber_push(JanetFiber *fiber, Janet x) {
    if (fiber->stacktop == INT32_MAX) janet_panic("stack overflow");
    if (fiber->stacktop >= fiber->capacity) {
        janet_fiber_grow(fiber, fiber->stacktop);
    }
    fiber->data[fiber->stacktop++] = x;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rsi, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x7fffffff, 0x1c(%rax) # imm = 0x7FFFFFFF
jne 0x36589
leaq 0x5398f(%rip), %rdi     # 0x89f13
callq 0x1ad60
movq -0x10(%rbp), %rax
movl 0x1c(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x20(%rcx), %eax
jl 0x365a9
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x1c(%rax), %esi
callq 0x365e0
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x10(%rbp), %rdx
movl 0x1c(%rdx), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x1c(%rdx)
movslq %ecx, %rcx
movq -0x8(%rbp), %rdx
movq %rdx, (%rax,%rcx,8)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/fiber.c
// Function: janet_fiber_push2
void janet_fiber_push2(JanetFiber *fiber, Janet x, Janet y) {
    if (fiber->stacktop >= INT32_MAX - 1) janet_panic("stack overflow");
    int32_t newtop = fiber->stacktop + 2;
    if (newtop > fiber->capacity) {
        janet_fiber_grow(fiber, newtop);
    }
    fiber->data[fiber->stacktop] = x;
    fiber->data[fiber->stacktop + 1] = y;
    fiber->stacktop = newtop;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x7ffffffe, 0x1c(%rax) # imm = 0x7FFFFFFE
jl 0x3665d
leaq 0x538bb(%rip), %rdi     # 0x89f13
callq 0x1ad60
movq -0x18(%rbp), %rax
movl 0x1c(%rax), %eax
addl $0x2, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x20(%rcx), %eax
jle 0x36682
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x365e0
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x18(%rbp), %rcx
movslq 0x1c(%rcx), %rcx
movq -0x8(%rbp), %rdx
movq %rdx, (%rax,%rcx,8)
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x18(%rbp), %rcx
movl 0x1c(%rcx), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq -0x10(%rbp), %rdx
movq %rdx, (%rax,%rcx,8)
movl -0x1c(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x1c(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/fiber.c
// Function: janet_fiber_push3
void janet_fiber_push3(JanetFiber *fiber, Janet x, Janet y, Janet z) {
    if (fiber->stacktop >= INT32_MAX - 2) janet_panic("stack overflow");
    int32_t newtop = fiber->stacktop + 3;
    if (newtop > fiber->capacity) {
        janet_fiber_grow(fiber, newtop);
    }
    fiber->data[fiber->stacktop] = x;
    fiber->data[fiber->stacktop + 1] = y;
    fiber->data[fiber->stacktop + 2] = z;
    fiber->stacktop = newtop;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %rdi, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x7ffffffd, 0x1c(%rax) # imm = 0x7FFFFFFD
jl 0x36701
leaq 0x53817(%rip), %rdi     # 0x89f13
callq 0x1ad60
movq -0x20(%rbp), %rax
movl 0x1c(%rax), %eax
addl $0x3, %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl 0x20(%rcx), %eax
jle 0x36726
movq -0x20(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x365e0
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x20(%rbp), %rcx
movslq 0x1c(%rcx), %rcx
movq -0x8(%rbp), %rdx
movq %rdx, (%rax,%rcx,8)
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x20(%rbp), %rcx
movl 0x1c(%rcx), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq -0x10(%rbp), %rdx
movq %rdx, (%rax,%rcx,8)
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x20(%rbp), %rcx
movl 0x1c(%rcx), %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
movq -0x18(%rbp), %rdx
movq %rdx, (%rax,%rcx,8)
movl -0x24(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x1c(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/fiber.c
// Function: janet_fiber_pushn
void janet_fiber_pushn(JanetFiber *fiber, const Janet *arr, int32_t n) {
    if (fiber->stacktop > INT32_MAX - n) janet_panic("stack overflow");
    int32_t newtop = fiber->stacktop + n;
    if (newtop > fiber->capacity) {
        janet_fiber_grow(fiber, newtop);
    }
    safe_memcpy(fiber->data + fiber->stacktop, arr, n * sizeof(Janet));
    fiber->stacktop = newtop;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %eax
movl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
subl -0x14(%rbp), %ecx
cmpl %ecx, %eax
jle 0x367c2
leaq 0x53756(%rip), %rdi     # 0x89f13
callq 0x1ad60
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x20(%rcx), %eax
jle 0x367e7
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x365e0
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0x1c(%rax), %rax
shlq $0x3, %rax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
movslq -0x14(%rbp), %rdx
shlq $0x3, %rdx
callq 0x6ae40
movl -0x18(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x1c(%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/fiber.c
// Function: make_struct_n
static Janet make_struct_n(const Janet *args, int32_t n) {
    int32_t i = 0;
    JanetKV *st = janet_struct_begin(n & (~1));
    for (; i < n; i += 2) {
        janet_struct_put(st, args[i], args[i + 1]);
    }
    return janet_wrap_struct(janet_struct_end(st));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x14(%rbp), %edi
andl $-0x2, %edi
callq 0x67720
movq %rax, -0x20(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x3687e
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rdx
movslq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rdx,%rsi,8), %rsi
movq (%rax,%rcx,8), %rdx
callq 0x67d00
movl -0x18(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x18(%rbp)
jmp 0x36845
movq -0x20(%rbp), %rdi
callq 0x67d30
movq %rax, %rdi
movabsq $-0x3000000000000, %rsi # imm = 0xFFFD000000000000
callq 0x7b550
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/fiber.c
// Function: janet_env_valid
int janet_env_valid(JanetFuncEnv *env) {
    if (env->offset < 0) {
        int32_t real_offset = -(env->offset);
        JanetFiber *fiber = env->as.fiber;
        int32_t i = fiber->frame;
        while (i > 0) {
            JanetStackFrame *frame = (JanetStackFrame *)(fiber->data + i - JANET_FRAME_SIZE);
            if (real_offset == i &&
                    frame->env == env &&
                    frame->func &&
                    frame->func->def->slotcount == env->length) {
                env->offset = real_offset;
                return 1;
            }
            i = frame->prevframe;
        }
        /* Invalid, set to empty off-stack variant. */
        env->offset = 0;
        env->length = 0;
        env->as.values = NULL;
        return 0;
    } else {
        return 1;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x1c(%rax)
jge 0x3698a
movq -0x10(%rbp), %rcx
xorl %eax, %eax
subl 0x1c(%rcx), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jle 0x3695f
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rax
movslq -0x24(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
addq $-0x20, %rax
movq %rax, -0x30(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x24(%rbp), %eax
jne 0x36953
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x36953
movq -0x30(%rbp), %rax
cmpq $0x0, (%rax)
je 0x36953
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movl 0x5c(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jne 0x36953
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x1c(%rax)
movl $0x1, -0x4(%rbp)
jmp 0x36991
movq -0x30(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, -0x24(%rbp)
jmp 0x368e8
movq -0x10(%rbp), %rax
movl $0x0, 0x1c(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x18(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movl $0x0, -0x4(%rbp)
jmp 0x36991
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/fiber.c
// Function: janet_env_maybe_detach
void janet_env_maybe_detach(JanetFuncEnv *env) {
    /* Check for detachable closure envs */
    janet_env_valid(env);
    if (env->offset > 0) {
        JanetFiberStatus s = janet_fiber_status(env->as.fiber);
        int isFinished = s == JANET_STATUS_DEAD ||
                         s == JANET_STATUS_ERROR ||
                         s == JANET_STATUS_USER0 ||
                         s == JANET_STATUS_USER1 ||
                         s == JANET_STATUS_USER2 ||
                         s == JANET_STATUS_USER3 ||
                         s == JANET_STATUS_USER4;
        if (isFinished) {
            janet_env_detach(env);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x368b0
movq -0x8(%rbp), %rax
cmpl $0x0, 0x1c(%rax)
jle 0x36a37
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x36a40
movl %eax, -0xc(%rbp)
movb $0x1, %al
cmpl $0x0, -0xc(%rbp)
movb %al, -0x11(%rbp)
je 0x36a1b
movb $0x1, %al
cmpl $0x1, -0xc(%rbp)
movb %al, -0x11(%rbp)
je 0x36a1b
movb $0x1, %al
cmpl $0x4, -0xc(%rbp)
movb %al, -0x11(%rbp)
je 0x36a1b
movb $0x1, %al
cmpl $0x5, -0xc(%rbp)
movb %al, -0x11(%rbp)
je 0x36a1b
movb $0x1, %al
cmpl $0x6, -0xc(%rbp)
movb %al, -0x11(%rbp)
je 0x36a1b
movb $0x1, %al
cmpl $0x7, -0xc(%rbp)
movb %al, -0x11(%rbp)
je 0x36a1b
cmpl $0x8, -0xc(%rbp)
sete %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
je 0x36a35
movq -0x8(%rbp), %rdi
callq 0x36a60
jmp 0x36a37
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/fiber.c
// Function: janet_fiber_cframe
void janet_fiber_cframe(JanetFiber *fiber, JanetCFunction cfun) {
    JanetStackFrame *newframe;

    int32_t oldframe = fiber->frame;
    int32_t nextframe = fiber->stackstart;
    int32_t nextstacktop = fiber->stacktop + JANET_FRAME_SIZE;

    if (fiber->capacity < nextstacktop) {
        janet_fiber_setcapacity(fiber, 2 * nextstacktop);
#ifdef JANET_DEBUG
    } else {
        janet_fiber_refresh_memory(fiber);
#endif
    }

    /* Set the next frame */
    fiber->frame = nextframe;
    fiber->stacktop = fiber->stackstart = nextstacktop;
    newframe = janet_fiber_frame(fiber);

    /* Set up the new frame */
    newframe->prevframe = oldframe;
    newframe->pc = (uint32_t *) cfun;
    newframe->func = NULL;
    newframe->env = NULL;
    newframe->flags = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %eax
addl $0x4, %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rax
movl 0x20(%rax), %eax
cmpl -0x24(%rbp), %eax
jge 0x370ab
movq -0x8(%rbp), %rdi
movl -0x24(%rbp), %esi
shll %esi
callq 0x360a0
movl -0x20(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x14(%rax)
movl -0x24(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x8(%rbp), %rax
movl %ecx, 0x1c(%rax)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x14(%rcx), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
addq $-0x20, %rax
movq %rax, -0x18(%rbp)
movl -0x1c(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x1c(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/fiber.c
// Function: janet_fiber_popframe
void janet_fiber_popframe(JanetFiber *fiber) {
    JanetStackFrame *frame = janet_fiber_frame(fiber);
    if (fiber->frame == 0) return;

    /* Clean up the frame (detach environments) */
    if (NULL != frame->func)
        janet_env_detach(frame->env);

    /* Shrink stack */
    fiber->stacktop = fiber->stackstart = fiber->frame;
    fiber->frame = frame->prevframe;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x14(%rcx), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
addq $-0x20, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x14(%rax)
jne 0x37167
jmp 0x371a2
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq (%rcx), %rax
je 0x3717f
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x36a60
movq -0x8(%rbp), %rax
movl 0x14(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x8(%rbp), %rax
movl %ecx, 0x1c(%rax)
movq -0x10(%rbp), %rax
movl 0x18(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x14(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/fiber.c
// Function: janet_fiber_can_resume
int janet_fiber_can_resume(JanetFiber *fiber) {
    JanetFiberStatus s = janet_fiber_status(fiber);
    int isFinished = s == JANET_STATUS_DEAD ||
                     s == JANET_STATUS_ERROR ||
                     s == JANET_STATUS_USER0 ||
                     s == JANET_STATUS_USER1 ||
                     s == JANET_STATUS_USER2 ||
                     s == JANET_STATUS_USER3 ||
                     s == JANET_STATUS_USER4;
    return !isFinished;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x36a40
movl %eax, -0xc(%rbp)
movb $0x1, %al
cmpl $0x0, -0xc(%rbp)
movb %al, -0x11(%rbp)
je 0x37914
movb $0x1, %al
cmpl $0x1, -0xc(%rbp)
movb %al, -0x11(%rbp)
je 0x37914
movb $0x1, %al
cmpl $0x4, -0xc(%rbp)
movb %al, -0x11(%rbp)
je 0x37914
movb $0x1, %al
cmpl $0x5, -0xc(%rbp)
movb %al, -0x11(%rbp)
je 0x37914
movb $0x1, %al
cmpl $0x6, -0xc(%rbp)
movb %al, -0x11(%rbp)
je 0x37914
movb $0x1, %al
cmpl $0x7, -0xc(%rbp)
movb %al, -0x11(%rbp)
je 0x37914
cmpl $0x8, -0xc(%rbp)
sete %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/filewatch.c
// Function: decode_watch_flags
static uint32_t decode_watch_flags(const Janet *options, int32_t n) {
    uint32_t flags = 0;
    for (int32_t i = 0; i < n; i++) {
        if (!(janet_checktype(options[i], JANET_KEYWORD))) {
            janet_panicf("expected keyword, got %v", options[i]);
        }
        JanetKeyword keyw = janet_unwrap_keyword(options[i]);
        const JanetWatchFlagName *result = janet_strbinsearch(watcher_flags_linux,
                                           sizeof(watcher_flags_linux) / sizeof(JanetWatchFlagName),
                                           sizeof(JanetWatchFlagName),
                                           keyw);
        if (!result) {
            janet_panicf("unknown inotify flag %v", options[i]);
        }
        flags |= result->flag;
    }
    return flags;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x37c03
xorl %eax, %eax
testb $0x1, %al
jne 0x37b21
jmp 0x37b57
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
ucomisd %xmm0, %xmm0
setp %al
testb $0x1, %al
jne 0x37b3b
jmp 0x37b96
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
shrq $0x2f, %rax
andq $0xf, %rax
cmpq $0x0, %rax
je 0x37b96
jmp 0x37b7c
movq -0x8(%rbp), %rcx
movslq -0x14(%rbp), %rdx
movabsq $-0x800000000000, %rax  # imm = 0xFFFF800000000000
andq (%rcx,%rdx,8), %rax
movabsq $-0x5000000000000, %rcx # imm = 0xFFFB000000000000
cmpq %rcx, %rax
je 0x37b96
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
leaq 0x53016(%rip), %rdi     # 0x8aba5
movb $0x0, %al
callq 0x1ac40
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x7b260
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
leaq 0x74faa(%rip), %rdi     # 0xacb60
movl $0x10, %edx
movq %rdx, %rsi
callq 0x6b360
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x37be8
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
leaq 0x52fdd(%rip), %rdi     # 0x8abbe
movb $0x0, %al
callq 0x1ac40
movq -0x28(%rbp), %rax
movl 0x8(%rax), %eax
orl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x37b0d
movl -0x10(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/filewatch.c
// Function: janet_watcher_init
static void janet_watcher_init(JanetWatcher *watcher, JanetChannel *channel, uint32_t default_flags) {
    int fd;
    do {
        fd = inotify_init1(IN_NONBLOCK | IN_CLOEXEC);
    } while (fd == -1 && errno == EINTR);
    if (fd == -1) {
        janet_panicv(janet_ev_lasterr());
    }
    watcher->watch_descriptors = janet_table(0);
    watcher->channel = channel;
    watcher->default_flags = default_flags;
    watcher->is_watching = 0;
    watcher->stream = janet_stream(fd, JANET_STREAM_READABLE, NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x80800, %edi          # imm = 0x80800
callq 0x12bf0
movl %eax, -0x18(%rbp)
xorl %eax, %eax
cmpl $-0x1, -0x18(%rbp)
movb %al, -0x21(%rbp)
jne 0x37c49
callq 0x12120
cmpl $0x4, (%rax)
sete %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x37c23
cmpl $-0x1, -0x18(%rbp)
jne 0x37c68
callq 0x2f7c0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1ac20
xorl %edi, %edi
callq 0x692f0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x1c(%rax)
movl -0x18(%rbp), %edi
movl $0x200, %esi            # imm = 0x200
xorl %eax, %eax
movl %eax, %edx
callq 0x2ab20
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/filewatch.c
// Function: janet_watcher_add
static void janet_watcher_add(JanetWatcher *watcher, const char *path, uint32_t flags) {
    if (watcher->stream == NULL) janet_panic("watcher closed");
    int result;
    do {
        result = inotify_add_watch(watcher->stream->handle, path, flags);
    } while (result == -1 && errno == EINTR);
    if (result == -1) {
        janet_panicv(janet_ev_lasterr());
    }
    Janet name = janet_cstringv(path);
    Janet wd = janet_wrap_integer(result);
    janet_table_put(watcher->watch_descriptors, name, wd);
    janet_table_put(watcher->watch_descriptors, wd, name);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x37d89
leaq 0x52ed4(%rip), %rdi     # 0x8ac58
callq 0x1ad60
jmp 0x37d8b
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl (%rax), %edi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x12790
movl %eax, -0x18(%rbp)
xorl %eax, %eax
cmpl $-0x1, -0x18(%rbp)
movb %al, -0x31(%rbp)
jne 0x37dbc
callq 0x12120
cmpl $0x4, (%rax)
sete %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x37d8b
cmpl $-0x1, -0x18(%rbp)
jne 0x37ddb
callq 0x2f7c0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1ac20
movq -0x10(%rbp), %rdi
callq 0x64a70
movq %rax, %rdi
movabsq $-0x6000000000000, %rsi # imm = 0xFFFA000000000000
callq 0x7b550
movq %rax, -0x28(%rbp)
cvtsi2sdl -0x18(%rbp), %xmm0
callq 0x7b820
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x697e0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x697e0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/filewatch.c
// Function: janet_watcher_remove
static void janet_watcher_remove(JanetWatcher *watcher, const char *path) {
    if (watcher->stream == NULL) janet_panic("watcher closed");
    Janet check = janet_table_get(watcher->watch_descriptors, janet_cstringv(path));
    janet_assert(janet_checktype(check, JANET_NUMBER), "bad watch descriptor");
    int watch_handle = janet_unwrap_integer(check);
    int result;
    do {
        result = inotify_rm_watch(watcher->stream->handle, watch_handle);
    } while (result != -1 && errno == EINTR);
    if (result == -1) {
        janet_panicv(janet_ev_lasterr());
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x37ed6
leaq 0x52d87(%rip), %rdi     # 0x8ac58
callq 0x1ad60
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x64a70
movq %rax, %rdi
movabsq $-0x6000000000000, %rsi # imm = 0xFFFA000000000000
callq 0x7b550
movq -0x38(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
callq 0x69420
movq %rax, -0x18(%rbp)
movb $0x1, %al
testb $0x1, %al
jne 0x37f1a
jmp 0x37f40
movsd -0x18(%rbp), %xmm0
ucomisd %xmm0, %xmm0
setp %al
testb $0x1, %al
jne 0x37f2c
jmp 0x37f8f
movq -0x18(%rbp), %rax
shrq $0x2f, %rax
andq $0xf, %rax
cmpq $0x0, %rax
je 0x37f8f
jmp 0x37f5d
movabsq $-0x800000000000, %rax  # imm = 0xFFFF800000000000
andq -0x18(%rbp), %rax
movabsq $-0x8000000000000, %rcx # imm = 0xFFF8000000000000
cmpq %rcx, %rax
je 0x37f8f
jmp 0x37f5f
movq 0x7808a(%rip), %rax     # 0xafff0
movq (%rax), %rdi
leaq 0x490a4(%rip), %rsi     # 0x81014
movl $0x84, %edx
leaq 0x52bbf(%rip), %rcx     # 0x8ab3b
leaq 0x52ce4(%rip), %r8      # 0x8ac67
movb $0x0, %al
callq 0x125f0
callq 0x12100
jmp 0x37f91
cvttsd2si -0x18(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl (%rax), %edi
movl -0x24(%rbp), %esi
callq 0x12b50
movl %eax, -0x28(%rbp)
xorl %eax, %eax
cmpl $-0x1, -0x28(%rbp)
movb %al, -0x39(%rbp)
je 0x37fc6
callq 0x12120
cmpl $0x4, (%rax)
sete %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x37f99
cmpl $-0x1, -0x28(%rbp)
jne 0x37fe5
callq 0x2f7c0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x1ac20
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/filewatch.c
// Function: janet_watcher_listen
static void janet_watcher_listen(JanetWatcher *watcher) {
    if (watcher->is_watching) janet_panic("already watching");
    watcher->is_watching = 1;
    JanetFunction *thunk = janet_thunk_delay(janet_wrap_nil());
    JanetFiber *fiber = janet_fiber(thunk, 64, 0, NULL);
    JanetWatcher **state = janet_malloc(sizeof(JanetWatcher *)); /* Gross */
    *state = watcher;
    janet_async_start_fiber(fiber, watcher->stream, JANET_ASYNC_LISTEN_READ, watcher_callback_read, state);
    janet_gcroot(janet_wrap_abstract(watcher));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x1c(%rax)
je 0x38072
leaq 0x52c0f(%rip), %rdi     # 0x8ac7c
callq 0x1ad60
movq -0x8(%rbp), %rax
movl $0x1, 0x1c(%rax)
movabsq $-0x77fffffffffff, %rdi # imm = 0xFFF8800000000001
callq 0x7b460
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1d0d0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x40, %esi
xorl %edx, %edx
xorl %eax, %eax
movl %eax, %ecx
callq 0x36450
movq %rax, -0x20(%rbp)
movl $0x8, %edi
callq 0x12770
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movq -0x28(%rbp), %r8
movl $0x1, %edx
leaq 0x1f7(%rip), %rcx       # 0x382e0
callq 0x2a860
movq -0x8(%rbp), %rdi
movabsq $-0x1000000000000, %rsi # imm = 0xFFFF000000000000
callq 0x7b610
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x39200
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/filewatch.c
// Function: janet_watcher_unlisten
static void janet_watcher_unlisten(JanetWatcher *watcher) {
    if (!watcher->is_watching) return;
    watcher->is_watching = 0;
    janet_stream_close(watcher->stream);
    janet_gcunroot(janet_wrap_abstract(watcher));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x1c(%rax)
jne 0x38198
jmp 0x381cf
movq -0x8(%rbp), %rax
movl $0x0, 0x1c(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x2ab50
movq -0x8(%rbp), %rdi
movabsq $-0x1000000000000, %rsi # imm = 0xFFFF000000000000
callq 0x7b610
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3a2c0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/filewatch.c
// Function: janet_filewatch_mark
static int janet_filewatch_mark(void *p, size_t s) {
    JanetWatcher *watcher = (JanetWatcher *) p;
    (void) s;
    if (watcher->channel == NULL) return 0; /* Incomplete initialization */
#ifdef JANET_WINDOWS
    for (int32_t i = 0; i < watcher->watch_descriptors->capacity; i++) {
        const JanetKV *kv = watcher->watch_descriptors->data + i;
        if (!janet_checktype(kv->value, JANET_POINTER)) continue;
        OverlappedWatch *ow = janet_unwrap_pointer(kv->value);
        janet_mark(janet_wrap_fiber(ow->fiber));
        janet_mark(janet_wrap_abstract(ow->stream));
        janet_mark(janet_wrap_string(ow->dir_path));
    }
#else
    janet_mark(janet_wrap_abstract(watcher->stream));
#endif
    janet_mark(janet_wrap_abstract(watcher->channel));
    janet_mark(janet_wrap_table(watcher->watch_descriptors));
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x3825c
movl $0x0, -0x4(%rbp)
jmp 0x382ce
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movabsq $-0x1000000000000, %rsi # imm = 0xFFFF000000000000
callq 0x7b610
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x38b90
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
movabsq $-0x1000000000000, %rsi # imm = 0xFFFF000000000000
callq 0x7b610
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x38b90
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movabsq $-0x3800000000000, %rsi # imm = 0xFFFC800000000000
callq 0x7b610
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x38b90
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/gc.c
// Function: janet_mark
void janet_mark(Janet x) {
    if (depth) {
        depth--;
        switch (janet_type(x)) {
            default:
                break;
            case JANET_STRING:
            case JANET_KEYWORD:
            case JANET_SYMBOL:
                janet_mark_string(janet_unwrap_string(x));
                break;
            case JANET_FUNCTION:
                janet_mark_function(janet_unwrap_function(x));
                break;
            case JANET_ARRAY:
                janet_mark_array(janet_unwrap_array(x));
                break;
            case JANET_TABLE:
                janet_mark_table(janet_unwrap_table(x));
                break;
            case JANET_STRUCT:
                janet_mark_struct(janet_unwrap_struct(x));
                break;
            case JANET_TUPLE:
                janet_mark_tuple(janet_unwrap_tuple(x));
                break;
            case JANET_BUFFER:
                janet_mark_buffer(janet_unwrap_buffer(x));
                break;
            case JANET_FIBER:
                janet_mark_fiber(janet_unwrap_fiber(x));
                break;
            case JANET_ABSTRACT:
                janet_mark_abstract(janet_unwrap_abstract(x));
                break;
        }
        depth++;
    } else {
        janet_gcroot(x);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %fs:0x0, %rax
leaq -0x358(%rax), %rax
cmpl $0x0, (%rax)
je 0x38cf1
movq %fs:0x0, %rax
leaq -0x358(%rax), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
movsd -0x8(%rbp), %xmm0
ucomisd %xmm0, %xmm0
setp %al
testb $0x1, %al
jne 0x38be4
jmp 0x38bf5
movq -0x8(%rbp), %rax
shrq $0x2f, %rax
andq $0xf, %rax
movl %eax, -0xc(%rbp)
jmp 0x38bfc
xorl %eax, %eax
movl %eax, -0xc(%rbp)
jmp 0x38bfc
movl -0xc(%rbp), %eax
addl $-0x3, %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0xb, %eax
ja 0x38c21
movq -0x18(%rbp), %rax
leaq 0x52098(%rip), %rcx     # 0x8acb0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x38cd5
movq -0x8(%rbp), %rdi
callq 0x7b260
movq %rax, %rdi
callq 0x38d00
jmp 0x38cd5
movq -0x8(%rbp), %rdi
callq 0x7b260
movq %rax, %rdi
callq 0x38d20
jmp 0x38cd5
movq -0x8(%rbp), %rdi
callq 0x7b260
movq %rax, %rdi
callq 0x38db0
jmp 0x38cd5
movq -0x8(%rbp), %rdi
callq 0x7b260
movq %rax, %rdi
callq 0x38e10
jmp 0x38cd5
movq -0x8(%rbp), %rdi
callq 0x7b260
movq %rax, %rdi
callq 0x38ed0
jmp 0x38cd5
movq -0x8(%rbp), %rdi
callq 0x7b260
movq %rax, %rdi
callq 0x38f30
jmp 0x38cd5
movq -0x8(%rbp), %rdi
callq 0x7b260
movq %rax, %rdi
callq 0x38f80
jmp 0x38cd5
movq -0x8(%rbp), %rdi
callq 0x7b260
movq %rax, %rdi
callq 0x38fa0
jmp 0x38cd5
movq -0x8(%rbp), %rdi
callq 0x7b260
movq %rax, %rdi
callq 0x39130
movq %fs:0x0, %rax
leaq -0x358(%rax), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x38cfa
movq -0x8(%rbp), %rdi
callq 0x39200
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/gc.c
// Function: janet_mark_function
static void janet_mark_function(JanetFunction *func) {
    int32_t i;
    int32_t numenvs;
    if (janet_gc_reachable(func))
        return;
    janet_gc_mark(func);
    if (NULL != func->def) {
        /* this should always be true, except if function is only partially constructed */
        numenvs = func->def->environments_length;
        for (i = 0; i < numenvs; ++i) {
            janet_mark_funcenv(func->envs[i]);
        }
        janet_mark_funcdef(func->def);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
andl $0x100, %eax            # imm = 0x100
cmpl $0x0, %eax
je 0x38d3e
jmp 0x38d9f
movq -0x8(%rbp), %rax
movl (%rax), %ecx
orl $0x100, %ecx            # imm = 0x100
movl %ecx, (%rax)
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpq 0x10(%rcx), %rax
je 0x38d9f
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl 0x74(%rax), %eax
movl %eax, -0x10(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x38d92
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rdi
callq 0x3afb0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x38d6d
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x3b020
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/gc.c
// Function: janet_mark_array
static void janet_mark_array(JanetArray *array) {
    if (janet_gc_reachable(array))
        return;
    janet_gc_mark(array);
    if (janet_gc_type((JanetGCObject *) array) == JANET_MEMORY_ARRAY) {
        janet_mark_many(array->data, array->count);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
andl $0x100, %eax            # imm = 0x100
cmpl $0x0, %eax
je 0x38dce
jmp 0x38e00
movq -0x8(%rbp), %rax
movl (%rax), %ecx
orl $0x100, %ecx            # imm = 0x100
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0x3, %eax
jne 0x38e00
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x10(%rax), %esi
callq 0x3ae50
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/gc.c
// Function: janet_mark_table
static void janet_mark_table(JanetTable *table) {
recur: /* Manual tail recursion */
    if (janet_gc_reachable(table))
        return;
    janet_gc_mark(table);
    enum JanetMemoryType memtype = janet_gc_type(table);
    if (memtype == JANET_MEMORY_TABLE_WEAKK) {
        janet_mark_values(table->data, table->capacity);
    } else if (memtype == JANET_MEMORY_TABLE_WEAKV) {
        janet_mark_keys(table->data, table->capacity);
    } else if (memtype == JANET_MEMORY_TABLE) {
        janet_mark_kvs(table->data, table->capacity);
    }
    /* do nothing for JANET_MEMORY_TABLE_WEAKKV */
    if (table->proto) {
        table = table->proto;
        goto recur;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
andl $0x100, %eax            # imm = 0x100
cmpl $0x0, %eax
je 0x38e31
jmp 0x38ebf
movq -0x8(%rbp), %rax
movl (%rax), %ecx
orl $0x100, %ecx            # imm = 0x100
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
movl %eax, -0xc(%rbp)
cmpl $0xe, -0xc(%rbp)
jne 0x38e69
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x14(%rax), %esi
callq 0x3aeb0
jmp 0x38ea3
cmpl $0xf, -0xc(%rbp)
jne 0x38e85
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x14(%rax), %esi
callq 0x3af00
jmp 0x38ea1
cmpl $0x5, -0xc(%rbp)
jne 0x38e9f
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x14(%rax), %esi
callq 0x3af50
jmp 0x38ea1
jmp 0x38ea3
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x38ebf
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x38e1c
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/gc.c
// Function: janet_mark_struct
static void janet_mark_struct(const JanetKV *st) {
recur:
    if (janet_gc_reachable(janet_struct_head(st)))
        return;
    janet_gc_mark(janet_struct_head(st));
    janet_mark_kvs(st, janet_struct_capacity(st));
    st = janet_struct_proto(st);
    if (st) goto recur;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl -0x28(%rax), %eax
andl $0x100, %eax            # imm = 0x100
cmpl $0x0, %eax
je 0x38eef
jmp 0x38f24
movq -0x8(%rbp), %rax
movl -0x28(%rax), %ecx
orl $0x100, %ecx            # imm = 0x100
movl %ecx, -0x28(%rax)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movl -0x10(%rax), %esi
callq 0x3af50
movq -0x8(%rbp), %rax
movq -0x8(%rax), %rax
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x38f24
jmp 0x38edc
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/gc.c
// Function: janet_mark_tuple
static void janet_mark_tuple(const Janet *tuple) {
    if (janet_gc_reachable(janet_tuple_head(tuple)))
        return;
    janet_gc_mark(janet_tuple_head(tuple));
    janet_mark_many(tuple, janet_tuple_length(tuple));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl -0x20(%rax), %eax
andl $0x100, %eax            # imm = 0x100
cmpl $0x0, %eax
je 0x38f4f
jmp 0x38f6f
movq -0x8(%rbp), %rax
movl -0x20(%rax), %ecx
orl $0x100, %ecx            # imm = 0x100
movl %ecx, -0x20(%rax)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movl -0x10(%rax), %esi
callq 0x3ae50
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/gc.c
// Function: janet_mark_abstract
static void janet_mark_abstract(void *adata) {
#ifdef JANET_EV
    /* Check if abstract type is a threaded abstract type. If it is, marking means
     * updating the threaded_abstract table. */
    if ((janet_abstract_head(adata)->gc.flags & JANET_MEM_TYPEBITS) == JANET_MEMORY_THREADED_ABSTRACT) {
        janet_table_put(&janet_vm.threaded_abstracts, janet_wrap_abstract(adata), janet_wrap_true());
        return;
    }
#endif
    if (janet_gc_reachable(janet_abstract_head(adata)))
        return;
    janet_gc_mark(janet_abstract_head(adata));
    if (janet_abstract_head(adata)->type->gcmark) {
        janet_abstract_head(adata)->type->gcmark(adata, janet_abstract_size(adata));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl -0x20(%rax), %eax
andl $0xff, %eax
cmpl $0xd, %eax
jne 0x391a4
movq %fs:0x0, %rax
leaq -0x348(%rax), %rax
addq $0x268, %rax            # imm = 0x268
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movabsq $-0x1000000000000, %rsi # imm = 0xFFFF000000000000
callq 0x7b610
movq %rax, -0x10(%rbp)
movabsq $-0x6ffffffffffff, %rdi # imm = 0xFFF9000000000001
callq 0x7b460
movq -0x20(%rbp), %rdi
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x697e0
jmp 0x391f0
movq -0x8(%rbp), %rax
movl -0x20(%rax), %eax
andl $0x100, %eax            # imm = 0x100
cmpl $0x0, %eax
je 0x391b7
jmp 0x391f0
movq -0x8(%rbp), %rax
movl -0x20(%rax), %ecx
orl $0x100, %ecx            # imm = 0x100
movl %ecx, -0x20(%rax)
movq -0x8(%rbp), %rax
movq -0x10(%rax), %rax
cmpq $0x0, 0x10(%rax)
je 0x391f0
movq -0x8(%rbp), %rax
movq -0x10(%rax), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rcx
movq -0x8(%rcx), %rsi
callq *%rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/gc.c
// Function: janet_gcroot
void janet_gcroot(Janet root) {
    size_t newcount = janet_vm.root_count + 1;
    if (newcount > janet_vm.root_capacity) {
        size_t newcap = 2 * newcount;
        janet_vm.roots = janet_realloc(janet_vm.roots, sizeof(Janet) * newcap);
        if (NULL == janet_vm.roots) {
            JANET_OUT_OF_MEMORY;
        }
        janet_vm.root_capacity = newcap;
    }
    janet_vm.roots[janet_vm.root_count] = root;
    janet_vm.root_count = newcount;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %fs:0x0, %rax
leaq -0x348(%rax), %rax
movq 0xc8(%rax), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq %fs:0x0, %rax
leaq -0x348(%rax), %rax
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq 0xd0(%rcx), %rax
jbe 0x39316
movq -0x10(%rbp), %rax
shlq %rax
movq %rax, -0x18(%rbp)
movq %fs:0x0, %rax
leaq -0x348(%rax), %rax
movq 0xc0(%rax), %rdi
movq -0x18(%rbp), %rsi
shlq $0x3, %rsi
callq 0x12840
movq %rax, -0x28(%rbp)
movq %fs:0x0, %rax
leaq -0x348(%rax), %rax
movq -0x28(%rbp), %rcx
movq %rcx, 0xc0(%rax)
movq %fs:0x0, %rax
leaq -0x348(%rax), %rax
movq %rax, %rcx
xorl %eax, %eax
cmpq 0xc0(%rcx), %rax
jne 0x392f3
jmp 0x392c5
movq 0x76d24(%rip), %rax     # 0xafff0
movq (%rax), %rdi
leaq 0x44d2e(%rip), %rsi     # 0x7e004
leaq 0x51a73(%rip), %rdx     # 0x8ad50
movl $0x268, %ecx            # imm = 0x268
movb $0x0, %al
callq 0x125f0
movl $0x1, %edi
callq 0x12a70
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq %fs:0x0, %rax
leaq -0x348(%rax), %rax
movq -0x30(%rbp), %rcx
movq %rcx, 0xd0(%rax)
movq %fs:0x0, %rax
leaq -0x348(%rax), %rax
movq 0xc0(%rax), %rax
movq %rax, -0x40(%rbp)
movq %fs:0x0, %rax
leaq -0x348(%rax), %rax
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq 0xc8(%rcx), %rcx
movq -0x8(%rbp), %rdx
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq %fs:0x0, %rax
leaq -0x348(%rax), %rax
movq -0x38(%rbp), %rcx
movq %rcx, 0xc8(%rax)
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/gc.c
// Function: janet_check_liveref
static int janet_check_liveref(Janet x) {
    switch (janet_type(x)) {
        default:
            return 1;
        case JANET_ARRAY:
        case JANET_TABLE:
        case JANET_FUNCTION:
        case JANET_BUFFER:
        case JANET_FIBER:
            return janet_gc_reachable(janet_unwrap_pointer(x));
        case JANET_STRING:
        case JANET_SYMBOL:
        case JANET_KEYWORD:
            return janet_gc_reachable(janet_string_head(janet_unwrap_string(x)));
        case JANET_ABSTRACT:
            return janet_gc_reachable(janet_abstract_head(janet_unwrap_abstract(x)));
        case JANET_TUPLE:
            return janet_gc_reachable(janet_tuple_head(janet_unwrap_tuple(x)));
        case JANET_STRUCT:
            return janet_gc_reachable(janet_struct_head(janet_unwrap_struct(x)));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movsd -0x10(%rbp), %xmm0
ucomisd %xmm0, %xmm0
setp %al
testb $0x1, %al
jne 0x39bae
jmp 0x39bbf
movq -0x10(%rbp), %rax
shrq $0x2f, %rax
andq $0xf, %rax
movl %eax, -0x14(%rbp)
jmp 0x39bc6
xorl %eax, %eax
movl %eax, -0x14(%rbp)
jmp 0x39bc6
movl -0x14(%rbp), %eax
addl $-0x3, %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0xb, %eax
ja 0x39beb
movq -0x20(%rbp), %rax
leaq 0x510fe(%rip), %rcx     # 0x8ace0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x1, -0x4(%rbp)
jmp 0x39c5f
movq -0x10(%rbp), %rdi
callq 0x7b260
movl (%rax), %eax
andl $0x100, %eax            # imm = 0x100
movl %eax, -0x4(%rbp)
jmp 0x39c5f
movq -0x10(%rbp), %rdi
callq 0x7b260
movl -0x18(%rax), %eax
andl $0x100, %eax            # imm = 0x100
movl %eax, -0x4(%rbp)
jmp 0x39c5f
movq -0x10(%rbp), %rdi
callq 0x7b260
movl -0x20(%rax), %eax
andl $0x100, %eax            # imm = 0x100
movl %eax, -0x4(%rbp)
jmp 0x39c5f
movq -0x10(%rbp), %rdi
callq 0x7b260
movl -0x20(%rax), %eax
andl $0x100, %eax            # imm = 0x100
movl %eax, -0x4(%rbp)
jmp 0x39c5f
movq -0x10(%rbp), %rdi
callq 0x7b260
movl -0x28(%rax), %eax
andl $0x100, %eax            # imm = 0x100
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/gc.c
// Function: janet_gcalloc
void *janet_gcalloc(enum JanetMemoryType type, size_t size) {
    JanetGCObject *mem;

    /* Make sure everything is inited */
    janet_assert(NULL != janet_vm.cache, "please initialize janet before use");
    mem = janet_malloc(size);

    /* Check for bad malloc */
    if (NULL == mem) {
        JANET_OUT_OF_MEMORY;
    }

    /* Configure block */
    mem->flags = type;

    /* Prepend block to heap list */
    janet_vm.next_collection += size;
    if (type < JANET_MEMORY_TABLE_WEAKK) {
        /* normal heap */
        mem->data.next = janet_vm.blocks;
        janet_vm.blocks = mem;
    } else {
        /* weak heap */
        mem->data.next = janet_vm.weak_blocks;
        janet_vm.weak_blocks = mem;
    }
    janet_vm.block_count++;

    return (void *)mem;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %fs:0x0, %rax
leaq -0x348(%rax), %rax
movq %rax, %rcx
xorl %eax, %eax
cmpq 0x70(%rcx), %rax
jne 0x39e9c
jmp 0x39e6c
movq 0x7617d(%rip), %rax     # 0xafff0
movq (%rax), %rdi
leaq 0x47197(%rip), %rsi     # 0x81014
movl $0x211, %edx            # imm = 0x211
leaq 0x50ec7(%rip), %rcx     # 0x8ad50
leaq 0x50edf(%rip), %r8      # 0x8ad6f
movb $0x0, %al
callq 0x125f0
callq 0x12100
jmp 0x39e9e
movq -0x10(%rbp), %rdi
callq 0x12770
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
jne 0x39ee3
jmp 0x39eb5
movq 0x76134(%rip), %rax     # 0xafff0
movq (%rax), %rdi
leaq 0x4413e(%rip), %rsi     # 0x7e004
leaq 0x50e83(%rip), %rdx     # 0x8ad50
movl $0x216, %ecx            # imm = 0x216
movb $0x0, %al
callq 0x125f0
movl $0x1, %edi
callq 0x12a70
movl -0x4(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq %fs:0x0, %rax
leaq -0x348(%rax), %rax
movq -0x20(%rbp), %rcx
addq 0xa8(%rax), %rcx
movq %rcx, 0xa8(%rax)
cmpl $0xe, -0x4(%rbp)
jae 0x39f60
movq %fs:0x0, %rax
leaq -0x348(%rax), %rax
movq 0x90(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq %fs:0x0, %rax
leaq -0x348(%rax), %rax
movq -0x28(%rbp), %rcx
movq %rcx, 0x90(%rax)
jmp 0x39fa2
movq %fs:0x0, %rax
leaq -0x348(%rax), %rax
movq 0x98(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq %fs:0x0, %rax
leaq -0x348(%rax), %rax
movq -0x30(%rbp), %rcx
movq %rcx, 0x98(%rax)
movq %fs:0x0, %rax
leaq -0x348(%rax), %rax
movq 0xb0(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0xb0(%rax)
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop