LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x466c8
testl %eax, %eax
je 0x15d76
pushq $-0x1
popq %r14
jmp 0x15e3f
leaq 0x158(%rbx), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x43c35
movq %rax, %xmm0
ucomisd %xmm0, %xmm0
setp %cl
movabsq $0x7800000000000, %rdx  # imm = 0x7800000000000
testq %rdx, %rax
setne %al
testb %al, %cl
jne 0x15db2
cvttsd2si %xmm0, %r14d
jmp 0x15e3f
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x15dcc
movq %r15, %rsi
callq 0x15d42
cmpl $-0x1, %eax
jge 0x15dd0
movl %eax, %r14d
jmp 0x15e3f
pushq $-0x2
jmp 0x15d6f
movl %eax, -0x2c(%rbp)
movl 0x74(%r12), %r14d
movslq %r14d, %rax
movq %rax, -0x38(%rbp)
cvtsi2sd %eax, %xmm0
callq 0x4b471
movq %r13, %rdi
movq %r15, %rsi
movq -0x38(%rbp), %r15
movq %rax, %rdx
callq 0x43e19
cmpl 0xe4(%rbx), %r15d
jge 0x15e0a
movq 0x10(%r12), %rax
jmp 0x15e30
movq 0x10(%r12), %rdi
leaq (,%r15,8), %rsi
callq 0x12840
movq %rax, 0x10(%r12)
testq %rax, %rax
je 0x15e51
leal (%r14,%r14), %ecx
movl %ecx, 0xe4(%rbx)
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
movq 0x6a198(%rip), %rax     # 0x7fff0
movq (%rax), %rdi
leaq 0x371a2(%rip), %rsi     # 0x4d004
leaq 0x38691(%rip), %rdx     # 0x4e4fa
movl $0xeb, %ecx
xorl %eax, %eax
callq 0x125e0
pushq $0x1
popq %rdi
callq 0x12a60
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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 0x15ea3
andq $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_O2/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
pushq $0x4
popq %r14
cmovgel %esi, %r14d
movq %r14, %rdi
callq 0x2881c
movq %r14, %rdi
callq 0x12760
testq %rax, %rax
je 0x15ee1
andl $0x0, 0x10(%rbx)
movl %r14d, 0x14(%rbx)
movq %rax, 0x18(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq 0x6a108(%rip), %rax     # 0x7fff0
movq (%rax), %rdi
leaq 0x37112(%rip), %rsi     # 0x4d004
leaq 0x38c62(%rip), %rdx     # 0x4eb5b
pushq $0x2d
popq %rcx
xorl %eax, %eax
callq 0x125e0
pushq $0x1
popq %rdi
callq 0x12a60
// File: /workspace/github_c_makefile_star2_O2/janet-lang[P]janet/src/core/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 0x15f4a
movl %edx, %ebx
movl %esi, %r15d
cmpl %edx, %esi
jl 0x15f56
movq %rdi, %r14
pushq $0x8
popq %rdi
pushq $0x20
popq %rsi
callq 0x291a0
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 0x38bef(%rip), %rdi     # 0x4eb40
callq 0x177b1
leaq 0x38bed(%rip), %rdi     # 0x4eb4a
callq 0x177b1
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
cmpl %esi, 0x14(%rdi)
jge 0x15ffd
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %rbx
movq 0x18(%rdi), %r12
callq 0x16030
movslq %r15d, %rax
movslq %r14d, %r15
imulq %rax, %r15
movl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
cmpq %rax, %r15
cmovgeq %rax, %r15
movslq 0x14(%rbx), %rax
movslq %r15d, %r14
movq %r14, %rdi
subq %rax, %rdi
callq 0x2881c
movq %r12, %rdi
movq %r14, %rsi
callq 0x12840
testq %rax, %rax
je 0x16006
movq %rax, 0x18(%rbx)
movl %r15d, 0x14(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x69fe3(%rip), %rax     # 0x7fff0
movq (%rax), %rdi
leaq 0x36fed(%rip), %rsi     # 0x4d004
leaq 0x38b3d(%rip), %rdx     # 0x4eb5b
pushq $0x61
popq %rcx
xorl %eax, %eax
callq 0x125e0
pushq $0x1
popq %rdi
callq 0x12a60
// File: /workspace/github_c_makefile_star2_O2/janet-lang[P]janet/src/core/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 0x16094
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 0x16086
pushq $0x1
popq %rdx
movq %r14, %rdi
movl %ebx, %esi
callq 0x15f9b
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_O2/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, %rax
movslq 0x10(%rdi), %r14
addq %r14, %rax
movl $0x80000000, %ecx       # imm = 0x80000000
cmpq %rcx, %rax
jge 0x16114
movq %rdi, %rbx
addl %esi, %r14d
cmpl 0x14(%rdi), %r14d
jle 0x1610b
movq %rbx, %rdi
callq 0x16030
leal (%r14,%r14), %eax
cmpl $0x40000000, %r14d      # imm = 0x40000000
movl $0x7fffffff, %r12d      # imm = 0x7FFFFFFF
cmovll %eax, %r12d
movq 0x18(%rbx), %rdi
movslq %r12d, %r15
movq %r15, %rsi
callq 0x12840
movq %rax, %r14
movslq 0x14(%rbx), %rax
subq %rax, %r15
movq %r15, %rdi
callq 0x2881c
testq %r14, %r14
je 0x16120
movq %r14, 0x18(%rbx)
movl %r12d, 0x14(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4e523(%rip), %rdi     # 0x6463e
callq 0x177b1
movq 0x69ec9(%rip), %rax     # 0x7fff0
movq (%rax), %rdi
leaq 0x36ed3(%rip), %rsi     # 0x4d004
leaq 0x38a23(%rip), %rdx     # 0x4eb5b
movl $0x81, %ecx
xorl %eax, %eax
callq 0x125e0
pushq $0x1
popq %rdi
callq 0x12a60
// File: /workspace/github_c_makefile_star2_O2/janet-lang[P]janet/src/core/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 0x161b0
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 0x16095
movslq 0x10(%r14), %rdi
addq 0x18(%r14), %rdi
movslq %ebx, %rdx
movq %r15, %rsi
callq 0x12670
addl %ebx, 0x10(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/janet-lang[P]janet/src/core/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
pushq $0x2
popq %rsi
callq 0x16095
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_O2/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
pushq $0x4
popq %rsi
callq 0x16095
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_O2/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
pushq $0x8
popq %rsi
callq 0x16095
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_O2/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
pushq $0x1
popq %r14
movl %r14d, %esi
callq 0x17a2c
movq %rax, %r15
leaq 0x4bb6e(%rip), %rsi     # 0x622ac
movq %rax, %rdi
callq 0x44ca9
testl %eax, %eax
je 0x16788
leaq 0x4d9e6(%rip), %rsi     # 0x64137
movq %r15, %rdi
callq 0x44ca9
testl %eax, %eax
je 0x1678b
leaq 0x41c5f(%rip), %rsi     # 0x583c3
movq %r15, %rdi
callq 0x44ca9
movl $0x0, %r14d
testl %eax, %eax
je 0x1678b
movq 0x8(%rbx), %rsi
leaq 0x38655(%rip), %rdi     # 0x4edd6
xorl %eax, %eax
callq 0x176c9
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/janet-lang[P]janet/src/core/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
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movslq %edx, %r15
movslq %ecx, %r13
pushq $0x2
popq %r12
cmpq %r13, %r15
jge 0x16a4c
movsd (%rbx,%r15,8), %xmm0
ucomisd %xmm0, %xmm0
jp 0x169fe
movq %rbx, %rdi
movl %r15d, %esi
callq 0x17ff0
movzbl %al, %esi
movq %r14, %rdi
callq 0x161be
incq %r15
jmp 0x169d2
movq %xmm0, %rax
movabsq $0x7800000000000, %rcx  # imm = 0x7800000000000
testq %rcx, %rax
je 0x169e3
movq %rbx, %rdi
movl %r15d, %esi
callq 0x17ea2
movl %edx, -0x2c(%rbp)
cmpq 0x18(%r14), %rax
jne 0x16a3c
movl 0x10(%r14), %esi
addl -0x2c(%rbp), %esi
movq %r14, %rdi
movl %r12d, %edx
callq 0x15f9b
movq 0x18(%r14), %rax
movq %r14, %rdi
movq %rax, %rsi
movl -0x2c(%rbp), %edx
callq 0x16172
jmp 0x169f9
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/janet-lang[P]janet/src/core/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
pushq $0x2
popq %rsi
callq 0x17801
movq %r12, %rdi
xorl %esi, %esi
callq 0x17a76
movq %rax, %r13
pushq $0x1
popq %rsi
movq %r12, %rdi
callq 0x17937
cvttsd2si %xmm0, %rax
testq %rax, %rax
js 0x16c6e
cvtsi2sd %rax, %xmm1
ucomisd %xmm1, %xmm0
jne 0x16c6e
jp 0x16c6e
movq %rax, %rcx
sarq $0x3, %rcx
movslq 0x10(%r13), %rdx
cmpq %rdx, %rcx
jge 0x16c6e
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 0x3818c(%rip), %rdi     # 0x4ee06
xorl %eax, %eax
callq 0x176c9
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x9
popq %rdi
pushq $0x18
popq %rsi
callq 0x291a0
movq %rbx, 0x10(%rax)
cmpl $0x0, 0x74(%rbx)
jne 0x1759f
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0x68a4a(%rip), %rax     # 0x7fff0
movq (%rax), %rdi
leaq 0x38a60(%rip), %rsi     # 0x50010
leaq 0x38a89(%rip), %rcx     # 0x50040
leaq 0x38aac(%rip), %r8      # 0x5006a
movl $0x214, %edx            # imm = 0x214
xorl %eax, %eax
callq 0x125e0
callq 0x12100
nop
// File: /workspace/github_c_makefile_star2_O2/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
movq %rax, %rbx
movq 0x38(%rax), %rax
testq %rax, %rax
jne 0x17616
leaq 0x38ab8(%rip), %rdi     # 0x500bc
movq %r14, %rsi
xorl %eax, %eax
callq 0x3c0ed
movq %rax, %rdi
callq 0x176a0
testl %r12d, %r12d
je 0x17641
cmpl $0x0, 0x40(%rbx)
je 0x17641
movq 0x28(%rbx), %rcx
testq %rcx, %rcx
sete %dl
cmpl $0xd, %r12d
setne %sil
orb %dl, %sil
pushq $0x1
popq %r15
jne 0x17646
incl 0x48(%rcx)
jmp 0x1764c
movl %r12d, %r15d
jmp 0x17684
cmpl $0x1, %r12d
je 0x17684
movl %r12d, %eax
leaq 0x67e3a(%rip), %rcx     # 0x7f490
movq (%rcx,%rax,8), %rdx
leaq 0x38a3f(%rip), %rdi     # 0x500a0
movq %r14, %rsi
xorl %eax, %eax
callq 0x3c0ed
movabsq $-0x6000000000000, %rsi # imm = 0xFFFA000000000000
movq %rax, %rdi
callq 0x4b366
movq %rax, %r14
movq 0x38(%rbx), %rax
movq %r14, (%rax)
movq 0x20(%rbx), %rax
testq %rax, %rax
je 0x17694
orb $0x8, 0x13(%rax)
movq 0x30(%rbx), %rdi
movl %r15d, %esi
callq 0x128e0
// File: /workspace/github_c_makefile_star2_O2/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 0x1772a
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 0x1772c
decl %esi
leaq -0x100(%rbp), %r14
movq %r14, %rdi
callq 0x15e80
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 0x3b9d0
movq 0x18(%r14), %rdi
movl 0x10(%r14), %esi
callq 0x41116
movq %rax, %rbx
movq %r14, %rdi
callq 0x15f62
movq %rbx, %rdi
callq 0x17796
// File: /workspace/github_c_makefile_star2_O2/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 0x17842
testl %edx, %edx
sets %cl
cmpl %edx, %eax
setle %sil
orb %cl, %sil
je 0x1784b
popq %rbp
retq
leaq 0x38e78(%rip), %rdi     # 0x506c1
jmp 0x17854
leaq 0x38ea2(%rip), %rdi     # 0x506f4
movl %edx, %esi
movl %eax, %edx
xorl %eax, %eax
callq 0x176c9
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
addq $0x8, %r14
movq -0x8(%r14), %rsi
testq %rsi, %rsi
je 0x1788f
movq %r15, %rdi
callq 0x44ca9
testl %eax, %eax
je 0x17893
addq $0x10, %r14
jmp 0x17874
xorl %eax, %eax
jmp 0x178ab
movq (%r14), %rdi
movabsq $-0x1800000000000, %rsi # imm = 0xFFFE800000000000
callq 0x4b3ab
movq %rax, (%rbx)
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/janet-lang[P]janet/src/core/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 0x178e9
movq %rsi, %r14
movq (%rbx), %rsi
testq %rsi, %rsi
je 0x1790c
movq %r14, %rdi
callq 0x17922
addq $0x10, %rbx
testl %eax, %eax
je 0x178d1
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x1790c
callq 0x439c6
movabsq $-0x5000000000000, %rsi # imm = 0xFFFB000000000000
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x4b366
movabsq $-0x7800000000000, %rdi # imm = 0xFFF8800000000000
incq %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x4b313
// File: /workspace/github_c_makefile_star2_O2/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, %r15
movq %rdi, %rbx
leaq 0x10(%rbp), %r14
testq %rsi, %rsi
je 0x18771
cmpl $0x1, -0x4(%r15)
sete %r12b
jmp 0x18774
xorl %r12d, %r12d
movq 0x20(%r14), %rax
movq %rax, 0x20(%rsp)
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x1aa9e
movq (%r14), %r14
testb %r12b, %r12b
je 0x187b1
movq 0x10(%r15), %rax
movq %rax, -0x30(%rbp)
movups (%r15), %xmm0
movaps %xmm0, -0x40(%rbp)
jmp 0x187cc
movabsq $-0x77fffffffffff, %rdi # imm = 0xFFF8800000000001
callq 0x4b313
leaq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x19f5c
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)
pushq $0x38
popq %rsi
pushq $0x2
popq %rdx
pushq $0x1
popq %rcx
movq %r14, %rdi
callq 0x20105
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x18a83
cmpl $0x0, -0x4(%rsi)
je 0x18a83
movq 0x10(%rsi), %rax
movq %rax, -0x20(%rbp)
movups (%rsi), %xmm0
jmp 0x18aad
movabsq $-0x77fffffffffff, %rdi # imm = 0xFFF8800000000001
callq 0x4b313
leaq -0x48(%rbp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x19f5c
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 0x1aa9e
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)
pushq $0x38
popq %rsi
pushq $0x3
popq %rdx
pushq $0x1
popq %rcx
movq %r14, %rdi
callq 0x1ffee
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x18cd9
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 0x1aa9e
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 0x1f88f
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)
pushq $0x3c
popq %rsi
xorl %edx, %edx
callq 0x2010f
jmp 0x18d37
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)
pushq $0x3c
popq %rsi
xorl %edx, %edx
callq 0x2010f
movabsq $-0x77fffffffffff, %rdi # imm = 0xFFF8800000000001
callq 0x4b313
movq %rbx, %rdi
movq %rax, %rsi
callq 0x19f5c
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1993a
cmpl $0x1, -0x4(%r12)
jne 0x1993a
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 0x1aa9e
leaq -0x40(%rbp), %rdi
movq %r13, %rsi
callq 0x19f5c
leaq -0x40(%rbp), %rcx
movq 0x10(%rcx), %rax
movq %rax, 0x40(%rsp)
movups (%rcx), %xmm0
jmp 0x1996b
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 0x1aa9e
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
pushq $0x1
popq %rdx
movq %r15, %rdi
callq 0x2010f
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_O2/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)
andl $0x0, 0x20(%rdi)
movabsq $-0x77fffffffffff, %rdi # imm = 0xFFF8800000000001
callq 0x4b313
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)
orq $-0x1, 0x10(%rbx)
movl %ecx, 0x18(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x19fa7
movl $0x1, 0x48(%rdi)
movq %rsi, 0x30(%rdi)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1a022
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 0x1a167
movq %rdx, %r14
movl %esi, %r12d
movq %rdi, %rbx
xorl %esi, %esi
cmpb $0x0, (%r14,%rsi)
leaq 0x1(%rsi), %rsi
jne 0x1a046
decl %esi
leaq -0x60(%rbp), %r15
movq %r15, %rdi
callq 0x15e80
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 0x3b9d0
movq 0x18(%r15), %rdi
movl 0x10(%r15), %esi
callq 0x41116
movq %rax, %r14
movq %r15, %rdi
callq 0x15f62
pushq $0x4
popq %rdi
callq 0x44648
movq %rax, %r15
movl %r12d, %eax
leaq 0x362a5(%rip), %rcx     # 0x50360
movslq (%rcx,%rax,4), %rdi
addq %rcx, %rdi
callq 0x439c6
movabsq $-0x5000000000000, %rsi # imm = 0xFFFB000000000000
movq %rax, %rdi
callq 0x4b366
movq %rax, (%r15)
movl 0x50(%rbx), %eax
cmpl $-0x1, %eax
je 0x1a0ef
cvtsi2sd %eax, %xmm0
callq 0x4b471
jmp 0x1a0fe
movabsq $-0x77fffffffffff, %rdi # imm = 0xFFF8800000000001
callq 0x4b313
movq %rax, 0x8(%r15)
movl 0x54(%rbx), %eax
cmpl $-0x1, %eax
je 0x1a115
cvtsi2sd %eax, %xmm0
callq 0x4b471
jmp 0x1a124
movabsq $-0x77fffffffffff, %rdi # imm = 0xFFF8800000000001
callq 0x4b313
movq %rax, 0x10(%r15)
movabsq $-0x6000000000000, %rsi # imm = 0xFFFA000000000000
movq %r14, %rdi
callq 0x4b366
movq %rax, 0x18(%r15)
movq 0x60(%rbx), %rbx
movq %r15, %rdi
callq 0x44674
movabsq $-0x4000000000000, %rsi # imm = 0xFFFC000000000000
movq %rax, %rdi
callq 0x4b366
movq %rbx, %rdi
movq %rax, %rsi
callq 0x131d2
addq $0xf0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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), %rdi
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x1a1c4
movl -0x4(%rax), %r15d
jmp 0x1a1c7
xorl %r15d, %r15d
movl 0x10(%rdi), %r12d
movl 0x14(%rdi), %r13d
movq (%r14), %rax
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x1a1e6
movl -0x4(%rax), %ecx
leal 0x1(%rcx), %edx
cmpl -0x8(%rax), %edx
jl 0x1a205
pushq $0x1
popq %rsi
pushq $0x38
popq %rdx
movq %rax, %rdi
callq 0x4799c
leaq 0x10(%rbp), %rdi
movq (%r14), %rcx
movq %rax, 0x20(%rcx)
movl -0x4(%rax), %ecx
leal 0x1(%rcx), %edx
xorl %esi, %esi
subl $0x1, %r15d
cmovbl %esi, %r15d
orl $0x20000, %r12d         # imm = 0x20000
movl %edx, -0x4(%rax)
movslq %ecx, %rcx
imulq $0x38, %rcx, %rcx
movups (%rdi), %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)
andl $0x0, 0x28(%rax,%rcx)
movl %r15d, 0x2c(%rax,%rcx)
orl $-0x1, 0x30(%rax,%rcx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/janet-lang[P]janet/src/core/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 0x1f77c
movl %eax, 0x8(%rbx)
movabsq $-0x77fffffffffff, %rdi # imm = 0xFFF8800000000001
callq 0x4b313
movq %rax, (%rbx)
orl $-0x1, 0xc(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/janet-lang[P]janet/src/core/compile.c
// Function: janetc_scope
void janetc_scope(JanetScope *s, JanetCompiler *c, int flags, const char *name) {
    JanetScope scope;
    scope.name = name;
    scope.child = NULL;
    scope.consts = NULL;
    scope.syms = NULL;
    scope.envs = NULL;
    scope.defs = NULL;
    scope.bytecode_start = janet_v_count(c->buffer);
    scope.flags = flags;
    scope.parent = c->scope;
    janetc_regalloc_init(&scope.ua);
    /* Inherit slots */
    if ((!(flags & JANET_SCOPE_FUNCTION)) && c->scope) {
        janetc_regalloc_clone(&scope.ra, &(c->scope->ra));
    } else {
        janetc_regalloc_init(&scope.ra);
    }
    /* Link parent and child and update pointer */
    if (c->scope)
        c->scope->child = s;
    c->scope = s;
    *s = scope;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x78, %rsp
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %rbx
movq %rcx, -0x88(%rbp)
andq $0x0, -0x28(%rbp)
xorps %xmm0, %xmm0
movups %xmm0, -0x78(%rbp)
movups %xmm0, -0x68(%rbp)
movq 0x8(%rsi), %rax
testq %rax, %rax
je 0x1a2cf
movl -0x4(%rax), %eax
jmp 0x1a2d1
xorl %eax, %eax
leaq -0x40(%rbp), %rdi
movl %eax, 0x20(%rdi)
movl %r15d, 0x24(%rdi)
movq (%r14), %rax
movq %rax, -0x40(%rdi)
callq 0x3d2bc
testb $0x1, %r15b
jne 0x1a305
movq (%r14), %rsi
testq %rsi, %rsi
je 0x1a305
leaq -0x58(%rbp), %rdi
addq $0x30, %rsi
callq 0x3d2da
jmp 0x1a30e
leaq -0x58(%rbp), %rdi
callq 0x3d2bc
movq (%r14), %rax
testq %rax, %rax
je 0x1a31a
movq %rbx, 0x10(%rax)
movq %rbx, (%r14)
pushq $0xe
popq %rcx
leaq -0x88(%rbp), %rsi
movq %rbx, %rdi
rep  movsq (%rsi), %es:(%rdi)
addq $0x78, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/janet-lang[P]janet/src/core/compile.c
// Function: janetc_popscope_keepslot
void janetc_popscope_keepslot(JanetCompiler *c, JanetSlot retslot) {
    JanetScope *scope;
    janetc_popscope(c);
    scope = c->scope;
    if (scope && retslot.envindex < 0 && retslot.index >= 0) {
        janetc_regalloc_touch(&scope->ra, retslot.index);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x1a338
movq (%rbx), %rdi
testq %rdi, %rdi
setne %al
movl 0x18(%rbp), %esi
cmpl $0x0, 0x1c(%rbp)
sets %cl
andb %al, %cl
testl %esi, %esi
setns %al
andb %cl, %al
cmpb $0x1, %al
jne 0x1a589
addq $0x30, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3d36c
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/janet-lang[P]janet/src/core/compile.c
// Function: janetc_return
JanetSlot janetc_return(JanetCompiler *c, JanetSlot s) {
    if (!(s.flags & JANET_SLOT_RETURNED)) {
        if (s.flags & JANET_SLOT_CONSTANT && janet_checktype(s.constant, JANET_NIL))
            janetc_emit(c, JOP_RETURN_NIL);
        else
            janetc_emit_s(c, JOP_RETURN, s, 0);
        s.flags |= JANET_SLOT_RETURNED;
    }
    return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x10(%rbp), %r14
movl 0x10(%r14), %r15d
btl $0x14, %r15d
jb 0x1aa81
btl $0x10, %r15d
jae 0x1aa52
movq (%r14), %rax
shrq $0x2f, %rax
cmpl $0x1fff1, %eax          # imm = 0x1FFF1
jne 0x1aa52
pushq $0x4
popq %rax
movq %rsi, %rdi
movl %eax, %esi
callq 0x1f7c4
jmp 0x1aa76
movq 0x10(%r14), %rax
movq %rax, 0x10(%rsp)
movups (%r14), %xmm0
movups %xmm0, (%rsp)
pushq $0x3
popq %rax
movq %rsi, %rdi
movl %eax, %esi
xorl %edx, %edx
callq 0x1fbb3
movl 0x10(%r14), %r15d
orl $0x100000, %r15d        # imm = 0x100000
movl %r15d, 0x10(%r14)
movq 0x10(%r14), %rax
movq %rax, 0x10(%rbx)
movups (%r14), %xmm0
movups %xmm0, (%rbx)
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/janet-lang[P]janet/src/core/compile.c
// Function: janetc_gettarget
JanetSlot janetc_gettarget(JanetFopts opts) {
    JanetSlot slot;
    if ((opts.flags & JANET_FOPTS_HINT) &&
            (opts.hint.envindex < 0) &&
            (opts.hint.index >= 0 && opts.hint.index <= 0xFF)) {
        slot = opts.hint;
    } else {
        slot.envindex = -1;
        slot.constant = janet_wrap_nil();
        slot.flags = 0;
        slot.index = janetc_allocfar(opts.compiler);
    }
    return slot;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rbp), %r14
testb $0x2, 0x22(%r14)
je 0x1aad4
cmpl $0x0, 0x24(%rbp)
jns 0x1aad4
cmpl $0xff, 0x20(%rbp)
ja 0x1aad4
movq 0x18(%r14), %rax
movq %rax, 0x10(%rbx)
movups 0x8(%r14), %xmm0
movups %xmm0, (%rbx)
jmp 0x1aaf9
orl $-0x1, 0xc(%rbx)
movabsq $-0x77fffffffffff, %rdi # imm = 0xFFF8800000000001
callq 0x4b313
movq %rax, (%rbx)
andl $0x0, 0x10(%rbx)
movq (%r14), %rdi
callq 0x1f77c
movl %eax, 0x8(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/janet-lang[P]janet/src/core/compile.c
// Function: janetc_toslots
JanetSlot *janetc_toslots(JanetCompiler *c, const Janet *vals, int32_t len) {
    int32_t i;
    JanetSlot *ret = NULL;
    JanetFopts subopts = janetc_fopts_default(c);
    subopts.flags |= JANET_FOPTS_ACCEPT_SPLICE;
    for (i = 0; i < len; i++) {
        janet_v_push(ret, janetc_value(subopts, vals[i]));
    }
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %rsi
leaq -0x68(%rbp), %r15
movq %r15, %rdi
callq 0x19f04
orb $0x8, 0x22(%r15)
xorl %r12d, %r12d
testl %ebx, %ebx
cmovlel %r12d, %ebx
xorl %r15d, %r15d
cmpq %r12, %rbx
je 0x1abad
testq %r15, %r15
je 0x1ab4e
movl -0x4(%r15), %eax
leal 0x1(%rax), %ecx
cmpl -0x8(%r15), %ecx
jl 0x1ab65
movq %r15, %rdi
pushq $0x1
popq %rsi
pushq $0x18
popq %rdx
callq 0x4799c
movq %rax, %r15
movl -0x4(%rax), %eax
leal 0x1(%rax), %ecx
movl %ecx, -0x4(%r15)
cltq
imulq $0x18, %rax, %r13
movq (%r14,%r12,8), %rsi
movq -0x48(%rbp), %rax
movq %rax, 0x20(%rsp)
movups -0x68(%rbp), %xmm0
movups -0x58(%rbp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
leaq -0x40(%rbp), %rdi
callq 0x1abbf
movq -0x30(%rbp), %rax
movq %rax, 0x10(%r15,%r13)
movups -0x40(%rbp), %xmm0
movups %xmm0, (%r15,%r13)
incq %r12
jmp 0x1ab37
movq %r15, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/janet-lang[P]janet/src/core/compile.c
// Function: janetc_toslotskv
JanetSlot *janetc_toslotskv(JanetCompiler *c, Janet ds) {
    JanetSlot *ret = NULL;
    JanetFopts subopts = janetc_fopts_default(c);
    subopts.flags |= JANET_FOPTS_ACCEPT_SPLICE;
    const JanetKV *kvs = NULL;
    int32_t cap = 0, len = 0;
    janet_dictionary_view(ds, &kvs, &len, &cap);
    for (int32_t i = 0; i < cap; i++) {
        if (janet_checktype(kvs[i].key, JANET_NIL)) continue;
        janet_v_push(ret, janetc_value(subopts, kvs[i].key));
        janet_v_push(ret, janetc_value(subopts, kvs[i].value));
    }
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %rbx
movq %rdi, %rsi
leaq -0x78(%rbp), %r14
movq %r14, %rdi
callq 0x19f04
orb $0x8, 0x22(%r14)
leaq -0x30(%rbp), %rsi
andq $0x0, (%rsi)
leaq -0x34(%rbp), %rcx
andl $0x0, (%rcx)
leaq -0x38(%rbp), %rdx
andl $0x0, (%rdx)
movq %rbx, %rdi
callq 0x45d86
xorl %r13d, %r13d
leaq -0x50(%rbp), %r15
xorl %ebx, %ebx
xorl %r12d, %r12d
movslq -0x34(%rbp), %rax
cmpq %rax, %rbx
jge 0x1b896
movq -0x30(%rbp), %rax
movq (%rax,%r13), %rcx
shrq $0x2f, %rcx
cmpl $0x1fff1, %ecx          # imm = 0x1FFF1
je 0x1b88a
testq %r12, %r12
je 0x1b7bd
movl -0x4(%r12), %ecx
leal 0x1(%rcx), %edx
cmpl -0x8(%r12), %edx
jl 0x1b7d8
movq %r12, %rdi
pushq $0x1
popq %rsi
pushq $0x18
popq %rdx
callq 0x4799c
movq %rax, %r12
movl -0x4(%rax), %ecx
movq -0x30(%rbp), %rax
leal 0x1(%rcx), %edx
movl %edx, -0x4(%r12)
movslq %ecx, %rcx
imulq $0x18, %rcx, %r14
movq (%rax,%r13), %rsi
movq -0x58(%rbp), %rax
movq %rax, 0x20(%rsp)
movups -0x78(%rbp), %xmm0
movups -0x68(%rbp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %r15, %rdi
callq 0x1abbf
movq -0x40(%rbp), %rax
movq %rax, 0x10(%r12,%r14)
movups -0x50(%rbp), %xmm0
movups %xmm0, (%r12,%r14)
movl -0x4(%r12), %eax
leal 0x1(%rax), %ecx
cmpl -0x8(%r12), %ecx
jl 0x1b842
movq %r12, %rdi
pushq $0x1
popq %rsi
pushq $0x18
popq %rdx
callq 0x4799c
movq %rax, %r12
movl -0x4(%rax), %eax
leal 0x1(%rax), %ecx
movl %ecx, -0x4(%r12)
cltq
imulq $0x18, %rax, %r14
movq -0x30(%rbp), %rax
movq 0x8(%rax,%r13), %rsi
movq -0x58(%rbp), %rax
movq %rax, 0x20(%rsp)
movups -0x78(%rbp), %xmm0
movups -0x68(%rbp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %r15, %rdi
callq 0x1abbf
movq -0x40(%rbp), %rax
movq %rax, 0x10(%r12,%r14)
movups -0x50(%rbp), %xmm0
movups %xmm0, (%r12,%r14)
incq %rbx
addq $0x10, %r13
jmp 0x1b784
movq %r12, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/janet-lang[P]janet/src/core/compile.c
// Function: janetc_freeslots
void janetc_freeslots(JanetCompiler *c, JanetSlot *slots) {
    int32_t i;
    for (i = 0; i < janet_v_count(slots); i++) {
        janetc_freeslot(c, slots[i]);
    }
    janet_v_free(slots);
}

// Assembly:
testq %rsi, %rsi
je 0x1bb54
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
movq %rsi, %r12
movslq -0x4(%rbx), %rax
cmpq %rax, %r15
jge 0x1bb3c
movq 0x10(%r12), %rax
movq %rax, 0x10(%rsp)
movups (%r12), %xmm0
movups %xmm0, (%rsp)
movq %r14, %rdi
callq 0x1a177
incq %r15
addq $0x18, %r12
jmp 0x1bb0f
addq $-0x8, %rbx
movq %rbx, %rdi
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x298c1
retq