LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/os.c
// Function: proc_get_status
static int proc_get_status(JanetProc *proc) {
    /* Use POSIX shell semantics for interpreting signals */
    int status = 0;
    pid_t result;
    do {
        result = waitpid(proc->pid, &status, 0);
    } while (result == -1 && errno == EINTR);
    if (WIFEXITED(status)) {
        status = WEXITSTATUS(status);
    } else if (WIFSTOPPED(status)) {
        status = WSTOPSIG(status) + 128;
    } else if (WIFSIGNALED(status)) {
        status = WTERMSIG(status) + 128;
    } else {
        /* Could possibly return -1 but for now, just panic */
        janet_panicf("Undefined status code for process termination, %d.", status);
    }
    return status;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %edi
leaq -0xc(%rbp), %rsi
xorl %edx, %edx
callq 0x12950
movl %eax, -0x10(%rbp)
xorl %eax, %eax
cmpl $-0x1, -0x10(%rbp)
movb %al, -0x11(%rbp)
jne 0x4e6b1
callq 0x12120
cmpl $0x4, (%rax)
sete %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x4e683
movl -0xc(%rbp), %eax
andl $0x7f, %eax
cmpl $0x0, %eax
jne 0x4e6d3
movl -0xc(%rbp), %eax
andl $0xff00, %eax           # imm = 0xFF00
sarl $0x8, %eax
movl %eax, -0xc(%rbp)
jmp 0x4e72d
movl -0xc(%rbp), %eax
andl $0xff, %eax
cmpl $0x7f, %eax
jne 0x4e6f5
movl -0xc(%rbp), %eax
andl $0xff00, %eax           # imm = 0xFF00
sarl $0x8, %eax
addl $0x80, %eax
movl %eax, -0xc(%rbp)
jmp 0x4e72b
movl -0xc(%rbp), %eax
andl $0x7f, %eax
addl $0x1, %eax
movsbl %al, %eax
sarl %eax
cmpl $0x0, %eax
jle 0x4e718
movl -0xc(%rbp), %eax
andl $0x7f, %eax
addl $0x80, %eax
movl %eax, -0xc(%rbp)
jmp 0x4e729
movl -0xc(%rbp), %esi
leaq 0x44df1(%rip), %rdi     # 0x93513
movb $0x0, %al
callq 0x1ac40
jmp 0x4e72b
jmp 0x4e72d
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/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
subq $0xc0, %rsp
leaq 0x10(%rbp), %rax
movl (%rax), %ecx
movl %ecx, -0x4(%rbp)
cmpl $0x0, 0x4(%rax)
je 0x4e763
xorl %eax, %eax
movl %eax, %edi
callq 0x647a0
movq %fs:0x0, %rax
leaq -0x348(%rax), %rax
addq $0x2c8, %rax            # imm = 0x2C8
movq %rax, -0xb8(%rbp)
cvtsi2sdl -0x4(%rbp), %xmm0
callq 0x7b820
movq -0xb8(%rbp), %rdi
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
callq 0x69420
movq %rax, -0x10(%rbp)
xorl %eax, %eax
testb $0x1, %al
jne 0x4e7aa
jmp 0x4e7d0
movsd -0x10(%rbp), %xmm0
ucomisd %xmm0, %xmm0
setp %al
testb $0x1, %al
jne 0x4e7bc
jmp 0x4e824
movq -0x10(%rbp), %rax
shrq $0x2f, %rax
andq $0xf, %rax
cmpq $0x0, %rax
je 0x4e824
jmp 0x4e7ed
movabsq $-0x800000000000, %rax  # imm = 0xFFFF800000000000
andq -0x10(%rbp), %rax
movabsq $-0x2000000000000, %rcx # imm = 0xFFFE000000000000
cmpq %rcx, %rax
je 0x4e824
leaq -0x98(%rbp), %rdi
callq 0x12600
movl -0x4(%rbp), %esi
leaq -0x98(%rbp), %rdi
callq 0x12bd0
xorl %edi, %edi
leaq -0x98(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x12080
movl -0x4(%rbp), %edi
callq 0x120a0
jmp 0x4e88b
movq -0x10(%rbp), %rdi
callq 0x7b260
movq %rax, -0xa0(%rbp)
movq -0xa0(%rbp), %rdi
movl $0x40, %esi
xorl %edx, %edx
xorl %eax, %eax
movl %eax, %ecx
callq 0x36450
movq %rax, -0xa8(%rbp)
movq -0xa8(%rbp), %rax
movq %rax, -0xc0(%rbp)
movabsq $-0x77fffffffffff, %rdi # imm = 0xFFF8800000000001
callq 0x7b460
movq -0xc0(%rbp), %rdi
movq %rax, -0xb0(%rbp)
movq -0xb0(%rbp), %rsi
xorl %edx, %edx
callq 0x2b100
addq $0xc0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/os.c
// Function: janet_proc_gc
static int janet_proc_gc(void *p, size_t s) {
    (void) s;
    JanetProc *proc = (JanetProc *) p;
#ifdef JANET_WINDOWS
    if (!(proc->flags & JANET_PROC_CLOSED)) {
        if (!(proc->flags & JANET_PROC_ALLOW_ZOMBIE)) {
            TerminateProcess(proc->pHandle, 1);
        }
        CloseHandle(proc->pHandle);
        CloseHandle(proc->tHandle);
    }
#else
    if (!(proc->flags & (JANET_PROC_WAITED | JANET_PROC_ALLOW_ZOMBIE))) {
        /* Kill and wait to prevent zombies */
        kill(proc->pid, SIGKILL);
        int status;
        if (!(proc->flags & JANET_PROC_WAITING)) {
            waitpid(proc->pid, &status, 0);
        }
    }
#endif
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
andl $0x82, %eax
cmpl $0x0, %eax
jne 0x4e8fb
movq -0x18(%rbp), %rax
movl 0x4(%rax), %edi
movl $0x9, %esi
callq 0x126e0
movq -0x18(%rbp), %rax
movl (%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
jne 0x4e8f9
movq -0x18(%rbp), %rax
movl 0x4(%rax), %edi
leaq -0x1c(%rbp), %rsi
xorl %edx, %edx
callq 0x12950
jmp 0x4e8fb
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpq 0x10(%rcx), %rax
je 0x4e958
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
movabsq $-0x1000000000000, %rsi # imm = 0xFFFF000000000000
callq 0x7b610
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x38b90
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpq 0x18(%rcx), %rax
je 0x4e988
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
movabsq $-0x1000000000000, %rsi # imm = 0xFFFF000000000000
callq 0x7b610
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x38b90
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpq 0x20(%rcx), %rax
je 0x4e9b8
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
movabsq $-0x1000000000000, %rsi # imm = 0xFFFF000000000000
callq 0x7b610
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x38b90
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x5cc6a(%rip), %rsi     # 0xabc30
callq 0x1c640
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x4f007
movq -0x28(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x4eff1
leaq 0x389cf(%rip), %rdi     # 0x879bb
callq 0x1ad60
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x4f07b
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x5ddf6(%rip), %rsi     # 0xace10
callq 0x1c640
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x4f061
movq -0x30(%rbp), %rax
movl 0x8(%rax), %eax
andl $0x20, %eax
cmpl $0x0, %eax
je 0x4f045
leaq 0x3d40f(%rip), %rdi     # 0x8c44f
callq 0x1ad60
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
movq (%rax), %rdi
callq 0x12700
movl %eax, -0x4(%rbp)
jmp 0x4f07b
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
leaq 0x44629(%rip), %rdi     # 0x9369d
movb $0x0, %al
callq 0x1ac40
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/os.c
// Function: os_execute_cleanup
static void os_execute_cleanup(EnvBlock envp, const char **child_argv) {
#ifdef JANET_WINDOWS
    (void) child_argv;
    if (NULL != envp) janet_sfree(envp);
#else
    janet_sfree((void *)child_argv);
    if (NULL != envp) {
        char **envitem = envp;
        while (*envitem != NULL) {
            janet_sfree(*envitem);
            envitem++;
        }
    }
    janet_sfree(envp);
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3acb0
xorl %eax, %eax
cmpq -0x8(%rbp), %rax
je 0x4f0ff
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x4f0fd
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x3acb0
movq -0x18(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x18(%rbp)
jmp 0x4f0d9
jmp 0x4f0ff
movq -0x8(%rbp), %rdi
callq 0x3acb0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x4f151
movl -0xc(%rbp), %edi
movl -0x1c(%rbp), %ecx
movl $0x200, %esi            # imm = 0x200
movl $0x400, %eax            # imm = 0x400
cmpl $0x0, %ecx
cmovnel %eax, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x2ab20
movq %rax, -0x8(%rbp)
jmp 0x4f1dd
movq -0x18(%rbp), %rax
leaq 0x5dcb4(%rip), %rcx     # 0xace10
cmpq %rcx, -0x10(%rax)
jne 0x4f1d5
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x28(%rbp), %rax
movl 0x8(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x4f18b
movl -0x2c(%rbp), %eax
orl $0x400, %eax            # imm = 0x400
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rax
movl 0x8(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x4f1a5
movl -0x2c(%rbp), %eax
orl $0x200, %eax            # imm = 0x200
movl %eax, -0x2c(%rbp)
movl -0xc(%rbp), %edi
callq 0x123e0
movl %eax, -0x30(%rbp)
cmpl $0x0, -0x30(%rbp)
jge 0x4f1c0
movq $0x0, -0x8(%rbp)
jmp 0x4f1dd
movl -0x30(%rbp), %edi
movl -0x2c(%rbp), %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x2ab20
movq %rax, -0x8(%rbp)
jmp 0x4f1dd
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/os.c
// Function: janet_decode_mode
static const uint8_t *janet_decode_mode(mode_t m) {
    const char *str = "other";
    if (S_ISREG(m)) str = "file";
    else if (S_ISDIR(m)) str = "directory";
    else if (S_ISFIFO(m)) str = "fifo";
    else if (S_ISBLK(m)) str = "block";
    else if (S_ISSOCK(m)) str = "socket";
    else if (S_ISLNK(m)) str = "link";
    else if (S_ISCHR(m)) str = "character";
    return janet_ckeyword(str);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
leaq 0x44191(%rip), %rax     # 0x93743
movq %rax, -0x10(%rbp)
movl -0x4(%rbp), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0x8000, %eax           # imm = 0x8000
jne 0x4f5d5
leaq 0x3d119(%rip), %rax     # 0x8c6e5
movq %rax, -0x10(%rbp)
jmp 0x4f68a
movl -0x4(%rbp), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0x4000, %eax           # imm = 0x4000
jne 0x4f5f4
leaq 0x43bb8(%rip), %rax     # 0x931a3
movq %rax, -0x10(%rbp)
jmp 0x4f688
movl -0x4(%rbp), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0x1000, %eax           # imm = 0x1000
jne 0x4f610
leaq 0x4413f(%rip), %rax     # 0x93749
movq %rax, -0x10(%rbp)
jmp 0x4f686
movl -0x4(%rbp), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0x6000, %eax           # imm = 0x6000
jne 0x4f62c
leaq 0x44128(%rip), %rax     # 0x9374e
movq %rax, -0x10(%rbp)
jmp 0x4f684
movl -0x4(%rbp), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0xc000, %eax           # imm = 0xC000
jne 0x4f648
leaq 0x383b0(%rip), %rax     # 0x879f2
movq %rax, -0x10(%rbp)
jmp 0x4f682
movl -0x4(%rbp), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0xa000, %eax           # imm = 0xA000
jne 0x4f664
leaq 0x43deb(%rip), %rax     # 0x93449
movq %rax, -0x10(%rbp)
jmp 0x4f680
movl -0x4(%rbp), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0x2000, %eax           # imm = 0x2000
jne 0x4f67e
leaq 0x452bc(%rip), %rax     # 0x94936
movq %rax, -0x10(%rbp)
jmp 0x4f680
jmp 0x4f682
jmp 0x4f684
jmp 0x4f686
jmp 0x4f688
jmp 0x4f68a
movq -0x10(%rbp), %rdi
callq 0x68d90
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/os.c
// Function: os_parse_permstring
static int32_t os_parse_permstring(const uint8_t *perm) {
    int32_t m = 0;
    if (perm[0] == 'r') m |= 0400;
    if (perm[1] == 'w') m |= 0200;
    if (perm[2] == 'x') m |= 0100;
    if (perm[3] == 'r') m |= 0040;
    if (perm[4] == 'w') m |= 0020;
    if (perm[5] == 'x') m |= 0010;
    if (perm[6] == 'r') m |= 0004;
    if (perm[7] == 'w') m |= 0002;
    if (perm[8] == 'x') m |= 0001;
    return m;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x72, %eax
jne 0x4f6f6
movl -0xc(%rbp), %eax
orl $0x100, %eax            # imm = 0x100
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x1(%rax), %eax
cmpl $0x77, %eax
jne 0x4f70e
movl -0xc(%rbp), %eax
orl $0x80, %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x2(%rax), %eax
cmpl $0x78, %eax
jne 0x4f724
movl -0xc(%rbp), %eax
orl $0x40, %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x3(%rax), %eax
cmpl $0x72, %eax
jne 0x4f73a
movl -0xc(%rbp), %eax
orl $0x20, %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x4(%rax), %eax
cmpl $0x77, %eax
jne 0x4f750
movl -0xc(%rbp), %eax
orl $0x10, %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x5(%rax), %eax
cmpl $0x78, %eax
jne 0x4f766
movl -0xc(%rbp), %eax
orl $0x8, %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x6(%rax), %eax
cmpl $0x72, %eax
jne 0x4f77c
movl -0xc(%rbp), %eax
orl $0x4, %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x7(%rax), %eax
cmpl $0x77, %eax
jne 0x4f792
movl -0xc(%rbp), %eax
orl $0x2, %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x8(%rax), %eax
cmpl $0x78, %eax
jne 0x4f7a8
movl -0xc(%rbp), %eax
orl $0x1, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4fa90
movzbl -0x9(%rbp), %eax
cmpl $0xd, %eax
jne 0x4f9d9
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x50(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x58(%rax)
jmp 0x4fa1c
movzbl -0x9(%rbp), %eax
cmpl $0xa, %eax
jne 0x4fa0a
movq -0x8(%rbp), %rax
movq $0x0, 0x58(%rax)
movq -0x8(%rbp), %rax
cmpl $0xd, 0x68(%rax)
je 0x4fa08
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x50(%rax)
jmp 0x4fa1a
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x58(%rax)
jmp 0x4fa1c
jmp 0x4fa1e
xorl %eax, %eax
cmpl $0x0, -0x10(%rbp)
movb %al, -0x19(%rbp)
jne 0x4fa3a
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
setne %al
xorb $-0x1, %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x4fa43
jmp 0x4fa7a
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
imulq $0x28, 0x30(%rcx), %rcx
addq %rcx, %rax
addq $-0x28, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movzbl -0x9(%rbp), %edx
callq *%rax
movl %eax, -0x10(%rbp)
jmp 0x4fa1e
movzbl -0x9(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x68(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4fa90
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl $0xa, %esi
callq 0x4f990
movq -0x8(%rbp), %rax
cmpq $0x1, 0x30(%rax)
jbe 0x4fb34
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rsi
subq $0x1, %rsi
xorl %edx, %edx
leaq 0x3d0bd(%rip), %rcx     # 0x8cbec
callq 0x4fb60
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x50(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x58(%rax)
movq -0x8(%rbp), %rax
movl 0x6c(%rax), %ecx
orl $0x1, %ecx
movl %ecx, 0x6c(%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x4fd2c
movl $0x1, -0x4(%rbp)
jmp 0x4fd5a
movq -0x10(%rbp), %rax
cmpl $0x0, 0x6c(%rax)
je 0x4fd3f
movl $0x3, -0x4(%rbp)
jmp 0x4fd5a
movq -0x10(%rbp), %rax
cmpq $0x1, 0x30(%rax)
jbe 0x4fd53
movl $0x2, -0x4(%rbp)
jmp 0x4fd5a
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x8(%rbp), %rax
movq $0x1, 0x30(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x40(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x60(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4fd10
movl %eax, -0x14(%rbp)
cmpl $0x1, -0x14(%rbp)
jne 0x4fdf6
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movl 0x6c(%rax), %ecx
andl $-0x3, %ecx
movl %ecx, 0x6c(%rax)
movq -0x10(%rbp), %rdi
callq 0x4fd60
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x4fdfe
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x60(%rax)
jne 0x4fe3f
movabsq $-0x77fffffffffff, %rdi # imm = 0xFFF8800000000001
callq 0x7b460
movq %rax, -0x8(%rbp)
jmp 0x4fed4
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
callq 0x7b260
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq $0x1, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jae 0x4fe9b
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
subq $0x1, %rcx
movq -0x10(%rbp), %rdx
movq (%rdx), %rdx
movq -0x20(%rbp), %rsi
movq (%rdx,%rsi,8), %rdx
movq %rdx, (%rax,%rcx,8)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x4fe5d
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x60(%rax)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movl 0x4(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x4(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x60(%rax)
jne 0x4ff0f
movabsq $-0x77fffffffffff, %rdi # imm = 0xFFF8800000000001
callq 0x7b460
movq %rax, -0x8(%rbp)
jmp 0x4ff9c
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq $0x1, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jae 0x4ff63
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
subq $0x1, %rcx
movq -0x10(%rbp), %rdx
movq (%rdx), %rdx
movq -0x20(%rbp), %rsi
movq (%rdx,%rsi,8), %rdx
movq %rdx, (%rax,%rcx,8)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x4ff25
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x60(%rax)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movl 0x4(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x4(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/parse.c
// Function: janet_parser_init
void janet_parser_init(JanetParser *parser) {
    parser->args = NULL;
    parser->states = NULL;
    parser->buf = NULL;
    parser->argcount = 0;
    parser->argcap = 0;
    parser->bufcount = 0;
    parser->bufcap = 0;
    parser->statecount = 0;
    parser->statecap = 0;
    parser->error = NULL;
    parser->lookback = -1;
    parser->line = 1;
    parser->column = 0;
    parser->pending = 0;
    parser->flag = 0;

    pushstate(parser, root, PFLAG_CONTAINER);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x40(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x48(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x38(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x68(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movq $0x1, 0x50(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x58(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x60(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x6c(%rax)
movq -0x8(%rbp), %rdi
leaq 0x88(%rip), %rsi        # 0x50100
movl $0x100, %edx            # imm = 0x100
callq 0x50090
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x40(%rbp)
movl $0x0, -0x3c(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x20(%rax)
movups -0x40(%rbp), %xmm0
movups -0x30(%rbp), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x517d0
addq $0x70, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jae 0x50740
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x38b90
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x50710
movq -0x20(%rbp), %rax
movl 0x6c(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x50773
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movabsq $-0x6000000000000, %rsi # imm = 0xFFFA000000000000
callq 0x7b550
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x38b90
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/parse.c
// Function: is_whitespace
static int is_whitespace(uint8_t c) {
    return c == ' '
           || c == '\t'
           || c == '\n'
           || c == '\r'
           || c == '\0'
           || c == '\v'
           || c == '\f';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x1(%rbp)
movzbl -0x1(%rbp), %ecx
movb $0x1, %al
cmpl $0x20, %ecx
movb %al, -0x2(%rbp)
je 0x5191b
movzbl -0x1(%rbp), %ecx
movb $0x1, %al
cmpl $0x9, %ecx
movb %al, -0x2(%rbp)
je 0x5191b
movzbl -0x1(%rbp), %ecx
movb $0x1, %al
cmpl $0xa, %ecx
movb %al, -0x2(%rbp)
je 0x5191b
movzbl -0x1(%rbp), %ecx
movb $0x1, %al
cmpl $0xd, %ecx
movb %al, -0x2(%rbp)
je 0x5191b
movzbl -0x1(%rbp), %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x2(%rbp)
je 0x5191b
movzbl -0x1(%rbp), %ecx
movb $0x1, %al
cmpl $0xb, %ecx
movb %al, -0x2(%rbp)
je 0x5191b
movzbl -0x1(%rbp), %eax
cmpl $0xc, %eax
sete %al
movb %al, -0x2(%rbp)
movb -0x2(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movb %al, -0x19(%rbp)
movzbl -0x19(%rbp), %eax
cmpl $0x5c, %eax
jne 0x51966
movq -0x18(%rbp), %rax
leaq 0x987(%rip), %rcx       # 0x522e0
movq %rcx, 0x20(%rax)
movl $0x1, -0x4(%rbp)
jmp 0x519a7
movzbl -0x19(%rbp), %eax
cmpl $0x22, %eax
jne 0x51981
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x523d0
movl %eax, -0x4(%rbp)
jmp 0x519a7
movzbl -0x19(%rbp), %eax
cmpl $0xa, %eax
je 0x519a0
movzbl -0x19(%rbp), %eax
cmpl $0xd, %eax
je 0x519a0
movq -0x10(%rbp), %rdi
movzbl -0x19(%rbp), %esi
callq 0x52810
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movzbl -0x11(%rbp), %eax
cmpl $0xa, %eax
jne 0x519ec
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x30(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x40(%rax)
jmp 0x519f9
movq -0x8(%rbp), %rdi
movzbl -0x11(%rbp), %esi
callq 0x52810
movl $0x1, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rcx
decq %rcx
movq %rcx, 0x30(%rax)
movzbl -0x19(%rbp), %eax
movl %eax, -0x20(%rbp)
subl $0x22, %eax
je 0x51a93
jmp 0x51a42
movl -0x20(%rbp), %eax
subl $0x28, %eax
je 0x51af0
jmp 0x51a50
movl -0x20(%rbp), %eax
subl $0x5b, %eax
je 0x51ad2
jmp 0x51a5a
movl -0x20(%rbp), %eax
subl $0x60, %eax
je 0x51ab4
jmp 0x51a64
movl -0x20(%rbp), %eax
subl $0x7b, %eax
jne 0x51b0e
jmp 0x51a72
movq -0x10(%rbp), %rdi
leaq -0x197d(%rip), %rsi     # 0x50100
movl $0x11100, %edx          # imm = 0x11100
callq 0x50090
movl $0x1, -0x4(%rbp)
jmp 0x51b3a
movq -0x10(%rbp), %rdi
leaq -0x16e(%rip), %rsi      # 0x51930
movl $0x2200, %edx           # imm = 0x2200
callq 0x50090
movl $0x1, -0x4(%rbp)
jmp 0x51b3a
movq -0x10(%rbp), %rdi
leaq 0x91(%rip), %rsi        # 0x51b50
movl $0x4200, %edx           # imm = 0x4200
callq 0x50090
movl $0x1, -0x4(%rbp)
jmp 0x51b3a
movq -0x10(%rbp), %rdi
leaq -0x19dd(%rip), %rsi     # 0x50100
movl $0x10900, %edx          # imm = 0x10900
callq 0x50090
movl $0x1, -0x4(%rbp)
jmp 0x51b3a
movq -0x10(%rbp), %rdi
leaq -0x19fb(%rip), %rsi     # 0x50100
movl $0x10500, %edx          # imm = 0x10500
callq 0x50090
movl $0x1, -0x4(%rbp)
jmp 0x51b3a
jmp 0x51b10
movq -0x10(%rbp), %rdi
leaq -0xebb(%rip), %rsi      # 0x50c60
movl $0x40000, %edx          # imm = 0x40000
callq 0x50090
movq -0x10(%rbp), %rdi
movl $0x40, %esi
callq 0x52810
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x4(%rax), %edi
callq 0x13180
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
subl $0x1, %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jl 0x51d5d
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x24(%rbp), %rcx
movq -0x10(%rbp), %rdx
movq (%rdx), %rdx
movq -0x10(%rbp), %rdi
movq 0x20(%rdi), %rsi
movq %rsi, %r8
addq $-0x1, %r8
movq %r8, 0x20(%rdi)
movq -0x8(%rdx,%rsi,8), %rdx
movq %rdx, (%rax,%rcx,8)
movl -0x24(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x51d1d
movq -0x18(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x20(%rbp), %rdi
movabsq $-0x4800000000000, %rsi # imm = 0xFFFB800000000000
callq 0x7b610
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl 0x4(%rax), %edi
callq 0x6a740
movq %rax, -0x28(%rbp)
movl -0x1c(%rbp), %ecx
movq -0x28(%rbp), %rax
orl -0x20(%rax), %ecx
movl %ecx, -0x20(%rax)
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
subl $0x1, %eax
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jl 0x51e09
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq -0x10(%rbp), %rdx
movq (%rdx), %rdx
movq -0x10(%rbp), %rdi
movq 0x20(%rdi), %rsi
movq %rsi, %r8
addq $-0x1, %r8
movq %r8, 0x20(%rdi)
movq -0x8(%rdx,%rsi,8), %rdx
movq %rdx, (%rax,%rcx,8)
movl -0x2c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x51dcd
movq -0x28(%rbp), %rdi
callq 0x6a7a0
movq %rax, %rdi
movabsq $-0x4000000000000, %rsi # imm = 0xFFFC000000000000
callq 0x7b550
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x4(%rax), %edi
sarl %edi
callq 0x692f0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x18(%rbp), %rcx
movslq 0x4(%rcx), %rcx
subq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jae 0x51ecd
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x28(%rbp), %rcx
movq 0x8(%rax,%rcx,8), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x697e0
movq -0x28(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x28(%rbp)
jmp 0x51e79
movq -0x18(%rbp), %rax
movslq 0x4(%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rdi
movabsq $-0x3800000000000, %rsi # imm = 0xFFFC800000000000
callq 0x7b610
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x4(%rax), %edi
sarl %edi
callq 0x67720
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x18(%rbp), %rcx
movslq 0x4(%rcx), %rcx
subq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jae 0x51f9d
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x28(%rbp), %rcx
movq 0x8(%rax,%rcx,8), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x67d00
movq -0x28(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x28(%rbp)
jmp 0x51f49
movq -0x18(%rbp), %rax
movslq 0x4(%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rdi
callq 0x67d30
movq %rax, %rdi
movabsq $-0x3000000000000, %rsi # imm = 0xFFFD000000000000
callq 0x7b550
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movb %al, -0x19(%rbp)
movzbl -0x19(%rbp), %edi
callq 0x528e0
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jge 0x52322
movq -0x10(%rbp), %rax
leaq 0x4269c(%rip), %rcx     # 0x949ae
movq %rcx, 0x8(%rax)
movl $0x1, -0x4(%rbp)
jmp 0x523c0
movzbl -0x19(%rbp), %eax
cmpl $0x78, %eax
jne 0x52351
movq -0x18(%rbp), %rax
movl $0x2, (%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x18(%rbp), %rax
leaq 0x665(%rip), %rcx       # 0x529b0
movq %rcx, 0x20(%rax)
jmp 0x523b9
movzbl -0x19(%rbp), %eax
cmpl $0x75, %eax
je 0x52363
movzbl -0x19(%rbp), %eax
cmpl $0x55, %eax
jne 0x52399
movzbl -0x19(%rbp), %edx
movl $0x6, %ecx
movl $0x4, %eax
cmpl $0x75, %edx
cmovel %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x18(%rbp), %rax
leaq 0x6cd(%rip), %rcx       # 0x52a60
movq %rcx, 0x20(%rax)
jmp 0x523b7
movq -0x10(%rbp), %rdi
movl -0x20(%rbp), %eax
movzbl %al, %esi
callq 0x52810
movq -0x18(%rbp), %rax
leaq -0xa83(%rip), %rcx      # 0x51930
movq %rcx, 0x20(%rax)
jmp 0x523b9
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/parse.c
// Function: checkescape
static int checkescape(uint8_t c) {
    switch (c) {
        default:
            return -1;
        case 'x':
        case 'u':
        case 'U':
            return 1;
        case 'n':
            return '\n';
        case 't':
            return '\t';
        case 'r':
            return '\r';
        case '0':
            return '\0';
        case 'z':
            return '\0';
        case 'f':
            return '\f';
        case 'v':
            return '\v';
        case 'a':
            return '\a';
        case 'b':
            return '\b';
        case '\'':
            return '\'';
        case '?':
            return '?';
        case 'e':
            return 27;
        case '"':
            return '"';
        case '\\':
            return '\\';
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x5(%rbp)
movzbl -0x5(%rbp), %eax
addl $-0x22, %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x58, %eax
ja 0x52910
movq -0x10(%rbp), %rax
leaq 0x4104d(%rip), %rcx     # 0x93954
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x529a1
movl $0x1, -0x4(%rbp)
jmp 0x529a1
movl $0xa, -0x4(%rbp)
jmp 0x529a1
movl $0x9, -0x4(%rbp)
jmp 0x529a1
movl $0xd, -0x4(%rbp)
jmp 0x529a1
movl $0x0, -0x4(%rbp)
jmp 0x529a1
movl $0x0, -0x4(%rbp)
jmp 0x529a1
movl $0xc, -0x4(%rbp)
jmp 0x529a1
movl $0xb, -0x4(%rbp)
jmp 0x529a1
movl $0x7, -0x4(%rbp)
jmp 0x529a1
movl $0x8, -0x4(%rbp)
jmp 0x529a1
movl $0x27, -0x4(%rbp)
jmp 0x529a1
movl $0x3f, -0x4(%rbp)
jmp 0x529a1
movl $0x1b, -0x4(%rbp)
jmp 0x529a1
movl $0x22, -0x4(%rbp)
jmp 0x529a1
movl $0x5c, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movb %al, -0x19(%rbp)
movzbl -0x19(%rbp), %edi
callq 0x52b30
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jge 0x529ef
movq -0x10(%rbp), %rax
leaq 0x41feb(%rip), %rcx     # 0x949cd
movq %rcx, 0x8(%rax)
movl $0x1, -0x4(%rbp)
jmp 0x52a50
movq -0x18(%rbp), %rax
movl 0x4(%rax), %ecx
shll $0x4, %ecx
addl -0x20(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x52a49
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
andl $0xff, %eax
movzbl %al, %esi
callq 0x52810
movq -0x18(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x18(%rbp), %rax
leaq -0x1115(%rip), %rcx     # 0x51930
movq %rcx, 0x20(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movb %al, -0x19(%rbp)
movzbl -0x19(%rbp), %edi
callq 0x52b30
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jge 0x52a9f
movq -0x10(%rbp), %rax
leaq 0x41f5b(%rip), %rcx     # 0x949ed
movq %rcx, 0x8(%rax)
movl $0x1, -0x4(%rbp)
jmp 0x52b1d
movq -0x18(%rbp), %rax
movl 0x4(%rax), %ecx
shll $0x4, %ecx
addl -0x20(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x52b16
movq -0x18(%rbp), %rax
cmpl $0x10ffff, 0x4(%rax)    # imm = 0x10FFFF
jle 0x52aec
movq -0x10(%rbp), %rax
leaq 0x41f32(%rip), %rcx     # 0x94a11
movq %rcx, 0x8(%rax)
movl $0x1, -0x4(%rbp)
jmp 0x52b1d
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x4(%rax), %esi
callq 0x52bb0
movq -0x18(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x18(%rbp), %rax
leaq -0x11e2(%rip), %rcx     # 0x51930
movq %rcx, 0x20(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/src/core/parse.c
// Function: to_hex
static int to_hex(uint8_t c) {
    if (c >= '0' && c <= '9') {
        return c - '0';
    } else if (c >= 'A' && c <= 'F') {
        return 10 + c - 'A';
    } else if (c >= 'a' && c <= 'f') {
        return 10 + c - 'a';
    } else {
        return -1;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x5(%rbp)
movzbl -0x5(%rbp), %eax
cmpl $0x30, %eax
jl 0x52b58
movzbl -0x5(%rbp), %eax
cmpl $0x39, %eax
jg 0x52b58
movzbl -0x5(%rbp), %eax
subl $0x30, %eax
movl %eax, -0x4(%rbp)
jmp 0x52ba1
movzbl -0x5(%rbp), %eax
cmpl $0x41, %eax
jl 0x52b79
movzbl -0x5(%rbp), %eax
cmpl $0x46, %eax
jg 0x52b79
movzbl -0x5(%rbp), %eax
addl $0xa, %eax
subl $0x41, %eax
movl %eax, -0x4(%rbp)
jmp 0x52ba1
movzbl -0x5(%rbp), %eax
cmpl $0x61, %eax
jl 0x52b9a
movzbl -0x5(%rbp), %eax
cmpl $0x66, %eax
jg 0x52b9a
movzbl -0x5(%rbp), %eax
addl $0xa, %eax
subl $0x61, %eax
movl %eax, -0x4(%rbp)
jmp 0x52ba1
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)