LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/janet-lang[P]janet/src/core/symcache.c
// Function: janet_symcache_init
void janet_symcache_init() {
    janet_vm.cache_capacity = 1024;
    janet_vm.cache = janet_calloc(1, (size_t) janet_vm.cache_capacity * sizeof(const uint8_t *));
    if (NULL == janet_vm.cache) {
        JANET_OUT_OF_MEMORY;
    }
    memset(&janet_vm.gensym_counter, '0', sizeof(janet_vm.gensym_counter));
    janet_vm.gensym_counter[0] = '_';
    janet_vm.cache_count = 0;
    janet_vm.cache_deleted = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %fs:0x0, %rax
leaq -0x348(%rax), %rax
movq %rax, %rbx
movl $0x400, 0x78(%rax)      # imm = 0x400
pushq $0x1
popq %rdi
movl $0x2000, %esi           # imm = 0x2000
callq 0x125a0
movq %rax, 0x70(%rbx)
testq %rax, %rax
je 0x435df
movabsq $0x303030303030305f, %rax # imm = 0x303030303030305F
movq %rax, 0x84(%rbx)
andq $0x0, 0x7c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0x3ca0a(%rip), %rax     # 0x7fff0
movq (%rax), %rdi
leaq 0x9a14(%rip), %rsi      # 0x4d004
leaq 0x23313(%rip), %rdx     # 0x6690a
pushq $0x2c
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/symcache.c
// Function: janet_symbol_deinit
void janet_symbol_deinit(const uint8_t *sym) {
    int status = 0;
    const uint8_t **bucket = janet_symcache_find(sym, &status);
    if (status) {
        janet_vm.cache_count--;
        janet_vm.cache_deleted++;
        *bucket = JANET_SYMCACHE_DELETED;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
leaq -0x14(%rbp), %r14
andl $0x0, (%r14)
movl -0x8(%rdi), %esi
movl -0x4(%rdi), %edx
movq %r14, %rcx
callq 0x43696
cmpl $0x0, (%r14)
je 0x4368d
movq %rax, %rbx
movq %fs:0x0, %rax
leaq -0x348(%rax), %rax
decl 0x7c(%rax)
incl 0x80(%rax)
leaq 0x232b2(%rip), %rax     # 0x6693c
movq %rax, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/janet-lang[P]janet/src/core/symcache.c
// Function: janet_symbol
const uint8_t *janet_symbol(const uint8_t *str, int32_t len) {
    int32_t hash = janet_string_calchash(str, len);
    uint8_t *newstr;
    int success = 0;
    const uint8_t **bucket = janet_symcache_findmem(str, len, hash, &success);
    if (success)
        return *bucket;
    JanetStringHead *head = janet_gcalloc(JANET_MEMORY_SYMBOL, sizeof(JanetStringHead) + (size_t) len + 1);
    head->hash = hash;
    head->length = len;
    newstr = (uint8_t *)(head->data);
    safe_memcpy(newstr, str, len);
    newstr[len] = 0;
    janet_symcache_put((const uint8_t *)newstr, bucket);
    return newstr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %r14d
movq %rdi, %rbx
callq 0x449cd
movl %eax, %r12d
leaq -0x34(%rbp), %r13
andl $0x0, (%r13)
movq %rbx, %rdi
movl %r14d, %esi
movl %eax, %edx
movq %r13, %rcx
callq 0x43696
movq %rax, %r15
cmpl $0x0, (%r13)
je 0x43832
movq (%r15), %r14
jmp 0x43877
movslq %r14d, %rax
movq %rax, -0x30(%rbp)
leaq 0x19(%rax), %rsi
pushq $0x2
popq %rdi
callq 0x291a0
movq %rax, %r13
movl %r12d, 0x14(%rax)
movl %r14d, 0x10(%rax)
leaq 0x18(%rax), %r14
movq %r14, %rdi
movq %rbx, %rsi
movq -0x30(%rbp), %rbx
movq %rbx, %rdx
callq 0x44ae2
movb $0x0, 0x18(%r13,%rbx)
movq %r14, %rdi
movq %r15, %rsi
callq 0x43889
movq %r14, %rax
addq $0x18, %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/symcache.c
// Function: janet_symcache_put
static void janet_symcache_put(const uint8_t *x, const uint8_t **bucket) {
    if ((janet_vm.cache_count + janet_vm.cache_deleted) * 2 > janet_vm.cache_capacity) {
        int status;
        janet_cache_resize(janet_tablen((2 * janet_vm.cache_count + 1)));
        bucket = janet_symcache_find(x, &status);
    }
    /* Add x to the cache */
    janet_vm.cache_count++;
    *bucket = x;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq %fs:0x0, %rax
leaq -0x348(%rax), %rax
movq %rax, %r14
movl 0x7c(%rax), %eax
movl 0x80(%r14), %ecx
addl %eax, %ecx
addl %ecx, %ecx
cmpl 0x78(%r14), %ecx
jbe 0x43984
movq %rbx, -0x40(%rbp)
leal 0x1(,%rax,2), %edi
callq 0x44ab0
movl %eax, %r12d
movq 0x70(%r14), %r15
movl %eax, %esi
shlq $0x3, %rsi
pushq $0x1
popq %rdi
callq 0x125a0
testq %rax, %rax
je 0x4399c
movl 0x78(%r14), %ebx
movq %rax, 0x70(%r14)
movl %r12d, 0x78(%r14)
movq %r14, -0x38(%rbp)
andl $0x0, 0x80(%r14)
xorl %r12d, %r12d
leaq 0x23021(%rip), %r14     # 0x6693c
cmpq %r12, %rbx
je 0x4395b
movq (%r15,%r12,8), %r13
testq %r13, %r13
sete %al
cmpq %r14, %r13
sete %cl
orb %al, %cl
jne 0x43956
movl -0x8(%r13), %esi
movl -0x4(%r13), %edx
movq %r13, %rdi
leaq -0x2c(%rbp), %rcx
callq 0x43696
cmpl $0x0, -0x2c(%rbp)
jne 0x4395b
testq %rax, %rax
je 0x4395b
movq %r13, (%rax)
incq %r12
jmp 0x4391b
movq %r15, %rdi
callq 0x120b0
movq -0x40(%rbp), %rbx
movl -0x8(%rbx), %esi
movl -0x4(%rbx), %edx
leaq -0x44(%rbp), %rcx
movq %rbx, %rdi
callq 0x43696
movq %rax, %r15
movq -0x38(%rbp), %r14
movl 0x7c(%r14), %eax
incl %eax
movl %eax, 0x7c(%r14)
movq %rbx, (%r15)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x3c64d(%rip), %rax     # 0x7fff0
movq (%rax), %rdi
leaq 0x9657(%rip), %rsi      # 0x4d004
leaq 0x22f56(%rip), %rdx     # 0x6690a
pushq $0x7c
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/symcache.c
// Function: janet_symbol_gen
const uint8_t *janet_symbol_gen(void) {
    const uint8_t **bucket = NULL;
    uint8_t *sym;
    int32_t hash = 0;
    int status;
    /* Leave spaces for 6 base 64 digits and two dashes. That means 64^6 possible suffixes, which
     * is enough for resolving collisions. */
    do {
        hash = janet_string_calchash(
                   janet_vm.gensym_counter,
                   sizeof(janet_vm.gensym_counter) - 1);
        bucket = janet_symcache_findmem(
                     janet_vm.gensym_counter,
                     sizeof(janet_vm.gensym_counter) - 1,
                     hash,
                     &status);
    } while (status && (inc_gensym(), 1));
    JanetStringHead *head = janet_gcalloc(JANET_MEMORY_SYMBOL, sizeof(JanetStringHead) + sizeof(janet_vm.gensym_counter));
    head->length = sizeof(janet_vm.gensym_counter) - 1;
    head->hash = hash;
    sym = (uint8_t *)(head->data);
    memcpy(sym, janet_vm.gensym_counter, sizeof(janet_vm.gensym_counter));
    sym[head->length] = 0;
    janet_symcache_put((const uint8_t *)sym, bucket);
    return (const uint8_t *)sym;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %fs:0x0, %rax
leaq -0x348(%rax), %rax
movq %rax, %r14
movq %rax, %rbx
addq $0x84, %rbx
pushq $0x7
popq %r15
movq %rbx, %rdi
movl %r15d, %esi
callq 0x449cd
movl %eax, %r13d
movq %rbx, %rdi
movl %r15d, %esi
movl %eax, %edx
leaq -0x2c(%rbp), %rcx
callq 0x43696
cmpl $0x0, -0x2c(%rbp)
je 0x43a7a
xorl %eax, %eax
cmpq $-0x6, %rax
je 0x43a13
movzbl 0x8a(%r14,%rax), %ecx
cmpl $0x5a, %ecx
jne 0x43a5c
movb $0x30, 0x8a(%r14,%rax)
decq %rax
jmp 0x43a3a
cmpl $0x39, %ecx
je 0x43a6a
cmpl $0x7a, %ecx
jne 0x43a6e
movb $0x41, %cl
jmp 0x43a70
movb $0x61, %cl
jmp 0x43a70
incb %cl
movb %cl, 0x8a(%r14,%rax)
jmp 0x43a13
movq %rax, %r12
pushq $0x2
popq %rdi
pushq $0x20
popq %rsi
callq 0x291a0
movl $0x7, 0x10(%rax)
movl %r13d, 0x14(%rax)
leaq 0x18(%rax), %r14
movq (%rbx), %rcx
movq %rcx, 0x18(%rax)
movb $0x0, 0x1f(%rax)
movq %r14, %rdi
movq %r12, %rsi
callq 0x43889
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/janet-lang[P]janet/src/core/table.c
// Function: janet_table_init_impl
static JanetTable *janet_table_init_impl(JanetTable *table, int32_t capacity, int stackalloc) {
    JanetKV *data;
    capacity = janet_tablen(capacity);
    if (stackalloc) table->gc.flags = JANET_TABLE_FLAG_STACK;
    if (capacity) {
        if (stackalloc) {
            data = janet_memalloc_empty_local(capacity);
        } else {
            data = (JanetKV *) janet_memalloc_empty(capacity);
            if (NULL == data) {
                JANET_OUT_OF_MEMORY;
            }
        }
        table->data = data;
        table->capacity = capacity;
    } else {
        table->data = NULL;
        table->capacity = 0;
    }
    table->count = 0;
    table->deleted = 0;
    table->proto = NULL;
    return table;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r15d
movq %rdi, %rbx
movl %esi, %edi
callq 0x44ab0
movl %eax, %r14d
testl %r15d, %r15d
je 0x43b00
movl $0x10000, (%rbx)        # imm = 0x10000
testl %r14d, %r14d
je 0x43b3c
movl %r14d, %edi
callq 0x445e0
jmp 0x43b41
testl %r14d, %r14d
je 0x43b3c
movl %r14d, %edi
callq 0x4b492
testq %rax, %rax
jne 0x43b41
movq 0x3c4d7(%rip), %rax     # 0x7fff0
movq (%rax), %rdi
leaq 0x94e1(%rip), %rsi      # 0x4d004
leaq 0x22e13(%rip), %rdx     # 0x6693d
pushq $0x37
popq %rcx
xorl %eax, %eax
callq 0x125e0
pushq $0x1
popq %rdi
callq 0x12a60
xorl %eax, %eax
xorl %r14d, %r14d
movq %rax, 0x20(%rbx)
movl %r14d, 0x14(%rbx)
andl $0x0, 0x10(%rbx)
andl $0x0, 0x18(%rbx)
andq $0x0, 0x28(%rbx)
movq %rbx, %rax
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/table.c
// Function: janet_table_deinit
void janet_table_deinit(JanetTable *table) {
    if (table->gc.flags & JANET_TABLE_FLAG_STACK) {
        janet_sfree(table->data);
    } else {
        janet_free(table->data);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testb $0x1, 0x2(%rdi)
movq 0x20(%rdi), %rdi
jne 0x43b84
popq %rbp
jmp 0x120b0
popq %rbp
jmp 0x298c1
// File: /workspace/github_c_makefile_star2_O2/janet-lang[P]janet/src/core/table.c
// Function: janet_table_get
Janet janet_table_get(JanetTable *t, Janet key) {
    for (int i = JANET_MAX_PROTO_DEPTH; t && i; t = t->proto, --i) {
        JanetKV *bucket = janet_table_find(t, key);
        if (NULL != bucket && !janet_checktype(bucket->key, JANET_NIL))
            return bucket->value;
    }
    return janet_wrap_nil();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
movl $0xffffff38, %r12d      # imm = 0xFFFFFF38
movabsq $-0x7800000000000, %rbx # imm = 0xFFF8800000000000
movabsq $-0x800000000000, %r13  # imm = 0xFFFF800000000000
testq %r15, %r15
je 0x43c91
testl %r12d, %r12d
je 0x43c91
movq %r15, %rdi
movq %r14, %rsi
callq 0x43c1e
testq %rax, %rax
je 0x43c88
movq (%rax), %rcx
andq %r13, %rcx
cmpq %rbx, %rcx
jne 0x43caa
movq 0x28(%r15), %r15
incl %r12d
jmp 0x43c63
incq %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4b313
movq 0x8(%rax), %rax
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/table.c
// Function: janet_table_get_ex
Janet janet_table_get_ex(JanetTable *t, Janet key, JanetTable **which) {
    for (int i = JANET_MAX_PROTO_DEPTH; t && i; t = t->proto, --i) {
        JanetKV *bucket = janet_table_find(t, key);
        if (NULL != bucket && !janet_checktype(bucket->key, JANET_NIL)) {
            *which = t;
            return bucket->value;
        }
    }
    return janet_wrap_nil();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, -0x30(%rbp)
movq %rsi, %r12
movq %rdi, %r15
movl $0xffffff38, %r13d      # imm = 0xFFFFFF38
movabsq $-0x7800000000000, %r14 # imm = 0xFFF8800000000000
movabsq $-0x800000000000, %rbx  # imm = 0xFFFF800000000000
testq %r15, %r15
je 0x43d1d
testl %r13d, %r13d
je 0x43d1d
movq %r15, %rdi
movq %r12, %rsi
callq 0x43c1e
testq %rax, %rax
je 0x43d14
movq (%rax), %rcx
andq %rbx, %rcx
cmpq %r14, %rcx
jne 0x43d36
movq 0x28(%r15), %r15
incl %r13d
jmp 0x43cef
incq %r14
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4b313
movq -0x30(%rbp), %rcx
movq %r15, (%rcx)
movq 0x8(%rax), %rax
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/table.c
// Function: janet_table_rawget
Janet janet_table_rawget(JanetTable *t, Janet key) {
    JanetKV *bucket = janet_table_find(t, key);
    if (NULL != bucket && !janet_checktype(bucket->key, JANET_NIL))
        return bucket->value;
    else
        return janet_wrap_nil();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movabsq $-0x7800000000000, %rbx # imm = 0xFFF8800000000000
callq 0x43c1e
testq %rax, %rax
je 0x43d7c
movabsq $-0x800000000000, %rcx  # imm = 0xFFFF800000000000
andq (%rax), %rcx
cmpq %rbx, %rcx
jne 0x43d8d
incq %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x4b313
movq 0x8(%rax), %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/janet-lang[P]janet/src/core/table.c
// Function: janet_table_remove
Janet janet_table_remove(JanetTable *t, Janet key) {
    JanetKV *bucket = janet_table_find(t, key);
    if (NULL != bucket && !janet_checktype(bucket->key, JANET_NIL)) {
        Janet ret = bucket->value;
        t->count--;
        t->deleted++;
        bucket->key = janet_wrap_nil();
        bucket->value = janet_wrap_false();
        return ret;
    } else {
        return janet_wrap_nil();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r15
movabsq $-0x77fffffffffff, %r14 # imm = 0xFFF8800000000001
callq 0x43c1e
testq %rax, %rax
je 0x43dd3
movq %rax, %rbx
movabsq $-0x800000000000, %rax  # imm = 0xFFFF800000000000
andq (%rbx), %rax
leaq -0x1(%r14), %rcx
cmpq %rcx, %rax
jne 0x43de3
movq %r14, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x4b313
movq 0x8(%rbx), %r12
decl 0x10(%r15)
incl 0x18(%r15)
movq %r14, %rdi
callq 0x4b313
movq %rax, (%rbx)
movabsq $-0x7000000000000, %rdi # imm = 0xFFF9000000000000
callq 0x4b313
movq %rax, 0x8(%rbx)
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/janet-lang[P]janet/src/core/table.c
// Function: janet_table_put
void janet_table_put(JanetTable *t, Janet key, Janet value) {
    if (janet_checktype(key, JANET_NIL)) return;
    if (janet_checktype(key, JANET_NUMBER) && isnan(janet_unwrap_number(key))) return;
    if (janet_checktype(value, JANET_NIL)) {
        janet_table_remove(t, key);
    } else {
        JanetKV *bucket = janet_table_find(t, key);
        if (NULL != bucket && !janet_checktype(bucket->key, JANET_NIL)) {
            bucket->value = value;
        } else {
            if (NULL == bucket || 2 * (t->count + t->deleted + 1) > t->capacity) {
                janet_table_rehash(t, janet_tablen(2 * t->count + 2));
            }
            bucket = janet_table_find(t, key);
            if (janet_checktype(bucket->value, JANET_BOOLEAN))
                --t->deleted;
            bucket->key = key;
            bucket->value = value;
            ++t->count;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rax
shrq $0x2f, %rax
cmpl $0x1fff1, %eax          # imm = 0x1FFF1
je 0x43f1f
movq %rsi, %r15
movq %rsi, %xmm0
ucomisd %xmm0, %xmm0
setp %al
movabsq $0x7800000000000, %rcx  # imm = 0x7800000000000
testq %rcx, %rsi
sete %cl
testb %cl, %al
jne 0x43f1f
movq %rdx, %rbx
movq %rdi, %r14
movabsq $-0x800000000000, %r12  # imm = 0xFFFF800000000000
movabsq $-0x7800000000000, %r13 # imm = 0xFFF8800000000000
movq %rdx, %rax
andq %r12, %rax
cmpq %r13, %rax
jne 0x43e9e
movq %r14, %rdi
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x43d98
movq %r14, %rdi
movq %r15, %rsi
callq 0x43c1e
testq %rax, %rax
je 0x43ed2
movq (%rax), %rcx
andq %r12, %rcx
cmpq %r13, %rcx
jne 0x43f1b
movl 0x10(%r14), %eax
movl 0x18(%r14), %ecx
addl %eax, %ecx
leal 0x2(,%rcx,2), %ecx
cmpl 0x14(%r14), %ecx
jg 0x43ed6
jmp 0x43eec
movl 0x10(%r14), %eax
leal 0x2(,%rax,2), %edi
callq 0x44ab0
movq %r14, %rdi
movl %eax, %esi
callq 0x43f2e
movq %r14, %rdi
movq %r15, %rsi
callq 0x43c1e
andq 0x8(%rax), %r12
movabsq $-0x7000000000000, %rcx # imm = 0xFFF9000000000000
cmpq %rcx, %r12
jne 0x43f0e
decl 0x18(%r14)
movq %r15, (%rax)
movq %rbx, 0x8(%rax)
incl 0x10(%r14)
jmp 0x43f1f
movq %rbx, 0x8(%rax)
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/table.c
// Function: janet_table_rehash
static void janet_table_rehash(JanetTable *t, int32_t size) {
    JanetKV *olddata = t->data;
    JanetKV *newdata;
    int islocal = t->gc.flags & JANET_TABLE_FLAG_STACK;
    if (islocal) {
        newdata = (JanetKV *) janet_memalloc_empty_local(size);
    } else {
        newdata = (JanetKV *) janet_memalloc_empty(size);
        if (NULL == newdata) {
            JANET_OUT_OF_MEMORY;
        }
    }
    int32_t oldcapacity = t->capacity;
    t->data = newdata;
    t->capacity = size;
    t->deleted = 0;
    for (int32_t i = 0; i < oldcapacity; i++) {
        JanetKV *kv = olddata + i;
        if (!janet_checktype(kv->key, JANET_NIL)) {
            JanetKV *newkv = janet_table_find(t, kv->key);
            *newkv = *kv;
        }
    }
    if (islocal) {
        janet_sfree(olddata);
    } else {
        janet_free(olddata);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %r15d
movq %rdi, %r14
movq 0x20(%rdi), %rbx
movl (%rdi), %eax
movl %eax, -0x2c(%rbp)
movl %esi, %edi
btl $0x10, %eax
jb 0x43f87
callq 0x4b492
testq %rax, %rax
jne 0x43f8c
movq 0x3c08c(%rip), %rax     # 0x7fff0
movq (%rax), %rdi
leaq 0x9096(%rip), %rsi      # 0x4d004
leaq 0x229c8(%rip), %rdx     # 0x6693d
pushq $0x7f
popq %rcx
xorl %eax, %eax
callq 0x125e0
pushq $0x1
popq %rdi
callq 0x12a60
callq 0x445e0
movl 0x14(%r14), %r13d
movq %rax, 0x20(%r14)
movl %r15d, 0x14(%r14)
andl $0x0, 0x18(%r14)
xorl %r15d, %r15d
testl %r13d, %r13d
cmovlel %r15d, %r13d
shlq $0x4, %r13
cmpq %r15, %r13
je 0x43fdc
movq (%rbx,%r15), %rsi
movq %rsi, %rax
shrq $0x2f, %rax
cmpl $0x1fff1, %eax          # imm = 0x1FFF1
je 0x43fd6
leaq (%rbx,%r15), %r12
movq %r14, %rdi
callq 0x43c1e
movups (%r12), %xmm0
movups %xmm0, (%rax)
addq $0x10, %r15
jmp 0x43fab
btl $0x10, -0x2c(%rbp)
jb 0x43ff9
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x120b0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x298c1
// File: /workspace/github_c_makefile_star2_O2/janet-lang[P]janet/src/core/table.c
// Function: janet_table_clear
void janet_table_clear(JanetTable *t) {
    int32_t capacity = t->capacity;
    JanetKV *data = t->data;
    janet_memempty(data, capacity);
    t->count = 0;
    t->deleted = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x14(%rdi), %esi
movq 0x20(%rdi), %rdi
callq 0x4b52f
andl $0x0, 0x10(%rbx)
andl $0x0, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/janet-lang[P]janet/src/core/table.c
// Function: janet_table_clone
JanetTable *janet_table_clone(JanetTable *table) {
    JanetTable *newTable = janet_gcalloc(JANET_MEMORY_TABLE, sizeof(JanetTable));
    newTable->count = table->count;
    newTable->capacity = table->capacity;
    newTable->deleted = table->deleted;
    newTable->proto = table->proto;
    newTable->data = janet_malloc(newTable->capacity * sizeof(JanetKV));
    if (NULL == newTable->data) {
        JANET_OUT_OF_MEMORY;
    }
    memcpy(newTable->data, table->data, (size_t) table->capacity * sizeof(JanetKV));
    return newTable;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x5
popq %rdi
pushq $0x30
popq %rsi
callq 0x291a0
movq %rax, %r14
movl 0x10(%rbx), %eax
movl %eax, 0x10(%r14)
movslq 0x14(%rbx), %r15
movl %r15d, 0x14(%r14)
movl 0x18(%rbx), %eax
movl %eax, 0x18(%r14)
movq 0x28(%rbx), %rax
movq %rax, 0x28(%r14)
shlq $0x4, %r15
movq %r15, %rdi
callq 0x12760
movq %rax, 0x20(%r14)
testq %rax, %rax
je 0x4409e
movq 0x20(%rbx), %rsi
movq %rax, %rdi
movq %r15, %rdx
callq 0x12670
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x3bf4b(%rip), %rax     # 0x7fff0
movq (%rax), %rdi
leaq 0x8f55(%rip), %rsi      # 0x4d004
leaq 0x22887(%rip), %rdx     # 0x6693d
movl $0xfe, %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/table.c
// Function: janet_table_mergekv
static void janet_table_mergekv(JanetTable *table, const JanetKV *kvs, int32_t cap) {
    int32_t i;
    for (i = 0; i < cap; i++) {
        const JanetKV *kv = kvs + i;
        if (!janet_checktype(kv->key, JANET_NIL)) {
            janet_table_put(table, kv->key, kv->value);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
testl %edx, %edx
cmovlel %r12d, %ebx
shlq $0x4, %rbx
cmpq %r12, %rbx
je 0x44125
movq (%r14,%r12), %rsi
movq %rsi, %rax
shrq $0x2f, %rax
cmpl $0x1fff1, %eax          # imm = 0x1FFF1
je 0x4411f
movq 0x8(%r14,%r12), %rdx
movq %r15, %rdi
callq 0x43e19
addq $0x10, %r12
jmp 0x440fb
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/janet-lang[P]janet/src/core/table.c
// Function: janet_table_to_struct
const JanetKV *janet_table_to_struct(JanetTable *t) {
    JanetKV *st = janet_struct_begin(t->count);
    JanetKV *kv = t->data;
    JanetKV *end = t->data + t->capacity;
    while (kv < end) {
        if (!janet_checktype(kv->key, JANET_NIL))
            janet_struct_put(st, kv->key, kv->value);
        kv++;
    }
    return janet_struct_end(st);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl 0x10(%rdi), %edi
callq 0x42cb8
movq %rax, %rbx
movq 0x20(%r14), %r15
movslq 0x14(%r14), %r14
shlq $0x4, %r14
addq %r15, %r14
cmpq %r14, %r15
jae 0x44187
movq (%r15), %rsi
movq %rsi, %rax
shrq $0x2f, %rax
cmpl $0x1fff1, %eax          # imm = 0x1FFF1
je 0x44181
movq 0x8(%r15), %rdx
movq %rbx, %rdi
callq 0x4300f
addq $0x10, %r15
jmp 0x4415f
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4301e
// File: /workspace/github_c_makefile_star2_O2/janet-lang[P]janet/src/core/table.c
// Function: janet_table_proto_flatten
JanetTable *janet_table_proto_flatten(JanetTable *t) {
    JanetTable *newTable = janet_table(0);
    while (t) {
        JanetKV *kv = t->data;
        JanetKV *end = t->data + t->capacity;
        while (kv < end) {
            if (!janet_checktype(kv->key, JANET_NIL))
                janet_table_put_no_overwrite(newTable, kv->key, kv->value);
            kv++;
        }
        t = t->proto;
    }
    return newTable;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r15
movabsq $-0x800000000000, %rbx  # imm = 0xFFFF800000000000
xorl %edi, %edi
callq 0x43b8a
movq %rbx, %rdx
movq %rax, %r14
testq %r15, %r15
je 0x442b8
movq 0x20(%r15), %rbx
movq %r15, -0x30(%rbp)
movslq 0x14(%r15), %r13
shlq $0x4, %r13
addq %rbx, %r13
cmpq %r13, %rbx
jae 0x442ab
movq (%rbx), %r15
movq %r15, %rax
andq %rdx, %rax
movabsq $-0x7800000000000, %rcx # imm = 0xFFF8800000000000
cmpq %rcx, %rax
je 0x442a2
movq %rdx, %r12
movq 0x8(%rbx), %rax
movq %rax, -0x38(%rbp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x43c1e
testq %rax, %rax
je 0x44251
movq (%rax), %rax
movq %r12, %rdx
andq %r12, %rax
movabsq $-0x7800000000000, %rcx # imm = 0xFFF8800000000000
cmpq %rcx, %rax
jne 0x442a2
movl 0x10(%r14), %eax
movl 0x18(%r14), %ecx
addl %eax, %ecx
leal 0x2(,%rcx,2), %ecx
cmpl 0x14(%r14), %ecx
jg 0x44255
jmp 0x4426b
movl 0x10(%r14), %eax
leal 0x2(,%rax,2), %edi
callq 0x44ab0
movq %r14, %rdi
movl %eax, %esi
callq 0x43f2e
movq %r14, %rdi
movq %r15, %rsi
callq 0x43c1e
movq 0x8(%rax), %rcx
movq %r12, %rdx
andq %r12, %rcx
movabsq $-0x7000000000000, %rsi # imm = 0xFFF9000000000000
cmpq %rsi, %rcx
jne 0x44293
decl 0x18(%r14)
movq %r15, (%rax)
movq -0x38(%rbp), %rcx
movq %rcx, 0x8(%rax)
incl 0x10(%r14)
addq $0x10, %rbx
jmp 0x441e0
movq -0x30(%rbp), %r15
movq 0x28(%r15), %r15
jmp 0x441c4
movq %r14, %rax
addq $0x18, %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/table.c
// Function: janet_memalloc_empty_local
static void *janet_memalloc_empty_local(int32_t count) {
    int32_t i;
    void *mem = janet_smalloc((size_t) count * sizeof(JanetKV));
    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 %r12
pushq %rbx
movabsq $-0x77fffffffffff, %rbx # imm = 0xFFF8800000000001
movslq %edi, %r15
movq %r15, %rdi
shlq $0x4, %rdi
callq 0x29673
movq %rax, %r14
xorl %r12d, %r12d
testl %r15d, %r15d
cmovlel %r12d, %r15d
shlq $0x4, %r15
cmpq %r12, %r15
je 0x44639
movq %rbx, %rdi
callq 0x4b313
movq %rax, (%r14,%r12)
movq %rbx, %rdi
callq 0x4b313
movq %rax, 0x8(%r14,%r12)
addq $0x10, %r12
jmp 0x44615
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/janet-lang[P]janet/src/core/tuple.c
// Function: janet_tuple_begin
Janet *janet_tuple_begin(int32_t length) {
    size_t size = sizeof(JanetTupleHead) + ((size_t) length * sizeof(Janet));
    JanetTupleHead *head = janet_gcalloc(JANET_MEMORY_TUPLE, size);
    head->sm_line = -1;
    head->sm_column = -1;
    head->length = length;
    return (Janet *)(head->data);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movslq %edi, %rbx
leaq 0x20(,%rbx,8), %rsi
pushq $0x4
popq %rdi
callq 0x291a0
orq $-0x1, 0x18(%rax)
movl %ebx, 0x10(%rax)
addq $0x20, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/janet-lang[P]janet/src/core/util.c
// Function: janet_string_calchash
int32_t janet_string_calchash(const uint8_t *str, int32_t len) {
    if (NULL == str || len == 0) return 5381;
    const uint8_t *end = str + len;
    uint32_t hash = 5381;
    while (str < end)
        hash = (hash << 5) + hash + *str++;
    hash = janet_hash_mix(hash, (uint32_t) len);
    return (int32_t) hash;
}

// Assembly:
testq %rdi, %rdi
sete %al
testl %esi, %esi
sete %cl
orb %al, %cl
je 0x449e2
movl $0x1505, %eax           # imm = 0x1505
retq
pushq %rbp
movq %rsp, %rbp
movslq %esi, %rcx
addq %rdi, %rcx
movl $0x1505, %eax           # imm = 0x1505
cmpq %rcx, %rdi
jae 0x44a03
imull $0x21, %eax, %edx
movzbl (%rdi), %eax
incq %rdi
addl %edx, %eax
jmp 0x449f1
movl %eax, %edi
popq %rbp
jmp 0x449a4
// File: /workspace/github_c_makefile_star2_O2/janet-lang[P]janet/src/core/util.c
// Function: janet_array_calchash
int32_t janet_array_calchash(const Janet *array, int32_t len) {
    const Janet *end = array + len;
    uint32_t hash = 33;
    while (array < end) {
        hash = janet_hash_mix(hash, janet_hash(*array++));
    }
    return (int32_t) hash;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq %esi, %rax
leaq (%rdi,%rax,8), %r15
pushq $0x21
popq %r14
cmpq %r15, %rbx
jae 0x44a43
movq (%rbx), %rdi
addq $0x8, %rbx
callq 0x46ba4
movl %r14d, %edi
movl %eax, %esi
callq 0x449a4
movl %eax, %r14d
jmp 0x44a23
movl %r14d, %eax
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/util.c
// Function: janet_kv_calchash
int32_t janet_kv_calchash(const JanetKV *kvs, int32_t len) {
    const JanetKV *end = kvs + len;
    uint32_t hash = 33;
    while (kvs < end) {
        hash = janet_hash_mix(hash, janet_hash(kvs->key));
        hash = janet_hash_mix(hash, janet_hash(kvs->value));
        kvs++;
    }
    return (int32_t) hash;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq %esi, %r15
shlq $0x4, %r15
addq %rdi, %r15
pushq $0x21
popq %r14
cmpq %r15, %rbx
jae 0x44aa2
movq (%rbx), %rdi
callq 0x46ba4
movl %r14d, %edi
movl %eax, %esi
callq 0x449a4
movl %eax, %r14d
movq 0x8(%rbx), %rdi
callq 0x46ba4
movl %r14d, %edi
movl %eax, %esi
callq 0x449a4
movl %eax, %r14d
addq $0x10, %rbx
jmp 0x44a6c
movl %r14d, %eax
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/util.c
// Function: janet_tablen
int32_t janet_tablen(int32_t n) {
    if (n < 0) return 0;
    n |= n >> 1;
    n |= n >> 2;
    n |= n >> 4;
    n |= n >> 8;
    n |= n >> 16;
    return n + 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testl %edi, %edi
js 0x44ade
movl %edi, %eax
shrl %eax
orl %edi, %eax
movl %eax, %ecx
shrl $0x2, %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x4, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x8, %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x10, %eax
orl %ecx, %eax
incl %eax
jmp 0x44ae0
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/janet-lang[P]janet/src/core/util.c
// Function: janet_dict_find
const JanetKV *janet_dict_find(const JanetKV *buckets, int32_t cap, Janet key) {
    int32_t index = janet_maphash(cap, janet_hash(key));
    int32_t i;
    const JanetKV *first_bucket = NULL;
    /* Higher half */
    for (i = index; i < cap; i++) {
        const JanetKV *kv = buckets + i;
        if (janet_checktype(kv->key, JANET_NIL)) {
            if (janet_checktype(kv->value, JANET_NIL)) {
                return kv;
            } else if (NULL == first_bucket) {
                first_bucket = kv;
            }
        } else if (janet_equals(kv->key, key)) {
            return buckets + i;
        }
    }
    /* Lower half */
    for (i = 0; i < index; i++) {
        const JanetKV *kv = buckets + i;
        if (janet_checktype(kv->key, JANET_NIL)) {
            if (janet_checktype(kv->value, JANET_NIL)) {
                return kv;
            } else if (NULL == first_bucket) {
                first_bucket = kv;
            }
        } else if (janet_equals(kv->key, key)) {
            return buckets + i;
        }
    }
    return first_bucket;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %r15d
movq %rdi, -0x30(%rbp)
movq %rdx, -0x38(%rbp)
movq %rdx, %rdi
callq 0x46ba4
leal -0x1(%r15), %ebx
andl %eax, %ebx
movslq %ebx, %r12
movslq %r15d, %r13
movq %r12, %r14
shlq $0x4, %r14
addq -0x30(%rbp), %r14
xorl %r15d, %r15d
cmpq %r13, %r12
jge 0x44b8b
movq (%r14), %rdi
movq %rdi, %rax
movabsq $-0x800000000000, %rcx  # imm = 0xFFFF800000000000
andq %rcx, %rax
movabsq $-0x7800000000000, %rdx # imm = 0xFFF8800000000000
cmpq %rdx, %rax
jne 0x44b71
movq 0x8(%r14), %rax
andq %rcx, %rax
cmpq %rdx, %rax
je 0x44c04
testq %r15, %r15
cmoveq %r14, %r15
jmp 0x44b82
movq -0x38(%rbp), %rsi
callq 0x466c8
testl %eax, %eax
jne 0x44c04
incq %r12
addq $0x10, %r14
jmp 0x44b31
xorl %r14d, %r14d
testl %ebx, %ebx
cmovlel %r14d, %ebx
movq -0x30(%rbp), %r13
movq %r13, %r12
movabsq $-0x800000000000, %rcx  # imm = 0xFFFF800000000000
movabsq $-0x7800000000000, %rdx # imm = 0xFFF8800000000000
subq $0x1, %rbx
jb 0x44c18
movq (%r12), %rdi
movq %rdi, %rax
andq %rcx, %rax
cmpq %rdx, %rax
jne 0x44bda
movq 0x8(%r12), %rax
andq %rcx, %rax
cmpq %rdx, %rax
je 0x44c09
testq %r15, %r15
cmoveq %r12, %r15
jmp 0x44bfb
movq -0x38(%rbp), %rsi
callq 0x466c8
movabsq $-0x7800000000000, %rdx # imm = 0xFFF8800000000000
movabsq $-0x800000000000, %rcx  # imm = 0xFFFF800000000000
testl %eax, %eax
jne 0x44c15
incq %r14
addq $0x10, %r12
jmp 0x44baf
movq %r14, %r15
jmp 0x44c18
shlq $0x4, %r14
addq %r14, %r13
movq %r13, %r15
jmp 0x44c18
movq %r12, %r15
movq %r15, %rax
addq $0x18, %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/util.c
// Function: janet_dictionary_get
Janet janet_dictionary_get(const JanetKV *data, int32_t cap, Janet key) {
    const JanetKV *kv = janet_dict_find(data, cap, key);
    if (kv && !janet_checktype(kv->key, JANET_NIL)) {
        return kv->value;
    }
    return janet_wrap_nil();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movabsq $-0x7800000000000, %rbx # imm = 0xFFF8800000000000
callq 0x44af3
testq %rax, %rax
je 0x44c56
movabsq $-0x800000000000, %rcx  # imm = 0xFFFF800000000000
andq (%rax), %rcx
cmpq %rbx, %rcx
jne 0x44c67
incq %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x4b313
movq 0x8(%rax), %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/janet-lang[P]janet/src/core/util.c
// Function: janet_dictionary_next
const JanetKV *janet_dictionary_next(const JanetKV *kvs, int32_t cap, const JanetKV *kv) {
    const JanetKV *end = kvs + cap;
    kv = (kv == NULL) ? kvs : kv + 1;
    while (kv < end) {
        if (!janet_checktype(kv->key, JANET_NIL))
            return kv;
        kv++;
    }
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movslq %esi, %rcx
shlq $0x4, %rcx
addq %rdi, %rcx
leaq 0x10(%rdx), %rax
testq %rdx, %rdx
cmoveq %rdi, %rax
cmpq %rcx, %rax
jae 0x44ca5
movq (%rax), %rdx
shrq $0x2f, %rdx
cmpl $0x1fff1, %edx          # imm = 0x1FFF1
jne 0x44ca7
addq $0x10, %rax
jmp 0x44c8b
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/janet-lang[P]janet/src/core/util.c
// Function: janet_cstrcmp
int janet_cstrcmp(const uint8_t *str, const char *other) {
    int32_t len = janet_string_length(str);
    int32_t index;
    for (index = 0; index < len; index++) {
        uint8_t c = str[index];
        uint8_t k = ((const uint8_t *)other)[index];
        if (c < k) return -1;
        if (c > k) return 1;
        if (k == '\0') break;
    }
    return (other[index] == '\0') ? 0 : -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl -0x8(%rdi), %ecx
xorl %edx, %edx
testl %ecx, %ecx
cmovlel %edx, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl $0x1, %r8d
cmpq %rdx, %rcx
je 0x44ce5
movb (%rsi,%rdx), %r9b
cmpb %r9b, (%rdi,%rdx)
jb 0x44cec
ja 0x44cdd
testb %r9b, %r9b
je 0x44ce2
incq %rdx
jmp 0x44cc2
movl %r8d, %eax
jmp 0x44cec
movq %rdx, %rcx
xorl %eax, %eax
cmpb (%rsi,%rcx), %al
sbbl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/janet-lang[P]janet/src/core/util.c
// Function: janet_strbinsearch
const void *janet_strbinsearch(
    const void *tab,
    size_t tabcount,
    size_t itemsize,
    const uint8_t *key) {
    size_t low = 0;
    size_t hi = tabcount;
    const char *t = (const char *)tab;
    while (low < hi) {
        size_t mid = low + ((hi - low) / 2);
        const char **item = (const char **)(t + mid * itemsize);
        const char *name = *item;
        int comp = janet_cstrcmp(key, name);
        if (comp < 0) {
            hi = mid;
        } else if (comp > 0) {
            low = mid + 1;
        } else {
            return (const void *)item;
        }
    }
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
movq %rsi, %r15
movq %rdi, %r14
xorl %ebx, %ebx
movq %r15, %r13
subq %rbx, %r13
jbe 0x44d45
shrq %r13
addq %rbx, %r13
movq %r13, %r12
imulq -0x30(%rbp), %r12
movq (%r14,%r12), %rsi
movq -0x38(%rbp), %rdi
callq 0x44ca9
testl %eax, %eax
js 0x44d40
je 0x44d49
incq %r13
movq %r13, %rbx
jmp 0x44d0f
movq %r13, %r15
jmp 0x44d0f
xorl %eax, %eax
jmp 0x44d4f
addq %r12, %r14
movq %r14, %rax
addq $0x18, %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/util.c
// Function: janet_def_sm
void janet_def_sm(JanetTable *env, const char *name, Janet val, const char *doc, const char *source_file, int32_t source_line) {
    JanetTable *subt = janet_table(2);
    janet_table_put(subt, janet_ckeywordv("value"), val);
    janet_add_meta(subt, doc, source_file, source_line);
    janet_table_put(env, janet_csymbolv(name), janet_wrap_table(subt));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, %r12d
movq %r8, %r13
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, -0x30(%rbp)
movq %rdi, -0x38(%rbp)
pushq $0x2
popq %rdi
callq 0x43b8a
movq %rax, %r14
leaq 0x14271(%rip), %rdi     # 0x59006
callq 0x439c6
movabsq $-0x5000000000000, %rsi # imm = 0xFFFB000000000000
movq %rax, %rdi
callq 0x4b366
movq %r14, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x43e19
movq %r14, %rdi
movq %rbx, %rsi
movq %r13, %rdx
movl %r12d, %ecx
callq 0x44e18
movq -0x30(%rbp), %rdi
callq 0x439c6
movabsq $-0x5800000000000, %rsi # imm = 0xFFFA800000000000
movq %rax, %rdi
callq 0x4b366
movq %rax, %rbx
movabsq $-0x3800000000000, %rsi # imm = 0xFFFC800000000000
movq %r14, %rdi
callq 0x4b3ab
movq -0x38(%rbp), %rdi
movq %rbx, %rsi
movq %rax, %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x43e19
// File: /workspace/github_c_makefile_star2_O2/janet-lang[P]janet/src/core/util.c
// Function: janet_add_meta
static void janet_add_meta(JanetTable *table, const char *doc, const char *source_file, int32_t source_line) {
    if (doc) {
        janet_table_put(table, janet_ckeywordv("doc"), janet_cstringv(doc));
    }
    if (source_file && source_line) {
        Janet triple[3];
        triple[0] = janet_cstringv(source_file);
        triple[1] = janet_wrap_integer(source_line);
        triple[2] = janet_wrap_integer(1);
        Janet value = janet_wrap_tuple(janet_tuple_n(triple, 3));
        janet_table_put(table, janet_ckeywordv("source-map"), value);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, %r15d
movq %rdx, %r13
movq %rdi, %rbx
movabsq $-0x5000000000000, %r12 # imm = 0xFFFB000000000000
movabsq $-0x6000000000000, %rax # imm = 0xFFFA000000000000
testq %rsi, %rsi
je 0x44ea4
movq %rsi, %r14
leaq 0x1fac7(%rip), %rdi     # 0x6491c
callq 0x439c6
movq %rax, %rdi
movq %r12, %rsi
callq 0x4b366
movq %rax, %r12
movq %r14, %rdi
callq 0x411ea
movq %rax, %rdi
movabsq $-0x6000000000000, %rsi # imm = 0xFFFA000000000000
callq 0x4b366
movq %rbx, %rdi
movq %r12, %rsi
movabsq $-0x5000000000000, %r12 # imm = 0xFFFB000000000000
movq %rax, %rdx
callq 0x43e19
movabsq $-0x6000000000000, %rax # imm = 0xFFFA000000000000
movq %rbx, -0x30(%rbp)
movq %rax, %rbx
testq %r13, %r13
sete %al
testl %r15d, %r15d
sete %cl
orb %al, %cl
jne 0x44f3a
movq %r13, %rdi
callq 0x411ea
movq %rax, %rdi
movq %rbx, %rsi
callq 0x4b366
leaq -0x50(%rbp), %r14
movq %rax, (%r14)
cvtsi2sd %r15d, %xmm0
callq 0x4b471
movq %rax, 0x8(%r14)
movsd 0xb42d(%rip), %xmm0     # 0x50318
callq 0x4b471
movq %rax, 0x10(%r14)
pushq $0x3
popq %rsi
movq %r14, %rdi
callq 0x44692
movabsq $-0x4000000000000, %rsi # imm = 0xFFFC000000000000
movq %rax, %rdi
callq 0x4b366
movq %rax, %r14
leaq 0x1faea(%rip), %rdi     # 0x64a05
callq 0x439c6
movq %rax, %rdi
movq %r12, %rsi
callq 0x4b366
movq -0x30(%rbp), %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x43e19
addq $0x28, %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/util.c
// Function: janet_var_sm
void janet_var_sm(JanetTable *env, const char *name, Janet val, const char *doc, const char *source_file, int32_t source_line) {
    JanetArray *array = janet_array(1);
    JanetTable *subt = janet_table(2);
    janet_array_push(array, val);
    janet_table_put(subt, janet_ckeywordv("ref"), janet_wrap_array(array));
    janet_add_meta(subt, doc, source_file, source_line);
    janet_table_put(env, janet_csymbolv(name), janet_wrap_table(subt));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, -0x2c(%rbp)
movq %r8, %r13
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, -0x38(%rbp)
movq %rdi, -0x40(%rbp)
pushq $0x1
popq %rdi
callq 0x12f68
movq %rax, %r15
pushq $0x2
popq %rdi
callq 0x43b8a
movq %rax, %r12
movq %r15, %rdi
movq %r14, %rsi
callq 0x131d2
leaq 0x1f130(%rip), %rdi     # 0x640d7
callq 0x439c6
movabsq $-0x5000000000000, %rsi # imm = 0xFFFB000000000000
movq %rax, %rdi
callq 0x4b366
movq %rax, %r14
movabsq $-0x4800000000000, %rsi # imm = 0xFFFB800000000000
movq %r15, %rdi
callq 0x4b3ab
movq %r12, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x43e19
movq %r12, %rdi
movq %rbx, %rsi
movq %r13, %rdx
movl -0x2c(%rbp), %ecx
callq 0x44e18
movq -0x38(%rbp), %rdi
callq 0x439c6
movabsq $-0x5800000000000, %rsi # imm = 0xFFFA800000000000
movq %rax, %rdi
callq 0x4b366
movq %rax, %rbx
movabsq $-0x3800000000000, %rsi # imm = 0xFFFC800000000000
movq %r12, %rdi
callq 0x4b3ab
movq -0x40(%rbp), %rdi
movq %rbx, %rsi
movq %rax, %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x43e19
// File: /workspace/github_c_makefile_star2_O2/janet-lang[P]janet/src/core/util.c
// Function: janet_registry_put
void janet_registry_put(
    JanetCFunction key,
    const char *name,
    const char *name_prefix,
    const char *source_file,
    int32_t source_line) {
    if (janet_vm.registry_count == janet_vm.registry_cap) {
        size_t newcap = (janet_vm.registry_count + 1) * 2;
        /* Size it nicely with core by default */
        if (newcap < 512) {
            newcap = 512;
        }
        void *newmem = janet_realloc(janet_vm.registry, newcap * sizeof(JanetCFunRegistry));
        if (NULL == newmem) {
            JANET_OUT_OF_MEMORY;
        }
        janet_vm.registry = newmem;
        janet_vm.registry_cap = newcap;
    }
    JanetCFunRegistry value = {
        key,
        name,
        name_prefix,
        source_file,
        source_line
    };
    janet_vm.registry[janet_vm.registry_count++] = value;
    janet_vm.registry_dirty = 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r8d, %r14d
movq %rcx, -0x38(%rbp)
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq %fs:0x0, %rax
leaq -0x348(%rax), %rax
movq %rax, %r13
movq 0x58(%rax), %rcx
cmpq 0x50(%rax), %rcx
jne 0x450cd
movl %r14d, -0x2c(%rbp)
leaq 0x2(,%rcx,2), %rax
cmpq $0x201, %rax            # imm = 0x201
movl $0x200, %r14d           # imm = 0x200
cmovaeq %rax, %r14
movq 0x48(%r13), %rdi
imulq $0x28, %r14, %rsi
callq 0x12840
testq %rax, %rax
je 0x45110
movq %rax, 0x48(%r13)
movq %r14, 0x50(%r13)
movq 0x58(%r13), %rcx
movl -0x2c(%rbp), %r14d
jmp 0x450d1
movq 0x48(%r13), %rax
leaq 0x1(%rcx), %rdx
movq %rdx, 0x58(%r13)
imulq $0x28, %rcx, %rcx
movq %rbx, (%rax,%rcx)
movq %r12, 0x8(%rax,%rcx)
movq %r15, 0x10(%rax,%rcx)
movq -0x38(%rbp), %rdx
movq %rdx, 0x18(%rax,%rcx)
movl %r14d, 0x20(%rax,%rcx)
movl $0x1, 0x60(%r13)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x3aed9(%rip), %rax     # 0x7fff0
movq (%rax), %rdi
leaq 0x7ee3(%rip), %rsi      # 0x4d004
leaq 0x2252f(%rip), %rdx     # 0x67657
movl $0x1c8, %ecx            # imm = 0x1C8
xorl %eax, %eax
callq 0x125e0
pushq $0x1
popq %rdi
callq 0x12a60
// File: /workspace/github_c_makefile_star2_O2/janet-lang[P]janet/src/core/util.c
// Function: janet_registry_get
JanetCFunRegistry *janet_registry_get(JanetCFunction key) {
    if (janet_vm.registry_dirty) {
        janet_registry_sort();
    }
    for (size_t i = 0; i < janet_vm.registry_count; i++) {
        if (janet_vm.registry[i].cfun == key) {
            return janet_vm.registry + i;
        }
    }
    JanetCFunRegistry *lo = janet_vm.registry;
    JanetCFunRegistry *hi = lo + janet_vm.registry_count;
    while (lo < hi) {
        JanetCFunRegistry *mid = lo + (hi - lo) / 2;
        if (mid->cfun == key) {
            return mid;
        }
        if ((void *)(mid->cfun) > (void *)(key)) {
            hi = mid;
        } else {
            lo = mid + 1;
        }
    }
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq %fs:0x0, %rax
leaq -0x348(%rax), %rax
cmpl $0x0, 0x60(%rax)
je 0x45208
pushq $0x1
popq %rcx
pushq $-0x1
popq %rdx
xorl %esi, %esi
movq 0x58(%rax), %rdi
cmpq %rdi, %rcx
jae 0x45202
movq 0x48(%rax), %rdi
imulq $0x28, %rcx, %r9
movq (%rdi,%r9), %r8
movups 0x18(%rdi,%r9), %xmm0
movaps %xmm0, -0x20(%rbp)
movups 0x8(%rdi,%r9), %xmm0
movaps %xmm0, -0x30(%rbp)
movq %rdx, %r10
movq %rsi, %r9
testq %r10, %r10
je 0x451da
cmpq %r8, (%rdi,%r9)
jb 0x451da
leaq (%rdi,%r9), %r11
addq $0x28, %r11
addq %r9, %rdi
movq 0x20(%rdi), %r14
movq %r14, 0x20(%r11)
movups (%rdi), %xmm0
movups 0x10(%rdi), %xmm1
movups %xmm1, 0x10(%r11)
movups %xmm0, (%r11)
movq 0x48(%rax), %rdi
addq $-0x28, %r9
incq %r10
jmp 0x4519f
movq %r8, 0x28(%rdi,%r9)
movaps -0x30(%rbp), %xmm0
movaps -0x20(%rbp), %xmm1
movups %xmm0, 0x30(%rdi,%r9)
movups %xmm1, 0x40(%rdi,%r9)
incq %rcx
addq $0x28, %rsi
decq %rdx
jmp 0x4516c
andl $0x0, 0x60(%rax)
jmp 0x4520c
movq 0x58(%rax), %rdi
movq 0x48(%rax), %rcx
leaq 0x1(%rdi), %rdx
leaq -0x28(%rcx), %rsi
decq %rdx
je 0x4522c
leaq 0x28(%rsi), %rax
cmpq %rbx, 0x28(%rsi)
movq %rax, %rsi
jne 0x45218
jmp 0x45268
imulq $0x28, %rdi, %rsi
addq %rcx, %rsi
pushq $0x50
popq %rdi
cmpq %rsi, %rcx
jae 0x45266
movq %rsi, %rax
subq %rcx, %rax
cqto
idivq %rdi
imulq $0x28, %rax, %rax
leaq (%rcx,%rax), %rdx
addq $0x28, %rdx
cmpq %rbx, -0x28(%rdx)
leaq (%rcx,%rax), %rax
cmovbeq %rdx, %rcx
cmovaq %rax, %rsi
jne 0x45236
jmp 0x45268
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/janet-lang[P]janet/src/core/util.c
// Function: janet_cfuns
void janet_cfuns(JanetTable *env, const char *regprefix, const JanetReg *cfuns) {
    while (cfuns->name) {
        Janet fun = janet_wrap_cfunction(cfuns->cfun);
        if (env) janet_def(env, cfuns->name, fun, cfuns->documentation);
        janet_registry_put(cfuns->cfun, cfuns->name, regprefix, NULL, 0);
        cfuns++;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movabsq $-0x1800000000000, %r12 # imm = 0xFFFE800000000000
cmpq $0x0, (%rbx)
je 0x452d2
movq 0x8(%rbx), %rdi
movq %r12, %rsi
callq 0x4b3ab
testq %r15, %r15
je 0x452b8
movq (%rbx), %rsi
movq 0x10(%rbx), %rcx
movq %r15, %rdi
movq %rax, %rdx
callq 0x44f49
movq (%rbx), %rsi
movq 0x8(%rbx), %rdi
movq %r14, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x4504f
addq $0x18, %rbx
jmp 0x4528f
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/janet-lang[P]janet/src/core/util.c
// Function: janet_cfuns_ext
void janet_cfuns_ext(JanetTable *env, const char *regprefix, const JanetRegExt *cfuns) {
    while (cfuns->name) {
        Janet fun = janet_wrap_cfunction(cfuns->cfun);
        if (env) janet_def_sm(env, cfuns->name, fun, cfuns->documentation, cfuns->source_file, cfuns->source_line);
        janet_registry_put(cfuns->cfun, cfuns->name, regprefix, cfuns->source_file, cfuns->source_line);
        cfuns++;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movabsq $-0x1800000000000, %r12 # imm = 0xFFFE800000000000
cmpq $0x0, (%rbx)
je 0x45347
movq 0x8(%rbx), %rdi
movq %r12, %rsi
callq 0x4b3ab
testq %r15, %r15
je 0x4532a
movq (%rbx), %rsi
movq 0x10(%rbx), %rcx
movq 0x18(%rbx), %r8
movl 0x20(%rbx), %r9d
movq %r15, %rdi
movq %rax, %rdx
callq 0x44d5e
movq (%rbx), %rsi
movq 0x8(%rbx), %rdi
movq 0x18(%rbx), %rcx
movl 0x20(%rbx), %r8d
movq %r14, %rdx
callq 0x4504f
addq $0x28, %rbx
jmp 0x452f9
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq