LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/janet-lang[P]janet/src/core/ev.c
// Function: janet_timeout_body
static void *janet_timeout_body(void *ptr) {
#ifdef JANET_ANDROID
    struct sigaction action;
    memset(&action, 0, sizeof(action));
    sigemptyset(&action.sa_mask);
    action.sa_flags = 0;
    action.sa_handler = &janet_timeout_stop;
    sigaction(SIGUSR1, &action, NULL);
#endif
    JanetThreadedTimeout tto = *(JanetThreadedTimeout *)ptr;
    janet_free(ptr);
    struct timespec ts;
    ts.tv_sec = (time_t) tto.sec;
    ts.tv_nsec = (tto.sec <= UINT32_MAX)
                 ? (long)((tto.sec - ((uint32_t)tto.sec)) * 1000000000)
                 : 0;
    nanosleep(&ts, &ts);
    janet_interpreter_interrupt(tto.vm);
    JanetEVGenericMessage msg = {0};
    janet_ev_post_event(tto.vm, janet_timeout_cb, msg);
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x58, %rsp
movsd (%rdi), %xmm0
movsd %xmm0, -0x10(%rbp)
movq 0x8(%rdi), %rbx
callq 0x120b0
movsd -0x10(%rbp), %xmm1
cvttsd2si %xmm1, %rax
movq %rax, -0x40(%rbp)
movsd 0x3287d(%rip), %xmm0    # 0x58f90
ucomisd %xmm1, %xmm0
jae 0x2671d
xorl %eax, %eax
jmp 0x26738
movl %eax, %eax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
subsd %xmm0, %xmm1
mulsd 0x32865(%rip), %xmm1    # 0x58f98
cvttsd2si %xmm1, %rax
leaq -0x40(%rbp), %rdi
movq %rax, 0x8(%rdi)
movq %rdi, %rsi
callq 0x123b0
movq %rbx, %rdi
callq 0x446a7
xorpd %xmm0, %xmm0
movapd %xmm0, -0x20(%rbp)
movapd %xmm0, -0x30(%rbp)
movaps -0x30(%rbp), %xmm0
movaps -0x20(%rbp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
leaq 0x92d(%rip), %rsi       # 0x270a3
movq %rbx, %rdi
callq 0x24172
xorl %eax, %eax
addq $0x58, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/janet-lang[P]janet/src/core/ev.c
// Function: janet_q_push
static int janet_q_push(JanetQueue *q, void *item, size_t itemsize) {
    if (janet_q_maybe_resize(q, itemsize)) return 1;
    memcpy((char *) q->data + itemsize * q->tail, item, itemsize);
    q->tail = q->tail + 1 < q->capacity ? q->tail + 1 : 0;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rdx, %rsi
callq 0x26e6f
movl %eax, %ecx
movl $0x1, %eax
testl %ecx, %ecx
jne 0x26e64
movslq 0x8(%rbx), %rdi
imulq %r14, %rdi
addq 0x10(%rbx), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x12670
movl 0x8(%rbx), %ecx
incl %ecx
xorl %eax, %eax
cmpl (%rbx), %ecx
cmovgel %eax, %ecx
movl %ecx, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/janet-lang[P]janet/src/core/ev.c
// Function: janet_q_maybe_resize
static int janet_q_maybe_resize(JanetQueue *q, size_t itemsize) {
    int32_t count = janet_q_count(q);
    /* Resize if needed */
    if (count + 1 >= q->capacity) {
        if (count + 1 >= JANET_MAX_Q_CAPACITY) return 1;
        int32_t newcap = (count + 2) * 2;
        if (newcap > JANET_MAX_Q_CAPACITY) newcap = JANET_MAX_Q_CAPACITY;
        q->data = janet_realloc(q->data, itemsize * newcap);
        if (NULL == q->data) {
            JANET_OUT_OF_MEMORY;
        }
        if (q->head > q->tail) {
            /* Two segments, fix 2nd seg. */
            int32_t newhead = q->head + (newcap - q->capacity);
            size_t seg1 = (size_t)(q->capacity - q->head);
            if (seg1 > 0) {
                memmove((char *) q->data + (newhead * itemsize),
                        (char *) q->data + (q->head * itemsize),
                        seg1 * itemsize);
            }
            q->head = newhead;
        }
        q->capacity = newcap;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl (%rdi), %edx
movl 0x4(%rdi), %esi
movl 0x8(%rdi), %edi
xorl %eax, %eax
cmpl %edi, %esi
movl $0x0, %ecx
cmovgl %edx, %ecx
addl %edi, %ecx
subl %esi, %ecx
leal 0x1(%rcx), %esi
cmpl %edx, %esi
jl 0x26f19
movl $0x1, %eax
cmpl $0x7fffffd, %ecx        # imm = 0x7FFFFFD
jg 0x26f19
leal 0x4(,%rcx,2), %eax
movl $0x7ffffff, %r15d       # imm = 0x7FFFFFF
cmpl %r15d, %eax
cmovll %eax, %r15d
movq 0x10(%rbx), %rdi
movslq %r15d, %rsi
imulq %r14, %rsi
callq 0x12840
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0x26f22
movslq 0x4(%rbx), %rsi
cmpl 0x8(%rbx), %esi
jle 0x26f14
movl (%rbx), %ecx
movl %r15d, %r12d
subl %ecx, %r12d
addl %esi, %r12d
cmpl %esi, %ecx
je 0x26f10
subl %esi, %ecx
movslq %ecx, %rdx
movslq %r12d, %rdi
imulq %r14, %rdi
addq %rax, %rdi
imulq %r14, %rsi
addq %rax, %rsi
imulq %r14, %rdx
callq 0x12920
movl %r12d, 0x4(%rbx)
movl %r15d, (%rbx)
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x136f0
// File: /workspace/github_c_makefile_star2_O3/janet-lang[P]janet/src/core/ev.c
// Function: janet_chan_unpack
static int janet_chan_unpack(JanetChannel *chan, Janet *x, int is_cleanup) {
    if (!janet_chan_is_threaded(chan)) return 0;
    switch (janet_type(*x)) {
        default:
            return 1;
        case JANET_BUFFER: {
            JanetBuffer *buf = janet_unwrap_buffer(*x);
            int flags = is_cleanup ? (JANET_MARSHAL_UNSAFE | JANET_MARSHAL_DECREF) : JANET_MARSHAL_UNSAFE;
            *x = janet_unmarshal(buf->data, buf->count, flags, NULL, NULL);
            janet_buffer_deinit(buf);
            janet_free(buf);
            return 0;
        }
        case JANET_NIL:
        case JANET_NUMBER:
        case JANET_POINTER:
        case JANET_BOOLEAN:
        case JANET_CFUNCTION:
            return 0;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
xorl %r14d, %r14d
testl %edi, %edi
je 0x26f49
movq %rsi, %rbx
movsd (%rsi), %xmm0
ucomisd %xmm0, %xmm0
jp 0x26f55
xorl %r14d, %r14d
movl %r14d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %xmm0, %rdi
movq %rdi, %rax
shrq $0x2f, %rax
andl $0xf, %eax
movl $0x1, %r14d
cmpl $0xf, %eax
ja 0x26f49
movl $0xa007, %ecx           # imm = 0xA007
btl %eax, %ecx
jb 0x26f46
cmpl $0xb, %eax
jne 0x26f49
movl %edx, %r15d
callq 0x4ebc4
movq %rax, %r12
xorl %edx, %edx
testl %r15d, %r15d
setne %dl
shll $0x12, %edx
orl $0x20000, %edx          # imm = 0x20000
movq 0x18(%rax), %rdi
movslq 0x10(%rax), %rsi
xorl %r14d, %r14d
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x30fa5
movq %rax, (%rbx)
movq %r12, %rdi
callq 0x176e1
movq %r12, %rdi
callq 0x120b0
jmp 0x26f49
// File: /workspace/github_c_makefile_star2_O3/janet-lang[P]janet/src/core/ev.c
// Function: janet_chanat_mark_fq
static void janet_chanat_mark_fq(JanetQueue *fq) {
    JanetChannelPending *pending = fq->data;
    if (fq->head <= fq->tail) {
        for (int32_t i = fq->head; i < fq->tail; i++)
            janet_mark(janet_wrap_fiber(pending[i].fiber));
    } else {
        for (int32_t i = fq->head; i < fq->capacity; i++)
            janet_mark(janet_wrap_fiber(pending[i].fiber));
        for (int32_t i = 0; i < fq->tail; i++)
            janet_mark(janet_wrap_fiber(pending[i].fiber));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %r15
movslq 0x4(%rdi), %r12
movl 0x8(%rdi), %eax
cmpl %eax, %r12d
jle 0x27056
movabsq $-0x6800000000000, %r14 # imm = 0xFFF9800000000000
cmpl (%rbx), %r12d
jge 0x27026
leaq (%r12,%r12,2), %rax
leaq (%r15,%rax,8), %r13
addq $0x8, %r13
movq (%r13), %rdi
movq %r14, %rsi
callq 0x4ed7e
movq %rax, %rdi
callq 0x2aca7
incq %r12
movslq (%rbx), %rax
addq $0x18, %r13
cmpq %rax, %r12
jl 0x27000
movl 0x8(%rbx), %eax
testl %eax, %eax
jle 0x27094
addq $0x8, %r15
xorl %r12d, %r12d
movq (%r15), %rdi
movq %r14, %rsi
callq 0x4ed7e
movq %rax, %rdi
callq 0x2aca7
incq %r12
movslq 0x8(%rbx), %rax
addq $0x18, %r15
cmpq %rax, %r12
jl 0x27031
jmp 0x27094
cmpl %eax, %r12d
jge 0x27094
movabsq $-0x6800000000000, %r14 # imm = 0xFFF9800000000000
leaq (%r12,%r12,2), %rax
leaq (%r15,%rax,8), %r15
addq $0x8, %r15
movq (%r15), %rdi
movq %r14, %rsi
callq 0x4ed7e
movq %rax, %rdi
callq 0x2aca7
incq %r12
movslq 0x8(%rbx), %rax
addq $0x18, %r15
cmpq %rax, %r12
jl 0x27071
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/janet-lang[P]janet/src/core/ffi.c
// Function: signature_mark
int signature_mark(void *p, size_t s) {
    (void) s;
    JanetFFISignature *sig = p;
    for (uint32_t i = 0; i < sig->arg_count; i++) {
        JanetFFIType t = sig->args[i].type;
        if (t.prim == JANET_FFI_TYPE_STRUCT) {
            janet_mark(janet_wrap_abstract(t.st));
        }
    }
    return 0;
}

// Assembly:
movl 0x4(%rdi), %eax
testl %eax, %eax
je 0x27119
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x40(%rdi), %r15
xorl %r12d, %r12d
movabsq $-0x1000000000000, %r14 # imm = 0xFFFF000000000000
cmpl $0xe, (%r15)
jne 0x27103
movq -0x8(%r15), %rdi
movq %r14, %rsi
callq 0x4ed7e
movq %rax, %rdi
callq 0x2aca7
movl 0x4(%rbx), %eax
incq %r12
movl %eax, %ecx
addq $0x20, %r15
cmpq %rcx, %r12
jb 0x270e6
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/janet-lang[P]janet/src/core/ffi.c
// Function: struct_mark
int struct_mark(void *p, size_t s) {
    (void) s;
    JanetFFIStruct *st = p;
    for (uint32_t i = 0; i < st->field_count; i++) {
        JanetFFIType t = st->fields[i].type;
        if (t.prim == JANET_FFI_TYPE_STRUCT) {
            janet_mark(janet_wrap_abstract(t.st));
        }
    }
    return 0;
}

// Assembly:
movl 0x8(%rdi), %eax
testl %eax, %eax
je 0x27175
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x18(%rdi), %r15
xorl %r12d, %r12d
movabsq $-0x1000000000000, %r14 # imm = 0xFFFF000000000000
cmpl $0xe, (%r15)
jne 0x2715f
movq -0x8(%r15), %rdi
movq %r14, %rsi
callq 0x4ed7e
movq %rax, %rdi
callq 0x2aca7
movl 0x8(%rbx), %eax
incq %r12
movl %eax, %ecx
addq $0x18, %r15
cmpq %rcx, %r12
jb 0x27142
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/janet-lang[P]janet/src/core/ffi.c
// Function: janet_ffi_trampoline
void janet_ffi_trampoline(void *ctx, void *userdata) {
    if (NULL == userdata) {
        /* Userdata not set. */
        janet_eprintf("no userdata found for janet callback");
        return;
    }
    Janet context = janet_wrap_pointer(ctx);
    JanetFunction *fun = userdata;
    janet_call(fun, 1, &context);
}

// Assembly:
testq %rsi, %rsi
je 0x271e2
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movabsq $-0x800000000000, %rsi  # imm = 0xFFFF800000000000
callq 0x4ed7e
leaq -0x10(%rbp), %rdx
movq %rax, (%rdx)
movq %rbx, %rdi
movl $0x1, %esi
callq 0x4b70a
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0x5de07(%rip), %rax     # 0x84ff0
movq (%rax), %rsi
leaq 0x3382b(%rip), %rdi     # 0x5aa1e
leaq 0x34da0(%rip), %rdx     # 0x5bf9a
xorl %eax, %eax
jmp 0x2ed91
// File: /workspace/github_c_makefile_star2_O3/janet-lang[P]janet/src/core/ffi.c
// Function: decode_ffi_cc
static JanetFFICallingConvention decode_ffi_cc(const uint8_t *name) {
    if (!janet_cstrcmp(name, "none")) return JANET_FFI_CC_NONE;
#ifdef JANET_FFI_WIN64_ENABLED
    if (!janet_cstrcmp(name, "win64")) return JANET_FFI_CC_WIN_64;
#endif
#ifdef JANET_FFI_SYSV64_ENABLED
    if (!janet_cstrcmp(name, "sysv64")) return JANET_FFI_CC_SYSV_64;
#endif
#ifdef JANET_FFI_AAPCS64_ENABLED
    if (!janet_cstrcmp(name, "aapcs64")) return JANET_FFI_CC_AAPCS64;
#endif
    if (!janet_cstrcmp(name, "default")) return JANET_FFI_CC_DEFAULT;
    janet_panicf("unknown calling convention %s", name);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x34236(%rip), %rsi     # 0x5c0ab
callq 0x4872e
testl %eax, %eax
je 0x27ebb
leaq 0x3421f(%rip), %rsi     # 0x5c0a4
movq %rbx, %rdi
callq 0x4872e
movl $0x1, %r14d
testl %eax, %eax
je 0x27ebe
leaq 0x343e6(%rip), %rsi     # 0x5c284
movq %rbx, %rdi
callq 0x4872e
testl %eax, %eax
je 0x27ebe
leaq 0x343db(%rip), %rdi     # 0x5c28c
movq %rbx, %rsi
xorl %eax, %eax
callq 0x190bb
xorl %r14d, %r14d
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/janet-lang[P]janet/src/core/fiber.c
// Function: janet_fiber_reset
JanetFiber *janet_fiber_reset(JanetFiber *fiber, JanetFunction *callee, int32_t argc, const Janet *argv) {
    int32_t newstacktop;
    fiber_reset(fiber);
    if (argc) {
        newstacktop = fiber->stacktop + argc;
        if (newstacktop >= fiber->capacity) {
            janet_fiber_setcapacity(fiber, 2 * newstacktop);
        }
        if (argv) {
            memcpy(fiber->data + fiber->stacktop, argv, argc * sizeof(Janet));
        } else {
            /* If argv not given, fill with nil */
            for (int32_t i = 0; i < argc; i++) {
                fiber->data[fiber->stacktop + i] = janet_wrap_nil();
            }
        }
        fiber->stacktop = newstacktop;
    }
    /* Don't panic on failure since we use this to implement janet_pcall */
    if (janet_fiber_funcframe(fiber, callee)) return NULL;
    janet_fiber_frame(fiber)->flags |= JANET_STACKFRAME_ENTRANCE;
#ifdef JANET_EV
    fiber->supervisor_channel = NULL;
#endif
    return fiber;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r13
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %rbx
movabsq $-0x77fffffffffff, %r12 # imm = 0xFFF8800000000001
movl $0x7fffffff, 0x24(%rdi) # imm = 0x7FFFFFFF
xorl %eax, %eax
movq %rax, 0x38(%rdi)
movaps 0x330d9(%rip), %xmm0    # 0x5c3d0
movups %xmm0, 0x10(%rdi)
movq %rax, 0x28(%rdi)
movq %r12, %rdi
callq 0x4ece6
movq %rbx, %rdx
movq %rax, 0x40(%rbx)
movl $0x0, 0x48(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%rbx)
movups %xmm0, 0x60(%rbx)
movl $0xffc0ffff, %eax       # imm = 0xFFC0FFFF
andl 0x10(%rbx), %eax
orl $0xe0000, %eax          # imm = 0xE0000
movl %eax, 0x10(%rbx)
testl %r15d, %r15d
je 0x293c7
movl 0x1c(%rdx), %ecx
addl %r15d, %ecx
movq %rcx, -0x38(%rbp)
cmpl 0x20(%rdx), %ecx
movq %rdx, -0x30(%rbp)
jl 0x2935f
movq -0x38(%rbp), %rax
leal (%rax,%rax), %esi
movq %rdx, %rdi
callq 0x29404
movq -0x30(%rbp), %rdx
movq %r14, -0x40(%rbp)
testq %r13, %r13
je 0x29389
movslq 0x1c(%rdx), %rdi
shlq $0x3, %rdi
addq 0x30(%rdx), %rdi
movslq %r15d, %rdx
shlq $0x3, %rdx
movq %r13, %rsi
callq 0x12670
movq -0x30(%rbp), %rdx
jmp 0x293bc
testl %r15d, %r15d
jle 0x293bc
movl %r15d, %ebx
movq %r12, %r15
xorl %r13d, %r13d
movq 0x30(%rdx), %r12
movl 0x1c(%rdx), %eax
addl %r13d, %eax
movslq %eax, %r14
movq %r15, %rdi
callq 0x4ece6
movq -0x30(%rbp), %rdx
movq %rax, (%r12,%r14,8)
incl %r13d
cmpl %r13d, %ebx
jne 0x29397
movq -0x38(%rbp), %rax
movl %eax, 0x1c(%rdx)
movq -0x40(%rbp), %r14
movq %rdx, %rdi
movq %r14, %rsi
movq %rdx, %rbx
callq 0x29466
testl %eax, %eax
je 0x293dd
xorl %eax, %eax
jmp 0x293f5
movq 0x30(%rbx), %rax
movslq 0x14(%rbx), %rcx
orl $0x2, -0x4(%rax,%rcx,8)
movq $0x0, 0x68(%rbx)
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movslq 0x20(%rdi), %r15
movq 0x30(%rdi), %rdi
movslq %esi, %r14
leaq (,%r14,8), %rsi
callq 0x12840
testq %rax, %rax
je 0x29461
movq %r14, %r12
subq %r15, %r12
movq %rax, 0x30(%rbx)
movl %r14d, 0x20(%rbx)
shlq $0x3, %r12
movq %fs:0x0, %rax
leaq -0x348(%rax), %rax
addq %r12, 0xa8(%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x13720
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r14
pushq %rbx
movl 0x1c(%rdi), %eax
cmpl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
je 0x296c4
movq %rsi, %rbx
movq %rdi, %r14
cmpl 0x20(%rdi), %eax
jl 0x296ae
leal (%rax,%rax), %ecx
cmpl $0x40000000, %eax       # imm = 0x40000000
movl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
cmovll %ecx, %esi
movq %r14, %rdi
callq 0x29404
movl 0x1c(%r14), %eax
movq 0x30(%r14), %rcx
leal 0x1(%rax), %edx
movl %edx, 0x1c(%r14)
cltq
movq %rbx, (%rcx,%rax,8)
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x33828(%rip), %rdi     # 0x5cef3
callq 0x191a3
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl 0x1c(%rdi), %eax
cmpl $0x7ffffffe, %eax       # imm = 0x7FFFFFFE
jge 0x29739
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leal 0x2(%rax), %r12d
cmpl 0x20(%rdi), %r12d
jle 0x29715
leal (%r12,%r12), %ecx
cmpl $0x3ffffffe, %eax       # imm = 0x3FFFFFFE
movl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
cmovll %ecx, %esi
movq %r14, %rdi
callq 0x29404
movl 0x1c(%r14), %eax
movq 0x30(%r14), %rcx
cltq
movq %r15, (%rcx,%rax,8)
movq 0x30(%r14), %rax
movslq 0x1c(%r14), %rcx
movq %rbx, 0x8(%rax,%rcx,8)
movl %r12d, 0x1c(%r14)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x337b3(%rip), %rdi     # 0x5cef3
callq 0x191a3
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl 0x1c(%rdi), %eax
cmpl $0x7ffffffd, %eax       # imm = 0x7FFFFFFD
jge 0x297cb
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
leal 0x3(%rax), %r13d
cmpl 0x20(%rdi), %r13d
jle 0x29794
leal (,%r13,2), %ecx
cmpl $0x3ffffffd, %eax       # imm = 0x3FFFFFFD
movl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
cmovll %ecx, %esi
movq %r14, %rdi
callq 0x29404
movl 0x1c(%r14), %eax
movq 0x30(%r14), %rcx
cltq
movq %r12, (%rcx,%rax,8)
movq 0x30(%r14), %rax
movslq 0x1c(%r14), %rcx
movq %r15, 0x8(%rax,%rcx,8)
movq 0x30(%r14), %rax
movslq 0x1c(%r14), %rcx
movq %rbx, 0x10(%rax,%rcx,8)
movl %r13d, 0x1c(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x33721(%rip), %rdi     # 0x5cef3
callq 0x191a3
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl 0x1c(%rdi), %eax
movl %edx, %ecx
xorl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
cmpl %ecx, %eax
jg 0x29849
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %rbx
leal (%rax,%r15), %r12d
cmpl 0x20(%rdi), %r12d
jle 0x29822
leal (%r12,%r12), %eax
cmpl $0x40000000, %r12d      # imm = 0x40000000
movl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
cmovll %eax, %esi
movq %rbx, %rdi
callq 0x29404
movl 0x1c(%rbx), %eax
movslq %eax, %rdi
shlq $0x3, %rdi
addq 0x30(%rbx), %rdi
movslq %r15d, %rdx
shlq $0x3, %rdx
movq %r14, %rsi
callq 0x48567
movl %r12d, 0x1c(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x336a3(%rip), %rdi     # 0x5cef3
callq 0x191a3
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movl %esi, %edi
andl $-0x2, %edi
callq 0x46574
movq %rax, %r15
testl %ebx, %ebx
jle 0x29893
xorl %r12d, %r12d
movq (%r14,%r12,8), %rsi
movq 0x8(%r14,%r12,8), %rdx
movq %r15, %rdi
callq 0x468b5
addq $0x2, %r12
cmpl %ebx, %r12d
jl 0x29879
movq %r15, %rdi
callq 0x468c4
movabsq $-0x3000000000000, %rsi # imm = 0xFFFD000000000000
movq %rax, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x4ed39
// File: /workspace/github_c_makefile_star2_O3/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:
movl 0x1c(%rdi), %ecx
movl $0x1, %eax
testl %ecx, %ecx
js 0x298c2
retq
pushq %rbp
movq %rsp, %rbp
movq 0x10(%rdi), %rdx
movl 0x14(%rdx), %r8d
testl %r8d, %r8d
jle 0x2990a
negl %ecx
movq 0x30(%rdx), %rdx
movl %r8d, %esi
cmpl %ecx, %r8d
jne 0x29900
cmpq %rdi, -0x10(%rdx,%rsi,8)
jne 0x29900
movq -0x20(%rdx,%rsi,8), %r8
testq %r8, %r8
je 0x29900
movq 0x10(%r8), %r8
movl 0x5c(%r8), %r8d
cmpl 0x18(%rdi), %r8d
je 0x29918
movl -0x8(%rdx,%rsi,8), %r8d
testl %r8d, %r8d
jg 0x298d9
addq $0x10, %rdi
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
xorl %eax, %eax
popq %rbp
retq
movl %ecx, 0x1c(%rdi)
jmp 0x29916
// File: /workspace/github_c_makefile_star2_O3/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x298b5
cmpl $0x0, 0x1c(%rbx)
jle 0x29968
movq 0x10(%rbx), %rax
movl 0x10(%rax), %eax
movl %eax, %ecx
andl $0x3c0000, %ecx         # imm = 0x3C0000
cmpl $0x40000, %ecx          # imm = 0x40000
je 0x2995d
shrl $0x10, %eax
andl $0x3f, %eax
cmpl $0x8, %eax
ja 0x29968
movl $0x103, %ecx            # imm = 0x103
btl %eax, %ecx
jae 0x29968
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2997c
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/janet-lang[P]janet/src/core/fiber.c
// Function: janet_env_detach
static void janet_env_detach(JanetFuncEnv *env) {
    /* Check for closure environment */
    if (env) {
        janet_env_valid(env);
        int32_t len = env->length;
        size_t s = sizeof(Janet) * (size_t) len;
        Janet *vmem = janet_malloc(s);
        janet_vm.next_collection += (uint32_t) s;
        if (NULL == vmem) {
            JANET_OUT_OF_MEMORY;
        }
        Janet *values = env->as.fiber->data + env->offset;
        safe_memcpy(vmem, values, s);
        uint32_t *bitset = janet_stack_frame(values)->func->def->closure_bitset;
        if (bitset) {
            /* Clear unneeded references in closure environment */
            for (int32_t i = 0; i < len; i += 32) {
                uint32_t mask = ~(bitset[i >> 5]);
                int32_t maxj = i + 32 > len ? len : i + 32;
                for (int32_t j = i; j < maxj; j++) {
                    if (mask & 1) vmem[j] = janet_wrap_nil();
                    mask >>= 1;
                }
            }
        }
        env->offset = 0;
        env->as.values = vmem;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
testq %rdi, %rdi
je 0x29a9d
movq %rdi, %r14
callq 0x298b5
movslq 0x18(%r14), %r13
leaq (,%r13,8), %r15
movq %r15, %rdi
callq 0x12760
movq %rax, %r12
movl %r15d, %ebx
movq %fs:0x0, %rax
leaq -0x348(%rax), %rax
addq %rbx, 0xa8(%rax)
testq %r12, %r12
je 0x29aac
movq %r12, %rdi
movq 0x10(%r14), %rax
movq 0x30(%rax), %rax
movq %r14, -0x38(%rbp)
movslq 0x1c(%r14), %rcx
leaq (%rax,%rcx,8), %r12
movq %rdi, -0x30(%rbp)
movq %r12, %rsi
movq %r15, %rdx
callq 0x48567
movq -0x20(%r12), %rax
movq 0x10(%rax), %rax
movq 0x30(%rax), %rax
movq %rax, -0x48(%rbp)
testq %rax, %rax
sete %al
testl %r13d, %r13d
setle %cl
orb %al, %cl
jne 0x29a8a
xorl %r14d, %r14d
movq -0x30(%rbp), %rbx
movq %r13, -0x40(%rbp)
leaq 0x20(%r14), %rax
cmpl %r13d, %eax
movq %rax, -0x50(%rbp)
cmovll %eax, %r13d
movq %r14, %rax
shrq $0x3, %rax
movq -0x48(%rbp), %rcx
movl (%rcx,%rax), %r12d
notl %r12d
xorl %r15d, %r15d
testb $0x1, %r12b
je 0x29a67
movabsq $-0x77fffffffffff, %rdi # imm = 0xFFF8800000000001
callq 0x4ece6
movq %rax, (%rbx,%r15,8)
shrl %r12d
incq %r15
leal (%r14,%r15), %eax
cmpl %eax, %r13d
jg 0x29a4e
addq $0x100, %rbx            # imm = 0x100
movq -0x40(%rbp), %r13
movq -0x50(%rbp), %r14
cmpl %r14d, %r13d
jg 0x29a2a
movq -0x38(%rbp), %rax
movl $0x0, 0x1c(%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x10(%rax)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x1377c
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movslq 0x14(%rdi), %r14
testq %r14, %r14
je 0x29dce
movq %rdi, %rbx
movq 0x30(%rdi), %r15
cmpq $0x0, -0x20(%r15,%r14,8)
je 0x29dbd
movq -0x10(%r15,%r14,8), %rdi
callq 0x2997c
movl 0x14(%rbx), %eax
jmp 0x29dc0
movl %r14d, %eax
movl %eax, 0x18(%rbx)
movl %eax, 0x1c(%rbx)
movl -0x8(%r15,%r14,8), %eax
movl %eax, 0x14(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testl %esi, %esi
jle 0x2a401
movq %rdi, %rbx
movl %esi, %r12d
xorl %r13d, %r13d
leaq 0x56f84(%rip), %r15     # 0x81340
xorl %r14d, %r14d
movq (%rbx,%r13,8), %rsi
movq %rsi, %rax
shrq $0x2f, %rax
cmpl $0x1fff6, %eax          # imm = 0x1FFF6
jne 0x2a423
movq %rsi, %rdi
callq 0x4ebc4
movl $0x10, %esi
movl $0x10, %edx
movq %r15, %rdi
movq %rax, %rcx
callq 0x48773
testq %rax, %rax
je 0x2a416
orl 0x8(%rax), %r14d
incq %r13
cmpq %r13, %r12
jne 0x2a3bf
jmp 0x2a404
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%rbx,%r13,8), %rsi
leaq 0x3377d(%rip), %rdi     # 0x5db9e
jmp 0x2a42a
leaq 0x3375b(%rip), %rdi     # 0x5db85
xorl %eax, %eax
callq 0x190bb
// File: /workspace/github_c_makefile_star2_O3/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:
cmpq $0x0, 0x10(%rdi)
je 0x2a7e3
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
movabsq $-0x1000000000000, %r14 # imm = 0xFFFF000000000000
movq %r14, %rsi
callq 0x4ed7e
movq %rax, %rdi
callq 0x2aca7
movq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0x4ed7e
movq %rax, %rdi
callq 0x2aca7
movq 0x8(%rbx), %rdi
movabsq $-0x3800000000000, %rsi # imm = 0xFFFC800000000000
callq 0x4ed7e
movq %rax, %rdi
callq 0x2aca7
popq %rbx
popq %r14
popq %rbp
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl (%rdi), %eax
btl $0x8, %eax
jb 0x2aeb7
movq %rdi, %rbx
orl $0x100, %eax            # imm = 0x100
movl %eax, (%rdi)
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x2aeb7
movslq 0x74(%rdi), %r14
testq %r14, %r14
jle 0x2aea8
xorl %r15d, %r15d
movq 0x18(%rbx,%r15,8), %rdi
callq 0x2bd92
incq %r15
cmpq %r15, %r14
jne 0x2ae92
movq 0x10(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2bdef
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rbx), %eax
btl $0x8, %eax
jb 0x2af5e
movl %eax, %ecx
orl $0x100, %ecx            # imm = 0x100
movl %ecx, (%rbx)
cmpb $0x5, %al
je 0x2af45
movzbl %al, %eax
cmpl $0xf, %eax
je 0x2af1e
cmpl $0xe, %eax
jne 0x2af51
movslq 0x14(%rbx), %r14
testq %r14, %r14
jle 0x2af51
movq 0x20(%rbx), %r15
shlq $0x4, %r14
addq %r15, %r14
movq 0x8(%r15), %rdi
callq 0x2aca7
addq $0x10, %r15
cmpq %r14, %r15
jb 0x2af0a
jmp 0x2af51
movslq 0x14(%rbx), %r14
testq %r14, %r14
jle 0x2af51
movq 0x20(%rbx), %r15
shlq $0x4, %r14
addq %r15, %r14
movq (%r15), %rdi
callq 0x2aca7
addq $0x10, %r15
cmpq %r14, %r15
jb 0x2af32
jmp 0x2af51
movq 0x20(%rbx), %rdi
movl 0x14(%rbx), %esi
callq 0x2bd5b
movq 0x28(%rbx), %rbx
testq %rbx, %rbx
jne 0x2aecf
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/janet-lang[P]janet/src/core/gc.c
// Function: janet_mark_fiber
static void janet_mark_fiber(JanetFiber *fiber) {
    int32_t i, j;
    JanetStackFrame *frame;
recur:
    if (janet_gc_reachable(fiber))
        return;
    janet_gc_mark(fiber);

    janet_mark(fiber->last_value);

    /* Mark values on the argument stack */
    janet_mark_many(fiber->data + fiber->stackstart,
                    fiber->stacktop - fiber->stackstart);

    i = fiber->frame;
    j = fiber->stackstart - JANET_FRAME_SIZE;
    while (i > 0) {
        frame = (JanetStackFrame *)(fiber->data + i - JANET_FRAME_SIZE);
        if (NULL != frame->func)
            janet_mark_function(frame->func);
        if (NULL != frame->env)
            janet_mark_funcenv(frame->env);
        /* Mark all values in the stack frame */
        janet_mark_many(fiber->data + i, j - i);
        j = i - JANET_FRAME_SIZE;
        i = frame->prevframe;
    }

    if (fiber->env)
        janet_mark_table(fiber->env);

#ifdef JANET_EV
    if (fiber->supervisor_channel) {
        janet_mark_abstract(fiber->supervisor_channel);
    }
    if (fiber->ev_stream) {
        janet_mark_abstract(fiber->ev_stream);
    }
    if (fiber->ev_callback) {
        fiber->ev_callback(fiber, JANET_ASYNC_EVENT_MARK);
    }
#endif

    /* Explicit tail recursion */
    if (fiber->child) {
        fiber = fiber->child;
        goto recur;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r12
movl (%r12), %eax
btl $0x8, %eax
jb 0x2b0a0
orl $0x100, %eax            # imm = 0x100
movl %eax, (%r12)
movq 0x40(%r12), %rdi
callq 0x2aca7
movq 0x30(%r12), %rax
movl 0x18(%r12), %r14d
testq %rax, %rax
je 0x2afd7
movslq %r14d, %rcx
movslq 0x1c(%r12), %rdx
subq %rcx, %rdx
testl %edx, %edx
jle 0x2afd7
leaq (%rax,%rcx,8), %rbx
leaq (%rbx,%rdx,8), %r14
movq (%rbx), %rdi
callq 0x2aca7
addq $0x8, %rbx
cmpq %r14, %rbx
jb 0x2afc1
movl 0x18(%r12), %r14d
movl 0x14(%r12), %eax
testl %eax, %eax
jle 0x2b051
movq %r12, -0x30(%rbp)
movl %eax, %r15d
movq 0x30(%r12), %r12
movl %eax, %r13d
movq -0x20(%r12,%r13,8), %rdi
testq %rdi, %rdi
je 0x2affe
callq 0x2ae61
movq -0x10(%r12,%r13,8), %rdi
testq %rdi, %rdi
je 0x2b00d
callq 0x2bd92
addl $-0x4, %r14d
subl %r13d, %r14d
testl %r14d, %r14d
jle 0x2b041
leaq (,%r13,8), %rbx
movq -0x30(%rbp), %rax
addq 0x30(%rax), %rbx
movslq %r14d, %rax
leaq (%rbx,%rax,8), %r14
movq (%rbx), %rdi
callq 0x2aca7
addq $0x8, %rbx
cmpq %r14, %rbx
jb 0x2b030
movl -0x8(%r12,%r13,8), %eax
movl %r15d, %r14d
testl %eax, %eax
movq -0x30(%rbp), %r12
jg 0x2afe4
movq 0x28(%r12), %rdi
testq %rdi, %rdi
je 0x2b060
callq 0x2aec2
movq 0x68(%r12), %rdi
testq %rdi, %rdi
je 0x2b06f
callq 0x2b0af
movq 0x58(%r12), %rdi
testq %rdi, %rdi
je 0x2b07e
callq 0x2b0af
movq 0x50(%r12), %rax
testq %rax, %rax
je 0x2b092
movq %r12, %rdi
movl $0x1, %esi
callq *%rax
movq 0x38(%r12), %r12
testq %r12, %r12
jne 0x2af7a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl -0x20(%rdi), %eax
cmpb $0xd, %al
jne 0x2b10d
movq %fs:0x0, %rax
leaq -0x348(%rax), %rax
leaq 0x268(%rax), %r14
movabsq $-0x1000000000000, %rsi # imm = 0xFFFF000000000000
movq %rbx, %rdi
callq 0x4ed7e
movq %rax, %rbx
movabsq $-0x6ffffffffffff, %rdi # imm = 0xFFF9000000000001
callq 0x4ece6
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
popq %rbx
popq %r14
popq %rbp
jmp 0x476f0
btl $0x8, %eax
jb 0x2b135
orl $0x100, %eax            # imm = 0x100
movl %eax, -0x20(%rbx)
movq -0x10(%rbx), %rax
movq 0x10(%rax), %rax
testq %rax, %rax
je 0x2b135
movq -0x8(%rbx), %rsi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmpq *%rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %fs:0x0, %rax
leaq -0x348(%rax), %rax
movq %rax, %r14
movq 0xc0(%rax), %rax
movq 0xc8(%r14), %rcx
leaq 0x1(%rcx), %r15
cmpq 0xd0(%r14), %r15
jbe 0x2b1a2
movq %r15, %rsi
shlq $0x4, %rsi
movq %rax, %rdi
callq 0x12840
movq %rax, 0xc0(%r14)
testq %rax, %rax
je 0x2b1b8
leaq (%r15,%r15), %rcx
movq %rcx, 0xd0(%r14)
movq 0xc8(%r14), %rcx
movq %rbx, (%rax,%rcx,8)
movq %r15, 0xc8(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x13814
// File: /workspace/github_c_makefile_star2_O3/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
movq %rdi, %xmm0
movq %rdi, %rcx
shrq $0x2f, %rcx
andl $0xf, %ecx
xorl %eax, %eax
ucomisd %xmm0, %xmm0
cmovpl %ecx, %eax
movl $0x1, %ecx
addl $-0x3, %eax
cmpl $0xb, %eax
ja 0x2b58b
leaq 0x3276b(%rip), %rdx     # 0x5dcc0
movslq (%rdx,%rax,4), %rax
addq %rdx, %rax
jmpq *%rax
callq 0x4ebc4
jmp 0x2b584
callq 0x4ebc4
addq $-0x18, %rax
jmp 0x2b584
callq 0x4ebc4
addq $-0x20, %rax
jmp 0x2b584
callq 0x4ebc4
addq $-0x28, %rax
movl $0x100, %ecx            # imm = 0x100
andl (%rax), %ecx
movl %ecx, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movl %edi, %r14d
movq %fs:0x0, %rax
leaq -0x348(%rax), %rax
cmpq $0x0, 0x70(%rax)
je 0x2b6f6
movq %rax, %rbx
movq %r15, %rdi
callq 0x12760
testq %rax, %rax
je 0x2b6fb
addq %r15, 0xa8(%rbx)
movl %r14d, (%rax)
xorl %ecx, %ecx
cmpl $0xe, %r14d
setae %cl
movq 0x90(%rbx,%rcx,8), %rdx
movq %rax, 0x90(%rbx,%rcx,8)
movq %rdx, 0x8(%rax)
incq 0xb0(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x138dc
callq 0x138ac
// File: /workspace/github_c_makefile_star2_O3/janet-lang[P]janet/src/core/gc.c
// Function: janet_collect
void janet_collect(void) {
    uint32_t i;
    if (janet_vm.gc_suspend) return;
    depth = JANET_RECURSION_GUARD;
    janet_vm.gc_mark_phase = 1;
    /* Try to prevent many major collections back to back.
     * A full collection will take O(janet_vm.block_count) time.
     * If we have a large heap, make sure our interval is not too
     * small so we won't make many collections over it. This is just a
     * heuristic for automatically changing the gc interval */
    if (janet_vm.block_count * 8 > janet_vm.gc_interval) {
        janet_vm.gc_interval = janet_vm.block_count * sizeof(JanetGCObject);
    }
    orig_rootcount = janet_vm.root_count;
#ifdef JANET_EV
    janet_ev_mark();
#endif
    janet_mark_fiber(janet_vm.root_fiber);
    for (i = 0; i < orig_rootcount; i++)
        janet_mark(janet_vm.roots[i]);
    while (orig_rootcount < janet_vm.root_count) {
        Janet x = janet_vm.roots[--janet_vm.root_count];
        janet_mark(x);
    }
    janet_vm.gc_mark_phase = 0;
    janet_sweep();
    janet_vm.next_collection = 0;
    janet_free_all_scratch();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %fs:0x0, %rax
leaq -0x348(%rax), %rax
cmpl $0x0, 0xb8(%rax)
je 0x2b72e
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %fs:0x0, %rax
movl $0x400, -0x358(%rax)    # imm = 0x400
movl $0x1, 0xbc(%rbx)
movq 0xb0(%rbx), %rcx
leaq (,%rcx,8), %rdx
cmpq 0xa0(%rbx), %rdx
jbe 0x2b774
shlq $0x4, %rcx
movq %rcx, 0xa0(%rbx)
movq 0xc8(%rbx), %rcx
leaq -0x350(%rax), %r14
movq %rcx, (%r14)
callq 0x2299d
movq 0x28(%rbx), %rdi
callq 0x2af69
cmpq $0x0, (%r14)
je 0x2b7c1
movl $0x1, %r15d
xorl %eax, %eax
movq 0xc0(%rbx), %rcx
movq (%rcx,%rax,8), %rdi
callq 0x2aca7
movl %r15d, %eax
movq (%r14), %rcx
incl %r15d
cmpq %rax, %rcx
ja 0x2b7a1
jmp 0x2b7c3
xorl %ecx, %ecx
movq 0xc8(%rbx), %rax
cmpq %rax, %rcx
jae 0x2b7f7
movq 0xc0(%rbx), %rcx
leaq -0x1(%rax), %rdx
movq %rdx, 0xc8(%rbx)
movq -0x8(%rcx,%rax,8), %rdi
callq 0x2aca7
movq 0xc8(%rbx), %rax
cmpq %rax, (%r14)
jb 0x2b7cf
movl $0x0, 0xbc(%rbx)
callq 0x2b1bd
movq $0x0, 0xa8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2b81d
// File: /workspace/github_c_makefile_star2_O3/janet-lang[P]janet/src/core/gc.c
// Function: janet_gcunroot
int janet_gcunroot(Janet root) {
    Janet *vtop = janet_vm.roots + janet_vm.root_count;
    /* Search from top to bottom as access is most likely LIFO */
    for (Janet *v = janet_vm.roots; v < vtop; v++) {
        if (janet_gc_idequals(root, *v)) {
            *v = janet_vm.roots[--janet_vm.root_count];
            return 1;
        }
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
movq %fs:0x0, %rax
leaq -0x348(%rax), %rax
movq %rax, %r14
movq 0xc8(%rax), %rax
xorl %ebx, %ebx
testq %rax, %rax
jle 0x2b909
movq 0xc0(%r14), %r12
leaq (%r12,%rax,8), %r13
movq (%r12), %rsi
movq %r15, %rdi
callq 0x2b91a
testl %eax, %eax
jne 0x2b8e2
addq $0x8, %r12
cmpq %r13, %r12
jb 0x2b8c7
jmp 0x2b909
movq 0xc0(%r14), %rax
movq 0xc8(%r14), %rcx
leaq -0x1(%rcx), %rdx
movq %rdx, 0xc8(%r14)
movq -0x8(%rax,%rcx,8), %rax
movq %rax, (%r12)
movl $0x1, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/janet-lang[P]janet/src/core/gc.c
// Function: janet_gcunrootall
int janet_gcunrootall(Janet root) {
    Janet *vtop = janet_vm.roots + janet_vm.root_count;
    int ret = 0;
    /* Search from top to bottom as access is most likely LIFO */
    for (Janet *v = janet_vm.roots; v < vtop; v++) {
        if (janet_gc_idequals(root, *v)) {
            *v = janet_vm.roots[--janet_vm.root_count];
            vtop--;
            ret = 1;
        }
    }
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %fs:0x0, %rax
leaq -0x348(%rax), %rax
movq %rax, %r14
movq 0xc8(%rax), %rax
testq %rax, %rax
jle 0x2ba05
movq 0xc0(%r14), %r12
leaq (%r12,%rax,8), %r13
xorl %r15d, %r15d
movq (%r12), %rsi
movq %rbx, %rdi
callq 0x2b91a
testl %eax, %eax
je 0x2b9fa
movq 0xc0(%r14), %rax
movq 0xc8(%r14), %rcx
leaq -0x1(%rcx), %rdx
movq %rdx, 0xc8(%r14)
movq -0x8(%rax,%rcx,8), %rax
movq %rax, (%r12)
addq $-0x8, %r13
movl $0x1, %r15d
addq $0x8, %r12
cmpq %r13, %r12
jb 0x2b9be
jmp 0x2ba08
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq