LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/src/core/asm.c
// Function: janet_disasm_constants
static Janet janet_disasm_constants(JanetFuncDef *def) {
    JanetArray *constants = janet_array(def->constants_length);
    for (int32_t i = 0; i < def->constants_length; i++) {
        constants->data[i] = def->constants[i];
    }
    constants->count = def->constants_length;
    return janet_wrap_array(constants);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x6c(%rdi), %edi
callq 0x146a0
movl 0x6c(%rbx), %edx
testl %edx, %edx
jle 0x16c2b
xorl %ecx, %ecx
movq 0x18(%rax), %rdx
movq 0x18(%rbx), %rsi
movq (%rsi,%rcx,8), %rsi
movq %rsi, (%rdx,%rcx,8)
incq %rcx
movslq 0x6c(%rbx), %rdx
cmpq %rdx, %rcx
jl 0x16c0f
movl %edx, 0x10(%rax)
movabsq $-0x4800000000000, %rsi # imm = 0xFFFB800000000000
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x4f9f2
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/src/core/asm.c
// Function: janet_disasm_sourcemap
static Janet janet_disasm_sourcemap(JanetFuncDef *def) {
    if (NULL == def->sourcemap) return janet_wrap_nil();
    JanetArray *sourcemap = janet_array(def->bytecode_length);
    for (int32_t i = 0; i < def->bytecode_length; i++) {
        Janet *t = janet_tuple_begin(2);
        JanetSourceMapping mapping = def->sourcemap[i];
        t[0] = janet_wrap_integer(mapping.line);
        t[1] = janet_wrap_integer(mapping.column);
        sourcemap->data[i] = janet_wrap_tuple(janet_tuple_end(t));
    }
    sourcemap->count = def->bytecode_length;
    return janet_wrap_array(sourcemap);
}

// Assembly:
cmpq $0x0, 0x38(%rdi)
je 0x16d0a
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x70(%rdi), %edi
callq 0x146a0
movq %rax, %r14
movl 0x70(%rbx), %eax
testl %eax, %eax
jle 0x16ce6
xorl %r13d, %r13d
movl $0x2, %edi
callq 0x48a50
movq %rax, %r12
movq 0x38(%rbx), %rax
xorps %xmm0, %xmm0
cvtsi2sdl (%rax,%r13,8), %xmm0
xorps %xmm1, %xmm1
cvtsi2sdl 0x4(%rax,%r13,8), %xmm1
movsd %xmm1, -0x30(%rbp)
callq 0x4fab8
movq %rax, (%r12)
movsd -0x30(%rbp), %xmm0
callq 0x4fab8
movq %rax, 0x8(%r12)
movq 0x18(%r14), %r15
movq %r12, %rdi
callq 0x48a81
movq %rax, %rdi
movabsq $-0x4000000000000, %rsi # imm = 0xFFFC000000000000
callq 0x4f9ad
movq %rax, (%r15,%r13,8)
incq %r13
movslq 0x70(%rbx), %rax
cmpq %rax, %r13
jl 0x16c77
movl %eax, 0x10(%r14)
movabsq $-0x4800000000000, %rsi # imm = 0xFFFB800000000000
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4f9f2
movabsq $-0x77fffffffffff, %rdi # imm = 0xFFF8800000000001
jmp 0x4f95a
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/src/core/asm.c
// Function: janet_disasm_environments
static Janet janet_disasm_environments(JanetFuncDef *def) {
    JanetArray *envs = janet_array(def->environments_length);
    for (int32_t i = 0; i < def->environments_length; i++) {
        envs->data[i] = janet_wrap_integer(def->environments[i]);
    }
    envs->count = def->environments_length;
    return janet_wrap_array(envs);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r14
movl 0x74(%rdi), %edi
callq 0x146a0
movq %rax, %rbx
movl 0x74(%r14), %eax
testl %eax, %eax
jle 0x16d63
xorl %r15d, %r15d
movq 0x18(%rbx), %r12
movq 0x10(%r14), %rax
xorps %xmm0, %xmm0
cvtsi2sdl (%rax,%r15,4), %xmm0
callq 0x4fab8
movq %rax, (%r12,%r15,8)
incq %r15
movslq 0x74(%r14), %rax
cmpq %rax, %r15
jl 0x16d3d
movl %eax, 0x10(%rbx)
movabsq $-0x4800000000000, %rsi # imm = 0xFFFB800000000000
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x4f9f2
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/src/core/asm.c
// Function: janet_disasm_defs
static Janet janet_disasm_defs(JanetFuncDef *def) {
    JanetArray *defs = janet_array(def->defs_length);
    for (int32_t i = 0; i < def->defs_length; i++) {
        defs->data[i] = janet_disasm(def->defs[i]);
    }
    defs->count = def->defs_length;
    return janet_wrap_array(defs);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r14
movl 0x78(%rdi), %edi
callq 0x146a0
movq %rax, %rbx
movl 0x78(%r14), %eax
testl %eax, %eax
jle 0x16dc5
xorl %r15d, %r15d
movq 0x18(%rbx), %r12
movq 0x20(%r14), %rax
movq (%rax,%r15,8), %rdi
callq 0x166cf
movq %rax, (%r12,%r15,8)
incq %r15
movslq 0x78(%r14), %rax
cmpq %rax, %r15
jl 0x16da4
movl %eax, 0x10(%rbx)
movabsq $-0x4800000000000, %rsi # imm = 0xFFFB800000000000
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x4f9f2
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/src/core/asm.c
// Function: janet_asm_deinit
static void janet_asm_deinit(JanetAssembler *a) {
    janet_table_deinit(&a->slots);
    janet_table_deinit(&a->labels);
    janet_table_deinit(&a->envs);
    janet_table_deinit(&a->defs);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x128, %rdi            # imm = 0x128
callq 0x47e7c
leaq 0xf8(%rbx), %rdi
callq 0x47e7c
leaq 0x158(%rbx), %rdi
callq 0x47e7c
addq $0x188, %rbx            # imm = 0x188
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x47e7c
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/src/core/asm.c
// Function: janet_asm_error
static void janet_asm_error(JanetAssembler *a, const char *message) {
    if (a->errindex < 0) {
        a->errmessage = janet_formatc("%s", message);
    } else {
        a->errmessage = janet_formatc("%s, instruction %d", message, a->errindex);
    }
    janet_asm_longjmp(a);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0xe0(%rdi), %edx
testl %edx, %edx
jns 0x17171
leaq 0x51eca(%rip), %rdi     # 0x69032
xorl %eax, %eax
callq 0x3fd86
jmp 0x1717f
leaq 0x3c589(%rip), %rdi     # 0x53701
xorl %eax, %eax
callq 0x3fd86
movq %rax, 0xd8(%rbx)
addq $0x10, %rbx
movq %rbx, %rdi
movl $0x1, %esi
callq 0x128f0
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/src/core/asm.c
// Function: janet_get1
static Janet janet_get1(Janet ds, Janet key) {
    switch (janet_type(ds)) {
        default:
            return janet_wrap_nil();
        case JANET_TABLE:
            return janet_table_get(janet_unwrap_table(ds), key);
        case JANET_STRUCT:
            return janet_struct_get(janet_unwrap_struct(ds), key);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %xmm0
movq %rdi, %rcx
shrq $0x2f, %rcx
andl $0xf, %ecx
xorl %eax, %eax
ucomisd %xmm0, %xmm0
movq %rsi, %rbx
cmovpl %ecx, %eax
cmpl $0x9, %eax
je 0x171d8
cmpl $0xa, %eax
jne 0x171ee
callq 0x4f838
movq %rax, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x47388
callq 0x4f838
movq %rax, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x47f51
movabsq $-0x77fffffffffff, %rdi # imm = 0xFFF8800000000001
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x4f95a
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/src/core/asm.c
// Function: doarg
static uint32_t doarg(
    JanetAssembler *a,
    enum JanetOpArgType argtype,
    int nth,
    int nbytes,
    int hassign,
    Janet x) {
    int32_t arg = doarg_1(a, argtype, x);
    /* Calculate the min and max values that can be stored given
     * nbytes, and whether or not the storage is signed */
    int32_t max = (1 << ((nbytes << 3) - hassign)) - 1;
    int32_t min = hassign ? -max - 1 : 0;
    if (arg < min)
        janet_asm_errorv(a, janet_formatc("instruction argument %v is too small, must be %d byte%s",
                                          x, nbytes, nbytes > 1 ? "s" : ""));
    if (arg > max)
        janet_asm_errorv(a, janet_formatc("instruction argument %v is too large, must be %d byte%s",
                                          x, nbytes, nbytes > 1 ? "s" : ""));
    return ((uint32_t) arg) << (nth << 3);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r14
movl %r8d, %r13d
movl %ecx, %r15d
movl %edx, %r12d
movq %rdi, %rbx
movq %r9, %rdx
callq 0x172c5
leal (,%r15,8), %ecx
subl %r13d, %ecx
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
shll %cl, %edx
testl %r13d, %r13d
cmovnel %edx, %r13d
cmpl %r13d, %eax
jl 0x17264
notl %edx
cmpl %edx, %eax
jg 0x17283
shll $0x3, %r12d
movl %r12d, %ecx
shll %cl, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x2, %r15d
leaq 0x51dc4(%rip), %rax     # 0x69033
leaq 0x55e87(%rip), %rcx     # 0x6d0fd
cmovgeq %rax, %rcx
leaq 0x3c7c8(%rip), %rdi     # 0x53a49
jmp 0x172a0
cmpl $0x2, %r15d
leaq 0x51da5(%rip), %rax     # 0x69033
leaq 0x55e68(%rip), %rcx     # 0x6d0fd
cmovgeq %rax, %rcx
leaq 0x3c7e1(%rip), %rdi     # 0x53a81
movq %r14, %rsi
movl %r15d, %edx
xorl %eax, %eax
callq 0x3fd86
movq %rax, 0xd8(%rbx)
addq $0x10, %rbx
movq %rbx, %rdi
movl $0x1, %esi
callq 0x128f0
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/src/core/asm.c
// Function: janet_asm_addenv
static int32_t janet_asm_addenv(JanetAssembler *a, Janet envname) {
    Janet check;
    JanetFuncDef *def = a->def;
    int32_t envindex;
    int32_t res;
    if (janet_equals(a->name, envname)) {
        return -1;
    }
    /* Check for memoized value */
    check = janet_table_get(&a->envs, envname);
    if (janet_checktype(check, JANET_NUMBER)) {
        return (int32_t) janet_unwrap_number(check);
    }
    if (NULL == a->parent) return -2;
    res = janet_asm_addenv(a->parent, envname);
    if (res < -1) {
        return res;
    }
    envindex = def->environments_length;
    janet_table_put(&a->envs, envname, janet_wrap_number(envindex));
    if (envindex >= a->environments_capacity) {
        int32_t newcap = 2 * envindex;
        def->environments = janet_realloc(def->environments, newcap * sizeof(int32_t));
        if (NULL == def->environments) {
            JANET_OUT_OF_MEMORY;
        }
        a->environments_capacity = newcap;
    }
    def->environments[envindex] = (int32_t) res;
    def->environments_length = envindex + 1;
    return envindex;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq 0x8(%rdi), %r12
movq 0xf0(%rdi), %rdi
callq 0x4acce
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
testl %eax, %eax
jne 0x1765e
leaq 0x158(%rbx), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x47f51
movq %rax, %xmm0
ucomisd %xmm0, %xmm0
setp %cl
movabsq $0x7800000000000, %rdx  # imm = 0x7800000000000
testq %rdx, %rax
setne %al
testb %al, %cl
jne 0x175cc
cvttsd2si %xmm0, %r14d
jmp 0x1765e
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x175e6
movq %r15, %rsi
callq 0x1755b
cmpl $-0x1, %eax
jge 0x175ee
movl %eax, %r14d
jmp 0x1765e
movl $0xfffffffe, %r14d      # imm = 0xFFFFFFFE
jmp 0x1765e
movl %eax, -0x2c(%rbp)
movl 0x74(%r12), %r14d
movslq %r14d, %rax
movq %rax, -0x38(%rbp)
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
callq 0x4fab8
movq %r13, %rdi
movq %r15, %rsi
movq -0x38(%rbp), %r15
movq %rax, %rdx
callq 0x481b3
cmpl 0xe4(%rbx), %r15d
jl 0x1764a
movq 0x10(%r12), %rdi
leaq (,%r15,8), %rsi
callq 0x12850
movq %rax, 0x10(%r12)
testq %rax, %rax
je 0x17670
leal (%r14,%r14), %eax
movl %eax, 0xe4(%rbx)
movq 0x10(%r12), %rax
movl -0x2c(%rbp), %ecx
movl %ecx, (%rax,%r15,4)
incl %r15d
movl %r15d, 0x74(%r12)
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x12e88
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/src/core/buffer.c
// Function: janet_buffer_init
JanetBuffer *janet_buffer_init(JanetBuffer *buffer, int32_t capacity) {
    janet_buffer_init_impl(buffer, capacity);
    buffer->gc.data.next = NULL;
    buffer->gc.flags = JANET_MEM_DISABLED;
    return buffer;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x1769e
movq $0x0, 0x8(%rbx)
movl $0x200, (%rbx)          # imm = 0x200
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/src/core/buffer.c
// Function: janet_buffer_init_impl
static JanetBuffer *janet_buffer_init_impl(JanetBuffer *buffer, int32_t capacity) {
    uint8_t *data = NULL;
    if (capacity < 4) capacity = 4;
    janet_gcpressure(capacity);
    data = janet_malloc(sizeof(uint8_t) * (size_t) capacity);
    if (NULL == data) {
        JANET_OUT_OF_MEMORY;
    }
    buffer->count = 0;
    buffer->capacity = capacity;
    buffer->data = data;
    return buffer;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpl $0x5, %esi
movl $0x4, %r14d
cmovgel %esi, %r14d
movq %r14, %rdi
callq 0x2b134
movq %r14, %rdi
callq 0x12770
testq %rax, %rax
je 0x176e1
movl $0x0, 0x10(%rbx)
movl %r14d, 0x14(%rbx)
movq %rax, 0x18(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
callq 0x12eb8
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/src/core/buffer.c
// Function: janet_pointer_buffer_unsafe
JanetBuffer *janet_pointer_buffer_unsafe(void *memory, int32_t capacity, int32_t count) {
    if (count < 0) janet_panic("count < 0");
    if (capacity < count) janet_panic("capacity < count");
    JanetBuffer *buffer = janet_gcalloc(JANET_MEMORY_BUFFER, sizeof(JanetBuffer));
    buffer->gc.flags |= JANET_BUFFER_FLAG_NO_REALLOC;
    buffer->capacity = capacity;
    buffer->count = count;
    buffer->data = (uint8_t *) memory;
    return buffer;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testl %edx, %edx
js 0x17729
movl %edx, %ebx
movl %esi, %r15d
cmpl %edx, %esi
jl 0x17735
movq %rdi, %r14
movl $0x20, %esi
movl $0x8, %edi
callq 0x2bb18
orb $0x1, 0x2(%rax)
movl %r15d, 0x14(%rax)
movl %ebx, 0x10(%rax)
movq %r14, 0x18(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3c410(%rip), %rdi     # 0x53b40
callq 0x19263
leaq 0x3c40e(%rip), %rdi     # 0x53b4a
callq 0x19263
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/src/core/buffer.c
// Function: janet_buffer_ensure
void janet_buffer_ensure(JanetBuffer *buffer, int32_t capacity, int32_t growth) {
    uint8_t *new_data;
    uint8_t *old = buffer->data;
    if (capacity <= buffer->capacity) return;
    janet_buffer_can_realloc(buffer);
    int64_t big_capacity = ((int64_t) capacity) * growth;
    capacity = big_capacity > INT32_MAX ? INT32_MAX : (int32_t) big_capacity;
    janet_gcpressure(capacity - buffer->capacity);
    new_data = janet_realloc(old, (size_t) capacity * sizeof(uint8_t));
    if (NULL == new_data) {
        JANET_OUT_OF_MEMORY;
    }
    buffer->data = new_data;
    buffer->capacity = capacity;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl 0x14(%rdi), %eax
cmpl %esi, %eax
jge 0x177d7
movq %rdi, %rbx
testb $0x1, 0x2(%rdi)
jne 0x177e2
movslq %esi, %rcx
movslq %edx, %r15
imulq %rcx, %r15
movl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
cmpq %rcx, %r15
cmovgeq %rcx, %r15
movq 0x18(%rbx), %r14
movl %r15d, %ecx
subl %eax, %ecx
movslq %ecx, %rdi
callq 0x2b134
movslq %r15d, %rsi
movq %r14, %rdi
callq 0x12850
testq %rax, %rax
je 0x177ee
movq %rax, 0x18(%rbx)
movl %r15d, 0x14(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3c5c5(%rip), %rdi     # 0x53dae
callq 0x19263
callq 0x12ee6
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/src/core/buffer.c
// Function: janet_buffer_setcount
void janet_buffer_setcount(JanetBuffer *buffer, int32_t count) {
    if (count < 0)
        return;
    if (count > buffer->count) {
        int32_t oldcount = buffer->count;
        janet_buffer_ensure(buffer, count, 1);
        memset(buffer->data + oldcount, 0, count - oldcount);
    }
    buffer->count = count;
}

// Assembly:
testl %esi, %esi
js 0x17842
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movslq 0x10(%rdi), %r15
cmpl %r15d, %esi
jle 0x17834
movq %r14, %rdi
movl %ebx, %esi
movl $0x1, %edx
callq 0x1777e
movq %r15, %rdi
addq 0x18(%r14), %rdi
movl %ebx, %eax
subl %r15d, %eax
movslq %eax, %rdx
xorl %esi, %esi
callq 0x12410
movl %ebx, 0x10(%r14)
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/buffer.c
// Function: janet_buffer_extra
void janet_buffer_extra(JanetBuffer *buffer, int32_t n) {
    /* Check for buffer overflow */
    if ((int64_t)n + buffer->count > INT32_MAX) {
        janet_panic("buffer overflow");
    }
    int32_t new_size = buffer->count + n;
    if (new_size > buffer->capacity) {
        janet_buffer_can_realloc(buffer);
        int32_t new_capacity = (new_size > (INT32_MAX / 2)) ? INT32_MAX : (new_size * 2);
        uint8_t *new_data = janet_realloc(buffer->data, new_capacity * sizeof(uint8_t));
        janet_gcpressure(new_capacity - buffer->capacity);
        if (NULL == new_data) {
            JANET_OUT_OF_MEMORY;
        }
        buffer->data = new_data;
        buffer->capacity = new_capacity;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movslq %esi, %rcx
movslq 0x10(%rdi), %rax
addq %rax, %rcx
movl $0x80000000, %edx       # imm = 0x80000000
cmpq %rdx, %rcx
jge 0x178bb
movq %rdi, %rbx
addl %esi, %eax
cmpl 0x14(%rdi), %eax
jle 0x178b2
testb $0x1, 0x2(%rbx)
jne 0x178c7
leal (%rax,%rax), %ecx
cmpl $0x40000000, %eax       # imm = 0x40000000
movl $0x7fffffff, %r12d      # imm = 0x7FFFFFFF
cmovll %ecx, %r12d
movq 0x18(%rbx), %rdi
movslq %r12d, %r15
movq %r15, %rsi
callq 0x12850
movq %rax, %r14
movslq 0x14(%rbx), %rax
subq %rax, %r15
movq %r15, %rdi
callq 0x2b134
testq %r14, %r14
je 0x178d3
movq %r14, 0x18(%rbx)
movl %r12d, 0x14(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x51d7c(%rip), %rdi     # 0x6963e
callq 0x19263
leaq 0x3c4e0(%rip), %rdi     # 0x53dae
callq 0x19263
callq 0x12f14
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/src/core/buffer.c
// Function: janet_buffer_push_bytes
void janet_buffer_push_bytes(JanetBuffer *buffer, const uint8_t *string, int32_t length) {
    if (0 == length) return;
    janet_buffer_extra(buffer, length);
    memcpy(buffer->data + buffer->count, string, length);
    buffer->count += length;
}

// Assembly:
testl %edx, %edx
je 0x17963
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
movl %edx, %esi
callq 0x17843
movslq 0x10(%r14), %rdi
addq 0x18(%r14), %rdi
movslq %ebx, %rdx
movq %r15, %rsi
callq 0x12680
addl %ebx, 0x10(%r14)
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/buffer.c
// Function: janet_buffer_push_u16
void janet_buffer_push_u16(JanetBuffer *buffer, uint16_t x) {
    janet_buffer_extra(buffer, 2);
    buffer->data[buffer->count] = x & 0xFF;
    buffer->data[buffer->count + 1] = (x >> 8) & 0xFF;
    buffer->count += 2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
movl $0x2, %esi
callq 0x17843
movq 0x18(%rbx), %rax
movslq 0x10(%rbx), %rcx
movl %r14d, %edx
movb %dl, (%rax,%rcx)
movq 0x18(%rbx), %rax
movslq 0x10(%rbx), %rcx
movb %dh, 0x1(%rax,%rcx)
addl $0x2, 0x10(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/src/core/buffer.c
// Function: janet_buffer_push_u32
void janet_buffer_push_u32(JanetBuffer *buffer, uint32_t x) {
    janet_buffer_extra(buffer, 4);
    buffer->data[buffer->count] = x & 0xFF;
    buffer->data[buffer->count + 1] = (x >> 8) & 0xFF;
    buffer->data[buffer->count + 2] = (x >> 16) & 0xFF;
    buffer->data[buffer->count + 3] = (x >> 24) & 0xFF;
    buffer->count += 4;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
movl $0x4, %esi
callq 0x17843
movq 0x18(%rbx), %rax
movslq 0x10(%rbx), %rcx
movl %r14d, %edx
movb %dl, (%rax,%rcx)
movq 0x18(%rbx), %rax
movslq 0x10(%rbx), %rcx
movb %dh, 0x1(%rax,%rcx)
movl %r14d, %eax
movl %r14d, %esi
shrl $0x10, %eax
movq 0x18(%rbx), %rcx
movslq 0x10(%rbx), %rdx
movb %al, 0x2(%rcx,%rdx)
shrl $0x18, %esi
movq 0x18(%rbx), %rax
movslq 0x10(%rbx), %rcx
movb %sil, 0x3(%rax,%rcx)
addl $0x4, 0x10(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/src/core/buffer.c
// Function: janet_buffer_push_u64
void janet_buffer_push_u64(JanetBuffer *buffer, uint64_t x) {
    janet_buffer_extra(buffer, 8);
    buffer->data[buffer->count] = x & 0xFF;
    buffer->data[buffer->count + 1] = (x >> 8) & 0xFF;
    buffer->data[buffer->count + 2] = (x >> 16) & 0xFF;
    buffer->data[buffer->count + 3] = (x >> 24) & 0xFF;
    buffer->data[buffer->count + 4] = (x >> 32) & 0xFF;
    buffer->data[buffer->count + 5] = (x >> 40) & 0xFF;
    buffer->data[buffer->count + 6] = (x >> 48) & 0xFF;
    buffer->data[buffer->count + 7] = (x >> 56) & 0xFF;
    buffer->count += 8;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl $0x8, %esi
callq 0x17843
movq 0x18(%rbx), %rax
movslq 0x10(%rbx), %rcx
movq %r14, %rdx
movb %dl, (%rax,%rcx)
movq 0x18(%rbx), %rax
movslq 0x10(%rbx), %rcx
movb %dh, 0x1(%rax,%rcx)
movl %edx, %eax
movq %r14, %rsi
shrl $0x10, %eax
movq 0x18(%rbx), %rcx
movslq 0x10(%rbx), %rdx
movb %al, 0x2(%rcx,%rdx)
movl %esi, %eax
shrl $0x18, %eax
movq 0x18(%rbx), %rcx
movslq 0x10(%rbx), %rdx
movb %al, 0x3(%rcx,%rdx)
movq %r14, %rax
shrq $0x20, %rax
movq 0x18(%rbx), %rcx
movslq 0x10(%rbx), %rdx
movb %al, 0x4(%rcx,%rdx)
movq %r14, %rax
shrq $0x28, %rax
movq 0x18(%rbx), %rcx
movslq 0x10(%rbx), %rdx
movb %al, 0x5(%rcx,%rdx)
movq %r14, %rax
shrq $0x30, %rax
movq 0x18(%rbx), %rcx
movslq 0x10(%rbx), %rdx
movb %al, 0x6(%rcx,%rdx)
shrq $0x38, %rsi
movq 0x18(%rbx), %rax
movslq 0x10(%rbx), %rcx
movb %sil, 0x7(%rax,%rcx)
addl $0x8, 0x10(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/src/core/buffer.c
// Function: should_reverse_bytes
static int should_reverse_bytes(const Janet *argv, int32_t argc) {
    JanetKeyword order_kw = janet_getkeyword(argv, argc);
    if (!janet_cstrcmp(order_kw, "le")) {
#if JANET_BIG_ENDIAN
        return 1;
#endif
    } else if (!janet_cstrcmp(order_kw, "be")) {
#if JANET_LITTLE_ENDIAN
        return 1;
#endif
    } else if (!janet_cstrcmp(order_kw, "native")) {
        return 0;
    } else {
        janet_panicf("expected endianness :le, :be or :native, got %v", argv[1]);
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %r14d
movl $0x1, %esi
callq 0x19505
movq %rax, %r15
leaq 0x4f2bf(%rip), %rsi     # 0x672ac
movq %rax, %rdi
callq 0x4920e
testl %eax, %eax
je 0x18037
leaq 0x51137(%rip), %rsi     # 0x69137
movq %r15, %rdi
callq 0x4920e
testl %eax, %eax
je 0x1803a
leaq 0x453b0(%rip), %rsi     # 0x5d3c3
movq %r15, %rdi
callq 0x4920e
movl $0x0, %r14d
testl %eax, %eax
je 0x1803a
movq 0x8(%rbx), %rsi
leaq 0x3bda6(%rip), %rdi     # 0x53dd6
xorl %eax, %eax
callq 0x1917b
xorl %r14d, %r14d
movl %r14d, %eax
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/buffer.c
// Function: buffer_push_impl
static void buffer_push_impl(JanetBuffer *buffer, Janet *argv, int32_t argc_offset, int32_t argc) {
    for (int32_t i = argc_offset; i < argc; i++) {
        if (janet_checktype(argv[i], JANET_NUMBER)) {
            janet_buffer_push_u8(buffer, (uint8_t)(janet_getinteger(argv, i) & 0xFF));
        } else {
            JanetByteView view = janet_getbytes(argv, i);
            if (view.bytes == buffer->data) {
                janet_buffer_ensure(buffer, buffer->count + view.len, 2);
                view.bytes = buffer->data;
            }
            janet_buffer_push_bytes(buffer, view.bytes, view.len);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, -0x30(%rbp)
movl %ecx, -0x34(%rbp)
cmpl %ecx, %edx
jge 0x1846b
movl %edx, %r14d
movq %rdi, %r12
movslq %edx, %rax
movq -0x30(%rbp), %rcx
leaq (%rcx,%rax,8), %rbx
movsd (%rbx), %xmm0
ucomisd %xmm0, %xmm0
jp 0x18406
movq -0x30(%rbp), %rdi
movl %r14d, %esi
callq 0x19b1d
movl %eax, %r15d
movl $0x1, %r13d
movq %r12, %rdi
movl $0x1, %esi
callq 0x17843
movq 0x18(%r12), %rax
movslq 0x10(%r12), %rcx
movb %r15b, (%rax,%rcx)
addl %r13d, 0x10(%r12)
incl %r14d
addq $0x8, %rbx
cmpl %r14d, -0x34(%rbp)
jne 0x183b8
jmp 0x1846b
movzwl 0x5(%rbx), %eax
testl $0x780, %eax            # imm = 0x780
je 0x183c2
movq -0x30(%rbp), %rdi
movl %r14d, %esi
callq 0x199cf
movq %rax, %r15
movl %edx, %r13d
cmpq 0x18(%r12), %rax
jne 0x18444
movl 0x10(%r12), %esi
addl %r13d, %esi
movq %r12, %rdi
movl $0x2, %edx
callq 0x1777e
movq 0x18(%r12), %r15
testl %r13d, %r13d
je 0x183f7
movq %r12, %rdi
movl %r13d, %esi
callq 0x17843
movslq 0x10(%r12), %rdi
addq 0x18(%r12), %rdi
movslq %r13d, %rdx
movq %r15, %rsi
callq 0x12680
jmp 0x183f2
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/buffer.c
// Function: bitloc
static void bitloc(int32_t argc, Janet *argv, JanetBuffer **b, int32_t *index, int *bit) {
    janet_fixarity(argc, 2);
    JanetBuffer *buffer = janet_getbuffer(argv, 0);
    double x = janet_getnumber(argv, 1);
    int64_t bitindex = (int64_t) x;
    int64_t byteindex = bitindex >> 3;
    int which_bit = bitindex & 7;
    if (bitindex != x || bitindex < 0 || byteindex >= buffer->count)
        janet_panicf("invalid bit index %v", argv[1]);
    *b = buffer;
    *index = (int32_t) byteindex;
    *bit = which_bit;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movl $0x2, %esi
callq 0x192b3
movq %r12, %rdi
xorl %esi, %esi
callq 0x19553
movq %rax, %r13
movq %r12, %rdi
movl $0x1, %esi
callq 0x1940c
cvttsd2si %xmm0, %rax
testq %rax, %rax
js 0x186a9
cvtsi2sd %rax, %xmm1
ucomisd %xmm1, %xmm0
jne 0x186a9
jp 0x186a9
movq %rax, %rcx
sarq $0x3, %rcx
movslq 0x10(%r13), %rdx
cmpq %rdx, %rcx
jge 0x186a9
andl $0x7, %eax
movq %r13, (%r15)
movl %ecx, (%r14)
movl %eax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%r12), %rsi
leaq 0x3b751(%rip), %rdi     # 0x53e06
xorl %eax, %eax
callq 0x1917b
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/src/core/bytecode.c
// Function: janet_thunk
JanetFunction *janet_thunk(JanetFuncDef *def) {
    JanetFunction *func = janet_gcalloc(JANET_MEMORY_FUNCTION, sizeof(JanetFunction));
    func->def = def;
    janet_assert(def->environments_length == 0, "tried to create thunk that needs upvalues");
    return func;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x18, %esi
movl $0x9, %edi
callq 0x2bb18
movq %rbx, 0x10(%rax)
cmpl $0x0, 0x74(%rbx)
jne 0x1907c
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x12fa8
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/src/core/capi.c
// Function: janet_signalv
void janet_signalv(JanetSignal sig, Janet message) {
    if (janet_vm.return_reg != NULL) {
        /* Should match logic in janet_call for coercing everything not ok to an error (no awaits, yields, etc.) */
        if (janet_vm.coerce_error && sig != JANET_SIGNAL_OK) {
#ifdef JANET_EV
            if (NULL != janet_vm.root_fiber && sig == JANET_SIGNAL_EVENT) {
                janet_vm.root_fiber->sched_id++;
            }
#endif
            if (sig != JANET_SIGNAL_ERROR) {
                message = janet_wrap_string(janet_formatc("%v coerced from %s to error", message, janet_signal_names[sig]));
            }
            sig = JANET_SIGNAL_ERROR;
        }
        *janet_vm.return_reg = message;
        if (NULL != janet_vm.fiber) {
            janet_vm.fiber->flags |= JANET_FIBER_DID_LONGJUMP;
        }
#if defined(JANET_BSD) || defined(JANET_APPLE)
        _longjmp(*janet_vm.signal_buf, sig);
#else
        longjmp(*janet_vm.signal_buf, sig);
#endif
    } else {
        const char *str = (const char *)janet_formatc("janet top level signal - %v\n", message);
        janet_top_level_signal(str);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movl %edi, %r12d
movq %fs:0x0, %rax
leaq -0x348(%rax), %rax
cmpq $0x0, 0x38(%rax)
jne 0x190c5
leaq 0x3c009(%rip), %rdi     # 0x550bc
movq %r14, %rsi
xorl %eax, %eax
callq 0x3fd86
movq %rax, %rdi
callq 0x19150
movq %rax, %rbx
testl %r12d, %r12d
je 0x1912d
cmpl $0x0, 0x40(%rbx)
je 0x1912d
movq 0x28(%rbx), %rax
testq %rax, %rax
sete %cl
cmpl $0xd, %r12d
setne %dl
orb %cl, %dl
jne 0x190eb
incl 0x48(%rax)
movl $0x1, %r15d
cmpl $0x1, %r12d
je 0x19130
movl %r12d, %eax
leaq 0x6c38f(%rip), %rcx     # 0x85490
movq (%rcx,%rax,8), %rdx
leaq 0x3bf94(%rip), %rdi     # 0x550a0
movq %r14, %rsi
xorl %eax, %eax
callq 0x3fd86
movabsq $-0x6000000000000, %rsi # imm = 0xFFFA000000000000
movq %rax, %rdi
callq 0x4f9ad
movq %rax, %r14
jmp 0x19130
movl %r12d, %r15d
movq 0x38(%rbx), %rax
movq %r14, (%rax)
movq 0x20(%rbx), %rax
testq %rax, %rax
je 0x19144
orb $0x8, 0x13(%rax)
movq 0x30(%rbx), %rdi
movl %r15d, %esi
callq 0x128f0
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/src/core/capi.c
// Function: janet_panicf
void janet_panicf(const char *format, ...) {
    va_list args;
    const uint8_t *ret;
    JanetBuffer buffer;
    int32_t len = 0;
    while (format[len]) len++;
    janet_buffer_init(&buffer, len);
    va_start(args, format);
    janet_formatbv(&buffer, format, args);
    va_end(args);
    ret = janet_string(buffer.data, buffer.count);
    janet_buffer_deinit(&buffer);
    janet_panics(ret);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0xf0, %rsp
movq %rdi, %rbx
movq %rsi, -0xd8(%rbp)
movq %rdx, -0xd0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %r8, -0xc0(%rbp)
movq %r9, -0xb8(%rbp)
testb %al, %al
je 0x191dc
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
xorl %esi, %esi
cmpb $0x0, (%rbx,%rsi)
leaq 0x1(%rsi), %rsi
jne 0x191de
decl %esi
leaq -0x100(%rbp), %r14
movq %r14, %rdi
callq 0x17678
movabsq $0x3000000008, %rax     # imm = 0x3000000008
leaq -0x30(%rbp), %rdx
movq %rax, (%rdx)
leaq 0x10(%rbp), %rax
movq %rax, 0x8(%rdx)
leaq -0xe0(%rbp), %rax
movq %rax, 0x10(%rdx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3f635
movq 0x18(%r14), %rdi
movl 0x10(%r14), %esi
callq 0x45094
movq %rax, %rbx
movq %r14, %rdi
callq 0x17741
movq %rbx, %rdi
callq 0x19248
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/src/core/capi.c
// Function: janet_arity
void janet_arity(int32_t arity, int32_t min, int32_t max) {
    if (min >= 0 && arity < min)
        janet_panicf("arity mismatch, expected at least %d, got %d", min, arity);
    if (max >= 0 && arity > max)
        janet_panicf("arity mismatch, expected at most %d, got %d", max, arity);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, %eax
testl %esi, %esi
sets %cl
cmpl %esi, %edi
setge %dil
orb %cl, %dil
je 0x192f4
testl %edx, %edx
sets %cl
cmpl %edx, %eax
setle %sil
orb %cl, %sil
je 0x192fd
popq %rbp
retq
leaq 0x3c3c6(%rip), %rdi     # 0x556c1
jmp 0x19306
leaq 0x3c3f0(%rip), %rdi     # 0x556f4
movl %edx, %esi
movl %eax, %edx
xorl %eax, %eax
callq 0x1917b
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/src/core/capi.c
// Function: janet_getmethod
int janet_getmethod(const uint8_t *method, const JanetMethod *methods, Janet *out) {
    while (methods->name) {
        if (!janet_cstrcmp(method, methods->name)) {
            *out = janet_wrap_cfunction(methods->cfun);
            return 1;
        }
        methods++;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r15
movq (%rsi), %rsi
xorl %r14d, %r14d
testq %rsi, %rsi
je 0x19368
movq %rdx, %rbx
movq %rdi, %r12
addq $0x10, %r15
movq %r12, %rdi
callq 0x4920e
testl %eax, %eax
je 0x1934c
movq (%r15), %rsi
addq $0x10, %r15
testq %rsi, %rsi
jne 0x19332
jmp 0x19368
movq -0x8(%r15), %rdi
movabsq $-0x1800000000000, %rsi # imm = 0xFFFE800000000000
callq 0x4f9f2
movq %rax, (%rbx)
movl $0x1, %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/capi.c
// Function: janet_nextmethod
Janet janet_nextmethod(const JanetMethod *methods, Janet key) {
    if (!janet_checktype(key, JANET_NIL)) {
        while (methods->name) {
            if (janet_keyeq(key, methods->name)) {
                methods++;
                break;
            }
            methods++;
        }
    }
    if (methods->name) {
        return janet_ckeywordv(methods->name);
    } else {
        return janet_wrap_nil();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq %rsi, %rax
shrq $0x2f, %rax
cmpl $0x1fff1, %eax          # imm = 0x1FFF1
je 0x193be
movq (%rbx), %rdx
testq %rdx, %rdx
je 0x193be
movq %rsi, %r14
addq $0x10, %rbx
movq %rbx, %rax
movq %rax, %rbx
movl $0x6, %edi
movq %r14, %rsi
callq 0x19ab1
testl %eax, %eax
jne 0x193be
movq (%rbx), %rdx
leaq 0x10(%rbx), %rax
testq %rdx, %rdx
jne 0x1939e
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x193e1
callq 0x47cd3
movabsq $-0x5000000000000, %rsi # imm = 0xFFFB000000000000
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x4f9ad
movabsq $-0x7800000000000, %rdi # imm = 0xFFF8800000000000
incq %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x4f95a
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/src/core/cfuns.c
// Function: do_debug
static JanetSlot do_debug(JanetFopts opts, JanetSlot *args) {
    (void)args;
    int32_t len = janet_v_count(args);
    JanetSlot t = janetc_gettarget(opts);
    janetc_emit_ssu(opts.compiler, JOP_SIGNAL, t,
                    (len == 1) ? args[0] : janetc_cslot(janet_wrap_nil()),
                    JANET_SIGNAL_DEBUG,
                    1);
    return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rbp), %r15
testq %rsi, %rsi
je 0x1a301
cmpl $0x1, -0x4(%r14)
sete %r12b
jmp 0x1a304
xorl %r12d, %r12d
movq 0x20(%r15), %rax
movq %rax, 0x20(%rsp)
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x1c898
movq (%r15), %r15
testb %r12b, %r12b
je 0x1a341
movq 0x10(%r14), %rax
movq %rax, -0x30(%rbp)
movups (%r14), %xmm0
movaps %xmm0, -0x40(%rbp)
jmp 0x1a35c
movabsq $-0x77fffffffffff, %rdi # imm = 0xFFF8800000000001
callq 0x4f95a
leaq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x1bc4e
movq -0x30(%rbp), %rax
movq %rax, 0x28(%rsp)
movaps -0x40(%rbp), %xmm0
movups %xmm0, 0x18(%rsp)
movq 0x10(%rbx), %rax
movq %rax, 0x10(%rsp)
movups (%rbx), %xmm0
movups %xmm0, (%rsp)
movq %r15, %rdi
movl $0x38, %esi
movl $0x2, %edx
movl $0x1, %ecx
callq 0x223b5
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/src/core/cfuns.c
// Function: do_yield
static JanetSlot do_yield(JanetFopts opts, JanetSlot *args) {
    if (janet_v_count(args) == 0) {
        return genericSSI(opts, JOP_SIGNAL, janetc_cslot(janet_wrap_nil()), 3);
    } else {
        return genericSSI(opts, JOP_SIGNAL, args[0], 3);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
leaq 0x10(%rbp), %r15
testq %rsi, %rsi
je 0x1a671
cmpl $0x0, -0x4(%rsi)
je 0x1a671
movq 0x10(%rsi), %rax
movq %rax, -0x20(%rbp)
movups (%rsi), %xmm0
jmp 0x1a69b
movabsq $-0x77fffffffffff, %rdi # imm = 0xFFF8800000000001
callq 0x4f95a
leaq -0x48(%rbp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x1bc4e
movq 0x10(%r14), %rax
movq %rax, -0x20(%rbp)
movups (%r14), %xmm0
movaps %xmm0, -0x30(%rbp)
movq (%r15), %r14
movq 0x20(%r15), %rax
movq %rax, 0x20(%rsp)
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x1c898
movq -0x20(%rbp), %rax
movq %rax, 0x28(%rsp)
movaps -0x30(%rbp), %xmm0
movups %xmm0, 0x18(%rsp)
movq 0x10(%rbx), %rax
movq %rax, 0x10(%rsp)
movups (%rbx), %xmm0
movups %xmm0, (%rsp)
movq %r14, %rdi
movl $0x38, %esi
movl $0x3, %edx
movl $0x1, %ecx
callq 0x22283
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/src/core/cfuns.c
// Function: do_put
static JanetSlot do_put(JanetFopts opts, JanetSlot *args) {
    if (opts.flags & JANET_FOPTS_DROP) {
        janetc_emit_sss(opts.compiler, JOP_PUT, args[0], args[1], args[2], 0);
        return janetc_cslot(janet_wrap_nil());
    } else {
        JanetSlot t = janetc_gettarget(opts);
        janetc_copy(opts.compiler, t, args[0]);
        janetc_emit_sss(opts.compiler, JOP_PUT, t, args[1], args[2], 0);
        return t;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rbp), %r15
testb $0x4, 0x22(%r15)
jne 0x1a8d3
movq 0x20(%r15), %rax
movq %rax, 0x20(%rsp)
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x1c898
movq (%r15), %rdi
movq 0x10(%r14), %rax
movq %rax, 0x28(%rsp)
movups (%r14), %xmm0
movups %xmm0, 0x18(%rsp)
movq 0x10(%rbx), %rax
movq %rax, 0x10(%rsp)
movups (%rbx), %xmm0
movups %xmm0, (%rsp)
callq 0x21b57
movq (%r15), %rdi
movq 0x40(%r14), %rax
movq %rax, 0x40(%rsp)
movups 0x30(%r14), %xmm0
movups %xmm0, 0x30(%rsp)
movq 0x28(%r14), %rax
movq %rax, 0x28(%rsp)
movups 0x18(%r14), %xmm0
movups %xmm0, 0x18(%rsp)
movq 0x10(%rbx), %rax
movq %rax, 0x10(%rsp)
movups (%rbx), %xmm0
movups %xmm0, (%rsp)
movl $0x3c, %esi
xorl %edx, %edx
callq 0x223bf
jmp 0x1a933
movq (%r15), %rdi
movq 0x40(%r14), %rax
movq %rax, 0x40(%rsp)
movups 0x30(%r14), %xmm0
movups %xmm0, 0x30(%rsp)
movq 0x28(%r14), %rax
movq %rax, 0x28(%rsp)
movups 0x18(%r14), %xmm0
movups %xmm0, 0x18(%rsp)
movq 0x10(%r14), %rax
movq %rax, 0x10(%rsp)
movups (%r14), %xmm0
movups %xmm0, (%rsp)
movl $0x3c, %esi
xorl %edx, %edx
callq 0x223bf
movabsq $-0x77fffffffffff, %rdi # imm = 0xFFF8800000000001
callq 0x4f95a
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1bc4e
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/src/core/cfuns.c
// Function: opfunction
static JanetSlot opfunction(
    JanetFopts opts,
    JanetSlot *args,
    int op,
    Janet defaultArg2) {
    JanetCompiler *c = opts.compiler;
    int32_t len;
    len = janet_v_count(args);
    JanetSlot t;
    if (len == 1) {
        t = janetc_gettarget(opts);
        janetc_emit_sss(c, op, t, args[0], janetc_cslot(defaultArg2), 1);
        return t;
    } else {
        /* len == 2 */
        t = janetc_gettarget(opts);
        janetc_emit_sss(c, op, t, args[0], args[1], 1);
    }
    return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %edx, %r14d
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x10(%rbp), %rax
movq (%rax), %r15
testq %rsi, %rsi
je 0x1b58c
cmpl $0x1, -0x4(%r12)
jne 0x1b58c
movq %rcx, %r13
movq 0x20(%rax), %rcx
movq %rcx, 0x20(%rsp)
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x1c898
leaq -0x40(%rbp), %rdi
movq %r13, %rsi
callq 0x1bc4e
leaq -0x40(%rbp), %rcx
movq 0x10(%rcx), %rax
movq %rax, 0x40(%rsp)
movups (%rcx), %xmm0
jmp 0x1b5bd
movq 0x20(%rax), %rcx
movq %rcx, 0x20(%rsp)
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x1c898
movq 0x28(%r12), %rax
movq %rax, 0x40(%rsp)
movups 0x18(%r12), %xmm0
movups %xmm0, 0x30(%rsp)
movq 0x10(%r12), %rax
movq %rax, 0x28(%rsp)
movups (%r12), %xmm0
movups %xmm0, 0x18(%rsp)
movq 0x10(%rbx), %rax
movq %rax, 0x10(%rsp)
movups (%rbx), %xmm0
movups %xmm0, (%rsp)
movzbl %r14b, %esi
movq %r15, %rdi
movl $0x1, %edx
callq 0x223bf
movq %rbx, %rax
addq $0x68, %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/compile.c
// Function: janetc_fopts_default
JanetFopts janetc_fopts_default(JanetCompiler *c) {
    JanetFopts ret;
    ret.compiler = c;
    ret.flags = 0;
    ret.hint = janetc_cslot(janet_wrap_nil());
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsi, (%rdi)
movl $0x0, 0x20(%rdi)
movabsq $-0x77fffffffffff, %rdi # imm = 0xFFF8800000000001
callq 0x4f95a
movq %rax, %xmm0
movq %rax, %rcx
shrq $0x2f, %rcx
andb $0xf, %cl
movl $0x10000, %edx          # imm = 0x10000
btsl %ecx, %edx
ucomisd %xmm0, %xmm0
movl $0x10001, %ecx          # imm = 0x10001
cmovpl %edx, %ecx
movq %rax, 0x8(%rbx)
movq $-0x1, 0x10(%rbx)
movl %ecx, 0x18(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/src/core/compile.c
// Function: janetc_cslot
JanetSlot janetc_cslot(Janet x) {
    JanetSlot ret;
    ret.flags = (1 << janet_type(x)) | JANET_SLOT_CONSTANT;
    ret.index = -1;
    ret.constant = x;
    ret.envindex = -1;
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rsi, %xmm0
movq %rsi, %rax
shrq $0x2f, %rax
andb $0xf, %al
movl $0x10000, %ecx          # imm = 0x10000
btsl %eax, %ecx
ucomisd %xmm0, %xmm0
movq %rdi, %rax
movl $0x10001, %edx          # imm = 0x10001
cmovpl %ecx, %edx
movl %edx, 0x10(%rdi)
movq $-0x1, 0x8(%rdi)
movq %rsi, (%rdi)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/src/core/compile.c
// Function: janetc_error
void janetc_error(JanetCompiler *c, const uint8_t *m) {
    /* Don't override first error */
    if (c->result.status == JANET_COMPILE_ERROR) {
        return;
    }
    c->result.status = JANET_COMPILE_ERROR;
    c->result.error = m;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $0x1, 0x48(%rdi)
je 0x1bc9c
movl $0x1, 0x48(%rdi)
movq %rsi, 0x30(%rdi)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/src/core/compile.c
// Function: janetc_lintf
void janetc_lintf(JanetCompiler *c, JanetCompileLintLevel level, const char *format, ...) {
    if (NULL != c->lints) {
        /* format message */
        va_list args;
        JanetBuffer buffer;
        int32_t len = 0;
        while (format[len]) len++;
        janet_buffer_init(&buffer, len);
        va_start(args, format);
        janet_formatbv(&buffer, format, args);
        va_end(args);
        const uint8_t *str = janet_string(buffer.data, buffer.count);
        janet_buffer_deinit(&buffer);
        /* construct linting payload */
        Janet *payload = janet_tuple_begin(4);
        payload[0] = janet_ckeywordv(janet_lint_level_names[level]);
        payload[1] = c->current_mapping.line == -1 ? janet_wrap_nil() : janet_wrap_integer(c->current_mapping.line);
        payload[2] = c->current_mapping.column == -1 ? janet_wrap_nil() : janet_wrap_integer(c->current_mapping.column);
        payload[3] = janet_wrap_string(str);
        janet_array_push(c->lints, janet_wrap_tuple(janet_tuple_end(payload)));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xf0, %rsp
movq %r9, -0xe8(%rbp)
testb %al, %al
je 0x1bd17
movapd %xmm0, -0xe0(%rbp)
movaps %xmm1, -0xd0(%rbp)
movaps %xmm2, -0xc0(%rbp)
movaps %xmm3, -0xb0(%rbp)
movaps %xmm4, -0xa0(%rbp)
movaps %xmm5, -0x90(%rbp)
movaps %xmm6, -0x80(%rbp)
movaps %xmm7, -0x70(%rbp)
movq %r8, -0xf0(%rbp)
movq %rcx, -0xf8(%rbp)
cmpq $0x0, 0x60(%rdi)
je 0x1be61
movq %rdx, %r14
movl %esi, %r12d
movq %rdi, %rbx
xorl %esi, %esi
cmpb $0x0, (%r14,%rsi)
leaq 0x1(%rsi), %rsi
jne 0x1bd3b
decl %esi
leaq -0x60(%rbp), %r15
movq %r15, %rdi
callq 0x17678
movabsq $0x3000000018, %rax     # imm = 0x3000000018
leaq -0x40(%rbp), %rdx
movq %rax, (%rdx)
leaq 0x10(%rbp), %rax
movq %rax, 0x8(%rdx)
leaq -0x110(%rbp), %rax
movq %rax, 0x10(%rdx)
movq %r15, %rdi
movq %r14, %rsi
callq 0x3f635
movq 0x18(%r15), %rdi
movl 0x10(%r15), %esi
callq 0x45094
movq %rax, %r14
movq %r15, %rdi
callq 0x17741
movl $0x4, %edi
callq 0x48a50
movq %rax, %r15
movl %r12d, %eax
leaq 0x395ae(%rip), %rcx     # 0x55360
movslq (%rcx,%rax,4), %rdi
addq %rcx, %rdi
callq 0x47cd3
movabsq $-0x5000000000000, %rsi # imm = 0xFFFB000000000000
movq %rax, %rdi
callq 0x4f9ad
movq %rax, (%r15)
movl 0x50(%rbx), %eax
cmpl $-0x1, %eax
je 0x1bde6
cvtsi2sd %eax, %xmm0
callq 0x4fab8
jmp 0x1bdf5
movabsq $-0x77fffffffffff, %rdi # imm = 0xFFF8800000000001
callq 0x4f95a
movq %rax, 0x8(%r15)
movl 0x54(%rbx), %eax
cmpl $-0x1, %eax
je 0x1be0f
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
callq 0x4fab8
jmp 0x1be1e
movabsq $-0x77fffffffffff, %rdi # imm = 0xFFF8800000000001
callq 0x4f95a
movq %rax, 0x10(%r15)
movabsq $-0x6000000000000, %rsi # imm = 0xFFFA000000000000
movq %r14, %rdi
callq 0x4f9ad
movq %rax, 0x18(%r15)
movq 0x60(%rbx), %rbx
movq %r15, %rdi
callq 0x48a81
movabsq $-0x4000000000000, %rsi # imm = 0xFFFC000000000000
movq %rax, %rdi
callq 0x4f9ad
movq %rbx, %rdi
movq %rax, %rsi
callq 0x148b3
addq $0xf0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/src/core/compile.c
// Function: janetc_nameslot
void janetc_nameslot(JanetCompiler *c, const uint8_t *sym, JanetSlot s) {
    SymPair sp;
    int32_t cnt = janet_v_count(c->buffer);
    sp.sym = sym;
    sp.sym2 = sym;
    sp.slot = s;
    sp.keep = 0;
    sp.slot.flags |= JANET_SLOT_NAMED;
    sp.birth_pc = cnt ? cnt - 1 : 0;
    sp.death_pc = UINT32_MAX;
    janet_v_push(c->scope->syms, sp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x10(%rbp), %rsi
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x1bebe
movl -0x4(%rax), %r15d
jmp 0x1bec1
xorl %r15d, %r15d
movl 0x10(%rsi), %r12d
movl 0x14(%rsi), %r13d
movq (%r14), %rax
movq 0x20(%rax), %rdi
testq %rdi, %rdi
je 0x1bedf
movl -0x4(%rdi), %eax
incl %eax
cmpl -0x8(%rdi), %eax
jl 0x1bef9
movl $0x1, %esi
movl $0x38, %edx
callq 0x4c0b4
leaq 0x10(%rbp), %rsi
movq (%r14), %rcx
movq %rax, 0x20(%rcx)
xorl %eax, %eax
subl $0x1, %r15d
cmovbl %eax, %r15d
orl $0x20000, %r12d         # imm = 0x20000
movq (%r14), %rax
movq 0x20(%rax), %rax
movslq -0x4(%rax), %rcx
leal 0x1(%rcx), %edx
movl %edx, -0x4(%rax)
imulq $0x38, %rcx, %rcx
movups (%rsi), %xmm0
movups %xmm0, (%rax,%rcx)
movl %r12d, 0x10(%rax,%rcx)
movl %r13d, 0x14(%rax,%rcx)
movq %rbx, 0x18(%rax,%rcx)
movq %rbx, 0x20(%rax,%rcx)
movl $0x0, 0x28(%rax,%rcx)
movl %r15d, 0x2c(%rax,%rcx)
movl $0xffffffff, 0x30(%rax,%rcx) # imm = 0xFFFFFFFF
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/compile.c
// Function: janetc_farslot
JanetSlot janetc_farslot(JanetCompiler *c) {
    JanetSlot ret;
    ret.flags = JANET_SLOTTYPE_ANY;
    ret.index = janetc_allocfar(c);
    ret.constant = janet_wrap_nil();
    ret.envindex = -1;
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0xffff, 0x10(%rdi)     # imm = 0xFFFF
movq %rsi, %rdi
callq 0x21a40
movl %eax, 0x8(%rbx)
movabsq $-0x77fffffffffff, %rdi # imm = 0xFFF8800000000001
callq 0x4f95a
movq %rax, (%rbx)
movl $0xffffffff, 0xc(%rbx)  # imm = 0xFFFFFFFF
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq