LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x30a1a(%rip), %xmm0    # 0x54f90
ucomisd %xmm1, %xmm0
jae 0x24580
xorl %eax, %eax
jmp 0x24598
movl %eax, %eax
cvtsi2sd %rax, %xmm0
subsd %xmm0, %xmm1
mulsd 0x30a05(%rip), %xmm1    # 0x54f98
cvttsd2si %xmm1, %rax
leaq -0x40(%rbp), %rdi
movq %rax, 0x8(%rdi)
movq %rdi, %rsi
callq 0x123b0
movq %rbx, %rdi
callq 0x4106c
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 0x918(%rip), %rsi       # 0x24eee
movq %rbx, %rdi
callq 0x22006
xorl %eax, %eax
addq $0x58, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x24c8c
testl %eax, %eax
je 0x24c5b
pushq $0x1
popq %rax
jmp 0x24c81
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_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movl (%rdi), %ecx
movl 0x4(%rdi), %edx
movl 0x8(%rdi), %esi
xorl %ebx, %ebx
cmpl %esi, %edx
movl $0x0, %eax
cmovgl %ecx, %eax
addl %esi, %eax
subl %edx, %eax
leal 0x1(%rax), %edx
cmpl %ecx, %edx
jl 0x24d38
cmpl $0x7fffffd, %eax        # imm = 0x7FFFFFD
jle 0x24cc8
pushq $0x1
popq %rbx
jmp 0x24d38
movq %rdi, %r14
leal 0x4(,%rax,2), %eax
movl $0x7ffffff, %r12d       # imm = 0x7FFFFFF
cmpl %r12d, %eax
cmovll %eax, %r12d
movq 0x10(%rdi), %rdi
movslq %r12d, %rsi
imulq %r15, %rsi
callq 0x12840
movq %rax, 0x10(%r14)
testq %rax, %rax
je 0x24d49
movslq 0x4(%r14), %rsi
cmpl 0x8(%r14), %esi
jle 0x24d35
movl (%r14), %ecx
movl %r12d, %r13d
subl %ecx, %r13d
addl %esi, %r13d
cmpl %esi, %ecx
je 0x24d31
subl %esi, %ecx
movslq %ecx, %rdx
movslq %r13d, %rdi
imulq %r15, %rdi
addq %rax, %rdi
imulq %r15, %rsi
addq %rax, %rsi
imulq %r15, %rdx
callq 0x12920
movl %r13d, 0x4(%r14)
movl %r12d, (%r14)
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x5b2a0(%rip), %rax     # 0x7fff0
movq (%rax), %rdi
leaq 0x282aa(%rip), %rsi     # 0x4d004
leaq 0x31b07(%rip), %rdx     # 0x56868
movl $0x96, %ecx
xorl %eax, %eax
callq 0x125e0
pushq $0x1
popq %rdi
callq 0x12a60
// File: /workspace/github_c_makefile_star2_O2/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
cmpl $0x0, 0x50(%rdi)
je 0x24dad
movq %rsi, %rbx
movsd (%rsi), %xmm0
ucomisd %xmm0, %xmm0
jp 0x24db9
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
pushq $0x1
popq %r14
cmpl $0xf, %eax
ja 0x24dad
movl $0xa007, %ecx           # imm = 0xA007
btl %eax, %ecx
jb 0x24daa
cmpl $0xb, %eax
jne 0x24dad
movl %edx, %r15d
callq 0x4b1f1
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 0x2ee91
movq %rax, (%rbx)
movq %r12, %rdi
callq 0x15f62
movq %r12, %rdi
callq 0x120b0
jmp 0x24dad
// File: /workspace/github_c_makefile_star2_O2/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
movabsq $-0x6800000000000, %r14 # imm = 0xFFF9800000000000
movq 0x10(%rdi), %r15
movslq 0x4(%rdi), %r12
movl 0x8(%rdi), %eax
cmpl %eax, %r12d
jle 0x24eae
imulq $0x18, %r12, %rax
leaq (%rax,%r15), %r13
addq $0x8, %r13
movslq (%rbx), %rax
cmpq %rax, %r12
jge 0x24e82
movq (%r13), %rdi
movq %r14, %rsi
callq 0x4b3ab
movq %rax, %rdi
callq 0x28843
incq %r12
addq $0x18, %r13
jmp 0x24e5d
addq $0x8, %r15
xorl %r12d, %r12d
movslq 0x8(%rbx), %rax
cmpq %rax, %r12
jge 0x24edf
movq (%r15), %rdi
movq %r14, %rsi
callq 0x4b3ab
movq %rax, %rdi
callq 0x28843
incq %r12
addq $0x18, %r15
jmp 0x24e89
imulq $0x18, %r12, %rcx
addq %rcx, %r15
addq $0x8, %r15
cltq
cmpq %rax, %r12
jge 0x24edf
movq (%r15), %rdi
movq %r14, %rsi
callq 0x4b3ab
movq %rax, %rdi
callq 0x28843
incq %r12
movl 0x8(%rbx), %eax
addq $0x18, %r15
jmp 0x24eb9
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
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
movl 0x4(%rbx), %eax
cmpq %rax, %r12
jae 0x24f56
cmpl $0xe, (%r15)
jne 0x24f4d
movq -0x8(%r15), %rdi
movq %r14, %rsi
callq 0x4b3ab
movq %rax, %rdi
callq 0x28843
incq %r12
addq $0x20, %r15
jmp 0x24f2b
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
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
movl 0x8(%rbx), %eax
cmpq %rax, %r12
jae 0x24fab
cmpl $0xe, (%r15)
jne 0x24fa2
movq -0x8(%r15), %rdi
movq %r14, %rsi
callq 0x4b3ab
movq %rax, %rdi
callq 0x28843
incq %r12
addq $0x18, %r15
jmp 0x24f80
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2501e
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movabsq $-0x800000000000, %rsi  # imm = 0xFFFF800000000000
callq 0x4b3ab
leaq -0x10(%rbp), %rdx
movq %rax, (%rdx)
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x47bff
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0x5afcb(%rip), %rax     # 0x7fff0
movq (%rax), %rsi
leaq 0x319ef(%rip), %rdi     # 0x56a1e
leaq 0x32f64(%rip), %rdx     # 0x57f9a
xorl %eax, %eax
jmp 0x2c621
// File: /workspace/github_c_makefile_star2_O2/janet-lang[P]janet/src/core/ffi.c
// Function: type_size
static size_t type_size(JanetFFIType t) {
    size_t count = t.array_count < 0 ? 1 : (size_t) t.array_count;
    if (t.prim == JANET_FFI_TYPE_STRUCT) {
        return t.st->size * count;
    } else {
        return janet_ffi_type_info[t.prim].size * count;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rsi, %rcx
sarq $0x20, %rcx
testq %rsi, %rsi
movabsq $0x1, %rax
cmovnsq %rcx, %rax
movl %esi, %ecx
cmpq $0xe, %rcx
jne 0x25340
movl (%rdi), %ecx
imulq %rcx, %rax
jmp 0x25350
shlq $0x4, %rcx
leaq 0x32b55(%rip), %rdx     # 0x57ea0
imulq (%rcx,%rdx), %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x324d6(%rip), %rsi     # 0x580ab
callq 0x44ca9
testl %eax, %eax
je 0x25c19
leaq 0x324bf(%rip), %rsi     # 0x580a4
movq %rbx, %rdi
callq 0x44ca9
pushq $0x1
popq %r14
testl %eax, %eax
je 0x25c1c
leaq 0x32688(%rip), %rsi     # 0x58284
movq %rbx, %rdi
callq 0x44ca9
testl %eax, %eax
je 0x25c1c
leaq 0x3267d(%rip), %rdi     # 0x5828c
movq %rbx, %rsi
xorl %eax, %eax
callq 0x176c9
xorl %r14d, %r14d
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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, -0x38(%rbp)
movq %rdi, %rbx
movabsq $-0x77fffffffffff, %rdi # imm = 0xFFF8800000000001
movl $0x7fffffff, 0x24(%rbx) # imm = 0x7FFFFFFF
andq $0x0, 0x38(%rbx)
movaps 0x314c1(%rip), %xmm0    # 0x583d0
movups %xmm0, 0x10(%rbx)
andq $0x0, 0x28(%rbx)
callq 0x4b313
movq %rax, 0x40(%rbx)
andl $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 0x26f8a
movl 0x1c(%rbx), %ecx
addl %r15d, %ecx
movq %rcx, -0x30(%rbp)
cmpl 0x20(%rbx), %ecx
jl 0x26f63
movq -0x30(%rbp), %rax
leal (%rax,%rax), %esi
movq %rbx, %rdi
callq 0x26ff6
testq %r13, %r13
je 0x26fc2
movslq 0x1c(%rbx), %rdi
shlq $0x3, %rdi
addq 0x30(%rbx), %rdi
movslq %r15d, %rdx
shlq $0x3, %rdx
movq %r13, %rsi
callq 0x12670
movq -0x30(%rbp), %rax
movl %eax, 0x1c(%rbx)
movq %rbx, %rdi
movq -0x38(%rbp), %rsi
callq 0x2707d
testl %eax, %eax
je 0x26f9e
xorl %ebx, %ebx
jmp 0x26fb0
movq 0x30(%rbx), %rax
movslq 0x14(%rbx), %rcx
orl $0x2, -0x4(%rax,%rcx,8)
andq $0x0, 0x68(%rbx)
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %r13d, %r13d
testl %r15d, %r15d
cmovlel %r13d, %r15d
cmpl %r13d, %r15d
je 0x26f83
movq 0x30(%rbx), %r14
movl 0x1c(%rbx), %eax
addl %r13d, %eax
movslq %eax, %r12
movabsq $-0x77fffffffffff, %rdi # imm = 0xFFF8800000000001
callq 0x4b313
movq %rax, (%r14,%r12,8)
incl %r13d
jmp 0x26fcc
// File: /workspace/github_c_makefile_star2_O2/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 0x27053
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
movq 0x58f96(%rip), %rax     # 0x7fff0
movq (%rax), %rdi
leaq 0x25fa0(%rip), %rsi     # 0x4d004
leaq 0x31e77(%rip), %rdx     # 0x58ee2
pushq $0x7a
popq %rcx
xorl %eax, %eax
callq 0x125e0
pushq $0x1
popq %rdi
callq 0x12a60
// File: /workspace/github_c_makefile_star2_O2/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
movq %rsi, %rbx
movl 0x1c(%rdi), %esi
cmpl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
je 0x272ba
movq %rdi, %r14
cmpl 0x20(%rdi), %esi
jl 0x272a3
movq %r14, %rdi
callq 0x272c6
movl 0x1c(%r14), %esi
movq 0x30(%r14), %rax
leal 0x1(%rsi), %ecx
movl %ecx, 0x1c(%r14)
movslq %esi, %rcx
movq %rbx, (%rax,%rcx,8)
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x31c32(%rip), %rdi     # 0x58ef3
callq 0x177b1
// File: /workspace/github_c_makefile_star2_O2/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 0x2733c
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leal 0x2(%rax), %r12d
cmpl 0x20(%rdi), %r12d
jle 0x27318
movq %r14, %rdi
movl %r12d, %esi
callq 0x272c6
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 0x31bb0(%rip), %rdi     # 0x58ef3
callq 0x177b1
// File: /workspace/github_c_makefile_star2_O2/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 0x273bc
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
leal 0x3(%rax), %r13d
cmpl 0x20(%rdi), %r13d
jle 0x27385
movq %r14, %rdi
movl %r13d, %esi
callq 0x272c6
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 0x31b30(%rip), %rdi     # 0x58ef3
callq 0x177b1
// File: /workspace/github_c_makefile_star2_O2/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 0x2742a
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %rbx
leal (%rax,%r15), %r12d
cmpl 0x20(%rdi), %r12d
jle 0x27403
movq %rbx, %rdi
movl %r12d, %esi
callq 0x272c6
movl 0x1c(%rbx), %eax
movslq %eax, %rdi
shlq $0x3, %rdi
addq 0x30(%rbx), %rdi
movslq %r15d, %rdx
shlq $0x3, %rdx
movq %r14, %rsi
callq 0x44ae2
movl %r12d, 0x1c(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x31ac2(%rip), %rdi     # 0x58ef3
callq 0x177b1
// File: /workspace/github_c_makefile_star2_O2/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, %r15d
movq %rdi, %rbx
movl %esi, %edi
andl $-0x2, %edi
callq 0x42cb8
movq %rax, %r14
movslq %r15d, %r15
xorl %r12d, %r12d
cmpq %r15, %r12
jge 0x27476
movq (%rbx,%r12,8), %rsi
movq 0x8(%rbx,%r12,8), %rdx
movq %r14, %rdi
callq 0x4300f
addq $0x2, %r12
jmp 0x2745a
movq %r14, %rdi
callq 0x4301e
movabsq $-0x3000000000000, %rsi # imm = 0xFFFD000000000000
movq %rax, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x4b366
// File: /workspace/github_c_makefile_star2_O2/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 0x274a5
retq
pushq %rbp
movq %rsp, %rbp
negl %ecx
leaq 0x10(%rdi), %rdx
movq 0x10(%rdi), %rsi
leaq 0x14(%rsi), %r8
movslq (%r8), %r9
testq %r9, %r9
jle 0x274f2
movq %r9, %r8
shlq $0x3, %r8
addq 0x30(%rsi), %r8
cmpl %ecx, %r9d
jne 0x274ec
cmpq %rdi, -0x10(%r8)
jne 0x274ec
movq -0x20(%r8), %r9
testq %r9, %r9
je 0x274ec
movq 0x10(%r9), %r9
movl 0x5c(%r9), %r9d
cmpl 0x18(%rdi), %r9d
je 0x274fc
addq $-0x8, %r8
jmp 0x274b7
xorps %xmm0, %xmm0
movups %xmm0, (%rdx)
xorl %eax, %eax
popq %rbp
retq
movl %ecx, 0x1c(%rdi)
jmp 0x274fa
// File: /workspace/github_c_makefile_star2_O2/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 0x27498
cmpl $0x0, 0x1c(%rbx)
jle 0x2754c
movq 0x10(%rbx), %rax
movl 0x10(%rax), %eax
movl %eax, %ecx
andl $0x3c0000, %ecx         # imm = 0x3C0000
cmpl $0x40000, %ecx          # imm = 0x40000
je 0x27541
shrl $0x10, %eax
andl $0x3f, %eax
cmpl $0x8, %eax
ja 0x2754c
movl $0x103, %ecx            # imm = 0x103
btl %eax, %ecx
jae 0x2754c
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x27560
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x27667
movq %rdi, %r12
callq 0x27498
movslq 0x18(%r12), %r13
leaq (,%r13,8), %r15
movq %r15, %rdi
callq 0x12760
movq %rax, %r14
movl %r15d, %ebx
movq %fs:0x0, %rax
leaq -0x348(%rax), %rax
addq %rbx, 0xa8(%rax)
testq %r14, %r14
je 0x27676
movq 0x10(%r12), %rax
movq 0x30(%rax), %rax
movq %r12, -0x30(%rbp)
movslq 0x1c(%r12), %rcx
leaq (%rax,%rcx,8), %r12
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x44ae2
movq -0x20(%r12), %rax
movq 0x10(%rax), %rax
movq 0x30(%rax), %rax
movq %rax, -0x40(%rbp)
testq %rax, %rax
je 0x2765b
xorl %ebx, %ebx
movabsq $-0x77fffffffffff, %r15 # imm = 0xFFF8800000000001
movq %r13, -0x38(%rbp)
cmpq %r13, %rbx
jge 0x2765b
movq %rbx, %rax
shrq $0x3, %rax
movq -0x40(%rbp), %rcx
movl (%rcx,%rax), %r12d
notl %r12d
leaq 0x20(%rbx), %rcx
cmpl %r13d, %ecx
movl %r13d, %eax
movq %rcx, -0x48(%rbp)
cmovll %ecx, %eax
movslq %eax, %r13
cmpq %r13, %rbx
jge 0x27651
testb $0x1, %r12b
je 0x27649
movq %r15, %rdi
callq 0x4b313
movq %rax, (%r14,%rbx,8)
shrl %r12d
incq %rbx
jmp 0x27632
movq -0x48(%rbp), %rbx
movq -0x38(%rbp), %r13
jmp 0x27607
movq -0x30(%rbp), %rax
andl $0x0, 0x1c(%rax)
movq %r14, 0x10(%rax)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x58973(%rip), %rax     # 0x7fff0
movq (%rax), %rdi
leaq 0x2597d(%rip), %rsi     # 0x4d004
leaq 0x31854(%rip), %rdx     # 0x58ee2
movl $0x106, %ecx            # imm = 0x106
xorl %eax, %eax
callq 0x125e0
pushq $0x1
popq %rdi
callq 0x12a60
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl 0x14(%rdi), %r12d
movl 0x18(%rdi), %eax
movslq %eax, %r15
movl 0x1c(%rdi), %r13d
addl $0x4, %r13d
cmpl %r13d, 0x20(%rdi)
jge 0x278fa
leal (,%r13,2), %esi
movq %r14, %rdi
callq 0x26ff6
movl %r15d, 0x14(%r14)
movl %r13d, 0x18(%r14)
movl %r13d, 0x1c(%r14)
movq 0x30(%r14), %rax
movl %r12d, -0x8(%rax,%r15,8)
movq %rbx, -0x18(%rax,%r15,8)
andq $0x0, -0x20(%rax,%r15,8)
andq $0x0, -0x10(%rax,%r15,8)
andl $0x0, -0x4(%rax,%r15,8)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x27977
movq %rdi, %rbx
movq 0x30(%rdi), %r15
cmpq $0x0, -0x20(%r15,%r14,8)
je 0x27966
movq -0x10(%r15,%r14,8), %rdi
callq 0x27560
movl 0x14(%rbx), %eax
jmp 0x27969
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_O2/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
movl %esi, %ebx
xorl %r15d, %r15d
testl %esi, %esi
cmovlel %r15d, %ebx
movq %rdi, %r14
pushq $0x10
popq %r12
xorl %r13d, %r13d
cmpq %r15, %rbx
je 0x27f8c
movq (%r14,%r15,8), %rsi
movq %rsi, %rax
shrq $0x2f, %rax
cmpl $0x1fff6, %eax          # imm = 0x1FFF6
jne 0x27fab
movq %rsi, %rdi
callq 0x4b1f1
leaq 0x543d0(%rip), %rdi     # 0x7c340
movq %r12, %rsi
movq %r12, %rdx
movq %rax, %rcx
callq 0x44cee
testq %rax, %rax
je 0x27f9e
orl 0x8(%rax), %r13d
incq %r15
jmp 0x27f4a
movl %r13d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%r14,%r15,8), %rsi
leaq 0x31bf5(%rip), %rdi     # 0x59b9e
jmp 0x27fb2
leaq 0x31bd3(%rip), %rdi     # 0x59b85
xorl %eax, %eax
callq 0x176c9
// File: /workspace/github_c_makefile_star2_O2/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 0x2837f
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
movabsq $-0x1000000000000, %r14 # imm = 0xFFFF000000000000
movq %r14, %rsi
callq 0x4b3ab
movq %rax, %rdi
callq 0x28843
movq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0x4b3ab
movq %rax, %rdi
callq 0x28843
movq 0x8(%rbx), %rdi
movabsq $-0x3800000000000, %rsi # imm = 0xFFFC800000000000
callq 0x4b3ab
movq %rax, %rdi
callq 0x28843
popq %rbx
popq %r14
popq %rbp
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq %fs:0x0, %rax
movl -0x358(%rax), %ecx
testl %ecx, %ecx
je 0x288b4
leaq -0x358(%rax), %r14
decl %ecx
movl %ecx, (%r14)
movq %rbx, %xmm0
movq %rbx, %rcx
shrq $0x2f, %rcx
andl $0xf, %ecx
xorl %eax, %eax
ucomisd %xmm0, %xmm0
cmovpl %ecx, %eax
addl $-0x3, %eax
cmpl $0xb, %eax
ja 0x289a5
leaq 0x313f6(%rip), %rcx     # 0x59c90
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rbx, %rdi
callq 0x4b1f1
orb $0x1, -0x17(%rax)
jmp 0x289a5
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x28c2a
movq %rbx, %rdi
callq 0x4b1f1
orb $0x1, 0x1(%rax)
jmp 0x289a5
movq %rbx, %rdi
callq 0x4b1f1
movq %rax, %rdi
callq 0x28a12
jmp 0x289a5
movq %rbx, %rdi
callq 0x4b1f1
movq %rax, %rdi
callq 0x28b9f
jmp 0x289a5
movq %rbx, %rdi
callq 0x4b1f1
movq %rax, %rdi
callq 0x28aa7
jmp 0x289a5
movq %rbx, %rdi
callq 0x4b1f1
movl (%rax), %ecx
btl $0x8, %ecx
jb 0x289a5
movl %ecx, %edx
orl $0x100, %edx            # imm = 0x100
movl %edx, (%rax)
cmpb $0x3, %cl
jne 0x289a5
movq 0x18(%rax), %rdi
movl 0x10(%rax), %esi
jmp 0x2895c
movq %rbx, %rdi
callq 0x4b1f1
movl -0x20(%rax), %ecx
btl $0x8, %ecx
jb 0x289a5
orl $0x100, %ecx            # imm = 0x100
movl %ecx, -0x20(%rax)
movl -0x10(%rax), %esi
movq %rax, %rdi
callq 0x2998a
jmp 0x289a5
movq %rbx, %rdi
callq 0x4b1f1
movq %rax, %rbx
movl -0x28(%rbx), %eax
btl $0x8, %eax
jb 0x289a5
orl $0x100, %eax            # imm = 0x100
movl %eax, -0x28(%rbx)
movl -0x10(%rbx), %esi
movq %rbx, %rdi
callq 0x299b8
movq -0x8(%rbx), %rbx
testq %rbx, %rbx
jne 0x2896e
jmp 0x289a5
movq %rbx, %rdi
callq 0x4b1f1
movq %rax, %rdi
callq 0x289ad
incl (%r14)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x289f4
movq %rdi, %rbx
orl $0x100, %eax            # imm = 0x100
movl %eax, (%rdi)
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x289f4
movl 0x74(%rax), %r14d
xorl %r15d, %r15d
testl %r14d, %r14d
cmovlel %r15d, %r14d
cmpq %r15, %r14
je 0x289ff
movq 0x18(%rbx,%r15,8), %rdi
callq 0x299ed
incq %r15
jmp 0x289e0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x10(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x29a34
// File: /workspace/github_c_makefile_star2_O2/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 0x28a9c
movl %eax, %ecx
orl $0x100, %ecx            # imm = 0x100
movl %ecx, (%rbx)
cmpb $0x5, %al
je 0x28a87
movzbl %al, %eax
cmpl $0xf, %eax
je 0x28a65
cmpl $0xe, %eax
jne 0x28a93
movq 0x20(%rbx), %r14
movslq 0x14(%rbx), %r15
shlq $0x4, %r15
addq %r14, %r15
cmpq %r15, %r14
jae 0x28a93
movq 0x8(%r14), %rdi
callq 0x28843
addq $0x10, %r14
jmp 0x28a51
movq 0x20(%rbx), %r14
movslq 0x14(%rbx), %r15
shlq $0x4, %r15
addq %r14, %r15
cmpq %r15, %r14
jae 0x28a93
movq (%r14), %rdi
callq 0x28843
addq $0x10, %r14
jmp 0x28a74
movq 0x20(%rbx), %rdi
movl 0x14(%rbx), %esi
callq 0x299b8
movq 0x28(%rbx), %rbx
testq %rbx, %rbx
jne 0x28a1f
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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, %rbx
pushq $0x1
popq %r14
movl (%rbx), %eax
btl $0x8, %eax
jb 0x28b90
orl $0x100, %eax            # imm = 0x100
movl %eax, (%rbx)
movq 0x40(%rbx), %rdi
callq 0x28843
movslq 0x18(%rbx), %rdi
movl 0x1c(%rbx), %esi
subl %edi, %esi
shlq $0x3, %rdi
addq 0x30(%rbx), %rdi
callq 0x2998a
leaq 0x14(%rbx), %r13
movl 0x18(%rbx), %r15d
movslq (%r13), %r12
testq %r12, %r12
jle 0x28b48
movq 0x30(%rbx), %r13
movq -0x20(%r13,%r12,8), %rdi
testq %rdi, %rdi
je 0x28b12
callq 0x289ad
leaq (%r13,%r12,8), %r13
movq -0x10(%r13), %rdi
testq %rdi, %rdi
je 0x28b25
callq 0x299ed
addl $-0x4, %r15d
movq %r12, %rdi
shlq $0x3, %rdi
addq 0x30(%rbx), %rdi
subl %r12d, %r15d
movl %r15d, %esi
callq 0x2998a
addq $-0x8, %r13
movl %r12d, %r15d
jmp 0x28af6
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x28b56
callq 0x28a12
movq 0x68(%rbx), %rdi
testq %rdi, %rdi
je 0x28b64
callq 0x28b9f
movq 0x58(%rbx), %rdi
testq %rdi, %rdi
je 0x28b72
callq 0x28b9f
movq 0x50(%rbx), %rax
testq %rax, %rax
je 0x28b83
movq %rbx, %rdi
movl %r14d, %esi
callq *%rax
movq 0x38(%rbx), %rbx
testq %rbx, %rbx
jne 0x28abc
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x28bfd
movq %fs:0x0, %rax
leaq -0x348(%rax), %rax
leaq 0x268(%rax), %r14
movabsq $-0x1000000000000, %rsi # imm = 0xFFFF000000000000
movq %rbx, %rdi
callq 0x4b3ab
movq %rax, %rbx
movabsq $-0x6ffffffffffff, %rdi # imm = 0xFFF9000000000001
callq 0x4b313
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
popq %rbx
popq %r14
popq %rbp
jmp 0x43e19
btl $0x8, %eax
jb 0x28c25
orl $0x100, %eax            # imm = 0x100
movl %eax, -0x20(%rbx)
movq -0x10(%rbx), %rax
movq 0x10(%rax), %rax
testq %rax, %rax
je 0x28c25
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_O2/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 0x28c92
movq %r15, %rsi
shlq $0x4, %rsi
movq %rax, %rdi
callq 0x12840
movq %rax, 0xc0(%r14)
testq %rax, %rax
je 0x28ca8
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
movq 0x57341(%rip), %rax     # 0x7fff0
movq (%rax), %rdi
leaq 0x2434b(%rip), %rsi     # 0x4d004
leaq 0x31070(%rip), %rdx     # 0x59d30
movl $0x268, %ecx            # imm = 0x268
xorl %eax, %eax
callq 0x125e0
pushq $0x1
popq %rdi
callq 0x12a60
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rcx
addl $-0x3, %eax
cmpl $0xb, %eax
ja 0x2907a
leaq 0x30c7c(%rip), %rdx     # 0x59cc0
movslq (%rdx,%rax,4), %rax
addq %rdx, %rax
jmpq *%rax
callq 0x4b1f1
jmp 0x29073
callq 0x4b1f1
addq $-0x18, %rax
jmp 0x29073
callq 0x4b1f1
addq $-0x20, %rax
jmp 0x29073
callq 0x4b1f1
addq $-0x28, %rax
movl $0x100, %ecx            # imm = 0x100
andl (%rax), %ecx
movl %ecx, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x29210
movq %rax, %rbx
movq %r15, %rdi
callq 0x12760
testq %rax, %rax
je 0x29240
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
movq 0x56dd9(%rip), %rax     # 0x7fff0
movq (%rax), %rdi
leaq 0x26def(%rip), %rsi     # 0x50010
leaq 0x30b08(%rip), %rcx     # 0x59d30
leaq 0x30b20(%rip), %r8      # 0x59d4f
movl $0x211, %edx            # imm = 0x211
xorl %eax, %eax
callq 0x125e0
callq 0x12100
movq 0x56da9(%rip), %rax     # 0x7fff0
movq (%rax), %rdi
leaq 0x23db3(%rip), %rsi     # 0x4d004
leaq 0x30ad8(%rip), %rdx     # 0x59d30
movl $0x216, %ecx            # imm = 0x216
xorl %eax, %eax
callq 0x125e0
pushq $0x1
popq %rdi
callq 0x12a60