LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/build/c/shell.c
// Function: janet_line_getter
Janet janet_line_getter(int32_t argc, Janet *argv) {
    janet_arity(argc, 0, 3);
    const char *str = (argc >= 1) ? (const char *) janet_getstring(argv, 0) : "";
    JanetBuffer *buf = (argc >= 2) ? janet_getbuffer(argv, 1) : janet_buffer(10);
    gbl_complete_env = (argc >= 3) ? janet_gettable(argv, 2) : NULL;
    janet_line_get(str, buf);
    gbl_complete_env = NULL;

    Janet result;
    if (gbl_cancel_current_repl_form) {
        gbl_cancel_current_repl_form = 0;

        /* Signal that the user bailed out of the current form */
        result = janet_ckeywordv("cancel");
    } else {
        result = janet_wrap_buffer(buf);
    }
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movl -0xc(%rbp), %edi
xorl %esi, %esi
movl $0x3, %edx
callq 0x16de0
cmpl $0x1, -0xc(%rbp)
jl 0x7e5f5
movq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x1d250
movq %rax, -0x40(%rbp)
jmp 0x7e602
leaq 0x58300(%rip), %rax     # 0xd68fc
movq %rax, -0x40(%rbp)
jmp 0x7e602
movq -0x40(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x2, -0xc(%rbp)
jl 0x7e624
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x1beb0
movq %rax, -0x48(%rbp)
jmp 0x7e632
movl $0xa, %edi
callq 0x1b5a0
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $0x3, -0xc(%rbp)
jl 0x7e654
movq -0x18(%rbp), %rdi
movl $0x2, %esi
callq 0x1fa90
movq %rax, -0x50(%rbp)
jmp 0x7e65c
xorl %eax, %eax
movq %rax, -0x50(%rbp)
jmp 0x7e65c
movq -0x50(%rbp), %rax
movq %rax, -0x58(%rbp)
movq %fs:0x0, %rax
movq -0x58(%rbp), %rcx
leaq -0x1790(%rax), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x7e730
movq %fs:0x0, %rax
leaq -0x1790(%rax), %rax
movq $0x0, (%rax)
movq %fs:0x0, %rax
leaq -0x1788(%rax), %rax
cmpl $0x0, (%rax)
je 0x7e702
movq %fs:0x0, %rax
leaq -0x1788(%rax), %rax
movl $0x0, (%rax)
leaq 0x57f15(%rip), %rdi     # 0xd65f2
callq 0x19e00
movq %rax, %rdi
movabsq $-0x5000000000000, %rsi # imm = 0xFFFB000000000000
callq 0x19dd0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x7e721
movq -0x28(%rbp), %rdi
movabsq $-0x2800000000000, %rsi # imm = 0xFFFD800000000000
callq 0x163b0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/build/c/shell.c
// Function: janet_line_get
void janet_line_get(const char *p, JanetBuffer *buffer) {
    gbl_prompt = p;
    buffer->count = 0;
    gbl_historyi = 0;
    if (check_simpleline(buffer)) return;
    FILE *out = janet_dynfile("err", stderr);
    if (line()) {
        norawmode();
        fputc('\n', out);
        return;
    }
    fflush(stdin);
    norawmode();
    fputc('\n', out);
    janet_buffer_ensure(buffer, gbl_len + 1, 2);
    memcpy(buffer->data, gbl_buf, gbl_len);
    buffer->data[gbl_len] = '\n';
    buffer->count = gbl_len + 1;
    replacehistory();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq %fs:0x0, %rax
movq -0x20(%rbp), %rcx
leaq -0x1af8(%rax), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x10(%rax)
movq %fs:0x0, %rax
leaq -0x1460(%rax), %rax
movl $0x0, (%rax)
movq -0x10(%rbp), %rdi
callq 0x7e9d0
cmpl $0x0, %eax
je 0x7e799
jmp 0x7e8bc
movq 0x6e850(%rip), %rax     # 0xecff0
movq (%rax), %rsi
leaq 0x535ad(%rip), %rdi     # 0xd1d57
callq 0x2a7d0
movq %rax, -0x18(%rbp)
callq 0x7f030
cmpl $0x0, %eax
je 0x7e7d5
callq 0x7e970
movq -0x18(%rbp), %rsi
movl $0xa, %edi
callq 0x15500
jmp 0x7e8bc
movq 0x6e7dc(%rip), %rax     # 0xecfb8
movq (%rax), %rdi
callq 0x15790
callq 0x7e970
movq -0x18(%rbp), %rsi
movl $0xa, %edi
callq 0x15500
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq %fs:0x0, %rax
movq -0x40(%rbp), %rdi
leaq -0x145c(%rax), %rax
movl (%rax), %esi
addl $0x1, %esi
movl $0x2, %edx
callq 0x1b5d0
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x38(%rbp)
movq %fs:0x0, %rax
leaq -0x1450(%rax), %rax
movq %rax, -0x30(%rbp)
movq %fs:0x0, %rax
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
leaq -0x145c(%rax), %rax
movslq (%rax), %rdx
callq 0x15690
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
movq %fs:0x0, %rax
movq %rax, %rcx
movq -0x28(%rbp), %rax
leaq -0x145c(%rcx), %rcx
movslq (%rcx), %rcx
movb $0xa, (%rax,%rcx)
movq %fs:0x0, %rax
leaq -0x145c(%rax), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x10(%rax)
callq 0x7ea30
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/build/c/shell.c
// Function: janet_line_deinit
void janet_line_deinit() {
    int i;
    norawmode();
    for (i = 0; i < gbl_history_count; i++)
        janet_free(gbl_history[i]);
    gbl_historyi = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x7e970
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x8(%rbp)
movq %fs:0x0, %rax
movq %rax, %rcx
movl -0x8(%rbp), %eax
leaq -0x1784(%rcx), %rcx
cmpl (%rcx), %eax
jge 0x7e942
movq %fs:0x0, %rax
leaq -0x1780(%rax), %rax
movslq -0x4(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x150b0
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x7e8f4
movq %fs:0x0, %rax
leaq -0x1460(%rax), %rax
movl $0x0, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/build/c/shell.c
// Function: check_simpleline
static int check_simpleline(JanetBuffer *buffer) {
    if (!isatty(STDIN_FILENO) || !checktermsupport()) {
        simpleline(buffer);
        return 1;
    }
    if (rawmode()) {
        simpleline(buffer);
        return 1;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
xorl %edi, %edi
callq 0x151c0
cmpl $0x0, %eax
je 0x7e9f2
callq 0x7efa0
cmpl $0x0, %eax
jne 0x7ea04
movq -0x10(%rbp), %rdi
callq 0x7ee20
movl $0x1, -0x4(%rbp)
jmp 0x7ea27
callq 0x7eec0
cmpl $0x0, %eax
je 0x7ea20
movq -0x10(%rbp), %rdi
callq 0x7ee20
movl $0x1, -0x4(%rbp)
jmp 0x7ea27
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/build/c/shell.c
// Function: replacehistory
static void replacehistory(void) {
    /* History count is always > 0 here */
    if (gbl_len == 0 || (gbl_history_count > 1 && !strcmp(gbl_buf, gbl_history[1]))) {
        /* Delete history */
        janet_free(gbl_history[0]);
        for (int i = 1; i < gbl_history_count; i++) {
            gbl_history[i - 1] = gbl_history[i];
        }
        gbl_history_count--;
    } else {
        char *newline = sdup(gbl_buf);
        if (!newline) return;
        janet_free(gbl_history[0]);
        gbl_history[0] = newline;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %fs:0x0, %rax
leaq -0x145c(%rax), %rax
cmpl $0x0, (%rax)
je 0x7eaac
movq %fs:0x0, %rax
leaq -0x1784(%rax), %rax
cmpl $0x1, (%rax)
jle 0x7eb5b
movq %fs:0x0, %rax
leaq -0x1450(%rax), %rax
movq %rax, -0x18(%rbp)
movq %fs:0x0, %rax
movq -0x18(%rbp), %rdi
leaq -0x1780(%rax), %rax
movq 0x8(%rax), %rsi
callq 0x155d0
cmpl $0x0, %eax
jne 0x7eb5b
movq %fs:0x0, %rax
leaq -0x1780(%rax), %rax
movq (%rax), %rdi
callq 0x150b0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq %fs:0x0, %rax
movq %rax, %rcx
movl -0x1c(%rbp), %eax
leaq -0x1784(%rcx), %rcx
cmpl (%rcx), %eax
jge 0x7eb3f
movq %fs:0x0, %rax
leaq -0x1780(%rax), %rax
movslq -0x4(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq %fs:0x0, %rax
movq -0x28(%rbp), %rdx
leaq -0x1780(%rax), %rax
movl -0x4(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x7eace
movq %fs:0x0, %rax
leaq -0x1784(%rax), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
jmp 0x7ebbd
movq %fs:0x0, %rax
leaq -0x1450(%rax), %rdi
callq 0x81380
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x7eb80
jmp 0x7ebbd
movq %fs:0x0, %rax
leaq -0x1780(%rax), %rax
movq (%rax), %rdi
callq 0x150b0
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq %fs:0x0, %rax
movq -0x30(%rbp), %rcx
leaq -0x1780(%rax), %rax
movq %rcx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/build/c/shell.c
// Function: simpleline
static void simpleline(JanetBuffer *buffer) {
    FILE *in = janet_dynfile("in", stdin);
    buffer->count = 0;
    int c;
    for (;;) {
        c = fgetc(in);
        if (c < 0 && !feof(in) && errno == EINTR) {
            continue;
        }
        if (feof(in) || c < 0) {
            break;
        }
        janet_buffer_push_u8(buffer, (uint8_t) c);
        if (c == '\n') break;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq 0x6e185(%rip), %rax     # 0xecfb8
movq (%rax), %rsi
leaq 0x52c2b(%rip), %rdi     # 0xd1a68
callq 0x2a7d0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x10(%rbp), %rdi
callq 0x15460
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jge 0x7ee7d
movq -0x10(%rbp), %rdi
callq 0x15630
cmpl $0x0, %eax
jne 0x7ee7d
callq 0x15120
cmpl $0x4, (%rax)
jne 0x7ee7d
jmp 0x7ee51
movq -0x10(%rbp), %rdi
callq 0x15630
cmpl $0x0, %eax
jne 0x7ee91
cmpl $0x0, -0x14(%rbp)
jge 0x7ee93
jmp 0x7eeac
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %eax
movzbl %al, %esi
callq 0x1b970
cmpl $0xa, -0x14(%rbp)
jne 0x7eeaa
jmp 0x7eeac
jmp 0x7ee51
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/build/c/shell.c
// Function: rawmode
static int rawmode(void) {
    struct termios t;
    if (!isatty(STDIN_FILENO)) goto fatal;
    if (tcgetattr(STDIN_FILENO, &gbl_termios_start) == -1) goto fatal;
    t = gbl_termios_start;
    t.c_iflag &= ~(BRKINT | ICRNL | INPCK | ISTRIP | IXON);
    t.c_cflag |= (CS8);
    t.c_lflag &= ~(ECHO | ICANON | IEXTEN | ISIG);
    t.c_cc[VMIN] = 1;
    t.c_cc[VTIME] = 0;
    if (tcsetattr(STDIN_FILENO, TCSADRAIN, &t) < 0) goto fatal;
    gbl_israwmode = 1;
    return 0;
fatal:
    errno = ENOTTY;
    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
xorl %edi, %edi
callq 0x151c0
cmpl $0x0, %eax
jne 0x7eed9
jmp 0x7ef7e
movq %fs:0x0, %rax
leaq -0x104c(%rax), %rsi
xorl %edi, %edi
callq 0x15980
cmpl $-0x1, %eax
jne 0x7eefd
jmp 0x7ef7e
movq %fs:0x0, %rax
leaq -0x104c(%rax), %rsi
leaq -0x40(%rbp), %rdi
movl $0x3c, %edx
callq 0x15690
movl -0x40(%rbp), %eax
andl $0xfffffacd, %eax       # imm = 0xFFFFFACD
movl %eax, -0x40(%rbp)
movl -0x38(%rbp), %eax
orl $0x30, %eax
movl %eax, -0x38(%rbp)
movl -0x34(%rbp), %eax
andl $0xffff7ff4, %eax       # imm = 0xFFFF7FF4
movl %eax, -0x34(%rbp)
movb $0x1, -0x29(%rbp)
movb $0x0, -0x2a(%rbp)
xorl %edi, %edi
movl $0x1, %esi
leaq -0x40(%rbp), %rdx
callq 0x15990
cmpl $0x0, %eax
jge 0x7ef5c
jmp 0x7ef7e
movq %fs:0x0, %rax
leaq -0x1050(%rax), %rax
movl $0x1, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x7ef90
callq 0x15120
movl $0x19, (%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/build/c/shell.c
// Function: checktermsupport
static int checktermsupport() {
    const char *t = getenv("TERM");
    int i;
    if (!t) return 1;
    for (i = 0; badterms[i]; i++)
        if (!strcmp(t, badterms[i])) return 0;
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x578f5(%rip), %rdi     # 0xd68a4
callq 0x15040
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x7efc8
movl $0x1, -0x4(%rbp)
jmp 0x7f01b
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rcx
leaq 0x6f4e6(%rip), %rax     # 0xee4c0
cmpq $0x0, (%rax,%rcx,8)
je 0x7f014
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rcx
leaq 0x6f4d0(%rip), %rax     # 0xee4c0
movq (%rax,%rcx,8), %rsi
callq 0x155d0
cmpl $0x0, %eax
jne 0x7f007
movl $0x0, -0x4(%rbp)
jmp 0x7f01b
jmp 0x7f009
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x7efcf
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/build/c/shell.c
// Function: getcols
static int getcols(void) {
#ifdef _WIN32
    CONSOLE_SCREEN_BUFFER_INFO csbi;
    GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &csbi);
    return (int)(csbi.srWindow.Right - csbi.srWindow.Left + 1);
#else
    struct winsize ws;
    if (ioctl(1, TIOCGWINSZ, &ws) == -1 || ws.ws_col == 0) {
        int start, cols;
        start = curpos();
        if (start == -1) goto failed;
        if (write_console("\x1b[999C", 6) != 6) goto failed;
        cols = curpos();
        if (cols == -1) goto failed;
        if (cols > start) {
            char seq[32];
            snprintf(seq, 32, "\x1b[%dD", cols - start);
            if (write_console(seq, strlen(seq)) == -1) {
                exit(1);
            }
        }
        return cols;
    } else {
        return ws.ws_col;
    }
failed:
    return 80;
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl $0x1, %edi
movl $0x5413, %esi           # imm = 0x5413
leaq -0xc(%rbp), %rdx
movb $0x0, %al
callq 0x15420
cmpl $-0x1, %eax
je 0x7f8cf
movzwl -0xa(%rbp), %eax
cmpl $0x0, %eax
jne 0x7f967
callq 0x812a0
movl %eax, -0x10(%rbp)
cmpl $-0x1, -0x10(%rbp)
jne 0x7f8e2
jmp 0x7f970
leaq 0x56fd2(%rip), %rdi     # 0xd68bb
movl $0x6, %esi
callq 0x7fad0
cmpq $0x6, %rax
je 0x7f8fb
jmp 0x7f970
callq 0x812a0
movl %eax, -0x14(%rbp)
cmpl $-0x1, -0x14(%rbp)
jne 0x7f90b
jmp 0x7f970
movl -0x14(%rbp), %eax
cmpl -0x10(%rbp), %eax
jle 0x7f95f
leaq -0x40(%rbp), %rdi
movl -0x14(%rbp), %ecx
subl -0x10(%rbp), %ecx
movl $0x20, %esi
leaq 0x56f99(%rip), %rdx     # 0xd68c2
movb $0x0, %al
callq 0x15390
leaq -0x40(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x15310
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x7fad0
cmpq $-0x1, %rax
jne 0x7f95d
movl $0x1, %edi
callq 0x15aa0
jmp 0x7f95f
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x7f977
movzwl -0xa(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x7f977
movl $0x50, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/build/c/shell.c
// Function: addhistory
static void addhistory(void) {
    int i, len;
    char *newline = sdup(gbl_buf);
    if (!newline) return;
    len = gbl_history_count;
    if (len < JANET_HISTORY_MAX) {
        gbl_history[gbl_history_count++] = newline;
        len++;
    } else {
        janet_free(gbl_history[JANET_HISTORY_MAX - 1]);
    }
    for (i = len - 1; i > 0; i--) {
        gbl_history[i] = gbl_history[i - 1];
    }
    gbl_history[0] = newline;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %fs:0x0, %rax
leaq -0x1450(%rax), %rdi
callq 0x81380
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x7f9b0
jmp 0x7fac4
movq %fs:0x0, %rax
leaq -0x1784(%rax), %rax
movl (%rax), %eax
movl %eax, -0x8(%rbp)
cmpl $0x64, -0x8(%rbp)
jge 0x7fa26
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq %fs:0x0, %rax
leaq -0x1780(%rax), %rax
movq %rax, -0x18(%rbp)
movq %fs:0x0, %rax
movq -0x20(%rbp), %rdx
movq %rax, %rcx
movq -0x18(%rbp), %rax
leaq -0x1784(%rcx), %rsi
movl (%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, (%rsi)
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x7fa45
movq %fs:0x0, %rax
leaq -0x1780(%rax), %rax
movq 0x318(%rax), %rdi
callq 0x150b0
movl -0x8(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jle 0x7faa2
movq %fs:0x0, %rax
leaq -0x1780(%rax), %rax
movl -0x4(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq %fs:0x0, %rax
movq -0x28(%rbp), %rdx
leaq -0x1780(%rax), %rax
movslq -0x4(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x4(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x7fa4e
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq %fs:0x0, %rax
movq -0x30(%rbp), %rcx
leaq -0x1780(%rax), %rax
movq %rcx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/build/c/shell.c
// Function: refresh
static void refresh(void) {
    char seq[64];
    JanetBuffer b;

    /* Keep cursor position on screen */
    char *_buf = gbl_buf;
    int _len = gbl_len;
    int _pos = gbl_pos;
    while ((gbl_plen + _pos) >= gbl_cols) {
        _buf++;
        _len--;
        _pos--;
    }
    while ((gbl_plen + _len) > gbl_cols) {
        _len--;
    }

    janet_buffer_init(&b, 0);
    /* Cursor to left edge, gbl_prompt and buffer */
    janet_buffer_push_u8(&b, '\r');
    janet_buffer_push_cstring(&b, gbl_prompt);
    janet_buffer_push_bytes(&b, (uint8_t *) _buf, _len);
    /* Erase to right */
    janet_buffer_push_cstring(&b, "\x1b[0K");
    /* Move cursor to original position. */
    snprintf(seq, 64, "\r\x1b[%dC", (int)(_pos + gbl_plen));
    janet_buffer_push_cstring(&b, seq);
    if (write_console((char *) b.data, b.count) == -1) {
        exit(1);
    }
    janet_buffer_deinit(&b);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %fs:0x0, %rax
leaq -0x1450(%rax), %rax
movq %rax, -0x68(%rbp)
movq %fs:0x0, %rax
leaq -0x145c(%rax), %rax
movl (%rax), %eax
movl %eax, -0x6c(%rbp)
movq %fs:0x0, %rax
leaq -0x1010(%rax), %rax
movl (%rax), %eax
movl %eax, -0x70(%rbp)
movq %fs:0x0, %rax
leaq -0x1aec(%rax), %rax
movl (%rax), %eax
addl -0x70(%rbp), %eax
movl %eax, -0x74(%rbp)
movq %fs:0x0, %rax
movq %rax, %rcx
movl -0x74(%rbp), %eax
leaq -0x1af0(%rcx), %rcx
cmpl (%rcx), %eax
jl 0x7feba
movq -0x68(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x68(%rbp)
movl -0x6c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x6c(%rbp)
movl -0x70(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x70(%rbp)
jmp 0x7fe62
jmp 0x7febc
movq %fs:0x0, %rax
leaq -0x1aec(%rax), %rax
movl (%rax), %eax
addl -0x6c(%rbp), %eax
movl %eax, -0x78(%rbp)
movq %fs:0x0, %rax
movq %rax, %rcx
movl -0x78(%rbp), %eax
leaq -0x1af0(%rcx), %rcx
cmpl (%rcx), %eax
jle 0x7feff
movl -0x6c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x6c(%rbp)
jmp 0x7febc
leaq -0x60(%rbp), %rdi
xorl %esi, %esi
callq 0x1b3f0
leaq -0x60(%rbp), %rdi
movl $0xd, %esi
callq 0x1b970
movq %fs:0x0, %rax
leaq -0x1af8(%rax), %rax
movq (%rax), %rsi
leaq -0x60(%rbp), %rdi
callq 0x1b8a0
movq -0x68(%rbp), %rsi
movl -0x6c(%rbp), %edx
leaq -0x60(%rbp), %rdi
callq 0x1b8e0
leaq -0x60(%rbp), %rdi
leaq 0x56981(%rip), %rsi     # 0xd68d3
callq 0x1b8a0
leaq -0x40(%rbp), %rax
movq %rax, -0x88(%rbp)
movl -0x70(%rbp), %eax
movl %eax, -0x7c(%rbp)
movq %fs:0x0, %rax
movq -0x88(%rbp), %rdi
movl -0x7c(%rbp), %ecx
leaq -0x1aec(%rax), %rax
addl (%rax), %ecx
movl $0x40, %esi
leaq 0x56945(%rip), %rdx     # 0xd68d8
movb $0x0, %al
callq 0x15390
leaq -0x40(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x1b8a0
movq -0x48(%rbp), %rdi
movslq -0x50(%rbp), %rsi
callq 0x7fad0
cmpq $-0x1, %rax
jne 0x7ffc4
movl $0x1, %edi
callq 0x15aa0
leaq -0x60(%rbp), %rdi
callq 0x1b570
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/build/c/shell.c
// Function: clearlines
static void clearlines(void) {
    for (int i = 0; i < gbl_lines_below; i++) {
        fprintf(stderr, "\x1b[1B\x1b[999D\x1b[K");
    }
    if (gbl_lines_below) {
        fprintf(stderr, "\x1b[%dA\x1b[999D", gbl_lines_below);
        fflush(stderr);
        gbl_lines_below = 0;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x8(%rbp)
movq %fs:0x0, %rax
movq %rax, %rcx
movl -0x8(%rbp), %eax
leaq -0x100c(%rcx), %rcx
cmpl (%rcx), %eax
jge 0x80075
movq 0x6cf97(%rip), %rax     # 0xecff0
movq (%rax), %rdi
leaq 0x5687c(%rip), %rsi     # 0xd68df
movb $0x0, %al
callq 0x15600
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x8002f
movq %fs:0x0, %rax
leaq -0x100c(%rax), %rax
cmpl $0x0, (%rax)
je 0x800ea
movq 0x6cf5c(%rip), %rax     # 0xecff0
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq %fs:0x0, %rax
movq -0x10(%rbp), %rdi
leaq -0x100c(%rax), %rax
movl (%rax), %edx
leaq 0x56832(%rip), %rsi     # 0xd68ed
movb $0x0, %al
callq 0x15600
movq 0x6cf27(%rip), %rax     # 0xecff0
movq (%rax), %rdi
callq 0x15790
movq %fs:0x0, %rax
leaq -0x100c(%rax), %rax
movl $0x0, (%rax)
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/build/c/shell.c
// Function: kdelete
static void kdelete(int draw) {
    if (gbl_pos != gbl_len) {
        memmove(gbl_buf + gbl_pos, gbl_buf + gbl_pos + 1, gbl_len - gbl_pos);
        gbl_buf[--gbl_len] = '\0';
        if (draw) refresh();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movq %fs:0x0, %rax
leaq -0x1010(%rax), %rax
movl (%rax), %eax
movl %eax, -0x8(%rbp)
movq %fs:0x0, %rax
movq %rax, %rcx
movl -0x8(%rbp), %eax
leaq -0x145c(%rcx), %rcx
cmpl (%rcx), %eax
je 0x8023d
movq %fs:0x0, %rax
leaq -0x1450(%rax), %rax
movq %rax, -0x38(%rbp)
movq %fs:0x0, %rax
movq %rax, %rcx
movq -0x38(%rbp), %rax
leaq -0x1010(%rcx), %rcx
movslq (%rcx), %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq %fs:0x0, %rax
leaq -0x1450(%rax), %rax
movq %rax, -0x30(%rbp)
movq %fs:0x0, %rax
movq %rax, %rcx
movq -0x30(%rbp), %rax
leaq -0x1010(%rcx), %rcx
movslq (%rcx), %rcx
addq %rcx, %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq %fs:0x0, %rax
leaq -0x145c(%rax), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
movq %fs:0x0, %rax
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq %rax, %rcx
movl -0x14(%rbp), %eax
leaq -0x1010(%rcx), %rcx
subl (%rcx), %eax
movslq %eax, %rdx
callq 0x15950
movq %fs:0x0, %rax
leaq -0x1450(%rax), %rax
movq %rax, -0x10(%rbp)
movq %fs:0x0, %rax
movq %rax, %rcx
movq -0x10(%rbp), %rax
leaq -0x145c(%rcx), %rdx
movl (%rdx), %ecx
addl $-0x1, %ecx
movl %ecx, (%rdx)
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
cmpl $0x0, -0x4(%rbp)
je 0x8023b
callq 0x7fe10
jmp 0x8023d
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/build/c/shell.c
// Function: kbackspace
static void kbackspace(int draw) {
    if (gbl_pos > 0) {
        memmove(gbl_buf + gbl_pos - 1, gbl_buf + gbl_pos, gbl_len - gbl_pos);
        gbl_pos--;
        gbl_buf[--gbl_len] = '\0';
        if (draw) refresh();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movq %fs:0x0, %rax
leaq -0x1010(%rax), %rax
cmpl $0x0, (%rax)
jle 0x806da
movq %fs:0x0, %rax
leaq -0x1450(%rax), %rax
movq %rax, -0x38(%rbp)
movq %fs:0x0, %rax
movq %rax, %rcx
movq -0x38(%rbp), %rax
leaq -0x1010(%rcx), %rcx
movslq (%rcx), %rcx
addq %rcx, %rax
addq $-0x1, %rax
movq %rax, -0x28(%rbp)
movq %fs:0x0, %rax
leaq -0x1450(%rax), %rax
movq %rax, -0x30(%rbp)
movq %fs:0x0, %rax
movq %rax, %rcx
movq -0x30(%rbp), %rax
leaq -0x1010(%rcx), %rcx
movslq (%rcx), %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq %fs:0x0, %rax
leaq -0x145c(%rax), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
movq %fs:0x0, %rax
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq %rax, %rcx
movl -0x14(%rbp), %eax
leaq -0x1010(%rcx), %rcx
subl (%rcx), %eax
movslq %eax, %rdx
callq 0x15950
movq %fs:0x0, %rax
leaq -0x1010(%rax), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
movq %fs:0x0, %rax
leaq -0x1450(%rax), %rax
movq %rax, -0x10(%rbp)
movq %fs:0x0, %rax
movq %rax, %rcx
movq -0x10(%rbp), %rax
leaq -0x145c(%rcx), %rdx
movl (%rdx), %ecx
addl $-0x1, %ecx
movl %ecx, (%rdx)
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
cmpl $0x0, -0x4(%rbp)
je 0x806d8
callq 0x7fe10
jmp 0x806da
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/build/c/shell.c
// Function: historymove
static void historymove(int delta) {
    if (gbl_history_count > 1) {
        janet_free(gbl_history[gbl_historyi]);
        gbl_history[gbl_historyi] = sdup(gbl_buf);

        gbl_historyi += delta;
        if (gbl_historyi < 0) {
            gbl_historyi = 0;
        } else if (gbl_historyi >= gbl_history_count) {
            gbl_historyi = gbl_history_count - 1;
        }
        strncpy(gbl_buf, gbl_history[gbl_historyi], JANET_LINE_MAX - 1);
        gbl_pos = gbl_len = (int) strlen(gbl_buf);
        gbl_buf[gbl_len] = '\0';

        refresh();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x4(%rbp)
movq %fs:0x0, %rax
leaq -0x1784(%rax), %rax
cmpl $0x1, (%rax)
jle 0x80cbe
movq %fs:0x0, %rax
leaq -0x1780(%rax), %rax
movq %rax, -0x20(%rbp)
movq %fs:0x0, %rax
movq %rax, %rcx
movq -0x20(%rbp), %rax
leaq -0x1460(%rcx), %rcx
movslq (%rcx), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x150b0
movq %fs:0x0, %rax
leaq -0x1450(%rax), %rdi
callq 0x81380
movq %rax, -0x18(%rbp)
movq %fs:0x0, %rax
leaq -0x1780(%rax), %rax
movq %rax, -0x10(%rbp)
movq %fs:0x0, %rax
movq -0x18(%rbp), %rdx
movq %rax, %rcx
movq -0x10(%rbp), %rax
leaq -0x1460(%rcx), %rcx
movslq (%rcx), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x4(%rbp), %eax
movl %eax, -0x8(%rbp)
movq %fs:0x0, %rax
movl -0x8(%rbp), %ecx
leaq -0x1460(%rax), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
movq %fs:0x0, %rax
leaq -0x1460(%rax), %rax
cmpl $0x0, (%rax)
jge 0x80b6f
movq %fs:0x0, %rax
leaq -0x1460(%rax), %rax
movl $0x0, (%rax)
jmp 0x80bd9
movq %fs:0x0, %rax
leaq -0x1460(%rax), %rax
movl (%rax), %eax
movl %eax, -0x24(%rbp)
movq %fs:0x0, %rax
movq %rax, %rcx
movl -0x24(%rbp), %eax
leaq -0x1784(%rcx), %rcx
cmpl (%rcx), %eax
jl 0x80bd7
movq %fs:0x0, %rax
leaq -0x1784(%rax), %rax
movl (%rax), %eax
subl $0x1, %eax
movl %eax, -0x28(%rbp)
movq %fs:0x0, %rax
movl -0x28(%rbp), %ecx
leaq -0x1460(%rax), %rax
movl %ecx, (%rax)
jmp 0x80bd9
movq %fs:0x0, %rax
leaq -0x1450(%rax), %rax
movq %rax, -0x48(%rbp)
movq %fs:0x0, %rax
leaq -0x1780(%rax), %rax
movq %rax, -0x40(%rbp)
movq %fs:0x0, %rax
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movq -0x40(%rbp), %rax
leaq -0x1460(%rcx), %rcx
movslq (%rcx), %rcx
movq (%rax,%rcx,8), %rsi
movl $0x3ff, %edx            # imm = 0x3FF
callq 0x15150
movq %fs:0x0, %rax
leaq -0x1450(%rax), %rdi
callq 0x15310
movl %eax, -0x34(%rbp)
movq %fs:0x0, %rax
movl -0x34(%rbp), %ecx
leaq -0x145c(%rax), %rax
movl %ecx, (%rax)
movq %fs:0x0, %rax
movl -0x34(%rbp), %ecx
leaq -0x1010(%rax), %rax
movl %ecx, (%rax)
movq %fs:0x0, %rax
leaq -0x1450(%rax), %rax
movq %rax, -0x30(%rbp)
movq %fs:0x0, %rax
movq %rax, %rcx
movq -0x30(%rbp), %rax
leaq -0x145c(%rcx), %rcx
movslq (%rcx), %rcx
movb $0x0, (%rax,%rcx)
callq 0x7fe10
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/build/c/shell.c
// Function: kbackspacew
static void kbackspacew(void) {
    while (gbl_pos && isspace(gbl_buf[gbl_pos - 1])) {
        kbackspace(0);
    }
    while (gbl_pos && !isspace(gbl_buf[gbl_pos - 1])) {
        kbackspace(0);
    }
    refresh();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
jmp 0x80cda
movq %fs:0x0, %rax
leaq -0x1010(%rax), %rcx
xorl %eax, %eax
cmpl $0x0, (%rcx)
movb %al, -0x1(%rbp)
je 0x80d59
callq 0x15c60
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq %fs:0x0, %rax
leaq -0x1450(%rax), %rax
movq %rax, -0x18(%rbp)
movq %fs:0x0, %rax
movq -0x18(%rbp), %rcx
movq %rax, %rdx
movq -0x10(%rbp), %rax
leaq -0x1010(%rdx), %rdx
movl (%rdx), %edx
subl $0x1, %edx
movslq %edx, %rdx
movsbl (%rcx,%rdx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
setne %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
testb $0x1, %al
jne 0x80d62
jmp 0x80d6e
xorl %edi, %edi
callq 0x80590
jmp 0x80cda
jmp 0x80d70
movq %fs:0x0, %rax
leaq -0x1010(%rax), %rcx
xorl %eax, %eax
cmpl $0x0, (%rcx)
movb %al, -0x19(%rbp)
je 0x80df1
callq 0x15c60
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq %fs:0x0, %rax
leaq -0x1450(%rax), %rax
movq %rax, -0x30(%rbp)
movq %fs:0x0, %rax
movq -0x30(%rbp), %rcx
movq %rax, %rdx
movq -0x28(%rbp), %rax
leaq -0x1010(%rdx), %rdx
movl (%rdx), %edx
subl $0x1, %edx
movslq %edx, %rdx
movsbl (%rcx,%rdx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x80dfa
jmp 0x80e06
xorl %edi, %edi
callq 0x80590
jmp 0x80d70
callq 0x7fe10
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/build/c/shell.c
// Function: krightw
static void krightw(void) {
    while (gbl_pos != gbl_len && isspace(gbl_buf[gbl_pos])) {
        gbl_pos++;
    }
    while (gbl_pos != gbl_len && !isspace(gbl_buf[gbl_pos])) {
        gbl_pos++;
    }
    refresh();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
jmp 0x80e2a
movq %fs:0x0, %rax
leaq -0x1010(%rax), %rax
movl (%rax), %eax
movl %eax, -0x8(%rbp)
movq %fs:0x0, %rax
movl -0x8(%rbp), %ecx
leaq -0x145c(%rax), %rdx
xorl %eax, %eax
cmpl (%rdx), %ecx
movb %al, -0x1(%rbp)
je 0x80ebe
callq 0x15c60
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq %fs:0x0, %rax
leaq -0x1450(%rax), %rax
movq %rax, -0x18(%rbp)
movq %fs:0x0, %rax
movq -0x18(%rbp), %rcx
movq %rax, %rdx
movq -0x10(%rbp), %rax
leaq -0x1010(%rdx), %rdx
movslq (%rdx), %rdx
movsbl (%rcx,%rdx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
setne %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
testb $0x1, %al
jne 0x80ec7
jmp 0x80ee6
movq %fs:0x0, %rax
leaq -0x1010(%rax), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x80e2a
jmp 0x80ee8
movq %fs:0x0, %rax
leaq -0x1010(%rax), %rax
movl (%rax), %eax
movl %eax, -0x20(%rbp)
movq %fs:0x0, %rax
movl -0x20(%rbp), %ecx
leaq -0x145c(%rax), %rdx
xorl %eax, %eax
cmpl (%rdx), %ecx
movb %al, -0x19(%rbp)
je 0x80f7e
callq 0x15c60
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq %fs:0x0, %rax
leaq -0x1450(%rax), %rax
movq %rax, -0x30(%rbp)
movq %fs:0x0, %rax
movq -0x30(%rbp), %rcx
movq %rax, %rdx
movq -0x28(%rbp), %rax
leaq -0x1010(%rdx), %rdx
movslq (%rdx), %rdx
movsbl (%rcx,%rdx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x80f87
jmp 0x80fa6
movq %fs:0x0, %rax
leaq -0x1010(%rax), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x80ee8
callq 0x7fe10
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/build/c/shell.c
// Function: kleftw
static void kleftw(void) {
    while (gbl_pos > 0 && isspace(gbl_buf[gbl_pos - 1])) {
        gbl_pos--;
    }
    while (gbl_pos > 0 && !isspace(gbl_buf[gbl_pos - 1])) {
        gbl_pos--;
    }
    refresh();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
jmp 0x80fca
movq %fs:0x0, %rax
leaq -0x1010(%rax), %rcx
xorl %eax, %eax
cmpl $0x0, (%rcx)
movb %al, -0x1(%rbp)
jle 0x81049
callq 0x15c60
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq %fs:0x0, %rax
leaq -0x1450(%rax), %rax
movq %rax, -0x18(%rbp)
movq %fs:0x0, %rax
movq -0x18(%rbp), %rcx
movq %rax, %rdx
movq -0x10(%rbp), %rax
leaq -0x1010(%rdx), %rdx
movl (%rdx), %edx
subl $0x1, %edx
movslq %edx, %rdx
movsbl (%rcx,%rdx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
setne %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
testb $0x1, %al
jne 0x81052
jmp 0x81071
movq %fs:0x0, %rax
leaq -0x1010(%rax), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
jmp 0x80fca
jmp 0x81073
movq %fs:0x0, %rax
leaq -0x1010(%rax), %rcx
xorl %eax, %eax
cmpl $0x0, (%rcx)
movb %al, -0x19(%rbp)
jle 0x810f4
callq 0x15c60
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq %fs:0x0, %rax
leaq -0x1450(%rax), %rax
movq %rax, -0x30(%rbp)
movq %fs:0x0, %rax
movq -0x30(%rbp), %rcx
movq %rax, %rdx
movq -0x28(%rbp), %rax
leaq -0x1010(%rdx), %rdx
movl (%rdx), %edx
subl $0x1, %edx
movslq %edx, %rdx
movsbl (%rcx,%rdx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x810fd
jmp 0x8111c
movq %fs:0x0, %rax
leaq -0x1010(%rax), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
jmp 0x81073
callq 0x7fe10
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/build/c/shell.c
// Function: kdeletew
static void kdeletew(void) {
    while (gbl_pos < gbl_len && isspace(gbl_buf[gbl_pos])) {
        kdelete(0);
    }
    while (gbl_pos < gbl_len && !isspace(gbl_buf[gbl_pos])) {
        kdelete(0);
    }
    refresh();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
jmp 0x8113a
movq %fs:0x0, %rax
leaq -0x1010(%rax), %rax
movl (%rax), %eax
movl %eax, -0x8(%rbp)
movq %fs:0x0, %rax
movl -0x8(%rbp), %ecx
leaq -0x145c(%rax), %rdx
xorl %eax, %eax
cmpl (%rdx), %ecx
movb %al, -0x1(%rbp)
jge 0x811ce
callq 0x15c60
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq %fs:0x0, %rax
leaq -0x1450(%rax), %rax
movq %rax, -0x18(%rbp)
movq %fs:0x0, %rax
movq -0x18(%rbp), %rcx
movq %rax, %rdx
movq -0x10(%rbp), %rax
leaq -0x1010(%rdx), %rdx
movslq (%rdx), %rdx
movsbl (%rcx,%rdx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
setne %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
testb $0x1, %al
jne 0x811d7
jmp 0x811e3
xorl %edi, %edi
callq 0x800f0
jmp 0x8113a
jmp 0x811e5
movq %fs:0x0, %rax
leaq -0x1010(%rax), %rax
movl (%rax), %eax
movl %eax, -0x20(%rbp)
movq %fs:0x0, %rax
movl -0x20(%rbp), %ecx
leaq -0x145c(%rax), %rdx
xorl %eax, %eax
cmpl (%rdx), %ecx
movb %al, -0x19(%rbp)
jge 0x8127b
callq 0x15c60
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq %fs:0x0, %rax
leaq -0x1450(%rax), %rax
movq %rax, -0x30(%rbp)
movq %fs:0x0, %rax
movq -0x30(%rbp), %rcx
movq %rax, %rdx
movq -0x28(%rbp), %rax
leaq -0x1010(%rdx), %rdx
movslq (%rdx), %rdx
movsbl (%rcx,%rdx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x81284
jmp 0x81290
xorl %edi, %edi
callq 0x800f0
jmp 0x811e5
callq 0x7fe10
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/build/c/shell.c
// Function: curpos
static int curpos(void) {
    char buf[32];
    int cols, rows;
    unsigned int i = 0;
    if (write_console("\x1b[6n", 4) != 4) return -1;
    while (i < sizeof(buf) - 1) {
        if (read_console(buf + i, 1) != 1) break;
        if (buf[i] == 'R') break;
        i++;
    }
    buf[i] = '\0';
    if (buf[0] != 27 || buf[1] != '[') return -1;
    if (sscanf(buf + 2, "%d;%d", &rows, &cols) != 2) return -1;
    return cols;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl $0x0, -0x3c(%rbp)
leaq 0x55612(%rip), %rdi     # 0xd68c8
movl $0x4, %esi
callq 0x7fad0
cmpq $0x4, %rax
je 0x812d2
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x81368
jmp 0x812d4
movl -0x3c(%rbp), %eax
cmpq $0x1f, %rax
jae 0x81313
leaq -0x30(%rbp), %rdi
movl -0x3c(%rbp), %eax
addq %rax, %rdi
movl $0x1, %esi
callq 0x7fb00
cmpq $0x1, %rax
je 0x812f9
jmp 0x81313
movl -0x3c(%rbp), %eax
movsbl -0x30(%rbp,%rax), %eax
cmpl $0x52, %eax
jne 0x81308
jmp 0x81313
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x812d4
movl -0x3c(%rbp), %eax
movb $0x0, -0x30(%rbp,%rax)
movsbl -0x30(%rbp), %eax
cmpl $0x1b, %eax
jne 0x8132d
movsbl -0x2f(%rbp), %eax
cmpl $0x5b, %eax
je 0x81336
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x81368
leaq -0x30(%rbp), %rdi
addq $0x2, %rdi
leaq 0x55588(%rip), %rsi     # 0xd68cd
leaq -0x38(%rbp), %rdx
leaq -0x34(%rbp), %rcx
movb $0x0, %al
callq 0x157c0
cmpl $0x2, %eax
je 0x81362
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x81368
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/build/c/shell.c
// Function: sdup
static char *sdup(const char *s) {
    size_t len = strlen(s) + 1;
    char *mem = janet_malloc(len);
    if (!mem) {
        return NULL;
    }
    return memcpy(mem, s, len);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x15310
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x15780
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x813bb
movq $0x0, -0x8(%rbp)
jmp 0x813d8
movq -0x20(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x15690
movq -0x28(%rbp), %rax
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/build/c/shell.c
// Function: is_symbol_char_gen
static int is_symbol_char_gen(uint8_t c) {
    if (c & 0x80) return 1;
    if (c >= 'a' && c <= 'z') return 1;
    if (c >= 'A' && c <= 'Z') return 1;
    if (c >= '0' && c <= '9') return 1;
    return (c == '!' ||
            c == '$' ||
            c == '%' ||
            c == '&' ||
            c == '*' ||
            c == '+' ||
            c == '-' ||
            c == '.' ||
            c == '/' ||
            c == ':' ||
            c == '<' ||
            c == '?' ||
            c == '=' ||
            c == '>' ||
            c == '@' ||
            c == '^' ||
            c == '_');
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x5(%rbp)
movzbl -0x5(%rbp), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0x81414
movl $0x1, -0x4(%rbp)
jmp 0x81582
movzbl -0x5(%rbp), %eax
cmpl $0x61, %eax
jl 0x81432
movzbl -0x5(%rbp), %eax
cmpl $0x7a, %eax
jg 0x81432
movl $0x1, -0x4(%rbp)
jmp 0x81582
movzbl -0x5(%rbp), %eax
cmpl $0x41, %eax
jl 0x81450
movzbl -0x5(%rbp), %eax
cmpl $0x5a, %eax
jg 0x81450
movl $0x1, -0x4(%rbp)
jmp 0x81582
movzbl -0x5(%rbp), %eax
cmpl $0x30, %eax
jl 0x8146e
movzbl -0x5(%rbp), %eax
cmpl $0x39, %eax
jg 0x8146e
movl $0x1, -0x4(%rbp)
jmp 0x81582
movzbl -0x5(%rbp), %ecx
movb $0x1, %al
cmpl $0x21, %ecx
movb %al, -0x6(%rbp)
je 0x81577
movzbl -0x5(%rbp), %ecx
movb $0x1, %al
cmpl $0x24, %ecx
movb %al, -0x6(%rbp)
je 0x81577
movzbl -0x5(%rbp), %ecx
movb $0x1, %al
cmpl $0x25, %ecx
movb %al, -0x6(%rbp)
je 0x81577
movzbl -0x5(%rbp), %ecx
movb $0x1, %al
cmpl $0x26, %ecx
movb %al, -0x6(%rbp)
je 0x81577
movzbl -0x5(%rbp), %ecx
movb $0x1, %al
cmpl $0x2a, %ecx
movb %al, -0x6(%rbp)
je 0x81577
movzbl -0x5(%rbp), %ecx
movb $0x1, %al
cmpl $0x2b, %ecx
movb %al, -0x6(%rbp)
je 0x81577
movzbl -0x5(%rbp), %ecx
movb $0x1, %al
cmpl $0x2d, %ecx
movb %al, -0x6(%rbp)
je 0x81577
movzbl -0x5(%rbp), %ecx
movb $0x1, %al
cmpl $0x2e, %ecx
movb %al, -0x6(%rbp)
je 0x81577
movzbl -0x5(%rbp), %ecx
movb $0x1, %al
cmpl $0x2f, %ecx
movb %al, -0x6(%rbp)
je 0x81577
movzbl -0x5(%rbp), %ecx
movb $0x1, %al
cmpl $0x3a, %ecx
movb %al, -0x6(%rbp)
je 0x81577
movzbl -0x5(%rbp), %ecx
movb $0x1, %al
cmpl $0x3c, %ecx
movb %al, -0x6(%rbp)
je 0x81577
movzbl -0x5(%rbp), %ecx
movb $0x1, %al
cmpl $0x3f, %ecx
movb %al, -0x6(%rbp)
je 0x81577
movzbl -0x5(%rbp), %ecx
movb $0x1, %al
cmpl $0x3d, %ecx
movb %al, -0x6(%rbp)
je 0x81577
movzbl -0x5(%rbp), %ecx
movb $0x1, %al
cmpl $0x3e, %ecx
movb %al, -0x6(%rbp)
je 0x81577
movzbl -0x5(%rbp), %ecx
movb $0x1, %al
cmpl $0x40, %ecx
movb %al, -0x6(%rbp)
je 0x81577
movzbl -0x5(%rbp), %ecx
movb $0x1, %al
cmpl $0x5e, %ecx
movb %al, -0x6(%rbp)
je 0x81577
movzbl -0x5(%rbp), %eax
cmpl $0x5f, %eax
sete %al
movb %al, -0x6(%rbp)
movb -0x6(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/build/c/shell.c
// Function: get_symprefix
static JanetByteView get_symprefix(void) {
    /* Calculate current partial symbol. Maybe we could actually hook up the Janet
     * parser here...*/
    int i;
    JanetByteView ret;
    ret.len = 0;
    for (i = gbl_pos - 1; i >= 0; i--) {
        uint8_t c = (uint8_t) gbl_buf[i];
        if (!is_symbol_char_gen(c)) break;
        ret.len++;
    }
    /* Will be const for duration of match checking */
    ret.bytes = (const uint8_t *)(gbl_buf + i + 1);
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x8(%rbp)
movq %fs:0x0, %rax
leaq -0x1010(%rax), %rax
movl (%rax), %eax
subl $0x1, %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0x81601
movq %fs:0x0, %rax
leaq -0x1450(%rax), %rax
movslq -0x14(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x15(%rbp)
movzbl -0x15(%rbp), %edi
callq 0x813f0
cmpl $0x0, %eax
jne 0x815ed
jmp 0x81601
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x815ba
movq %fs:0x0, %rax
movslq -0x14(%rbp), %rcx
leaq -0x144f(%rax,%rcx), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl -0x8(%rbp), %edx
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/build/c/shell.c
// Function: find_matches
static void find_matches(JanetByteView prefix) {
    JanetTable *env = gbl_complete_env;
    gbl_match_count = 0;
    while (NULL != env) {
        JanetKV *kvend = env->data + env->capacity;
        for (JanetKV *kv = env->data; kv < kvend; kv++) {
            if (!janet_checktype(kv->key, JANET_SYMBOL)) continue;
            const uint8_t *sym = janet_unwrap_symbol(kv->key);
            check_match(prefix, sym, janet_string_length(sym));
        }
        env = env->proto;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x8(%rbp)
movq %fs:0x0, %rax
leaq -0x1790(%rax), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq %fs:0x0, %rax
leaq -0x1008(%rax), %rax
movl $0x0, (%rax)
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
je 0x823f2
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x18(%rbp), %rcx
movslq 0x14(%rcx), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x823e1
xorl %eax, %eax
testb $0x1, %al
jne 0x8235b
jmp 0x82387
movq -0x28(%rbp), %rax
movsd (%rax), %xmm0
ucomisd %xmm0, %xmm0
setp %al
testb $0x1, %al
jne 0x82370
jmp 0x823a9
movq -0x28(%rbp), %rax
movq (%rax), %rax
shrq $0x2f, %rax
andq $0xf, %rax
cmpq $0x0, %rax
je 0x823a9
jmp 0x823a7
movq -0x28(%rbp), %rcx
movabsq $-0x800000000000, %rax  # imm = 0xFFFF800000000000
andq (%rcx), %rax
movabsq $-0x5800000000000, %rcx # imm = 0xFFFA800000000000
cmpq %rcx, %rax
je 0x823a9
jmp 0x823d0
movq -0x28(%rbp), %rax
movq (%rax), %rdi
callq 0x1f9e0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdx
movq -0x30(%rbp), %rax
movl -0x8(%rax), %ecx
movq -0x10(%rbp), %rdi
movl -0x8(%rbp), %esi
callq 0x82640
movq -0x28(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x28(%rbp)
jmp 0x82345
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x82312
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/build/c/shell.c
// Function: check_specials
static void check_specials(JanetByteView src) {
    check_cmatch(src, "break");
    check_cmatch(src, "def");
    check_cmatch(src, "do");
    check_cmatch(src, "fn");
    check_cmatch(src, "if");
    check_cmatch(src, "quasiquote");
    check_cmatch(src, "quote");
    check_cmatch(src, "set");
    check_cmatch(src, "splice");
    check_cmatch(src, "unquote");
    check_cmatch(src, "var");
    check_cmatch(src, "while");
    check_cmatch(src, "upscope");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x8(%rbp)
movq -0x10(%rbp), %rdi
movl -0x8(%rbp), %esi
leaq 0x4f6b6(%rip), %rdx     # 0xd1ad3
callq 0x82880
movq -0x10(%rbp), %rdi
movl -0x8(%rbp), %esi
leaq 0x53c9f(%rip), %rdx     # 0xd60cf
callq 0x82880
movq -0x10(%rbp), %rdi
movl -0x8(%rbp), %esi
leaq 0x5396d(%rip), %rdx     # 0xd5db0
callq 0x82880
movq -0x10(%rbp), %rdi
movl -0x8(%rbp), %esi
leaq 0x533dd(%rip), %rdx     # 0xd5833
callq 0x82880
movq -0x10(%rbp), %rdi
movl -0x8(%rbp), %esi
leaq 0x53c87(%rip), %rdx     # 0xd60f0
callq 0x82880
movq -0x10(%rbp), %rdi
movl -0x8(%rbp), %esi
leaq 0x53c9f(%rip), %rdx     # 0xd611b
callq 0x82880
movq -0x10(%rbp), %rdi
movl -0x8(%rbp), %esi
leaq 0x53ccb(%rip), %rdx     # 0xd615a
callq 0x82880
movq -0x10(%rbp), %rdi
movl -0x8(%rbp), %esi
leaq 0x53d42(%rip), %rdx     # 0xd61e4
callq 0x82880
movq -0x10(%rbp), %rdi
movl -0x8(%rbp), %esi
leaq 0x53da6(%rip), %rdx     # 0xd625b
callq 0x82880
movq -0x10(%rbp), %rdi
movl -0x8(%rbp), %esi
leaq 0x5335d(%rip), %rdx     # 0xd5825
callq 0x82880
movq -0x10(%rbp), %rdi
movl -0x8(%rbp), %esi
leaq 0x538e0(%rip), %rdx     # 0xd5dbb
callq 0x82880
movq -0x10(%rbp), %rdi
movl -0x8(%rbp), %esi
leaq 0x53dac(%rip), %rdx     # 0xd629a
callq 0x82880
movq -0x10(%rbp), %rdi
movl -0x8(%rbp), %esi
leaq 0x538b2(%rip), %rdx     # 0xd5db3
callq 0x82880
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/janet-lang[P]janet/build/c/shell.c
// Function: longest_common_prefix
static JanetByteView longest_common_prefix(void) {
    JanetByteView bv;
    if (gbl_match_count == 0) {
        bv.len = 0;
        bv.bytes = NULL;
    } else {
        bv = gbl_matches[0];
        for (int i = 0; i < gbl_match_count; i++) {
            JanetByteView other = gbl_matches[i];
            int32_t minlen = other.len < bv.len ? other.len : bv.len;
            for (bv.len = 0; bv.len < minlen; bv.len++) {
                if (bv.bytes[bv.len] != other.bytes[bv.len]) {
                    break;
                }
            }
        }
    }
    return bv;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %fs:0x0, %rax
leaq -0x1008(%rax), %rax
cmpl $0x0, (%rax)
jne 0x82544
movl $0x0, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
jmp 0x82629
movq %fs:0x0, %rax
leaq -0x1000(%rax), %rax
movq (%rax), %rcx
movq %rcx, -0x10(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x30(%rbp)
movq %fs:0x0, %rax
movq %rax, %rcx
movl -0x30(%rbp), %eax
leaq -0x1008(%rcx), %rcx
cmpl (%rcx), %eax
jge 0x82627
movq %fs:0x0, %rax
leaq -0x1000(%rax), %rax
movslq -0x14(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq %rcx, -0x28(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x825d1
movl -0x20(%rbp), %eax
movl %eax, -0x34(%rbp)
jmp 0x825d7
movl -0x8(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jge 0x82617
movq -0x10(%rbp), %rax
movslq -0x8(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movq -0x28(%rbp), %rcx
movslq -0x8(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x8260a
jmp 0x82617
jmp 0x8260c
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x825e4
jmp 0x82619
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x8256d
jmp 0x82629
movq -0x10(%rbp), %rax
movl -0x8(%rbp), %edx
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)