LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/janet-lang[P]janet/src/core/peg.c
// Function: spec_matchtime
static void spec_matchtime(Builder *b, int32_t argc, const Janet *argv) {
    peg_arity(b, argc, 2, 3);
    Reserve r = reserve(b, 4);
    uint32_t subrule = peg_compile1(b, argv[0]);
    Janet fun = argv[1];
    if (!janet_checktype(fun, JANET_FUNCTION) &&
            !janet_checktype(fun, JANET_CFUNCTION)) {
        peg_panicf(b, "expected function or cfunction, got %v", fun);
    }
    uint32_t tag = (argc == 3) ? emit_tag(b, argv[2]) : 0;
    uint32_t cindex = emit_constant(b, fun);
    emit_3(r, RULE_MATCHTIME, subrule, cindex, tag);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %rbx
pushq $0x2
popq %rdx
pushq $0x3
popq %rcx
callq 0x3acb8
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0x39d6e
movq %rax, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x39872
movq 0x8(%r14), %r12
movq %r12, %rcx
btsq $0x2f, %rcx
shrq $0x2f, %rcx
cmpl $0x1fffd, %ecx          # imm = 0x1FFFD
jne 0x3a5b6
movl %eax, -0x2c(%rbp)
xorl %r13d, %r13d
cmpl $0x3, %r15d
jne 0x3a584
movq 0x10(%r14), %rsi
movq %rbx, %rdi
callq 0x3ad06
movl %eax, %r13d
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3af6c
pushq $0x14
popq %rdx
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movl -0x2c(%rbp), %ecx
movl %eax, %r8d
movl %r13d, %r9d
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3a0a8
leaq 0x29be1(%rip), %rdi     # 0x6419e
movq %r12, %rsi
xorl %eax, %eax
callq 0x3c0ed
movq %rbx, %rdi
movq %rax, %rsi
callq 0x39d47
// File: /workspace/github_c_makefile_star2_O2/janet-lang[P]janet/src/core/peg.c
// Function: spec_constant
static void spec_constant(Builder *b, int32_t argc, const Janet *argv) {
    janet_arity(argc, 1, 2);
    Reserve r = reserve(b, 3);
    uint32_t tag = (argc == 2) ? emit_tag(b, argv[1]) : 0;
    emit_2(r, RULE_CONSTANT, emit_constant(b, argv[0]), tag);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %rbx
pushq $0x1
popq %rsi
pushq $0x2
popq %rdx
movl %r15d, %edi
callq 0x1781a
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x39d6e
movq %rax, -0x30(%rbp)
movq %rdx, %r12
xorl %r13d, %r13d
cmpl $0x2, %r15d
jne 0x3a630
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0x3ad06
movl %eax, %r13d
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x3af6c
pushq $0x10
popq %rdx
movq -0x30(%rbp), %rdi
movq %r12, %rsi
movl %eax, %ecx
movl %r13d, %r8d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3ae38
// File: /workspace/github_c_makefile_star2_O2/janet-lang[P]janet/src/core/peg.c
// Function: spec_error
static void spec_error(Builder *b, int32_t argc, const Janet *argv) {
    if (argc == 0) {
        Reserve r = reserve(b, 2);
        uint32_t rule = peg_compile1(b, janet_wrap_number(0));
        emit_1(r, RULE_ERROR, rule);
    } else {
        spec_onerule(b, argc, argv, RULE_ERROR);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
je 0x3a692
pushq $0x15
popq %rcx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3abef
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x39d6e
movq %rax, %r14
movq %rdx, %r15
xorps %xmm0, %xmm0
callq 0x4b471
movq %rbx, %rdi
movq %rax, %rsi
callq 0x39872
pushq $0x15
popq %rdx
movq %r14, %rdi
movq %r15, %rsi
movl %eax, %ecx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x39e05
// File: /workspace/github_c_makefile_star2_O2/janet-lang[P]janet/src/core/peg.c
// Function: spec_nth
static void spec_nth(Builder *b, int32_t argc, const Janet *argv) {
    peg_arity(b, argc, 2, 3);
    Reserve r = reserve(b, 4);
    uint32_t nth = peg_getnat(b, argv[0]);
    uint32_t rule = peg_compile1(b, argv[1]);
    uint32_t tag = (argc == 3) ? emit_tag(b, argv[2]) : 0;
    emit_3(r, RULE_NTH, nth, rule, tag);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movl %esi, %r13d
movq %rdi, %rbx
pushq $0x2
popq %rdx
pushq $0x3
popq %rcx
callq 0x3acb8
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0x39d6e
movq %rax, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x3a071
movl %eax, %r15d
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0x39872
movl %eax, %r12d
xorl %r9d, %r9d
cmpl $0x3, %r13d
jne 0x3a7a6
movq 0x10(%r14), %rsi
movq %rbx, %rdi
callq 0x3ad06
movl %eax, %r9d
pushq $0x23
popq %rdx
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl %r15d, %ecx
movl %r12d, %r8d
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3a0a8
// File: /workspace/github_c_makefile_star2_O2/janet-lang[P]janet/src/core/peg.c
// Function: spec_capture_number
static void spec_capture_number(Builder *b, int32_t argc, const Janet *argv) {
    peg_arity(b, argc, 1, 3);
    Reserve r = reserve(b, 4);
    uint32_t base = 0;
    if (argc >= 2) {
        if (!janet_checktype(argv[1], JANET_NIL)) {
            if (!janet_checkint(argv[1])) goto error;
            base = (uint32_t) janet_unwrap_integer(argv[1]);
            if (base < 2 || base > 36) goto error;
        }
    }
    uint32_t tag = (argc == 3) ? emit_tag(b, argv[2]) : 0;
    uint32_t rule = peg_compile1(b, argv[0]);
    emit_3(r, RULE_CAPTURE_NUM, rule, base, tag);
    return;
error:
    peg_panicf(b, "expected integer between 2 and 36, got %v", argv[1]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %rbx
pushq $0x1
popq %rdx
pushq $0x3
popq %rcx
callq 0x3acb8
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0x39d6e
movq %rax, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
xorl %r12d, %r12d
movl $0x0, %r13d
cmpl $0x2, %r15d
jl 0x3a85f
movq 0x8(%r14), %rdi
movq %rdi, %rax
shrq $0x2f, %rax
xorl %r13d, %r13d
movl $0x0, %r12d
cmpl $0x1fff1, %eax          # imm = 0x1FFF1
je 0x3a84a
callq 0x45e2b
testl %eax, %eax
je 0x3a890
movsd 0x8(%r14), %xmm0
cvttsd2si %xmm0, %r12d
leal -0x25(%r12), %eax
cmpl $-0x23, %eax
jb 0x3a896
cmpl $0x3, %r15d
jne 0x3a85f
movq 0x10(%r14), %rsi
movq %rbx, %rdi
callq 0x3ad06
movl %eax, %r13d
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x39872
pushq $0x1f
popq %rdx
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl %eax, %ecx
movl %r12d, %r8d
movl %r13d, %r9d
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3a0a8
movq 0x8(%r14), %rsi
jmp 0x3a89b
movq %xmm0, %rsi
leaq 0x2994a(%rip), %rdi     # 0x641ec
xorl %eax, %eax
callq 0x3c0ed
movq %rbx, %rdi
movq %rax, %rsi
callq 0x39d47
// File: /workspace/github_c_makefile_star2_O2/janet-lang[P]janet/src/core/peg.c
// Function: spec_range
static void spec_range(Builder *b, int32_t argc, const Janet *argv) {
    peg_arity(b, argc, 1, -1);
    if (argc == 1) {
        Reserve r = reserve(b, 2);
        const uint8_t *str = peg_getrange(b, argv[0]);
        uint32_t arg = str[0] | (str[1] << 16);
        emit_1(r, RULE_RANGE, arg);
    } else {
        /* Compile as a set */
        Reserve r = reserve(b, 9);
        uint32_t bitmap[8] = {0};
        for (int32_t i = 0; i < argc; i++) {
            const uint8_t *str = peg_getrange(b, argv[i]);
            for (uint32_t c = str[0]; c <= str[1]; c++)
                bitmap_set(bitmap, c);
        }
        emit_rule(r, RULE_SET, 8, bitmap);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %rbx
pushq $0x1
popq %r12
pushq $-0x1
popq %rcx
movl %r12d, %edx
callq 0x3acb8
cmpl $0x1, %r15d
jne 0x3a936
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x39d6e
movq %rax, %r15
movq %rdx, %r12
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x3b138
movzbl (%rax), %edx
movzbl 0x1(%rax), %ecx
shll $0x10, %ecx
orl %edx, %ecx
pushq $0x3
popq %rdx
movq %r15, %rdi
movq %r12, %rsi
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x39e05
pushq $0x9
popq %rsi
movq %rbx, %rdi
callq 0x39d6e
movq %rax, -0x30(%rbp)
movq %rdx, -0x38(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x50(%rbp)
movaps %xmm0, -0x60(%rbp)
xorl %r13d, %r13d
testl %r15d, %r15d
cmovlel %r13d, %r15d
cmpq %r15, %r13
je 0x3a994
movq (%r14,%r13,8), %rsi
movq %rbx, %rdi
callq 0x3b138
movzbl (%rax), %ecx
movzbl 0x1(%rax), %eax
cmpl %eax, %ecx
ja 0x3a98f
movl %r12d, %edx
shll %cl, %edx
movl %ecx, %esi
shrl $0x3, %esi
andl $0x1c, %esi
orl %edx, -0x60(%rbp,%rsi)
incl %ecx
jmp 0x3a976
incq %r13
jmp 0x3a95e
pushq $0x4
popq %rdx
pushq $0x8
popq %rcx
leaq -0x60(%rbp), %r8
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x39fcb
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/janet-lang[P]janet/src/core/peg.c
// Function: spec_set
static void spec_set(Builder *b, int32_t argc, const Janet *argv) {
    peg_fixarity(b, argc, 1);
    Reserve r = reserve(b, 9);
    const uint8_t *str = peg_getset(b, argv[0]);
    uint32_t bitmap[8] = {0};
    for (int32_t i = 0; i < janet_string_length(str); i++)
        bitmap_set(bitmap, str[i]);
    emit_rule(r, RULE_SET, 8, bitmap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r13
movq %rdi, %r12
pushq $0x1
popq %rbx
movl %ebx, %edx
callq 0x3a02e
pushq $0x9
popq %rsi
movq %r12, %rdi
callq 0x39d6e
movq %rax, %r14
movq (%r13), %rdi
movq %rdi, %rax
shrq $0x2f, %rax
cmpl $0x1fff4, %eax          # imm = 0x1FFF4
jne 0x3aa51
movq %rdx, %r15
callq 0x4b1f1
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%rbp)
movaps %xmm0, -0x50(%rbp)
movslq -0x8(%rax), %rdx
xorl %esi, %esi
cmpq %rdx, %rsi
jge 0x3aa2d
movzbl (%rax,%rsi), %ecx
movl %ebx, %edi
shll %cl, %edi
shrl $0x5, %ecx
orl %edi, -0x50(%rbp,%rcx,4)
incq %rsi
jmp 0x3aa14
pushq $0x4
popq %rdx
pushq $0x8
popq %rcx
leaq -0x50(%rbp), %r8
movq %r14, %rdi
movq %r15, %rsi
callq 0x39fcb
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2981d(%rip), %rsi     # 0x64275
movq %r12, %rdi
callq 0x39d47
// File: /workspace/github_c_makefile_star2_O2/janet-lang[P]janet/src/core/peg.c
// Function: spec_split
static void spec_split(Builder *b, int32_t argc, const Janet *argv) {
    peg_fixarity(b, argc, 2);
    Reserve r = reserve(b, 3);
    uint32_t subrule1 = peg_compile1(b, argv[0]);
    uint32_t subrule2 = peg_compile1(b, argv[1]);
    emit_2(r, RULE_SPLIT, subrule1, subrule2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
pushq $0x2
popq %rdx
callq 0x3a02e
pushq $0x3
popq %rsi
movq %r14, %rdi
callq 0x39d6e
movq %rax, %r15
movq %rdx, %r12
movq (%rbx), %rsi
movq %r14, %rdi
callq 0x39872
movl %eax, %r13d
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x39872
pushq $0x22
popq %rdx
movq %r15, %rdi
movq %r12, %rsi
movl %r13d, %ecx
movl %eax, %r8d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3ae38
// File: /workspace/github_c_makefile_star2_O2/janet-lang[P]janet/src/core/peg.c
// Function: spec_onerule
static void spec_onerule(Builder *b, int32_t argc, const Janet *argv, uint32_t op) {
    peg_fixarity(b, argc, 1);
    Reserve r = reserve(b, 2);
    uint32_t rule = peg_compile1(b, argv[0]);
    emit_1(r, op, rule);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdx, %r14
movq %rdi, %r15
pushq $0x1
popq %rdx
callq 0x3a02e
pushq $0x2
popq %rsi
movq %r15, %rdi
callq 0x39d6e
movq %rax, %r12
movq %rdx, %r13
movq (%r14), %rsi
movq %r15, %rdi
callq 0x39872
movq %r12, %rdi
movq %r13, %rsi
movl %ebx, %edx
movl %eax, %ecx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x39e05
// File: /workspace/github_c_makefile_star2_O2/janet-lang[P]janet/src/core/peg.c
// Function: spec_tag1
static void spec_tag1(Builder *b, int32_t argc, const Janet *argv, uint32_t op) {
    peg_arity(b, argc, 0, 1);
    Reserve r = reserve(b, 2);
    uint32_t tag = (argc) ? emit_tag(b, argv[0]) : 0;
    (void) argv;
    emit_1(r, op, tag);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, -0x2c(%rbp)
movq %rdx, -0x38(%rbp)
movl %esi, %r12d
movq %rdi, %r15
xorl %r14d, %r14d
pushq $0x1
popq %rcx
xorl %edx, %edx
callq 0x3acb8
pushq $0x2
popq %rsi
movq %r15, %rdi
callq 0x39d6e
movq %rax, %r13
movq %rdx, %rbx
testl %r12d, %r12d
je 0x3ac99
movq -0x38(%rbp), %rax
movq (%rax), %rsi
movq %r15, %rdi
callq 0x3ad06
movl %eax, %r14d
movq %r13, %rdi
movq %rbx, %rsi
movl -0x2c(%rbp), %edx
movl %r14d, %ecx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x39e05
// File: /workspace/github_c_makefile_star2_O2/janet-lang[P]janet/src/core/peg.c
// Function: peg_arity
static void peg_arity(Builder *b, int32_t arity, int32_t min, int32_t max) {
    if (min >= 0 && arity < min)
        peg_panicf(b, "arity mismatch, expected at least %d, got %d", min, arity);
    if (max >= 0 && arity > max)
        peg_panicf(b, "arity mismatch, expected at most %d, got %d", max, arity);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %esi, %eax
movq %rdi, %rbx
cmpl %edx, %esi
jl 0x3acde
testl %ecx, %ecx
sets %dl
cmpl %ecx, %eax
setle %sil
orb %dl, %sil
je 0x3ace9
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x159dc(%rip), %rdi     # 0x506c1
movl %edx, %esi
jmp 0x3acf2
leaq 0x15a04(%rip), %rdi     # 0x506f4
movl %ecx, %esi
movl %eax, %edx
xorl %eax, %eax
callq 0x3c0ed
movq %rbx, %rdi
movq %rax, %rsi
callq 0x39d47
// File: /workspace/github_c_makefile_star2_O2/janet-lang[P]janet/src/core/peg.c
// Function: emit_tag
static uint32_t emit_tag(Builder *b, Janet t) {
    if (!janet_checktype(t, JANET_KEYWORD))
        peg_panicf(b, "expected keyword for capture tag, got %v", t);
    Janet check = janet_table_get(b->tags, t);
    if (janet_checktype(check, JANET_NIL)) {
        uint32_t tag = b->nexttag++;
        if (tag > 255) {
            peg_panic(b, "too many tags - up to 255 tags are supported per peg");
        }
        Janet val = janet_wrap_number(tag);
        janet_table_put(b->tags, t, val);
        return tag;
    } else {
        return (uint32_t) janet_unwrap_number(check);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rax
shrq $0x2f, %rax
cmpl $0x1fff6, %eax          # imm = 0x1FFF6
jne 0x3ad93
movabsq $-0x800000000000, %r15  # imm = 0xFFFF800000000000
movq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0x43c35
andq %rax, %r15
movabsq $-0x7800000000000, %rcx # imm = 0xFFF8800000000000
cmpq %rcx, %r15
jne 0x3ad7b
movl 0x34(%rbx), %r15d
leal 0x1(%r15), %eax
movl %eax, 0x34(%rbx)
cmpl $0x100, %r15d           # imm = 0x100
jae 0x3adaf
cvtsi2sd %r15d, %xmm0
callq 0x4b471
movq 0x10(%rbx), %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x43e19
jmp 0x3ad85
movq %rax, %xmm0
cvttsd2si %xmm0, %r15
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x293a6(%rip), %rdi     # 0x64140
movq %r14, %rsi
xorl %eax, %eax
callq 0x3c0ed
movq %rbx, %rdi
movq %rax, %rsi
callq 0x39d47
leaq 0x293b3(%rip), %rsi     # 0x64169
movq %rbx, %rdi
callq 0x39d47
// File: /workspace/github_c_makefile_star2_O2/janet-lang[P]janet/src/core/peg.c
// Function: spec_cap1
static void spec_cap1(Builder *b, int32_t argc, const Janet *argv, uint32_t op) {
    peg_arity(b, argc, 1, 2);
    Reserve r = reserve(b, 3);
    uint32_t tag = (argc == 2) ? emit_tag(b, argv[1]) : 0;
    uint32_t rule = peg_compile1(b, argv[0]);
    emit_2(r, op, rule, tag);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, -0x2c(%rbp)
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r14
pushq $0x1
popq %rdx
pushq $0x2
popq %rcx
callq 0x3acb8
pushq $0x3
popq %rsi
movq %r14, %rdi
callq 0x39d6e
movq %rax, -0x38(%rbp)
movq %rdx, %r13
xorl %ebx, %ebx
cmpl $0x2, %r12d
jne 0x3ae0e
movq 0x8(%r15), %rsi
movq %r14, %rdi
callq 0x3ad06
movl %eax, %ebx
movq (%r15), %rsi
movq %r14, %rdi
callq 0x39872
movq -0x38(%rbp), %rdi
movq %r13, %rsi
movl -0x2c(%rbp), %edx
movl %eax, %ecx
movl %ebx, %r8d
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3ae38
// File: /workspace/github_c_makefile_star2_O2/janet-lang[P]janet/src/core/peg.c
// Function: spec_variadic
static void spec_variadic(Builder *b, int32_t argc, const Janet *argv, uint32_t op) {
    uint32_t rule = janet_v_count(b->bytecode);
    janet_v_push(b->bytecode, op);
    janet_v_push(b->bytecode, argc);
    for (int32_t i = 0; i < argc; i++)
        janet_v_push(b->bytecode, 0);
    for (int32_t i = 0; i < argc; i++) {
        uint32_t rulei = peg_compile1(b, argv[i]);
        b->bytecode[rule + 2 + i] = rulei;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %r12d
movq %rdx, %rbx
movl %esi, %r15d
movq %rdi, %r14
movq 0x20(%rdi), %rax
testq %rax, %rax
je 0x3ae91
movl -0x4(%rax), %ecx
leal 0x2(%rcx), %edx
movl %edx, -0x2c(%rbp)
leal 0x1(%rcx), %edx
cmpl -0x8(%rax), %edx
jge 0x3ae97
jmp 0x3aeaf
pushq $0x2
popq %rcx
movl %ecx, -0x2c(%rbp)
pushq $0x1
popq %rsi
pushq $0x4
popq %rdx
movq %rax, %rdi
callq 0x4799c
movq %rax, 0x20(%r14)
movl -0x4(%rax), %ecx
leal 0x1(%rcx), %edx
movl %edx, -0x4(%rax)
movslq %ecx, %rcx
movl %r12d, (%rax,%rcx,4)
movl -0x4(%rax), %ecx
leal 0x1(%rcx), %edx
cmpl -0x8(%rax), %edx
jl 0x3aedc
pushq $0x1
popq %rsi
pushq $0x4
popq %rdx
movq %rax, %rdi
callq 0x4799c
movq %rax, 0x20(%r14)
movl -0x4(%rax), %ecx
leal 0x1(%rcx), %edx
movl %edx, -0x4(%rax)
movslq %ecx, %rcx
xorl %r13d, %r13d
testl %r15d, %r15d
cmovgl %r15d, %r13d
movl %r15d, (%rax,%rcx,4)
pushq $0x1
popq %r15
pushq $0x4
popq %r12
movl %r13d, -0x30(%rbp)
subl $0x1, %r13d
jb 0x3af31
movl -0x4(%rax), %ecx
leal 0x1(%rcx), %edx
cmpl -0x8(%rax), %edx
jl 0x3af25
movq %rax, %rdi
movl %r15d, %esi
movl %r12d, %edx
callq 0x4799c
movq %rax, 0x20(%r14)
movl -0x4(%rax), %ecx
leal 0x1(%rcx), %edx
movl %edx, -0x4(%rax)
movslq %ecx, %rcx
andl $0x0, (%rax,%rcx,4)
jmp 0x3aefc
movl -0x30(%rbp), %r15d
movl -0x2c(%rbp), %r12d
xorl %r13d, %r13d
cmpq %r13, %r15
je 0x3af5d
movq (%rbx,%r13,8), %rsi
movq %r14, %rdi
callq 0x39872
movq 0x20(%r14), %rcx
leal (%r12,%r13), %edx
movl %eax, (%rcx,%rdx,4)
incq %r13
jmp 0x3af3c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/janet-lang[P]janet/src/core/peg.c
// Function: spec_repeater
static void spec_repeater(Builder *b, int32_t argc, const Janet *argv, int32_t min) {
    peg_fixarity(b, argc, 1);
    Reserve r = reserve(b, 4);
    uint32_t subrule = peg_compile1(b, argv[0]);
    emit_3(r, RULE_BETWEEN, min, UINT32_MAX, subrule);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdx, %r14
movq %rdi, %r15
pushq $0x1
popq %rdx
callq 0x3a02e
pushq $0x4
popq %rsi
movq %r15, %rdi
callq 0x39d6e
movq %rax, %r12
movq %rdx, %r13
movq (%r14), %rsi
movq %r15, %rdi
callq 0x39872
pushq $0xb
popq %rdx
pushq $-0x1
popq %r8
movq %r12, %rdi
movq %r13, %rsi
movl %ebx, %ecx
movl %eax, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3a0a8
// File: /workspace/github_c_makefile_star2_O2/janet-lang[P]janet/src/core/peg.c
// Function: spec_branch
static void spec_branch(Builder *b, int32_t argc, const Janet *argv, uint32_t rule) {
    peg_fixarity(b, argc, 2);
    Reserve r = reserve(b, 3);
    uint32_t rule_a = peg_compile1(b, argv[0]);
    uint32_t rule_b = peg_compile1(b, argv[1]);
    emit_2(r, rule, rule_a, rule_b);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, -0x2c(%rbp)
movq %rdx, %r14
movq %rdi, %r15
pushq $0x2
popq %rdx
callq 0x3a02e
pushq $0x3
popq %rsi
movq %r15, %rdi
callq 0x39d6e
movq %rax, %r12
movq %rdx, %r13
movq (%r14), %rsi
movq %r15, %rdi
callq 0x39872
movl %eax, %ebx
movq 0x8(%r14), %rsi
movq %r15, %rdi
callq 0x39872
movq %r12, %rdi
movq %r13, %rsi
movl -0x2c(%rbp), %edx
movl %ebx, %ecx
movl %eax, %r8d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3ae38
// File: /workspace/github_c_makefile_star2_O2/janet-lang[P]janet/src/core/peg.c
// Function: spec_readint
static void spec_readint(Builder *b, int32_t argc, const Janet *argv, uint32_t mask) {
    peg_arity(b, argc, 1, 2);
    Reserve r = reserve(b, 3);
    uint32_t tag = (argc == 2) ? emit_tag(b, argv[1]) : 0;
    int32_t width = peg_getnat(b, argv[0]);
    if ((width < 0) || (width > JANET_MAX_READINT_WIDTH)) {
        peg_panicf(b, "width must be between 0 and %d, got %d", JANET_MAX_READINT_WIDTH, width);
    }
    emit_2(r, RULE_READINT, mask | ((uint32_t) width), tag);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, -0x2c(%rbp)
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %rbx
pushq $0x1
popq %rdx
pushq $0x2
popq %rcx
callq 0x3acb8
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x39d6e
movq %rax, -0x38(%rbp)
movq %rdx, %r13
xorl %r14d, %r14d
cmpl $0x2, %r12d
jne 0x3b0e5
movq 0x8(%r15), %rsi
movq %rbx, %rdi
callq 0x3ad06
movl %eax, %r14d
movq (%r15), %rsi
movq %rbx, %rdi
callq 0x3a071
cmpl $0x9, %eax
jae 0x3b11a
orl -0x2c(%rbp), %eax
pushq $0x1b
popq %rdx
movq -0x38(%rbp), %rdi
movq %r13, %rsi
movl %eax, %ecx
movl %r14d, %r8d
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3ae38
leaq 0x290a4(%rip), %rdi     # 0x641c5
pushq $0x8
popq %rsi
movl %eax, %edx
xorl %eax, %eax
callq 0x3c0ed
movq %rbx, %rdi
movq %rax, %rsi
callq 0x39d47
// File: /workspace/github_c_makefile_star2_O2/janet-lang[P]janet/src/core/peg.c
// Function: peg_getrange
static const uint8_t *peg_getrange(Builder *b, Janet x) {
    if (!janet_checktype(x, JANET_STRING))
        peg_panic(b, "expected string for character range");
    const uint8_t *str = janet_unwrap_string(x);
    if (janet_string_length(str) != 2)
        peg_panicf(b, "expected string to have length 2, got %v", x);
    if (str[1] < str[0])
        peg_panicf(b, "range %v is empty", x);
    return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq %rsi, %rax
shrq $0x2f, %rax
cmpl $0x1fff4, %eax          # imm = 0x1FFF4
jne 0x3b16d
movq %rsi, %r14
movq %rsi, %rdi
callq 0x4b1f1
cmpl $0x2, -0x8(%rax)
jne 0x3b17c
movb 0x1(%rax), %cl
cmpb (%rax), %cl
jb 0x3b185
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x290a2(%rip), %rsi     # 0x64216
movq %rbx, %rdi
callq 0x39d47
leaq 0x290b7(%rip), %rdi     # 0x6423a
jmp 0x3b18c
leaq 0x290d7(%rip), %rdi     # 0x64263
movq %r14, %rsi
xorl %eax, %eax
callq 0x3c0ed
movq %rbx, %rdi
movq %rax, %rsi
callq 0x39d47
// File: /workspace/github_c_makefile_star2_O2/janet-lang[P]janet/src/core/peg.c
// Function: cap_save
static CapState cap_save(PegState *s) {
    CapState cs;
    cs.scratch = s->scratch->count;
    cs.cap = s->captures->count;
    cs.tcap = s->tagged_captures->count;
    return cs;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x28(%rdi), %rax
movq 0x30(%rdi), %rcx
movl 0x10(%rcx), %edx
movl 0x10(%rax), %ecx
movq 0x40(%rdi), %rax
movl 0x10(%rax), %eax
shlq $0x20, %rax
orq %rcx, %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/janet-lang[P]janet/src/core/peg.c
// Function: pushcap
static void pushcap(PegState *s, Janet capture, uint32_t tag) {
    if (s->mode == PEG_MODE_ACCUMULATE) {
        janet_to_string_b(s->scratch, capture);
    }
    if (s->mode == PEG_MODE_NORMAL) {
        janet_array_push(s->captures, capture);
    }
    if (s->has_backref) {
        janet_array_push(s->tagged_captures, capture);
        janet_buffer_push_u8(s->tags, tag);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
movl 0x68(%rdi), %eax
cmpl $0x1, %eax
jne 0x3b1ed
movq 0x30(%r14), %rdi
movq %r15, %rsi
callq 0x3b300
movl 0x68(%r14), %eax
testl %eax, %eax
jne 0x3b1fd
movq 0x28(%r14), %rdi
movq %r15, %rsi
callq 0x131d2
cmpl $0x0, 0x64(%r14)
je 0x3b226
movq 0x40(%r14), %rdi
movq %r15, %rsi
callq 0x131d2
movq 0x38(%r14), %rdi
movzbl %bl, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x161be
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/janet-lang[P]janet/src/core/pp.c
// Function: string_description_b
static void string_description_b(JanetBuffer *buffer, const char *title, void *pointer) {
    janet_buffer_ensure(buffer, buffer->count + BUFSIZE, 2);
    uint8_t *c = buffer->data + buffer->count;
    int32_t i;
    union {
        uint8_t bytes[sizeof(void *)];
        void *p;
    } pbuf;

    pbuf.p = pointer;
    *c++ = '<';
    /* Maximum of 32 bytes for abstract type name */
    for (i = 0; i < 32 && title[i]; ++i)
        *c++ = ((uint8_t *)title) [i];
    *c++ = ' ';
    *c++ = '0';
    *c++ = 'x';
#if defined(JANET_64)
#define POINTSIZE 6
#else
#define POINTSIZE (sizeof(void *))
#endif
    for (i = POINTSIZE; i > 0; --i) {
        uint8_t byte = pbuf.bytes[i - 1];
        *c++ = HEX(byte >> 4);
        *c++ = HEX(byte & 0xF);
    }
    *c++ = '>';
    buffer->count = (int32_t)(c - buffer->data);
#undef POINTSIZE
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movl 0x10(%rdi), %esi
addl $0x40, %esi
pushq $0x2
popq %rdx
callq 0x15f9b
movq 0x18(%rbx), %rdx
movslq 0x10(%rbx), %rax
leaq (%rdx,%rax), %rcx
movq %r15, -0x20(%rbp)
movb $0x3c, (%rdx,%rax)
addl %eax, %edx
pushq $-0x5
popq %rax
subl %edx, %eax
xorl %edx, %edx
cmpq $0x20, %rdx
je 0x3b5f9
movb (%r14,%rdx), %sil
testb %sil, %sil
je 0x3b5f9
movb %sil, 0x1(%rcx,%rdx)
incq %rdx
jmp 0x3b5e0
addq %rdx, %rcx
addq $0x4, %rcx
movw $0x3020, -0x3(%rcx)     # imm = 0x3020
movb $0x78, -0x1(%rcx)
subl %edx, %eax
pushq $0x6
popq %rdi
leaq 0x2bfaa(%rip), %rdx     # 0x675c0
movq %rdi, %rsi
subq $0x1, %rsi
jb 0x3b649
movzbl -0x21(%rbp,%rdi), %edi
movl %edi, %r8d
shrl $0x4, %r8d
movb (%rdx,%r8), %r8b
movb %r8b, (%rcx)
andl $0xf, %edi
movb (%rdx,%rdi), %dil
movb %dil, 0x1(%rcx)
addq $0x2, %rcx
addl $-0x2, %eax
movq %rsi, %rdi
jmp 0x3b619
movb $0x3e, (%rcx)
addl 0x18(%rbx), %eax
negl %eax
movl %eax, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/janet-lang[P]janet/src/core/pp.c
// Function: janet_description_b
void janet_description_b(JanetBuffer *buffer, Janet x) {
    switch (janet_type(x)) {
        default:
            break;
        case JANET_NIL:
            janet_buffer_push_cstring(buffer, "nil");
            return;
        case JANET_KEYWORD:
            janet_buffer_push_u8(buffer, ':');
            break;
        case JANET_STRING:
            janet_escape_string_b(buffer, janet_unwrap_string(x));
            return;
        case JANET_BUFFER: {
            JanetBuffer *b = janet_unwrap_buffer(x);
            janet_escape_buffer_b(buffer, b);
            return;
        }
        case JANET_ABSTRACT: {
            JanetAbstract p = janet_unwrap_abstract(x);
            const JanetAbstractType *t = janet_abstract_type(p);
            if (t->tostring != NULL) {
                janet_buffer_push_cstring(buffer, "<");
                janet_buffer_push_cstring(buffer, t->name);
                janet_buffer_push_cstring(buffer, " ");
                t->tostring(p, buffer);
                janet_buffer_push_cstring(buffer, ">");
            } else {
                string_description_b(buffer, t->name, p);
            }
            return;
        }
    }
    janet_to_string_b(buffer, x);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rsi, %xmm0
movq %rsi, %rcx
shrq $0x2f, %rcx
andl $0xf, %ecx
xorl %eax, %eax
ucomisd %xmm0, %xmm0
movq %rdi, %rbx
cmovpl %ecx, %eax
cmpl $0xe, %eax
je 0x3b72b
cmpl $0x4, %eax
je 0x3b6b0
cmpl $0x6, %eax
je 0x3b70b
cmpl $0xb, %eax
je 0x3b6c3
cmpl $0x1, %eax
jne 0x3b716
leaq 0x1f01b(%rip), %rsi     # 0x5a6c6
jmp 0x3b77b
movq %r14, %rdi
callq 0x4b1f1
movl -0x8(%rax), %edx
movq %rbx, %rdi
movq %rax, %rsi
jmp 0x3b6fc
movq %r14, %rdi
callq 0x4b1f1
movq %rax, %r14
cmpq %rbx, %rax
jne 0x3b6e6
imull $0x6, 0x10(%r14), %esi
addl $0x3, %esi
pushq $0x1
popq %rdx
movq %r14, %rdi
callq 0x15f9b
pushq $0x40
popq %rsi
movq %rbx, %rdi
callq 0x161be
movq 0x18(%r14), %rsi
movl 0x10(%r14), %edx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3c58f
pushq $0x3a
popq %rsi
movq %rbx, %rdi
callq 0x161be
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3b300
movq %r14, %rdi
callq 0x4b1f1
movq %rax, %r14
movq -0x10(%rax), %r15
cmpq $0x0, 0x38(%r15)
je 0x3b78d
leaq 0x2c58d(%rip), %rsi     # 0x67cd5
movq %rbx, %rdi
callq 0x1614c
movq (%r15), %rsi
movq %rbx, %rdi
callq 0x1614c
leaq 0x27e76(%rip), %rsi     # 0x635d8
movq %rbx, %rdi
callq 0x1614c
movq %r14, %rdi
movq %rbx, %rsi
callq *0x38(%r15)
leaq 0x28929(%rip), %rsi     # 0x640a4
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1614c
movq (%r15), %rsi
movq %rbx, %rdi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3b5a2
// File: /workspace/github_c_makefile_star2_O2/janet-lang[P]janet/src/core/pp.c
// Function: janet_description
const uint8_t *janet_description(Janet x) {
    JanetBuffer b;
    janet_buffer_init(&b, 10);
    janet_description_b(&b, x);
    const uint8_t *ret = janet_string(b.data, b.count);
    janet_buffer_deinit(&b);
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq -0x30(%rbp), %r14
pushq $0xa
popq %rsi
movq %r14, %rdi
callq 0x15e80
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3b65f
movq 0x18(%r14), %rdi
movl 0x10(%r14), %esi
callq 0x41116
movq %rax, %rbx
movq %r14, %rdi
callq 0x15f62
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/janet-lang[P]janet/src/core/pp.c
// Function: janet_to_string
const uint8_t *janet_to_string(Janet x) {
    switch (janet_type(x)) {
        default: {
            JanetBuffer b;
            janet_buffer_init(&b, 10);
            janet_to_string_b(&b, x);
            const uint8_t *ret = janet_string(b.data, b.count);
            janet_buffer_deinit(&b);
            return ret;
        }
        case JANET_BUFFER:
            return janet_string(janet_unwrap_buffer(x)->data, janet_unwrap_buffer(x)->count);
        case JANET_STRING:
        case JANET_SYMBOL:
        case JANET_KEYWORD:
            return janet_unwrap_string(x);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq %rdi, %xmm0
movq %rdi, %rcx
shrq $0x2f, %rcx
andl $0xf, %ecx
xorl %eax, %eax
ucomisd %xmm0, %xmm0
cmovpl %ecx, %eax
leal -0x4(%rax), %ecx
cmpl $0x3, %ecx
jae 0x3b82f
movq %rbx, %rdi
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x4b1f1
cmpl $0xb, %eax
jne 0x3b85b
movq %rbx, %rdi
callq 0x4b1f1
movq 0x18(%rax), %r14
movq %rbx, %rdi
callq 0x4b1f1
movl 0x10(%rax), %esi
movq %r14, %rdi
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x41116
leaq -0x30(%rbp), %r14
pushq $0xa
popq %rsi
movq %r14, %rdi
callq 0x15e80
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3b300
movq 0x18(%r14), %rdi
movl 0x10(%r14), %esi
callq 0x41116
movq %rax, %rbx
movq %r14, %rdi
callq 0x15f62
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/janet-lang[P]janet/src/core/pp.c
// Function: janet_pretty_
static JanetBuffer *janet_pretty_(JanetBuffer *buffer, int depth, int flags, Janet x, int32_t startlen) {
    struct pretty S;
    if (NULL == buffer) {
        buffer = janet_buffer(0);
    }
    S.buffer = buffer;
    S.depth = depth;
    S.indent = 0;
    S.flags = flags;
    S.bufstartlen = startlen;
    S.keysort_capacity = 0;
    S.keysort_buffer = NULL;
    S.keysort_start = 0;
    janet_table_init(&S.seen, 10);
    janet_pretty_one(&S, x, 0);
    janet_table_deinit(&S.seen);
    return S.buffer;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %r8d, %r14d
movq %rcx, %rbx
movl %edx, %r15d
movl %esi, %r12d
testq %rdi, %rdi
jne 0x3b8da
xorl %edi, %edi
callq 0x15f78
movq %rax, %rdi
leaq -0x58(%rbp), %r13
movq %rdi, -0x28(%r13)
movl %r12d, -0x20(%r13)
andl $0x0, -0x1c(%r13)
movl %r15d, -0x18(%r13)
movl %r14d, -0x14(%r13)
xorps %xmm0, %xmm0
movups %xmm0, -0x10(%r13)
pushq $0xa
popq %rsi
movq %r13, %rdi
callq 0x43ac0
leaq -0x80(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x3c6e7
movq %r13, %rdi
callq 0x43b70
movq (%r14), %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/janet-lang[P]janet/src/core/pp.c
// Function: janet_jdn_
static JanetBuffer *janet_jdn_(JanetBuffer *buffer, int depth, Janet x, int32_t startlen) {
    struct pretty S;
    if (NULL == buffer) {
        buffer = janet_buffer(0);
    }
    S.buffer = buffer;
    S.depth = depth;
    S.indent = 0;
    S.flags = 0;
    S.bufstartlen = startlen;
    S.keysort_capacity = 0;
    S.keysort_buffer = NULL;
    S.keysort_start = 0;
    janet_table_init(&S.seen, 10);
    int res = print_jdn_one(&S, x, depth);
    janet_table_deinit(&S.seen);
    if (res) {
        janet_panic("could not print to jdn format");
    }
    return S.buffer;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movl %ecx, %r15d
movq %rdx, %r14
movl %esi, %ebx
testq %rdi, %rdi
jne 0x3b96a
xorl %edi, %edi
callq 0x15f78
movq %rax, %rdi
leaq -0x50(%rbp), %r12
movq %rdi, -0x28(%r12)
movl %ebx, -0x20(%r12)
andq $0x0, -0x1c(%r12)
movl %r15d, -0x14(%r12)
xorps %xmm0, %xmm0
movups %xmm0, -0x10(%r12)
pushq $0xa
popq %rsi
movq %r12, %rdi
callq 0x43ac0
leaq -0x78(%rbp), %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x3ce82
movl %eax, %ebx
movq %r12, %rdi
callq 0x43b70
testl %ebx, %ebx
jne 0x3b9c4
movq -0x78(%rbp), %rax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x28d05(%rip), %rdi     # 0x646d0
callq 0x177b1
// File: /workspace/github_c_makefile_star2_O2/janet-lang[P]janet/src/core/pp.c
// Function: typestr
static const char *typestr(Janet x) {
    JanetType t = janet_type(x);
    return (t == JANET_ABSTRACT)
           ? janet_abstract_type(janet_unwrap_abstract(x))->name
           : janet_type_names[t];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %xmm0
movq %rdi, %rcx
shrq $0x2f, %rcx
andl $0xf, %ecx
xorl %eax, %eax
ucomisd %xmm0, %xmm0
cmovpl %ecx, %eax
cmpl $0xe, %eax
jne 0x3c0de
callq 0x4b1f1
movq -0x10(%rax), %rax
jmp 0x3c0e8
shll $0x3, %eax
addq 0x43eb8(%rip), %rax     # 0x7ffa0
movq (%rax), %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/janet-lang[P]janet/src/core/pp.c
// Function: janet_formatc
const uint8_t *janet_formatc(const char *format, ...) {
    va_list args;
    const uint8_t *ret;
    JanetBuffer buffer;
    int32_t len = 0;

    /* Calculate length, init buffer and args */
    while (format[len]) len++;
    janet_buffer_init(&buffer, len);
    va_start(args, format);

    /* Run format */
    janet_formatbv(&buffer, format, args);

    /* Iterate length */
    va_end(args);

    ret = janet_string(buffer.data, buffer.count);
    janet_buffer_deinit(&buffer);
    return 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 0x3c14e
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 0x3c150
decl %esi
leaq -0x100(%rbp), %r14
movq %r14, %rdi
callq 0x15e80
movabsq $0x3000000008, %rax     # imm = 0x3000000008
leaq -0x30(%rbp), %rdx
movq %rax, (%rdx)
leaq 0x10(%rbp), %rax
movq %rax, 0x8(%rdx)
leaq -0xe0(%rbp), %rax
movq %rax, 0x10(%rdx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3b9d0
movq 0x18(%r14), %rdi
movl 0x10(%r14), %esi
callq 0x41116
movq %rax, %rbx
movq %r14, %rdi
callq 0x15f62
movq %rbx, %rax
addq $0xf0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/janet-lang[P]janet/src/core/pp.c
// Function: print_newline
static void print_newline(struct pretty *S, int just_a_space) {
    int i;
    if (just_a_space || (S->flags & JANET_PRETTY_ONELINE)) {
        janet_buffer_push_u8(S->buffer, ' ');
        return;
    }
    janet_buffer_push_u8(S->buffer, '\n');
    for (i = 0; i < S->indent; i++) {
        janet_buffer_push_u8(S->buffer, ' ');
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
jne 0x3ce62
testb $0x2, 0x10(%rbx)
jne 0x3ce62
movq (%rbx), %rdi
pushq $0xa
popq %rsi
callq 0x161be
xorl %r15d, %r15d
pushq $0x20
popq %r14
cmpl 0xc(%rbx), %r15d
jge 0x3ce77
movq (%rbx), %rdi
movl %r14d, %esi
callq 0x161be
incl %r15d
jmp 0x3ce4c
movq (%rbx), %rdi
pushq $0x20
popq %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x161be
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/janet-lang[P]janet/src/core/regalloc.c
// Function: janetc_regalloc_clone
void janetc_regalloc_clone(JanetcRegisterAllocator *dest, JanetcRegisterAllocator *src) {
    size_t size;
    dest->count = src->count;
    dest->capacity = src->capacity;
    dest->max = src->max;
    size = sizeof(uint32_t) * (size_t) dest->capacity;
    dest->regtemps = 0;
    if (size) {
        dest->chunks = janet_malloc(size);
        if (!dest->chunks) {
            JANET_OUT_OF_MEMORY;
        }
        memcpy(dest->chunks, src->chunks, size);
    } else {
        dest->chunks = NULL;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r15
movl 0x8(%rsi), %eax
movl %eax, 0x8(%rdi)
movslq 0xc(%rsi), %r14
movl %r14d, 0xc(%rdi)
movl 0x10(%rsi), %eax
andl $0x0, 0x14(%rdi)
movl %eax, 0x10(%rdi)
testq %r14, %r14
je 0x3d333
movq %rsi, %rbx
shlq $0x2, %r14
movq %r14, %rdi
callq 0x12760
movq %rax, (%r15)
testq %rax, %rax
je 0x3d342
movq (%rbx), %rsi
movq %rax, %rdi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x12670
andq $0x0, (%r15)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x42ca7(%rip), %rax     # 0x7fff0
movq (%rax), %rdi
leaq 0xfcb1(%rip), %rsi      # 0x4d004
leaq 0x27412(%rip), %rdx     # 0x6476c
pushq $0x4d
popq %rcx
xorl %eax, %eax
callq 0x125e0
pushq $0x1
popq %rdi
callq 0x12a60
// File: /workspace/github_c_makefile_star2_O2/janet-lang[P]janet/src/core/regalloc.c
// Function: janetc_regalloc_touch
void janetc_regalloc_touch(JanetcRegisterAllocator *ra, int32_t reg) {
    int32_t chunk = reg >> 5;
    int32_t bit = reg & 0x1F;
    while (chunk >= ra->count) pushchunk(ra);
    ra->chunks[chunk] |= ithbit(bit);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
movl %esi, %r15d
sarl $0x5, %r15d
cmpl 0x8(%rbx), %r15d
jl 0x3d393
movq %rbx, %rdi
callq 0x3d3af
jmp 0x3d383
pushq $0x1
popq %rax
movl %r14d, %ecx
shll %cl, %eax
movq (%rbx), %rcx
movslq %r15d, %rdx
orl %eax, (%rcx,%rdx,4)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/janet-lang[P]janet/src/core/regalloc.c
// Function: pushchunk
static void pushchunk(JanetcRegisterAllocator *ra) {
    /* Registers 240-255 are always allocated (reserved) */
    uint32_t chunk = ra->count == 7 ? 0xFFFF0000 : 0;
    int32_t newcount = ra->count + 1;
    if (newcount > ra->capacity) {
        int32_t newcapacity = newcount * 2;
        ra->chunks = janet_realloc(ra->chunks, (size_t) newcapacity * sizeof(uint32_t));
        if (!ra->chunks) {
            JANET_OUT_OF_MEMORY;
        }
        ra->capacity = newcapacity;
    }
    ra->chunks[ra->count] = chunk;
    ra->count = newcount;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq 0x8(%rdi), %r15
movq %r15, %r14
incq %r14
movq (%rdi), %rax
cmpl 0xc(%rdi), %r15d
jge 0x3d3d4
movl %r15d, %ecx
jmp 0x3d3f6
leaq (,%r14,8), %rsi
movq %rax, %rdi
callq 0x12840
movq %rax, (%rbx)
testq %rax, %rax
je 0x3d41d
leal (%r14,%r14), %ecx
movl %ecx, 0xc(%rbx)
movl 0x8(%rbx), %ecx
xorl %edx, %edx
cmpl $0x7, %r15d
setne %dl
shll $0x10, %edx
addl $0xffff0000, %edx       # imm = 0xFFFF0000
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl %r14d, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x42bcc(%rip), %rax     # 0x7fff0
movq (%rax), %rdi
leaq 0xfbd6(%rip), %rsi      # 0x4d004
leaq 0x27337(%rip), %rdx     # 0x6476c
pushq $0x5e
popq %rcx
xorl %eax, %eax
callq 0x125e0
pushq $0x1
popq %rdi
callq 0x12a60
// File: /workspace/github_c_makefile_star2_O2/janet-lang[P]janet/src/core/regalloc.c
// Function: janetc_regalloc_1
int32_t janetc_regalloc_1(JanetcRegisterAllocator *ra) {
    /* Get the nth bit in the array */
    int32_t bit, chunk, nchunks, reg;
    bit = -1;
    nchunks = ra->count;
    for (chunk = 0; chunk < nchunks; chunk++) {
        uint32_t block = ra->chunks[chunk];
        if (block == 0xFFFFFFFF) continue;
        bit = count_trailing_ones(block);
        break;
    }
    /* No reg found */
    if (bit == -1) {
        pushchunk(ra);
        bit = 0;
        chunk = nchunks;
    }
    /* set the bit at index bit in chunk */
    ra->chunks[chunk] |= ithbit(bit);
    reg = (chunk << 5) + bit;
    if (reg > ra->max)
        ra->max = reg;
    return reg;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x8(%rdi), %r14d
xorl %eax, %eax
testl %r14d, %r14d
movl $0x0, %ecx
cmovgl %r14d, %ecx
cmpq %rax, %rcx
je 0x3d478
movq (%rbx), %rdx
movl (%rdx,%rax,4), %edx
cmpl $-0x1, %edx
jne 0x3d484
incq %rax
jmp 0x3d463
movq %rbx, %rdi
callq 0x3d3af
xorl %ecx, %ecx
jmp 0x3d48c
notl %edx
bsfl %edx, %ecx
movl %eax, %r14d
pushq $0x1
popq %rdx
shll %cl, %edx
movq (%rbx), %rsi
movslq %r14d, %rax
orl %edx, (%rsi,%rax,4)
shll $0x5, %eax
orl %ecx, %eax
cmpl 0x10(%rbx), %eax
jle 0x3d4a7
movl %eax, 0x10(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/janet-lang[P]janet/src/core/regalloc.c
// Function: janetc_regalloc_check
int janetc_regalloc_check(JanetcRegisterAllocator *ra, int32_t reg) {
    int32_t chunk = reg >> 5;
    int32_t bit = reg & 0x1F;
    while (chunk >= ra->count) pushchunk(ra);
    return !!(ra->chunks[chunk] & ithbit(bit));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl %esi, %r15d
sarl $0x5, %r15d
cmpl 0x8(%r14), %r15d
jl 0x3d4ee
movq %r14, %rdi
callq 0x3d3af
jmp 0x3d4de
movq (%r14), %rax
movslq %r15d, %rcx
movl (%rax,%rcx,4), %ecx
xorl %eax, %eax
btl %ebx, %ecx
setb %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/janet-lang[P]janet/src/core/regalloc.c
// Function: janetc_regalloc_temp
int32_t janetc_regalloc_temp(JanetcRegisterAllocator *ra, JanetcRegisterTemp nth) {
    int32_t oldmax = ra->max;
    if (ra->regtemps & (1 << nth)) {
        JANET_EXIT("regtemp already allocated");
    }
    ra->regtemps |= 1 << nth;
    int32_t reg = janetc_regalloc_1(ra);
    if (reg > 0xFF) {
        reg = 0xF0 + nth;
        ra->max = (reg > oldmax) ? reg : oldmax;
    }
    return reg;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movl 0x14(%rdi), %eax
pushq $0x1
popq %rdx
movl %ebx, %ecx
shll %cl, %edx
btl %esi, %eax
jb 0x3d55b
movq %rdi, %r14
movl 0x10(%rdi), %r15d
orl %edx, %eax
movl %eax, 0x14(%rdi)
callq 0x3d447
cmpl $0x100, %eax            # imm = 0x100
jl 0x3d550
addl $0xf0, %ebx
cmpl %r15d, %ebx
cmovgl %ebx, %r15d
movl %r15d, 0x10(%r14)
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x42a8e(%rip), %rax     # 0x7fff0
movq (%rax), %rdi
leaq 0x12aa4(%rip), %rsi     # 0x50010
leaq 0x271f9(%rip), %rcx     # 0x6476c
leaq 0x27206(%rip), %r8      # 0x64780
movl $0x9e, %edx
xorl %eax, %eax
callq 0x125e0
callq 0x12100
// File: /workspace/github_c_makefile_star2_O2/janet-lang[P]janet/src/core/run.c
// Function: janet_loop_fiber
int janet_loop_fiber(JanetFiber *fiber) {
    int status;
#ifdef JANET_EV
    janet_schedule(fiber, janet_wrap_nil());
    janet_loop();
    status = janet_fiber_status(fiber);
#else
    Janet out;
    status = janet_continue(fiber, janet_wrap_nil(), &out);
    if (status != JANET_SIGNAL_OK && status != JANET_SIGNAL_EVENT) {
        janet_stacktrace_ext(fiber, out, "");
    }
#endif
    return status;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movabsq $-0x77fffffffffff, %rdi # imm = 0xFFF8800000000001
callq 0x4b313
movq %rbx, %rdi
movq %rax, %rsi
callq 0x209ca
callq 0x22d74
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x27553
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/janet-lang[P]janet/src/core/specials.c
// Function: janetc_def
static JanetSlot janetc_def(JanetFopts opts, int32_t argn, const Janet *argv) {
    JanetCompiler *c = opts.compiler;
    JanetTable *attr_table = handleattr(c, "def", argn, argv);
    if (c->result.status == JANET_COMPILE_ERROR) {
        return janetc_cslot(janet_wrap_nil());
    }
    opts.flags &= ~JANET_FOPTS_HINT;
    SlotHeadPair *into = NULL;
    into = dohead_destructure(c, into, opts, argv[0], argv[argn - 1]);
    if (c->result.status == JANET_COMPILE_ERROR) {
        janet_v_free(into);
        return janetc_cslot(janet_wrap_nil());
    }
    JanetSlot ret;
    janet_assert(janet_v_count(into) > 0, "bad destructure");
    for (int32_t i = 0; i < janet_v_count(into); i++) {
        destructure(c, into[i].lhs, into[i].rhs, defleaf, attr_table);
        ret = into[i].rhs;
    }
    janet_v_free(into);
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r12
movl %esi, %r13d
movq %rdi, %rbx
movq 0x10(%rbp), %r14
leaq 0x26d6b(%rip), %rsi     # 0x64b3d
movq %r14, %rdi
movl %r13d, %edx
movq %r12, %rcx
callq 0x3fa06
movq %rax, -0x30(%rbp)
cmpl $0x1, 0x48(%r14)
je 0x3de3d
leaq 0x10(%rbp), %rax
andb $-0x3, 0x22(%rax)
movslq %r13d, %rcx
movq (%r12), %rdx
movq -0x8(%r12,%rcx,8), %rcx
movq 0x20(%rax), %rsi
movq %rsi, 0x20(%rsp)
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %r14, %rdi
xorl %esi, %esi
callq 0x3d9c8
movq %rax, %r12
cmpl $0x1, 0x48(%r14)
jne 0x3de59
testq %r12, %r12
je 0x3de3d
addq $-0x8, %r12
movq %r12, %rdi
callq 0x298c1
movabsq $-0x77fffffffffff, %rdi # imm = 0xFFF8800000000001
callq 0x4b313
movq %rbx, %rdi
movq %rax, %rsi
callq 0x19f5c
jmp 0x3dec9
testq %r12, %r12
je 0x3dedb
movl -0x4(%r12), %eax
testl %eax, %eax
jle 0x3dedb
leaq 0x8(%r12), %r13
xorl %r15d, %r15d
cltq
cmpq %rax, %r15
jge 0x3debd
movq -0x8(%r13), %rsi
movq 0x10(%r13), %rax
movq %rax, 0x10(%rsp)
movups (%r13), %xmm0
movups %xmm0, (%rsp)
movq %r14, %rdi
leaq 0x23be(%rip), %rdx      # 0x40254
movq -0x30(%rbp), %rcx
callq 0x3fb99
movq 0x10(%r13), %rax
movq %rax, 0x10(%rbx)
movups (%r13), %xmm0
movups %xmm0, (%rbx)
incq %r15
movl -0x4(%r12), %eax
addq $0x20, %r13
jmp 0x3de6f
addq $-0x8, %r12
movq %r12, %rdi
callq 0x298c1
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x4210e(%rip), %rax     # 0x7fff0
movq (%rax), %rdi
leaq 0x12124(%rip), %rsi     # 0x50010
leaq 0x2697a(%rip), %rcx     # 0x6486d
leaq 0x26987(%rip), %r8      # 0x64881
movl $0x20c, %edx            # imm = 0x20C
xorl %eax, %eax
callq 0x125e0
callq 0x12100