LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/janet-lang[P]janet/src/core/specials.c
// Function: janetc_var
static JanetSlot janetc_var(JanetFopts opts, int32_t argn, const Janet *argv) {
    JanetCompiler *c = opts.compiler;
    JanetTable *attr_table = handleattr(c, "var", argn, argv);
    if (c->result.status == JANET_COMPILE_ERROR) {
        return janetc_cslot(janet_wrap_nil());
    }
    SlotHeadPair *into = NULL;
    into = dohead_destructure(c, into, opts, argv[0], argv[argn - 1]);
    if (c->result.status == JANET_COMPILE_ERROR) {
        janet_v_free(into);
        return janetc_cslot(janet_wrap_nil());
    }
    JanetSlot ret;
    janet_assert(janet_v_count(into) > 0, "bad destructure");
    for (int32_t i = 0; i < janet_v_count(into); i++) {
        destructure(c, into[i].lhs, into[i].rhs, varleaf, attr_table);
        ret = into[i].rhs;
    }
    janet_v_free(into);
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r12
movl %esi, %r13d
movq %rdi, %rbx
movq 0x10(%rbp), %r15
leaq 0x25eab(%rip), %rsi     # 0x68803
movq %r15, %rdi
movl %r13d, %edx
movq %r12, %rcx
callq 0x42fc8
cmpl $0x1, 0x48(%r15)
je 0x429c2
movq %rax, %r14
leaq 0x10(%rbp), %rax
movslq %r13d, %rcx
movq (%r12), %rdx
movq -0x8(%r12,%rcx,8), %rcx
movq 0x20(%rax), %rsi
movq %rsi, 0x20(%rsp)
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %r15, %rdi
xorl %esi, %esi
callq 0x40fb0
movq %rax, -0x30(%rbp)
cmpl $0x1, 0x48(%r15)
jne 0x429de
cmpq $0x0, -0x30(%rbp)
je 0x429c2
movq -0x30(%rbp), %rdi
addq $-0x8, %rdi
callq 0x2bcd9
movabsq $-0x77fffffffffff, %rdi # imm = 0xFFF8800000000001
callq 0x4ece6
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1baf6
jmp 0x42a5a
cmpq $0x0, -0x30(%rbp)
je 0x42a6c
movq -0x30(%rbp), %rax
cmpl $0x0, -0x4(%rax)
jle 0x42a6c
movq %r15, %r12
movq -0x30(%rbp), %rax
leaq 0x8(%rax), %r13
xorl %r15d, %r15d
movq -0x8(%r13), %rsi
movq 0x10(%r13), %rax
movq %rax, 0x10(%rsp)
movups (%r13), %xmm0
movups %xmm0, (%rsp)
movq %r12, %rdi
leaq 0x19a6(%rip), %rdx      # 0x443c7
movq %r14, %rcx
callq 0x43160
movq 0x10(%r13), %rax
movq %rax, 0x10(%rbx)
movups (%r13), %xmm0
movups %xmm0, (%rbx)
incq %r15
movq -0x30(%rbp), %rax
movslq -0x4(%rax), %rax
addq $0x20, %r13
cmpq %rax, %r15
jl 0x42a01
movq -0x30(%rbp), %rdi
addq $-0x8, %rdi
callq 0x2bcd9
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x13f98
// File: /workspace/github_c_makefile_star2_O3/janet-lang[P]janet/src/core/specials.c
// Function: janetc_make_sourcemap
static const Janet *janetc_make_sourcemap(JanetCompiler *c) {
    Janet *tup = janet_tuple_begin(3);
    tup[0] = c->source ? janet_wrap_string(c->source) : janet_wrap_nil();
    tup[1] = janet_wrap_integer(c->current_mapping.line);
    tup[2] = janet_wrap_integer(c->current_mapping.column);
    return janet_tuple_end(tup);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
movl $0x3, %edi
callq 0x47fa0
movq %rax, %rbx
movq 0x20(%r14), %rdi
testq %rdi, %rdi
je 0x43bbc
movabsq $-0x6000000000000, %rsi # imm = 0xFFFA000000000000
callq 0x4ed39
jmp 0x43bcb
movabsq $-0x77fffffffffff, %rdi # imm = 0xFFF8800000000001
callq 0x4ece6
movq %rax, (%rbx)
cvtsi2sdl 0x50(%r14), %xmm0
callq 0x4ee44
movq %rax, 0x8(%rbx)
xorps %xmm0, %xmm0
cvtsi2sdl 0x54(%r14), %xmm0
callq 0x4ee44
movq %rax, 0x10(%rbx)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x47fd1
// File: /workspace/github_c_makefile_star2_O3/janet-lang[P]janet/src/core/specials.c
// Function: namelocal
static int namelocal(JanetCompiler *c, const uint8_t *head, int32_t flags, JanetSlot ret) {
    int isUnnamedRegister = !(ret.flags & JANET_SLOT_NAMED) &&
                            ret.index > 0 &&
                            ret.envindex >= 0;
    /* optimization for `(def x my-def)` - don't emit a movn/movf instruction, we can just alias my-def */
    /* TODO - implement optimization for `(def x my-var)` correctly as well w/ de-aliasing */
    int canAlias = !(flags & JANET_SLOT_MUTABLE) &&
                   !(ret.flags & JANET_SLOT_MUTABLE) &&
                   (ret.flags & JANET_SLOT_NAMED) &&
                   (ret.index >= 0) &&
                   (ret.envindex == -1);
    if (canAlias) {
        ret.flags &= ~JANET_SLOT_MUTABLE;
        isUnnamedRegister = 1; /* don't free slot after use - is an alias for another slot */
    } else if (!isUnnamedRegister) {
        /* Slot is not able to be named */
        JanetSlot localslot = janetc_farslot(c);
        janetc_copy(c, localslot, ret);
        ret = localslot;
    }
    ret.flags |= flags;
    janetc_nameslot(c, head, ret);
    return !isUnnamedRegister;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %edx, %r15d
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x10(%rbp), %r13
movl 0x8(%r13), %ecx
movl 0x10(%r13), %eax
btl $0x11, %eax
setae %dl
testl %ecx, %ecx
setg %sil
andb %dl, %sil
cmpb $0x1, %sil
jne 0x43c41
cmpl $0x0, 0xc(%r13)
setns %dl
jmp 0x43c43
xorl %edx, %edx
movl %eax, %esi
orl %r15d, %esi
btl $0x12, %esi
jb 0x43c69
btl $0x11, %eax
jae 0x43c69
testl %ecx, %ecx
js 0x43c69
cmpl $-0x1, 0xc(%r13)
jne 0x43c69
andl $0xfffbffff, %eax       # imm = 0xFFFBFFFF
xorl %r12d, %r12d
jmp 0x43cca
xorl %r12d, %r12d
testb %dl, %dl
jne 0x43cca
leaq -0x40(%rbp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x1be05
movq 0x10(%r13), %rax
movq %rax, 0x28(%rsp)
movups (%r13), %xmm0
movups %xmm0, 0x18(%rsp)
movq 0x10(%r12), %rax
movq %rax, 0x10(%rsp)
movups (%r12), %xmm0
movups %xmm0, (%rsp)
movq %r14, %rdi
callq 0x217fb
movq 0x10(%r12), %rax
movq %rax, 0x10(%r13)
movups (%r12), %xmm0
movups %xmm0, (%r13)
movl 0x10(%r13), %eax
movl $0x1, %r12d
orl %r15d, %eax
movl %eax, 0x10(%r13)
movq 0x10(%r13), %rax
movq %rax, 0x10(%rsp)
movups (%r13), %xmm0
movups %xmm0, (%rsp)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1bd3f
movl %r12d, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/janet-lang[P]janet/src/core/specials.c
// Function: janetc_addfuncdef
static int32_t janetc_addfuncdef(JanetCompiler *c, JanetFuncDef *def) {
    JanetScope *scope = c->scope;
    while (scope) {
        if (scope->flags & JANET_SCOPE_FUNCTION)
            break;
        scope = scope->parent;
    }
    janet_assert(scope, "could not add funcdef");
    janet_v_push(scope->defs, def);
    return janet_v_count(scope->defs) - 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq (%rdi), %r14
testq %r14, %r14
je 0x43d22
movq %rsi, %rbx
testb $0x1, 0x6c(%r14)
jne 0x43d27
movq 0x8(%r14), %r14
testq %r14, %r14
jne 0x43d12
callq 0x13fcc
movq 0x28(%r14), %rax
testq %rax, %rax
je 0x43d3b
movl -0x4(%rax), %ecx
leal 0x1(%rcx), %edx
cmpl -0x8(%rax), %edx
jl 0x43d57
movq %rax, %rdi
movl $0x1, %esi
movl $0x8, %edx
callq 0x4b4e8
movq %rax, 0x28(%r14)
movl -0x4(%rax), %ecx
leal 0x1(%rcx), %edx
movl %edx, -0x4(%rax)
movslq %ecx, %rcx
movq %rbx, (%rax,%rcx,8)
movq 0x28(%r14), %rax
testq %rax, %rax
je 0x43d71
movl -0x4(%rax), %eax
decl %eax
jmp 0x43d76
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/janet-lang[P]janet/src/core/specials.c
// Function: janetc_check_nil_form
static int janetc_check_nil_form(Janet x, Janet *capture, uint32_t fun_tag) {
    if (!janet_checktype(x, JANET_TUPLE)) return 0;
    JanetTuple tup = janet_unwrap_tuple(x);
    if (3 != janet_tuple_length(tup)) return 0;
    Janet op1 = tup[0];
    if (!janet_checktype(op1, JANET_FUNCTION)) return 0;
    JanetFunction *fun = janet_unwrap_function(op1);
    uint32_t tag = fun->def->flags & JANET_FUNCDEF_FLAG_TAG;
    if (tag != fun_tag) return 0;
    if (janet_checktype(tup[1], JANET_NIL)) {
        *capture = tup[2];
        return 1;
    } else if (janet_checktype(tup[2], JANET_NIL)) {
        *capture = tup[1];
        return 1;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rax
shrq $0x2f, %rax
xorl %ebx, %ebx
cmpl $0x1fff8, %eax          # imm = 0x1FFF8
jne 0x43e15
movl %edx, %r15d
movq %rsi, %r14
callq 0x4ebc4
cmpl $0x3, -0x10(%rax)
jne 0x43e15
movq %rax, %r12
movabsq $-0x800000000000, %r13  # imm = 0xFFFF800000000000
movq (%rax), %rdi
movq %rdi, %rax
andq %r13, %rax
movabsq $-0x2000000000000, %rcx # imm = 0xFFFE000000000000
cmpq %rcx, %rax
jne 0x43e15
callq 0x4ebc4
movq 0x10(%rax), %rax
movzwl 0x58(%rax), %eax
cmpl %r15d, %eax
jne 0x43e15
movabsq $-0x7800000000000, %rcx # imm = 0xFFF8800000000000
movq 0x8(%r12), %rax
movq 0x10(%r12), %rdx
movq %rax, %rsi
andq %r13, %rsi
cmpq %rcx, %rsi
jne 0x43e05
movq %rdx, %rax
jmp 0x43e0d
andq %r13, %rdx
cmpq %rcx, %rdx
jne 0x43e15
movq %rax, (%r14)
movl $0x1, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/janet-lang[P]janet/src/core/specials.c
// Function: qq_slots
static JanetSlot qq_slots(JanetFopts opts, JanetSlot *slots, int makeop) {
    JanetSlot target = janetc_gettarget(opts);
    janetc_pushslots(opts.compiler, slots);
    janetc_freeslots(opts.compiler, slots);
    janetc_emit_s(opts.compiler, makeop, target, 1);
    return target;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
movq 0x30(%rbp), %rax
movq %rax, 0x20(%rsp)
movaps 0x10(%rbp), %xmm0
movaps 0x20(%rbp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x1c64f
movq 0x10(%rbp), %rdi
movq %r15, %rsi
callq 0x1d251
movq 0x10(%rbp), %rdi
movq %r15, %rsi
callq 0x1d496
movq 0x10(%rbp), %rdi
movq 0x10(%r14), %rax
movq %rax, 0x10(%rsp)
movups (%r14), %xmm0
movups %xmm0, (%rsp)
movzbl %bl, %esi
movl $0x1, %edx
callq 0x21ae6
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/janet-lang[P]janet/src/core/state.c
// Function: janet_vm_alloc
JanetVM *janet_vm_alloc(void) {
    JanetVM *mem = janet_malloc(sizeof(JanetVM));
    if (NULL == mem) {
        JANET_OUT_OF_MEMORY;
    }
    return mem;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x348, %edi            # imm = 0x348
callq 0x12760
testq %rax, %rax
je 0x4463a
popq %rbp
retq
callq 0x14000
// File: /workspace/github_c_makefile_star2_O3/janet-lang[P]janet/src/core/string.c
// Function: janet_string_begin
uint8_t *janet_string_begin(int32_t length) {
    JanetStringHead *head = janet_gcalloc(JANET_MEMORY_STRING, sizeof(JanetStringHead) + (size_t) length + 1);
    head->length = length;
    uint8_t *data = (uint8_t *)head->data;
    data[length] = 0;
    return data;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movslq %edi, %rbx
leaq 0x19(%rbx), %rsi
movl $0x1, %edi
callq 0x2b686
movl %ebx, 0x10(%rax)
movb $0x0, 0x18(%rax,%rbx)
addq $0x18, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/janet-lang[P]janet/src/core/string.c
// Function: janet_string
const uint8_t *janet_string(const uint8_t *buf, int32_t len) {
    JanetStringHead *head = janet_gcalloc(JANET_MEMORY_STRING, sizeof(JanetStringHead) + (size_t) len + 1);
    head->length = len;
    head->hash = janet_string_calchash(buf, len);
    uint8_t *data = (uint8_t *)head->data;
    safe_memcpy(data, buf, len);
    data[len] = 0;
    return data;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movslq %esi, %r14
leaq 0x19(%r14), %rsi
movl $0x1, %edi
callq 0x2b686
movq %rax, %r15
movl %r14d, 0x10(%rax)
movq %rbx, %rdi
movl %r14d, %esi
callq 0x483ad
movl %eax, 0x14(%r15)
leaq 0x18(%r15), %r12
movq %r12, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x48567
movb $0x0, 0x18(%r15,%r14)
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/janet-lang[P]janet/src/core/string.c
// Function: janet_string_compare
int janet_string_compare(const uint8_t *lhs, const uint8_t *rhs) {
    int32_t xlen = janet_string_length(lhs);
    int32_t ylen = janet_string_length(rhs);
    int32_t len = xlen > ylen ? ylen : xlen;
    int res = memcmp(lhs, rhs, len);
    if (res) return res > 0 ? 1 : -1;
    if (xlen == ylen) return 0;
    return xlen < ylen ? -1 : 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl -0x8(%rdi), %ebx
movl -0x8(%rsi), %r14d
cmpl %r14d, %ebx
movl %r14d, %eax
cmovll %ebx, %eax
movslq %eax, %rdx
callq 0x12530
testl %eax, %eax
je 0x447d5
setg %al
jmp 0x447df
xorl %eax, %eax
cmpl %r14d, %ebx
je 0x447e9
setge %al
movzbl %al, %eax
leal -0x1(,%rax,2), %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/janet-lang[P]janet/src/core/string.c
// Function: janet_string_equalconst
int janet_string_equalconst(const uint8_t *lhs, const uint8_t *rhs, int32_t rlen, int32_t rhash) {
    int32_t lhash = janet_string_hash(lhs);
    int32_t llen = janet_string_length(lhs);
    if (lhash != rhash || llen != rlen)
        return 0;
    if (lhs == rhs)
        return 1;
    return !memcmp(lhs, rhs, rlen);
}

// Assembly:
xorl %eax, %eax
cmpl %ecx, -0x4(%rdi)
jne 0x44815
cmpl %edx, -0x8(%rdi)
jne 0x44815
cmpq %rsi, %rdi
je 0x44816
pushq %rbp
movq %rsp, %rbp
movslq %edx, %rdx
callq 0x127c0
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
sete %al
popq %rbp
retq
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/janet-lang[P]janet/src/core/string.c
// Function: findsetup
static void findsetup(int32_t argc, Janet *argv, struct kmp_state *s, int32_t extra) {
    janet_arity(argc, 2, 3 + extra);
    JanetByteView pat = janet_getbytes(argv, 0);
    JanetByteView text = janet_getbytes(argv, 1);
    int32_t start = 0;
    if (argc >= 3) {
        start = janet_getinteger(argv, 2);
        if (start < 0) janet_panic("expected non-negative start index");
    }
    kmp_init(s, text.bytes, text.len, pat.bytes, pat.len);
    s->i = start;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, -0x40(%rbp)
movq %rsi, %r13
movl %edi, %ebx
leal 0x3(%rcx), %edx
movl $0x2, %esi
callq 0x1920c
xorl %r14d, %r14d
movq %r13, %rdi
xorl %esi, %esi
callq 0x19909
movq %rax, -0x38(%rbp)
movl %edx, -0x2c(%rbp)
movq %r13, %rdi
movl $0x1, %esi
callq 0x19909
movq %rax, %r15
movl %edx, %r12d
cmpl $0x3, %ebx
jl 0x44e14
movq %r13, %rdi
movl $0x2, %esi
callq 0x19a57
movl %eax, %r14d
testl %eax, %eax
js 0x44e40
movq -0x40(%rbp), %rbx
movq %rbx, %rdi
movq %r15, %rsi
movl %r12d, %edx
movq -0x38(%rbp), %rcx
movl -0x2c(%rbp), %r8d
callq 0x4598f
movl %r14d, (%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x240b5(%rip), %rdi     # 0x68efc
callq 0x191a3
// File: /workspace/github_c_makefile_star2_O3/janet-lang[P]janet/src/core/string.c
// Function: kmp_next
static int32_t kmp_next(struct kmp_state *state) {
    int32_t i = state->i;
    int32_t j = state->j;
    int32_t textlen = state->textlen;
    int32_t patlen = state->patlen;
    const uint8_t *text = state->text;
    const uint8_t *pat = state->pat;
    int32_t *lookup = state->lookup;
    while (i < textlen) {
        if (text[i] == pat[j]) {
            if (j == patlen - 1) {
                state->i = i + 1;
                state->j = lookup[j];
                return i - j;
            } else {
                i++;
                j++;
            }
        } else {
            if (j > 0) {
                j = lookup[j - 1];
            } else {
                i++;
            }
        }
    }
    return -1;
}

// Assembly:
movl (%rdi), %r9d
movl 0x8(%rdi), %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %ecx, %r9d
jge 0x44ec7
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0x18(%rdi), %r8
movq 0x20(%rdi), %r10
movq 0x10(%rdi), %rsi
movl 0x4(%rdi), %r11d
movl 0xc(%rdi), %edx
decl %edx
movslq %r9d, %rbx
movb (%r8,%rbx), %bl
movslq %r11d, %r14
cmpb (%r10,%r14), %bl
jne 0x44e96
leal 0x1(%r9), %ebx
cmpl %edx, %r11d
je 0x44eb4
incl %r11d
jmp 0x44eab
testl %r11d, %r11d
jle 0x44ea5
movl %r11d, %r11d
movl -0x4(%rsi,%r11,4), %r11d
jmp 0x44ea8
incl %r9d
movl %r9d, %ebx
movl %ebx, %r9d
cmpl %ecx, %ebx
jl 0x44e78
jmp 0x44ec3
movl %ebx, (%rdi)
movl (%rsi,%r14,4), %eax
movl %eax, 0x4(%rdi)
subl %edx, %r9d
movl %r9d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/janet-lang[P]janet/src/core/string.c
// Function: replacesetup
static void replacesetup(int32_t argc, Janet *argv, struct replace_state *s) {
    janet_arity(argc, 3, 4);
    JanetByteView pat = janet_getbytes(argv, 0);
    Janet subst = argv[1];
    JanetByteView text = janet_getbytes(argv, 2);
    int32_t start = 0;
    if (argc == 4) {
        start = janet_getinteger(argv, 3);
        if (start < 0) janet_panic("expected non-negative start index");
    }
    kmp_init(&s->kmp, text.bytes, text.len, pat.bytes, pat.len);
    s->kmp.i = start;
    s->subst = subst;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r13
movl %edi, %r15d
movl $0x3, %esi
movl $0x4, %edx
callq 0x1920c
xorl %r14d, %r14d
movq %r13, %rdi
xorl %esi, %esi
callq 0x19909
movq %rax, -0x38(%rbp)
movl %edx, -0x2c(%rbp)
movq 0x8(%r13), %rax
movq %rax, -0x40(%rbp)
movq %r13, %rdi
movl $0x2, %esi
callq 0x19909
movl %edx, %r12d
cmpl $0x4, %r15d
jne 0x451d5
movq %r13, %rdi
movl $0x3, %esi
movq %rax, %r15
callq 0x19a57
movl %eax, %r14d
movq %r15, %rax
testl %r14d, %r14d
js 0x45205
movq %rbx, %rdi
movq %rax, %rsi
movl %r12d, %edx
movq -0x38(%rbp), %rcx
movl -0x2c(%rbp), %r8d
callq 0x4598f
movl %r14d, (%rbx)
movq -0x40(%rbp), %rax
movq %rax, 0x28(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x23cf0(%rip), %rdi     # 0x68efc
callq 0x191a3
// File: /workspace/github_c_makefile_star2_O3/janet-lang[P]janet/src/core/string.c
// Function: trim_help_args
static void trim_help_args(int32_t argc, Janet *argv, JanetByteView *str, JanetByteView *set) {
    janet_arity(argc, 1, 2);
    *str = janet_getbytes(argv, 0);
    if (argc >= 2) {
        *set = janet_getbytes(argv, 1);
    } else {
        set->bytes = (const uint8_t *)(" \t\r\n\v\f");
        set->len = 6;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r14
movl %edi, %r12d
movl $0x1, %esi
movl $0x2, %edx
callq 0x1920c
movq %r14, %rdi
xorl %esi, %esi
callq 0x19909
movq %rax, (%r15)
movl %edx, 0x8(%r15)
cmpl $0x2, %r12d
jl 0x457fa
movq %r14, %rdi
movl $0x1, %esi
callq 0x19909
jmp 0x45806
movl $0x6, %edx
leaq 0x23733(%rip), %rax     # 0x68f39
movq %rax, (%rbx)
movl %edx, 0x8(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/janet-lang[P]janet/src/core/string.c
// Function: trim_help_leftedge
static int32_t trim_help_leftedge(JanetByteView str, JanetByteView set) {
    for (int32_t i = 0; i < str.len; i++)
        if (!trim_help_checkset(set, str.bytes[i]))
            return i;
    return str.len;
}

// Assembly:
movl %esi, %eax
testl %esi, %esi
jle 0x4585f
pushq %rbp
movq %rsp, %rbp
pushq %rbx
movl %ecx, %r8d
movl %eax, %r9d
xorl %esi, %esi
testl %ecx, %ecx
jle 0x4585b
movb (%rdi,%rsi), %r10b
cmpb %r10b, (%rdx)
je 0x45851
movl $0x1, %ebx
movq %rbx, %r11
cmpq %rbx, %r8
je 0x4584c
leaq 0x1(%r11), %rbx
cmpb %r10b, (%rdx,%r11)
jne 0x4583a
cmpq %r8, %r11
jae 0x4585b
incq %rsi
cmpq %r9, %rsi
jne 0x45828
movl %eax, %esi
popq %rbx
popq %rbp
jmp 0x45861
xorl %esi, %esi
cmpl %eax, %esi
cmovll %esi, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/janet-lang[P]janet/src/core/string.c
// Function: kmp_init
static void kmp_init(
    struct kmp_state *s,
    const uint8_t *text, int32_t textlen,
    const uint8_t *pat, int32_t patlen) {
    if (patlen == 0) {
        janet_panic("expected non-empty pattern");
    }
    int32_t *lookup = janet_calloc(patlen, sizeof(int32_t));
    if (!lookup) {
        JANET_OUT_OF_MEMORY;
    }
    s->lookup = lookup;
    s->i = 0;
    s->j = 0;
    s->text = text;
    s->pat = pat;
    s->textlen = textlen;
    s->patlen = patlen;
    /* Init state machine */
    {
        int32_t i, j;
        for (i = 1, j = 0; i < patlen; i++) {
            while (j && pat[j] != pat[i]) j = lookup[j - 1];
            if (pat[j] == pat[i]) j++;
            lookup[i] = j;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testl %r8d, %r8d
je 0x45a4e
movl %r8d, %r14d
movq %rcx, %rbx
movl %edx, %r15d
movq %rsi, %r13
movq %rdi, %r12
movslq %r8d, %rdi
movl $0x4, %esi
callq 0x125a0
testq %rax, %rax
je 0x45a5a
movq %rax, 0x10(%r12)
movq $0x0, (%r12)
movq %r13, 0x18(%r12)
movq %rbx, 0x20(%r12)
movl %r15d, 0x8(%r12)
movl %r14d, 0xc(%r12)
cmpl $0x2, %r14d
jl 0x45a3f
movl %r14d, %ecx
xorl %esi, %esi
movl $0x1, %edx
movb (%rbx,%rdx), %dil
movl $0x0, %r8d
testl %esi, %esi
je 0x45a23
movl %esi, %r8d
movslq %r8d, %rsi
cmpb %dil, (%rbx,%rsi)
je 0x45a23
movl -0x4(%rax,%rsi,4), %r8d
testl %r8d, %r8d
jne 0x45a0d
xorl %r8d, %r8d
movslq %r8d, %rsi
xorl %r8d, %r8d
cmpb %dil, (%rbx,%rsi)
sete %r8b
addl %r8d, %esi
movl %esi, (%rax,%rdx,4)
incq %rdx
cmpq %rcx, %rdx
jne 0x459fc
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x234c9(%rip), %rdi     # 0x68f1e
callq 0x191a3
callq 0x1402e
nop
// File: /workspace/github_c_makefile_star2_O3/janet-lang[P]janet/src/core/strtod.c
// Function: bignat_muladd
static void bignat_muladd(struct BigNat *mant, uint32_t factor, uint32_t term) {
    int32_t i;
    uint64_t carry = ((uint64_t) mant->first_digit) * factor + term;
    mant->first_digit = carry % BIGNAT_BASE;
    carry /= BIGNAT_BASE;
    for (i = 0; i < mant->n; i++) {
        carry += ((uint64_t) mant->digits[i]) * factor;
        mant->digits[i] = carry % BIGNAT_BASE;
        carry /= BIGNAT_BASE;
    }
    if (carry) bignat_append(mant, (uint32_t) carry);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl (%rdi), %r8d
movl %esi, %eax
imulq %rax, %r8
movl %edx, %ecx
addq %r8, %rcx
movl %ecx, %edx
andl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
movl %edx, (%rdi)
movq %rcx, %rbx
shrq $0x1f, %rbx
cmpl $0x0, 0x4(%rdi)
jle 0x46074
movq 0x10(%rdi), %rdx
xorl %esi, %esi
movl (%rdx,%rsi,4), %ecx
imulq %rax, %rcx
addq %rbx, %rcx
movl %ecx, %r8d
andl $0x7fffffff, %r8d       # imm = 0x7FFFFFFF
movl %r8d, (%rdx,%rsi,4)
incq %rsi
movq %rcx, %rbx
shrq $0x1f, %rbx
movslq 0x4(%rdi), %r8
cmpq %r8, %rsi
jl 0x46049
shrq $0x1f, %rcx
je 0x46086
movl $0x1, %esi
callq 0x463f6
movl %ebx, (%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/janet-lang[P]janet/src/core/strtod.c
// Function: janet_scan_int64
int janet_scan_int64(const uint8_t *str, int32_t len, int64_t *out) {
    int neg;
    uint64_t bi;
    if (scan_uint64(str, len, &bi, &neg)) {
        if (neg && bi <= ((UINT64_MAX / 2) + 1)) {
            if (bi > INT64_MAX) {
                *out = INT64_MIN;
            } else {
                *out = -((int64_t) bi);
            }
            return 1;
        }
        if (!neg && bi <= INT64_MAX) {
            *out = (int64_t) bi;
            return 1;
        }
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
leaq -0x18(%rbp), %rdx
leaq -0xc(%rbp), %rcx
callq 0x4611e
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
je 0x46117
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
movl -0xc(%rbp), %esi
testl %esi, %esi
setne %dil
movq -0x18(%rbp), %rcx
leaq 0x1(%rdx), %r8
cmpq %r8, %rcx
setb %r8b
andb %dil, %r8b
cmpb $0x1, %r8b
jne 0x460fa
movq %rcx, %rax
negq %rax
testq %rcx, %rcx
cmovsq %rdx, %rax
movq %rax, %rcx
jmp 0x4610f
testl %esi, %esi
sete %dl
testq %rcx, %rcx
setns %sil
andb %dl, %sil
cmpb $0x1, %sil
jne 0x46117
movq %rcx, (%rbx)
movl $0x1, %eax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x46315
leal -0x2(%rax), %esi
cmpb $0x3a, (%rdi,%rsi)
jne 0x46315
movl %eax, %eax
movzbl -0x1(%rdi,%rax), %eax
cmpl $0x75, %eax
je 0x46360
cmpl $0x73, %eax
je 0x46343
movl $0x1, %r14d
cmpl $0x6e, %eax
jne 0x46335
leaq -0x20(%rbp), %r15
jmp 0x4631b
leaq -0x20(%rbp), %r15
movl %eax, %esi
xorl %edx, %edx
movq %r15, %rcx
callq 0x45a60
movl %eax, %r14d
movsd (%r15), %xmm0
callq 0x4ee44
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 0x4609c
movl %eax, %r14d
xorl $0x1, %r14d
movq (%r15), %rdi
callq 0x2c267
jmp 0x46332
leaq -0x20(%rbp), %rdx
leaq -0x2c(%rbp), %r14
movq %r14, %rcx
callq 0x4611e
testl %eax, %eax
sete %cl
cmpl $0x0, (%r14)
setne %al
orb %cl, %al
jne 0x46386
movq -0x20(%rbp), %rdi
jmp 0x46388
xorl %edi, %edi
movzbl %al, %r14d
callq 0x2c29c
jmp 0x46332
// File: /workspace/github_c_makefile_star2_O3/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 0x177e3
movslq 0x10(%rbx), %rdi
addq 0x18(%rbx), %rdi
leaq 0x24146(%rip), %rdx     # 0x6a500
movl $0x20, %esi
movsd -0x10(%rbp), %xmm0
movb $0x1, %al
callq 0x12390
testl %eax, %eax
jle 0x463ec
movl %eax, %ecx
xorl %edx, %edx
movslq 0x10(%rbx), %rsi
addq 0x18(%rbx), %rsi
cmpb $0x2c, (%rdx,%rsi)
jne 0x463e5
movb $0x2e, (%rsi,%rdx)
incq %rdx
cmpl %edx, %ecx
jne 0x463d3
addl %eax, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x46438
movq 0x10(%rbx), %rdi
leaq (,%r15,8), %rsi
callq 0x12840
testq %rax, %rax
je 0x4644f
movl %r15d, %ecx
addl %r15d, %ecx
movl %ecx, 0x8(%rbx)
movq %rax, 0x10(%rbx)
jmp 0x4643c
movq 0x10(%rbx), %rax
movl %r15d, 0x4(%rbx)
leaq (%rax,%r14,4), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x1405c
// File: /workspace/github_c_makefile_star2_O3/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 0x464a6
movq 0x10(%rdi), %rsi
xorl %edx, %edx
movslq 0x4(%rdi), %r9
cmpq %r9, %r8
jge 0x46478
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
ja 0x4646b
movl 0x4(%rdi), %r8d
shlq $0x1f, %rdx
movq %rdx, %rax
movl (%rdi), %edx
testl %r8d, %r8d
je 0x464c3
movq 0x10(%rdi), %rsi
movslq %r8d, %r9
cmpl $0x0, -0x4(%rsi,%r9,4)
jne 0x464c3
decl %r8d
movl %r8d, 0x4(%rdi)
addq %rdx, %rax
xorl %edx, %edx
divq %rcx
movl %eax, (%rdi)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x46502
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 0x46506
movl -0xc(%rax,%r8,4), %r9d
jmp 0x46512
movl (%rdi), %edx
jmp 0x46568
xorl %r9d, %r9d
cmpl $0x2, %r8d
jne 0x46512
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
// File: /workspace/github_c_makefile_star2_O3/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 0x48535
testl %eax, %eax
jns 0x46594
leal 0x1(%rbx), %edi
callq 0x48535
movslq %eax, %r14
movq %r14, %rsi
shlq $0x4, %rsi
addq $0x28, %rsi
movl $0x6, %edi
callq 0x2b686
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 0x4eedd
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/janet-lang[P]janet/src/core/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 0x4a67f
leal -0x1(%r12), %r13d
andl %eax, %r13d
cmpl %r12d, %r13d
jge 0x46655
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 0x466ae
movq %r14, %rsi
callq 0x4a1bd
testl %eax, %eax
jne 0x466ae
addq $0x10, %r15
decq %r12
jne 0x46628
testl %r13d, %r13d
jle 0x4669e
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 0x466ae
movq %r14, %rsi
callq 0x4a1bd
testl %eax, %eax
jne 0x466a3
incq %r12
addq $0x10, %r15
decq %r13
jne 0x4666e
xorl %r15d, %r15d
jmp 0x466ae
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_O3/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 0x468e0
movq %r14, %rbx
jmp 0x46935
callq 0x46574
movq %rax, %rbx
movl -0x10(%r14), %eax
testl %eax, %eax
jle 0x4692d
leaq 0x8(%r14), %r15
xorl %r12d, %r12d
movq -0x8(%r15), %rsi
movq %rsi, %rcx
shrq $0x2f, %rcx
cmpl $0x1fff1, %ecx          # imm = 0x1FFF1
je 0x4691e
movq (%r15), %rdx
movq %rbx, %rdi
movl $0x1, %ecx
callq 0x466c0
movl -0x10(%r14), %eax
incq %r12
movslq %eax, %rcx
addq $0x10, %r15
cmpq %rcx, %r12
jl 0x468f7
movq -0x8(%r14), %rax
movq %rax, -0x8(%rbx)
movl -0x10(%rbx), %esi
movq %rbx, %rdi
callq 0x48481
movl %eax, -0x14(%rbx)
movq -0x8(%rbx), %rcx
testq %rcx, %rcx
je 0x46958
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_O3/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
je 0x469eb
movq %rsi, %r14
movq %rdi, %r15
movl $0xffffff39, %r13d      # imm = 0xFFFFFF39
movabsq $-0x800000000000, %r12  # imm = 0xFFFF800000000000
movq %r15, %rdi
movq %r14, %rsi
callq 0x465e2
testq %rax, %rax
je 0x469d6
movq (%rax), %rcx
andq %r12, %rcx
cmpq %rbx, %rcx
jne 0x46a04
movq -0x8(%r15), %r15
testq %r15, %r15
je 0x469eb
leal 0x1(%r13), %eax
testl %r13d, %r13d
movl %eax, %r13d
jne 0x469bb
incq %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4ece6
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_O3/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
pushq %rax
movq %rdx, -0x30(%rbp)
movabsq $-0x7800000000000, %r14 # imm = 0xFFF8800000000000
testq %rdi, %rdi
je 0x46a7a
movq %rsi, %r12
movq %rdi, %r15
movl $0xffffff39, %ebx       # imm = 0xFFFFFF39
movabsq $-0x800000000000, %r13  # imm = 0xFFFF800000000000
movq %r15, %rdi
movq %r12, %rsi
callq 0x465e2
testq %rax, %rax
je 0x46a68
movq (%rax), %rcx
andq %r13, %rcx
cmpq %r14, %rcx
jne 0x46a93
movq -0x8(%r15), %r15
testq %r15, %r15
je 0x46a7a
leal 0x1(%rbx), %eax
testl %ebx, %ebx
movl %eax, %ebx
jne 0x46a4d
incq %r14
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4ece6
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_O3/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 0x47425
movq %rax, %r14
movl -0x10(%rbx), %eax
testl %eax, %eax
jle 0x46b04
leaq 0x8(%rbx), %r15
xorl %r12d, %r12d
movq -0x8(%r15), %rsi
movq %rsi, %rcx
shrq $0x2f, %rcx
cmpl $0x1fff1, %ecx          # imm = 0x1FFF1
je 0x46af5
movq (%r15), %rdx
movq %r14, %rdi
callq 0x476f0
movl -0x10(%rbx), %eax
incq %r12
movslq %eax, %rcx
addq $0x10, %r15
cmpq %rcx, %r12
jl 0x46ad4
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x46ed8
movabsq $0x303030303030305f, %rax # imm = 0x303030303030305F
movq %rax, 0x84(%rbx)
movq $0x0, 0x7c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x1408a
// File: /workspace/github_c_makefile_star2_O3/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 0x46f70
cmpl $0x0, (%r14)
je 0x46f67
movq %rax, %rbx
movq %fs:0x0, %rax
leaq -0x348(%rax), %rax
decl 0x7c(%rax)
incl 0x80(%rax)
leaq 0x239b8(%rip), %rax     # 0x6a91c
movq %rax, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x483ad
movl %eax, %r12d
leaq -0x34(%rbp), %r13
movl $0x0, (%r13)
movq %rbx, %rdi
movl %r14d, %esi
movl %eax, %edx
movq %r13, %rcx
callq 0x46f70
movq %rax, %r15
cmpl $0x0, (%r13)
je 0x470e8
movq (%r15), %r14
jmp 0x4712f
movslq %r14d, %rax
movq %rax, -0x30(%rbp)
leaq 0x19(%rax), %rsi
movl $0x2, %edi
callq 0x2b686
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 0x48567
movb $0x0, 0x18(%r13,%rbx)
movq %r14, %rdi
movq %r15, %rsi
callq 0x47141
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_O3/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 0x47244
movq %rbx, -0x40(%rbp)
leal 0x1(,%rax,2), %edi
callq 0x48535
movl %eax, %r12d
movq 0x70(%r14), %r15
movl %eax, %esi
shlq $0x3, %rsi
movl $0x1, %edi
callq 0x125a0
testq %rax, %rax
je 0x4725c
movl 0x78(%r14), %ebx
movq %rax, 0x70(%r14)
movl %r12d, 0x78(%r14)
movq %r14, -0x38(%rbp)
movl $0x0, 0x80(%r14)
testq %rbx, %rbx
je 0x4721b
xorl %r12d, %r12d
leaq 0x2373f(%rip), %r14     # 0x6a91c
movq (%r15,%r12,8), %r13
testq %r13, %r13
sete %al
cmpq %r14, %r13
sete %cl
orb %al, %cl
jne 0x47213
movl -0x8(%r13), %esi
movl -0x4(%r13), %edx
movq %r13, %rdi
leaq -0x2c(%rbp), %rcx
callq 0x46f70
cmpl $0x0, -0x2c(%rbp)
jne 0x4721b
testq %rax, %rax
je 0x4721b
movq %r13, (%rax)
incq %r12
cmpq %r12, %rbx
jne 0x471dd
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 0x46f70
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
callq 0x140ea
// File: /workspace/github_c_makefile_star2_O3/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 0x483ad
movl %eax, %r15d
leaq -0x24(%rbp), %r14
movq %rbx, %rdi
movl $0x7, %esi
movl %eax, %edx
movq %r14, %rcx
callq 0x46f70
cmpl $0x0, (%r14)
je 0x47336
movl $0x6, %eax
movzbl (%rbx,%rax), %ecx
cmpl $0x39, %ecx
je 0x472fb
cmpl $0x5a, %ecx
je 0x472f0
cmpl $0x7a, %ecx
jne 0x472ff
movb $0x41, %cl
jmp 0x47301
movb $0x30, (%rbx,%rax)
decq %rax
jne 0x472d9
jmp 0x47304
movb $0x61, %cl
jmp 0x47301
incb %cl
movb %cl, (%rbx,%rax)
movq %rbx, %rdi
movl $0x7, %esi
callq 0x483ad
movl %eax, %r15d
movq %rbx, %rdi
movl $0x7, %esi
movl %eax, %edx
movq %r14, %rcx
callq 0x46f70
movq %rax, %r12
cmpl $0x0, -0x24(%rbp)
movl $0x6, %eax
jne 0x472d9
jmp 0x47339
movq %rax, %r12
movl $0x20, %esi
movl $0x2, %edi
callq 0x2b686
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 0x47141
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)