LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/src/core/os.c
// Function: janet_signal_callback
static void janet_signal_callback(JanetEVGenericMessage msg) {
    int sig = msg.tag;
    if (msg.argi) janet_interpreter_interrupt_handled(NULL);
    Janet handlerv = janet_table_get(&janet_vm.signal_handlers, janet_wrap_integer(sig));
    if (!janet_checktype(handlerv, JANET_FUNCTION)) {
        /* Let another thread/process try to handle this */
        sigset_t set;
        sigemptyset(&set);
        sigaddset(&set, sig);
#ifdef JANET_THREADS
        pthread_sigmask(SIG_BLOCK, &set, NULL);
#else
        sigprocmask(SIG_BLOCK, &set, NULL);
#endif
        raise(sig);
        return;
    }
    JanetFunction *handler = janet_unwrap_function(handlerv);
    JanetFiber *fiber = janet_fiber(handler, 64, 0, NULL);
    janet_schedule_soon(fiber, janet_wrap_nil(), JANET_SIGNAL_OK);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x80, %rsp
movl 0x10(%rbp), %ebx
cmpl $0x0, 0x14(%rbp)
je 0x38a4d
xorl %edi, %edi
callq 0x45019
movq %fs:0x0, %rax
leaq -0x348(%rax), %rax
leaq 0x2c8(%rax), %r14
xorps %xmm0, %xmm0
cvtsi2sd %ebx, %xmm0
callq 0x4fab8
movq %r14, %rdi
movq %rax, %rsi
callq 0x47f51
movq %rax, %rcx
shrq $0x2f, %rcx
cmpl $0x1fffc, %ecx          # imm = 0x1FFFC
jne 0x38acd
movq %rax, %rdi
callq 0x4f838
movq %rax, %rdi
movl $0x40, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x29abc
movq %rax, %rbx
movabsq $-0x77fffffffffff, %rdi # imm = 0xFFF8800000000001
callq 0x4f95a
movq %rbx, %rdi
movq %rax, %rsi
xorl %edx, %edx
addq $0x80, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x22cd0
leaq -0x90(%rbp), %r14
movq %r14, %rdi
callq 0x12600
movq %r14, %rdi
movl %ebx, %esi
callq 0x12bd0
xorl %edi, %edi
movq %r14, %rsi
xorl %edx, %edx
callq 0x12080
movl %ebx, %edi
callq 0x120a0
addq $0x80, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/src/core/os.c
// Function: janet_proc_mark
static int janet_proc_mark(void *p, size_t s) {
    (void) s;
    JanetProc *proc = (JanetProc *)p;
    if (NULL != proc->in) janet_mark(janet_wrap_abstract(proc->in));
    if (NULL != proc->out) janet_mark(janet_wrap_abstract(proc->out));
    if (NULL != proc->err) janet_mark(janet_wrap_abstract(proc->err));
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
movabsq $-0x1000000000000, %rbx # imm = 0xFFFF000000000000
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x38b69
movq %rbx, %rsi
callq 0x4f9f2
movq %rax, %rdi
callq 0x2b15b
movq 0x18(%r14), %rdi
testq %rdi, %rdi
je 0x38b82
movq %rbx, %rsi
callq 0x4f9f2
movq %rax, %rdi
callq 0x2b15b
movq 0x20(%r14), %rdi
testq %rdi, %rdi
je 0x38b9b
movq %rbx, %rsi
callq 0x4f9f2
movq %rax, %rdi
callq 0x2b15b
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/src/core/os.c
// Function: janet_proc_get
static int janet_proc_get(void *p, Janet key, Janet *out) {
    JanetProc *proc = (JanetProc *)p;
    if (janet_keyeq(key, "in")) {
        *out = (NULL == proc->in) ? janet_wrap_nil() : janet_wrap_abstract(proc->in);
        return 1;
    }
    if (janet_keyeq(key, "out")) {
        *out = (NULL == proc->out) ? janet_wrap_nil() : janet_wrap_abstract(proc->out);
        return 1;
    }
    if (janet_keyeq(key, "err")) {
        *out = (NULL == proc->err) ? janet_wrap_nil() : janet_wrap_abstract(proc->err);
        return 1;
    }
#ifndef JANET_WINDOWS
    if (janet_keyeq(key, "pid")) {
        *out = janet_wrap_number(proc->pid);
        return 1;
    }
#endif
    if ((-1 != proc->return_code) && janet_keyeq(key, "return-code")) {
        *out = janet_wrap_integer(proc->return_code);
        return 1;
    }
    if (!janet_checktype(key, JANET_KEYWORD)) return 0;
    return janet_getmethod(janet_unwrap_keyword(key), proc_methods, out);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x207f6(%rip), %rsi     # 0x593b2
movq %r14, %rdi
callq 0x193f7
testl %eax, %eax
je 0x38bce
movq 0x10(%r15), %rdi
jmp 0x38bfe
leaq 0x2698c(%rip), %rsi     # 0x5f561
movq %r14, %rdi
callq 0x193f7
testl %eax, %eax
je 0x38be7
movq 0x18(%r15), %rdi
jmp 0x38bfe
leaq 0x22e30(%rip), %rsi     # 0x5ba1e
movq %r14, %rdi
callq 0x193f7
testl %eax, %eax
je 0x38c36
movq 0x20(%r15), %rdi
testq %rdi, %rdi
je 0x38c14
movabsq $-0x1000000000000, %rsi # imm = 0xFFFF000000000000
callq 0x4f9f2
jmp 0x38c23
movabsq $-0x77fffffffffff, %rdi # imm = 0xFFF8800000000001
callq 0x4f95a
movq %rax, (%rbx)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2e77e(%rip), %rsi     # 0x673bb
movq %r14, %rdi
callq 0x193f7
testl %eax, %eax
je 0x38c56
cvtsi2sdl 0x4(%r15), %xmm0
callq 0x4fab8
jmp 0x38c23
cmpl $-0x1, 0x8(%r15)
je 0x38c78
leaq 0x2e88f(%rip), %rsi     # 0x674f3
movq %r14, %rdi
callq 0x193f7
testl %eax, %eax
je 0x38c78
cvtsi2sdl 0x8(%r15), %xmm0
jmp 0x38c4f
movq %r14, %rcx
shrq $0x2f, %rcx
xorl %eax, %eax
cmpl $0x1fff6, %ecx          # imm = 0x1FFF6
jne 0x38c2b
movq %r14, %rdi
callq 0x4f838
leaq 0x4b498(%rip), %rsi     # 0x84130
movq %rax, %rdi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1930f
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/src/core/os.c
// Function: janet_getjstream
static JanetHandle janet_getjstream(Janet *argv, int32_t n, void **orig) {
#ifdef JANET_EV
    JanetStream *stream = janet_checkabstract(argv[n], &janet_stream_type);
    if (stream != NULL) {
        if (stream->flags & JANET_STREAM_CLOSED)
            janet_panic("stream is closed");
        *orig = stream;
        return stream->handle;
    }
#endif
    JanetFile *f = janet_checkabstract(argv[n], &janet_file_type);
    if (f != NULL) {
        if (f->flags & JANET_FILE_CLOSED) {
            janet_panic("file is closed");
        }
        *orig = f;
#ifdef JANET_WINDOWS
        return (HANDLE) _get_osfhandle(_fileno(f->file));
#else
        return fileno(f->file);
#endif
    }
    janet_panicf("expected file|stream, got %v", argv[n]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
leaq 0x4873b(%rip), %rsi     # 0x81410
callq 0x19a7e
testq %rax, %rax
je 0x38cef
testb $0x1, 0x4(%rax)
jne 0x38d18
movq %rax, (%rbx)
movl (%rax), %eax
popq %rbx
popq %r14
popq %rbp
retq
movq (%r14), %rdi
leaq 0x498f7(%rip), %rsi     # 0x825f0
callq 0x19a7e
testq %rax, %rax
je 0x38d24
testb $0x20, 0x8(%rax)
jne 0x38d35
movq %rax, (%rbx)
movq (%rax), %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x12700
leaq 0x22c8c(%rip), %rdi     # 0x5b9ab
callq 0x19263
movq (%r14), %rsi
leaq 0x2e860(%rip), %rdi     # 0x6758e
xorl %eax, %eax
callq 0x1917b
leaq 0x26688(%rip), %rdi     # 0x5f3c4
callq 0x19263
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/src/core/os.c
// Function: get_stdio_for_handle
static JanetStream *get_stdio_for_handle(JanetHandle handle, void *orig, int iswrite) {
    if (orig == NULL) {
        return janet_stream(handle, iswrite ? JANET_STREAM_WRITABLE : JANET_STREAM_READABLE, NULL);
    } else if (janet_abstract_type(orig) == &janet_file_type) {
        JanetFile *jf = (JanetFile *)orig;
        uint32_t flags = 0;
        if (jf->flags & JANET_FILE_WRITE) {
            flags |= JANET_STREAM_WRITABLE;
        }
        if (jf->flags & JANET_FILE_READ) {
            flags |= JANET_STREAM_READABLE;
        }
        /* duplicate handle when converting file to stream */
#ifdef JANET_WINDOWS
        HANDLE prochandle = GetCurrentProcess();
        HANDLE newHandle = INVALID_HANDLE_VALUE;
        if (!DuplicateHandle(prochandle, handle, prochandle, &newHandle, 0, FALSE, DUPLICATE_SAME_ACCESS)) {
            return NULL;
        }
#else
        int newHandle = dup(handle);
        if (newHandle < 0) {
            return NULL;
        }
#endif
        return janet_stream(newHandle, flags, NULL);
    } else {
        return orig;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x38d63
movq -0x10(%rsi), %rax
cmpq 0x4d239(%rip), %rax     # 0x85f90
je 0x38d76
movq %rsi, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
xorl %esi, %esi
testl %edx, %edx
setne %sil
shll $0x9, %esi
addl $0x200, %esi            # imm = 0x200
jmp 0x38dc5
movl 0x8(%rsi), %ebx
callq 0x123e0
testl %eax, %eax
js 0x38dd2
andl $0x3, %ebx
rolw $0x8, %bx
movl %ebx, %ecx
shrl $0x4, %ecx
movl $0xf0f, %edx            # imm = 0xF0F
andl %edx, %ecx
andl %edx, %ebx
shll $0x4, %ebx
orl %ecx, %ebx
movl $0x3333, %ecx           # imm = 0x3333
movl %ebx, %edx
andl %ecx, %edx
shrl $0x2, %ebx
andl %ecx, %ebx
leal (%rbx,%rdx,4), %ecx
movl %ecx, %edx
andl $0x5550, %edx           # imm = 0x5550
shrl %ecx
andl $0x5540, %ecx           # imm = 0x5540
leal (%rcx,%rdx,2), %esi
shrl $0x5, %esi
movl %eax, %edi
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x22910
xorl %esi, %esi
jmp 0x38d59
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/src/core/parse.c
// Function: janet_valid_utf8
int janet_valid_utf8(const uint8_t *str, int32_t len) {
    int32_t i = 0;
    int32_t j;
    while (i < len) {
        int32_t nexti;
        uint8_t c = str[i];

        /* Check the number of bytes in code point */
        if (c < 0x80) nexti = i + 1;
        else if ((c >> 5) == 0x06) nexti = i + 2;
        else if ((c >> 4) == 0x0E) nexti = i + 3;
        else if ((c >> 3) == 0x1E) nexti = i + 4;
        /* Don't allow 5 or 6 byte code points */
        else return 0;

        /* No overflow */
        if (nexti > len) return 0;

        /* Ensure trailing bytes are well formed (10XX XXXX) */
        for (j = i + 1; j < nexti; j++) {
            if ((str[j] >> 6) != 2) return 0;
        }

        /* Check for overlong encoding */
        if ((nexti == i + 2) && str[i] < 0xC2) return 0;
        if ((str[i] == 0xE0) && str[i + 1] < 0xA0) return 0;
        if ((str[i] == 0xF0) && str[i + 1] < 0x90) return 0;

        i = nexti;
    }
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
xorl %eax, %eax
cmpl %esi, %eax
jge 0x3908b
movslq %eax, %rcx
movzbl (%rdi,%rcx), %ecx
testb %cl, %cl
js 0x38fbc
movl $0x1, %r10d
xorl %edx, %edx
jmp 0x38fd5
movl %ecx, %edx
andl $-0x20, %edx
cmpl $0xc0, %edx
jne 0x39055
movl $0x2, %r10d
movb $0x1, %dl
leal (%rax,%r10), %r8d
cmpl %esi, %r8d
jg 0x39015
leal 0x1(%rax), %r9d
testb %cl, %cl
jns 0x39009
movslq %r9d, %r11
addq %rdi, %r11
movl %r10d, %r10d
decq %r10
xorl %ebx, %ebx
movb (%r11,%rbx), %r14b
andb $-0x40, %r14b
negb %r14b
jno 0x39015
incq %rbx
cmpl %ebx, %r10d
jne 0x38ff4
cmpb $-0x3e, %cl
setb %r10b
testb %dl, %r10b
je 0x39027
xorl %edx, %edx
movl %eax, %r8d
movl %r8d, %eax
testb %dl, %dl
jne 0x38f9f
jmp 0x39092
cmpl $0xf0, %ecx
je 0x39048
cmpl $0xe0, %ecx
jne 0x39051
movslq %r9d, %rdx
cmpb $-0x60, (%rdi,%rdx)
jb 0x39015
cmpl $0xf0, %ecx
jne 0x39051
movslq %r9d, %rcx
cmpb $-0x70, (%rdi,%rcx)
jb 0x39015
movb $0x1, %dl
jmp 0x3901a
movl %ecx, %edx
andl $-0x10, %edx
cmpl $0xe0, %edx
jne 0x3906d
movl $0x3, %r10d
jmp 0x38fb8
movl %ecx, %r8d
andl $-0x8, %r8d
movl $0x4, %r10d
xorl %edx, %edx
cmpl $0xf0, %r8d
je 0x38fd5
jmp 0x39017
movl $0x1, %eax
jmp 0x39094
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/src/core/parse.c
// Function: janet_parser_consume
void janet_parser_consume(JanetParser *parser, uint8_t c) {
    int consumed = 0;
    janet_parser_checkdead(parser);
    if (c == '\r') {
        parser->line++;
        parser->column = 0;
    } else if (c == '\n') {
        parser->column = 0;
        if (parser->lookback != '\r')
            parser->line++;
    } else {
        parser->column++;
    }
    while (!consumed && !parser->error) {
        JanetParseState *state = parser->states + parser->statecount - 1;
        consumed = state->consumer(parser, state, c);
    }
    parser->lookback = c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
callq 0x39112
cmpl $0xa, %r14d
je 0x390c5
cmpl $0xd, %r14d
jne 0x390d9
incq 0x50(%rbx)
movq $0x0, 0x58(%rbx)
jmp 0x390dd
movq $0x0, 0x58(%rbx)
cmpl $0xd, 0x68(%rbx)
je 0x390dd
incq 0x50(%rbx)
jmp 0x390dd
incq 0x58(%rbx)
movzbl %r14b, %r14d
cmpq $0x0, 0x8(%rbx)
jne 0x39109
movq 0x10(%rbx), %rax
movq 0x30(%rbx), %rcx
leaq (%rcx,%rcx,4), %rcx
leaq (%rax,%rcx,8), %rsi
addq $-0x28, %rsi
movq %rbx, %rdi
movl %r14d, %edx
callq *0x20(%rsi)
testl %eax, %eax
je 0x390e1
movl %r14d, 0x68(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/src/core/parse.c
// Function: janet_parser_eof
void janet_parser_eof(JanetParser *parser) {
    janet_parser_checkdead(parser);
    size_t oldcolumn = parser->column;
    size_t oldline = parser->line;
    janet_parser_consume(parser, '\n');
    if (parser->statecount > 1) {
        delim_error(parser, parser->statecount - 1, 0, "unexpected end of source");
    }
    parser->line = oldline;
    parser->column = oldcolumn;
    parser->flag |= JANET_PARSER_DEAD;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x39112
movq 0x50(%rbx), %r15
movq 0x58(%rbx), %r14
movq %rbx, %rdi
movl $0xa, %esi
callq 0x39099
movq 0x30(%rbx), %rsi
cmpq $0x2, %rsi
jb 0x39182
decq %rsi
leaq 0x27a14(%rip), %rcx     # 0x60b8c
movq %rbx, %rdi
xorl %edx, %edx
callq 0x39199
movq %r15, 0x50(%rbx)
movq %r14, 0x58(%rbx)
orb $0x1, 0x6c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/src/core/parse.c
// Function: delim_error
static void delim_error(JanetParser *parser, size_t stack_index, char c, const char *msg) {
    JanetParseState *s = parser->states + stack_index;
    JanetBuffer *buffer = janet_buffer(40);
    if (msg) {
        janet_buffer_push_cstring(buffer, msg);
    }
    if (c) {
        janet_buffer_push_u8(buffer, c);
    }
    if (stack_index > 0) {
        janet_buffer_push_cstring(buffer, ", ");
        if (s->flags & PFLAG_PARENS) {
            janet_buffer_push_u8(buffer, '(');
        } else if (s->flags & PFLAG_SQRBRACKETS) {
            janet_buffer_push_u8(buffer, '[');
        } else if (s->flags & PFLAG_CURLYBRACKETS) {
            janet_buffer_push_u8(buffer, '{');
        } else if (s->flags & PFLAG_STRING) {
            janet_buffer_push_u8(buffer, '"');
        } else if (s->flags & PFLAG_LONGSTRING) {
            int32_t i;
            for (i = 0; i < s->argn; i++) {
                janet_buffer_push_u8(buffer, '`');
            }
        }
        janet_formatb(buffer, " opened at line %d, column %d", (int32_t) s->line, (int32_t) s->column);
    }
    parser->error = (const char *) janet_string(buffer->data, buffer->count);
    parser->flag |= JANET_PARSER_GENERATED_ERROR;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r13
movl %edx, %r12d
movq %rsi, %r15
leaq (%rsi,%rsi,4), %rbx
shlq $0x3, %rbx
movq %rdi, -0x30(%rbp)
addq 0x10(%rdi), %rbx
movl $0x28, %edi
callq 0x17757
movq %rax, %r14
testq %r13, %r13
je 0x391dd
movq %r14, %rdi
movq %r13, %rsi
callq 0x178d8
testb %r12b, %r12b
je 0x391ee
movzbl %r12b, %esi
movq %r14, %rdi
callq 0x179a7
testq %r15, %r15
je 0x3926e
leaq 0x2f3dd(%rip), %rsi     # 0x685d7
movq %r14, %rdi
callq 0x178d8
movl 0x8(%rbx), %eax
movb $0x28, %cl
btl $0xa, %eax
jb 0x3924c
movb $0x5b, %cl
btl $0xb, %eax
jb 0x3924c
movb $0x7b, %cl
btl $0xc, %eax
jb 0x3924c
movb $0x22, %cl
btl $0xd, %eax
jb 0x3924c
btl $0xe, %eax
jae 0x39257
cmpl $0x0, 0x4(%rbx)
jle 0x39257
xorl %r15d, %r15d
movq %r14, %rdi
movl $0x60, %esi
callq 0x179a7
incl %r15d
cmpl 0x4(%rbx), %r15d
jl 0x39234
jmp 0x39257
movzbl %cl, %esi
movq %r14, %rdi
callq 0x179a7
movl 0x10(%rbx), %edx
movl 0x18(%rbx), %ecx
leaq 0x2f376(%rip), %rsi     # 0x685da
movq %r14, %rdi
xorl %eax, %eax
callq 0x3fe5a
movq 0x18(%r14), %rdi
movl 0x10(%r14), %esi
callq 0x45094
movq -0x30(%rbp), %rcx
movq %rax, 0x8(%rcx)
orb $0x2, 0x6c(%rcx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/src/core/parse.c
// Function: janet_parser_status
enum JanetParserStatus janet_parser_status(JanetParser *parser) {
    if (parser->error) return JANET_PARSE_ERROR;
    if (parser->flag) return JANET_PARSE_DEAD;
    if (parser->statecount > 1) return JANET_PARSE_PENDING;
    return JANET_PARSE_ROOT;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x1, %eax
cmpq $0x0, 0x8(%rdi)
jne 0x392bd
movl $0x3, %eax
cmpl $0x0, 0x6c(%rdi)
jne 0x392bd
xorl %eax, %eax
cmpq $0x2, 0x30(%rdi)
setae %al
addl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/src/core/parse.c
// Function: janet_parser_flush
void janet_parser_flush(JanetParser *parser) {
    parser->argcount = 0;
    parser->statecount = 1;
    parser->bufcount = 0;
    parser->pending = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
movq %rax, 0x20(%rdi)
movq $0x1, 0x30(%rdi)
movq %rax, 0x40(%rdi)
movq %rax, 0x60(%rdi)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/src/core/parse.c
// Function: janet_parser_error
const char *janet_parser_error(JanetParser *parser) {
    enum JanetParserStatus status = janet_parser_status(parser);
    if (status == JANET_PARSE_ERROR) {
        const char *e = parser->error;
        parser->error = NULL;
        parser->flag &= ~JANET_PARSER_GENERATED_ERROR;
        janet_parser_flush(parser);
        return e;
    }
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x39308
xorl %ecx, %ecx
movq %rcx, 0x8(%rdi)
andb $-0x3, 0x6c(%rdi)
movq %rcx, 0x20(%rdi)
movq $0x1, 0x30(%rdi)
movq %rcx, 0x40(%rdi)
movq %rcx, 0x60(%rdi)
jmp 0x3930a
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/src/core/parse.c
// Function: janet_parser_produce
Janet janet_parser_produce(JanetParser *parser) {
    Janet ret;
    size_t i;
    if (parser->pending == 0) return janet_wrap_nil();
    ret = janet_unwrap_tuple(parser->args[0])[0];
    for (i = 1; i < parser->argcount; i++) {
        parser->args[i - 1] = parser->args[i];
    }
    parser->pending--;
    parser->argcount--;
    parser->states[0].argn--;
    return ret;
}

// Assembly:
cmpq $0x0, 0x60(%rdi)
je 0x3936a
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
movq (%rax), %rdi
callq 0x4f838
movq (%rax), %rax
movq 0x20(%rbx), %rcx
cmpq $0x2, %rcx
jb 0x39351
movl $0x1, %edx
movq (%rbx), %rcx
movq (%rcx,%rdx,8), %rsi
movq %rsi, -0x8(%rcx,%rdx,8)
incq %rdx
movq 0x20(%rbx), %rcx
cmpq %rcx, %rdx
jb 0x39339
decq 0x60(%rbx)
decq %rcx
movq %rcx, 0x20(%rbx)
movq 0x10(%rbx), %rcx
decl 0x4(%rcx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movabsq $-0x77fffffffffff, %rdi # imm = 0xFFF8800000000001
jmp 0x4f95a
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/src/core/parse.c
// Function: janet_parser_produce_wrapped
Janet janet_parser_produce_wrapped(JanetParser *parser) {
    Janet ret;
    size_t i;
    if (parser->pending == 0) return janet_wrap_nil();
    ret = parser->args[0];
    for (i = 1; i < parser->argcount; i++) {
        parser->args[i - 1] = parser->args[i];
    }
    parser->pending--;
    parser->argcount--;
    parser->states[0].argn--;
    return ret;
}

// Assembly:
cmpq $0x0, 0x60(%rdi)
je 0x393c5
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rax
movq 0x20(%rdi), %rcx
movq (%rax), %rax
cmpq $0x2, %rcx
jb 0x393b1
movl $0x1, %edx
movq (%rdi), %rcx
movq (%rcx,%rdx,8), %rsi
movq %rsi, -0x8(%rcx,%rdx,8)
incq %rdx
movq 0x20(%rdi), %rcx
cmpq %rcx, %rdx
jb 0x39399
decq 0x60(%rdi)
decq %rcx
movq %rcx, 0x20(%rdi)
movq 0x10(%rdi), %rcx
decl 0x4(%rcx)
popq %rbp
retq
movabsq $-0x77fffffffffff, %rdi # imm = 0xFFF8800000000001
jmp 0x4f95a
// File: /workspace/github_c_makefile_star2_O1/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 0x30(%rdi), %r15
movq 0x50(%rdi), %r13
movq 0x58(%rdi), %r14
leaq 0x1(%r15), %r12
cmpq 0x38(%rdi), %r12
jbe 0x3946f
movl %edx, -0x2c(%rbp)
movq %rsi, -0x38(%rbp)
movq 0x10(%rbx), %rdi
movq %r12, %rax
shlq $0x4, %rax
leaq (%rax,%rax,4), %rsi
callq 0x12850
testq %rax, %rax
je 0x394a5
leaq (%r12,%r12), %rcx
movq %rax, 0x10(%rbx)
movq %rcx, 0x38(%rbx)
movq -0x38(%rbp), %rsi
movl -0x2c(%rbp), %edx
movq 0x10(%rbx), %rax
leaq (%r15,%r15,4), %rcx
movq $0x0, (%rax,%rcx,8)
movl %edx, 0x8(%rax,%rcx,8)
movq %r13, 0x10(%rax,%rcx,8)
movq %r14, 0x18(%rax,%rcx,8)
movq %rsi, 0x20(%rax,%rcx,8)
movq %r12, 0x30(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x13cf8
// File: /workspace/github_c_makefile_star2_O1/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 0x397a5
movq %r12, %rdi
callq 0x12770
movq %rax, 0x18(%r14)
testq %rax, %rax
je 0x39820
movq 0x18(%rbx), %rsi
movq %rax, %rdi
movq %r12, %rdx
callq 0x12680
testq %r15, %r15
je 0x397cc
shlq $0x3, %r15
movq %r15, %rdi
callq 0x12770
movq %rax, (%r14)
testq %rax, %rax
je 0x39820
movq (%rbx), %rsi
movq %rax, %rdi
movq %r15, %rdx
callq 0x12680
testq %r13, %r13
je 0x39811
addq $0x10, %r14
shlq $0x3, %r13
leaq (,%r13,4), %r15
addq %r13, %r15
movq %r15, %rdi
callq 0x12770
movq %rax, (%r14)
testq %rax, %rax
je 0x39820
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 0x12680
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x13d28
// File: /workspace/github_c_makefile_star2_O1/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 0x3986b
xorl %r14d, %r14d
movq (%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x2b15b
incq %r14
cmpq 0x20(%rbx), %r14
jb 0x39856
testb $0x2, 0x6c(%rbx)
je 0x3988c
movq 0x8(%rbx), %rdi
movabsq $-0x6000000000000, %rsi # imm = 0xFFFA000000000000
callq 0x4f9ad
movq %rax, %rdi
callq 0x2b15b
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3a368
cmpl $0xa, %edx
je 0x3a38e
cmpl $0xd, %edx
je 0x3a38e
jmp 0x3a37f
cmpl $0x22, %edx
je 0x3a389
cmpl $0x5c, %edx
jne 0x3a37f
leaq 0x551(%rip), %rax       # 0x3a8ca
movq %rax, 0x20(%rsi)
jmp 0x3a38e
movzbl %dl, %esi
callq 0x3ac00
jmp 0x3a38e
callq 0x3a9be
movl $0x1, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3a3a8
decq 0x30(%rdi)
movq $0x0, 0x40(%rdi)
jmp 0x3a3b5
pushq %rbp
movq %rsp, %rbp
movzbl %dl, %esi
callq 0x3ac00
popq %rbp
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3a3ed
cmpl $0x5b, %edx
je 0x3a408
cmpl $0x60, %edx
je 0x3a419
cmpl $0x7b, %edx
jne 0x3a44a
leaq -0xf39(%rip), %rsi      # 0x394aa
movq %rbx, %rdi
movl $0x11100, %edx          # imm = 0x11100
jmp 0x3a439
cmpl $0x22, %edx
je 0x3a42a
cmpl $0x28, %edx
jne 0x3a44a
leaq -0xf54(%rip), %rsi      # 0x394aa
movq %rbx, %rdi
movl $0x10500, %edx          # imm = 0x10500
jmp 0x3a439
leaq -0xf65(%rip), %rsi      # 0x394aa
movq %rbx, %rdi
movl $0x10900, %edx          # imm = 0x10900
jmp 0x3a439
leaq 0x4f(%rip), %rsi        # 0x3a46f
movq %rbx, %rdi
movl $0x4200, %edx           # imm = 0x4200
jmp 0x3a439
leaq -0xde(%rip), %rsi       # 0x3a353
movq %rbx, %rdi
movl $0x2200, %edx           # imm = 0x2200
callq 0x39412
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq -0x871(%rip), %rsi      # 0x39be0
movq %rbx, %rdi
movl $0x40000, %edx          # imm = 0x40000
callq 0x39412
movq %rbx, %rdi
movl $0x40, %esi
callq 0x3ac00
xorl %eax, %eax
jmp 0x3a443
// File: /workspace/github_c_makefile_star2_O1/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 0x3a4b7
btl $0x15, %eax
jb 0x3a4d2
incl 0x4(%rbx)
movl $0x1, %r12d
cmpb $0x60, %r15b
je 0x3a4fd
orl $0x100000, %eax         # imm = 0x100000
movl %eax, 0x8(%rbx)
movzbl %r15b, %esi
movq %r14, %rdi
callq 0x3ac00
jmp 0x3a4fd
cmpb $0x60, %r15b
jne 0x3a4eb
andl $0xffcfffff, %eax       # imm = 0xFFCFFFFF
orl $0x200000, %eax         # imm = 0x200000
movl %eax, 0x8(%rbx)
movl $0x1, (%rbx)
jmp 0x3a4f7
movl (%rbx), %eax
movl 0x4(%rbx), %ecx
cmpl %ecx, %eax
jne 0x3a509
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3a9be
xorl %r12d, %r12d
jmp 0x3a4fd
movzbl %r15b, %esi
movq %r14, %rdi
callq 0x3ac00
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 0x3a51f
incl %eax
movl %eax, (%rbx)
jmp 0x3a4f7
cmpl $0x0, (%rbx)
jle 0x3a53c
xorl %r12d, %r12d
movq %r14, %rdi
movl $0x60, %esi
callq 0x3ac00
incl %r12d
cmpl (%rbx), %r12d
jl 0x3a527
movzbl %r15b, %esi
movq %r14, %rdi
callq 0x3ac00
movl $0x0, (%rbx)
movl $0xffcfffff, %eax       # imm = 0xFFCFFFFF
andl 0x8(%rbx), %eax
orl $0x100000, %eax         # imm = 0x100000
movl %eax, 0x8(%rbx)
jmp 0x3a4f7
// File: /workspace/github_c_makefile_star2_O1/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 0x146a0
movslq 0x4(%rbx), %rcx
testq %rcx, %rcx
jle 0x3a5a7
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
jg 0x3a581
movl 0x4(%rbx), %ecx
movl %ecx, 0x10(%rax)
movabsq $-0x4800000000000, %rsi # imm = 0xFFFB800000000000
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x4f9f2
// File: /workspace/github_c_makefile_star2_O1/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 0x48a50
orl %r14d, -0x20(%rax)
movslq 0x4(%r15), %rcx
testq %rcx, %rcx
jle 0x3a610
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
jg 0x3a5ee
movq %rax, %rdi
callq 0x48a81
movabsq $-0x4000000000000, %rsi # imm = 0xFFFC000000000000
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4f9ad
// File: /workspace/github_c_makefile_star2_O1/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, %r14
movq %rdi, %rbx
movl 0x4(%rsi), %edi
sarl %edi
callq 0x47e96
movq %rax, %r15
movq 0x20(%rbx), %rax
movslq 0x4(%r14), %rcx
movq %rax, %r12
subq %rcx, %r12
cmpq %rax, %r12
jae 0x3a683
movq (%rbx), %rax
movq (%rax,%r12,8), %rsi
movq 0x8(%rax,%r12,8), %rdx
movq %r15, %rdi
callq 0x481b3
addq $0x2, %r12
movq 0x20(%rbx), %rax
jmp 0x3a660
movslq 0x4(%r14), %rcx
subq %rcx, %rax
movq %rax, 0x20(%rbx)
movabsq $-0x3800000000000, %rsi # imm = 0xFFFC800000000000
movq %r15, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x4f9f2
// File: /workspace/github_c_makefile_star2_O1/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, %r14
movq %rdi, %rbx
movl 0x4(%rsi), %edi
sarl %edi
callq 0x46f8c
movq %rax, %r15
movq 0x20(%rbx), %rax
movslq 0x4(%r14), %rcx
movq %rax, %r12
subq %rcx, %r12
cmpq %rax, %r12
jae 0x3a6f7
movq (%rbx), %rax
movq (%rax,%r12,8), %rsi
movq 0x8(%rax,%r12,8), %rdx
movq %r15, %rdi
callq 0x472ba
addq $0x2, %r12
movq 0x20(%rbx), %rax
jmp 0x3a6d4
movslq 0x4(%r14), %rcx
subq %rcx, %rax
movq %rax, 0x20(%rbx)
movq %r15, %rdi
callq 0x472c9
movabsq $-0x3000000000000, %rsi # imm = 0xFFFD000000000000
movq %rax, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x4f9ad
// File: /workspace/github_c_makefile_star2_O1/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
movb $-0x1, %al
movb $0x1, %cl
cmpl $0x54, %edx
jle 0x3a8f8
leal -0x61(%rdx), %esi
cmpl $0x19, %esi
ja 0x3a91b
leaq 0x2ce19(%rip), %r8      # 0x67704
movslq (%r8,%rsi,4), %rsi
addq %r8, %rsi
jmpq *%rsi
movb $0x7, %al
jmp 0x3a949
cmpl $0x2f, %edx
jg 0x3a909
cmpl $0x22, %edx
je 0x3a929
cmpl $0x27, %edx
je 0x3a929
jmp 0x3a94b
cmpl $0x30, %edx
je 0x3a915
cmpl $0x3f, %edx
je 0x3a929
jmp 0x3a94b
xorl %ecx, %ecx
xorl %eax, %eax
jmp 0x3a94b
cmpl $0x5c, %edx
je 0x3a929
cmpl $0x55, %edx
jne 0x3a94b
movb $0x1, %al
jmp 0x3a949
xorl %ecx, %ecx
movl %edx, %eax
jmp 0x3a94b
movb $0xb, %al
jmp 0x3a949
movb $0x8, %al
jmp 0x3a949
movb $0xd, %al
jmp 0x3a949
movb $0xc, %al
jmp 0x3a949
movb $0xa, %al
jmp 0x3a949
movb $0x9, %al
jmp 0x3a949
movb $0x1b, %al
xorl %ecx, %ecx
testb %cl, %cl
je 0x3a95c
leaq 0x2dd25(%rip), %rax     # 0x6867b
movq %rax, 0x8(%rdi)
jmp 0x3a9b2
cmpb $0x55, %dl
je 0x3a97e
movzbl %dl, %ecx
cmpl $0x75, %ecx
je 0x3a97e
cmpl $0x78, %ecx
jne 0x3a99f
movq $0x2, (%rbx)
leaq 0x2e8(%rip), %rax       # 0x3ac64
jmp 0x3a9ae
xorl %eax, %eax
cmpb $0x75, %dl
setne %al
leal 0x4(,%rax,2), %eax
movl %eax, (%rbx)
movl $0x0, 0x4(%rbx)
leaq 0x340(%rip), %rax       # 0x3acdd
jmp 0x3a9ae
movzbl %al, %esi
callq 0x3ac00
leaq -0x65b(%rip), %rax      # 0x3a353
movq %rax, 0x20(%rbx)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3ac79
addl $-0x30, %edx
jmp 0x3ac97
leal -0x41(%rdx), %eax
cmpb $0x5, %al
ja 0x3ac85
addl $-0x37, %edx
jmp 0x3ac97
leal -0x61(%rdx), %eax
addl $-0x57, %edx
cmpb $0x6, %al
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmovbl %edx, %eax
movl %eax, %edx
testl %edx, %edx
js 0x3acc6
movl 0x4(%rbx), %eax
shll $0x4, %eax
addl %edx, %eax
movl %eax, 0x4(%rbx)
decl (%rbx)
jne 0x3acd1
movzbl %al, %esi
callq 0x3ac00
movl $0x0, 0x4(%rbx)
leaq -0x96d(%rip), %rax      # 0x3a353
movq %rax, 0x20(%rbx)
jmp 0x3acd1
leaq 0x2d9cd(%rip), %rax     # 0x6869a
movq %rax, 0x8(%rdi)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3acf9
addl $-0x30, %edx
jmp 0x3ad17
leal -0x41(%rdx), %eax
cmpb $0x5, %al
ja 0x3ad05
addl $-0x37, %edx
jmp 0x3ad17
leal -0x61(%rdx), %eax
addl $-0x57, %edx
cmpb $0x6, %al
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmovbl %edx, %eax
movl %eax, %edx
testl %edx, %edx
js 0x3ad40
movl 0x4(%rbx), %r15d
shll $0x4, %r15d
addl %edx, %r15d
movl %r15d, 0x4(%rbx)
decl (%rbx)
jne 0x3ad4b
cmpl $0x110000, %r15d        # imm = 0x110000
jl 0x3ad5b
leaq 0x2d9a0(%rip), %rax     # 0x686de
jmp 0x3ad47
leaq 0x2d973(%rip), %rax     # 0x686ba
movq %rax, 0x8(%r14)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x7f, %r15d
jle 0x3adcc
movl %r15d, %eax
cmpl $0x7ff, %r15d           # imm = 0x7FF
jg 0x3ad76
shrl $0x6, %eax
andb $0x1f, %al
orb $-0x40, %al
jmp 0x3adb9
cmpl $0xffff, %r15d          # imm = 0xFFFF
jg 0x3ad88
shrl $0xc, %eax
andb $0xf, %al
orb $-0x20, %al
jmp 0x3ada4
shrl $0x12, %eax
andb $0x7, %al
orb $-0x10, %al
movzbl %al, %esi
movq %r14, %rdi
callq 0x3ac00
movl %r15d, %eax
shrl $0xc, %eax
andb $0x3f, %al
orb $-0x80, %al
movzbl %al, %esi
movq %r14, %rdi
callq 0x3ac00
movl %r15d, %eax
shrl $0x6, %eax
andb $0x3f, %al
orb $-0x80, %al
movzbl %al, %esi
movq %r14, %rdi
callq 0x3ac00
andb $0x3f, %r15b
orb $-0x80, %r15b
movzbl %r15b, %esi
movq %r14, %rdi
callq 0x3ac00
movl $0x0, 0x4(%rbx)
leaq -0xa93(%rip), %rax      # 0x3a353
movq %rax, 0x20(%rbx)
jmp 0x3ad4b
// File: /workspace/github_c_makefile_star2_O1/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
xorl %ecx, %ecx
testl %edx, %edx
jle 0x3ae51
movl %edx, %r8d
xorl %edx, %edx
movb (%rdi,%rdx), %r11b
cmpb %r11b, (%rsi,%rdx)
jae 0x3ae15
movl $0x1, %r10d
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x3ae32
movl $0x1, %eax
movl $0x1, %r10d
ja 0x3ae32
xorl %r10d, %r10d
testb %r11b, %r11b
sete %r10b
addl %r10d, %r10d
movl %r9d, %eax
testl %r10d, %r10d
jne 0x3ae47
incq %rdx
movl %eax, %r9d
cmpq %rdx, %r8
jne 0x3adfe
movl %r8d, %edx
jmp 0x3ae4d
cmpl $0x2, %r10d
jne 0x3ae5a
movl %edx, %eax
jmp 0x3ae53
xorl %eax, %eax
cmpb (%rdi,%rax), %cl
sbbl %ecx, %ecx
movl %ecx, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3b294
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 0x3b27f
movb $0x5b, %sil
btl $0xb, %edx
jb 0x3b27f
movb $0x7b, %sil
btl $0xc, %edx
jb 0x3b27f
movb $0x22, %sil
btl $0xd, %edx
jb 0x3b27f
btl $0xe, %edx
jae 0x3b28b
leaq (%rax,%rcx,8), %r12
cmpl $0x0, 0x4(%r12)
jle 0x3b28b
xorl %r13d, %r13d
movq %rbx, %rdi
movl $0x60, %esi
callq 0x3ac00
incl %r13d
cmpl 0x4(%r12), %r13d
jl 0x3b266
jmp 0x3b28b
movzbl %sil, %esi
movq %rbx, %rdi
callq 0x3ac00
incq %r15
cmpq 0x30(%rbx), %r15
jb 0x3b221
movq 0x18(%rbx), %rdi
addq %r14, %rdi
movl 0x40(%rbx), %esi
subl %r14d, %esi
callq 0x45094
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 0x4f9ad
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x3b302
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0x18(%rdi)
je 0x3b2fe
xorl %r14d, %r14d
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x2b15b
incq %r14
movl 0x18(%rbx), %eax
cmpq %rax, %r14
jb 0x3b2e6
popq %rbx
popq %r14
popq %rbp
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2fa0d
movl 0x18(%r14), %esi
movq %rbx, %rdi
callq 0x2fa6f
movq %rbx, %rdi
movq %r14, %rsi
callq 0x304eb
cmpq $0x0, 0x10(%r14)
je 0x3b394
xorl %r15d, %r15d
movq (%r14), %rax
movl (%rax,%r15,4), %esi
movq %rbx, %rdi
callq 0x2fa6f
incq %r15
cmpq 0x10(%r14), %r15
jb 0x3b37c
cmpl $0x0, 0x18(%r14)
je 0x3b3ba
xorl %r15d, %r15d
movq 0x8(%r14), %rax
movq (%rax,%r15,8), %rsi
movq %rbx, %rdi
callq 0x2fb5d
incq %r15
movl 0x18(%r14), %eax
cmpq %rax, %r15
jb 0x3b39e
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/janet-lang[P]janet/src/core/peg.c
// Function: 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 0x47e96
movq %rax, -0x68(%rbp)
movq $0x0, -0x60(%rbp)
leaq 0x2d825(%rip), %rdi     # 0x68f0d
callq 0x19f23
movq %rax, %rcx
shrq $0x2f, %rcx
cmpl $0x1fff9, %ecx          # imm = 0x1FFF9
jne 0x3b708
movq %rax, %rdi
callq 0x4f838
movq %rax, -0x60(%rbp)
xorl %ebx, %ebx
xorl %edi, %edi
callq 0x47e96
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 0x3d25a
movq 0x20(%r15), %rax
testq %rax, %rax
je 0x3b757
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 0x3b775
movslq -0x4(%rax), %r15
shlq $0x3, %r15
jmp 0x3b778
xorl %r15d, %r15d
leaq (%r15,%r13), %rsi
leaq 0x48ebd(%rip), %rdi     # 0x84640
callq 0x144d2
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 0x3b7a6
movl -0x4(%rax), %r12d
movl %r12d, 0x18(%r14)
movq -0x48(%rbp), %rsi
movq %rbx, %rdx
callq 0x49017
movq 0x8(%r14), %rdi
movq -0x50(%rbp), %rsi
movq %r15, %rdx
callq 0x49017
movq -0x48(%rbp), %rax
testq %rax, %rax
je 0x3b7d5
movslq -0x4(%rax), %rax
jmp 0x3b7d7
xorl %eax, %eax
movq %rax, 0x10(%r14)
leaq -0x68(%rbp), %rdi
movl 0x38(%rdi), %eax
movl %eax, 0x1c(%r14)
callq 0x3d7ce
movq %r14, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq