LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0x17146
leaq 0x50ed5(%rip), %rdi     # 0x68012
xorl %eax, %eax
callq 0x3f652
jmp 0x17154
leaq 0x3b5b4(%rip), %rdi     # 0x52701
xorl %eax, %eax
callq 0x3f652
movq %rax, 0xd8(%rbx)
addq $0x10, %rbx
movq %rbx, %rdi
movl $0x1, %esi
callq 0x128e0
// File: /workspace/github_c_makefile_star2_O3/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 0x171ad
cmpl $0xa, %eax
jne 0x171c3
callq 0x4ebc4
movq %rax, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x46988
callq 0x4ebc4
movq %rax, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x474e0
movabsq $-0x77fffffffffff, %rdi # imm = 0xFFF8800000000001
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x4ece6
// File: /workspace/github_c_makefile_star2_O3/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 0x1729a
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 0x17239
notl %edx
cmpl %edx, %eax
jg 0x17258
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 0x50dcf(%rip), %rax     # 0x68013
leaq 0x54e92(%rip), %rcx     # 0x6c0dd
cmovgeq %rax, %rcx
leaq 0x3b7f3(%rip), %rdi     # 0x52a49
jmp 0x17275
cmpl $0x2, %r15d
leaq 0x50db0(%rip), %rax     # 0x68013
leaq 0x54e73(%rip), %rcx     # 0x6c0dd
cmovgeq %rax, %rcx
leaq 0x3b80c(%rip), %rdi     # 0x52a81
movq %r14, %rsi
movl %r15d, %edx
xorl %eax, %eax
callq 0x3f652
movq %rax, 0xd8(%rbx)
addq $0x10, %rbx
movq %rbx, %rdi
movl $0x1, %esi
callq 0x128e0
// File: /workspace/github_c_makefile_star2_O3/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 0x4a1bd
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
testl %eax, %eax
jne 0x17600
leaq 0x158(%rbx), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x474e0
movq %rax, %xmm0
ucomisd %xmm0, %xmm0
setp %cl
movabsq $0x7800000000000, %rdx  # imm = 0x7800000000000
testq %rdx, %rax
setne %al
testb %al, %cl
jne 0x1756c
cvttsd2si %xmm0, %r14d
jmp 0x17600
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x17586
movq %r15, %rsi
callq 0x174fb
cmpl $-0x1, %eax
jge 0x1758e
movl %eax, %r14d
jmp 0x17600
movl $0xfffffffe, %r14d      # imm = 0xFFFFFFFE
jmp 0x17600
movl %eax, -0x2c(%rbp)
movl 0x74(%r12), %r14d
movslq %r14d, %rax
movq %rax, -0x38(%rbp)
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
callq 0x4ee44
movq %r13, %rdi
movq %r15, %rsi
movq -0x38(%rbp), %r15
movq %rax, %rdx
callq 0x476f0
cmpl 0xe4(%rbx), %r15d
jge 0x175cb
movq 0x10(%r12), %rax
jmp 0x175f1
movq 0x10(%r12), %rdi
leaq (,%r15,8), %rsi
callq 0x12840
movq %rax, 0x10(%r12)
testq %rax, %rax
je 0x17612
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
callq 0x12e78
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x1763e
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_O3/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 0x2ac80
movq %r14, %rdi
callq 0x12760
testq %rax, %rax
je 0x17681
movl $0x0, 0x10(%rbx)
movl %r14d, 0x14(%rbx)
movq %rax, 0x18(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
callq 0x12ea8
// File: /workspace/github_c_makefile_star2_O3/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 0x176c9
movl %edx, %ebx
movl %esi, %r15d
cmpl %edx, %esi
jl 0x176d5
movq %rdi, %r14
movl $0x20, %esi
movl $0x8, %edi
callq 0x2b686
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 0x3b470(%rip), %rdi     # 0x52b40
callq 0x191a3
leaq 0x3b46e(%rip), %rdi     # 0x52b4a
callq 0x191a3
// File: /workspace/github_c_makefile_star2_O3/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 0x17777
movq %rdi, %rbx
testb $0x1, 0x2(%rdi)
jne 0x17782
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 0x2ac80
movslq %r15d, %rsi
movq %r14, %rdi
callq 0x12840
testq %rax, %rax
je 0x1778e
movq %rax, 0x18(%rbx)
movl %r15d, 0x14(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3b625(%rip), %rdi     # 0x52dae
callq 0x191a3
callq 0x12ed6
// File: /workspace/github_c_makefile_star2_O3/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 0x177e2
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 0x177d4
movq %r14, %rdi
movl %ebx, %esi
movl $0x1, %edx
callq 0x1771e
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_O3/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 0x1785b
movq %rdi, %rbx
addl %esi, %eax
cmpl 0x14(%rdi), %eax
jle 0x17852
testb $0x1, 0x2(%rbx)
jne 0x17867
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 0x12840
movq %rax, %r14
movslq 0x14(%rbx), %rax
subq %rax, %r15
movq %r15, %rdi
callq 0x2ac80
testq %r14, %r14
je 0x17873
movq %r14, 0x18(%rbx)
movl %r12d, 0x14(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x50dbc(%rip), %rdi     # 0x6861e
callq 0x191a3
leaq 0x3b540(%rip), %rdi     # 0x52dae
callq 0x191a3
callq 0x12f04
// File: /workspace/github_c_makefile_star2_O3/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 0x17903
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 0x177e3
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_O3/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 0x1943f
movq %rax, %r15
leaq 0x4e30f(%rip), %rsi     # 0x6629c
movq %rax, %rdi
callq 0x4872e
testl %eax, %eax
je 0x17fd7
leaq 0x50177(%rip), %rsi     # 0x68117
movq %r15, %rdi
callq 0x4872e
testl %eax, %eax
je 0x17fda
leaq 0x44410(%rip), %rsi     # 0x5c3c3
movq %r15, %rdi
callq 0x4872e
movl $0x0, %r14d
testl %eax, %eax
je 0x17fda
movq 0x8(%rbx), %rsi
leaq 0x3ae06(%rip), %rdi     # 0x52dd6
xorl %eax, %eax
callq 0x190bb
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/janet-lang[P]janet/src/core/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 0x18417
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 0x183a6
movq -0x30(%rbp), %rdi
movl %r14d, %esi
callq 0x19a57
movl %eax, %r15d
movl $0x1, %r13d
movq %r12, %rdi
movl $0x1, %esi
callq 0x177e3
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 0x18358
jmp 0x18417
movq %xmm0, %rax
movabsq $0x7800000000000, %rcx  # imm = 0x7800000000000
testq %rcx, %rax
je 0x18362
movq -0x30(%rbp), %rdi
movl %r14d, %esi
callq 0x19909
movq %rax, %r15
movl %edx, %r13d
cmpq 0x18(%r12), %rax
jne 0x183ed
movl 0x10(%r12), %esi
addl %r13d, %esi
movq %r12, %rdi
movl $0x2, %edx
callq 0x1771e
movq 0x18(%r12), %r15
testl %r13d, %r13d
je 0x18397
movq %r12, %rdi
movl %r13d, %esi
callq 0x177e3
movslq 0x10(%r12), %rdi
addq 0x18(%r12), %rdi
movslq %r13d, %rdx
movq %r15, %rsi
callq 0x12670
jmp 0x18392
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/janet-lang[P]janet/src/core/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 0x191f3
movq %r12, %rdi
xorl %esi, %esi
callq 0x1948d
movq %rax, %r13
movq %r12, %rdi
movl $0x1, %esi
callq 0x19346
cvttsd2si %xmm0, %rax
testq %rax, %rax
js 0x18655
cvtsi2sd %rax, %xmm1
ucomisd %xmm1, %xmm0
jne 0x18655
jp 0x18655
movq %rax, %rcx
sarq $0x3, %rcx
movslq 0x10(%r13), %rdx
cmpq %rdx, %rcx
jge 0x18655
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 0x3a7a5(%rip), %rdi     # 0x52e06
xorl %eax, %eax
callq 0x190bb
// File: /workspace/github_c_makefile_star2_O3/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 0x2b686
movq %rbx, 0x10(%rax)
cmpl $0x0, 0x74(%rbx)
jne 0x18fbe
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x12f98
nop
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
pushq %rax
movq %rsi, %r14
movl %edi, %r15d
movq %fs:0x0, %rax
leaq -0x348(%rax), %rax
movq %rax, %rbx
movq 0x38(%rax), %rax
testq %rax, %rax
jne 0x19009
leaq 0x3b0c5(%rip), %rdi     # 0x540bc
movq %r14, %rsi
xorl %eax, %eax
callq 0x3f652
movq %rax, %rdi
callq 0x19090
testl %r15d, %r15d
je 0x19074
cmpl $0x0, 0x40(%rbx)
je 0x19074
movq 0x28(%rbx), %rcx
testq %rcx, %rcx
sete %dl
cmpl $0xd, %r15d
setne %sil
orb %dl, %sil
jne 0x19030
incl 0x48(%rcx)
jmp 0x19036
cmpl $0x1, %r15d
je 0x1906e
movl %r15d, %eax
leaq 0x6b450(%rip), %rcx     # 0x84490
movq (%rcx,%rax,8), %rdx
leaq 0x3b055(%rip), %rdi     # 0x540a0
movq %r14, %rsi
xorl %eax, %eax
callq 0x3f652
movabsq $-0x6000000000000, %rsi # imm = 0xFFFA000000000000
movq %rax, %rdi
callq 0x4ed39
movq %rax, %r14
movq 0x38(%rbx), %rax
movl $0x1, %r15d
movq %r14, (%rax)
movq 0x20(%rbx), %rax
testq %rax, %rax
je 0x19084
orb $0x8, 0x13(%rax)
movq 0x30(%rbx), %rdi
movl %r15d, %esi
callq 0x128e0
// File: /workspace/github_c_makefile_star2_O3/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 0x1911c
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 0x1911e
decl %esi
leaq -0x100(%rbp), %r14
movq %r14, %rdi
callq 0x17618
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 0x3ef42
movq 0x18(%r14), %rdi
movl 0x10(%r14), %esi
callq 0x44754
movq %rax, %rbx
movq %r14, %rdi
callq 0x176e1
movq %rbx, %rdi
callq 0x19188
// File: /workspace/github_c_makefile_star2_O3/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 0x19234
testl %edx, %edx
sets %cl
cmpl %edx, %eax
setle %sil
orb %cl, %sil
je 0x1923d
popq %rbp
retq
leaq 0x3b486(%rip), %rdi     # 0x546c1
jmp 0x19246
leaq 0x3b4b0(%rip), %rdi     # 0x546f4
movl %edx, %esi
movl %eax, %edx
xorl %eax, %eax
callq 0x190bb
// File: /workspace/github_c_makefile_star2_O3/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 0x192a8
movq %rdx, %rbx
movq %rdi, %r12
addq $0x10, %r15
movq %r12, %rdi
callq 0x4872e
testl %eax, %eax
je 0x1928c
movq (%r15), %rsi
addq $0x10, %r15
testq %rsi, %rsi
jne 0x19272
jmp 0x192a8
movq -0x8(%r15), %rdi
movabsq $-0x1800000000000, %rsi # imm = 0xFFFE800000000000
callq 0x4ed7e
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_O3/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
jne 0x192ef
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x1931b
callq 0x47261
movabsq $-0x5000000000000, %rsi # imm = 0xFFFB000000000000
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x4ed39
movq (%rbx), %rdx
testq %rdx, %rdx
je 0x1931b
movq %rsi, %r14
addq $0x10, %rbx
movl $0x6, %edi
movq %r14, %rsi
callq 0x199eb
testl %eax, %eax
jne 0x192cc
movq (%rbx), %rdx
addq $0x10, %rbx
testq %rdx, %rdx
jne 0x192fe
movabsq $-0x7800000000000, %rdi # imm = 0xFFF8800000000000
incq %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x4ece6
// File: /workspace/github_c_makefile_star2_O3/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 %rdi, %rbx
leaq 0x10(%rbp), %r14
testq %rsi, %rsi
je 0x1a244
movq %rsi, %r15
movl -0x4(%rsi), %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 0x1c64f
movq (%r14), %r14
cmpl $0x1, %r12d
jne 0x1a26a
movq 0x10(%r15), %rax
movq %rax, -0x30(%rbp)
movups (%r15), %xmm0
movaps %xmm0, -0x40(%rbp)
jmp 0x1a285
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 0x1c64f
movq (%r14), %r14
movabsq $-0x77fffffffffff, %rdi # imm = 0xFFF8800000000001
callq 0x4ece6
leaq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x1baf6
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 %r14, %rdi
movl $0x38, %esi
movl $0x2, %edx
movl $0x1, %ecx
callq 0x22059
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1a571
cmpl $0x0, -0x4(%rsi)
je 0x1a571
movq 0x10(%rsi), %rax
movq %rax, -0x20(%rbp)
movups (%rsi), %xmm0
jmp 0x1a59b
movabsq $-0x77fffffffffff, %rdi # imm = 0xFFF8800000000001
callq 0x4ece6
leaq -0x48(%rbp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x1baf6
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 0x1c64f
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 0x21f27
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1a7d3
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 0x1c64f
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 0x217fb
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 0x22063
jmp 0x1a833
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 0x22063
movabsq $-0x77fffffffffff, %rdi # imm = 0xFFF8800000000001
callq 0x4ece6
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1baf6
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 $0x88, %rsp
movl %edx, -0x2c(%rbp)
movq %rsi, %r12
movq %rdi, %r15
leaq 0x10(%rbp), %rax
movq (%rax), %r14
testq %rsi, %rsi
je 0x1b4a1
cmpl $0x1, -0x4(%r12)
jne 0x1b4a1
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)
leaq -0x48(%rbp), %rbx
movq %rbx, %rdi
callq 0x1c64f
movq 0x10(%rbx), %rax
movq %rax, 0x10(%r15)
movups (%rbx), %xmm0
movups %xmm0, (%r15)
leaq -0x60(%rbp), %rbx
movq %rbx, %rdi
movq %r13, %rsi
callq 0x1baf6
movq 0x10(%rbx), %rax
movq %rax, 0x40(%rsp)
movups (%rbx), %xmm0
jmp 0x1b4e5
movq 0x20(%rax), %rcx
movq %rcx, 0x20(%rsp)
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
leaq -0x48(%rbp), %rbx
movq %rbx, %rdi
callq 0x1c64f
movq 0x10(%rbx), %rax
movq %rax, 0x10(%r15)
movups (%rbx), %xmm0
movups %xmm0, (%r15)
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(%r15), %rax
movq %rax, 0x10(%rsp)
movups (%r15), %xmm0
movups %xmm0, (%rsp)
movzbl -0x2c(%rbp), %esi
movq %r14, %rdi
movl $0x1, %edx
callq 0x22063
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/janet-lang[P]janet/src/core/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 0x1bb44
movl $0x1, 0x48(%rdi)
movq %rsi, 0x30(%rdi)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1bbbf
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 0x1bd09
movq %rdx, %r14
movl %esi, %r12d
movq %rdi, %rbx
xorl %esi, %esi
cmpb $0x0, (%r14,%rsi)
leaq 0x1(%rsi), %rsi
jne 0x1bbe3
decl %esi
leaq -0x60(%rbp), %r15
movq %r15, %rdi
callq 0x17618
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 0x3ef42
movq 0x18(%r15), %rdi
movl 0x10(%r15), %esi
callq 0x44754
movq %rax, %r14
movq %r15, %rdi
callq 0x176e1
movl $0x4, %edi
callq 0x47fa0
movq %rax, %r15
movl %r12d, %eax
leaq 0x38706(%rip), %rcx     # 0x54360
movslq (%rcx,%rax,4), %rdi
addq %rcx, %rdi
callq 0x47261
movabsq $-0x5000000000000, %rsi # imm = 0xFFFB000000000000
movq %rax, %rdi
callq 0x4ed39
movq %rax, (%r15)
movl 0x50(%rbx), %eax
cmpl $-0x1, %eax
je 0x1bc8e
cvtsi2sd %eax, %xmm0
callq 0x4ee44
jmp 0x1bc9d
movabsq $-0x77fffffffffff, %rdi # imm = 0xFFF8800000000001
callq 0x4ece6
movq %rax, 0x8(%r15)
movl 0x54(%rbx), %eax
cmpl $-0x1, %eax
je 0x1bcb7
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
callq 0x4ee44
jmp 0x1bcc6
movabsq $-0x77fffffffffff, %rdi # imm = 0xFFF8800000000001
callq 0x4ece6
movq %rax, 0x10(%r15)
movabsq $-0x6000000000000, %rsi # imm = 0xFFFA000000000000
movq %r14, %rdi
callq 0x4ed39
movq %rax, 0x18(%r15)
movq 0x60(%rbx), %rbx
movq %r15, %rdi
callq 0x47fd1
movabsq $-0x4000000000000, %rsi # imm = 0xFFFC000000000000
movq %rax, %rdi
callq 0x4ed39
movq %rbx, %rdi
movq %rax, %rsi
callq 0x148a3
addq $0xf0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1bd66
movl -0x4(%rax), %r15d
jmp 0x1bd69
xorl %r15d, %r15d
movl 0x10(%rdi), %r12d
movl 0x14(%rdi), %r13d
movq (%r14), %rax
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x1bd88
movl -0x4(%rax), %ecx
leal 0x1(%rcx), %edx
cmpl -0x8(%rax), %edx
jl 0x1bdab
movq %rax, %rdi
movl $0x1, %esi
movl $0x38, %edx
callq 0x4b4e8
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)
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_O3/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 0x216e0
movl %eax, 0x8(%rbx)
movabsq $-0x77fffffffffff, %rdi # imm = 0xFFF8800000000001
callq 0x4ece6
movq %rax, (%rbx)
movl $0xffffffff, 0xc(%rbx)  # imm = 0xFFFFFFFF
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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)
movq $0x0, -0x28(%rbp)
xorps %xmm0, %xmm0
movups %xmm0, -0x78(%rbp)
movups %xmm0, -0x68(%rbp)
movq 0x8(%rsi), %rax
testq %rax, %rax
je 0x1be81
movl -0x4(%rax), %eax
jmp 0x1be83
xorl %eax, %eax
leaq -0x40(%rbp), %rdi
movl %eax, 0x20(%rdi)
movl %r15d, 0x24(%rdi)
movq (%r14), %rax
movq %rax, -0x40(%rdi)
callq 0x40918
testb $0x1, %r15b
jne 0x1beb7
movq (%r14), %rsi
testq %rsi, %rsi
je 0x1beb7
leaq -0x58(%rbp), %rdi
addq $0x30, %rsi
callq 0x40939
jmp 0x1bec0
leaq -0x58(%rbp), %rdi
callq 0x40918
movq (%r14), %rax
testq %rax, %rax
je 0x1becc
movq %rbx, 0x10(%rax)
movq %rbx, (%r14)
leaq -0x88(%rbp), %rsi
movl $0xe, %ecx
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_O3/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 0x1beec
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 0x1c147
addq $0x30, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x409ac
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1c632
btl $0x10, %r15d
jae 0x1c603
movq (%r14), %rax
shrq $0x2f, %rax
cmpl $0x1fff1, %eax          # imm = 0x1FFF1
jne 0x1c603
movq %rsi, %rdi
movl $0x4, %esi
callq 0x21728
jmp 0x1c627
movq 0x10(%r14), %rax
movq %rax, 0x10(%rsp)
movups (%r14), %xmm0
movups %xmm0, (%rsp)
movq %rsi, %rdi
movl $0x3, %esi
xorl %edx, %edx
callq 0x21ae6
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_O3/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 0x1c685
cmpl $0x0, 0x24(%rbp)
jns 0x1c685
cmpl $0xff, 0x20(%rbp)
ja 0x1c685
movq 0x18(%r14), %rax
movq %rax, 0x10(%rbx)
movups 0x8(%r14), %xmm0
movups %xmm0, (%rbx)
jmp 0x1c6b0
movl $0xffffffff, 0xc(%rbx)  # imm = 0xFFFFFFFF
movabsq $-0x77fffffffffff, %rdi # imm = 0xFFF8800000000001
callq 0x4ece6
movq %rax, (%rbx)
movl $0x0, 0x10(%rbx)
movq (%r14), %rdi
callq 0x216e0
movl %eax, 0x8(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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, %r14d
movq %rsi, %rbx
movq %rdi, -0x50(%rbp)
movabsq $-0x77fffffffffff, %rdi # imm = 0xFFF8800000000001
callq 0x4ece6
movq %rax, %xmm0
movq %rax, %rcx
shrq $0x2f, %rcx
andb $0xf, %cl
movl $0x10000, %edx          # imm = 0x10000
btsl %ecx, %edx
ucomisd %xmm0, %xmm0
movq %rax, -0x48(%rbp)
movl $0x10001, %eax          # imm = 0x10001
cmovpl %edx, %eax
movq $-0x1, -0x40(%rbp)
movl %eax, -0x38(%rbp)
movl $0x80000, -0x30(%rbp)   # imm = 0x80000
testl %r14d, %r14d
jle 0x1c7a9
movl %r14d, %r12d
xorl %r13d, %r13d
xorl %r15d, %r15d
testq %r15, %r15
je 0x1c73f
movl -0x4(%r15), %eax
leal 0x1(%rax), %ecx
cmpl -0x8(%r15), %ecx
jl 0x1c75a
movq %r15, %rdi
movl $0x1, %esi
movl $0x18, %edx
callq 0x4b4e8
movq %rax, %r15
movl -0x4(%rax), %eax
leal 0x1(%rax), %ecx
movl %ecx, -0x4(%r15)
cltq
leaq (%rax,%rax,2), %r14
movq (%rbx,%r13,8), %rsi
movq -0x30(%rbp), %rax
movq %rax, 0x20(%rsp)
movups -0x50(%rbp), %xmm0
movups -0x40(%rbp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
leaq -0x68(%rbp), %rdi
callq 0x1c7be
movq -0x58(%rbp), %rax
movq %rax, 0x10(%r15,%r14,8)
movupd -0x68(%rbp), %xmm0
movupd %xmm0, (%r15,%r14,8)
incq %r13
cmpq %r13, %r12
jne 0x1c72d
jmp 0x1c7ac
xorl %r15d, %r15d
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_O3/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 $0x88, %rsp
movq %rsi, %r14
movabsq $-0x7800000000000, %r13 # imm = 0xFFF8800000000000
movq %rdi, -0x60(%rbp)
leaq 0x1(%r13), %rdi
callq 0x4ece6
movq %rax, %xmm0
movq %rax, -0x58(%rbp)
shrq $0x2f, %rax
andb $0xf, %al
movl $0x10000, %ecx          # imm = 0x10000
btsl %eax, %ecx
ucomisd %xmm0, %xmm0
movl $0x10001, %eax          # imm = 0x10001
cmovpl %ecx, %eax
movq $-0x1, -0x50(%rbp)
movl %eax, -0x48(%rbp)
movl $0x80000, -0x40(%rbp)   # imm = 0x80000
leaq -0x30(%rbp), %rsi
movq $0x0, (%rsi)
xorl %ebx, %ebx
leaq -0x34(%rbp), %r15
movl %ebx, (%r15)
leaq -0x7c(%rbp), %rdx
movl %ebx, (%rdx)
movq %r14, %rdi
movq %r15, %rcx
callq 0x4985f
movl (%r15), %eax
testl %eax, %eax
jle 0x1d23c
xorl %r15d, %r15d
movabsq $-0x800000000000, %r14  # imm = 0xFFFF800000000000
xorl %r12d, %r12d
xorl %ebx, %ebx
movq -0x30(%rbp), %rcx
movq (%rcx,%r15), %rdx
andq %r14, %rdx
cmpq %r13, %rdx
je 0x1d229
testq %rbx, %rbx
je 0x1d14c
movl -0x4(%rbx), %eax
leal 0x1(%rax), %edx
cmpl -0x8(%rbx), %edx
jl 0x1d16b
movq %rbx, %rdi
movl $0x1, %esi
movl $0x18, %edx
callq 0x4b4e8
movq %rax, %rbx
movl -0x4(%rax), %eax
movq -0x30(%rbp), %rcx
leal 0x1(%rax), %edx
movl %edx, -0x4(%rbx)
cltq
leaq (%rax,%rax,2), %r13
movq (%rcx,%r15), %rsi
movq -0x40(%rbp), %rax
movq %rax, 0x20(%rsp)
movups -0x60(%rbp), %xmm0
movups -0x50(%rbp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
leaq -0x78(%rbp), %rdi
callq 0x1c7be
movq -0x68(%rbp), %rax
movq %rax, 0x10(%rbx,%r13,8)
movups -0x78(%rbp), %xmm0
movups %xmm0, (%rbx,%r13,8)
movl -0x4(%rbx), %eax
leal 0x1(%rax), %ecx
cmpl -0x8(%rbx), %ecx
jl 0x1d1d3
movq %rbx, %rdi
movl $0x1, %esi
movl $0x18, %edx
callq 0x4b4e8
movq %rax, %rbx
movl -0x4(%rax), %eax
leal 0x1(%rax), %ecx
movl %ecx, -0x4(%rbx)
cltq
leaq (%rax,%rax,2), %r13
movq -0x30(%rbp), %rax
movq 0x8(%rax,%r15), %rsi
movq -0x40(%rbp), %rax
movq %rax, 0x20(%rsp)
movups -0x60(%rbp), %xmm0
movups -0x50(%rbp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
leaq -0x78(%rbp), %rdi
callq 0x1c7be
movq -0x68(%rbp), %rax
movq %rax, 0x10(%rbx,%r13,8)
movupd -0x78(%rbp), %xmm0
movupd %xmm0, (%rbx,%r13,8)
movl -0x34(%rbp), %eax
movabsq $-0x7800000000000, %r13 # imm = 0xFFF8800000000000
incq %r12
movslq %eax, %rcx
addq $0x10, %r15
cmpq %rcx, %r12
jl 0x1d128
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/janet-lang[P]janet/src/core/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 0x1d4fb
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
cmpl $0x0, -0x4(%rsi)
jle 0x1d4e7
movq %rdi, %r14
leaq 0x10(%rbx), %r15
xorl %r12d, %r12d
testb $0xb, 0x2(%r15)
jne 0x1d4d7
cmpl $0x0, -0x4(%r15)
jns 0x1d4d7
movl -0x8(%r15), %esi
movq (%r14), %rdi
addq $0x30, %rdi
callq 0x40ac6
incq %r12
movslq -0x4(%rbx), %rax
addq $0x18, %r15
cmpq %rax, %r12
jl 0x1d4b9
addq $-0x8, %rbx
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2bcd9
retq