LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/util.c
// Function: janet_dictionary_view
int janet_dictionary_view(Janet tab, const JanetKV **data, int32_t *len, int32_t *cap) {
    if (janet_checktype(tab, JANET_TABLE)) {
        *data = janet_unwrap_table(tab)->data;
        *cap = janet_unwrap_table(tab)->capacity;
        *len = janet_unwrap_table(tab)->count;
        return 1;
    } else if (janet_checktype(tab, JANET_STRUCT)) {
        *data = janet_unwrap_struct(tab);
        *cap = janet_struct_capacity(janet_unwrap_struct(tab));
        *len = janet_struct_length(janet_unwrap_struct(tab));
        return 1;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
xorl %eax, %eax
testb $0x1, %al
jne 0x6d350
jmp 0x6d376
movsd -0x10(%rbp), %xmm0
ucomisd %xmm0, %xmm0
setp %al
testb $0x1, %al
jne 0x6d362
jmp 0x6d393
movq -0x10(%rbp), %rax
shrq $0x2f, %rax
andq $0xf, %rax
cmpq $0x0, %rax
je 0x6d393
jmp 0x6d3d7
movabsq $-0x800000000000, %rax  # imm = 0xFFFF800000000000
andq -0x10(%rbp), %rax
movabsq $-0x3800000000000, %rcx # imm = 0xFFFC800000000000
cmpq %rcx, %rax
jne 0x6d3d7
movq -0x10(%rbp), %rdi
callq 0x7b260
movq 0x20(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x7b260
movl 0x14(%rax), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x7b260
movl 0x10(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x6d46b
xorl %eax, %eax
testb $0x1, %al
jne 0x6d3df
jmp 0x6d405
movsd -0x10(%rbp), %xmm0
ucomisd %xmm0, %xmm0
setp %al
testb $0x1, %al
jne 0x6d3f1
jmp 0x6d422
movq -0x10(%rbp), %rax
shrq $0x2f, %rax
andq $0xf, %rax
cmpq $0x0, %rax
je 0x6d422
jmp 0x6d462
movabsq $-0x800000000000, %rax  # imm = 0xFFFF800000000000
andq -0x10(%rbp), %rax
movabsq $-0x3000000000000, %rcx # imm = 0xFFFD000000000000
cmpq %rcx, %rax
jne 0x6d462
movq -0x10(%rbp), %rdi
callq 0x7b260
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x7b260
movl -0x10(%rax), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x7b260
movl -0x18(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x6d46b
jmp 0x6d464
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/util.c
// Function: janet_checkint
int janet_checkint(Janet x) {
    if (!janet_checktype(x, JANET_NUMBER))
        return 0;
    double dval = janet_unwrap_number(x);
    return janet_checkintrange(dval);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movb $0x1, %al
testb $0x1, %al
jne 0x6d490
jmp 0x6d4b6
movsd -0x10(%rbp), %xmm0
ucomisd %xmm0, %xmm0
setp %al
testb $0x1, %al
jne 0x6d4a2
jmp 0x6d4dc
movq -0x10(%rbp), %rax
shrq $0x2f, %rax
andq $0xf, %rax
cmpq $0x0, %rax
je 0x6d4dc
jmp 0x6d4d3
movabsq $-0x800000000000, %rax  # imm = 0xFFFF800000000000
andq -0x10(%rbp), %rax
movabsq $-0x8000000000000, %rcx # imm = 0xFFF8000000000000
cmpq %rcx, %rax
je 0x6d4dc
movl $0x0, -0x4(%rbp)
jmp 0x6d53a
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
xorl %eax, %eax
movsd 0x11f83(%rip), %xmm1    # 0x7f478
ucomisd %xmm1, %xmm0
movb %al, -0x19(%rbp)
jb 0x6d52f
xorl %eax, %eax
movsd 0x11f78(%rip), %xmm0    # 0x7f480
ucomisd -0x18(%rbp), %xmm0
movb %al, -0x19(%rbp)
jb 0x6d52f
movsd -0x18(%rbp), %xmm0
cvttsd2si -0x18(%rbp), %eax
cvtsi2sd %eax, %xmm1
ucomisd %xmm1, %xmm0
sete %al
setnp %cl
andb %cl, %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/util.c
// Function: janet_checkuint
int janet_checkuint(Janet x) {
    if (!janet_checktype(x, JANET_NUMBER))
        return 0;
    double dval = janet_unwrap_number(x);
    return janet_checkuintrange(dval);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movb $0x1, %al
testb $0x1, %al
jne 0x6d550
jmp 0x6d576
movsd -0x10(%rbp), %xmm0
ucomisd %xmm0, %xmm0
setp %al
testb $0x1, %al
jne 0x6d562
jmp 0x6d59c
movq -0x10(%rbp), %rax
shrq $0x2f, %rax
andq $0xf, %rax
cmpq $0x0, %rax
je 0x6d59c
jmp 0x6d593
movabsq $-0x800000000000, %rax  # imm = 0xFFFF800000000000
andq -0x10(%rbp), %rax
movabsq $-0x8000000000000, %rcx # imm = 0xFFF8000000000000
cmpq %rcx, %rax
je 0x6d59c
movl $0x0, -0x4(%rbp)
jmp 0x6d5f8
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
xorl %eax, %eax
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
movb %al, -0x19(%rbp)
jb 0x6d5ed
xorl %eax, %eax
movsd 0x189e5(%rip), %xmm0    # 0x85fa8
ucomisd -0x18(%rbp), %xmm0
movb %al, -0x19(%rbp)
jb 0x6d5ed
movsd -0x18(%rbp), %xmm0
cvttsd2si %xmm0, %rax
movl %eax, %eax
cvtsi2sd %rax, %xmm1
ucomisd %xmm1, %xmm0
sete %al
setnp %cl
andb %cl, %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/util.c
// Function: janet_checkint64
int janet_checkint64(Janet x) {
    if (!janet_checktype(x, JANET_NUMBER))
        return 0;
    double dval = janet_unwrap_number(x);
    return janet_checkint64range(dval);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movb $0x1, %al
testb $0x1, %al
jne 0x6d610
jmp 0x6d636
movsd -0x10(%rbp), %xmm0
ucomisd %xmm0, %xmm0
setp %al
testb $0x1, %al
jne 0x6d622
jmp 0x6d65c
movq -0x10(%rbp), %rax
shrq $0x2f, %rax
andq $0xf, %rax
cmpq $0x0, %rax
je 0x6d65c
jmp 0x6d653
movabsq $-0x800000000000, %rax  # imm = 0xFFFF800000000000
andq -0x10(%rbp), %rax
movabsq $-0x8000000000000, %rcx # imm = 0xFFF8000000000000
cmpq %rcx, %rax
je 0x6d65c
movl $0x0, -0x4(%rbp)
jmp 0x6d6bc
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
xorl %eax, %eax
movsd 0x1d74b(%rip), %xmm1    # 0x8adc0
ucomisd %xmm1, %xmm0
movb %al, -0x19(%rbp)
jb 0x6d6b1
xorl %eax, %eax
movsd 0x1d740(%rip), %xmm0    # 0x8adc8
ucomisd -0x18(%rbp), %xmm0
movb %al, -0x19(%rbp)
jb 0x6d6b1
movsd -0x18(%rbp), %xmm0
cvttsd2si -0x18(%rbp), %rax
cvtsi2sd %rax, %xmm1
ucomisd %xmm1, %xmm0
sete %al
setnp %cl
andb %cl, %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/util.c
// Function: janet_checkuint64
int janet_checkuint64(Janet x) {
    if (!janet_checktype(x, JANET_NUMBER))
        return 0;
    double dval = janet_unwrap_number(x);
    return janet_checkuint64range(dval);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movb $0x1, %al
testb $0x1, %al
jne 0x6d6e0
jmp 0x6d706
movsd -0x10(%rbp), %xmm0
ucomisd %xmm0, %xmm0
setp %al
testb $0x1, %al
jne 0x6d6f2
jmp 0x6d72f
movq -0x10(%rbp), %rax
shrq $0x2f, %rax
andq $0xf, %rax
cmpq $0x0, %rax
je 0x6d72f
jmp 0x6d723
movabsq $-0x800000000000, %rax  # imm = 0xFFFF800000000000
andq -0x10(%rbp), %rax
movabsq $-0x8000000000000, %rcx # imm = 0xFFF8000000000000
cmpq %rcx, %rax
je 0x6d72f
movl $0x0, -0x4(%rbp)
jmp 0x6d7cf
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
xorl %eax, %eax
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
movb %al, -0x19(%rbp)
jb 0x6d7c4
xorl %eax, %eax
movsd 0x1d672(%rip), %xmm0    # 0x8adc8
ucomisd -0x18(%rbp), %xmm0
movb %al, -0x19(%rbp)
jb 0x6d7c4
movsd -0x18(%rbp), %xmm0
movsd 0x1392b(%rip), %xmm2    # 0x81098
movaps %xmm0, %xmm1
subsd %xmm2, %xmm1
cvttsd2si %xmm1, %rcx
movaps %xmm0, %xmm1
cvttsd2si %xmm1, %rax
movq %rax, %rdx
sarq $0x3f, %rdx
andq %rdx, %rcx
orq %rcx, %rax
movq %rax, %xmm1
movaps 0x140e6(%rip), %xmm2    # 0x81880
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0x140ea(%rip), %xmm2    # 0x81890
subpd %xmm2, %xmm1
movaps %xmm1, %xmm2
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm2, %xmm1
ucomisd %xmm1, %xmm0
sete %al
setnp %cl
andb %cl, %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/util.c
// Function: janet_checkint16
int janet_checkint16(Janet x) {
    if (!janet_checktype(x, JANET_NUMBER))
        return 0;
    double dval = janet_unwrap_number(x);
    return janet_checkint16range(dval);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movb $0x1, %al
testb $0x1, %al
jne 0x6d7f0
jmp 0x6d816
movsd -0x10(%rbp), %xmm0
ucomisd %xmm0, %xmm0
setp %al
testb $0x1, %al
jne 0x6d802
jmp 0x6d83c
movq -0x10(%rbp), %rax
shrq $0x2f, %rax
andq $0xf, %rax
cmpq $0x0, %rax
je 0x6d83c
jmp 0x6d833
movabsq $-0x800000000000, %rax  # imm = 0xFFFF800000000000
andq -0x10(%rbp), %rax
movabsq $-0x8000000000000, %rcx # imm = 0xFFF8000000000000
cmpq %rcx, %rax
je 0x6d83c
movl $0x0, -0x4(%rbp)
jmp 0x6d89d
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
xorl %eax, %eax
movsd 0x186bb(%rip), %xmm1    # 0x85f10
ucomisd %xmm1, %xmm0
movb %al, -0x19(%rbp)
jb 0x6d892
xorl %eax, %eax
movsd 0x186b0(%rip), %xmm0    # 0x85f18
ucomisd -0x18(%rbp), %xmm0
movb %al, -0x19(%rbp)
jb 0x6d892
movsd -0x18(%rbp), %xmm1
movaps %xmm1, %xmm0
cvttsd2si %xmm1, %eax
cwtl
cvtsi2sd %eax, %xmm1
ucomisd %xmm1, %xmm0
sete %al
setnp %cl
andb %cl, %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/util.c
// Function: janet_checkuint16
int janet_checkuint16(Janet x) {
    if (!janet_checktype(x, JANET_NUMBER))
        return 0;
    double dval = janet_unwrap_number(x);
    return janet_checkuint16range(dval);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movb $0x1, %al
testb $0x1, %al
jne 0x6d8c0
jmp 0x6d8e6
movsd -0x10(%rbp), %xmm0
ucomisd %xmm0, %xmm0
setp %al
testb $0x1, %al
jne 0x6d8d2
jmp 0x6d90c
movq -0x10(%rbp), %rax
shrq $0x2f, %rax
andq $0xf, %rax
cmpq $0x0, %rax
je 0x6d90c
jmp 0x6d903
movabsq $-0x800000000000, %rax  # imm = 0xFFFF800000000000
andq -0x10(%rbp), %rax
movabsq $-0x8000000000000, %rcx # imm = 0xFFF8000000000000
cmpq %rcx, %rax
je 0x6d90c
movl $0x0, -0x4(%rbp)
jmp 0x6d967
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
xorl %eax, %eax
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
movb %al, -0x19(%rbp)
jb 0x6d95c
xorl %eax, %eax
movsd 0x2b055(%rip), %xmm0    # 0x98988
ucomisd -0x18(%rbp), %xmm0
movb %al, -0x19(%rbp)
jb 0x6d95c
movsd -0x18(%rbp), %xmm0
cvttsd2si %xmm0, %eax
movzwl %ax, %eax
cvtsi2sd %eax, %xmm1
ucomisd %xmm1, %xmm0
sete %al
setnp %cl
andb %cl, %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/util.c
// Function: janet_checksize
int janet_checksize(Janet x) {
    if (!janet_checktype(x, JANET_NUMBER))
        return 0;
    double dval = janet_unwrap_number(x);
    if (dval != (double)((size_t) dval)) return 0;
    if (SIZE_MAX > JANET_INTMAX_INT64) {
        return dval <= JANET_INTMAX_INT64;
    } else {
        return dval <= SIZE_MAX;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movb $0x1, %al
testb $0x1, %al
jne 0x6d980
jmp 0x6d9a6
movsd -0x10(%rbp), %xmm0
ucomisd %xmm0, %xmm0
setp %al
testb $0x1, %al
jne 0x6d992
jmp 0x6d9cf
movq -0x10(%rbp), %rax
shrq $0x2f, %rax
andq $0xf, %rax
cmpq $0x0, %rax
je 0x6d9cf
jmp 0x6d9c3
movabsq $-0x800000000000, %rax  # imm = 0xFFFF800000000000
andq -0x10(%rbp), %rax
movabsq $-0x8000000000000, %rcx # imm = 0xFFF8000000000000
cmpq %rcx, %rax
je 0x6d9cf
movl $0x0, -0x4(%rbp)
jmp 0x6da59
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
movsd 0x136b2(%rip), %xmm2    # 0x81098
movaps %xmm0, %xmm1
subsd %xmm2, %xmm1
cvttsd2si %xmm1, %rcx
movaps %xmm0, %xmm1
cvttsd2si %xmm1, %rax
movq %rax, %rdx
sarq $0x3f, %rdx
andq %rdx, %rcx
orq %rcx, %rax
movq %rax, %xmm1
movaps 0x13e6d(%rip), %xmm2    # 0x81880
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0x13e71(%rip), %xmm2    # 0x81890
subpd %xmm2, %xmm1
movaps %xmm1, %xmm2
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm2, %xmm1
ucomisd %xmm1, %xmm0
jne 0x6da38
jp 0x6da38
jmp 0x6da41
movl $0x0, -0x4(%rbp)
jmp 0x6da59
movsd 0x1d37f(%rip), %xmm0    # 0x8adc8
ucomisd -0x18(%rbp), %xmm0
setae %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/util.c
// Function: janet_get_core_table
JanetTable *janet_get_core_table(const char *name) {
    JanetTable *env = janet_core_env(NULL);
    Janet out = janet_wrap_nil();
    JanetBindingType bt = janet_resolve(env, janet_csymbol(name), &out);
    if (bt == JANET_BINDING_NONE) return NULL;
    if (!janet_checktype(out, JANET_TABLE)) return NULL;
    return janet_unwrap_table(out);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x26c10
movq %rax, -0x18(%rbp)
movabsq $-0x77fffffffffff, %rdi # imm = 0xFFF8800000000001
callq 0x7b460
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x68d90
movq -0x30(%rbp), %rdi
movq %rax, %rsi
leaq -0x20(%rbp), %rdx
callq 0x6cff0
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jne 0x6dac0
movq $0x0, -0x8(%rbp)
jmp 0x6db22
xorl %eax, %eax
testb $0x1, %al
jne 0x6dac8
jmp 0x6daee
movsd -0x20(%rbp), %xmm0
ucomisd %xmm0, %xmm0
setp %al
testb $0x1, %al
jne 0x6dada
jmp 0x6db15
movq -0x20(%rbp), %rax
shrq $0x2f, %rax
andq $0xf, %rax
cmpq $0x0, %rax
je 0x6db15
jmp 0x6db0b
movabsq $-0x800000000000, %rax  # imm = 0xFFFF800000000000
andq -0x20(%rbp), %rax
movabsq $-0x3800000000000, %rcx # imm = 0xFFFC800000000000
cmpq %rcx, %rax
je 0x6db15
movq $0x0, -0x8(%rbp)
jmp 0x6db22
movq -0x20(%rbp), %rdi
callq 0x7b260
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/util.c
// Function: janet_gettime
int janet_gettime(struct timespec *spec, enum JanetTimeSource source) {
    clockid_t cid = CLOCK_REALTIME;
    if (source == JANET_TIME_REALTIME) {
        cid = CLOCK_REALTIME;
    } else if (source == JANET_TIME_MONOTONIC) {
        cid = CLOCK_MONOTONIC;
    } else if (source == JANET_TIME_CPUTIME) {
        cid = CLOCK_PROCESS_CPUTIME_ID;
    }
    return clock_gettime(cid, spec);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x6dd05
movl $0x0, -0x10(%rbp)
jmp 0x6dd25
cmpl $0x1, -0xc(%rbp)
jne 0x6dd14
movl $0x1, -0x10(%rbp)
jmp 0x6dd23
cmpl $0x2, -0xc(%rbp)
jne 0x6dd21
movl $0x2, -0x10(%rbp)
jmp 0x6dd23
jmp 0x6dd25
movl -0x10(%rbp), %edi
movq -0x8(%rbp), %rsi
callq 0x12230
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/util.c
// Function: janet_cryptorand
int janet_cryptorand(uint8_t *out, size_t n) {
#ifndef JANET_NO_CRYPTORAND
#ifdef JANET_WINDOWS
    for (size_t i = 0; i < n; i += sizeof(unsigned int)) {
        unsigned int v;
        if (rand_s(&v))
            return -1;
        for (int32_t j = 0; (j < (int32_t) sizeof(unsigned int)) && (i + j < n); j++) {
            out[i + j] = v & 0xff;
            v = v >> 8;
        }
    }
    return 0;
#elif defined(JANET_BSD) || defined(MAC_OS_X_VERSION_10_7)
    arc4random_buf(out, n);
    return 0;
#else
    /* We should be able to call getrandom on linux, but it doesn't seem
       to be uniformly supported on linux distros.
       On Mac, arc4random_buf wasn't available on until 10.7.
       In these cases, use this fallback path for now... */
    int rc;
    int randfd;
    RETRY_EINTR(randfd, open("/dev/urandom", O_RDONLY | O_CLOEXEC));
    if (randfd < 0)
        return -1;
    while (n > 0) {
        ssize_t nread;
        RETRY_EINTR(nread, read(randfd, out, n));
        if (nread <= 0) {
            RETRY_EINTR(rc, close(randfd));
            return -1;
        }
        out += nread;
        n -= nread;
    }
    RETRY_EINTR(rc, close(randfd));
    return 0;
#endif
#else
    (void) out;
    (void) n;
    return -1;
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq 0x2ace9(%rip), %rdi     # 0x98a80
movl $0x80000, %esi          # imm = 0x80000
movb $0x0, %al
callq 0x12900
movl %eax, -0x20(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x20(%rbp)
movb %al, -0x29(%rbp)
jge 0x6ddbf
callq 0x12120
cmpl $0x4, (%rax)
sete %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x6dd90
cmpl $0x0, -0x20(%rbp)
jge 0x6ddd8
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6dead
jmp 0x6ddda
cmpq $0x0, -0x18(%rbp)
jbe 0x6de79
jmp 0x6dde7
movl -0x20(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x12520
movq %rax, -0x28(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x28(%rbp)
movb %al, -0x2a(%rbp)
jge 0x6de15
callq 0x12120
cmpl $0x4, (%rax)
sete %al
movb %al, -0x2a(%rbp)
movb -0x2a(%rbp), %al
testb $0x1, %al
jne 0x6dde7
cmpq $0x0, -0x28(%rbp)
jg 0x6de59
jmp 0x6de25
movl -0x20(%rbp), %edi
callq 0x12470
movl %eax, -0x1c(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x1c(%rbp)
movb %al, -0x2b(%rbp)
jge 0x6de49
callq 0x12120
cmpl $0x4, (%rax)
sete %al
movb %al, -0x2b(%rbp)
movb -0x2b(%rbp), %al
testb $0x1, %al
jne 0x6de25
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6dead
movq -0x28(%rbp), %rax
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x18(%rbp)
jmp 0x6ddda
jmp 0x6de7b
movl -0x20(%rbp), %edi
callq 0x12470
movl %eax, -0x1c(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x1c(%rbp)
movb %al, -0x2c(%rbp)
jge 0x6de9f
callq 0x12120
cmpl $0x4, (%rax)
sete %al
movb %al, -0x2c(%rbp)
movb -0x2c(%rbp), %al
testb $0x1, %al
jne 0x6de7b
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/util.c
// Function: get_processed_name
char *get_processed_name(const char *name) {
    if (name[0] == '.') return (char *) name;
    const char *c;
    for (c = name; *c; c++) {
        if (*c == '/') return (char *) name;
    }
    size_t l = (size_t)(c - name);
    char *ret = janet_malloc(l + 3);
    if (NULL == ret) {
        JANET_OUT_OF_MEMORY;
    }
    ret[0] = '.';
    ret[1] = '/';
    memcpy(ret + 2, name, l + 1);
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2e, %eax
jne 0x6dee5
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x6dfa7
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpb $0x0, (%rax)
je 0x6df1f
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0x6df0f
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x6dfa7
jmp 0x6df11
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x6deed
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
addq $0x3, %rdi
callq 0x12770
movq %rax, -0x28(%rbp)
xorl %eax, %eax
cmpq -0x28(%rbp), %rax
jne 0x6df77
jmp 0x6df49
movq 0x420a0(%rip), %rax     # 0xafff0
movq (%rax), %rdi
leaq 0x100aa(%rip), %rsi     # 0x7e004
leaq 0x2aac6(%rip), %rdx     # 0x98a27
movl $0x41a, %ecx            # imm = 0x41A
movb $0x0, %al
callq 0x125f0
movl $0x1, %edi
callq 0x12a70
movq -0x28(%rbp), %rax
movb $0x2e, (%rax)
movq -0x28(%rbp), %rax
movb $0x2f, 0x1(%rax)
movq -0x28(%rbp), %rdi
addq $0x2, %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
addq $0x1, %rdx
callq 0x12680
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/value.c
// Function: janet_compare_abstract
static int janet_compare_abstract(JanetAbstract xx, JanetAbstract yy) {
    if (xx == yy) return 0;
    const JanetAbstractType *xt = janet_abstract_type(xx);
    const JanetAbstractType *yt = janet_abstract_type(yy);
    if (xt != yt) {
        return xt > yt ? 1 : -1;
    }
    if (xt->compare == NULL) {
        return xx > yy ? 1 : -1;
    }
    return xt->compare(xx, yy);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x6e903
movl $0x0, -0x4(%rbp)
jmp 0x6e97f
movq -0x10(%rbp), %rax
movq -0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
je 0x6e942
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rsi
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl $0x1, %ecx
cmpq %rsi, %rdx
cmoval %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x6e97f
movq -0x20(%rbp), %rax
cmpq $0x0, 0x40(%rax)
jne 0x6e96a
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rsi
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl $0x1, %ecx
cmpq %rsi, %rdx
cmoval %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x6e97f
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq *%rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/value.c
// Function: getter_checkint
static int32_t getter_checkint(JanetType type, Janet key, int32_t max) {
    if (!janet_checkint(key)) goto bad;
    int32_t ret = janet_unwrap_integer(key);
    if (ret < 0) goto bad;
    if (ret >= max) goto bad;
    return ret;
bad:
    janet_panicf("expected integer key for %s in range [0, %d), got %v", janet_type_names[type], max, key);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rsi, -0x8(%rbp)
movl %edi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6d480
cmpl $0x0, %eax
jne 0x6f8f2
jmp 0x6f915
cvttsd2si -0x8(%rbp), %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jge 0x6f902
jmp 0x6f915
movl -0x14(%rbp), %eax
cmpl -0x10(%rbp), %eax
jl 0x6f90c
jmp 0x6f915
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0x4030f(%rip), %rax     # 0xafc30
movq (%rax,%rcx,8), %rsi
movl -0x10(%rbp), %edx
movq -0x8(%rbp), %rcx
leaq 0x29481(%rip), %rdi     # 0x98db4
movb $0x0, %al
callq 0x1ac40
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/vector.c
// Function: janet_v_grow
void *janet_v_grow(void *v, int32_t increment, int32_t itemsize) {
    int32_t dbl_cur = (NULL != v) ? 2 * janet_v__cap(v) : 0;
    int32_t min_needed = janet_v_count(v) + increment;
    int32_t m = dbl_cur > min_needed ? dbl_cur : min_needed;
    size_t newsize = ((size_t) itemsize) * m + sizeof(int32_t) * 2;
    int32_t *p = (int32_t *) janet_srealloc(v ? janet_v__raw(v) : 0, newsize);
    if (!v) p[1] = 0;
    p[0] = m;
    return p + 2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
xorl %eax, %eax
cmpq -0x8(%rbp), %rax
je 0x70788
movq -0x8(%rbp), %rax
movl -0x8(%rax), %eax
shll %eax
movl %eax, -0x34(%rbp)
jmp 0x7078f
xorl %eax, %eax
movl %eax, -0x34(%rbp)
jmp 0x7078f
movl -0x34(%rbp), %eax
movl %eax, -0x14(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x707a8
movq -0x8(%rbp), %rax
movl -0x4(%rax), %eax
movl %eax, -0x38(%rbp)
jmp 0x707af
xorl %eax, %eax
movl %eax, -0x38(%rbp)
jmp 0x707af
movl -0x38(%rbp), %eax
addl -0xc(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jle 0x707c8
movl -0x14(%rbp), %eax
movl %eax, -0x3c(%rbp)
jmp 0x707ce
movl -0x18(%rbp), %eax
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movslq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq %rcx, %rax
addq $0x8, %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x707fd
movq -0x8(%rbp), %rax
addq $-0x8, %rax
movq %rax, -0x48(%rbp)
jmp 0x70805
xorl %eax, %eax
movq %rax, -0x48(%rbp)
jmp 0x70805
movq -0x48(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x3aae0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x70828
movq -0x30(%rbp), %rax
movl $0x0, 0x4(%rax)
movl -0x1c(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
movq -0x30(%rbp), %rax
addq $0x8, %rax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/vector.c
// Function: janet_v_flattenmem
void *janet_v_flattenmem(void *v, int32_t itemsize) {
    char *p;
    if (NULL == v) return NULL;
    size_t size = (size_t) itemsize * janet_v__cnt(v);
    p = janet_malloc(size);
    if (NULL != p) {
        safe_memcpy(p, v, size);
        return p;
    } else {
        JANET_OUT_OF_MEMORY;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
jne 0x70861
movq $0x0, -0x8(%rbp)
jmp 0x708d5
movslq -0x14(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq -0x4(%rcx), %rcx
imulq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x12770
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq -0x20(%rbp), %rax
je 0x708a5
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x6ae40
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x708d5
jmp 0x708a7
movq 0x3f742(%rip), %rax     # 0xafff0
movq (%rax), %rdi
leaq 0xd74c(%rip), %rsi      # 0x7e004
leaq 0x2852a(%rip), %rdx     # 0x98de9
movl $0x33, %ecx
movb $0x0, %al
callq 0x125f0
movl $0x1, %edi
callq 0x12a70
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/vm.c
// Function: janet_continue
JanetSignal janet_continue(JanetFiber *fiber, Janet in, Janet *out) {
    /* Check conditions */
    JanetSignal tmp_signal = janet_check_can_resume(fiber, out, 0);
    if (tmp_signal) return tmp_signal;
    return janet_continue_no_check(fiber, in, out);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
xorl %edx, %edx
callq 0x79d30
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x70ab4
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x70ac8
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rsi
callq 0x79ed0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/vm.c
// Function: vm_do_trace
static void vm_do_trace(JanetFunction *func, int32_t argc, const Janet *argv) {
    if (func->def->name) {
        janet_eprintf("trace (%S", func->def->name);
    } else {
        janet_eprintf("trace (%p", janet_wrap_function(func));
    }
    for (int32_t i = 0; i < argc; i++) {
        janet_eprintf(" %p", argv[i]);
    }
    janet_eprintf(")\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
cmpq $0x0, 0x48(%rax)
je 0x70fbf
movq 0x3f057(%rip), %rax     # 0xafff0
movq (%rax), %rsi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x48(%rax), %rcx
leaq 0x16a7f(%rip), %rdi     # 0x87a2e
leaq 0x27ff6(%rip), %rdx     # 0x98fac
movb $0x0, %al
callq 0x3fa20
jmp 0x71001
movq 0x3f02a(%rip), %rax     # 0xafff0
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movabsq $-0x2000000000000, %rsi # imm = 0xFFFE000000000000
callq 0x7b610
movq -0x30(%rbp), %rsi
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
leaq 0x16a3b(%rip), %rdi     # 0x87a2e
leaq 0x27fbc(%rip), %rdx     # 0x98fb6
movb $0x0, %al
callq 0x3fa20
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x71046
movq 0x3efd9(%rip), %rax     # 0xafff0
movq (%rax), %rsi
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rcx
leaq 0x16a01(%rip), %rdi     # 0x87a2e
leaq 0x1bc96(%rip), %rdx     # 0x8ccca
movb $0x0, %al
callq 0x3fa20
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x71008
movq 0x3efa3(%rip), %rax     # 0xafff0
movq (%rax), %rsi
leaq 0x169d7(%rip), %rdi     # 0x87a2e
leaq 0x27f62(%rip), %rdx     # 0x98fc0
movb $0x0, %al
callq 0x3fa20
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/vm.c
// Function: janet_try_init
void janet_try_init(JanetTryState *state) {
    state->stackn = janet_vm.stackn++;
    state->gc_handle = janet_vm.gc_suspend;
    state->vm_fiber = janet_vm.fiber;
    state->vm_jmp_buf = janet_vm.signal_buf;
    state->vm_return_reg = janet_vm.return_reg;
    state->coerce_error = janet_vm.coerce_error;
    janet_vm.return_reg = &(state->payload);
    janet_vm.signal_buf = &(state->buf);
    janet_vm.coerce_error = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %fs:0x0, %rax
leaq -0x348(%rax), %rax
movl 0x18(%rax), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, 0x18(%rax)
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movq %fs:0x0, %rax
leaq -0x348(%rax), %rax
movl 0xb8(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x4(%rax)
movq %fs:0x0, %rax
leaq -0x348(%rax), %rax
movq 0x20(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq %fs:0x0, %rax
leaq -0x348(%rax), %rax
movq 0x30(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq %fs:0x0, %rax
leaq -0x348(%rax), %rax
movq 0x38(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq %fs:0x0, %rax
leaq -0x348(%rax), %rax
movl 0x40(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xf0(%rax)
movq -0x8(%rbp), %rax
addq $0xe8, %rax
movq %rax, -0x18(%rbp)
movq %fs:0x0, %rax
leaq -0x348(%rax), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x38(%rax)
movq -0x8(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x10(%rbp)
movq %fs:0x0, %rax
leaq -0x348(%rax), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x30(%rax)
movq %fs:0x0, %rax
leaq -0x348(%rax), %rax
movl $0x0, 0x40(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/vm.c
// Function: janet_restore
void janet_restore(JanetTryState *state) {
    janet_vm.stackn = state->stackn;
    janet_vm.gc_suspend = state->gc_handle;
    janet_vm.fiber = state->vm_fiber;
    janet_vm.signal_buf = state->vm_jmp_buf;
    janet_vm.return_reg = state->vm_return_reg;
    janet_vm.coerce_error = state->coerce_error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x30(%rbp)
movq %fs:0x0, %rax
leaq -0x348(%rax), %rax
movl -0x30(%rbp), %ecx
movl %ecx, 0x18(%rax)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x2c(%rbp)
movq %fs:0x0, %rax
leaq -0x348(%rax), %rax
movl -0x2c(%rbp), %ecx
movl %ecx, 0xb8(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq %fs:0x0, %rax
leaq -0x348(%rax), %rax
movq -0x28(%rbp), %rcx
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq %fs:0x0, %rax
leaq -0x348(%rax), %rax
movq -0x20(%rbp), %rcx
movq %rcx, 0x30(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq %fs:0x0, %rax
leaq -0x348(%rax), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x38(%rax)
movq -0x8(%rbp), %rax
movl 0xf0(%rax), %eax
movl %eax, -0xc(%rbp)
movq %fs:0x0, %rax
leaq -0x348(%rax), %rax
movl -0xc(%rbp), %ecx
movl %ecx, 0x40(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/vm.c
// Function: janet_continue_signal
JanetSignal janet_continue_signal(JanetFiber *fiber, Janet in, Janet *out, JanetSignal sig) {
    JanetSignal tmp_signal = janet_check_can_resume(fiber, out, sig != JANET_SIGNAL_OK);
    if (tmp_signal) return tmp_signal;
    if (sig != JANET_SIGNAL_OK) {
        JanetFiber *child = fiber;
        while (child->child) child = child->child;
        child->gc.flags &= ~JANET_FIBER_STATUS_MASK;
        child->gc.flags |= sig << JANET_FIBER_STATUS_OFFSET;
        child->flags |= JANET_FIBER_RESUME_SIGNAL;
    }
    return janet_continue_no_check(fiber, in, out);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
cmpl $0x0, -0x24(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %edx
callq 0x79d30
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
je 0x7a391
movl -0x28(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x7a3f8
cmpl $0x0, -0x24(%rbp)
je 0x7a3e4
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0x7a3b8
movq -0x30(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x7a39f
movq -0x30(%rbp), %rax
movl (%rax), %ecx
andl $0xffc0ffff, %ecx       # imm = 0xFFC0FFFF
movl %ecx, (%rax)
movl -0x24(%rbp), %ecx
shll $0x10, %ecx
movq -0x30(%rbp), %rax
orl (%rax), %ecx
movl %ecx, (%rax)
movq -0x30(%rbp), %rax
movl 0x10(%rax), %ecx
orl $0x400000, %ecx         # imm = 0x400000
movl %ecx, 0x10(%rax)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rsi
callq 0x79ed0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/vm.c
// Function: janet_pcall
JanetSignal janet_pcall(
    JanetFunction *fun,
    int32_t argc,
    const Janet *argv,
    Janet *out,
    JanetFiber **f) {
    JanetFiber *fiber;
    if (f && *f) {
        fiber = janet_fiber_reset(*f, fun, argc, argv);
    } else {
        fiber = janet_fiber(fun, 64, argc, argv);
    }
    if (f) *f = fiber;
    if (NULL == fiber) {
        *out = janet_cstringv("arity mismatch");
        return JANET_SIGNAL_ERROR;
    }
    return janet_continue(fiber, janet_wrap_nil(), out);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x7a459
movq -0x30(%rbp), %rax
cmpq $0x0, (%rax)
je 0x7a459
movq -0x30(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movq -0x20(%rbp), %rcx
callq 0x35e70
movq %rax, -0x38(%rbp)
jmp 0x7a472
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %edx
movq -0x20(%rbp), %rcx
movl $0x40, %esi
callq 0x36450
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x7a484
movq -0x38(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
xorl %eax, %eax
cmpq -0x38(%rbp), %rax
jne 0x7a4cd
movq -0x28(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq 0x1ea8e(%rip), %rdi     # 0x98f29
callq 0x64a70
movq %rax, %rdi
movabsq $-0x6000000000000, %rsi # imm = 0xFFFA000000000000
callq 0x7b550
movq %rax, %rcx
movq -0x50(%rbp), %rax
movq %rcx, -0x40(%rbp)
movq -0x40(%rbp), %rcx
movq %rcx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x7a4fc
movq -0x38(%rbp), %rax
movq %rax, -0x58(%rbp)
movabsq $-0x77fffffffffff, %rdi # imm = 0xFFF8800000000001
callq 0x7b460
movq -0x58(%rbp), %rdi
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rdx
movq -0x48(%rbp), %rsi
callq 0x70a80
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/vm.c
// Function: janet_mcall
Janet janet_mcall(const char *name, int32_t argc, Janet *argv) {
    /* At least 1 argument */
    if (argc < 1) {
        janet_panicf("method :%s expected at least 1 argument", name);
    }
    /* Find method */
    Janet method = janet_method_lookup(argv[0], name);
    if (janet_checktype(method, JANET_NIL)) {
        janet_panicf("could not find method :%s for %v", name, argv[0]);
    }
    /* Invoke method */
    return janet_method_invoke(method, argc, argv);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
cmpl $0x1, -0x14(%rbp)
jge 0x7a53b
movq -0x10(%rbp), %rsi
leaq 0x1ea04(%rip), %rdi     # 0x98f38
movb $0x0, %al
callq 0x1ac40
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rsi
movq (%rax), %rdi
callq 0x7a5e0
movq %rax, -0x28(%rbp)
xorl %eax, %eax
testb $0x1, %al
jne 0x7a557
jmp 0x7a57d
movsd -0x28(%rbp), %xmm0
ucomisd %xmm0, %xmm0
setp %al
testb $0x1, %al
jne 0x7a569
jmp 0x7a59a
movq -0x28(%rbp), %rax
shrq $0x2f, %rax
andq $0xf, %rax
cmpq $0x0, %rax
je 0x7a59a
jmp 0x7a5b3
movabsq $-0x800000000000, %rax  # imm = 0xFFFF800000000000
andq -0x28(%rbp), %rax
movabsq $-0x7800000000000, %rcx # imm = 0xFFF8800000000000
cmpq %rcx, %rax
jne 0x7a5b3
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rax
movq (%rax), %rdx
leaq 0x1e9b4(%rip), %rdi     # 0x98f60
movb $0x0, %al
callq 0x1ac40
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rdi
callq 0x7a630
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/vm.c
// Function: janet_method_invoke
static Janet janet_method_invoke(Janet method, int32_t argc, Janet *argv) {
    switch (janet_type(method)) {
        case JANET_CFUNCTION:
            return (janet_unwrap_cfunction(method))(argc, argv);
        case JANET_FUNCTION: {
            JanetFunction *fun = janet_unwrap_function(method);
            return janet_call(fun, argc, argv);
        }
        case JANET_ABSTRACT: {
            JanetAbstract abst = janet_unwrap_abstract(method);
            const JanetAbstractType *at = janet_abstract_type(abst);
            if (NULL != at->call) {
                return at->call(abst, argc, argv);
            }
        }
        /* fallthrough */
        case JANET_STRING:
        case JANET_BUFFER:
        case JANET_TABLE:
        case JANET_STRUCT:
        case JANET_ARRAY:
        case JANET_TUPLE: {
            if (argc != 1) {
                janet_panicf("%v called with %d arguments, possibly expected 1", method, argc);
            }
            return janet_in(method, argv[0]);
        }
        default: {
            if (argc != 1) {
                janet_panicf("%v called with %d arguments, possibly expected 1", method, argc);
            }
            return janet_in(argv[0], method);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movsd -0x10(%rbp), %xmm0
ucomisd %xmm0, %xmm0
setp %al
testb $0x1, %al
jne 0x7a655
jmp 0x7a666
movq -0x10(%rbp), %rax
shrq $0x2f, %rax
andq $0xf, %rax
movl %eax, -0x3c(%rbp)
jmp 0x7a66d
xorl %eax, %eax
movl %eax, -0x3c(%rbp)
jmp 0x7a66d
movl -0x3c(%rbp), %eax
addl $-0x4, %eax
movl %eax, %ecx
movq %rcx, -0x48(%rbp)
subl $0xa, %eax
ja 0x7a74a
movq -0x48(%rbp), %rax
leaq 0x1e76f(%rip), %rcx     # 0x98dfc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rdi
callq 0x7b260
movl -0x14(%rbp), %edi
movq -0x20(%rbp), %rsi
callq *%rax
movq %rax, -0x8(%rbp)
jmp 0x7a779
movq -0x10(%rbp), %rdi
callq 0x7b260
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
callq 0x70ae0
movq %rax, -0x8(%rbp)
jmp 0x7a779
movq -0x10(%rbp), %rdi
callq 0x7b260
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x10(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rcx
xorl %eax, %eax
cmpq 0x58(%rcx), %rax
je 0x7a717
movq -0x38(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x30(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
callq *%rax
movq %rax, -0x8(%rbp)
jmp 0x7a779
jmp 0x7a719
cmpl $0x1, -0x14(%rbp)
je 0x7a734
movl -0x14(%rbp), %edx
movq -0x10(%rbp), %rsi
leaq 0x1eb4b(%rip), %rdi     # 0x99278
movb $0x0, %al
callq 0x1ac40
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rdi
movq (%rax), %rsi
callq 0x6f5f0
movq %rax, -0x8(%rbp)
jmp 0x7a779
cmpl $0x1, -0x14(%rbp)
je 0x7a765
movl -0x14(%rbp), %edx
movq -0x10(%rbp), %rsi
leaq 0x1eb1a(%rip), %rdi     # 0x99278
movb $0x0, %al
callq 0x1ac40
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x6f5f0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/vm.c
// Function: janet_deinit
void janet_deinit(void) {
    janet_clear_memory();
    janet_symcache_deinit();
    janet_free(janet_vm.roots);
    janet_vm.roots = NULL;
    janet_vm.root_count = 0;
    janet_vm.root_capacity = 0;
    janet_vm.abstract_registry = NULL;
    janet_vm.core_env = NULL;
    janet_vm.top_dyns = NULL;
    janet_vm.user = NULL;
    janet_free(janet_vm.traversal_base);
    janet_vm.fiber = NULL;
    janet_vm.root_fiber = NULL;
    janet_free(janet_vm.registry);
    janet_vm.registry = NULL;
#ifdef JANET_EV
    janet_ev_deinit();
#endif
#ifdef JANET_NET
    janet_net_deinit();
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x3a5f0
callq 0x688b0
movq %fs:0x0, %rax
leaq -0x348(%rax), %rax
movq 0xc0(%rax), %rdi
callq 0x120b0
movq %fs:0x0, %rax
leaq -0x348(%rax), %rax
movq $0x0, 0xc0(%rax)
movq %fs:0x0, %rax
leaq -0x348(%rax), %rax
movq $0x0, 0xc8(%rax)
movq %fs:0x0, %rax
leaq -0x348(%rax), %rax
movq $0x0, 0xd0(%rax)
movq %fs:0x0, %rax
leaq -0x348(%rax), %rax
movq $0x0, 0x68(%rax)
movq %fs:0x0, %rax
leaq -0x348(%rax), %rax
movq $0x0, 0x10(%rax)
movq %fs:0x0, %rax
leaq -0x348(%rax), %rax
movq $0x0, 0x8(%rax)
movq %fs:0x0, %rax
leaq -0x348(%rax), %rax
movq $0x0, (%rax)
movq %fs:0x0, %rax
leaq -0x348(%rax), %rax
movq 0x118(%rax), %rdi
callq 0x120b0
movq %fs:0x0, %rax
leaq -0x348(%rax), %rax
movq $0x0, 0x20(%rax)
movq %fs:0x0, %rax
leaq -0x348(%rax), %rax
movq $0x0, 0x28(%rax)
movq %fs:0x0, %rax
leaq -0x348(%rax), %rax
movq 0x48(%rax), %rdi
callq 0x120b0
movq %fs:0x0, %rax
leaq -0x348(%rax), %rax
movq $0x0, 0x48(%rax)
callq 0x2f090
callq 0x49e00
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/vm.c
// Function: janet_binop_call
static Janet janet_binop_call(const char *lmethod, const char *rmethod, Janet lhs, Janet rhs) {
    Janet lm = janet_method_lookup(lhs, lmethod);
    if (janet_checktype(lm, JANET_NIL)) {
        /* Invert order for rmethod */
        Janet lr = janet_method_lookup(rhs, rmethod);
        Janet argv[2] = { rhs, lhs };
        if (janet_checktype(lr, JANET_NIL)) {
            janet_panicf("could not find method :%s for %v or :%s for %v",
                         lmethod, lhs,
                         rmethod, rhs);
        }
        return janet_method_invoke(lr, 2, argv);
    } else {
        Janet argv[2] = { lhs, rhs };
        return janet_method_invoke(lm, 2, argv);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %rdi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdi
callq 0x7a5e0
movq %rax, -0x30(%rbp)
xorl %eax, %eax
testb $0x1, %al
jne 0x7ad01
jmp 0x7ad2a
movsd -0x30(%rbp), %xmm0
ucomisd %xmm0, %xmm0
setp %al
testb $0x1, %al
jne 0x7ad13
jmp 0x7ad4b
movq -0x30(%rbp), %rax
shrq $0x2f, %rax
andq $0xf, %rax
cmpq $0x0, %rax
je 0x7ad4b
jmp 0x7aded
movabsq $-0x800000000000, %rax  # imm = 0xFFFF800000000000
andq -0x30(%rbp), %rax
movabsq $-0x7800000000000, %rcx # imm = 0xFFF8800000000000
cmpq %rcx, %rax
jne 0x7aded
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rdi
callq 0x7a5e0
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
xorl %eax, %eax
testb $0x1, %al
jne 0x7ad74
jmp 0x7ad9a
movsd -0x38(%rbp), %xmm0
ucomisd %xmm0, %xmm0
setp %al
testb $0x1, %al
jne 0x7ad86
jmp 0x7adb7
movq -0x38(%rbp), %rax
shrq $0x2f, %rax
andq $0xf, %rax
cmpq $0x0, %rax
je 0x7adb7
jmp 0x7add5
movabsq $-0x800000000000, %rax  # imm = 0xFFFF800000000000
andq -0x38(%rbp), %rax
movabsq $-0x7800000000000, %rcx # imm = 0xFFF8800000000000
cmpq %rcx, %rax
jne 0x7add5
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %r8
leaq 0x1e3b9(%rip), %rdi     # 0x99187
movb $0x0, %al
callq 0x1ac40
leaq -0x50(%rbp), %rdx
movq -0x38(%rbp), %rdi
movl $0x2, %esi
callq 0x7a630
movq %rax, -0x8(%rbp)
jmp 0x7ae13
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x60(%rbp), %rdx
movq -0x30(%rbp), %rdi
movl $0x2, %esi
callq 0x7a630
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/vm.c
// Function: janet_unary_call
static Janet janet_unary_call(const char *method, Janet arg) {
    Janet m = janet_method_lookup(arg, method);
    if (janet_checktype(m, JANET_NIL)) {
        janet_panicf("could not find method :%s for %v", method, arg);
    } else {
        Janet argv[1] = { arg };
        return janet_method_invoke(m, 1, argv);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
callq 0x7a5e0
movq %rax, -0x20(%rbp)
xorl %eax, %eax
testb $0x1, %al
jne 0x7ae49
jmp 0x7ae6f
movsd -0x20(%rbp), %xmm0
ucomisd %xmm0, %xmm0
setp %al
testb $0x1, %al
jne 0x7ae5b
jmp 0x7ae8c
movq -0x20(%rbp), %rax
shrq $0x2f, %rax
andq $0xf, %rax
cmpq $0x0, %rax
je 0x7ae8c
jmp 0x7aea2
movabsq $-0x800000000000, %rax  # imm = 0xFFFF800000000000
andq -0x20(%rbp), %rax
movabsq $-0x7800000000000, %rcx # imm = 0xFFF8800000000000
cmpq %rcx, %rax
jne 0x7aea2
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq 0x1e0c5(%rip), %rdi     # 0x98f60
movb $0x0, %al
callq 0x1ac40
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rdx
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x7a630
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/vm.c
// Function: resolve_method
static Janet resolve_method(Janet name, JanetFiber *fiber) {
    int32_t argc = fiber->stacktop - fiber->stackstart;
    if (argc < 1) janet_panicf("method call (%v) takes at least 1 argument, got 0", name);
    Janet callee = method_to_fun(name, fiber->data[fiber->stackstart]);
    if (janet_checktype(callee, JANET_NIL))
        janet_panicf("unknown method %v invoked on %v", name, fiber->data[fiber->stackstart]);
    return callee;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x1c(%rax), %eax
movq -0x18(%rbp), %rcx
subl 0x18(%rcx), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x1, -0x1c(%rbp)
jge 0x7af09
movq -0x10(%rbp), %rsi
leaq 0x1e2b4(%rip), %rdi     # 0x991b6
movb $0x0, %al
callq 0x1ac40
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x18(%rbp), %rcx
movslq 0x18(%rcx), %rcx
movq -0x10(%rbp), %rdi
movq (%rax,%rcx,8), %rsi
callq 0x7b010
movq %rax, -0x8(%rbp)
xorl %eax, %eax
testb $0x1, %al
jne 0x7af32
jmp 0x7af58
movsd -0x8(%rbp), %xmm0
ucomisd %xmm0, %xmm0
setp %al
testb $0x1, %al
jne 0x7af44
jmp 0x7af75
movq -0x8(%rbp), %rax
shrq $0x2f, %rax
andq $0xf, %rax
cmpq $0x0, %rax
je 0x7af75
jmp 0x7af9b
movabsq $-0x800000000000, %rax  # imm = 0xFFFF800000000000
andq -0x8(%rbp), %rax
movabsq $-0x7800000000000, %rcx # imm = 0xFFF8800000000000
cmpq %rcx, %rax
jne 0x7af9b
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x18(%rbp), %rcx
movslq 0x18(%rcx), %rcx
movq -0x10(%rbp), %rsi
movq (%rax,%rcx,8), %rdx
leaq 0x1e254(%rip), %rdi     # 0x991e8
movb $0x0, %al
callq 0x1ac40
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/wrap.c
// Function: janet_nanbox_from_cpointer
Janet janet_nanbox_from_cpointer(const void *p, uint64_t tagmask) {
    Janet ret;
    ret.pointer = (void *)p;
    ret.u64 |= tagmask;
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x18(%rbp), %rax
orq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)