LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/janet-lang[P]janet/src/core/util.c
// Function: janet_text_substitution
JanetByteView janet_text_substitution(
    Janet *subst,
    const uint8_t *bytes,
    uint32_t len,
    JanetArray *extra_argv) {
    int32_t extra_argc = extra_argv == NULL ? 0 : extra_argv->count;
    JanetType type = janet_type(*subst);
    switch (type) {
        case JANET_FUNCTION:
        case JANET_CFUNCTION: {
            int32_t argc = 1 + extra_argc;
            Janet *argv = janet_tuple_begin(argc);
            argv[0] = janet_stringv(bytes, len);
            for (int32_t i = 0; i < extra_argc; i++) {
                argv[i + 1] = extra_argv->data[i];
            }
            janet_tuple_end(argv);
            if (type == JANET_FUNCTION) {
                return to_byte_view(janet_call(janet_unwrap_function(*subst), argc, argv));
            } else {
                return to_byte_view(janet_unwrap_cfunction(*subst)(argc, argv));
            }
        }
        default:
            return memoize_byte_view(subst);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r14
movl %edx, %r13d
movq %rsi, %r15
movq %rdi, %rbx
testq %rcx, %rcx
je 0x494df
movl 0x10(%r14), %r12d
jmp 0x494e2
xorl %r12d, %r12d
movsd (%rbx), %xmm0
ucomisd %xmm0, %xmm0
movq %xmm0, %rdi
jp 0x49547
leaq -0x48(%rbp), %r14
leaq -0x50(%rbp), %rsi
movq %r14, %rdx
callq 0x497a9
testl %eax, %eax
je 0x4950b
movq -0x50(%rbp), %r15
jmp 0x49532
movq (%rbx), %rdi
callq 0x3ed51
movq %rax, %r15
movabsq $-0x6000000000000, %rsi # imm = 0xFFFA000000000000
movq %rax, %rdi
callq 0x4ed39
movq %rax, (%rbx)
movq %r15, %r14
addq $-0x8, %r14
movl (%r14), %edx
movq %r15, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rdi, %rax
shrq $0x2f, %rax
movq %rax, -0x38(%rbp)
andl $0xe, %eax
cmpl $0xc, %eax
jne 0x494f1
movq -0x38(%rbp), %rax
andl $0xf, %eax
movq %rax, -0x38(%rbp)
leal 0x1(%r12), %edi
movl %edi, -0x2c(%rbp)
callq 0x47fa0
movq %rax, -0x40(%rbp)
movq %r15, %rdi
movl %r13d, %esi
callq 0x44754
movabsq $-0x6000000000000, %rsi # imm = 0xFFFA000000000000
movq %rax, %rdi
callq 0x4ed39
movq -0x40(%rbp), %rcx
movq %rcx, %r15
movq %rax, (%rcx)
testl %r12d, %r12d
jle 0x495c0
movl %r12d, %eax
xorl %ecx, %ecx
movq 0x18(%r14), %rdx
movq (%rdx,%rcx,8), %rdx
movq %rdx, 0x8(%r15,%rcx,8)
leaq 0x1(%rcx), %rdx
movq %rdx, %rcx
cmpq %rdx, %rax
jne 0x495a7
movq %r15, %rdi
callq 0x47fd1
movq (%rbx), %rdi
callq 0x4ebc4
cmpl $0xc, -0x38(%rbp)
jne 0x495e6
movq %rax, %rdi
movl -0x2c(%rbp), %esi
movq %r15, %rdx
callq 0x4b70a
jmp 0x495ee
movl -0x2c(%rbp), %edi
movq %r15, %rsi
callq *%rax
movq %rax, %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x49601
// File: /workspace/github_c_makefile_star2_O3/janet-lang[P]janet/src/core/util.c
// Function: to_byte_view
static JanetByteView to_byte_view(Janet value) {
    JanetByteView result;
    if (!janet_bytes_view(value, &result.bytes, &result.len)) {
        JanetString str = janet_to_string(value);
        result.bytes = str;
        result.len = janet_string_length(str);
    }
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
leaq -0x18(%rbp), %rbx
leaq -0x20(%rbp), %rsi
movq %rbx, %rdx
callq 0x497a9
testl %eax, %eax
je 0x49629
movq -0x20(%rbp), %rax
jmp 0x49638
movq %r14, %rdi
callq 0x3ed51
movq %rax, %rbx
addq $-0x8, %rbx
movl (%rbx), %edx
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/janet-lang[P]janet/src/core/util.c
// Function: janet_resolve
JanetBindingType janet_resolve(JanetTable *env, const uint8_t *sym, Janet *out) {
    JanetBinding binding = janet_resolve_ext(env, sym);
    if (binding.type == JANET_BINDING_DYNAMIC_DEF || binding.type == JANET_BINDING_DYNAMIC_MACRO) {
        *out = janet_array_peek(janet_unwrap_array(binding.value));
    } else {
        *out = binding.value;
    }
    return binding.type;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %rdx
movq %rdi, %rsi
leaq -0x30(%rbp), %r15
movq %r15, %rdi
callq 0x49643
movl (%r15), %r14d
movl %r14d, %ecx
andl $-0x2, %ecx
movq 0x8(%r15), %rax
cmpl $0x4, %ecx
jne 0x496c4
movq %rax, %rdi
callq 0x4ebc4
movq %rax, %rdi
callq 0x14926
movq %rax, (%rbx)
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/janet-lang[P]janet/src/core/util.c
// Function: janet_resolve_core
Janet janet_resolve_core(const char *name) {
    JanetTable *env = janet_core_env(NULL);
    Janet out = janet_wrap_nil();
    janet_resolve(env, janet_csymbol(name), &out);
    return out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %edi, %edi
callq 0x1fb46
movq %rax, %r14
movabsq $-0x77fffffffffff, %rdi # imm = 0xFFF8800000000001
callq 0x4ece6
leaq -0x20(%rbp), %r15
movq %rax, (%r15)
movq %rbx, %rdi
callq 0x47261
movq %r14, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x49680
movq (%r15), %rax
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/util.c
// Function: janet_indexed_view
int janet_indexed_view(Janet seq, const Janet **data, int32_t *len) {
    if (janet_checktype(seq, JANET_ARRAY)) {
        *data = janet_unwrap_array(seq)->data;
        *len = janet_unwrap_array(seq)->count;
        return 1;
    } else if (janet_checktype(seq, JANET_TUPLE)) {
        *data = janet_unwrap_tuple(seq);
        *len = janet_tuple_length(janet_unwrap_tuple(seq));
        return 1;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movabsq $-0x800000000000, %rcx  # imm = 0xFFFF800000000000
andq %rdi, %rcx
movabsq $-0x4000000000000, %rax # imm = 0xFFFC000000000000
cmpq %rax, %rcx
je 0x4977b
xorl %eax, %eax
movabsq $-0x4800000000000, %rdx # imm = 0xFFFB800000000000
cmpq %rdx, %rcx
jne 0x497a0
movq %r14, %rdi
callq 0x4ebc4
movq 0x18(%rax), %rax
movl $0x10, %r12d
jmp 0x4978a
movq %r14, %rdi
callq 0x4ebc4
movq $-0x10, %r12
movq %rax, (%r15)
movq %r14, %rdi
callq 0x4ebc4
movl (%rax,%r12), %eax
movl %eax, (%rbx)
movl $0x1, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/janet-lang[P]janet/src/core/util.c
// Function: janet_bytes_view
int janet_bytes_view(Janet str, const uint8_t **data, int32_t *len) {
    JanetType t = janet_type(str);
    if (t == JANET_STRING || t == JANET_SYMBOL || t == JANET_KEYWORD) {
        *data = janet_unwrap_string(str);
        *len = janet_string_length(janet_unwrap_string(str));
        return 1;
    } else if (t == JANET_BUFFER) {
        *data = janet_unwrap_buffer(str)->data;
        *len = janet_unwrap_buffer(str)->count;
        return 1;
    } else if (t == JANET_ABSTRACT) {
        void *abst = janet_unwrap_abstract(str);
        const JanetAbstractType *atype = janet_abstract_type(abst);
        if (NULL == atype->bytes) {
            return 0;
        }
        JanetByteView view = atype->bytes(abst, janet_abstract_size(abst));
        *data = view.bytes;
        *len = view.len;
        return 1;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r15
movq %rdi, %xmm0
movq %rdi, %rax
shrq $0x2f, %rax
andl $0xf, %eax
xorl %r12d, %r12d
ucomisd %xmm0, %xmm0
cmovnpl %r12d, %eax
movq %rsi, %r14
movl %eax, %ecx
andl $-0x2, %ecx
cmpl $0x4, %ecx
setne %cl
cmpl $0x6, %eax
setne %dl
testb %cl, %dl
jne 0x49804
movq %r15, %rdi
callq 0x4ebc4
movq %rax, (%r14)
movq %r15, %rdi
callq 0x4ebc4
movl -0x8(%rax), %edx
jmp 0x4984b
cmpl $0xe, %eax
je 0x4982a
cmpl $0xb, %eax
jne 0x49853
movq %r15, %rdi
callq 0x4ebc4
movq 0x18(%rax), %rax
movq %rax, (%r14)
movq %r15, %rdi
callq 0x4ebc4
movl 0x10(%rax), %edx
jmp 0x4984b
movq %r15, %rdi
callq 0x4ebc4
movq -0x10(%rax), %rcx
movq 0x68(%rcx), %rcx
testq %rcx, %rcx
je 0x49853
movq -0x8(%rax), %rsi
movq %rax, %rdi
callq *%rcx
movq %rax, (%r14)
movl %edx, (%rbx)
movl $0x1, %r12d
movl %r12d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/janet-lang[P]janet/src/core/util.c
// Function: janet_dictionary_view
int janet_dictionary_view(Janet tab, const JanetKV **data, int32_t *len, int32_t *cap) {
    if (janet_checktype(tab, JANET_TABLE)) {
        *data = janet_unwrap_table(tab)->data;
        *cap = janet_unwrap_table(tab)->capacity;
        *len = janet_unwrap_table(tab)->count;
        return 1;
    } else if (janet_checktype(tab, JANET_STRUCT)) {
        *data = janet_unwrap_struct(tab);
        *cap = janet_struct_capacity(janet_unwrap_struct(tab));
        *len = janet_struct_length(janet_unwrap_struct(tab));
        return 1;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rsi, %r12
movq %rdi, %r15
movabsq $-0x800000000000, %rcx  # imm = 0xFFFF800000000000
andq %rdi, %rcx
movabsq $-0x3000000000000, %rax # imm = 0xFFFD000000000000
cmpq %rax, %rcx
je 0x498c0
xorl %eax, %eax
movabsq $-0x3800000000000, %rsi # imm = 0xFFFC800000000000
cmpq %rsi, %rcx
jne 0x49903
movq %rdx, -0x30(%rbp)
movq %r15, %rdi
callq 0x4ebc4
movq 0x20(%rax), %rax
movl $0x10, %r13d
movl $0x14, %ebx
jmp 0x498da
movq %rdx, -0x30(%rbp)
movq %r15, %rdi
callq 0x4ebc4
movq $-0x18, %r13
movq $-0x10, %rbx
movq %rax, (%r12)
movq %r15, %rdi
callq 0x4ebc4
movl (%rax,%rbx), %eax
movl %eax, (%r14)
movq %r15, %rdi
callq 0x4ebc4
movl (%rax,%r13), %eax
movq -0x30(%rbp), %rcx
movl %eax, (%rcx)
movl $0x1, %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/util.c
// Function: janet_get_core_table
JanetTable *janet_get_core_table(const char *name) {
    JanetTable *env = janet_core_env(NULL);
    Janet out = janet_wrap_nil();
    JanetBindingType bt = janet_resolve(env, janet_csymbol(name), &out);
    if (bt == JANET_BINDING_NONE) return NULL;
    if (!janet_checktype(out, JANET_TABLE)) return NULL;
    return janet_unwrap_table(out);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %edi, %edi
callq 0x1fb46
movq %rax, %r14
movabsq $-0x77fffffffffff, %rdi # imm = 0xFFF8800000000001
callq 0x4ece6
leaq -0x20(%rbp), %r15
movq %rax, (%r15)
movq %rbx, %rdi
callq 0x47261
movq %r14, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x49680
testl %eax, %eax
je 0x49c82
movq -0x20(%rbp), %rdi
movq %rdi, %rax
shrq $0x2f, %rax
cmpl $0x1fff9, %eax          # imm = 0x1FFF9
jne 0x49c82
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4ebc4
xorl %eax, %eax
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/util.c
// Function: janet_sorted_keys
int32_t janet_sorted_keys(const JanetKV *dict, int32_t cap, int32_t *index_buffer) {

    /* First, put populated indices into index_buffer */
    int32_t next_index = 0;
    for (int32_t i = 0; i < cap; i++) {
        if (!janet_checktype(dict[i].key, JANET_NIL)) {
            index_buffer[next_index++] = i;
        }
    }

    /* Next, sort those (simple insertion sort here for now) */
    for (int32_t i = 1; i < next_index; i++) {
        int32_t index_to_insert = index_buffer[i];
        Janet lhs = dict[index_to_insert].key;
        for (int32_t j = i - 1; j >= 0; j--) {
            index_buffer[j + 1] = index_buffer[j];
            Janet rhs = dict[index_buffer[j]].key;
            if (janet_compare(lhs, rhs) >= 0) {
                index_buffer[j + 1] = index_to_insert;
                break;
            } else if (j == 0) {
                index_buffer[0] = index_to_insert;
            }
        }
    }

    /* Return number of indices found */
    return next_index;

}

// Assembly:
testl %esi, %esi
jle 0x49d78
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rdi, %r15
movl %esi, %edi
xorl %ecx, %ecx
movq %r15, %rdx
xorl %eax, %eax
movq (%rdx), %rsi
shrq $0x2f, %rsi
cmpl $0x1fff1, %esi          # imm = 0x1FFF1
je 0x49cce
movslq %eax, %rsi
incl %eax
movl %ecx, (%rbx,%rsi,4)
incq %rcx
addq $0x10, %rdx
cmpq %rcx, %rdi
jne 0x49cb7
cmpl $0x2, %eax
jl 0x49d69
movl %eax, -0x2c(%rbp)
movl %eax, %eax
movq %rax, -0x40(%rbp)
movl $0x1, %eax
movl $0x2, %r13d
movq %rax, -0x50(%rbp)
movslq (%rbx,%rax,4), %rax
movq %rax, -0x38(%rbp)
shlq $0x4, %rax
movq (%r15,%rax), %r12
movq %r13, -0x48(%rbp)
leaq -0x2(%r13), %r14
movl %r14d, %eax
movslq (%rbx,%rax,4), %rax
movl %eax, -0x4(%rbx,%r13,4)
shlq $0x4, %rax
movq (%r15,%rax), %rsi
movq %r12, %rdi
callq 0x4a795
testl %eax, %eax
jns 0x49d49
testl %r14d, %r14d
jne 0x49d3e
movq -0x38(%rbp), %rax
movl %eax, (%rbx)
decq %r13
cmpq $0x1, %r13
jg 0x49d0f
jmp 0x49d52
movq -0x38(%rbp), %rax
movl %eax, -0x4(%rbx,%r13,4)
movq -0x50(%rbp), %rax
incq %rax
movq -0x48(%rbp), %r13
incq %r13
cmpq -0x40(%rbp), %rax
jne 0x49cf7
movl -0x2c(%rbp), %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/janet-lang[P]janet/src/core/util.c
// Function: janet_cryptorand
int janet_cryptorand(uint8_t *out, size_t n) {
#ifndef JANET_NO_CRYPTORAND
#ifdef JANET_WINDOWS
    for (size_t i = 0; i < n; i += sizeof(unsigned int)) {
        unsigned int v;
        if (rand_s(&v))
            return -1;
        for (int32_t j = 0; (j < (int32_t) sizeof(unsigned int)) && (i + j < n); j++) {
            out[i + j] = v & 0xff;
            v = v >> 8;
        }
    }
    return 0;
#elif defined(JANET_BSD) || defined(MAC_OS_X_VERSION_10_7)
    arc4random_buf(out, n);
    return 0;
#else
    /* We should be able to call getrandom on linux, but it doesn't seem
       to be uniformly supported on linux distros.
       On Mac, arc4random_buf wasn't available on until 10.7.
       In these cases, use this fallback path for now... */
    int rc;
    int randfd;
    RETRY_EINTR(randfd, open("/dev/urandom", O_RDONLY | O_CLOEXEC));
    if (randfd < 0)
        return -1;
    while (n > 0) {
        ssize_t nread;
        RETRY_EINTR(nread, read(randfd, out, n));
        if (nread <= 0) {
            RETRY_EINTR(rc, close(randfd));
            return -1;
        }
        out += nread;
        n -= nread;
    }
    RETRY_EINTR(rc, close(randfd));
    return 0;
#endif
#else
    (void) out;
    (void) n;
    return -1;
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x218ad(%rip), %r12     # 0x6b690
movq %r12, %rdi
movl $0x80000, %esi          # imm = 0x80000
xorl %eax, %eax
callq 0x128f0
testl %eax, %eax
jns 0x49e08
callq 0x12120
cmpl $0x4, (%rax)
je 0x49de3
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
jmp 0x49e6e
movl %eax, %ebx
testq %r14, %r14
je 0x49e43
movl %ebx, %edi
movq %r15, %rsi
movq %r14, %rdx
callq 0x12520
testq %rax, %rax
jns 0x49e2d
callq 0x12120
cmpl $0x4, (%rax)
je 0x49e0f
jmp 0x49e53
je 0x49e53
addq %rax, %r15
subq %rax, %r14
jne 0x49e0f
jmp 0x49e43
callq 0x12120
cmpl $0x4, (%rax)
jne 0x49e6e
movl %ebx, %edi
callq 0x12460
xorl %r14d, %r14d
testl %eax, %eax
js 0x49e39
jmp 0x49e6e
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
movl %ebx, %edi
callq 0x12460
testl %eax, %eax
jns 0x49e6e
callq 0x12120
cmpl $0x4, (%rax)
je 0x49e59
movl %r14d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/janet-lang[P]janet/src/core/util.c
// Function: get_processed_name
char *get_processed_name(const char *name) {
    if (name[0] == '.') return (char *) name;
    const char *c;
    for (c = name; *c; c++) {
        if (*c == '/') return (char *) name;
    }
    size_t l = (size_t)(c - name);
    char *ret = janet_malloc(l + 3);
    if (NULL == ret) {
        JANET_OUT_OF_MEMORY;
    }
    ret[0] = '.';
    ret[1] = '/';
    memcpy(ret + 2, name, l + 1);
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb (%rdi), %al
cmpb $0x2e, %al
je 0x49ed3
movl $0x1, %r14d
testb %al, %al
je 0x49ea8
movzbl %al, %eax
cmpl $0x2f, %eax
je 0x49ed3
movb (%rbx,%r14), %al
incq %r14
jmp 0x49e93
leaq 0x2(%r14), %rdi
callq 0x12760
testq %rax, %rax
je 0x49ee1
movq %rax, %r15
movw $0x2f2e, (%rax)         # imm = 0x2F2E
movq %rax, %rdi
addq $0x2, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x12670
movq %r15, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x14234
// File: /workspace/github_c_makefile_star2_O3/janet-lang[P]janet/src/core/value.c
// Function: push_traversal_node
static void push_traversal_node(void *lhs, void *rhs, int32_t index2) {
    JanetTraversalNode node;
    node.self = (JanetGCObject *) lhs;
    node.other = (JanetGCObject *) rhs;
    node.index = 0;
    node.index2 = index2;
    int is_new = janet_vm.traversal_base == NULL;
    if (is_new || (janet_vm.traversal + 1 >= janet_vm.traversal_top)) {
        size_t oldsize = is_new ? 0 : (janet_vm.traversal - janet_vm.traversal_base);
        size_t newsize = 2 * oldsize + 1;
        if (newsize < 128) {
            newsize = 128;
        }
        JanetTraversalNode *tn = janet_realloc(janet_vm.traversal_base, newsize * sizeof(JanetTraversalNode));
        if (tn == NULL) {
            JANET_OUT_OF_MEMORY;
        }
        janet_vm.traversal_base = tn;
        janet_vm.traversal_top = janet_vm.traversal_base + newsize;
        janet_vm.traversal = janet_vm.traversal_base + oldsize;
    }
    *(++janet_vm.traversal) = node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq %fs:0x0, %rax
leaq -0x348(%rax), %rax
movq %rax, %r12
movq 0x118(%rax), %rdi
testq %rdi, %rdi
je 0x4a433
movq 0x108(%r12), %rax
leaq 0x18(%rax), %rcx
cmpq 0x110(%r12), %rcx
jb 0x4a495
movl %ebx, -0x2c(%rbp)
subq %rdi, %rax
sarq $0x3, %rax
movabsq $-0x5555555555555555, %r13 # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %r13
jmp 0x4a439
movl %ebx, -0x2c(%rbp)
xorl %r13d, %r13d
leaq (,%r13,2), %rax
leaq 0x1(,%r13,2), %rbx
movl $0x80, %ecx
cmpq %rcx, %rax
cmovbq %rcx, %rbx
leaq (,%rbx,8), %rax
leaq (%rax,%rax,2), %rsi
callq 0x12840
testq %rax, %rax
je 0x4a4c2
movq %rax, 0x118(%r12)
leaq (%rbx,%rbx,2), %rcx
leaq (%rax,%rcx,8), %rcx
movq %rcx, 0x110(%r12)
leaq (,%r13,2), %rcx
addq %r13, %rcx
leaq (%rax,%rcx,8), %rax
movl -0x2c(%rbp), %ebx
leaq 0x18(%rax), %rcx
movq %rcx, 0x108(%r12)
movq %r15, 0x18(%rax)
movq %r14, 0x20(%rax)
movl $0x0, 0x28(%rax)
movl %ebx, 0x2c(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x14264
// File: /workspace/github_c_makefile_star2_O3/janet-lang[P]janet/src/core/value.c
// Function: getter_checkint
static int32_t getter_checkint(JanetType type, Janet key, int32_t max) {
    if (!janet_checkint(key)) goto bad;
    int32_t ret = janet_unwrap_integer(key);
    if (ret < 0) goto bad;
    if (ret >= max) goto bad;
    return ret;
bad:
    janet_panicf("expected integer key for %s in range [0, %d), got %v", janet_type_names[type], max, key);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r14d
movq %rsi, %rbx
movl %edi, %r15d
movq %rsi, %rdi
callq 0x49912
testl %eax, %eax
je 0x4ac18
movq %rbx, %xmm0
cvttsd2si %xmm0, %eax
testl %eax, %eax
js 0x4ac18
cmpl %r14d, %eax
jge 0x4ac18
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl %r15d, %eax
leaq 0x397ee(%rip), %rcx     # 0x84410
movq (%rcx,%rax,8), %rsi
leaq 0x20dc3(%rip), %rdi     # 0x6b9f0
movl %r14d, %edx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x190bb
// File: /workspace/github_c_makefile_star2_O3/janet-lang[P]janet/src/core/value.c
// Function: janet_length
int32_t janet_length(Janet x) {
    switch (janet_type(x)) {
        default:
            janet_panicf("expected %T, got %v", JANET_TFLAG_LENGTHABLE, x);
        case JANET_STRING:
        case JANET_SYMBOL:
        case JANET_KEYWORD:
            return janet_string_length(janet_unwrap_string(x));
        case JANET_ARRAY:
            return janet_unwrap_array(x)->count;
        case JANET_BUFFER:
            return janet_unwrap_buffer(x)->count;
        case JANET_TUPLE:
            return janet_tuple_length(janet_unwrap_tuple(x));
        case JANET_STRUCT:
            return janet_struct_length(janet_unwrap_struct(x));
        case JANET_TABLE:
            return janet_unwrap_table(x)->count;
        case JANET_ABSTRACT: {
            void *abst = janet_unwrap_abstract(x);
            const JanetAbstractType *type = janet_abstract_type(abst);
            if (type->length != NULL) {
                size_t len = type->length(abst, janet_abstract_size(abst));
                if (len > INT32_MAX) {
                    janet_panicf("invalid integer length %u", len);
                }
                return (int32_t)(len);
            }
            Janet argv[1] = { x };
            Janet len = janet_mcall("length", 1, argv);
            if (!janet_checkint(len))
                janet_panicf("invalid integer length %v", len);
            return janet_unwrap_integer(len);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rdi, %xmm0
movq %rdi, %rcx
shrq $0x2f, %rcx
andl $0xf, %ecx
xorl %eax, %eax
ucomisd %xmm0, %xmm0
cmovpl %ecx, %eax
addl $-0x4, %eax
cmpl $0xa, %eax
ja 0x4b0d2
leaq 0x207eb(%rip), %rcx     # 0x6b814
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rbx, %rdi
callq 0x4ebc4
movl 0x10(%rax), %eax
jmp 0x4b0cb
movq %rbx, %rdi
callq 0x4ebc4
movl -0x8(%rax), %eax
jmp 0x4b0cb
movq %rbx, %rdi
callq 0x4ebc4
movl -0x10(%rax), %eax
jmp 0x4b0cb
movq %rbx, %rdi
callq 0x4ebc4
movq -0x10(%rax), %rcx
movq 0x60(%rcx), %rcx
testq %rcx, %rcx
je 0x4b09b
movq -0x8(%rax), %rsi
movq %rax, %rdi
callq *%rcx
testq $-0x80000000, %rax      # imm = 0x80000000
je 0x4b0cb
leaq 0x208cb(%rip), %rdi     # 0x6b954
movq %rax, %rsi
jmp 0x4b0f2
movq %rbx, %rdi
callq 0x4ebc4
movl -0x18(%rax), %eax
jmp 0x4b0cb
leaq -0x10(%rbp), %rdx
movq %rbx, (%rdx)
leaq 0x1cef1(%rip), %rdi     # 0x67f9a
movl $0x1, %esi
callq 0x4e687
movq %rax, %rbx
movq %rax, %rdi
callq 0x49912
testl %eax, %eax
je 0x4b0e8
movq %rbx, %xmm0
cvttsd2si %xmm0, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x900e(%rip), %rdi      # 0x540e7
movl $0xff0, %esi            # imm = 0xFF0
movq %rbx, %rdx
xorl %eax, %eax
callq 0x190bb
leaq 0x2087f(%rip), %rdi     # 0x6b96e
movq %rbx, %rsi
xorl %eax, %eax
callq 0x190bb
// File: /workspace/github_c_makefile_star2_O3/janet-lang[P]janet/src/core/value.c
// Function: janet_lengthv
Janet janet_lengthv(Janet x) {
    switch (janet_type(x)) {
        default:
            janet_panicf("expected %T, got %v", JANET_TFLAG_LENGTHABLE, x);
        case JANET_STRING:
        case JANET_SYMBOL:
        case JANET_KEYWORD:
            return janet_wrap_integer(janet_string_length(janet_unwrap_string(x)));
        case JANET_ARRAY:
            return janet_wrap_integer(janet_unwrap_array(x)->count);
        case JANET_BUFFER:
            return janet_wrap_integer(janet_unwrap_buffer(x)->count);
        case JANET_TUPLE:
            return janet_wrap_integer(janet_tuple_length(janet_unwrap_tuple(x)));
        case JANET_STRUCT:
            return janet_wrap_integer(janet_struct_length(janet_unwrap_struct(x)));
        case JANET_TABLE:
            return janet_wrap_integer(janet_unwrap_table(x)->count);
        case JANET_ABSTRACT: {
            void *abst = janet_unwrap_abstract(x);
            const JanetAbstractType *type = janet_abstract_type(abst);
            if (type->length != NULL) {
                size_t len = type->length(abst, janet_abstract_size(abst));
                /* If len is always less then double, we can never overflow */
#ifdef JANET_32
                return janet_wrap_number(len);
#else
                if (len < (size_t) JANET_INTMAX_INT64) {
                    return janet_wrap_number((double) len);
                } else {
                    janet_panicf("integer length %u too large", len);
                }
#endif
            }
            Janet argv[1] = { x };
            return janet_mcall("length", 1, argv);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rdi, %xmm0
movq %rdi, %rcx
shrq $0x2f, %rcx
andl $0xf, %ecx
xorl %eax, %eax
ucomisd %xmm0, %xmm0
cmovpl %ecx, %eax
addl $-0x4, %eax
cmpl $0xa, %eax
ja 0x4b1d7
leaq 0x20713(%rip), %rcx     # 0x6b840
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rbx, %rdi
callq 0x4ebc4
xorps %xmm0, %xmm0
cvtsi2sdl 0x10(%rax), %xmm0
jmp 0x4b1ad
movq %rbx, %rdi
callq 0x4ebc4
xorps %xmm0, %xmm0
cvtsi2sdl -0x8(%rax), %xmm0
jmp 0x4b1ad
movq %rbx, %rdi
callq 0x4ebc4
xorps %xmm0, %xmm0
cvtsi2sdl -0x10(%rax), %xmm0
jmp 0x4b1ad
movq %rbx, %rdi
callq 0x4ebc4
movq -0x10(%rax), %rcx
movq 0x60(%rcx), %rcx
testq %rcx, %rcx
je 0x4b1b8
movq -0x8(%rax), %rsi
movq %rax, %rdi
callq *%rcx
movq %rax, %rcx
shrq $0x35, %rcx
jne 0x4b1ed
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
jmp 0x4b1ad
movq %rbx, %rdi
callq 0x4ebc4
xorps %xmm0, %xmm0
cvtsi2sdl -0x18(%rax), %xmm0
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x4ee44
leaq -0x10(%rbp), %rdx
movq %rbx, (%rdx)
leaq 0x1cdd4(%rip), %rdi     # 0x67f9a
movl $0x1, %esi
callq 0x4e687
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x8f09(%rip), %rdi      # 0x540e7
movl $0xff0, %esi            # imm = 0xFF0
movq %rbx, %rdx
xorl %eax, %eax
callq 0x190bb
leaq 0x20794(%rip), %rdi     # 0x6b988
movq %rax, %rsi
xorl %eax, %eax
callq 0x190bb
// File: /workspace/github_c_makefile_star2_O3/janet-lang[P]janet/src/core/vector.c
// Function: janet_v_grow
void *janet_v_grow(void *v, int32_t increment, int32_t itemsize) {
    int32_t dbl_cur = (NULL != v) ? 2 * janet_v__cap(v) : 0;
    int32_t min_needed = janet_v_count(v) + increment;
    int32_t m = dbl_cur > min_needed ? dbl_cur : min_needed;
    size_t newsize = ((size_t) itemsize) * m + sizeof(int32_t) * 2;
    int32_t *p = (int32_t *) janet_srealloc(v ? janet_v__raw(v) : 0, newsize);
    if (!v) p[1] = 0;
    p[0] = m;
    return p + 2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
testq %rdi, %rdi
je 0x4b502
movl -0x8(%rbx), %eax
movl -0x4(%rbx), %r14d
addl %eax, %eax
jmp 0x4b507
xorl %eax, %eax
xorl %r14d, %r14d
addl %esi, %r14d
cmpl %r14d, %eax
cmovgl %eax, %r14d
movslq %edx, %rax
movslq %r14d, %rsi
imulq %rax, %rsi
addq $0x8, %rsi
leaq -0x8(%rbx), %rdi
testq %rbx, %rbx
cmoveq %rbx, %rdi
callq 0x2bc37
testq %rbx, %rbx
jne 0x4b53b
movl $0x0, 0x4(%rax)
movl %r14d, (%rax)
addq $0x8, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/janet-lang[P]janet/src/core/vector.c
// Function: janet_v_flattenmem
void *janet_v_flattenmem(void *v, int32_t itemsize) {
    char *p;
    if (NULL == v) return NULL;
    size_t size = (size_t) itemsize * janet_v__cnt(v);
    p = janet_malloc(size);
    if (NULL != p) {
        safe_memcpy(p, v, size);
        return p;
    } else {
        JANET_OUT_OF_MEMORY;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x4b584
movq %rdi, %rbx
movslq %esi, %rax
movslq -0x4(%rdi), %r15
imulq %rax, %r15
movq %r15, %rdi
callq 0x12760
testq %rax, %rax
je 0x4b595
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x48567
jmp 0x4b587
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x14292
nop
// File: /workspace/github_c_makefile_star2_O3/janet-lang[P]janet/src/core/vm.c
// Function: janet_continue
JanetSignal janet_continue(JanetFiber *fiber, Janet in, Janet *out) {
    /* Check conditions */
    JanetSignal tmp_signal = janet_check_can_resume(fiber, out, 0);
    if (tmp_signal) return tmp_signal;
    return janet_continue_no_check(fiber, in, out);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rdx, %rsi
xorl %edx, %edx
callq 0x4e1dd
testl %eax, %eax
je 0x4b6f2
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4e2a9
// File: /workspace/github_c_makefile_star2_O3/janet-lang[P]janet/src/core/vm.c
// Function: vm_do_trace
static void vm_do_trace(JanetFunction *func, int32_t argc, const Janet *argv) {
    if (func->def->name) {
        janet_eprintf("trace (%S", func->def->name);
    } else {
        janet_eprintf("trace (%p", janet_wrap_function(func));
    }
    for (int32_t i = 0; i < argc; i++) {
        janet_eprintf(" %p", argv[i]);
    }
    janet_eprintf(")\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %r14d
movq 0x10(%rdi), %rax
movq 0x48(%rax), %rcx
movq 0x39687(%rip), %rax     # 0x84ff0
movq (%rax), %r15
testq %rcx, %rcx
je 0x4b984
leaq 0xf0a6(%rip), %rdi      # 0x5aa1e
leaq 0x20285(%rip), %rdx     # 0x6bc04
movq %r15, %rsi
jmp 0x4b9a7
movabsq $-0x2000000000000, %rsi # imm = 0xFFFE000000000000
callq 0x4ed7e
leaq 0xf084(%rip), %rdi      # 0x5aa1e
leaq 0x2026d(%rip), %rdx     # 0x6bc0e
movq %r15, %rsi
movq %rax, %rcx
xorl %eax, %eax
callq 0x2ed91
testl %r14d, %r14d
movq 0x39638(%rip), %rax     # 0x84ff0
jle 0x4b9f1
movl %r14d, %r13d
leaq 0xf05a(%rip), %r14      # 0x5aa1e
leaq 0x1429f(%rip), %r15     # 0x5fc6a
xorl %r12d, %r12d
movq (%rax), %rsi
movq (%rbx,%r12,8), %rcx
movq %r14, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x2ed91
movq 0x39607(%rip), %rax     # 0x84ff0
incq %r12
cmpq %r12, %r13
jne 0x4b9ce
movq (%rax), %rsi
leaq 0xf023(%rip), %rdi      # 0x5aa1e
leaq 0x20216(%rip), %rdx     # 0x6bc18
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2ed91
// File: /workspace/github_c_makefile_star2_O3/janet-lang[P]janet/src/core/vm.c
// Function: janet_check_can_resume
static JanetSignal janet_check_can_resume(JanetFiber *fiber, Janet *out, int is_cancel) {
    /* Check conditions */
    JanetFiberStatus old_status = janet_fiber_status(fiber);
    if (janet_vm.stackn >= JANET_RECURSION_GUARD) {
        janet_fiber_set_status(fiber, JANET_STATUS_ERROR);
        *out = janet_cstringv("C stack recursed too deeply");
        return JANET_SIGNAL_ERROR;
    }
    /* If a "task" fiber is trying to be used as a normal fiber, detect that. See bug #920.
     * Fibers must be marked as root fibers manually, or by the ev scheduler. */
    if (janet_vm.fiber != NULL && (fiber->gc.flags & JANET_FIBER_FLAG_ROOT)) {
#ifdef JANET_EV
        *out = janet_cstringv(is_cancel
                              ? "cannot cancel root fiber, use ev/cancel"
                              : "cannot resume root fiber, use ev/go");
#else
        *out = janet_cstringv(is_cancel
                              ? "cannot cancel root fiber"
                              : "cannot resume root fiber");
#endif
        return JANET_SIGNAL_ERROR;
    }
    if (old_status == JANET_STATUS_ALIVE ||
            old_status == JANET_STATUS_DEAD ||
            (old_status >= JANET_STATUS_USER0 && old_status <= JANET_STATUS_USER4) ||
            old_status == JANET_STATUS_ERROR) {
        const uint8_t *str = janet_formatc("cannot resume fiber with status :%s",
                                           janet_status_names[old_status]);
        *out = janet_wrap_string(str);
        return JANET_SIGNAL_ERROR;
    }
    return JANET_SIGNAL_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %r12d
movq %rsi, %rbx
movq %rdi, %r15
callq 0x2996f
movl %eax, %r14d
movq %fs:0x0, %rax
leaq -0x348(%rax), %rax
cmpl $0x400, 0x18(%rax)      # imm = 0x400
jl 0x4e22d
movl $0xffc0ffff, %eax       # imm = 0xFFC0FFFF
andl 0x10(%r15), %eax
orl $0x10000, %eax          # imm = 0x10000
movl %eax, 0x10(%r15)
leaq 0x1d8ab(%rip), %rdi     # 0x6bad6
jmp 0x4e281
cmpq $0x0, 0x20(%rax)
je 0x4e23b
testb $0x4, 0x2(%r15)
jne 0x4e26c
xorl %eax, %eax
cmpl $0xf, %r14d
ja 0x4e2a0
movl $0x81f3, %ecx           # imm = 0x81F3
btl %r14d, %ecx
jae 0x4e2a0
movl %r14d, %eax
leaq 0x362a8(%rip), %rcx     # 0x84500
movq (%rcx,%rax,8), %rsi
leaq 0x1dc49(%rip), %rdi     # 0x6beac
xorl %eax, %eax
callq 0x3f652
jmp 0x4e286
testl %r12d, %r12d
leaq 0x1dc12(%rip), %rax     # 0x6be88
leaq 0x1dbe3(%rip), %rdi     # 0x6be60
cmoveq %rax, %rdi
callq 0x4482c
movabsq $-0x6000000000000, %rsi # imm = 0xFFFA000000000000
movq %rax, %rdi
callq 0x4ed39
movq %rax, (%rbx)
movl $0x1, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/janet-lang[P]janet/src/core/vm.c
// Function: janet_continue_signal
JanetSignal janet_continue_signal(JanetFiber *fiber, Janet in, Janet *out, JanetSignal sig) {
    JanetSignal tmp_signal = janet_check_can_resume(fiber, out, sig != JANET_SIGNAL_OK);
    if (tmp_signal) return tmp_signal;
    if (sig != JANET_SIGNAL_OK) {
        JanetFiber *child = fiber;
        while (child->child) child = child->child;
        child->gc.flags &= ~JANET_FIBER_STATUS_MASK;
        child->gc.flags |= sig << JANET_FIBER_STATUS_OFFSET;
        child->flags |= JANET_FIBER_RESUME_SIGNAL;
    }
    return janet_continue_no_check(fiber, in, out);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %r12d
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %edx, %edx
testl %ecx, %ecx
setne %dl
movq %rbx, %rsi
callq 0x4e1dd
testl %eax, %eax
je 0x4e59a
movl $0x1, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
testl %r12d, %r12d
je 0x4e5c3
movq %r15, %rcx
movq %rcx, %rax
movq 0x38(%rcx), %rcx
testq %rcx, %rcx
jne 0x4e5a2
movl $0xffc0ffff, %ecx       # imm = 0xFFC0FFFF
andl (%rax), %ecx
shll $0x10, %r12d
orl %ecx, %r12d
movl %r12d, (%rax)
orb $0x40, 0x12(%rax)
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x4e2a9
// File: /workspace/github_c_makefile_star2_O3/janet-lang[P]janet/src/core/vm.c
// Function: janet_pcall
JanetSignal janet_pcall(
    JanetFunction *fun,
    int32_t argc,
    const Janet *argv,
    Janet *out,
    JanetFiber **f) {
    JanetFiber *fiber;
    if (f && *f) {
        fiber = janet_fiber_reset(*f, fun, argc, argv);
    } else {
        fiber = janet_fiber(fun, 64, argc, argv);
    }
    if (f) *f = fiber;
    if (NULL == fiber) {
        *out = janet_cstringv("arity mismatch");
        return JANET_SIGNAL_ERROR;
    }
    return janet_continue(fiber, janet_wrap_nil(), out);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %rcx
movl %esi, %edx
movq %rdi, %rsi
testq %r8, %r8
je 0x4e605
movq %r8, %r14
movq (%r8), %rdi
testq %rdi, %rdi
je 0x4e617
callq 0x292bc
jmp 0x4e624
movq %rsi, %rdi
movl $0x40, %esi
callq 0x295e4
movq %rax, %r15
jmp 0x4e62a
movq %rsi, %rdi
movl $0x40, %esi
callq 0x295e4
movq %rax, %r15
movq %rax, (%r14)
testq %r15, %r15
je 0x4e656
movabsq $-0x77fffffffffff, %rdi # imm = 0xFFF8800000000001
callq 0x4ece6
movq %r15, %rdi
movq %rax, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4b6c1
leaq 0x1d524(%rip), %rdi     # 0x6bb81
callq 0x4482c
movabsq $-0x6000000000000, %rsi # imm = 0xFFFA000000000000
movq %rax, %rdi
callq 0x4ed39
movq %rax, (%rbx)
movl $0x1, %eax
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/vm.c
// Function: janet_mcall
Janet janet_mcall(const char *name, int32_t argc, Janet *argv) {
    /* At least 1 argument */
    if (argc < 1) {
        janet_panicf("method :%s expected at least 1 argument", name);
    }
    /* Find method */
    Janet method = janet_method_lookup(argv[0], name);
    if (janet_checktype(method, JANET_NIL)) {
        janet_panicf("could not find method :%s for %v", name, argv[0]);
    }
    /* Invoke method */
    return janet_method_invoke(method, argc, argv);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
jle 0x4e6cd
movq %rdx, %r14
movl %esi, %r15d
movq (%rdx), %rdi
movq %rbx, %rsi
callq 0x4e6f2
movq %rax, %rcx
shrq $0x2f, %rcx
cmpl $0x1fff1, %ecx          # imm = 0x1FFF1
je 0x4e6de
movq %rax, %rdi
movl %r15d, %esi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4e726
leaq 0x1d4bc(%rip), %rdi     # 0x6bb90
movq %rbx, %rsi
xorl %eax, %eax
callq 0x190bb
movq (%r14), %rdx
leaq 0x1d4d0(%rip), %rdi     # 0x6bbb8
movq %rbx, %rsi
xorl %eax, %eax
callq 0x190bb
// File: /workspace/github_c_makefile_star2_O3/janet-lang[P]janet/src/core/vm.c
// Function: janet_method_invoke
static Janet janet_method_invoke(Janet method, int32_t argc, Janet *argv) {
    switch (janet_type(method)) {
        case JANET_CFUNCTION:
            return (janet_unwrap_cfunction(method))(argc, argv);
        case JANET_FUNCTION: {
            JanetFunction *fun = janet_unwrap_function(method);
            return janet_call(fun, argc, argv);
        }
        case JANET_ABSTRACT: {
            JanetAbstract abst = janet_unwrap_abstract(method);
            const JanetAbstractType *at = janet_abstract_type(abst);
            if (NULL != at->call) {
                return at->call(abst, argc, argv);
            }
        }
        /* fallthrough */
        case JANET_STRING:
        case JANET_BUFFER:
        case JANET_TABLE:
        case JANET_STRUCT:
        case JANET_ARRAY:
        case JANET_TUPLE: {
            if (argc != 1) {
                janet_panicf("%v called with %d arguments, possibly expected 1", method, argc);
            }
            return janet_in(method, argv[0]);
        }
        default: {
            if (argc != 1) {
                janet_panicf("%v called with %d arguments, possibly expected 1", method, argc);
            }
            return janet_in(argv[0], method);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %ebx
movq %rdi, %r15
movq %rdi, %xmm0
movq %rdi, %rcx
shrq $0x2f, %rcx
andl $0xf, %ecx
xorl %eax, %eax
ucomisd %xmm0, %xmm0
cmovpl %ecx, %eax
addl $-0x4, %eax
cmpl $0xa, %eax
ja 0x4e7eb
leaq 0x1d2d5(%rip), %rcx     # 0x6ba38
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cmpl $0x1, %ebx
jne 0x4e7f8
movq (%r14), %rsi
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4aa04
movq %r15, %rdi
callq 0x4ebc4
movq %rax, %rdi
movl %ebx, %esi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4b70a
movq %r15, %rdi
callq 0x4ebc4
movl %ebx, %edi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmpq *%rax
movq %r15, %rdi
callq 0x4ebc4
movq -0x10(%rax), %rcx
movq 0x58(%rcx), %rcx
testq %rcx, %rcx
je 0x4e76c
movq %rax, %rdi
movl %ebx, %esi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmpq *%rcx
cmpl $0x1, %ebx
jne 0x4e7f8
movq (%r14), %rdi
movq %r15, %rsi
jmp 0x4e77b
leaq 0x1d6d1(%rip), %rdi     # 0x6bed0
movq %r15, %rsi
movl %ebx, %edx
xorl %eax, %eax
callq 0x190bb
// File: /workspace/github_c_makefile_star2_O3/janet-lang[P]janet/src/core/vm.c
// Function: janet_deinit
void janet_deinit(void) {
    janet_clear_memory();
    janet_symcache_deinit();
    janet_free(janet_vm.roots);
    janet_vm.roots = NULL;
    janet_vm.root_count = 0;
    janet_vm.root_capacity = 0;
    janet_vm.abstract_registry = NULL;
    janet_vm.core_env = NULL;
    janet_vm.top_dyns = NULL;
    janet_vm.user = NULL;
    janet_free(janet_vm.traversal_base);
    janet_vm.fiber = NULL;
    janet_vm.root_fiber = NULL;
    janet_free(janet_vm.registry);
    janet_vm.registry = NULL;
#ifdef JANET_EV
    janet_ev_deinit();
#endif
#ifdef JANET_NET
    janet_net_deinit();
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
callq 0x2ba1a
callq 0x46edd
movq %fs:0x0, %rax
leaq -0x348(%rax), %rax
movq %rax, %rbx
movq 0xc0(%rax), %rdi
callq 0x120b0
xorl %r14d, %r14d
movq %r14, 0x68(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq %r14, 0x10(%rbx)
movups %xmm0, 0xc0(%rbx)
movq %r14, 0xd0(%rbx)
movq 0x118(%rbx), %rdi
callq 0x120b0
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rbx)
movq 0x48(%rbx), %rdi
callq 0x120b0
movq %r14, 0x48(%rbx)
callq 0x250fc
popq %rbx
popq %r14
popq %rbp
jmp 0x35404
// File: /workspace/github_c_makefile_star2_O3/janet-lang[P]janet/src/core/vm.c
// Function: janet_binop_call
static Janet janet_binop_call(const char *lmethod, const char *rmethod, Janet lhs, Janet rhs) {
    Janet lm = janet_method_lookup(lhs, lmethod);
    if (janet_checktype(lm, JANET_NIL)) {
        /* Invert order for rmethod */
        Janet lr = janet_method_lookup(rhs, rmethod);
        Janet argv[2] = { rhs, lhs };
        if (janet_checktype(lr, JANET_NIL)) {
            janet_panicf("could not find method :%s for %v or :%s for %v",
                         lmethod, lhs,
                         rmethod, rhs);
        }
        return janet_method_invoke(lr, 2, argv);
    } else {
        Janet argv[2] = { lhs, rhs };
        return janet_method_invoke(lm, 2, argv);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq %rdx, %rdi
movq %r12, %rsi
callq 0x4e6f2
movq %rax, %rcx
shrq $0x2f, %rcx
cmpl $0x1fff1, %ecx          # imm = 0x1FFF1
jne 0x4ea3d
movabsq $-0x800000000000, %r13  # imm = 0xFFFF800000000000
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4e6f2
movq %rbx, -0x40(%rbp)
movq %r14, -0x38(%rbp)
andq %rax, %r13
movabsq $-0x7800000000000, %rcx # imm = 0xFFF8800000000000
cmpq %rcx, %r13
je 0x4ea64
leaq -0x40(%rbp), %rdx
jmp 0x4ea48
leaq -0x40(%rbp), %rdx
movq %r14, (%rdx)
movq %rbx, 0x8(%rdx)
movq %rax, %rdi
movl $0x2, %esi
callq 0x4e726
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1d374(%rip), %rdi     # 0x6bddf
movq %r12, %rsi
movq %r14, %rdx
movq %r15, %rcx
movq %rbx, %r8
xorl %eax, %eax
callq 0x190bb
// File: /workspace/github_c_makefile_star2_O3/janet-lang[P]janet/src/core/vm.c
// Function: resolve_method
static Janet resolve_method(Janet name, JanetFiber *fiber) {
    int32_t argc = fiber->stacktop - fiber->stackstart;
    if (argc < 1) janet_panicf("method call (%v) takes at least 1 argument, got 0", name);
    Janet callee = method_to_fun(name, fiber->data[fiber->stackstart]);
    if (janet_checktype(callee, JANET_NIL))
        janet_panicf("unknown method %v invoked on %v", name, fiber->data[fiber->stackstart]);
    return callee;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movslq 0x18(%rsi), %rax
cmpl %eax, 0x1c(%rsi)
jle 0x4eab8
movq %rsi, %r14
movq 0x30(%rsi), %rcx
movq (%rcx,%rax,8), %rdi
movq %rbx, %rsi
callq 0x4ac3a
movq %rax, %rcx
shrq $0x2f, %rcx
cmpl $0x1fff1, %ecx          # imm = 0x1FFF1
je 0x4eac9
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x1d34f(%rip), %rdi     # 0x6be0e
movq %rbx, %rsi
xorl %eax, %eax
callq 0x190bb
movq 0x30(%r14), %rax
movslq 0x18(%r14), %rcx
movq (%rax,%rcx,8), %rdx
leaq 0x1d364(%rip), %rdi     # 0x6be40
movq %rbx, %rsi
xorl %eax, %eax
callq 0x190bb
nop
// File: /workspace/github_c_makefile_star2_O3/janet-lang[P]janet/src/core/wrap.c
// Function: janet_memalloc_empty
void *janet_memalloc_empty(int32_t count) {
    int32_t i;
    void *mem = janet_malloc((size_t) count * sizeof(JanetKV));
    janet_vm.next_collection += (size_t) count * sizeof(JanetKV);
    if (NULL == mem) {
        JANET_OUT_OF_MEMORY;
    }
    JanetKV *mmem = (JanetKV *)mem;
    for (i = 0; i < count; i++) {
        JanetKV *kv = mmem + i;
        kv->key = janet_wrap_nil();
        kv->value = janet_wrap_nil();
    }
    return mem;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %r14d
movslq %edi, %r15
shlq $0x4, %r15
movq %r15, %rdi
callq 0x12760
movq %rax, %rbx
movq %fs:0x0, %rax
leaq -0x348(%rax), %rax
addq %r15, 0xa8(%rax)
testq %rbx, %rbx
je 0x4eed8
testl %r14d, %r14d
jle 0x4eeca
movabsq $-0x77fffffffffff, %rax # imm = 0xFFF8800000000001
movl %r14d, %ecx
shlq $0x4, %rcx
xorl %edx, %edx
movq %rax, (%rbx,%rdx)
movq %rax, 0x8(%rbx,%rdx)
addq $0x10, %rdx
cmpq %rdx, %rcx
jne 0x4eeb8
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x142c0
// File: /workspace/github_c_makefile_star2_O3/janet-lang[P]janet/src/core/wrap.c
// Function: janet_memempty
void janet_memempty(JanetKV *mem, int32_t count) {
    int32_t i;
    for (i = 0; i < count; i++) {
        mem[i].key = janet_wrap_nil();
        mem[i].value = janet_wrap_nil();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testl %esi, %esi
jle 0x4ef09
movabsq $-0x77fffffffffff, %rax # imm = 0xFFF8800000000001
movl %esi, %ecx
shlq $0x4, %rcx
xorl %edx, %edx
movq %rax, (%rdi,%rdx)
movq %rax, 0x8(%rdi,%rdx)
addq $0x10, %rdx
cmpq %rdx, %rcx
jne 0x4eef7
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/janet-lang[P]janet/src/boot/buffer_test.c
// Function: buffer_test
int buffer_test() {

    int i;
    JanetBuffer *buffer1, *buffer2;

    buffer1 = janet_buffer(100);
    buffer2 = janet_buffer(0);

    janet_buffer_push_cstring(buffer1, "hello, world!\n");

    janet_buffer_push_u8(buffer2, 'h');
    janet_buffer_push_u8(buffer2, 'e');
    janet_buffer_push_u8(buffer2, 'l');
    janet_buffer_push_u8(buffer2, 'l');
    janet_buffer_push_u8(buffer2, 'o');
    janet_buffer_push_u8(buffer2, ',');
    janet_buffer_push_u8(buffer2, ' ');
    janet_buffer_push_u8(buffer2, 'w');
    janet_buffer_push_u8(buffer2, 'o');
    janet_buffer_push_u8(buffer2, 'r');
    janet_buffer_push_u8(buffer2, 'l');
    janet_buffer_push_u8(buffer2, 'd');
    janet_buffer_push_u8(buffer2, '!');
    janet_buffer_push_u8(buffer2, '\n');

    assert(buffer1->count == buffer2->count);
    assert(buffer1->capacity >= buffer1->count);
    assert(buffer2->capacity >= buffer2->count);

    for (i = 0; i < buffer1->count; i++) {
        assert(buffer1->data[i] == buffer2->data[i]);
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl $0x64, %edi
callq 0x176f7
movq %rax, %rbx
xorl %edi, %edi
callq 0x176f7
movq %rax, %r14
leaq 0x1cc72(%rip), %rsi     # 0x6c0cf
movq %rbx, %rdi
callq 0x17878
movq %r14, %rdi
movl $0x68, %esi
callq 0x17947
movq %r14, %rdi
movl $0x65, %esi
callq 0x17947
movq %r14, %rdi
movl $0x6c, %esi
callq 0x17947
movq %r14, %rdi
movl $0x6c, %esi
callq 0x17947
movq %r14, %rdi
movl $0x6f, %esi
callq 0x17947
movq %r14, %rdi
movl $0x2c, %esi
callq 0x17947
movq %r14, %rdi
movl $0x20, %esi
callq 0x17947
movq %r14, %rdi
movl $0x77, %esi
callq 0x17947
movq %r14, %rdi
movl $0x6f, %esi
callq 0x17947
movq %r14, %rdi
movl $0x72, %esi
callq 0x17947
movq %r14, %rdi
movl $0x6c, %esi
callq 0x17947
movq %r14, %rdi
movl $0x64, %esi
callq 0x17947
movq %r14, %rdi
movl $0x21, %esi
callq 0x17947
movq %r14, %rdi
movl $0xa, %esi
callq 0x17947
movl 0x10(%rbx), %eax
cmpl 0x10(%r14), %eax
jne 0x4f579
cmpl %eax, 0x14(%rbx)
jl 0x4f598
cmpl %eax, 0x14(%r14)
jl 0x4f5b7
testl %eax, %eax
jle 0x4f553
movq 0x18(%rbx), %rcx
movq 0x18(%r14), %rdx
xorl %esi, %esi
movb (%rcx,%rsi), %dil
cmpb (%rdx,%rsi), %dil
jne 0x4f55a
incq %rsi
cmpq %rsi, %rax
jne 0x4f541
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x1cc0f(%rip), %rdi     # 0x6c170
leaq 0x1cb97(%rip), %rsi     # 0x6c0ff
leaq 0x1cba7(%rip), %rcx     # 0x6c116
movl $0x3a, %edx
callq 0x123f0
leaq 0x1cb5e(%rip), %rdi     # 0x6c0de
leaq 0x1cb78(%rip), %rsi     # 0x6c0ff
leaq 0x1cb88(%rip), %rcx     # 0x6c116
movl $0x35, %edx
callq 0x123f0
leaq 0x1cb89(%rip), %rdi     # 0x6c128
leaq 0x1cb59(%rip), %rsi     # 0x6c0ff
leaq 0x1cb69(%rip), %rcx     # 0x6c116
movl $0x36, %edx
callq 0x123f0
leaq 0x1cb8e(%rip), %rdi     # 0x6c14c
leaq 0x1cb3a(%rip), %rsi     # 0x6c0ff
leaq 0x1cb4a(%rip), %rcx     # 0x6c116
movl $0x37, %edx
callq 0x123f0
nop