LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/parse.c
// Function: write_codepoint
static void write_codepoint(JanetParser *p, int32_t codepoint) {
    if (codepoint <= 0x7F) {
        push_buf(p, (uint8_t) codepoint);
    } else if (codepoint <= 0x7FF) {
        push_buf(p, (uint8_t)((codepoint >>  6) & 0x1F) | 0xC0);
        push_buf(p, (uint8_t)((codepoint >>  0) & 0x3F) | 0x80);
    } else if (codepoint <= 0xFFFF) {
        push_buf(p, (uint8_t)((codepoint >> 12) & 0x0F) | 0xE0);
        push_buf(p, (uint8_t)((codepoint >>  6) & 0x3F) | 0x80);
        push_buf(p, (uint8_t)((codepoint >>  0) & 0x3F) | 0x80);
    } else {
        push_buf(p, (uint8_t)((codepoint >> 18) & 0x07) | 0xF0);
        push_buf(p, (uint8_t)((codepoint >> 12) & 0x3F) | 0x80);
        push_buf(p, (uint8_t)((codepoint >>  6) & 0x3F) | 0x80);
        push_buf(p, (uint8_t)((codepoint >>  0) & 0x3F) | 0x80);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x7f, -0xc(%rbp)
jg 0x52bd9
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %eax
movzbl %al, %esi
callq 0x52810
jmp 0x52cfb
cmpl $0x7ff, -0xc(%rbp)      # imm = 0x7FF
jg 0x52c21
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %eax
sarl $0x6, %eax
andl $0x1f, %eax
movzbl %al, %eax
orl $0xc0, %eax
movzbl %al, %esi
callq 0x52810
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %eax
sarl $0x0, %eax
andl $0x3f, %eax
movzbl %al, %eax
orl $0x80, %eax
movzbl %al, %esi
callq 0x52810
jmp 0x52cf9
cmpl $0xffff, -0xc(%rbp)     # imm = 0xFFFF
jg 0x52c83
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %eax
sarl $0xc, %eax
andl $0xf, %eax
movzbl %al, %eax
orl $0xe0, %eax
movzbl %al, %esi
callq 0x52810
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %eax
sarl $0x6, %eax
andl $0x3f, %eax
movzbl %al, %eax
orl $0x80, %eax
movzbl %al, %esi
callq 0x52810
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %eax
sarl $0x0, %eax
andl $0x3f, %eax
movzbl %al, %eax
orl $0x80, %eax
movzbl %al, %esi
callq 0x52810
jmp 0x52cf7
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %eax
sarl $0x12, %eax
andl $0x7, %eax
movzbl %al, %eax
orl $0xf0, %eax
movzbl %al, %esi
callq 0x52810
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %eax
sarl $0xc, %eax
andl $0x3f, %eax
movzbl %al, %eax
orl $0x80, %eax
movzbl %al, %esi
callq 0x52810
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %eax
sarl $0x6, %eax
andl $0x3f, %eax
movzbl %al, %eax
orl $0x80, %eax
movzbl %al, %esi
callq 0x52810
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %eax
sarl $0x0, %eax
andl $0x3f, %eax
movzbl %al, %eax
orl $0x80, %eax
movzbl %al, %esi
callq 0x52810
jmp 0x52cf9
jmp 0x52cfb
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/parse.c
// Function: check_str_const
static int check_str_const(const char *cstr, const uint8_t *str, int32_t len) {
    int32_t index;
    for (index = 0; index < len; index++) {
        uint8_t c = str[index];
        uint8_t k = ((const uint8_t *)cstr)[index];
        if (c < k) return -1;
        if (c > k) return 1;
        if (k == '\0') break;
    }
    return (cstr[index] == '\0') ? 0 : -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x52d8c
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x21(%rbp)
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x22(%rbp)
movzbl -0x21(%rbp), %eax
movzbl -0x22(%rbp), %ecx
cmpl %ecx, %eax
jge 0x52d5f
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x52da8
movzbl -0x21(%rbp), %eax
movzbl -0x22(%rbp), %ecx
cmpl %ecx, %eax
jle 0x52d74
movl $0x1, -0x4(%rbp)
jmp 0x52da8
movzbl -0x22(%rbp), %eax
cmpl $0x0, %eax
jne 0x52d7f
jmp 0x52d8c
jmp 0x52d81
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x52d26
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %edx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
xorl %ecx, %ecx
cmpl $0x0, %edx
cmovel %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/parse.c
// Function: parser_state_frames
static Janet parser_state_frames(const JanetParser *p) {
    int32_t count = (int32_t) p->statecount;
    JanetArray *states = janet_array(count);
    states->count = count;
    uint8_t *buf = p->buf;
    /* Iterate arg stack backwards */
    Janet *args = p->argcount ? p->args + p->argcount : p->args; /* avoid ptr arithmetic on NULL */
    for (int32_t i = count - 1; i >= 0; --i) {
        JanetParseState *s = p->states + i;
        /* avoid ptr arithmetic on args if NULL */
        if ((s->flags & PFLAG_CONTAINER) && s->argn) {
            args -= s->argn;
        }
        states->data[i] = janet_wrap_parse_state(s, args, buf, (uint32_t) p->bufcount);
    }
    return janet_wrap_array(states);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %edi
callq 0x13180
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x52e10
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x20(%rcx), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x50(%rbp)
jmp 0x52e1b
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x14(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jl 0x52eda
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x34(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movl 0x8(%rax), %eax
andl $0x100, %eax            # imm = 0x100
cmpl $0x0, %eax
je 0x52e86
movq -0x40(%rbp), %rax
cmpl $0x0, 0x4(%rax)
je 0x52e86
movq -0x40(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x30(%rbp), %rax
movslq %ecx, %rdx
xorl %ecx, %ecx
subq %rdx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x58(%rbp)
movslq -0x34(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x40(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movl %eax, %ecx
callq 0x530a0
movq -0x60(%rbp), %rcx
movq %rax, %rdx
movq -0x58(%rbp), %rax
movq %rdx, -0x48(%rbp)
movq -0x48(%rbp), %rdx
movq %rdx, (%rax,%rcx,8)
movl -0x34(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x52e2c
movq -0x20(%rbp), %rdi
movabsq $-0x4800000000000, %rsi # imm = 0xFFFB800000000000
callq 0x7b610
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/peg.c
// Function: peg_mark
static int peg_mark(void *p, size_t size) {
    (void) size;
    JanetPeg *peg = (JanetPeg *)p;
    if (NULL != peg->constants)
        for (uint32_t i = 0; i < peg->num_constants; i++)
            janet_mark(peg->constants[i]);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpq 0x8(%rcx), %rax
je 0x535c8
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jae 0x535c6
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x1c(%rbp), %ecx
movq (%rax,%rcx,8), %rdi
callq 0x38b90
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x5359b
jmp 0x535c8
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/peg.c
// Function: cfun_peg_getter
static int cfun_peg_getter(JanetAbstract a, Janet key, Janet *out) {
    (void) a;
    if (!janet_checktype(key, JANET_KEYWORD))
        return 0;
    return janet_getmethod(janet_unwrap_keyword(key), peg_methods, out);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rsi, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
xorl %eax, %eax
testb $0x1, %al
jne 0x535ec
jmp 0x53612
movsd -0x10(%rbp), %xmm0
ucomisd %xmm0, %xmm0
setp %al
testb $0x1, %al
jne 0x535fe
jmp 0x53638
movq -0x10(%rbp), %rax
shrq $0x2f, %rax
andq $0xf, %rax
cmpq $0x0, %rax
je 0x53638
jmp 0x5362f
movabsq $-0x800000000000, %rax  # imm = 0xFFFF800000000000
andq -0x10(%rbp), %rax
movabsq $-0x5000000000000, %rcx # imm = 0xFFFB000000000000
cmpq %rcx, %rax
je 0x53638
movl $0x0, -0x4(%rbp)
jmp 0x53657
movq -0x10(%rbp), %rdi
callq 0x7b260
movq %rax, %rdi
movq -0x20(%rbp), %rdx
leaq 0x5d501(%rip), %rsi     # 0xb0b50
callq 0x1ae90
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/peg.c
// Function: peg_marshal
static void peg_marshal(void *p, JanetMarshalContext *ctx) {
    JanetPeg *peg = (JanetPeg *)p;
    janet_marshal_size(ctx, peg->bytecode_len);
    janet_marshal_int(ctx, (int32_t)peg->num_constants);
    janet_marshal_abstract(ctx, p);
    for (size_t i = 0; i < peg->bytecode_len; i++)
        janet_marshal_int(ctx, (int32_t) peg->bytecode[i]);
    for (uint32_t j = 0; j < peg->num_constants; j++)
        janet_marshal_janet(ctx, peg->constants[j]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x404b0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x18(%rax), %esi
callq 0x405a0
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x41700
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x536e1
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movl (%rax,%rcx,4), %esi
callq 0x405a0
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x536ae
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jae 0x53717
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x24(%rbp), %ecx
movq (%rax,%rcx,8), %rsi
callq 0x40800
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x536e8
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/peg.c
// Function: compile_peg
static JanetPeg *compile_peg(Janet x) {
    Builder builder;
    builder.grammar = janet_table(0);
    builder.default_grammar = NULL;
    {
        Janet default_grammarv = janet_dyn("peg-grammar");
        if (janet_checktype(default_grammarv, JANET_TABLE)) {
            builder.default_grammar = janet_unwrap_table(default_grammarv);
        }
    }
    builder.tags = janet_table(0);
    builder.constants = NULL;
    builder.bytecode = NULL;
    builder.nexttag = 1;
    builder.form = x;
    builder.depth = JANET_RECURSION_GUARD;
    builder.has_backref = 0;
    peg_compile1(&builder, x);
    JanetPeg *peg = make_peg(&builder);
    builder_cleanup(&builder);
    return peg;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
xorl %edi, %edi
callq 0x692f0
movq %rax, -0x48(%rbp)
movq $0x0, -0x40(%rbp)
leaq 0x41357(%rip), %rdi     # 0x9523d
callq 0x1ce50
movq %rax, -0x50(%rbp)
xorl %eax, %eax
testb $0x1, %al
jne 0x53ef7
jmp 0x53f1d
movsd -0x50(%rbp), %xmm0
ucomisd %xmm0, %xmm0
setp %al
testb $0x1, %al
jne 0x53f09
jmp 0x53f3a
movq -0x50(%rbp), %rax
shrq $0x2f, %rax
andq $0xf, %rax
cmpq $0x0, %rax
je 0x53f3a
jmp 0x53f47
movabsq $-0x800000000000, %rax  # imm = 0xFFFF800000000000
andq -0x50(%rbp), %rax
movabsq $-0x3800000000000, %rcx # imm = 0xFFFC800000000000
cmpq %rcx, %rax
jne 0x53f47
movq -0x50(%rbp), %rdi
callq 0x7b260
movq %rax, -0x40(%rbp)
xorl %edi, %edi
callq 0x692f0
movq %rax, -0x38(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x0, -0x28(%rbp)
movl $0x1, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x400, -0x18(%rbp)     # imm = 0x400
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x571d0
leaq -0x48(%rbp), %rdi
callq 0x57ca0
movq %rax, -0x58(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x57e20
movq -0x58(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/peg.c
// Function: peg_call_reset
static void peg_call_reset(PegCall *c) {
    c->s.depth = JANET_RECURSION_GUARD;
    c->s.captures->count = 0;
    c->s.tagged_captures->count = 0;
    c->s.scratch->count = 0;
    c->s.tags->count = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x400, 0x64(%rax)      # imm = 0x400
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movl $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movl $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movl $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movl $0x0, 0x10(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x120, %rsp            # imm = 0x120
movq %rdi, -0x8(%rbp)
leaq -0x120(%rbp), %rdi
leaq 0x57d73(%rip), %rsi     # 0xaeed0
movl $0x118, %edx            # imm = 0x118
callq 0x12680
movq -0x8(%rbp), %rdi
leaq -0x120(%rbp), %rdx
xorl %eax, %eax
movl %eax, %esi
callq 0x6bd40
leaq 0x57cde(%rip), %rdi     # 0xaee60
callq 0x6c180
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/peg.c
// Function: make_peg
static JanetPeg *make_peg(Builder *b) {
    size_t bytecode_start = size_padded(sizeof(JanetPeg), sizeof(uint32_t));
    size_t bytecode_size = janet_v_count(b->bytecode) * sizeof(uint32_t);
    size_t constants_start = size_padded(bytecode_start + bytecode_size, sizeof(Janet));
    size_t constants_size = janet_v_count(b->constants) * sizeof(Janet);
    size_t total_size = constants_start + constants_size;
    char *mem = janet_abstract(&janet_peg_type, total_size);
    JanetPeg *peg = (JanetPeg *)mem;
    peg->bytecode = (uint32_t *)(mem + bytecode_start);
    peg->constants = (Janet *)(mem + constants_start);
    peg->num_constants = janet_v_count(b->constants);
    safe_memcpy(peg->bytecode, b->bytecode, bytecode_size);
    safe_memcpy(peg->constants, b->constants, constants_size);
    peg->bytecode_len = janet_v_count(b->bytecode);
    peg->has_backref = b->has_backref;
    return peg;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl $0x20, %edi
movl $0x4, %esi
callq 0x57190
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x57cda
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movl -0x4(%rax), %eax
movl %eax, -0x44(%rbp)
jmp 0x57ce1
xorl %eax, %eax
movl %eax, -0x44(%rbp)
jmp 0x57ce1
movl -0x44(%rbp), %eax
cltq
shlq $0x2, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
addq -0x18(%rbp), %rdi
movl $0x8, %esi
callq 0x57190
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x57d1f
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movl -0x4(%rax), %eax
movl %eax, -0x48(%rbp)
jmp 0x57d26
xorl %eax, %eax
movl %eax, -0x48(%rbp)
jmp 0x57d26
movl -0x48(%rbp), %eax
cltq
shlq $0x3, %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rsi
leaq 0x57116(%rip), %rdi     # 0xaee60
callq 0x12de0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rcx
addq -0x10(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rcx
addq -0x20(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x57d95
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movl -0x4(%rax), %eax
movl %eax, -0x4c(%rbp)
jmp 0x57d9c
xorl %eax, %eax
movl %eax, -0x4c(%rbp)
jmp 0x57d9c
movl -0x4c(%rbp), %ecx
movq -0x40(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x40(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0x6ae40
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x28(%rbp), %rdx
callq 0x6ae40
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x57df2
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movl -0x4(%rax), %eax
movl %eax, -0x50(%rbp)
jmp 0x57df9
xorl %eax, %eax
movl %eax, -0x50(%rbp)
jmp 0x57df9
movl -0x50(%rbp), %eax
movslq %eax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movl 0x38(%rax), %ecx
movq -0x40(%rbp), %rax
movl %ecx, 0x1c(%rax)
movq -0x40(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x57eea
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movl -0x4(%rax), %eax
movl %eax, -0x24(%rbp)
jmp 0x57ef1
xorl %eax, %eax
movl %eax, -0x24(%rbp)
jmp 0x57ef1
movl -0x24(%rbp), %eax
movl %eax, -0x8(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x57f93
movq -0x18(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x57f3a
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movl -0x4(%rax), %eax
addl $0x1, %eax
movq -0x18(%rbp), %rcx
movq 0x20(%rcx), %rcx
cmpl -0x8(%rcx), %eax
jl 0x57f5e
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
movl $0x1, %esi
movl $0x4, %edx
callq 0x70760
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
jmp 0x57f60
jmp 0x57f60
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x20(%rcx), %rdx
movl -0x4(%rdx), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x4(%rdx)
movslq %ecx, %rcx
movl $0x0, (%rax,%rcx,4)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x57f0c
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x58071
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movl -0x4(%rax), %eax
movl %eax, -0x28(%rbp)
jmp 0x58078
xorl %eax, %eax
movl %eax, -0x28(%rbp)
jmp 0x58078
movl -0x28(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x580a4
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movl -0x4(%rax), %eax
addl $0x1, %eax
movq -0x8(%rbp), %rcx
movq 0x20(%rcx), %rcx
cmpl -0x8(%rcx), %eax
jl 0x580c8
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movl $0x1, %esi
movl $0x4, %edx
callq 0x70760
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
jmp 0x580ca
jmp 0x580ca
movl -0xc(%rbp), %edx
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x20(%rcx), %rsi
movl -0x4(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, -0x4(%rsi)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x58114
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movl -0x4(%rax), %eax
addl $0x1, %eax
movq -0x8(%rbp), %rcx
movq 0x20(%rcx), %rcx
cmpl -0x8(%rcx), %eax
jl 0x58138
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movl $0x1, %esi
movl $0x4, %edx
callq 0x70760
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
jmp 0x5813a
jmp 0x5813a
movl -0x10(%rbp), %edx
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x20(%rcx), %rsi
movl -0x4(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, -0x4(%rsi)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl -0x10(%rbp), %eax
addl $0x3, %eax
sarl $0x2, %eax
movl %eax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x581f8
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x5819f
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movl -0x4(%rax), %eax
addl $0x1, %eax
movq -0x8(%rbp), %rcx
movq 0x20(%rcx), %rcx
cmpl -0x8(%rcx), %eax
jl 0x581c3
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movl $0x1, %esi
movl $0x4, %edx
callq 0x70760
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
jmp 0x581c5
jmp 0x581c5
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x20(%rcx), %rdx
movl -0x4(%rdx), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x4(%rdx)
movslq %ecx, %rcx
movl $0x0, (%rax,%rcx,4)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x58171
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movl -0x1c(%rbp), %eax
shlq $0x2, %rax
addq %rax, %rdi
addq $0x8, %rdi
movq -0x18(%rbp), %rsi
movslq -0x10(%rbp), %rdx
callq 0x12680
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl $0x2, %edx
callq 0x58360
movq -0x8(%rbp), %rdi
movl $0x4, %esi
callq 0x57ec0
movq %rax, -0x28(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x583c0
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x571d0
movl %eax, -0x30(%rbp)
movl -0x2c(%rbp), %ecx
movl -0x2c(%rbp), %r8d
movl -0x30(%rbp), %r9d
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl $0xb, %edx
callq 0x58420
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rsi, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x57ff0
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jge 0x5840c
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rsi
leaq 0x3cfb0(%rip), %rdi     # 0x953a9
movb $0x0, %al
callq 0x5bdd0
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x57e80
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl $0x1, %edx
movl $0x2, %ecx
callq 0x59770
movq -0x8(%rbp), %rdi
movl $0x3, %esi
callq 0x57ec0
movq %rax, -0x28(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x59800
movl %eax, -0x2c(%rbp)
cmpl $0x2, -0xc(%rbp)
jne 0x585ce
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x59800
movl %eax, -0x34(%rbp)
jmp 0x585d5
xorl %eax, %eax
movl %eax, -0x34(%rbp)
jmp 0x585d5
movl -0x34(%rbp), %eax
movl %eax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movl $0x1, 0x38(%rax)
movl -0x2c(%rbp), %ecx
movl -0x30(%rbp), %r8d
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl $0xc, %edx
callq 0x599f0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl $0x2, %edx
movl $0x3, %ecx
callq 0x59770
movq -0x8(%rbp), %rdi
movl $0x4, %esi
callq 0x57ec0
movq %rax, -0x28(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x571d0
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x59c40
movl %eax, -0x30(%rbp)
cmpl $0x3, -0xc(%rbp)
jne 0x58692
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x59800
movl %eax, -0x38(%rbp)
jmp 0x58699
xorl %eax, %eax
movl %eax, -0x38(%rbp)
jmp 0x58699
movl -0x38(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x2c(%rbp), %ecx
movl -0x30(%rbp), %r8d
movl -0x34(%rbp), %r9d
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl $0x13, %edx
callq 0x58420
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl $0x1, %edx
movl $0x2, %ecx
callq 0x59770
movq -0x8(%rbp), %rdi
movl $0x3, %esi
callq 0x57ec0
movq %rax, -0x28(%rbp)
movq %rdx, -0x20(%rbp)
movl -0xc(%rbp), %edx
xorl %eax, %eax
movl $0x1, %ecx
cmpl $0x2, %edx
cmovel %ecx, %eax
movl %eax, -0x2c(%rbp)
cmpl $0x2, -0xc(%rbp)
jne 0x5876d
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x57ff0
movl %eax, -0x38(%rbp)
jmp 0x58774
xorl %eax, %eax
movl %eax, -0x38(%rbp)
jmp 0x58774
movl -0x38(%rbp), %eax
movl %eax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x571d0
movl %eax, -0x34(%rbp)
movl -0x30(%rbp), %ecx
movl -0x34(%rbp), %r8d
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl $0x5, %edx
callq 0x599f0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl $0x1, %edx
callq 0x58360
movq -0x8(%rbp), %rdi
movl $0x4, %esi
callq 0x57ec0
movq %rax, -0x28(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x571d0
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %r9d
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl $0xb, %edx
xorl %ecx, %ecx
movl $0x1, %r8d
callq 0x58420
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl $0x1, %edx
movl $0x2, %ecx
callq 0x59770
movq -0x8(%rbp), %rdi
movl $0x3, %esi
callq 0x57ec0
movq %rax, -0x28(%rbp)
movq %rdx, -0x20(%rbp)
cmpl $0x2, -0xc(%rbp)
jne 0x588cb
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x59800
movl %eax, -0x34(%rbp)
jmp 0x588d2
xorl %eax, %eax
movl %eax, -0x34(%rbp)
jmp 0x588d2
movl -0x34(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x583c0
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %ecx
movl -0x2c(%rbp), %r8d
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl $0xf, %edx
callq 0x599f0
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl $0x2, %edx
callq 0x58360
movq -0x8(%rbp), %rdi
movl $0x4, %esi
callq 0x57ec0
movq %rax, -0x28(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x583c0
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x571d0
movl %eax, -0x30(%rbp)
movl -0x2c(%rbp), %ecx
movl -0x30(%rbp), %r9d
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl $0xb, %edx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
callq 0x58420
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/peg.c
// Function: spec_atmost
static void spec_atmost(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, 0, n, subrule);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl $0x2, %edx
callq 0x58360
movq -0x8(%rbp), %rdi
movl $0x4, %esi
callq 0x57ec0
movq %rax, -0x28(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x583c0
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x571d0
movl %eax, -0x30(%rbp)
movl -0x2c(%rbp), %r8d
movl -0x30(%rbp), %r9d
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl $0xb, %edx
xorl %ecx, %ecx
callq 0x58420
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl $0x3, %edx
callq 0x58360
movq -0x8(%rbp), %rdi
movl $0x4, %esi
callq 0x57ec0
movq %rax, -0x28(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x583c0
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x583c0
movl %eax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x571d0
movl %eax, -0x34(%rbp)
movl -0x2c(%rbp), %ecx
movl -0x30(%rbp), %r8d
movl -0x34(%rbp), %r9d
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl $0xb, %edx
callq 0x58420
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl $0x2, %edx
movl $0x3, %ecx
callq 0x59770
movq -0x8(%rbp), %rdi
movl $0x4, %esi
callq 0x57ec0
movq %rax, -0x28(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x571d0
movl %eax, -0x2c(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
xorl %eax, %eax
testb $0x1, %al
jne 0x58b76
jmp 0x58ba3
movsd -0x38(%rbp), %xmm0
ucomisd %xmm0, %xmm0
setp %al
testb $0x1, %al
jne 0x58b8b
jmp 0x58c31
movq -0x38(%rbp), %rax
shrq $0x2f, %rax
andq $0xf, %rax
cmpq $0x0, %rax
je 0x58c31
jmp 0x58bc0
movabsq $-0x800000000000, %rax  # imm = 0xFFFF800000000000
andq -0x38(%rbp), %rax
movabsq $-0x2000000000000, %rcx # imm = 0xFFFE000000000000
cmpq %rcx, %rax
je 0x58c31
xorl %eax, %eax
testb $0x1, %al
jne 0x58bc8
jmp 0x58bee
movsd -0x38(%rbp), %xmm0
ucomisd %xmm0, %xmm0
setp %al
testb $0x1, %al
jne 0x58bda
jmp 0x58c31
movq -0x38(%rbp), %rax
shrq $0x2f, %rax
andq $0xf, %rax
cmpq $0x0, %rax
je 0x58c31
jmp 0x58c0b
movabsq $-0x800000000000, %rax  # imm = 0xFFFF800000000000
andq -0x38(%rbp), %rax
movabsq $-0x1800000000000, %rcx # imm = 0xFFFE800000000000
cmpq %rcx, %rax
je 0x58c31
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x38(%rbp), %rsi
leaq 0x3c8b0(%rip), %rdi     # 0x954ce
movb $0x0, %al
callq 0x5bdd0
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x57e80
cmpl $0x3, -0xc(%rbp)
jne 0x58c4d
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x59800
movl %eax, -0x4c(%rbp)
jmp 0x58c54
xorl %eax, %eax
movl %eax, -0x4c(%rbp)
jmp 0x58c54
movl -0x4c(%rbp), %eax
movl %eax, -0x3c(%rbp)
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x59c40
movl %eax, -0x40(%rbp)
movl -0x2c(%rbp), %ecx
movl -0x40(%rbp), %r8d
movl -0x3c(%rbp), %r9d
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl $0x14, %edx
callq 0x58420
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl -0xc(%rbp), %edi
movl $0x1, %esi
movl $0x2, %edx
callq 0x1ae30
movq -0x8(%rbp), %rdi
movl $0x3, %esi
callq 0x57ec0
movq %rax, -0x28(%rbp)
movq %rdx, -0x20(%rbp)
cmpl $0x2, -0xc(%rbp)
jne 0x58d17
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x59800
movl %eax, -0x30(%rbp)
jmp 0x58d1e
xorl %eax, %eax
movl %eax, -0x30(%rbp)
jmp 0x58d1e
movl -0x30(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x59c40
movl %eax, %ecx
movl -0x2c(%rbp), %r8d
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl $0x10, %edx
callq 0x599f0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x58dfa
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x57ec0
movq %rax, -0x28(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
xorps %xmm0, %xmm0
callq 0x7b820
movq -0x40(%rbp), %rdi
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rsi
callq 0x571d0
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %ecx
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl $0x15, %edx
callq 0x57fb0
jmp 0x58e0f
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl $0x15, %ecx
callq 0x59680
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl $0x2, %edx
movl $0x3, %ecx
callq 0x59770
movq -0x8(%rbp), %rdi
movl $0x4, %esi
callq 0x57ec0
movq %rax, -0x28(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x583c0
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x571d0
movl %eax, -0x30(%rbp)
cmpl $0x3, -0xc(%rbp)
jne 0x58ff2
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x59800
movl %eax, -0x38(%rbp)
jmp 0x58ff9
xorl %eax, %eax
movl %eax, -0x38(%rbp)
jmp 0x58ff9
movl -0x38(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x2c(%rbp), %ecx
movl -0x30(%rbp), %r8d
movl -0x34(%rbp), %r9d
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl $0x23, %edx
callq 0x58420
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl $0x1, %edx
movl $0x3, %ecx
callq 0x59770
movq -0x8(%rbp), %rdi
movl $0x4, %esi
callq 0x57ec0
movq %rax, -0x28(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x2c(%rbp)
cmpl $0x2, -0xc(%rbp)
jl 0x59109
xorl %eax, %eax
testb $0x1, %al
jne 0x59088
jmp 0x590b6
movq -0x18(%rbp), %rax
movsd 0x8(%rax), %xmm0
ucomisd %xmm0, %xmm0
setp %al
testb $0x1, %al
jne 0x5909e
jmp 0x59107
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
shrq $0x2f, %rax
andq $0xf, %rax
cmpq $0x0, %rax
je 0x59107
jmp 0x590d7
movq -0x18(%rbp), %rcx
movabsq $-0x800000000000, %rax  # imm = 0xFFFF800000000000
andq 0x8(%rcx), %rax
movabsq $-0x7800000000000, %rcx # imm = 0xFFF8800000000000
cmpq %rcx, %rax
je 0x59107
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x6d480
cmpl $0x0, %eax
jne 0x590eb
jmp 0x59168
movq -0x18(%rbp), %rax
cvttsd2si 0x8(%rax), %eax
movl %eax, -0x2c(%rbp)
cmpl $0x2, -0x2c(%rbp)
jb 0x59103
cmpl $0x24, -0x2c(%rbp)
jbe 0x59105
jmp 0x59168
jmp 0x59107
jmp 0x59109
cmpl $0x3, -0xc(%rbp)
jne 0x59125
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x59800
movl %eax, -0x38(%rbp)
jmp 0x5912c
xorl %eax, %eax
movl %eax, -0x38(%rbp)
jmp 0x5912c
movl -0x38(%rbp), %eax
movl %eax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x571d0
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %ecx
movl -0x2c(%rbp), %r8d
movl -0x30(%rbp), %r9d
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl $0x1f, %edx
callq 0x58420
addq $0x40, %rsp
popq %rbp
retq
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0x3c39d(%rip), %rdi     # 0x9551c
movb $0x0, %al
callq 0x5bdd0
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x57e80
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl $0x1, %edx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x59770
cmpl $0x1, -0xc(%rbp)
jne 0x5925d
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x57ec0
movq %rax, -0x28(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x59ef0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movzbl (%rax), %eax
movq -0x30(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
shll $0x10, %ecx
orl %ecx, %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %ecx
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl $0x3, %edx
callq 0x57fb0
jmp 0x59315
movq -0x8(%rbp), %rdi
movl $0x9, %esi
callq 0x57ec0
movq %rax, -0x48(%rbp)
movq %rdx, -0x40(%rbp)
leaq -0x70(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x12420
movl $0x0, -0x74(%rbp)
movl -0x74(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x592fa
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movslq -0x74(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x59ef0
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x84(%rbp)
movl -0x84(%rbp), %eax
movq -0x80(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
cmpl %ecx, %eax
ja 0x592ed
leaq -0x70(%rbp), %rdi
movl -0x84(%rbp), %eax
movzbl %al, %esi
callq 0x59fe0
movl -0x84(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x84(%rbp)
jmp 0x592b8
jmp 0x592ef
movl -0x74(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x74(%rbp)
jmp 0x5928a
leaq -0x70(%rbp), %r8
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
movl $0x4, %edx
movl $0x8, %ecx
callq 0x582c0
addq $0x90, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl $0x1, %edx
callq 0x58360
movq -0x8(%rbp), %rdi
movl $0x9, %esi
callq 0x57ec0
movq %rax, -0x28(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x5a020
movq %rax, -0x30(%rbp)
leaq -0x50(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x12420
movl $0x0, -0x54(%rbp)
movl -0x54(%rbp), %eax
movq -0x30(%rbp), %rcx
cmpl -0x8(%rcx), %eax
jge 0x593b1
leaq -0x50(%rbp), %rdi
movq -0x30(%rbp), %rax
movslq -0x54(%rbp), %rcx
movzbl (%rax,%rcx), %esi
callq 0x59fe0
movl -0x54(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x54(%rbp)
jmp 0x59385
leaq -0x50(%rbp), %r8
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl $0x4, %edx
movl $0x8, %ecx
callq 0x582c0
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl $0x2, %edx
callq 0x58360
movq -0x8(%rbp), %rdi
movl $0x3, %esi
callq 0x57ec0
movq %rax, -0x28(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x571d0
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x571d0
movl %eax, -0x30(%rbp)
movl -0x2c(%rbp), %ecx
movl -0x30(%rbp), %r8d
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl $0x22, %edx
callq 0x599f0
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl $0x1, %edx
callq 0x58360
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x57ec0
movq %rax, -0x30(%rbp)
movq %rdx, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x571d0
movl %eax, -0x34(%rbp)
movl -0x1c(%rbp), %edx
movl -0x34(%rbp), %ecx
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x57fb0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)