LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/src/core/peg.c
// Function: cfun_peg_replace_generic
static Janet cfun_peg_replace_generic(int32_t argc, Janet *argv, int only_one) {
    PegCall c = peg_cfun_init(argc, argv, 1);
    JanetBuffer *ret = janet_buffer(0);
    int32_t trail = 0;
    for (int32_t i = c.start; i < c.bytes.len;) {
        peg_call_reset(&c);
        const uint8_t *result = peg_rule(&c.s, c.s.bytecode, c.bytes.bytes + i);
        if (NULL != result) {
            if (trail < i) {
                janet_buffer_push_bytes(ret, c.bytes.bytes + trail, (i - trail));
                trail = i;
            }
            int32_t nexti = (int32_t)(result - c.bytes.bytes);
            JanetByteView subst = janet_text_substitution(&c.subst, c.bytes.bytes + i, nexti - i, c.s.captures);
            janet_buffer_push_bytes(ret, subst.bytes, subst.len);
            trail = nexti;
            if (nexti == i) nexti++;
            i = nexti;
            if (only_one) break;
        } else {
            i++;
        }
    }
    if (trail < c.bytes.len) {
        janet_buffer_push_bytes(ret, c.bytes.bytes + trail, (c.bytes.len - trail));
    }
    return janet_wrap_buffer(ret);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movl %edx, %r12d
movq %rsi, %rdx
movl %edi, %esi
leaq -0xd0(%rbp), %r14
movq %r14, %rdi
movl $0x1, %ecx
callq 0x3b868
xorl %r15d, %r15d
xorl %edi, %edi
callq 0x17757
movq %rax, -0x38(%rbp)
movl 0x90(%r14), %r14d
testl %r12d, %r12d
sete -0x29(%rbp)
xorl %ebx, %ebx
cmpl -0x50(%rbp), %r14d
jge 0x3d1be
movl $0x400, -0x6c(%rbp)     # imm = 0x400
movq -0xa0(%rbp), %rax
movl %r15d, 0x10(%rax)
movq -0x88(%rbp), %rax
movl %r15d, 0x10(%rax)
movq -0x98(%rbp), %rax
movl %r15d, 0x10(%rax)
movq -0x90(%rbp), %rax
movl %r15d, 0x10(%rax)
movq -0xb0(%rbp), %rsi
movslq %r14d, %r13
movq -0x58(%rbp), %rdx
addq %r13, %rdx
leaq -0xc8(%rbp), %rdi
callq 0x3b9f4
testq %rax, %rax
je 0x3d1b1
movq %rax, %r12
movl %r14d, %edx
subl %ebx, %edx
jle 0x3d16f
movslq %ebx, %rsi
addq -0x58(%rbp), %rsi
movq -0x38(%rbp), %rdi
callq 0x17925
movq -0xa0(%rbp), %rcx
movq -0x58(%rbp), %rax
subl %eax, %r12d
addq %rax, %r13
xorl %ebx, %ebx
movl %r12d, %edx
subl %r14d, %edx
sete %bl
leaq -0x48(%rbp), %rdi
movq %r13, %rsi
callq 0x49fd0
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x17925
addl %r12d, %ebx
movb -0x29(%rbp), %al
movl %ebx, %r14d
movl %r12d, %ebx
jmp 0x3d1b6
incl %r14d
movb $0x1, %al
testb %al, %al
jne 0x3d0f6
movl -0x50(%rbp), %edx
subl %ebx, %edx
jle 0x3d1d5
movslq %ebx, %rsi
addq -0x58(%rbp), %rsi
movq -0x38(%rbp), %rdi
callq 0x17925
movabsq $-0x2800000000000, %rsi # imm = 0xFFFD800000000000
movq -0x38(%rbp), %rdi
callq 0x4f9f2
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/src/core/peg.c
// Function: janet_lib_peg
void janet_lib_peg(JanetTable *env) {
    JanetRegExt cfuns[] = {
        JANET_CORE_REG("peg/compile", cfun_peg_compile),
        JANET_CORE_REG("peg/match", cfun_peg_match),
        JANET_CORE_REG("peg/find", cfun_peg_find),
        JANET_CORE_REG("peg/find-all", cfun_peg_find_all),
        JANET_CORE_REG("peg/replace", cfun_peg_replace),
        JANET_CORE_REG("peg/replace-all", cfun_peg_replace_all),
        JANET_REG_END
    };
    janet_core_cfuns_ext(env, NULL, cfuns);
    janet_register_abstract_type(&janet_peg_type);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x120, %rsp            # imm = 0x120
movq %rdi, %rbx
leaq 0x4748f(%rip), %rsi     # 0x846b0
leaq -0x130(%rbp), %r14
movl $0x118, %edx            # imm = 0x118
movq %r14, %rdi
callq 0x12680
movq %rbx, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x498ba
leaq 0x473f7(%rip), %rdi     # 0x84640
callq 0x49b93
addq $0x120, %rsp            # imm = 0x120
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/src/core/peg.c
// Function: reserve
static Reserve reserve(Builder *b, int32_t size) {
    Reserve r;
    r.index = janet_v_count(b->bytecode);
    r.builder = b;
    r.size = size;
    for (int32_t i = 0; i < size; i++)
        janet_v_push(b->bytecode, 0);
    return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
movq 0x20(%rdi), %rax
testq %rax, %rax
je 0x3d84f
movl -0x4(%rax), %r15d
jmp 0x3d852
xorl %r15d, %r15d
testl %r14d, %r14d
jle 0x3d89a
movl %r14d, %r12d
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x3d86d
movl -0x4(%rdi), %eax
incl %eax
cmpl -0x8(%rdi), %eax
jl 0x3d880
movl $0x1, %esi
movl $0x4, %edx
callq 0x4c0b4
movq %rax, 0x20(%rbx)
movq 0x20(%rbx), %rax
movslq -0x4(%rax), %rcx
leal 0x1(%rcx), %edx
movl %edx, -0x4(%rax)
movl $0x0, (%rax,%rcx,4)
decl %r12d
jne 0x3d85a
shlq $0x20, %r14
orq %r14, %r15
movq %rbx, %rax
movq %r15, %rdx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/src/core/peg.c
// Function: emit_bytes
static void emit_bytes(Builder *b, uint32_t op, int32_t len, const uint8_t *bytes) {
    uint32_t next_rule = janet_v_count(b->bytecode);
    janet_v_push(b->bytecode, op);
    janet_v_push(b->bytecode, len);
    int32_t words = ((len + 3) >> 2);
    for (int32_t i = 0; i < words; i++)
        janet_v_push(b->bytecode, 0);
    memcpy(b->bytecode + next_rule + 2, bytes, len);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %r14d
movq %rdi, %r15
movq 0x20(%rdi), %rdi
testq %rdi, %rdi
je 0x3d919
movl -0x4(%rdi), %r12d
jmp 0x3d91c
xorl %r12d, %r12d
testq %rdi, %rdi
je 0x3d92b
movl -0x4(%rdi), %eax
incl %eax
cmpl -0x8(%rdi), %eax
jl 0x3d93e
movl $0x1, %esi
movl $0x4, %edx
callq 0x4c0b4
movq %rax, 0x20(%r15)
movq 0x20(%r15), %rdi
movslq -0x4(%rdi), %rax
leal 0x1(%rax), %ecx
movl %ecx, -0x4(%rdi)
movl $0x0, (%rdi,%rax,4)
testq %rdi, %rdi
je 0x3d962
movl -0x4(%rdi), %eax
incl %eax
cmpl -0x8(%rdi), %eax
jl 0x3d975
movl $0x1, %esi
movl $0x4, %edx
callq 0x4c0b4
movq %rax, 0x20(%r15)
movq 0x20(%r15), %rax
movslq -0x4(%rax), %rcx
leal 0x1(%rcx), %edx
movl %edx, -0x4(%rax)
movl %r14d, (%rax,%rcx,4)
leal 0x3(%r14), %r13d
sarl $0x2, %r13d
testl %r13d, %r13d
jle 0x3d9d4
movq 0x20(%r15), %rdi
testq %rdi, %rdi
je 0x3d9a7
movl -0x4(%rdi), %eax
incl %eax
cmpl -0x8(%rdi), %eax
jl 0x3d9ba
movl $0x1, %esi
movl $0x4, %edx
callq 0x4c0b4
movq %rax, 0x20(%r15)
movq 0x20(%r15), %rax
movslq -0x4(%rax), %rcx
leal 0x1(%rcx), %edx
movl %edx, -0x4(%rax)
movl $0x0, (%rax,%rcx,4)
decl %r13d
jne 0x3d994
movq 0x20(%r15), %rax
leaq (%rax,%r12,4), %rdi
addq $0x8, %rdi
movslq %r14d, %rdx
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x12680
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/src/core/peg.c
// Function: spec_repeat
static void spec_repeat(Builder *b, int32_t argc, const Janet *argv) {
    peg_fixarity(b, argc, 2);
    Reserve r = reserve(b, 4);
    int32_t n = peg_getnat(b, argv[0]);
    uint32_t subrule = peg_compile1(b, argv[1]);
    emit_3(r, RULE_BETWEEN, n, n, subrule);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rdi, %r14
movl $0x2, %edx
callq 0x3dab2
movq %r14, %rdi
movl $0x4, %esi
callq 0x3d82f
movq %rax, %r15
movq %rdx, %r12
movq (%rbx), %rsi
movq %r14, %rdi
callq 0x3daf5
movl %eax, %r13d
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x3d25a
leaq -0x34(%rbp), %r8
movl %r13d, (%r8)
movl %r13d, 0x4(%r8)
movl %eax, 0x8(%r8)
movq %r15, %rdi
movq %r12, %rsi
movl $0xb, %edx
movl $0x3, %ecx
callq 0x3da7a
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/src/core/peg.c
// Function: peg_getnat
static int32_t peg_getnat(Builder *b, Janet x) {
    int32_t i = peg_getinteger(b, x);
    if (i < 0)
        peg_panicf(b, "expected non-negative integer, got %v", x);
    return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
callq 0x3d8b0
testl %eax, %eax
js 0x3db10
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x2b562(%rip), %rdi     # 0x69079
movq %r14, %rsi
xorl %eax, %eax
callq 0x3fd86
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3d808
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/src/core/peg.c
// Function: spec_reference
static void spec_reference(Builder *b, int32_t argc, const Janet *argv) {
    peg_arity(b, argc, 1, 2);
    Reserve r = reserve(b, 3);
    uint32_t search = emit_tag(b, argv[0]);
    uint32_t tag = (argc == 2) ? emit_tag(b, argv[1]) : 0;
    b->has_backref = 1;
    emit_2(r, RULE_GETTAG, search, tag);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r12
movl %esi, %r14d
movq %rdi, %rbx
movl $0x1, %edx
movl $0x2, %ecx
callq 0x3e882
movq %rbx, %rdi
movl $0x3, %esi
callq 0x3d82f
movq %rax, -0x30(%rbp)
movq %rdx, %r15
movq (%r12), %rsi
movq %rbx, %rdi
callq 0x3e8d0
movl %eax, %r13d
xorl %eax, %eax
cmpl $0x2, %r14d
jne 0x3dbd8
movq 0x8(%r12), %rsi
movq %rbx, %rdi
callq 0x3e8d0
movl $0x1, 0x38(%rbx)
leaq -0x38(%rbp), %r8
movl %r13d, (%r8)
movl %eax, 0x4(%r8)
movq -0x30(%rbp), %rdi
movq %r15, %rsi
movl $0xc, %edx
movl $0x2, %ecx
callq 0x3da7a
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/src/core/peg.c
// Function: spec_replace
static void spec_replace(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]);
    uint32_t constant = emit_constant(b, argv[1]);
    uint32_t tag = (argc == 3) ? emit_tag(b, argv[2]) : 0;
    emit_3(r, RULE_REPLACE, subrule, constant, tag);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r12
movl %esi, %r13d
movq %rdi, %r15
movl $0x2, %edx
movl $0x3, %ecx
callq 0x3e882
movq %r15, %rdi
movl $0x4, %esi
callq 0x3d82f
movq %rax, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
movq (%r12), %rsi
movq %r15, %rdi
callq 0x3d25a
movl %eax, %ebx
movq 0x8(%r12), %rsi
movq %r15, %rdi
callq 0x3eb36
movl %eax, %r14d
xorl %eax, %eax
cmpl $0x3, %r13d
jne 0x3dc80
movq 0x10(%r12), %rsi
movq %r15, %rdi
callq 0x3e8d0
leaq -0x44(%rbp), %r8
movl %ebx, (%r8)
movl %r14d, 0x4(%r8)
movl %eax, 0x8(%r8)
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl $0x13, %edx
movl $0x3, %ecx
callq 0x3da7a
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/src/core/peg.c
// Function: spec_look
static void spec_look(Builder *b, int32_t argc, const Janet *argv) {
    peg_arity(b, argc, 1, 2);
    Reserve r = reserve(b, 3);
    int32_t rulearg = argc == 2 ? 1 : 0;
    int32_t offset = argc == 2 ? peg_getinteger(b, argv[0]) : 0;
    uint32_t subrule = peg_compile1(b, argv[rulearg]);
    emit_2(r, RULE_LOOK, (uint32_t) offset, subrule);
}

// 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
movl $0x1, %edx
movl $0x2, %ecx
callq 0x3e882
movq %rbx, %rdi
movl $0x3, %esi
callq 0x3d82f
movq %rax, -0x30(%rbp)
movq %rdx, %r12
xorl %r15d, %r15d
cmpl $0x2, %r13d
jne 0x3dd18
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x3d8b0
movl %eax, %r15d
xorl %eax, %eax
cmpl $0x2, %r13d
sete %al
movq (%r14,%rax,8), %rsi
movq %rbx, %rdi
callq 0x3d25a
leaq -0x38(%rbp), %r8
movl %r15d, (%r8)
movl %eax, 0x4(%r8)
movq -0x30(%rbp), %rdi
movq %r12, %rsi
movl $0x5, %edx
movl $0x2, %ecx
callq 0x3da7a
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/src/core/peg.c
// Function: spec_opt
static void spec_opt(Builder *b, int32_t argc, const Janet *argv) {
    peg_fixarity(b, argc, 1);
    Reserve r = reserve(b, 4);
    uint32_t subrule = peg_compile1(b, argv[0]);
    emit_3(r, RULE_BETWEEN, 0, 1, subrule);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rdi, %r14
movl $0x1, %edx
callq 0x3dab2
movq %r14, %rdi
movl $0x4, %esi
callq 0x3d82f
movq %rax, %r15
movq %rdx, %r12
movq (%rbx), %rsi
movq %r14, %rdi
callq 0x3d25a
movabsq $0x100000000, %rcx      # imm = 0x100000000
leaq -0x2c(%rbp), %r8
movq %rcx, (%r8)
movl %eax, 0x8(%r8)
movq %r15, %rdi
movq %r12, %rsi
movl $0xb, %edx
movl $0x3, %ecx
callq 0x3da7a
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/src/core/peg.c
// Function: spec_argument
static void spec_argument(Builder *b, int32_t argc, const Janet *argv) {
    peg_arity(b, argc, 1, 2);
    Reserve r = reserve(b, 3);
    uint32_t tag = (argc == 2) ? emit_tag(b, argv[1]) : 0;
    int32_t index = peg_getnat(b, argv[0]);
    emit_2(r, RULE_ARGUMENT, index, 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
movl $0x1, %edx
movl $0x2, %ecx
callq 0x3e882
movq %rbx, %rdi
movl $0x3, %esi
callq 0x3d82f
movq %rax, -0x30(%rbp)
movq %rdx, %r12
xorl %r13d, %r13d
cmpl $0x2, %r15d
jne 0x3de32
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0x3e8d0
movl %eax, %r13d
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x3daf5
leaq -0x38(%rbp), %r8
movl %eax, (%r8)
movl %r13d, 0x4(%r8)
movq -0x30(%rbp), %rdi
movq %r12, %rsi
movl $0xf, %edx
movl $0x2, %ecx
callq 0x3da7a
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/src/core/peg.c
// Function: spec_atleast
static void spec_atleast(Builder *b, int32_t argc, const Janet *argv) {
    peg_fixarity(b, argc, 2);
    Reserve r = reserve(b, 4);
    int32_t n = peg_getnat(b, argv[0]);
    uint32_t subrule = peg_compile1(b, argv[1]);
    emit_3(r, RULE_BETWEEN, n, UINT32_MAX, subrule);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rdi, %r14
movl $0x2, %edx
callq 0x3dab2
movq %r14, %rdi
movl $0x4, %esi
callq 0x3d82f
movq %rax, %r15
movq %rdx, %r12
movq (%rbx), %rsi
movq %r14, %rdi
callq 0x3daf5
movl %eax, %r13d
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x3d25a
leaq -0x34(%rbp), %r8
movl %r13d, (%r8)
movl $0xffffffff, 0x4(%r8)   # imm = 0xFFFFFFFF
movl %eax, 0x8(%r8)
movq %r15, %rdi
movq %r12, %rsi
movl $0xb, %edx
movl $0x3, %ecx
callq 0x3da7a
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/src/core/peg.c
// Function: spec_between
static void spec_between(Builder *b, int32_t argc, const Janet *argv) {
    peg_fixarity(b, argc, 3);
    Reserve r = reserve(b, 4);
    int32_t lo = peg_getnat(b, argv[0]);
    int32_t hi = peg_getnat(b, argv[1]);
    uint32_t subrule = peg_compile1(b, argv[2]);
    emit_3(r, RULE_BETWEEN, lo, hi, subrule);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movl $0x3, %edx
callq 0x3dab2
movq %rbx, %rdi
movl $0x4, %esi
callq 0x3d82f
movq %rax, -0x30(%rbp)
movq %rdx, %r12
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x3daf5
movl %eax, %r13d
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0x3daf5
movl %eax, %r15d
movq 0x10(%r14), %rsi
movq %rbx, %rdi
callq 0x3d25a
leaq -0x3c(%rbp), %r8
movl %r13d, (%r8)
movl %r15d, 0x4(%r8)
movl %eax, 0x8(%r8)
movq -0x30(%rbp), %rdi
movq %r12, %rsi
movl $0xb, %edx
movl $0x3, %ecx
callq 0x3da7a
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/src/core/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 $0x28, %rsp
movq %rdx, %r12
movl %esi, %r15d
movq %rdi, %rbx
movl $0x2, %edx
movl $0x3, %ecx
callq 0x3e882
movq %rbx, %rdi
movl $0x4, %esi
callq 0x3d82f
movq %rax, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
movq (%r12), %rsi
movq %rbx, %rdi
callq 0x3d25a
movq 0x8(%r12), %r13
movq %r13, %rcx
btsq $0x2f, %rcx
shrq $0x2f, %rcx
cmpl $0x1fffd, %ecx          # imm = 0x1FFFD
jne 0x3e0e1
movl %eax, -0x2c(%rbp)
xorl %r14d, %r14d
cmpl $0x3, %r15d
jne 0x3e09e
movq 0x10(%r12), %rsi
movq %rbx, %rdi
callq 0x3e8d0
movl %eax, %r14d
movq %rbx, %rdi
movq %r13, %rsi
callq 0x3eb36
leaq -0x4c(%rbp), %r8
movl -0x2c(%rbp), %ecx
movl %ecx, (%r8)
movl %eax, 0x4(%r8)
movl %r14d, 0x8(%r8)
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movl $0x14, %edx
movl $0x3, %ecx
callq 0x3da7a
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2b0b6(%rip), %rdi     # 0x6919e
movq %r13, %rsi
xorl %eax, %eax
callq 0x3fd86
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3d808
// File: /workspace/github_c_makefile_star2_O1/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
subq $0x18, %rsp
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %rbx
movl %esi, %edi
movl $0x1, %esi
movl $0x2, %edx
callq 0x192cc
movq %rbx, %rdi
movl $0x3, %esi
callq 0x3d82f
movq %rax, -0x30(%rbp)
movq %rdx, %r12
xorl %r13d, %r13d
cmpl $0x2, %r15d
jne 0x3e163
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0x3e8d0
movl %eax, %r13d
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x3eb36
leaq -0x38(%rbp), %r8
movl %eax, (%r8)
movl %r13d, 0x4(%r8)
movq -0x30(%rbp), %rdi
movq %r12, %rsi
movl $0x10, %edx
movl $0x2, %ecx
callq 0x3da7a
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/src/core/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 0x3e1d5
movq %rbx, %rdi
movl $0x15, %ecx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3e79c
movq %rbx, %rdi
movl $0x2, %esi
callq 0x3d82f
movq %rax, %r14
movq %rdx, %r15
xorps %xmm0, %xmm0
callq 0x4fab8
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3d25a
leaq -0x1c(%rbp), %r8
movl %eax, (%r8)
movq %r14, %rdi
movq %r15, %rsi
movl $0x15, %edx
movl $0x1, %ecx
callq 0x3da7a
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/src/core/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 $0x28, %rsp
movq %rdx, %r12
movl %esi, %r13d
movq %rdi, %r15
movl $0x2, %edx
movl $0x3, %ecx
callq 0x3e882
movq %r15, %rdi
movl $0x4, %esi
callq 0x3d82f
movq %rax, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
movq (%r12), %rsi
movq %r15, %rdi
callq 0x3daf5
movl %eax, %ebx
movq 0x8(%r12), %rsi
movq %r15, %rdi
callq 0x3d25a
movl %eax, %r14d
xorl %eax, %eax
cmpl $0x3, %r13d
jne 0x3e2fc
movq 0x10(%r12), %rsi
movq %r15, %rdi
callq 0x3e8d0
leaq -0x44(%rbp), %r8
movl %ebx, (%r8)
movl %r14d, 0x4(%r8)
movl %eax, 0x8(%r8)
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl $0x23, %edx
movl $0x3, %ecx
callq 0x3da7a
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/src/core/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 $0x28, %rsp
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %rbx
movl $0x1, %edx
movl $0x3, %ecx
callq 0x3e882
movq %rbx, %rdi
movl $0x4, %esi
callq 0x3d82f
movq %rax, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
xorl %r13d, %r13d
movl $0x0, %r12d
cmpl $0x2, %r15d
jl 0x3e3af
movq 0x8(%r14), %rdi
movq %rdi, %rax
shrq $0x2f, %rax
movl $0x0, %r12d
cmpl $0x1fff1, %eax          # imm = 0x1FFF1
je 0x3e3af
callq 0x4a41f
testl %eax, %eax
je 0x3e404
cvttsd2si 0x8(%r14), %r12d
leal -0x25(%r12), %eax
cmpl $-0x23, %eax
jb 0x3e404
cmpl $0x3, %r15d
jne 0x3e3c4
movq 0x10(%r14), %rsi
movq %rbx, %rdi
callq 0x3e8d0
movl %eax, %r13d
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x3d25a
leaq -0x44(%rbp), %r8
movl %eax, (%r8)
movl %r12d, 0x4(%r8)
movl %r13d, 0x8(%r8)
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl $0x1f, %edx
movl $0x3, %ecx
callq 0x3da7a
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%r14), %rsi
leaq 0x2addd(%rip), %rdi     # 0x691ec
xorl %eax, %eax
callq 0x3fd86
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3d808
// File: /workspace/github_c_makefile_star2_O1/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 $0x28, %rsp
movq %rdx, %r14
movl %esi, %r13d
movq %rdi, %rbx
movl $0x1, %edx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x3e882
movq %rbx, %rdi
cmpl $0x1, %r13d
jne 0x3e4a2
movl $0x2, %esi
callq 0x3d82f
movq %rax, %r15
movq %rdx, %r12
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x3ed4b
movzbl (%rax), %ecx
movzbl 0x1(%rax), %eax
shll $0x10, %eax
orl %ecx, %eax
leaq -0x50(%rbp), %r8
movl %eax, (%r8)
movq %r15, %rdi
movq %r12, %rsi
movl $0x3, %edx
movl $0x1, %ecx
jmp 0x3e518
movl $0x9, %esi
callq 0x3d82f
movq %rax, -0x30(%rbp)
movq %rdx, %r12
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%rbp)
movaps %xmm0, -0x50(%rbp)
testl %r13d, %r13d
jle 0x3e503
movl %r13d, %r13d
xorl %r15d, %r15d
movq (%r14,%r15,8), %rsi
movq %rbx, %rdi
callq 0x3ed4b
movzbl (%rax), %ecx
movzbl 0x1(%rax), %eax
cmpb %al, %cl
ja 0x3e4fb
incl %eax
movl $0x1, %edx
shll %cl, %edx
movl %ecx, %esi
shrl $0x3, %esi
andl $0x1c, %esi
orl %edx, -0x50(%rbp,%rsi)
incl %ecx
cmpl %ecx, %eax
jne 0x3e4e2
incq %r15
cmpq %r13, %r15
jne 0x3e4c9
leaq -0x50(%rbp), %r8
movq -0x30(%rbp), %rdi
movq %r12, %rsi
movl $0x4, %edx
movl $0x8, %ecx
callq 0x3da7a
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/src/core/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 %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r12
movq %rdi, %r15
movl $0x1, %edx
callq 0x3dab2
movq %r15, %rdi
movl $0x9, %esi
callq 0x3d82f
movq %rax, %rbx
movq (%r12), %rdi
movq %rdi, %rax
shrq $0x2f, %rax
cmpl $0x1fff4, %eax          # imm = 0x1FFF4
jne 0x3e5cb
movq %rdx, %r14
callq 0x4f838
xorps %xmm0, %xmm0
movaps %xmm0, -0x30(%rbp)
movaps %xmm0, -0x40(%rbp)
movslq -0x8(%rax), %rdx
testq %rdx, %rdx
jle 0x3e5a5
xorl %esi, %esi
movzbl (%rax,%rsi), %ecx
movl $0x1, %edi
shll %cl, %edi
shrl $0x5, %ecx
orl %edi, -0x40(%rbp,%rcx,4)
incq %rsi
cmpq %rsi, %rdx
jne 0x3e58b
leaq -0x40(%rbp), %r8
movq %rbx, %rdi
movq %r14, %rsi
movl $0x4, %edx
movl $0x8, %ecx
callq 0x3da7a
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2aca3(%rip), %rsi     # 0x69275
movq %r15, %rdi
callq 0x3d808
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x2, %edx
callq 0x3dab2
movq %r14, %rdi
movl $0x3, %esi
callq 0x3d82f
movq %rax, %r15
movq %rdx, %r12
movq (%rbx), %rsi
movq %r14, %rdi
callq 0x3d25a
movl %eax, %r13d
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x3d25a
leaq -0x30(%rbp), %r8
movl %r13d, (%r8)
movl %eax, 0x4(%r8)
movq %r15, %rdi
movq %r12, %rsi
movl $0x22, %edx
movl $0x2, %ecx
callq 0x3da7a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/src/core/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
movl $0x1, %edx
callq 0x3dab2
movq %r15, %rdi
movl $0x2, %esi
callq 0x3d82f
movq %rax, %r12
movq %rdx, %r13
movq (%r14), %rsi
movq %r15, %rdi
callq 0x3d25a
leaq -0x2c(%rbp), %r8
movl %eax, (%r8)
movq %r12, %rdi
movq %r13, %rsi
movl %ebx, %edx
movl $0x1, %ecx
callq 0x3da7a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/src/core/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
xorl %edx, %edx
movl $0x1, %ecx
callq 0x3e882
movq %r15, %rdi
movl $0x2, %esi
callq 0x3d82f
movq %rax, %r13
movq %rdx, %rbx
testl %r12d, %r12d
je 0x3e859
movq -0x38(%rbp), %rax
movq (%rax), %rsi
movq %r15, %rdi
callq 0x3e8d0
movl %eax, %r14d
leaq -0x3c(%rbp), %r8
movl %r14d, (%r8)
movq %r13, %rdi
movq %rbx, %rsi
movl -0x2c(%rbp), %edx
movl $0x1, %ecx
callq 0x3da7a
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/src/core/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 0x3e8a8
testl %ecx, %ecx
sets %dl
cmpl %ecx, %eax
setle %sil
orb %dl, %sil
je 0x3e8b3
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x16e12(%rip), %rdi     # 0x556c1
movl %edx, %esi
jmp 0x3e8bc
leaq 0x16e3a(%rip), %rdi     # 0x556f4
movl %ecx, %esi
movl %eax, %edx
xorl %eax, %eax
callq 0x3fd86
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3d808
// File: /workspace/github_c_makefile_star2_O1/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 0x3e95d
movabsq $-0x800000000000, %r15  # imm = 0xFFFF800000000000
movq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0x47f51
andq %rax, %r15
movabsq $-0x7800000000000, %rcx # imm = 0xFFF8800000000000
cmpq %rcx, %r15
jne 0x3e945
movl 0x34(%rbx), %r15d
leal 0x1(%r15), %eax
movl %eax, 0x34(%rbx)
cmpl $0x100, %r15d           # imm = 0x100
jae 0x3e979
cvtsi2sd %r15d, %xmm0
callq 0x4fab8
movq 0x10(%rbx), %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x481b3
jmp 0x3e94f
movq %rax, %xmm0
cvttsd2si %xmm0, %r15
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2a7dc(%rip), %rdi     # 0x69140
movq %r14, %rsi
xorl %eax, %eax
callq 0x3fd86
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3d808
leaq 0x2a7e9(%rip), %rsi     # 0x69169
movq %rbx, %rdi
callq 0x3d808
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x1, %edx
movl $0x2, %ecx
callq 0x3e882
movq %r14, %rdi
movl $0x3, %esi
callq 0x3d82f
movq %rax, -0x38(%rbp)
movq %rdx, %r13
xorl %ebx, %ebx
cmpl $0x2, %r12d
jne 0x3e9de
movq 0x8(%r15), %rsi
movq %r14, %rdi
callq 0x3e8d0
movl %eax, %ebx
movq (%r15), %rsi
movq %r14, %rdi
callq 0x3d25a
leaq -0x40(%rbp), %r8
movl %eax, (%r8)
movl %ebx, 0x4(%r8)
movq -0x38(%rbp), %rdi
movq %r13, %rsi
movl -0x2c(%rbp), %edx
movl $0x2, %ecx
callq 0x3da7a
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/src/core/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), %rdi
testq %rdi, %rdi
je 0x3ea44
movl -0x4(%rdi), %r13d
addl $0x2, %r13d
jmp 0x3ea4a
movl $0x2, %r13d
testq %rdi, %rdi
je 0x3ea59
movl -0x4(%rdi), %eax
incl %eax
cmpl -0x8(%rdi), %eax
jl 0x3ea6c
movl $0x1, %esi
movl $0x4, %edx
callq 0x4c0b4
movq %rax, 0x20(%r14)
movq 0x20(%r14), %rdi
movslq -0x4(%rdi), %rax
leal 0x1(%rax), %ecx
movl %ecx, -0x4(%rdi)
movl %r12d, (%rdi,%rax,4)
testq %rdi, %rdi
je 0x3ea8d
movl -0x4(%rdi), %eax
incl %eax
cmpl -0x8(%rdi), %eax
jl 0x3eaa0
movl $0x1, %esi
movl $0x4, %edx
callq 0x4c0b4
movq %rax, 0x20(%r14)
movq 0x20(%r14), %rax
movslq -0x4(%rax), %rcx
leal 0x1(%rcx), %edx
movl %edx, -0x4(%rax)
movl %r15d, (%rax,%rcx,4)
testl %r15d, %r15d
jle 0x3eafa
movl %r15d, %r12d
movq 0x20(%r14), %rdi
testq %rdi, %rdi
je 0x3eacd
movl -0x4(%rdi), %eax
incl %eax
cmpl -0x8(%rdi), %eax
jl 0x3eae0
movl $0x1, %esi
movl $0x4, %edx
callq 0x4c0b4
movq %rax, 0x20(%r14)
movq 0x20(%r14), %rax
movslq -0x4(%rax), %rcx
leal 0x1(%rcx), %edx
movl %edx, -0x4(%rax)
movl $0x0, (%rax,%rcx,4)
decl %r12d
jne 0x3eaba
testl %r15d, %r15d
jle 0x3eb27
movl %r15d, %r15d
movl %r13d, %r12d
xorl %r13d, %r13d
movq (%rbx,%r13,8), %rsi
movq %r14, %rdi
callq 0x3d25a
movq 0x20(%r14), %rcx
leal (%r12,%r13), %edx
movl %eax, (%rcx,%rdx,4)
incq %r13
cmpq %r13, %r15
jne 0x3eb08
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/src/core/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
subq $0x18, %rsp
movl %ecx, %ebx
movq %rdx, %r14
movq %rdi, %r15
movl $0x1, %edx
callq 0x3dab2
movq %r15, %rdi
movl $0x4, %esi
callq 0x3d82f
movq %rax, %r12
movq %rdx, %r13
movq (%r14), %rsi
movq %r15, %rdi
callq 0x3d25a
leaq -0x34(%rbp), %r8
movl %ebx, (%r8)
movl $0xffffffff, 0x4(%r8)   # imm = 0xFFFFFFFF
movl %eax, 0x8(%r8)
movq %r12, %rdi
movq %r13, %rsi
movl $0xb, %edx
movl $0x3, %ecx
callq 0x3da7a
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/src/core/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
subq $0x18, %rsp
movl %ecx, -0x2c(%rbp)
movq %rdx, %r14
movq %rdi, %r15
movl $0x2, %edx
callq 0x3dab2
movq %r15, %rdi
movl $0x3, %esi
callq 0x3d82f
movq %rax, %r12
movq %rdx, %r13
movq (%r14), %rsi
movq %r15, %rdi
callq 0x3d25a
movl %eax, %ebx
movq 0x8(%r14), %rsi
movq %r15, %rdi
callq 0x3d25a
leaq -0x34(%rbp), %r8
movl %ebx, (%r8)
movl %eax, 0x4(%r8)
movq %r12, %rdi
movq %r13, %rsi
movl -0x2c(%rbp), %edx
movl $0x2, %ecx
callq 0x3da7a
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/src/core/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, %r13
movl %esi, %r15d
movq %rdi, %rbx
movl $0x1, %edx
movl $0x2, %ecx
callq 0x3e882
movq %rbx, %rdi
movl $0x3, %esi
callq 0x3d82f
movq %rax, -0x38(%rbp)
movq %rdx, %r12
xorl %r14d, %r14d
cmpl $0x2, %r15d
jne 0x3ece7
movq 0x8(%r13), %rsi
movq %rbx, %rdi
callq 0x3e8d0
movl %eax, %r14d
movq (%r13), %rsi
movq %rbx, %rdi
callq 0x3daf5
cmpl $0x9, %eax
jae 0x3ed2b
orl -0x2c(%rbp), %eax
leaq -0x40(%rbp), %r8
movl %eax, (%r8)
movl %r14d, 0x4(%r8)
movq -0x38(%rbp), %rdi
movq %r12, %rsi
movl $0x1b, %edx
movl $0x2, %ecx
callq 0x3da7a
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2a493(%rip), %rdi     # 0x691c5
movl $0x8, %esi
movl %eax, %edx
xorl %eax, %eax
callq 0x3fd86
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3d808
// File: /workspace/github_c_makefile_star2_O1/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 0x3ed80
movq %rsi, %r14
movq %rsi, %rdi
callq 0x4f838
cmpl $0x2, -0x8(%rax)
jne 0x3ed8f
movb 0x1(%rax), %cl
cmpb (%rax), %cl
jb 0x3ed98
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x2a48f(%rip), %rsi     # 0x69216
movq %rbx, %rdi
callq 0x3d808
leaq 0x2a4a4(%rip), %rdi     # 0x6923a
jmp 0x3ed9f
leaq 0x2a4c4(%rip), %rdi     # 0x69263
movq %r14, %rsi
xorl %eax, %eax
callq 0x3fd86
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3d808
// File: /workspace/github_c_makefile_star2_O1/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
cmpl $0x1, 0x68(%rdi)
jne 0x3edd8
movq 0x30(%r14), %rdi
movq %r15, %rsi
callq 0x3ef10
cmpl $0x0, 0x68(%r14)
jne 0x3edeb
movq 0x28(%r14), %rdi
movq %r15, %rsi
callq 0x148b3
cmpl $0x0, 0x64(%r14)
je 0x3ee14
movq 0x40(%r14), %rdi
movq %r15, %rsi
callq 0x148b3
movq 0x38(%r14), %rdi
movzbl %bl, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x179a7
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/src/core/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
movl $0x2, %edx
callq 0x1777e
movq 0x18(%rbx), %rax
movslq 0x10(%rbx), %rdx
movq %r15, -0x20(%rbp)
leaq (%rax,%rdx), %rcx
incq %rcx
movb $0x3c, -0x1(%rcx)
movb (%r14), %sil
testb %sil, %sil
je 0x3f234
xorl %edx, %edx
movq %rcx, %rax
movb %sil, (%rcx)
cmpq $0x1f, %rdx
je 0x3f22e
leaq 0x1(%rax), %rcx
movb 0x1(%r14,%rdx), %sil
incq %rdx
testb %sil, %sil
jne 0x3f211
leaq 0x1(%rax), %rcx
jmp 0x3f237
addq %rdx, %rax
movb $0x20, (%rcx)
movw $0x7830, 0x2(%rax)      # imm = 0x7830
leaq 0x4(%rax), %rcx
addl $0x5, %eax
movl $0x7, %edx
leaq 0x2d36d(%rip), %rsi     # 0x6c5c0
movzbl -0x22(%rbp,%rdx), %edi
movl %edi, %r8d
shrl $0x4, %r8d
movb (%rsi,%r8), %r8b
movb %r8b, (%rcx)
andl $0xf, %edi
movb (%rsi,%rdi), %dil
movb %dil, 0x1(%rcx)
addq $0x2, %rcx
decq %rdx
addl $0x2, %eax
cmpq $0x1, %rdx
ja 0x3f253
movb $0x3e, (%rcx)
subl 0x18(%rbx), %eax
movl %eax, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/src/core/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 $0x5, %eax
jle 0x3f336
cmpl $0x6, %eax
je 0x3f357
cmpl $0xb, %eax
je 0x3f379
cmpl $0xe, %eax
jne 0x3f364
movq %r14, %rdi
callq 0x4f838
movq %rax, %r14
movq -0x10(%rax), %r15
cmpq $0x0, 0x38(%r15)
je 0x3f3e4
leaq 0x2d9d7(%rip), %rsi     # 0x6ccd5
movq %rbx, %rdi
callq 0x178d8
movq (%r15), %rsi
movq %rbx, %rdi
callq 0x178d8
leaq 0x292c0(%rip), %rsi     # 0x685d8
movq %rbx, %rdi
callq 0x178d8
movq %r14, %rdi
movq %rbx, %rsi
callq *0x38(%r15)
leaq 0x29d73(%rip), %rsi     # 0x690a4
jmp 0x3f3d2
cmpl $0x1, %eax
je 0x3f3cb
cmpl $0x4, %eax
jne 0x3f364
movq %r14, %rdi
callq 0x4f838
movl -0x8(%rax), %edx
movq %rbx, %rdi
movq %rax, %rsi
jmp 0x3f3bc
movq %rbx, %rdi
movl $0x3a, %esi
callq 0x179a7
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3ef10
movq %r14, %rdi
callq 0x4f838
movq %rax, %r14
cmpq %rbx, %rax
jne 0x3f3a4
movl 0x10(%r14), %eax
leal (%rax,%rax,2), %eax
leal 0x3(,%rax,2), %esi
movq %r14, %rdi
movl $0x1, %edx
callq 0x1777e
movq %rbx, %rdi
movl $0x40, %esi
callq 0x179a7
movq 0x18(%r14), %rsi
movl 0x10(%r14), %edx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4026c
leaq 0x202f4(%rip), %rsi     # 0x5f6c6
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x178d8
movq (%r15), %rsi
movq %rbx, %rdi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3f1cd
// File: /workspace/github_c_makefile_star2_O1/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
movq %r14, %rdi
movl $0xa, %esi
callq 0x17678
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3f295
movq 0x18(%r14), %rdi
movl 0x10(%r14), %esi
callq 0x45094
movq %rax, %rbx
movq %r14, %rdi
callq 0x17741
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3f488
movq %rbx, %rdi
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x4f838
cmpl $0xb, %eax
jne 0x3f4b4
movq %rbx, %rdi
callq 0x4f838
movq 0x18(%rax), %r14
movq %rbx, %rdi
callq 0x4f838
movl 0x10(%rax), %esi
movq %r14, %rdi
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x45094
leaq -0x30(%rbp), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x17678
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3ef10
movq 0x18(%r14), %rdi
movl 0x10(%r14), %esi
callq 0x45094
movq %rax, %rbx
movq %r14, %rdi
callq 0x17741
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3f535
xorl %edi, %edi
callq 0x17757
movq %rax, %rdi
leaq -0x58(%rbp), %r13
movq %rdi, -0x28(%r13)
movl %r12d, -0x20(%r13)
movl $0x0, -0x1c(%r13)
movl %r15d, -0x18(%r13)
movl %r14d, -0x14(%r13)
xorps %xmm0, %xmm0
movups %xmm0, -0x10(%r13)
movq %r13, %rdi
movl $0xa, %esi
callq 0x47df0
leaq -0x80(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x403ce
movq %r13, %rdi
callq 0x47e7c
movq (%r14), %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq