LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/janet-lang[P]janet/src/core/parse.c
// Function: pushstate
static void pushstate(JanetParser *p, Consumer consumer, int flags) {
    JanetParseState s;
    s.counter = 0;
    s.argn = 0;
    s.flags = flags;
    s.consumer = consumer;
    s.line = p->line;
    s.column = p->column;
    _pushstate(p, s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x50(%rdi), %r12
movq 0x58(%rdi), %r13
movq 0x10(%rdi), %rax
movq 0x30(%rdi), %r15
leaq 0x1(%r15), %r14
cmpq 0x38(%rdi), %r14
jbe 0x38f52
movl %edx, -0x2c(%rbp)
movq %rsi, -0x38(%rbp)
movq %r14, %rcx
shlq $0x4, %rcx
leaq (%rcx,%rcx,4), %rsi
movq %rax, %rdi
callq 0x12840
testq %rax, %rax
je 0x38f84
leaq (%r14,%r14), %rcx
movq %rax, 0x10(%rbx)
movq %rcx, 0x38(%rbx)
movq -0x38(%rbp), %rsi
movl -0x2c(%rbp), %edx
leaq (%r15,%r15,4), %rcx
movq $0x0, (%rax,%rcx,8)
movl %edx, 0x8(%rax,%rcx,8)
movq %r12, 0x10(%rax,%rcx,8)
movq %r13, 0x18(%rax,%rcx,8)
movq %rsi, 0x20(%rax,%rcx,8)
movq %r14, 0x30(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x13ce8
// File: /workspace/github_c_makefile_star2_O3/janet-lang[P]janet/src/core/parse.c
// Function: janet_parser_clone
void janet_parser_clone(const JanetParser *src, JanetParser *dest) {
    /* Misc fields */
    dest->flag = src->flag;
    dest->pending = src->pending;
    dest->lookback = src->lookback;
    dest->line = src->line;
    dest->column = src->column;
    dest->error = src->error;

    /* Keep counts */
    dest->argcount = src->argcount;
    dest->bufcount = src->bufcount;
    dest->statecount = src->statecount;

    /* Capacities are equal to counts */
    dest->bufcap = dest->bufcount;
    dest->statecap = dest->statecount;
    dest->argcap = dest->argcount;

    /* Deep cloned fields */
    dest->args = NULL;
    dest->states = NULL;
    dest->buf = NULL;
    if (dest->bufcap) {
        dest->buf = janet_malloc(dest->bufcap);
        if (!dest->buf) goto nomem;
        memcpy(dest->buf, src->buf, dest->bufcap);
    }
    if (dest->argcap) {
        dest->args = janet_malloc(sizeof(Janet) * dest->argcap);
        if (!dest->args) goto nomem;
        memcpy(dest->args, src->args, dest->argcap * sizeof(Janet));
    }
    if (dest->statecap) {
        dest->states = janet_malloc(sizeof(JanetParseState) * dest->statecap);
        if (!dest->states) goto nomem;
        memcpy(dest->states, src->states, dest->statecap * sizeof(JanetParseState));
    }

    return;

nomem:
    JANET_OUT_OF_MEMORY;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x6c(%rdi), %eax
movl %eax, 0x6c(%rsi)
movq 0x60(%rdi), %rax
movq %rax, 0x60(%rsi)
movl 0x68(%rdi), %eax
movl %eax, 0x68(%rsi)
movq 0x50(%rdi), %rax
movq %rax, 0x50(%rsi)
movq 0x58(%rdi), %rax
movq %rax, 0x58(%rsi)
movq 0x8(%rdi), %rax
movq %rax, 0x8(%rsi)
movq 0x20(%rdi), %r15
movq %r15, 0x20(%rsi)
movq 0x40(%rdi), %r12
movq %r12, 0x40(%rsi)
movq 0x30(%rdi), %r13
movq %r13, 0x30(%rsi)
movq %r12, 0x48(%rsi)
movq %r13, 0x38(%rsi)
movq %r15, 0x28(%rsi)
movq $0x0, (%rsi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rsi)
testq %r12, %r12
je 0x39286
movq %r12, %rdi
callq 0x12760
movq %rax, 0x18(%r14)
testq %rax, %rax
je 0x39301
movq 0x18(%rbx), %rsi
movq %rax, %rdi
movq %r12, %rdx
callq 0x12670
testq %r15, %r15
je 0x392ad
shlq $0x3, %r15
movq %r15, %rdi
callq 0x12760
movq %rax, (%r14)
testq %rax, %rax
je 0x39301
movq (%rbx), %rsi
movq %rax, %rdi
movq %r15, %rdx
callq 0x12670
testq %r13, %r13
je 0x392f2
addq $0x10, %r14
shlq $0x3, %r13
leaq (,%r13,4), %r15
addq %r13, %r15
movq %r15, %rdi
callq 0x12760
movq %rax, (%r14)
testq %rax, %rax
je 0x39301
movq 0x10(%rbx), %rsi
movq %rax, %rdi
movq %r15, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x12670
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x13d18
// File: /workspace/github_c_makefile_star2_O3/janet-lang[P]janet/src/core/parse.c
// Function: parsermark
static int parsermark(void *p, size_t size) {
    size_t i;
    JanetParser *parser = (JanetParser *)p;
    (void) size;
    for (i = 0; i < parser->argcount; i++) {
        janet_mark(parser->args[i]);
    }
    if (parser->flag & JANET_PARSER_GENERATED_ERROR) {
        janet_mark(janet_wrap_string((const uint8_t *) parser->error));
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x20(%rdi)
je 0x3934c
xorl %r14d, %r14d
movq (%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x2aca7
incq %r14
cmpq 0x20(%rbx), %r14
jb 0x39337
testb $0x2, 0x6c(%rbx)
je 0x3936d
movq 0x8(%rbx), %rdi
movabsq $-0x6000000000000, %rsi # imm = 0xFFFA000000000000
callq 0x4ed39
movq %rax, %rdi
callq 0x2aca7
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/janet-lang[P]janet/src/core/parse.c
// Function: stringchar
static int stringchar(JanetParser *p, JanetParseState *state, uint8_t c) {
    /* Enter escape */
    if (c == '\\') {
        state->consumer = escape1;
        return 1;
    }
    /* String end */
    if (c == '"') {
        return stringend(p, state);
    }
    /* normal char */
    if (c != '\n' && c != '\r')
        push_buf(p, c);
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $0x21, %edx
jg 0x39e7d
cmpl $0xa, %edx
je 0x39ea3
cmpl $0xd, %edx
je 0x39ea3
jmp 0x39e94
cmpl $0x22, %edx
je 0x39e9e
cmpl $0x5c, %edx
jne 0x39e94
leaq 0x576(%rip), %rax       # 0x3a404
movq %rax, 0x20(%rsi)
jmp 0x39ea3
movzbl %dl, %esi
callq 0x3a723
jmp 0x39ea3
callq 0x3a4d3
movl $0x1, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/janet-lang[P]janet/src/core/parse.c
// Function: comment
static int comment(JanetParser *p, JanetParseState *state, uint8_t c) {
    (void) state;
    if (c == '\n') {
        p->statecount--;
        p->bufcount = 0;
    } else {
        push_buf(p, c);
    }
    return 1;
}

// Assembly:
cmpl $0xa, %edx
jne 0x39ebd
decq 0x30(%rdi)
movq $0x0, 0x40(%rdi)
jmp 0x39eca
pushq %rbp
movq %rsp, %rbp
movzbl %dl, %esi
callq 0x3a723
popq %rbp
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/janet-lang[P]janet/src/core/parse.c
// Function: atsign
static int atsign(JanetParser *p, JanetParseState *state, uint8_t c) {
    (void) state;
    p->statecount--;
    switch (c) {
        case '{':
            pushstate(p, root, PFLAG_CONTAINER | PFLAG_CURLYBRACKETS | PFLAG_ATSYM);
            return 1;
        case '"':
            pushstate(p, stringchar, PFLAG_BUFFER | PFLAG_STRING);
            return 1;
        case '`':
            pushstate(p, longstring, PFLAG_BUFFER | PFLAG_LONGSTRING);
            return 1;
        case '[':
            pushstate(p, root, PFLAG_CONTAINER | PFLAG_SQRBRACKETS | PFLAG_ATSYM);
            return 1;
        case '(':
            pushstate(p, root, PFLAG_CONTAINER | PFLAG_PARENS | PFLAG_ATSYM);
            return 1;
        default:
            break;
    }
    pushstate(p, tokenchar, PFLAG_TOKEN);
    push_buf(p, '@'); /* Push the leading at-sign that was dropped */
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
decq 0x30(%rdi)
cmpl $0x5a, %edx
jle 0x39f02
cmpl $0x5b, %edx
je 0x39f1d
cmpl $0x60, %edx
je 0x39f2e
cmpl $0x7b, %edx
jne 0x39f5f
leaq -0xf6f(%rip), %rsi      # 0x38f89
movq %rbx, %rdi
movl $0x11100, %edx          # imm = 0x11100
jmp 0x39f4e
cmpl $0x22, %edx
je 0x39f3f
cmpl $0x28, %edx
jne 0x39f5f
leaq -0xf8a(%rip), %rsi      # 0x38f89
movq %rbx, %rdi
movl $0x10500, %edx          # imm = 0x10500
jmp 0x39f4e
leaq -0xf9b(%rip), %rsi      # 0x38f89
movq %rbx, %rdi
movl $0x10900, %edx          # imm = 0x10900
jmp 0x39f4e
leaq 0x4f(%rip), %rsi        # 0x39f84
movq %rbx, %rdi
movl $0x4200, %edx           # imm = 0x4200
jmp 0x39f4e
leaq -0xde(%rip), %rsi       # 0x39e68
movq %rbx, %rdi
movl $0x2200, %edx           # imm = 0x2200
callq 0x38ef2
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq -0x8b5(%rip), %rsi      # 0x396b1
movq %rbx, %rdi
movl $0x40000, %edx          # imm = 0x40000
callq 0x38ef2
movq %rbx, %rdi
movl $0x40, %esi
callq 0x3a723
xorl %eax, %eax
jmp 0x39f58
// File: /workspace/github_c_makefile_star2_O3/janet-lang[P]janet/src/core/parse.c
// Function: longstring
static int longstring(JanetParser *p, JanetParseState *state, uint8_t c) {
    if (state->flags & PFLAG_INSTRING) {
        /* We are inside the long string */
        if (c == '`') {
            state->flags |= PFLAG_END_CANDIDATE;
            state->flags &= ~PFLAG_INSTRING;
            state->counter = 1; /* Use counter to keep track of number of '=' seen */
            return 1;
        }
        push_buf(p, c);
        return 1;
    } else if (state->flags & PFLAG_END_CANDIDATE) {
        int i;
        /* We are checking a potential end of the string */
        if (state->counter == state->argn) {
            stringend(p, state);
            return 0;
        }
        if (c == '`' && state->counter < state->argn) {
            state->counter++;
            return 1;
        }
        /* Failed end candidate */
        for (i = 0; i < state->counter; i++) {
            push_buf(p, '`');
        }
        push_buf(p, c);
        state->counter = 0;
        state->flags &= ~PFLAG_END_CANDIDATE;
        state->flags |= PFLAG_INSTRING;
        return 1;
    } else {
        /* We are at beginning of string */
        state->argn++;
        if (c != '`') {
            state->flags |= PFLAG_INSTRING;
            push_buf(p, c);
        }
        return 1;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %r15d
movq %rsi, %rbx
movq %rdi, %r14
movl 0x8(%rsi), %eax
btl $0x14, %eax
jb 0x39fcc
btl $0x15, %eax
jb 0x39fe7
incl 0x4(%rbx)
movl $0x1, %r12d
cmpb $0x60, %r15b
je 0x3a012
orl $0x100000, %eax         # imm = 0x100000
movl %eax, 0x8(%rbx)
movzbl %r15b, %esi
movq %r14, %rdi
callq 0x3a723
jmp 0x3a012
cmpb $0x60, %r15b
jne 0x3a000
andl $0xffcfffff, %eax       # imm = 0xFFCFFFFF
orl $0x200000, %eax         # imm = 0x200000
movl %eax, 0x8(%rbx)
movl $0x1, (%rbx)
jmp 0x3a00c
movl (%rbx), %eax
movl 0x4(%rbx), %ecx
cmpl %ecx, %eax
jne 0x3a01e
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3a4d3
xorl %r12d, %r12d
jmp 0x3a012
movzbl %r15b, %esi
movq %r14, %rdi
callq 0x3a723
movl $0x1, %r12d
movl %r12d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
cmpb $0x60, %r15b
sete %dl
cmpl %ecx, %eax
setl %cl
testb %cl, %dl
je 0x3a034
incl %eax
movl %eax, (%rbx)
jmp 0x3a00c
testl %eax, %eax
jle 0x3a050
xorl %r12d, %r12d
movq %r14, %rdi
movl $0x60, %esi
callq 0x3a723
incl %r12d
cmpl (%rbx), %r12d
jl 0x3a03b
movzbl %r15b, %esi
movq %r14, %rdi
callq 0x3a723
movl $0x0, (%rbx)
movl $0xffcfffff, %eax       # imm = 0xFFCFFFFF
andl 0x8(%rbx), %eax
orl $0x100000, %eax         # imm = 0x100000
movl %eax, 0x8(%rbx)
jmp 0x3a00c
// File: /workspace/github_c_makefile_star2_O3/janet-lang[P]janet/src/core/parse.c
// Function: close_array
static Janet close_array(JanetParser *p, JanetParseState *state) {
    JanetArray *array = janet_array(state->argn);
    for (int32_t i = state->argn - 1; i >= 0; i--)
        array->data[i] = p->args[--p->argcount];
    array->count = state->argn;
    return janet_wrap_array(array);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl 0x4(%rsi), %edi
callq 0x14690
movslq 0x4(%rbx), %rcx
testq %rcx, %rcx
jle 0x3a0be
incq %rcx
movq 0x18(%rax), %rdx
movq (%r14), %rsi
movq 0x20(%r14), %rdi
leaq -0x1(%rdi), %r8
movq %r8, 0x20(%r14)
movq -0x8(%rsi,%rdi,8), %rsi
movq %rsi, -0x10(%rdx,%rcx,8)
decq %rcx
cmpq $0x1, %rcx
ja 0x3a095
movl 0x4(%rbx), %ecx
movl %ecx, 0x10(%rax)
movabsq $-0x4800000000000, %rsi # imm = 0xFFFB800000000000
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x4ed7e
// File: /workspace/github_c_makefile_star2_O3/janet-lang[P]janet/src/core/parse.c
// Function: close_tuple
static Janet close_tuple(JanetParser *p, JanetParseState *state, int32_t flag) {
    Janet *ret = janet_tuple_begin(state->argn);
    janet_tuple_flag(ret) |= flag;
    for (int32_t i = state->argn - 1; i >= 0; i--)
        ret[i] = p->args[--p->argcount];
    return janet_wrap_tuple(janet_tuple_end(ret));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
movl 0x4(%rsi), %edi
callq 0x47fa0
orl %r14d, -0x20(%rax)
movslq 0x4(%r15), %rcx
testq %rcx, %rcx
jle 0x3a124
incq %rcx
movq (%rbx), %rdx
movq 0x20(%rbx), %rsi
leaq -0x1(%rsi), %rdi
movq %rdi, 0x20(%rbx)
movq -0x8(%rdx,%rsi,8), %rdx
movq %rdx, -0x10(%rax,%rcx,8)
decq %rcx
cmpq $0x1, %rcx
ja 0x3a102
movq %rax, %rdi
callq 0x47fd1
movabsq $-0x4000000000000, %rsi # imm = 0xFFFC000000000000
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4ed39
// File: /workspace/github_c_makefile_star2_O3/janet-lang[P]janet/src/core/parse.c
// Function: close_table
static Janet close_table(JanetParser *p, JanetParseState *state) {
    JanetTable *table = janet_table(state->argn >> 1);
    for (size_t i = p->argcount - state->argn; i < p->argcount; i += 2) {
        Janet key = p->args[i];
        Janet value = p->args[i + 1];
        janet_table_put(table, key, value);
    }
    p->argcount -= state->argn;
    return janet_wrap_table(table);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
movl 0x4(%rsi), %edi
sarl %edi
callq 0x47425
movq %rax, %r14
movq 0x20(%rbx), %rax
movslq 0x4(%r15), %rcx
movq %rax, %r12
subq %rcx, %r12
cmpq %rax, %r12
jae 0x3a1a4
movq (%rbx), %rax
movq (%rax,%r12,8), %rsi
movq 0x8(%rax,%r12,8), %rdx
movq %r14, %rdi
callq 0x476f0
addq $0x2, %r12
movq 0x20(%rbx), %rax
cmpq %rax, %r12
jb 0x3a179
movslq 0x4(%r15), %rcx
subq %rcx, %rax
movq %rax, %r12
movq %r12, 0x20(%rbx)
movabsq $-0x3800000000000, %rsi # imm = 0xFFFC800000000000
movq %r14, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x4ed7e
// File: /workspace/github_c_makefile_star2_O3/janet-lang[P]janet/src/core/parse.c
// Function: close_struct
static Janet close_struct(JanetParser *p, JanetParseState *state) {
    JanetKV *st = janet_struct_begin(state->argn >> 1);
    for (size_t i = p->argcount - state->argn; i < p->argcount; i += 2) {
        Janet key = p->args[i];
        Janet value = p->args[i + 1];
        janet_struct_put(st, key, value);
    }
    p->argcount -= state->argn;
    return janet_wrap_struct(janet_struct_end(st));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
movl 0x4(%rsi), %edi
sarl %edi
callq 0x46574
movq %rax, %r14
movq 0x20(%rbx), %rax
movslq 0x4(%r15), %rcx
movq %rax, %r12
subq %rcx, %r12
cmpq %rax, %r12
jae 0x3a21e
movq (%rbx), %rax
movq (%rax,%r12,8), %rsi
movq 0x8(%rax,%r12,8), %rdx
movq %r14, %rdi
callq 0x468b5
addq $0x2, %r12
movq 0x20(%rbx), %rax
cmpq %rax, %r12
jb 0x3a1f3
movslq 0x4(%r15), %rcx
subq %rcx, %rax
movq %rax, %r12
movq %r12, 0x20(%rbx)
movq %r14, %rdi
callq 0x468c4
movabsq $-0x3000000000000, %rsi # imm = 0xFFFD000000000000
movq %rax, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x4ed39
// File: /workspace/github_c_makefile_star2_O3/janet-lang[P]janet/src/core/parse.c
// Function: escape1
static int escape1(JanetParser *p, JanetParseState *state, uint8_t c) {
    int e = checkescape(c);
    if (e < 0) {
        p->error = "invalid string escape sequence";
        return 1;
    }
    if (c == 'x') {
        state->counter = 2;
        state->argn = 0;
        state->consumer = escapeh;
    } else if (c == 'u' || c == 'U') {
        state->counter = c == 'u' ? 4 : 6;
        state->argn = 0;
        state->consumer = escapeu;
    } else {
        push_buf(p, (uint8_t) e);
        state->consumer = stringchar;
    }
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
cmpl $0x54, %edx
jle 0x3a431
leal -0x61(%rdx), %eax
cmpl $0x19, %eax
ja 0x3a452
leaq 0x2c2d3(%rip), %rcx     # 0x666f4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x7, %dl
jmp 0x3a4b4
cmpl $0x2f, %edx
jg 0x3a442
cmpl $0x22, %edx
je 0x3a4b4
cmpl $0x27, %edx
je 0x3a4b4
jmp 0x3a45c
cmpl $0x30, %edx
je 0x3a44e
cmpl $0x3f, %edx
je 0x3a4b4
jmp 0x3a45c
xorl %edx, %edx
jmp 0x3a4b4
cmpl $0x55, %edx
je 0x3a469
cmpl $0x5c, %edx
je 0x3a4b4
leaq 0x2d1f8(%rip), %rax     # 0x6765b
movq %rax, 0x8(%rdi)
jmp 0x3a4c7
xorl %eax, %eax
cmpb $0x75, %dl
setne %al
leal 0x4(,%rax,2), %eax
movl %eax, (%rbx)
movl $0x0, 0x4(%rbx)
leaq 0x372(%rip), %rax       # 0x3a7fa
jmp 0x3a4c3
movq $0x2, (%rbx)
leaq 0x2f1(%rip), %rax       # 0x3a789
jmp 0x3a4c3
movb $0x9, %dl
jmp 0x3a4b4
movb $0xd, %dl
jmp 0x3a4b4
movb $0xb, %dl
jmp 0x3a4b4
movb $0xc, %dl
jmp 0x3a4b4
movb $0x1b, %dl
jmp 0x3a4b4
movb $0x8, %dl
jmp 0x3a4b4
movb $0xa, %dl
movzbl %dl, %esi
callq 0x3a723
leaq -0x65b(%rip), %rax      # 0x39e68
movq %rax, 0x20(%rbx)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/janet-lang[P]janet/src/core/parse.c
// Function: escapeh
static int escapeh(JanetParser *p, JanetParseState *state, uint8_t c) {
    int digit = to_hex(c);
    if (digit < 0) {
        p->error = "invalid hex digit in hex escape";
        return 1;
    }
    state->argn = (state->argn << 4) + digit;
    state->counter--;
    if (!state->counter) {
        push_buf(p, (uint8_t)(state->argn & 0xFF));
        state->argn = 0;
        state->consumer = stringchar;
    }
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
leal -0x30(%rdx), %eax
cmpb $0x9, %al
ja 0x3a79e
addl $-0x30, %edx
jmp 0x3a7b4
leal -0x41(%rdx), %eax
cmpb $0x5, %al
ja 0x3a7aa
addl $-0x37, %edx
jmp 0x3a7b4
leal -0x61(%rdx), %eax
cmpb $0x5, %al
ja 0x3a7e3
addl $-0x57, %edx
testl %edx, %edx
js 0x3a7e3
movl 0x4(%rbx), %eax
shll $0x4, %eax
addl %edx, %eax
movl %eax, 0x4(%rbx)
decl (%rbx)
jne 0x3a7ee
movzbl %al, %esi
callq 0x3a723
movl $0x0, 0x4(%rbx)
leaq -0x975(%rip), %rax      # 0x39e68
movq %rax, 0x20(%rbx)
jmp 0x3a7ee
leaq 0x2ce90(%rip), %rax     # 0x6767a
movq %rax, 0x8(%rdi)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/janet-lang[P]janet/src/core/parse.c
// Function: escapeu
static int escapeu(JanetParser *p, JanetParseState *state, uint8_t c) {
    int digit = to_hex(c);
    if (digit < 0) {
        p->error = "invalid hex digit in unicode escape";
        return 1;
    }
    state->argn = (state->argn << 4) + digit;
    state->counter--;
    if (!state->counter) {
        if (state->argn > 0x10FFFF) {
            p->error = "invalid unicode codepoint";
            return 1;
        }
        write_codepoint(p, state->argn);
        state->argn = 0;
        state->consumer = stringchar;
    }
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leal -0x30(%rdx), %eax
cmpb $0x9, %al
ja 0x3a816
addl $-0x30, %edx
jmp 0x3a82c
leal -0x41(%rdx), %eax
cmpb $0x5, %al
ja 0x3a822
addl $-0x37, %edx
jmp 0x3a82c
leal -0x61(%rdx), %eax
cmpb $0x5, %al
ja 0x3a855
addl $-0x57, %edx
testl %edx, %edx
js 0x3a855
movl 0x4(%rbx), %r15d
shll $0x4, %r15d
addl %edx, %r15d
movl %r15d, 0x4(%rbx)
decl (%rbx)
jne 0x3a860
cmpl $0x110000, %r15d        # imm = 0x110000
jl 0x3a870
leaq 0x2ce6b(%rip), %rax     # 0x676be
jmp 0x3a85c
leaq 0x2ce3e(%rip), %rax     # 0x6769a
movq %rax, 0x8(%r14)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x7f, %r15d
jle 0x3a8db
movl %r15d, %eax
cmpl $0x7ff, %r15d           # imm = 0x7FF
ja 0x3a889
shrl $0x6, %eax
orb $-0x40, %al
jmp 0x3a8c8
cmpl $0xffff, %r15d          # imm = 0xFFFF
ja 0x3a899
shrl $0xc, %eax
orb $-0x20, %al
jmp 0x3a8b3
shrl $0x12, %eax
orb $-0x10, %al
movzbl %al, %esi
movq %r14, %rdi
callq 0x3a723
movl %r15d, %eax
shrl $0xc, %eax
andb $0x3f, %al
orb $-0x80, %al
movzbl %al, %esi
movq %r14, %rdi
callq 0x3a723
movl %r15d, %eax
shrl $0x6, %eax
andb $0x3f, %al
orb $-0x80, %al
movzbl %al, %esi
movq %r14, %rdi
callq 0x3a723
andb $0x3f, %r15b
orb $-0x80, %r15b
movzbl %r15b, %esi
movq %r14, %rdi
callq 0x3a723
movl $0x0, 0x4(%rbx)
leaq -0xa8d(%rip), %rax      # 0x39e68
movq %rax, 0x20(%rbx)
jmp 0x3a860
// File: /workspace/github_c_makefile_star2_O3/janet-lang[P]janet/src/core/parse.c
// Function: parser_state_delimiters
static Janet parser_state_delimiters(const JanetParser *_p) {
    JanetParser *p = (JanetParser *)_p;
    size_t i;
    const uint8_t *str;
    size_t oldcount;
    oldcount = p->bufcount;
    for (i = 0; i < p->statecount; i++) {
        JanetParseState *s = p->states + i;
        if (s->flags & PFLAG_PARENS) {
            push_buf(p, '(');
        } else if (s->flags & PFLAG_SQRBRACKETS) {
            push_buf(p, '[');
        } else if (s->flags & PFLAG_CURLYBRACKETS) {
            push_buf(p, '{');
        } else if (s->flags & PFLAG_STRING) {
            push_buf(p, '"');
        } else if (s->flags & PFLAG_LONGSTRING) {
            int32_t i;
            for (i = 0; i < s->argn; i++) {
                push_buf(p, '`');
            }
        }
    }
    /* avoid ptr arithmetic on NULL */
    str = janet_string(oldcount ? p->buf + oldcount : p->buf, (int32_t)(p->bufcount - oldcount));
    p->bufcount = oldcount;
    return janet_wrap_string(str);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x40(%rdi), %r14
cmpq $0x0, 0x30(%rdi)
je 0x3ad39
xorl %r15d, %r15d
movq 0x10(%rbx), %rax
leaq (%r15,%r15,4), %rcx
movl 0x8(%rax,%rcx,8), %edx
movb $0x28, %sil
btl $0xa, %edx
jb 0x3ad24
movb $0x5b, %sil
btl $0xb, %edx
jb 0x3ad24
movb $0x7b, %sil
btl $0xc, %edx
jb 0x3ad24
movb $0x22, %sil
btl $0xd, %edx
jb 0x3ad24
btl $0xe, %edx
jae 0x3ad30
leaq (%rax,%rcx,8), %r12
cmpl $0x0, 0x4(%r12)
jle 0x3ad30
xorl %r13d, %r13d
movq %rbx, %rdi
movl $0x60, %esi
callq 0x3a723
incl %r13d
cmpl 0x4(%r12), %r13d
jl 0x3ad0b
jmp 0x3ad30
movzbl %sil, %esi
movq %rbx, %rdi
callq 0x3a723
incq %r15
cmpq 0x30(%rbx), %r15
jb 0x3acc6
movq 0x18(%rbx), %rdi
addq %r14, %rdi
movl 0x40(%rbx), %esi
subl %r14d, %esi
callq 0x44754
movq %r14, 0x40(%rbx)
movabsq $-0x6000000000000, %rsi # imm = 0xFFFA000000000000
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4ed39
nop
// File: /workspace/github_c_makefile_star2_O3/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:
cmpq $0x0, 0x8(%rdi)
je 0x3ada6
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0x18(%rdi)
je 0x3ada2
xorl %r14d, %r14d
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x2aca7
incq %r14
movl 0x18(%rbx), %eax
cmpq %rax, %r14
jb 0x3ad8a
popq %rbx
popq %r14
popq %rbp
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %rsi
movq %rbx, %rdi
callq 0x2f455
movl 0x18(%r14), %esi
movq %rbx, %rdi
callq 0x2f4b7
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2ff4d
cmpq $0x0, 0x10(%r14)
je 0x3ae38
xorl %r15d, %r15d
movq (%r14), %rax
movl (%rax,%r15,4), %esi
movq %rbx, %rdi
callq 0x2f4b7
incq %r15
cmpq 0x10(%r14), %r15
jb 0x3ae20
cmpl $0x0, 0x18(%r14)
je 0x3ae5e
xorl %r15d, %r15d
movq 0x8(%r14), %rax
movq (%rax,%r15,8), %rsi
movq %rbx, %rdi
callq 0x2f5a5
incq %r15
movl 0x18(%r14), %eax
cmpq %rax, %r15
jb 0x3ae42
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/janet-lang[P]janet/src/core/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r14
xorl %edi, %edi
callq 0x47425
movq %rax, -0x68(%rbp)
movq $0x0, -0x60(%rbp)
leaq 0x2cd9c(%rip), %rdi     # 0x67eed
callq 0x19e4d
movq %rax, %rcx
shrq $0x2f, %rcx
cmpl $0x1fff9, %ecx          # imm = 0x1FFF9
jne 0x3b171
movq %rax, %rdi
callq 0x4ebc4
movq %rax, -0x60(%rbp)
xorl %ebx, %ebx
xorl %edi, %edi
callq 0x47425
leaq -0x68(%rbp), %r15
movq %rax, 0x10(%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%r15)
movq %r14, 0x28(%r15)
movabsq $0x100000400, %rax      # imm = 0x100000400
movq %rax, 0x30(%r15)
movl $0x0, 0x38(%r15)
movq %r15, %rdi
movq %r14, %rsi
callq 0x3cb74
movq 0x20(%r15), %rax
testq %rax, %rax
je 0x3b1c0
movslq -0x4(%rax), %rbx
shlq $0x2, %rbx
leaq 0x27(%rbx), %r13
andq $-0x8, %r13
movq -0x50(%rbp), %rax
xorl %r12d, %r12d
testq %rax, %rax
je 0x3b1de
movslq -0x4(%rax), %r15
shlq $0x3, %r15
jmp 0x3b1e1
xorl %r15d, %r15d
leaq (%r15,%r13), %rsi
leaq 0x48454(%rip), %rdi     # 0x83640
callq 0x144c2
movq %rax, %r14
leaq 0x20(%rax), %rdi
movq %rdi, (%rax)
addq %rax, %r13
movq %r13, 0x8(%rax)
movq -0x50(%rbp), %rax
testq %rax, %rax
je 0x3b20f
movl -0x4(%rax), %r12d
movl %r12d, 0x18(%r14)
movq -0x48(%rbp), %rsi
movq %rbx, %rdx
callq 0x48567
movq 0x8(%r14), %rdi
movq -0x50(%rbp), %rsi
movq %r15, %rdx
callq 0x48567
movq -0x48(%rbp), %rax
testq %rax, %rax
je 0x3b23e
movslq -0x4(%rax), %rax
jmp 0x3b240
xorl %eax, %eax
movq %rax, 0x10(%r14)
leaq -0x68(%rbp), %rdi
movl 0x38(%rdi), %eax
movl %eax, 0x1c(%r14)
callq 0x3d0fb
movq %r14, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/janet-lang[P]janet/src/core/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, -0x34(%rbp)
movq %rsi, %rdx
movl %edi, %esi
leaq -0xd0(%rbp), %r15
movq %r15, %rdi
movl $0x1, %ecx
callq 0x3b2d1
xorl %r14d, %r14d
xorl %edi, %edi
callq 0x176f7
movq %rax, -0x30(%rbp)
movl 0x80(%r15), %edx
movl 0x90(%r15), %ebx
cmpl %edx, %ebx
jge 0x3cada
xorl %r15d, %r15d
xorl %r14d, %r14d
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 %ebx, %r13
movq -0x58(%rbp), %rdx
addq %r13, %rdx
leaq -0xc8(%rbp), %rdi
callq 0x3b460
testq %rax, %rax
je 0x3cac8
movq %rax, %r12
movl %ebx, %edx
subl %r14d, %edx
jle 0x3ca80
movslq %r14d, %rsi
addq -0x58(%rbp), %rsi
movq -0x30(%rbp), %rdi
callq 0x178c5
movq -0xa0(%rbp), %rcx
movq -0x58(%rbp), %rax
movl %r12d, %r14d
subl %eax, %r14d
addq %rax, %r13
xorl %r12d, %r12d
movl %r14d, %edx
subl %ebx, %edx
sete %bl
leaq -0x48(%rbp), %rdi
movq %r13, %rsi
callq 0x494b7
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x178c5
cmpl $0x0, -0x34(%rbp)
jne 0x3cad7
movb %bl, %r12b
addl %r14d, %r12d
movl %r12d, %ebx
jmp 0x3caca
incl %ebx
movl -0x50(%rbp), %edx
cmpl %edx, %ebx
jl 0x3ca11
jmp 0x3cada
movl -0x50(%rbp), %edx
subl %r14d, %edx
jle 0x3caef
movslq %r14d, %rsi
addq -0x58(%rbp), %rsi
movq -0x30(%rbp), %rdi
callq 0x178c5
movabsq $-0x2800000000000, %rsi # imm = 0xFFFD800000000000
movq -0x30(%rbp), %rdi
callq 0x4ed7e
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/janet-lang[P]janet/src/core/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 0x46b75(%rip), %rsi     # 0x836b0
leaq -0x130(%rbp), %r14
movl $0x118, %edx            # imm = 0x118
movq %r14, %rdi
callq 0x12670
movq %rbx, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x48d77
leaq 0x46add(%rip), %rdi     # 0x83640
callq 0x49050
addq $0x120, %rsp            # imm = 0x120
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3d17c
movl -0x4(%rax), %r15d
jmp 0x3d17f
xorl %r15d, %r15d
testl %r14d, %r14d
jle 0x3d1c5
movl %r14d, %r12d
testq %rax, %rax
je 0x3d197
movl -0x4(%rax), %ecx
leal 0x1(%rcx), %edx
cmpl -0x8(%rax), %edx
jl 0x3d1b3
movq %rax, %rdi
movl $0x1, %esi
movl $0x4, %edx
callq 0x4b4e8
movq %rax, 0x20(%rbx)
movl -0x4(%rax), %ecx
leal 0x1(%rcx), %edx
movl %edx, -0x4(%rax)
movslq %ecx, %rcx
movl $0x0, (%rax,%rcx,4)
decl %r12d
jne 0x3d187
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_O3/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), %rax
testq %rax, %rax
je 0x3d24e
movl -0x4(%rax), %ecx
leal 0x1(%rcx), %edx
cmpl -0x8(%rax), %edx
jge 0x3d250
movq %rcx, %r12
jmp 0x3d26f
xorl %ecx, %ecx
movq %rcx, %r12
movq %rax, %rdi
movl $0x1, %esi
movl $0x4, %edx
callq 0x4b4e8
movq %rax, 0x20(%r15)
movl -0x4(%rax), %ecx
leal 0x1(%rcx), %edx
movl %edx, -0x4(%rax)
movslq %ecx, %rcx
movl $0x0, (%rax,%rcx,4)
movl -0x4(%rax), %ecx
leal 0x1(%rcx), %edx
cmpl -0x8(%rax), %edx
jl 0x3d2a3
movq %rax, %rdi
movl $0x1, %esi
movl $0x4, %edx
callq 0x4b4e8
movq %rax, 0x20(%r15)
movl -0x4(%rax), %ecx
leal 0x1(%rcx), %edx
movl %edx, -0x4(%rax)
movslq %ecx, %rcx
movl %r14d, (%rax,%rcx,4)
leal 0x3(%r14), %r13d
sarl $0x2, %r13d
testl %r13d, %r13d
jle 0x3d2f3
movl -0x4(%rax), %ecx
leal 0x1(%rcx), %edx
cmpl -0x8(%rax), %edx
jl 0x3d2e1
movq %rax, %rdi
movl $0x1, %esi
movl $0x4, %edx
callq 0x4b4e8
movq %rax, 0x20(%r15)
movl -0x4(%rax), %ecx
leal 0x1(%rcx), %edx
movl %edx, -0x4(%rax)
movslq %ecx, %rcx
movl $0x0, (%rax,%rcx,4)
decl %r13d
jne 0x3d2ba
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 0x12670
// File: /workspace/github_c_makefile_star2_O3/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 0x3d3cd
movq %r14, %rdi
movl $0x4, %esi
callq 0x3d15c
movq %rax, %r15
movq %rdx, %r12
movq (%rbx), %rsi
movq %r14, %rdi
callq 0x3d410
movl %eax, %r13d
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x3cb74
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 0x3d395
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/janet-lang[P]janet/src/core/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 0x3d1db
testl %eax, %eax
js 0x3d42b
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x2ac27(%rip), %rdi     # 0x68059
movq %r14, %rsi
xorl %eax, %eax
callq 0x3f652
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3d135
// File: /workspace/github_c_makefile_star2_O3/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 0x3e1ac
movq %rbx, %rdi
movl $0x3, %esi
callq 0x3d15c
movq %rax, -0x30(%rbp)
movq %rdx, %r15
movq (%r12), %rsi
movq %rbx, %rdi
callq 0x3e1fa
movl %eax, %r13d
xorl %eax, %eax
cmpl $0x2, %r14d
jne 0x3d4f3
movq 0x8(%r12), %rsi
movq %rbx, %rdi
callq 0x3e1fa
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 0x3d395
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/janet-lang[P]janet/src/core/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 0x3e1ac
movq %r15, %rdi
movl $0x4, %esi
callq 0x3d15c
movq %rax, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
movq (%r12), %rsi
movq %r15, %rdi
callq 0x3cb74
movl %eax, %ebx
movq 0x8(%r12), %rsi
movq %r15, %rdi
callq 0x3e44f
movl %eax, %r14d
xorl %eax, %eax
cmpl $0x3, %r13d
jne 0x3d59b
movq 0x10(%r12), %rsi
movq %r15, %rdi
callq 0x3e1fa
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 0x3d395
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/janet-lang[P]janet/src/core/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 0x3e1ac
movq %rbx, %rdi
movl $0x3, %esi
callq 0x3d15c
movq %rax, -0x30(%rbp)
movq %rdx, %r12
xorl %r15d, %r15d
cmpl $0x2, %r13d
jne 0x3d633
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x3d1db
movl %eax, %r15d
xorl %eax, %eax
cmpl $0x2, %r13d
sete %al
movq (%r14,%rax,8), %rsi
movq %rbx, %rdi
callq 0x3cb74
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 0x3d395
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/janet-lang[P]janet/src/core/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 0x3d3cd
movq %r14, %rdi
movl $0x4, %esi
callq 0x3d15c
movq %rax, %r15
movq %rdx, %r12
movq (%rbx), %rsi
movq %r14, %rdi
callq 0x3cb74
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 0x3d395
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/janet-lang[P]janet/src/core/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 0x3e1ac
movq %rbx, %rdi
movl $0x3, %esi
callq 0x3d15c
movq %rax, -0x30(%rbp)
movq %rdx, %r12
xorl %r13d, %r13d
cmpl $0x2, %r15d
jne 0x3d74d
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0x3e1fa
movl %eax, %r13d
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x3d410
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 0x3d395
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/janet-lang[P]janet/src/core/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 0x3d3cd
movq %r14, %rdi
movl $0x4, %esi
callq 0x3d15c
movq %rax, %r15
movq %rdx, %r12
movq (%rbx), %rsi
movq %r14, %rdi
callq 0x3d410
movl %eax, %r13d
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x3cb74
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 0x3d395
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/janet-lang[P]janet/src/core/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 0x3d3cd
movq %rbx, %rdi
movl $0x4, %esi
callq 0x3d15c
movq %rax, -0x30(%rbp)
movq %rdx, %r12
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x3d410
movl %eax, %r13d
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0x3d410
movl %eax, %r15d
movq 0x10(%r14), %rsi
movq %rbx, %rdi
callq 0x3cb74
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 0x3d395
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/janet-lang[P]janet/src/core/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 0x3e1ac
movq %rbx, %rdi
movl $0x4, %esi
callq 0x3d15c
movq %rax, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
movq (%r12), %rsi
movq %rbx, %rdi
callq 0x3cb74
movq 0x8(%r12), %r13
movq %r13, %rcx
btsq $0x2f, %rcx
shrq $0x2f, %rcx
cmpl $0x1fffd, %ecx          # imm = 0x1FFFD
jne 0x3d9fc
movl %eax, -0x2c(%rbp)
xorl %r14d, %r14d
cmpl $0x3, %r15d
jne 0x3d9b9
movq 0x10(%r12), %rsi
movq %rbx, %rdi
callq 0x3e1fa
movl %eax, %r14d
movq %rbx, %rdi
movq %r13, %rsi
callq 0x3e44f
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 0x3d395
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2a77b(%rip), %rdi     # 0x6817e
movq %r13, %rsi
xorl %eax, %eax
callq 0x3f652
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3d135
// File: /workspace/github_c_makefile_star2_O3/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 0x1920c
movq %rbx, %rdi
movl $0x3, %esi
callq 0x3d15c
movq %rax, -0x30(%rbp)
movq %rdx, %r12
xorl %r13d, %r13d
cmpl $0x2, %r15d
jne 0x3da7e
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0x3e1fa
movl %eax, %r13d
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x3e44f
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 0x3d395
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/janet-lang[P]janet/src/core/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 0x3daf0
movq %rbx, %rdi
movl $0x15, %ecx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3e0c6
movq %rbx, %rdi
movl $0x2, %esi
callq 0x3d15c
movq %rax, %r14
movq %rdx, %r15
xorps %xmm0, %xmm0
callq 0x4ee44
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3cb74
leaq -0x1c(%rbp), %r8
movl %eax, (%r8)
movq %r14, %rdi
movq %r15, %rsi
movl $0x15, %edx
movl $0x1, %ecx
callq 0x3d395
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/janet-lang[P]janet/src/core/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 0x3e1ac
movq %r15, %rdi
movl $0x4, %esi
callq 0x3d15c
movq %rax, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
movq (%r12), %rsi
movq %r15, %rdi
callq 0x3d410
movl %eax, %ebx
movq 0x8(%r12), %rsi
movq %r15, %rdi
callq 0x3cb74
movl %eax, %r14d
xorl %eax, %eax
cmpl $0x3, %r13d
jne 0x3dc17
movq 0x10(%r12), %rsi
movq %r15, %rdi
callq 0x3e1fa
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 0x3d395
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq