LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/src/core/strtod.c
// Function: janet_scan_numeric
int janet_scan_numeric(
    const uint8_t *str,
    int32_t len,
    Janet *out) {
    int result;
    double num;
    int64_t i64 = 0;
    uint64_t u64 = 0;
    if (len < 2 || str[len - 2] != ':') {
        result = janet_scan_number_base(str, len, 0, &num);
        *out = janet_wrap_number(num);
        return result;
    }
    switch (str[len - 1]) {
        default:
            return 1;
        case 'n':
            result = janet_scan_number_base(str, len - 2, 0, &num);
            *out = janet_wrap_number(num);
            return result;
        /* Condition is inverted janet_scan_int64 and janet_scan_uint64 */
        case 's':
            result = !janet_scan_int64(str, len - 2, &i64);
            *out = janet_wrap_s64(i64);
            return result;
        case 'u':
            result = !janet_scan_uint64(str, len - 2, &u64);
            *out = janet_wrap_u64(u64);
            return result;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movl %esi, %eax
movq $0x0, -0x28(%rbp)
cmpl $0x2, %esi
jl 0x46d2e
leal -0x2(%rax), %esi
cmpb $0x3a, (%rdi,%rsi)
jne 0x46d2e
movl %eax, %eax
movzbl -0x1(%rdi,%rax), %eax
cmpl $0x75, %eax
je 0x46d79
cmpl $0x73, %eax
je 0x46d5c
movl $0x1, %r14d
cmpl $0x6e, %eax
jne 0x46d4e
leaq -0x20(%rbp), %r15
jmp 0x46d34
leaq -0x20(%rbp), %r15
movl %eax, %esi
xorl %edx, %edx
movq %r15, %rcx
callq 0x46414
movl %eax, %r14d
movsd (%r15), %xmm0
callq 0x4fab8
movq %rax, (%rbx)
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq -0x28(%rbp), %r15
movq %r15, %rdx
callq 0x46a96
movl %eax, %r14d
xorl $0x1, %r14d
movq (%r15), %rdi
callq 0x2c747
jmp 0x46d4b
leaq -0x20(%rbp), %rdx
leaq -0x2c(%rbp), %r14
movq %r14, %rcx
callq 0x46b18
testl %eax, %eax
sete %cl
cmpl $0x0, (%r14)
setne %al
orb %cl, %al
jne 0x46d9f
movq -0x20(%rbp), %rdi
jmp 0x46da1
xorl %edi, %edi
movzbl %al, %r14d
callq 0x2c77c
jmp 0x46d4b
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/src/core/strtod.c
// Function: janet_buffer_dtostr
void janet_buffer_dtostr(JanetBuffer *buffer, double x) {
#define BUFSIZE 32
    janet_buffer_extra(buffer, BUFSIZE);
    int count = snprintf((char *) buffer->data + buffer->count, BUFSIZE, "%.17g", x);
#undef BUFSIZE
    /* fix locale issues with commas */
    for (int i = 0; i < count; i++) {
        char c = buffer->data[buffer->count + i];
        if (c == ',') {
            buffer->data[buffer->count + i] = '.';
        }
    }
    buffer->count += count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movsd %xmm0, -0x10(%rbp)
movq %rdi, %rbx
movl $0x20, %esi
callq 0x17843
movslq 0x10(%rbx), %rdi
addq 0x18(%rbx), %rdi
leaq 0x2474d(%rip), %rdx     # 0x6b520
movl $0x20, %esi
movsd -0x10(%rbp), %xmm0
movb $0x1, %al
callq 0x12390
testl %eax, %eax
jle 0x46e05
movl %eax, %ecx
xorl %edx, %edx
movslq 0x10(%rbx), %rsi
addq 0x18(%rbx), %rsi
cmpb $0x2c, (%rdx,%rsi)
jne 0x46dfe
movb $0x2e, (%rsi,%rdx)
incq %rdx
cmpl %edx, %ecx
jne 0x46dec
addl %eax, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/src/core/strtod.c
// Function: bignat_extra
static uint32_t *bignat_extra(struct BigNat *mant, int32_t n) {
    int32_t oldn = mant->n;
    int32_t newn = oldn + n;
    if (mant->cap < newn) {
        int32_t newcap = 2 * newn;
        uint32_t *mem = janet_realloc(mant->digits, (size_t) newcap * sizeof(uint32_t));
        if (NULL == mem) {
            JANET_OUT_OF_MEMORY;
        }
        mant->cap = newcap;
        mant->digits = mem;
    }
    mant->n = newn;
    return mant->digits + oldn;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq 0x4(%rdi), %r14
movslq %esi, %r15
addq %r14, %r15
cmpl %r15d, 0x8(%rdi)
jge 0x46e4f
movq 0x10(%rbx), %rdi
leaq (,%r15,8), %rsi
callq 0x12850
testq %rax, %rax
je 0x46e69
movl %r15d, %ecx
addl %r15d, %ecx
movl %ecx, 0x8(%rbx)
movq %rax, 0x10(%rbx)
movl %r15d, 0x4(%rbx)
shlq $0x2, %r14
addq 0x10(%rbx), %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x1406c
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/src/core/strtod.c
// Function: bignat_div
static void bignat_div(struct BigNat *mant, uint32_t divisor) {
    int32_t i;
    uint32_t quotient, remainder;
    uint64_t dividend;
    remainder = 0, quotient = 0;
    for (i = mant->n - 1; i >= 0; i--) {
        dividend = ((uint64_t)remainder * BIGNAT_BASE) + mant->digits[i];
        if (i < mant->n - 1) mant->digits[i + 1] = quotient;
        quotient = (uint32_t)(dividend / divisor);
        remainder = (uint32_t)(dividend % divisor);
        mant->digits[i] = remainder;
    }
    dividend = ((uint64_t)remainder * BIGNAT_BASE) + mant->first_digit;
    if (mant->n && mant->digits[mant->n - 1] == 0) mant->n--;
    mant->first_digit = (uint32_t)(dividend / divisor);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movslq 0x4(%rdi), %r8
xorl %eax, %eax
movl %esi, %ecx
testq %r8, %r8
jle 0x46ebc
movq 0x10(%rdi), %rsi
xorl %edx, %edx
movslq 0x4(%rdi), %r9
cmpq %r9, %r8
jge 0x46e92
movl %eax, (%rsi,%r8,4)
shlq $0x1f, %rdx
movl -0x4(%rsi,%r8,4), %eax
addq %rdx, %rax
xorl %edx, %edx
divq %rcx
movl %edx, -0x4(%rsi,%r8,4)
decq %r8
leaq 0x1(%r8), %r9
cmpq $0x1, %r9
jg 0x46e85
shlq $0x1f, %rdx
movq %rdx, %rax
movl (%rdi), %edx
movslq 0x4(%rdi), %rsi
testq %rsi, %rsi
je 0x46ed8
movq 0x10(%rdi), %r8
cmpl $0x0, -0x4(%r8,%rsi,4)
jne 0x46ed8
decl %esi
movl %esi, 0x4(%rdi)
addq %rdx, %rax
xorl %edx, %edx
divq %rcx
movl %eax, (%rdi)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/src/core/strtod.c
// Function: bignat_extract
static double bignat_extract(struct BigNat *mant, int32_t exponent2) {
    uint64_t top53;
    int32_t n = mant->n;
    /* Get most significant 53 bits from mant. Bit 52 (0 indexed) should
     * always be 1. This is essentially a large right shift on mant.*/
    if (n) {
        /* Two or more digits */
        uint64_t d1 = mant->digits[n - 1]; /* MSD (non-zero) */
        uint64_t d2 = (n == 1) ? mant->first_digit : mant->digits[n - 2];
        uint64_t d3 = (n > 2) ? mant->digits[n - 3] : (n == 2) ? mant->first_digit : 0;
        int lz = clz((uint32_t) d1);
        int nbits = 32 - lz;
        /* First get 54 bits */
        top53 = (d2 << (54 - BIGNAT_NBIT)) + (d3 >> (2 * BIGNAT_NBIT - 54));
        top53 >>= nbits;
        top53 |= (d1 << (54 - nbits));
        /* Rounding based on lowest bit of 54 */
        if (top53 & 1) top53++;
        top53 >>= 1;
        if (top53 > 0x1FffffFFFFffffUL) {
            top53 >>= 1;
            exponent2++;
        }
        /* Correct exponent - to correct for large right shift to mantissa. */
        exponent2 += (nbits - 53) + BIGNAT_NBIT * n;
    } else {
        /* One digit */
        top53 = mant->first_digit;
    }
    return ldexp((double)top53, exponent2);
}

// Assembly:
movslq 0x4(%rdi), %r8
testq %r8, %r8
je 0x46f17
pushq %rbp
movq %rsp, %rbp
movq 0x10(%rdi), %rax
leaq (%rax,%r8,4), %rcx
addq $-0x8, %rcx
movl 0x4(%rcx), %edx
cmpl $0x1, %r8d
cmoveq %rdi, %rcx
movl (%rcx), %ecx
cmpl $0x3, %r8d
jl 0x46f1b
movl -0xc(%rax,%r8,4), %r9d
jmp 0x46f27
movl (%rdi), %edx
jmp 0x46f7d
xorl %r9d, %r9d
cmpl $0x2, %r8d
jne 0x46f27
movl (%rdi), %r9d
bsrl %edx, %edi
xorl $0x1f, %edi
movl $0x20, %eax
subl %edi, %eax
shlq $0x17, %rcx
shrl $0x8, %r9d
addq %rcx, %r9
movq %r9, %r10
movl %eax, %ecx
shrq %cl, %r10
leal 0x16(%rdi), %ecx
shlq %cl, %rdx
orq %r10, %rdx
btq %rax, %r9
adcq $0x0, %rdx
xorl %eax, %eax
movq %rdx, %rcx
shrq $0x36, %rcx
setne %al
leal 0x1(%rax), %ecx
shrq %cl, %rdx
movl %r8d, %ecx
shll $0x5, %ecx
subl %r8d, %ecx
addl %ecx, %esi
subl %edi, %esi
addl %eax, %esi
addl $-0x15, %esi
popq %rbp
cvtsi2sd %rdx, %xmm0
movl %esi, %edi
jmp 0x12130
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/src/core/struct.c
// Function: janet_struct_begin
JanetKV *janet_struct_begin(int32_t count) {
    /* Calculate capacity as power of 2 after 2 * count. */
    int32_t capacity = janet_tablen(2 * count);
    if (capacity < 0) capacity = janet_tablen(count + 1);

    size_t size = sizeof(JanetStructHead) + (size_t) capacity * sizeof(JanetKV);
    JanetStructHead *head = janet_gcalloc(JANET_MEMORY_STRUCT, size);
    head->length = count;
    head->capacity = capacity;
    head->hash = 0;
    head->proto = NULL;

    JanetKV *st = (JanetKV *)(head->data);
    janet_memempty(st, capacity);
    return st;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
leal (%rbx,%rbx), %edi
callq 0x48fe5
testl %eax, %eax
jns 0x46fac
leal 0x1(%rbx), %edi
callq 0x48fe5
movslq %eax, %r14
movq %r14, %rsi
shlq $0x4, %rsi
addq $0x28, %rsi
movl $0x6, %edi
callq 0x2bb18
movq %rax, %r15
movl %ebx, 0x10(%rax)
movl %r14d, 0x18(%rax)
movl $0x0, 0x14(%rax)
movq $0x0, 0x20(%rax)
addq $0x28, %r15
movq %r15, %rdi
movl %r14d, %esi
callq 0x4fb51
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/src/core/struct.c
// Function: janet_struct_find
const JanetKV *janet_struct_find(const JanetKV *st, Janet key) {
    int32_t cap = janet_struct_capacity(st);
    int32_t index = janet_maphash(cap, janet_hash(key));
    int32_t i;
    for (i = index; i < cap; i++)
        if (janet_checktype(st[i].key, JANET_NIL) || janet_equals(st[i].key, key))
            return st + i;
    for (i = 0; i < index; i++)
        if (janet_checktype(st[i].key, JANET_NIL) || janet_equals(st[i].key, key))
            return st + i;
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, -0x30(%rbp)
movslq -0x10(%rdi), %r12
movq %rsi, %rdi
callq 0x4b1e3
leal -0x1(%r12), %r13d
andl %eax, %r13d
cmpl %r12d, %r13d
jge 0x4706d
movabsq $-0x7800000000000, %rbx # imm = 0xFFF8800000000000
movslq %r13d, %r15
subq %r15, %r12
shlq $0x4, %r15
addq -0x30(%rbp), %r15
movq (%r15), %rdi
movq %rdi, %rax
movabsq $-0x800000000000, %rcx  # imm = 0xFFFF800000000000
andq %rcx, %rax
cmpq %rbx, %rax
je 0x470c6
movq %r14, %rsi
callq 0x4acce
testl %eax, %eax
jne 0x470c6
addq $0x10, %r15
decq %r12
jne 0x47040
testl %r13d, %r13d
jle 0x470b6
movabsq $-0x7800000000000, %rbx # imm = 0xFFF8800000000000
movl %r13d, %r13d
movq -0x30(%rbp), %r15
xorl %r12d, %r12d
movq (%r15), %rdi
movq %rdi, %rax
movabsq $-0x800000000000, %rcx  # imm = 0xFFFF800000000000
andq %rcx, %rax
cmpq %rbx, %rax
je 0x470bb
movq %r14, %rsi
callq 0x4acce
testl %eax, %eax
jne 0x470c6
incq %r12
addq $0x10, %r15
decq %r13
jne 0x47086
xorl %r15d, %r15d
jmp 0x470c6
shlq $0x4, %r12
movq -0x30(%rbp), %r15
addq %r12, %r15
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/src/core/struct.c
// Function: janet_struct_end
const JanetKV *janet_struct_end(JanetKV *st) {
    if (janet_struct_hash(st) != janet_struct_length(st)) {
        /* Error building struct, probably duplicate values. We need to rebuild
         * the struct using only the values that went in. The second creation should always
         * succeed. */
        JanetKV *newst = janet_struct_begin(janet_struct_hash(st));
        for (int32_t i = 0; i < janet_struct_capacity(st); i++) {
            JanetKV *kv = st + i;
            if (!janet_checktype(kv->key, JANET_NIL)) {
                janet_struct_put(newst, kv->key, kv->value);
            }
        }
        janet_struct_proto(newst) = janet_struct_proto(st);
        st = newst;
    }
    janet_struct_hash(st) = janet_kv_calchash(st, janet_struct_capacity(st));
    if (janet_struct_proto(st)) {
        janet_struct_hash(st) += 2654435761u * janet_struct_hash(janet_struct_proto(st));
    }
    return (const JanetKV *)st;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r14
movl -0x14(%rdi), %edi
cmpl -0x18(%r14), %edi
jne 0x472e5
movq %r14, %rbx
jmp 0x47335
callq 0x46f8c
movq %rax, %rbx
cmpl $0x0, -0x10(%r14)
jle 0x4732d
leaq 0x8(%r14), %r15
xorl %r12d, %r12d
movq -0x8(%r15), %rsi
movq %rsi, %rax
shrq $0x2f, %rax
cmpl $0x1fff1, %eax          # imm = 0x1FFF1
je 0x4731d
movq (%r15), %rdx
movq %rbx, %rdi
movl $0x1, %ecx
callq 0x470d8
incq %r12
movslq -0x10(%r14), %rax
addq $0x10, %r15
cmpq %rax, %r12
jl 0x472fb
movq -0x8(%r14), %rax
movq %rax, -0x8(%rbx)
movl -0x10(%rbx), %esi
movq %rbx, %rdi
callq 0x48f31
movl %eax, -0x14(%rbx)
movq -0x8(%rbx), %rcx
testq %rcx, %rcx
je 0x47358
imull $0x9e3779b1, -0x14(%rcx), %ecx # imm = 0x9E3779B1
addl %eax, %ecx
movl %ecx, -0x14(%rbx)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/src/core/struct.c
// Function: janet_struct_get
Janet janet_struct_get(const JanetKV *st, Janet key) {
    for (int i = JANET_MAX_PROTO_DEPTH; st && i; --i, st = janet_struct_proto(st)) {
        const JanetKV *kv = janet_struct_find(st, key);
        if (NULL != kv && !janet_checktype(kv->key, JANET_NIL)) {
            return kv->value;
        }
    }
    return janet_wrap_nil();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movabsq $-0x7800000000000, %rbx # imm = 0xFFF8800000000000
testq %rdi, %rdi
sete %r13b
je 0x4740a
movq %rsi, %r15
movq %rdi, %r12
movl $0xffffff39, %r14d      # imm = 0xFFFFFF39
movq %r12, %rdi
movq %r15, %rsi
callq 0x46ffa
movb $0x1, %cl
testq %rax, %rax
je 0x473e6
movq (%rax), %rdx
movabsq $-0x800000000000, %rsi  # imm = 0xFFFF800000000000
andq %rsi, %rdx
cmpq %rbx, %rdx
je 0x473e6
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
xorl %ecx, %ecx
testb %cl, %cl
je 0x4740a
movq -0x8(%r12), %r12
testq %r12, %r12
sete %al
testl %r14d, %r14d
sete %r13b
orb %al, %r13b
incl %r14d
cmpb $0x1, %r13b
jne 0x473b5
jmp 0x4740a
testb $0x1, %r13b
je 0x47429
incq %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4f95a
movq -0x30(%rbp), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/src/core/struct.c
// Function: janet_struct_get_ex
Janet janet_struct_get_ex(const JanetKV *st, Janet key, JanetStruct *which) {
    for (int i = JANET_MAX_PROTO_DEPTH; st && i; --i, st = janet_struct_proto(st)) {
        const JanetKV *kv = janet_struct_find(st, key);
        if (NULL != kv && !janet_checktype(kv->key, JANET_NIL)) {
            *which = st;
            return kv->value;
        }
    }
    return janet_wrap_nil();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, -0x38(%rbp)
movabsq $-0x7800000000000, %rbx # imm = 0xFFF8800000000000
testq %rdi, %rdi
sete %r12b
je 0x474cb
movq %rsi, %r15
movq %rdi, %r13
movl $0xffffff39, %r14d      # imm = 0xFFFFFF39
movq %r13, %rdi
movq %r15, %rsi
callq 0x46ffa
movb $0x1, %cl
testq %rax, %rax
je 0x474a8
movq (%rax), %rdx
movabsq $-0x800000000000, %rsi  # imm = 0xFFFF800000000000
andq %rsi, %rdx
cmpq %rbx, %rdx
je 0x474a8
movq -0x38(%rbp), %rcx
movq %r13, (%rcx)
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
xorl %ecx, %ecx
testb %cl, %cl
je 0x474cb
movq -0x8(%r13), %r13
testq %r13, %r13
sete %al
testl %r14d, %r14d
sete %r12b
orb %al, %r12b
incl %r14d
cmpb $0x1, %r12b
jne 0x47470
jmp 0x474cb
testb $0x1, %r12b
je 0x474ea
incq %rbx
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4f95a
movq -0x30(%rbp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/src/core/struct.c
// Function: janet_struct_to_table
JanetTable *janet_struct_to_table(const JanetKV *st) {
    JanetTable *table = janet_table(janet_struct_capacity(st));
    int32_t i;
    for (i = 0; i < janet_struct_capacity(st); i++) {
        const JanetKV *kv = st + i;
        if (!janet_checktype(kv->key, JANET_NIL)) {
            janet_table_put(table, kv->key, kv->value);
        }
    }
    return table;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl -0x10(%rdi), %edi
callq 0x47e96
movq %rax, %r14
cmpl $0x0, -0x10(%rbx)
jle 0x47550
leaq 0x8(%rbx), %r15
xorl %r12d, %r12d
movq -0x8(%r15), %rsi
movq %rsi, %rax
shrq $0x2f, %rax
cmpl $0x1fff1, %eax          # imm = 0x1FFF1
je 0x47540
movq (%r15), %rdx
movq %r14, %rdi
callq 0x481b3
incq %r12
movslq -0x10(%rbx), %rax
addq $0x10, %r15
cmpq %rax, %r12
jl 0x47523
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x1, %edi
movl $0x2000, %esi           # imm = 0x2000
callq 0x125a0
movq %rax, 0x70(%rbx)
testq %rax, %rax
je 0x47923
movabsq $0x3030303030303030, %rax # imm = 0x3030303030303030
movq %rax, 0x84(%rbx)
movb $0x5f, 0x84(%rbx)
movq $0x0, 0x7c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x1409a
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x0, (%r14)
movl -0x8(%rdi), %esi
movl -0x4(%rdi), %edx
movq %r14, %rcx
callq 0x479bb
cmpl $0x0, (%r14)
je 0x479b2
movq %rax, %rbx
movq %fs:0x0, %rax
leaq -0x348(%rax), %rax
decl 0x7c(%rax)
incl 0x80(%rax)
leaq 0x23f8d(%rip), %rax     # 0x6b93c
movq %rax, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x48e5d
movl %eax, %r12d
leaq -0x34(%rbp), %r13
movl $0x0, (%r13)
movq %rbx, %rdi
movl %r14d, %esi
movl %eax, %edx
movq %r13, %rcx
callq 0x479bb
movq %rax, %r15
cmpl $0x0, (%r13)
je 0x47b60
movq (%r15), %r14
jmp 0x47ba7
movslq %r14d, %rax
movq %rax, -0x30(%rbp)
leaq 0x19(%rax), %rsi
movl $0x2, %edi
callq 0x2bb18
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 0x49017
movb $0x0, 0x18(%r13,%rbx)
movq %r14, %rdi
movq %r15, %rsi
callq 0x47bb9
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_O1/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 0x47cb8
movq %rbx, -0x40(%rbp)
leal 0x1(,%rax,2), %edi
callq 0x48fe5
movl %eax, %r12d
movq 0x70(%r14), %r15
movl %eax, %esi
shlq $0x3, %rsi
movl $0x1, %edi
callq 0x125a0
testq %rax, %rax
je 0x47cce
movl 0x78(%r14), %ebx
movq %rax, 0x70(%r14)
movl %r12d, 0x78(%r14)
movq %r14, -0x38(%rbp)
movl $0x0, 0x80(%r14)
testq %rbx, %rbx
je 0x47c93
xorl %r12d, %r12d
leaq 0x23ce7(%rip), %r14     # 0x6b93c
movq (%r15,%r12,8), %r13
testq %r13, %r13
sete %al
cmpq %r14, %r13
sete %cl
orb %al, %cl
jne 0x47c8b
movl -0x8(%r13), %esi
movl -0x4(%r13), %edx
movq %r13, %rdi
leaq -0x2c(%rbp), %rcx
callq 0x479bb
cmpl $0x0, -0x2c(%rbp)
jne 0x47c93
testq %rax, %rax
je 0x47c93
movq %r13, (%rax)
incq %r12
cmpq %r12, %rbx
jne 0x47c55
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 0x479bb
movq %rax, %r15
movq -0x38(%rbp), %r14
incl 0x7c(%r14)
movq %rbx, (%r15)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x140fa
// File: /workspace/github_c_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x10, %rsp
movq %fs:0x0, %rax
leaq -0x348(%rax), %rax
movq %rax, %rbx
addq $0x84, %rbx
movq %rbx, %rdi
movl $0x7, %esi
callq 0x48e5d
movl %eax, %r15d
leaq -0x24(%rbp), %r14
movq %rbx, %rdi
movl $0x7, %esi
movl %eax, %edx
movq %r14, %rcx
callq 0x479bb
cmpl $0x0, (%r14)
je 0x47da8
movl $0x6, %eax
movzbl (%rbx,%rax), %ecx
cmpl $0x39, %ecx
je 0x47d6d
cmpl $0x5a, %ecx
je 0x47d62
cmpl $0x7a, %ecx
jne 0x47d71
movb $0x41, %cl
jmp 0x47d73
movb $0x30, (%rbx,%rax)
decq %rax
jne 0x47d4b
jmp 0x47d76
movb $0x61, %cl
jmp 0x47d73
incb %cl
movb %cl, (%rbx,%rax)
movq %rbx, %rdi
movl $0x7, %esi
callq 0x48e5d
movl %eax, %r15d
movq %rbx, %rdi
movl $0x7, %esi
movl %eax, %edx
movq %r14, %rcx
callq 0x479bb
movq %rax, %r12
cmpl $0x0, -0x24(%rbp)
movl $0x6, %eax
jne 0x47d4b
jmp 0x47dab
movq %rax, %r12
movl $0x20, %esi
movl $0x2, %edi
callq 0x2bb18
movl $0x7, 0x10(%rax)
movl %r15d, 0x14(%rax)
leaq 0x18(%rax), %r14
movq (%rbx), %rcx
movq %rcx, 0x18(%rax)
movb $0x0, 0x1f(%rax)
movq %r14, %rdi
movq %r12, %rsi
callq 0x47bb9
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 %r12
pushq %rbx
movl %edx, %r15d
movq %rdi, %rbx
movl %esi, %edi
callq 0x48fe5
movl %eax, %r14d
testl %r15d, %r15d
je 0x47e22
movl $0x10000, (%rbx)        # imm = 0x10000
xorl %r12d, %r12d
testl %r14d, %r14d
je 0x47e39
movl %r14d, %edi
testl %r15d, %r15d
je 0x47e40
callq 0x489e6
jmp 0x47e4a
xorl %eax, %eax
xorl %r14d, %r14d
jmp 0x47e4a
callq 0x4fad9
testq %rax, %rax
je 0x47e6e
movq %rax, 0x20(%rbx)
movl %r14d, 0x14(%rbx)
movl %r12d, 0x10(%rbx)
movl %r12d, 0x18(%rbx)
movq $0x0, 0x28(%rbx)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x14128
// File: /workspace/github_c_makefile_star2_O1/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 0x47e90
popq %rbp
jmp 0x120b0
popq %rbp
jmp 0x2c187
// File: /workspace/github_c_makefile_star2_O1/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
movabsq $-0x7800000000000, %rbx # imm = 0xFFF8800000000000
testq %rdi, %rdi
sete %r13b
je 0x47fda
movq %rsi, %r15
movq %rdi, %r12
movl $0xffffff39, %r14d      # imm = 0xFFFFFF39
movq 0x20(%r12), %rdi
movl 0x14(%r12), %esi
movq %r15, %rdx
callq 0x49028
movb $0x1, %cl
testq %rax, %rax
je 0x47fb6
movq (%rax), %rdx
movabsq $-0x800000000000, %rsi  # imm = 0xFFFF800000000000
andq %rsi, %rdx
cmpq %rbx, %rdx
je 0x47fb6
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
xorl %ecx, %ecx
testb %cl, %cl
je 0x47fda
movq 0x28(%r12), %r12
testq %r12, %r12
sete %al
testl %r14d, %r14d
sete %r13b
orb %al, %r13b
incl %r14d
cmpb $0x1, %r13b
jne 0x47f7e
jmp 0x47fda
testb $0x1, %r13b
je 0x47ff9
incq %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4f95a
movq -0x30(%rbp), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
subq $0x18, %rsp
movq %rdx, -0x38(%rbp)
movabsq $-0x7800000000000, %rbx # imm = 0xFFF8800000000000
testq %rdi, %rdi
sete %r12b
je 0x480a0
movq %rsi, %r15
movq %rdi, %r13
movl $0xffffff39, %r14d      # imm = 0xFFFFFF39
movq 0x20(%r13), %rdi
movl 0x14(%r13), %esi
movq %r15, %rdx
callq 0x49028
movb $0x1, %cl
testq %rax, %rax
je 0x4807d
movq (%rax), %rdx
movabsq $-0x800000000000, %rsi  # imm = 0xFFFF800000000000
andq %rsi, %rdx
cmpq %rbx, %rdx
je 0x4807d
movq -0x38(%rbp), %rcx
movq %r13, (%rcx)
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
xorl %ecx, %ecx
testb %cl, %cl
je 0x480a0
movq 0x28(%r13), %r13
testq %r13, %r13
sete %al
testl %r14d, %r14d
sete %r12b
orb %al, %r12b
incl %r14d
cmpb $0x1, %r12b
jne 0x48040
jmp 0x480a0
testb $0x1, %r12b
je 0x480bf
incq %rbx
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4f95a
movq -0x30(%rbp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
movq %rsi, %rdx
movabsq $-0x7800000000000, %rbx # imm = 0xFFF8800000000000
movq 0x20(%rdi), %rax
movl 0x14(%rdi), %esi
movq %rax, %rdi
callq 0x49028
testq %rax, %rax
je 0x4810b
movabsq $-0x800000000000, %rcx  # imm = 0xFFFF800000000000
andq (%rax), %rcx
cmpq %rbx, %rcx
jne 0x4811c
incq %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x4f95a
movq 0x8(%rax), %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rsi, %rdx
movq %rdi, %r15
movabsq $-0x77fffffffffff, %r14 # imm = 0xFFF8800000000001
movq 0x20(%rdi), %rdi
movl 0x14(%r15), %esi
callq 0x49028
testq %rax, %rax
je 0x4816d
movq %rax, %rbx
movabsq $-0x800000000000, %rax  # imm = 0xFFFF800000000000
andq (%rbx), %rax
leaq -0x1(%r14), %rcx
cmpq %rcx, %rax
jne 0x4817d
movq %r14, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x4f95a
movq 0x8(%rbx), %r12
decl 0x10(%r15)
incl 0x18(%r15)
movq %r14, %rdi
callq 0x4f95a
movq %rax, (%rbx)
movabsq $-0x7000000000000, %rdi # imm = 0xFFF9000000000000
callq 0x4f95a
movq %rax, 0x8(%rbx)
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x482bf
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 0x482bf
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 0x48238
movq %r14, %rdi
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x48127
movq 0x20(%r14), %rdi
movl 0x14(%r14), %esi
movq %r15, %rdx
callq 0x49028
testq %rax, %rax
je 0x4826d
movq (%rax), %rcx
andq %r12, %rcx
cmpq %r13, %rcx
jne 0x482bb
movl 0x18(%r14), %eax
addl 0x10(%r14), %eax
leal 0x2(,%rax,2), %eax
cmpl 0x14(%r14), %eax
jle 0x48287
movl 0x10(%r14), %eax
leal 0x2(,%rax,2), %edi
callq 0x48fe5
movq %r14, %rdi
movl %eax, %esi
callq 0x482ce
movq 0x20(%r14), %rdi
movl 0x14(%r14), %esi
movq %r15, %rdx
callq 0x49028
andq 0x8(%rax), %r12
movabsq $-0x7000000000000, %rcx # imm = 0xFFF9000000000000
cmpq %rcx, %r12
jne 0x482ae
decl 0x18(%r14)
movq %r15, (%rax)
movq %rbx, 0x8(%rax)
incl 0x10(%r14)
jmp 0x482bf
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_O1/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
btl $0x10, %eax
movl %eax, -0x2c(%rbp)
movl %esi, %edi
jb 0x48302
callq 0x4fad9
testq %rax, %rax
jne 0x48307
callq 0x14156
callq 0x489e6
movslq 0x14(%r14), %r13
movq %rax, 0x20(%r14)
movl %r15d, 0x14(%r14)
movl $0x0, 0x18(%r14)
testq %r13, %r13
jle 0x4835b
shlq $0x4, %r13
xorl %r15d, %r15d
movq (%rbx,%r15), %rdx
movq %rdx, %rax
shrq $0x2f, %rax
cmpl $0x1fff1, %eax          # imm = 0x1FFF1
je 0x48352
leaq (%rbx,%r15), %r12
movq 0x20(%r14), %rdi
movl 0x14(%r14), %esi
callq 0x49028
movups (%r12), %xmm0
movups %xmm0, (%rax)
addq $0x10, %r15
cmpq %r15, %r13
jne 0x48327
btl $0x10, -0x2c(%rbp)
jb 0x48378
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 0x2c187
// File: /workspace/github_c_makefile_star2_O1/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 0x4fb51
xorl %eax, %eax
movl %eax, 0x10(%rbx)
movl %eax, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
movq %rdi, %r14
movl $0x30, %esi
movl $0x5, %edi
callq 0x2bb18
movq %rax, %rbx
movl 0x10(%r14), %eax
movl %eax, 0x10(%rbx)
movslq 0x14(%r14), %rdi
movl %edi, 0x14(%rbx)
movl 0x18(%r14), %eax
movl %eax, 0x18(%rbx)
movq 0x28(%r14), %rax
movq %rax, 0x28(%rbx)
shlq $0x4, %rdi
callq 0x12770
movq %rax, 0x20(%rbx)
testq %rax, %rax
je 0x48419
movq 0x20(%r14), %rsi
movslq 0x14(%r14), %rdx
shlq $0x4, %rdx
movq %rax, %rdi
callq 0x12680
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
callq 0x14184
// File: /workspace/github_c_makefile_star2_O1/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:
testl %edx, %edx
jle 0x4847e
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl %edx, %r15d
shlq $0x4, %r15
xorl %r12d, %r12d
movq (%rbx,%r12), %rsi
movq %rsi, %rax
shrq $0x2f, %rax
cmpl $0x1fff1, %eax          # imm = 0x1FFF1
je 0x4846d
movq 0x8(%rbx,%r12), %rdx
movq %r14, %rdi
callq 0x481b3
addq $0x10, %r12
cmpq %r12, %r15
jne 0x4844e
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x46f8c
movq %rax, %rbx
movslq 0x14(%r14), %r15
testq %r15, %r15
jle 0x484db
movq 0x20(%r14), %r14
shlq $0x4, %r15
addq %r14, %r15
movq (%r14), %rsi
movq %rsi, %rax
shrq $0x2f, %rax
cmpl $0x1fff1, %eax          # imm = 0x1FFF1
je 0x484d2
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x472ba
addq $0x10, %r14
cmpq %r15, %r14
jb 0x484b5
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x472c9
// File: /workspace/github_c_makefile_star2_O1/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, %rbx
movl $0x30, %esi
movl $0x5, %edi
callq 0x2bb18
movq %rax, %r14
movq %rax, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x47dfc
testq %rbx, %rbx
je 0x48637
movabsq $-0x800000000000, %rdx  # imm = 0xFFFF800000000000
movabsq $-0x7800000000000, %rcx # imm = 0xFFF8800000000000
movq %rbx, -0x30(%rbp)
movslq 0x14(%rbx), %rax
testq %rax, %rax
jle 0x48626
movq %rax, %rsi
movq -0x30(%rbp), %rax
movq 0x20(%rax), %r13
shlq $0x4, %rsi
addq %r13, %rsi
movq %rsi, -0x40(%rbp)
movq (%r13), %r15
movq %r15, %rax
andq %rdx, %rax
cmpq %rcx, %rax
je 0x48618
movq %rcx, %rbx
movq %rdx, %r12
movq 0x8(%r13), %rax
movq %rax, -0x38(%rbp)
movq 0x20(%r14), %rdi
movl 0x14(%r14), %esi
movq %r15, %rdx
callq 0x49028
testq %rax, %rax
je 0x485bf
movq (%rax), %rax
movq %r12, %rdx
andq %r12, %rax
movq %rbx, %rcx
cmpq %rbx, %rax
jne 0x48618
movl 0x18(%r14), %eax
addl 0x10(%r14), %eax
leal 0x2(,%rax,2), %eax
cmpl 0x14(%r14), %eax
jle 0x485d9
movl 0x10(%r14), %eax
leal 0x2(,%rax,2), %edi
callq 0x48fe5
movq %r14, %rdi
movl %eax, %esi
callq 0x482ce
movq 0x20(%r14), %rdi
movl 0x14(%r14), %esi
movq %r15, %rdx
callq 0x49028
movq 0x8(%rax), %rcx
movq %r12, %rdx
andq %r12, %rcx
movabsq $-0x7000000000000, %rsi # imm = 0xFFF9000000000000
cmpq %rsi, %rcx
jne 0x48606
decl 0x18(%r14)
movq %r15, (%rax)
movq -0x38(%rbp), %rcx
movq %rcx, 0x8(%rax)
incl 0x10(%r14)
movq %rbx, %rcx
addq $0x10, %r13
cmpq -0x40(%rbp), %r13
jb 0x48563
movq -0x30(%rbp), %rbx
movq 0x28(%rbx), %rbx
testq %rbx, %rbx
jne 0x4853c
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_O1/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
movl %edi, %r15d
movslq %edi, %r14
movq %r14, %rdi
shlq $0x4, %rdi
callq 0x2bfe0
movq %rax, %rbx
testl %r14d, %r14d
jle 0x48a41
movabsq $-0x77fffffffffff, %r14 # imm = 0xFFF8800000000001
movl %r15d, %r15d
shlq $0x4, %r15
xorl %r12d, %r12d
movq %r14, %rdi
callq 0x4f95a
movq %rax, (%rbx,%r12)
movq %r14, %rdi
callq 0x4f95a
movq %rax, 0x8(%rbx,%r12)
addq $0x10, %r12
cmpq %r12, %r15
jne 0x48a1f
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x4, %edi
callq 0x2bb18
movq $-0x1, 0x18(%rax)
movl %ebx, 0x10(%rax)
addq $0x20, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x1505, %eax           # imm = 0x1505
jne 0x48ec3
testl %esi, %esi
jle 0x48e9b
pushq %rbp
movq %rsp, %rbp
movslq %esi, %rax
addq %rdi, %rax
movl $0x1505, %ecx           # imm = 0x1505
movl %ecx, %edx
shll $0x5, %edx
addl %ecx, %edx
movzbl (%rdi), %ecx
incq %rdi
addl %edx, %ecx
cmpq %rax, %rdi
jb 0x48e84
popq %rbp
jmp 0x48ea0
movl $0x1505, %ecx           # imm = 0x1505
movl %ecx, %eax
shll $0x6, %eax
addl %eax, %esi
movl %ecx, %eax
shrl $0x2, %eax
movl $0x9e3779b9, %edx       # imm = 0x9E3779B9
addl %edx, %eax
addl %esi, %eax
movl %eax, %esi
shll $0x6, %esi
shrl $0x2, %eax
addl %esi, %eax
addl %edx, %eax
xorl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r12
pushq %rbx
testl %esi, %esi
jle 0x48f1f
movq %rdi, %rbx
movslq %esi, %rax
leaq (%rdi,%rax,8), %r15
movl $0x21, %r14d
movl $0x9e3779b9, %r12d      # imm = 0x9E3779B9
movq (%rbx), %rdi
addq $0x8, %rbx
callq 0x4b1e3
movl %r14d, %ecx
shll $0x6, %ecx
movl %r14d, %edx
shrl $0x2, %edx
addl %ecx, %edx
addl %r12d, %edx
addl %eax, %edx
movl %edx, %eax
shll $0x6, %eax
shrl $0x2, %edx
addl %eax, %edx
addl %r12d, %edx
xorl %edx, %r14d
cmpq %r15, %rbx
jb 0x48ee9
jmp 0x48f25
movl $0x21, %r14d
movl %r14d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
pushq %rax
testl %esi, %esi
jle 0x48fcd
movq %rdi, %rbx
movslq %esi, %r15
shlq $0x4, %r15
addq %rdi, %r15
movl $0x21, %r14d
movl $0x9e3779b9, %r12d      # imm = 0x9E3779B9
movq (%rbx), %rdi
callq 0x4b1e3
movl %r14d, %ecx
shll $0x6, %ecx
movl %r14d, %r13d
shrl $0x2, %r13d
addl %ecx, %r13d
addl %r12d, %r13d
addl %eax, %r13d
movl %r13d, %eax
shll $0x6, %eax
shrl $0x2, %r13d
addl %eax, %r13d
addl %r12d, %r13d
xorl %r14d, %r13d
movq 0x8(%rbx), %rdi
callq 0x4b1e3
movl %r13d, %ecx
shll $0x6, %ecx
addl %eax, %ecx
movl %r13d, %r14d
shrl $0x2, %r14d
addl %r12d, %r14d
addl %ecx, %r14d
movl %r14d, %eax
shll $0x6, %eax
shrl $0x2, %r14d
addl %eax, %r14d
addl %r12d, %r14d
xorl %r13d, %r14d
addq $0x10, %rbx
cmpq %r15, %rbx
jb 0x48f60
jmp 0x48fd3
movl $0x21, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x49013
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 0x49015
xorl %eax, %eax
popq %rbp
retq