LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/termbox[P]termbox/termbox.c
// Function: tb_clear
void tb_clear(void) {
    if (buffer_size_change_request) {
        update_size();
        buffer_size_change_request = 0;
    }
    cellbuf_clear(&back_buffer);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x5be6(%rip), %eax      # 0xa9d0
cmpl $0x0, %eax
je 0x4dfe
callq 0x4340
movl $0x0, 0x5bd2(%rip)      # 0xa9d0
leaq 0x5bab(%rip), %rdi      # 0xa9b0
callq 0x3dc0
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/termbox[P]termbox/termbox.c
// Function: tb_select_input_mode
int tb_select_input_mode(int mode) {
    if (mode) {
        if ((mode & (TB_INPUT_ESC | TB_INPUT_ALT)) == 0)
            mode |= TB_INPUT_ESC;

        /* technically termbox can handle that, but let's be nice and show here
           what mode is actually used */
        if ((mode & (TB_INPUT_ESC | TB_INPUT_ALT)) ==
            (TB_INPUT_ESC | TB_INPUT_ALT))
            mode &= ~TB_INPUT_ALT;

        inputmode = mode;
        if (mode & TB_INPUT_MOUSE) {
            bytebuffer_puts(&output_buffer, funcs[T_ENTER_MOUSE]);
            bytebuffer_flush(&output_buffer, inout);
        } else {
            bytebuffer_puts(&output_buffer, funcs[T_EXIT_MOUSE]);
            bytebuffer_flush(&output_buffer, inout);
        }
    }
    return inputmode;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
je 0x4eb7
movl -0x4(%rbp), %eax
andl $0x3, %eax
cmpl $0x0, %eax
jne 0x4e39
movl -0x4(%rbp), %eax
orl $0x1, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
andl $0x3, %eax
cmpl $0x3, %eax
jne 0x4e4d
movl -0x4(%rbp), %eax
andl $-0x3, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl %eax, 0x5302(%rip)      # 0xa158
movl -0x4(%rbp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x4e8c
movq 0x5b40(%rip), %rax      # 0xa9a8
movq 0x60(%rax), %rsi
leaq 0x5b25(%rip), %rdi      # 0xa998
callq 0x3c00
movl 0x5ac2(%rip), %esi      # 0xa940
leaq 0x5b13(%rip), %rdi      # 0xa998
callq 0x3fe0
jmp 0x4eb5
movq 0x5b15(%rip), %rax      # 0xa9a8
movq 0x68(%rax), %rsi
leaq 0x5afa(%rip), %rdi      # 0xa998
callq 0x3c00
movl 0x5a97(%rip), %esi      # 0xa940
leaq 0x5ae8(%rip), %rdi      # 0xa998
callq 0x3fe0
jmp 0x4eb7
movl 0x529b(%rip), %eax      # 0xa158
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/termbox[P]termbox/termbox.c
// Function: terminfo_copy_string
static const char *terminfo_copy_string(char *data, int str, int table) {
    const int16_t off = *(int16_t *)(data + str);
    const char *src = data + table + off;
    int len = strlen(src);
    char *dst = malloc(len + 1);
    strcpy(dst, src);
    return dst;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movw (%rax,%rcx), %ax
movw %ax, -0x12(%rbp)
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
addq %rcx, %rax
movswl -0x12(%rbp), %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x30c0
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
callq 0x31b0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x3070
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/termbox[P]termbox/termbox.c
// Function: terminfo_try_path
static char *terminfo_try_path(const char *path, const char *term) {
    char tmp[4096];
    snprintf(tmp, sizeof(tmp), "%s/%c/%s", path, term[0], term);
    tmp[sizeof(tmp) - 1] = '\0';
    char *data = read_file(tmp);
    if (data) {
        return data;
    }

    // fallback to darwin specific dirs structure
    snprintf(tmp, sizeof(tmp), "%s/%x/%s", path, term[0], term);
    tmp[sizeof(tmp) - 1] = '\0';
    return read_file(tmp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1030, %rsp           # imm = 0x1030
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq -0x1020(%rbp), %rdi
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movsbl (%rax), %r8d
movq -0x18(%rbp), %r9
movl $0x1000, %esi           # imm = 0x1000
leaq 0x1dcb(%rip), %rdx      # 0x71a1
movb $0x0, %al
callq 0x30d0
movb $0x0, -0x21(%rbp)
leaq -0x1020(%rbp), %rdi
callq 0x5460
movq %rax, -0x1028(%rbp)
cmpq $0x0, -0x1028(%rbp)
je 0x540b
movq -0x1028(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x5449
leaq -0x1020(%rbp), %rdi
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movsbl (%rax), %r8d
movq -0x18(%rbp), %r9
movl $0x1000, %esi           # imm = 0x1000
leaq 0x1d7c(%rip), %rdx      # 0x71aa
movb $0x0, %al
callq 0x30d0
movb $0x0, -0x21(%rbp)
leaq -0x1020(%rbp), %rdi
callq 0x5460
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x1030, %rsp           # imm = 0x1030
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/termbox[P]termbox/termbox.c
// Function: read_file
static char *read_file(const char *file) {
    FILE *f = fopen(file, "rb");
    if (!f)
        return 0;

    struct stat st;
    if (fstat(fileno(f), &st) != 0) {
        fclose(f);
        return 0;
    }

    char *data = malloc(st.st_size);
    if (!data) {
        fclose(f);
        return 0;
    }

    if (fread(data, 1, st.st_size, f) != (size_t)st.st_size) {
        fclose(f);
        free(data);
        return 0;
    }

    fclose(f);
    return data;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x1d39(%rip), %rsi      # 0x71b3
callq 0x3210
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x5497
movq $0x0, -0x8(%rbp)
jmp 0x5545
movq -0x18(%rbp), %rdi
callq 0x3180
movl %eax, %edi
leaq -0xa8(%rbp), %rsi
callq 0x3240
cmpl $0x0, %eax
je 0x54c6
movq -0x18(%rbp), %rdi
callq 0x30b0
movq $0x0, -0x8(%rbp)
jmp 0x5545
movq -0x78(%rbp), %rdi
callq 0x31b0
movq %rax, -0xb0(%rbp)
cmpq $0x0, -0xb0(%rbp)
jne 0x54f3
movq -0x18(%rbp), %rdi
callq 0x30b0
movq $0x0, -0x8(%rbp)
jmp 0x5545
movq -0xb0(%rbp), %rdi
movq -0x78(%rbp), %rdx
movq -0x18(%rbp), %rcx
movl $0x1, %esi
callq 0x3090
cmpq -0x78(%rbp), %rax
je 0x5531
movq -0x18(%rbp), %rdi
callq 0x30b0
movq -0xb0(%rbp), %rdi
callq 0x3040
movq $0x0, -0x8(%rbp)
jmp 0x5545
movq -0x18(%rbp), %rdi
callq 0x30b0
movq -0xb0(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/termbox[P]termbox/termbox.c
// Function: try_compatible
static int try_compatible(const char *term, const char *name,
                          const char **tkeys, const char **tfuncs) {
    if (strstr(term, name)) {
        keys = tkeys;
        funcs = tfuncs;
        return 0;
    }

    return EUNSUPPORTED_TERM;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3250
cmpq $0x0, %rax
je 0x55aa
movq -0x20(%rbp), %rax
movq %rax, 0x544a(%rip)      # 0xa9e0
movq -0x28(%rbp), %rax
movq %rax, 0x5407(%rip)      # 0xa9a8
movl $0x0, -0x4(%rbp)
jmp 0x55b1
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/termbox[P]termbox/termbox.c
// Function: convertnum
static int convertnum(uint32_t num, char *buf) {
    int i, l = 0;
    int ch;
    do {
        buf[l++] = '0' + (num % 10);
        num /= 10;
    } while (num);
    for (i = 0; i < l / 2; i++) {
        ch = buf[i];
        buf[i] = buf[l - 1 - i];
        buf[l - 1 - i] = ch;
    }
    return l;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x4(%rbp), %eax
movl $0xa, %ecx
xorl %edx, %edx
divl %ecx
addl $0x30, %edx
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x18(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0x4(%rbp), %eax
movl $0xa, %ecx
xorl %edx, %edx
divl %ecx
movl %eax, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jne 0x5632
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x18(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x20(%rbp), %eax
cmpl %ecx, %eax
jge 0x56dc
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
subl $0x1, %ecx
subl -0x14(%rbp), %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %dl
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x1c(%rbp), %eax
movb %al, %dl
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
subl $0x1, %ecx
subl -0x14(%rbp), %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x5672
movl -0x18(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/termbox[P]termbox/termbox.c
// Function: bytebuffer_reserve
static void bytebuffer_reserve(struct bytebuffer *b, int cap) {
    if (b->cap >= cap) {
        return;
    }

    // prefer doubling capacity
    if (b->cap * 2 >= cap) {
        cap = b->cap * 2;
    }

    char *newbuf = realloc(b->buf, cap);
    b->buf = newbuf;
    b->cap = cap;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
cmpl -0xc(%rbp), %eax
jl 0x570d
jmp 0x5750
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
shll %eax
cmpl -0xc(%rbp), %eax
jl 0x5727
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
shll %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movslq -0xc(%rbp), %rsi
callq 0x31c0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xc(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/termbox[P]termbox/termbox.c
// Function: cellbuf_resize
static void cellbuf_resize(struct cellbuf *buf, int width, int height) {
    if (buf->width == width && buf->height == height)
        return;

    int oldw = buf->width;
    int oldh = buf->height;
    struct tb_cell *oldcells = buf->cells;

    cellbuf_init(buf, width, height);
    cellbuf_clear(buf);

    int minw = (width < oldw) ? width : oldw;
    int minh = (height < oldh) ? height : oldh;
    int i;

    for (i = 0; i < minh; ++i) {
        struct tb_cell *csrc = oldcells + (i * oldw);
        struct tb_cell *cdst = buf->cells + (i * width);
        memcpy(cdst, csrc, sizeof(struct tb_cell) * minw);
    }

    free(oldcells);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
cmpl -0xc(%rbp), %eax
jne 0x59be
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
cmpl -0x10(%rbp), %eax
jne 0x59be
jmp 0x5a9b
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x3d40
movq -0x8(%rbp), %rdi
callq 0x3dc0
movl -0xc(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x5a05
movl -0xc(%rbp), %eax
movl %eax, -0x44(%rbp)
jmp 0x5a0b
movl -0x14(%rbp), %eax
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x10(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x5a21
movl -0x10(%rbp), %eax
movl %eax, -0x48(%rbp)
jmp 0x5a27
movl -0x18(%rbp), %eax
movl %eax, -0x48(%rbp)
movl -0x48(%rbp), %eax
movl %eax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x28(%rbp), %eax
jge 0x5a92
movq -0x20(%rbp), %rax
movl -0x2c(%rbp), %ecx
imull -0x14(%rbp), %ecx
movslq %ecx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x2c(%rbp), %ecx
imull -0xc(%rbp), %ecx
movslq %ecx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movslq -0x24(%rbp), %rdx
shlq $0x3, %rdx
callq 0x3170
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x5a34
movq -0x20(%rbp), %rdi
callq 0x3040
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/termbox[P]termbox/termbox.c
// Function: read_up_to
static int read_up_to(int n) {
    assert(n > 0);
    const int prevlen = input_buffer.len;
    bytebuffer_resize(&input_buffer, prevlen + n);

    int read_n = 0;
    while (read_n <= n) {
        ssize_t r = 0;
        if (read_n < n) {
            r = read(inout, input_buffer.buf + prevlen + read_n, n - read_n);
        }
#ifdef __CYGWIN__
        // While linux man for tty says when VMIN == 0 && VTIME == 0, read
        // should return 0 when there is nothing to read, cygwin's read returns
        // -1. Not sure why and if it's correct to ignore it, but let's pretend
        // it's zero.
        if (r < 0)
            r = 0;
#endif
        if (r < 0) {
            // EAGAIN / EWOULDBLOCK shouldn't occur here
            assert(errno != EAGAIN && errno != EWOULDBLOCK);
            return -1;
        } else if (r > 0) {
            read_n += r;
        } else {
            bytebuffer_resize(&input_buffer, prevlen + read_n);
            return read_n;
        }
    }
    assert(!"unreachable");
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jle 0x5ca3
jmp 0x5cc2
leaq 0x176f(%rip), %rdi      # 0x7419
leaq 0x16c5(%rip), %rsi      # 0x7376
movl $0x4a5, %edx            # imm = 0x4A5
leaq 0x1762(%rip), %rcx      # 0x741f
callq 0x30e0
movl 0x4cc8(%rip), %eax      # 0xa990
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %esi
addl -0x8(%rbp), %esi
leaq 0x4cb0(%rip), %rdi      # 0xa988
callq 0x6420
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0x8(%rbp), %eax
jg 0x5daa
movq $0x0, -0x18(%rbp)
movl -0x10(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x5d2d
movl 0x4c3a(%rip), %edi      # 0xa940
movq 0x4c7b(%rip), %rsi      # 0xa988
movslq -0xc(%rbp), %rax
addq %rax, %rsi
movslq -0x10(%rbp), %rax
addq %rax, %rsi
movl -0x8(%rbp), %eax
subl -0x10(%rbp), %eax
movslq %eax, %rdx
callq 0x3140
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jge 0x5d72
callq 0x3060
cmpl $0xb, (%rax)
je 0x5d4a
callq 0x3060
cmpl $0xb, (%rax)
je 0x5d4a
jmp 0x5d69
leaq 0x16e2(%rip), %rdi      # 0x7433
leaq 0x161e(%rip), %rsi      # 0x7376
movl $0x4b9, %edx            # imm = 0x4B9
leaq 0x16bb(%rip), %rcx      # 0x741f
callq 0x30e0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5dc9
cmpq $0x0, -0x18(%rbp)
jle 0x5d89
movq -0x18(%rbp), %rcx
movslq -0x10(%rbp), %rax
addq %rcx, %rax
movl %eax, -0x10(%rbp)
jmp 0x5da3
movl -0xc(%rbp), %esi
addl -0x10(%rbp), %esi
leaq 0x4bf2(%rip), %rdi      # 0xa988
callq 0x6420
movl -0x10(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x5dc9
jmp 0x5da5
jmp 0x5ce4
leaq 0x16aa(%rip), %rdi      # 0x745b
leaq 0x15be(%rip), %rsi      # 0x7376
movl $0x4c2, %edx            # imm = 0x4C2
leaq 0x165b(%rip), %rcx      # 0x741f
callq 0x30e0
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/termbox[P]termbox/termbox.c
// Function: get_term_size
static void get_term_size(int *w, int *h) {
    struct winsize sz;
    memset(&sz, 0, sizeof(sz));

    ioctl(inout, TIOCGWINSZ, &sz);

    *w = sz.ws_col > 0 ? sz.ws_col : 80;
    *h = sz.ws_row > 0 ? sz.ws_row : 24;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
movl $0x8, %edx
callq 0x3100
movl 0x4b3a(%rip), %edi      # 0xa940
movl $0x5413, %esi           # imm = 0x5413
leaq -0x18(%rbp), %rdx
movb $0x0, %al
callq 0x3110
movzwl -0x16(%rbp), %eax
cmpl $0x0, %eax
jle 0x5e28
movzwl -0x16(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x5e32
movl $0x50, %eax
movl %eax, -0x1c(%rbp)
jmp 0x5e32
movl -0x1c(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movzwl -0x18(%rbp), %eax
cmpl $0x0, %eax
jle 0x5e4d
movzwl -0x18(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0x5e57
movl $0x18, %eax
movl %eax, -0x20(%rbp)
jmp 0x5e57
movl -0x20(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/termbox[P]termbox/termbox.c
// Function: parse_escape_seq
static int parse_escape_seq(struct tb_event *event, const char *buf, int len) {
    int mouse_parsed = parse_mouse_event(event, buf, len);

    if (mouse_parsed != 0)
        return mouse_parsed;

    // it's pretty simple here, find 'starts_with' match and return
    // success, else return failure
    int i;
    for (i = 0; keys[i]; i++) {
        if (starts_with(buf, len, keys[i])) {
            event->ch = 0;
            event->key = 0xFFFF - i;
            return strlen(keys[i]);
        }
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x5fb0
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
je 0x5ea7
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x5f2c
movl $0x0, -0x24(%rbp)
movq 0x4b2b(%rip), %rax      # 0xa9e0
movslq -0x24(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x5f25
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
movq 0x4b12(%rip), %rax      # 0xa9e0
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
callq 0x6390
testb $0x1, %al
jne 0x5ee1
jmp 0x5f18
movq -0x10(%rbp), %rax
movl $0x0, 0x4(%rax)
movl $0xffff, %eax           # imm = 0xFFFF
subl -0x24(%rbp), %eax
movw %ax, %cx
movq -0x10(%rbp), %rax
movw %cx, 0x2(%rax)
movq 0x4ada(%rip), %rax      # 0xa9e0
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x30c0
movl %eax, -0x4(%rbp)
jmp 0x5f2c
jmp 0x5f1a
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x5eae
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/termbox[P]termbox/termbox.c
// Function: bytebuffer_truncate
static void bytebuffer_truncate(struct bytebuffer *b, int n) {
    if (n <= 0)
        return;
    if (n > b->len)
        n = b->len;
    const int nmove = b->len - n;
    memmove(b->buf, b->buf + n, nmove);
    b->len -= n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jg 0x5f57
jmp 0x5fa7
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jle 0x5f6d
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
subl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movslq -0xc(%rbp), %rax
addq %rax, %rsi
movslq -0x10(%rbp), %rdx
callq 0x31d0
movl -0xc(%rbp), %edx
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x8(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/termbox[P]termbox/termbox.c
// Function: starts_with
static bool starts_with(const char *s1, int len, const char *s2) {
    int n = 0;
    while (*s2 && n < len) {
        if (*s1++ != *s2++)
            return false;
        n++;
    }
    return *s2 == 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x20(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x25(%rbp)
je 0x63c3
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
setl %al
movb %al, -0x25(%rbp)
movb -0x25(%rbp), %al
testb $0x1, %al
jne 0x63cc
jmp 0x6405
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movsbl (%rax), %eax
movq -0x20(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movsbl (%rcx), %ecx
cmpl %ecx, %eax
je 0x63fa
movb $0x0, -0x1(%rbp)
jmp 0x6417
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x63a6
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/termbox[P]termbox/utf8.c
// Function: tb_utf8_char_to_unicode
int tb_utf8_char_to_unicode(uint32_t *out, const char *c) {
    if (*c == 0)
        return TB_EOF;

    int i;
    unsigned char len = tb_utf8_char_length(*c);
    unsigned char mask = utf8_mask[len - 1];
    uint32_t result = c[0] & mask;
    for (i = 1; i < len; ++i) {
        result <<= 6;
        result |= c[i] & 0x3f;
    }

    *out = result;
    return (int)len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x64b8
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6539
movq -0x18(%rbp), %rax
movsbl (%rax), %edi
callq 0x6470
movb %al, -0x1d(%rbp)
movzbl -0x1d(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rcx
leaq 0x1098(%rip), %rax      # 0x7570
movb (%rax,%rcx), %al
movb %al, -0x1e(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
movzbl -0x1e(%rbp), %ecx
andl %ecx, %eax
movl %eax, -0x24(%rbp)
movl $0x1, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movzbl -0x1d(%rbp), %ecx
cmpl %ecx, %eax
jge 0x6529
movl -0x24(%rbp), %eax
shll $0x6, %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
andl $0x3f, %eax
orl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x64f5
movl -0x24(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movzbl -0x1d(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/termbox[P]termbox/utf8.c
// Function: tb_utf8_unicode_to_char
int tb_utf8_unicode_to_char(char *out, uint32_t c) {
    int len = 0;
    int first;
    int i;

    if (c < 0x80) {
        first = 0;
        len = 1;
    } else if (c < 0x800) {
        first = 0xc0;
        len = 2;
    } else if (c < 0x10000) {
        first = 0xe0;
        len = 3;
    } else if (c < 0x200000) {
        first = 0xf0;
        len = 4;
    } else if (c < 0x4000000) {
        first = 0xf8;
        len = 5;
    } else {
        first = 0xfc;
        len = 6;
    }

    for (i = len - 1; i > 0; --i) {
        out[i] = (c & 0x3f) | 0x80;
        c >>= 6;
    }
    out[0] = c | first;

    return len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
cmpl $0x80, -0xc(%rbp)
jae 0x657b
movl $0x0, -0x14(%rbp)
movl $0x1, -0x10(%rbp)
jmp 0x65f5
cmpl $0x800, -0xc(%rbp)      # imm = 0x800
jae 0x6594
movl $0xc0, -0x14(%rbp)
movl $0x2, -0x10(%rbp)
jmp 0x65f3
cmpl $0x10000, -0xc(%rbp)    # imm = 0x10000
jae 0x65ad
movl $0xe0, -0x14(%rbp)
movl $0x3, -0x10(%rbp)
jmp 0x65f1
cmpl $0x200000, -0xc(%rbp)   # imm = 0x200000
jae 0x65c6
movl $0xf0, -0x14(%rbp)
movl $0x4, -0x10(%rbp)
jmp 0x65ef
cmpl $0x4000000, -0xc(%rbp)  # imm = 0x4000000
jae 0x65df
movl $0xf8, -0x14(%rbp)
movl $0x5, -0x10(%rbp)
jmp 0x65ed
movl $0xfc, -0x14(%rbp)
movl $0x6, -0x10(%rbp)
jmp 0x65ef
jmp 0x65f1
jmp 0x65f3
jmp 0x65f5
movl -0x10(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jle 0x6630
movl -0xc(%rbp), %eax
andl $0x3f, %eax
orl $0x80, %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0xc(%rbp), %eax
shrl $0x6, %eax
movl %eax, -0xc(%rbp)
movl -0x18(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x65fe
movl -0xc(%rbp), %eax
orl -0x14(%rbp), %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, (%rax)
movl -0x10(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/antonblanchard[P]will-it-scale/tests/unix1.c
// Function: testcase
void testcase(unsigned long long *iterations, unsigned long nr)
{
	int fd[2];
	char c;
	int ret;

	socketpair(AF_UNIX, SOCK_STREAM, 0, fd);

	while (1) {
		do {
			ret = write(fd[WRITE], &c, 1);
		} while (ret != 1 && errno == EINTR);

		do {
			ret = read(fd[READ], &c, 1);
		} while (ret != 1 && errno == EINTR);

		(*iterations)++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x18(%rbp), %rcx
movl $0x1, %esi
xorl %edx, %edx
movl %esi, %edi
callq 0x2160
jmp 0x2fd4
movl -0x14(%rbp), %edi
leaq -0x19(%rbp), %rsi
movl $0x1, %edx
callq 0x20c0
movl %eax, -0x20(%rbp)
xorl %eax, %eax
cmpl $0x1, -0x20(%rbp)
movb %al, -0x21(%rbp)
je 0x3001
callq 0x2070
cmpl $0x4, (%rax)
sete %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x2fd4
jmp 0x300a
movl -0x18(%rbp), %edi
leaq -0x19(%rbp), %rsi
movl $0x1, %edx
callq 0x2130
movl %eax, -0x20(%rbp)
xorl %eax, %eax
cmpl $0x1, -0x20(%rbp)
movb %al, -0x22(%rbp)
je 0x3037
callq 0x2070
cmpl $0x4, (%rax)
sete %al
movb %al, -0x22(%rbp)
movb -0x22(%rbp), %al
testb $0x1, %al
jne 0x300a
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x2fd2
// File: /workspace/github_c_makefile_star2_O0/wtakuo[P]SVM/fun.c
// Function: new_function
Function new_function (size_t nargs, size_t nlv, Bcode code[], size_t codelen) {
    Function f = malloc(sizeof(struct _Function));
    if (f == NULL) {
        perror("new_function");
        exit(EXIT_FAILURE);
    }
    f->nargs = nargs;
    f->nlv = nlv;
    f->code = code;
    f->codelen = codelen;

    return f;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movl $0x20, %edi
callq 0x1060
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x1fe3
leaq 0x112d(%rip), %rdi      # 0x3101
callq 0x1070
movl $0x1, %edi
callq 0x1090
movq 0x20(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
movq 0x18(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x18(%rax)
movq (%rsp), %rax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/wtakuo[P]SVM/vmbench.c
// Function: vmtest
void vmtest (int x, int y, int z, vm_mode_t mode) {
    int codelen = sizeof(code)/sizeof(Bcode);
    Function f = new_function(3, 0, code + 16, codelen - 16);
    gv[0] = (Value)f;
    gv[1] = (Value)x;
    gv[2] = (Value)y;
    gv[3] = (Value)z;

    vm(code, codelen, vs_base, VS_SIZE, gv, GV_SIZE, mode);

    delete_function(f);
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x24(%rsp)
movl %esi, 0x20(%rsp)
movl %edx, 0x1c(%rsp)
movl %ecx, 0x18(%rsp)
movl $0x4b, 0x14(%rsp)
movl 0x14(%rsp), %eax
subl $0x10, %eax
movslq %eax, %rcx
movl $0x3, %edi
xorl %eax, %eax
movl %eax, %esi
leaq 0x2ffa(%rip), %rdx      # 0x5060
addq $0x10, %rdx
callq 0x1fa0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x3050(%rip)      # 0x50d0
movslq 0x24(%rsp), %rax
movq %rax, 0x304c(%rip)      # 0x50d8
movslq 0x20(%rsp), %rax
movq %rax, 0x3048(%rip)      # 0x50e0
movslq 0x1c(%rsp), %rax
movq %rax, 0x3044(%rip)      # 0x50e8
movslq 0x14(%rsp), %rsi
movq 0x3000(%rip), %rdx      # 0x50b0
movl 0x18(%rsp), %eax
leaq 0x2fa5(%rip), %rdi      # 0x5060
movl $0x400, %ecx            # imm = 0x400
leaq 0x3009(%rip), %r8       # 0x50d0
movl $0x8, %r9d
movl %eax, (%rsp)
callq 0x11a0
movq 0x8(%rsp), %rdi
callq 0x2020
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wtakuo[P]SVM/vmbench.c
// Function: main
int main (int argc, char *argv[]) {
    vm_mode_t mode = vm_normal_mode;
    int x, y, z;
    int i = 1;

    while (i < argc && argv[i][0] == '-') {
        char *arg = argv[i];
        int j = 1;
        while (arg[j] != '\0') {
            switch (arg[j]) {
            case 't':
                mode = vm_trace_mode;
                break;
            case 's':
                mode = vm_step_mode;
                break;
            default:
                fprintf(stderr, "usage: %s [-t][-s] x y z\n", argv[0]);
                return EXIT_FAILURE;
            }
            j++;
        }
        i++;
    }
    if (argc < i + 3) {
        fprintf(stderr, "usage: %s [-t][-s] x y z\n", argv[0]);
        return EXIT_FAILURE;
    }
    x = atoi(argv[i]);
    y = atoi(argv[i+1]);
    z = atoi(argv[i+2]);

    vmtest(x, y, z, mode);

    return EXIT_SUCCESS;
}

// Assembly:
subq $0x48, %rsp
movl $0x0, 0x44(%rsp)
movl %edi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movl $0x0, 0x34(%rsp)
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %ecx
xorl %eax, %eax
cmpl 0x40(%rsp), %ecx
movb %al, 0x13(%rsp)
jge 0x2140
movq 0x38(%rsp), %rax
movslq 0x24(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
sete %al
movb %al, 0x13(%rsp)
movb 0x13(%rsp), %al
testb $0x1, %al
jne 0x214d
jmp 0x2200
movq 0x38(%rsp), %rax
movslq 0x24(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x18(%rsp)
movl $0x1, 0x14(%rsp)
movq 0x18(%rsp), %rax
movslq 0x14(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x21f0
movq 0x18(%rsp), %rax
movslq 0x14(%rsp), %rcx
movsbl (%rax,%rcx), %eax
movl %eax, 0xc(%rsp)
subl $0x73, %eax
je 0x21a9
jmp 0x2194
movl 0xc(%rsp), %eax
subl $0x74, %eax
jne 0x21b3
jmp 0x219f
movl $0x1, 0x34(%rsp)
jmp 0x21e0
movl $0x2, 0x34(%rsp)
jmp 0x21e0
movq 0x2e3e(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
movq 0x38(%rsp), %rax
movq (%rax), %rdx
leaq 0xf42(%rip), %rsi       # 0x310e
movb $0x0, %al
callq 0x1050
movl $0x1, 0x44(%rsp)
jmp 0x22a5
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x2168
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x2115
movl 0x40(%rsp), %eax
movl 0x24(%rsp), %ecx
addl $0x3, %ecx
cmpl %ecx, %eax
jge 0x2239
movq 0x2de2(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
movq 0x38(%rsp), %rax
movq (%rax), %rdx
leaq 0xee6(%rip), %rsi       # 0x310e
movb $0x0, %al
callq 0x1050
movl $0x1, 0x44(%rsp)
jmp 0x22a5
movq 0x38(%rsp), %rax
movslq 0x24(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1080
movl %eax, 0x30(%rsp)
movq 0x38(%rsp), %rax
movl 0x24(%rsp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1080
movl %eax, 0x2c(%rsp)
movq 0x38(%rsp), %rax
movl 0x24(%rsp), %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1080
movl %eax, 0x28(%rsp)
movl 0x30(%rsp), %edi
movl 0x2c(%rsp), %esi
movl 0x28(%rsp), %edx
movl 0x34(%rsp), %ecx
callq 0x2030
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/sasairc[P]yasuna/src/libbenly/src/env.c
// Function: release_env_t
void release_env_t(env_t* env)
{
    if (env == NULL)
        return;

    int i   = 0,
        j   = 0;

    j = env->envc - 1;
    while (i <= j) {
        if (*(env->envs + i) != NULL) {
            free(*(env->envs + i));
            *(env->envs + i) = NULL;
        }
        if (*(env->envs + j) != NULL) {
            free(*(env->envs + j));
            *(env->envs + j) = NULL;
        }
        i++;
        j--;
    }
    if (env->envs != NULL) {
        free(env->envs);
        env->envs = NULL;
    }
    if (env != NULL) {
        free(env);
        env = NULL;
    }

    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x1388
jmp 0x147b
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
subl $0x1, %eax
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jg 0x143d
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x13ea
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x10(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x1426
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x10(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x13a2
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x1461
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
cmpq $0x0, -0x8(%rbp)
je 0x1479
movq -0x8(%rbp), %rdi
callq 0x1030
movq $0x0, -0x8(%rbp)
jmp 0x147b
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/./../dynasm/dasm_x86.h
// Function: dasm_init
void dasm_init(Dst_DECL, int maxsection)
{
  dasm_State *D;
  size_t psz = 0;
  int i;
  Dst_REF = NULL;
  DASM_M_GROW(Dst, struct dasm_State, Dst_REF, psz, DASM_PSZ(maxsection));
  D = Dst_REF;
  D->psize = psz;
  D->lglabels = NULL;
  D->lgsize = 0;
  D->pclabels = NULL;
  D->pcsize = 0;
  D->globals = NULL;
  D->maxsection = maxsection;
  for (i = 0; i < maxsection; i++) {
    D->sections[i].buf = NULL;  /* Need this for pass3. */
    D->sections[i].rbuf = D->sections[i].buf - DASM_SEC2POS(i);
    D->sections[i].bsize = 0;
    D->sections[i].epos = 0;  /* Wrong, but is recalculated after resize. */
  }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x30(%rsp), %rax
movq $0x0, (%rax)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x2c(%rsp), %eax
subl $0x1, %eax
cltq
imulq $0x28, %rax, %rax
addq $0x78, %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rax
cmpq (%rsp), %rax
jae 0x5387
cmpq $0x10, 0x8(%rsp)
jae 0x532d
movq $0x10, 0x8(%rsp)
jmp 0x532f
movq 0x8(%rsp), %rax
cmpq (%rsp), %rax
jae 0x534b
movq 0x8(%rsp), %rax
addq 0x8(%rsp), %rax
movq %rax, 0x8(%rsp)
jmp 0x532f
movq 0x30(%rsp), %rax
movq (%rax), %rdi
movq 0x8(%rsp), %rsi
callq 0x5150
movq %rax, %rcx
movq 0x30(%rsp), %rax
movq %rcx, (%rax)
movq 0x30(%rsp), %rax
cmpq $0x0, (%rax)
jne 0x537d
movl $0x1, %edi
callq 0x5190
movq 0x8(%rsp), %rax
movq %rax, 0x18(%rsp)
jmp 0x5389
movq 0x30(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x18(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, (%rax)
movq 0x20(%rsp), %rax
movq $0x0, 0x10(%rax)
movq 0x20(%rsp), %rax
movq $0x0, 0x18(%rax)
movq 0x20(%rsp), %rax
movq $0x0, 0x20(%rax)
movq 0x20(%rsp), %rax
movq $0x0, 0x28(%rax)
movq 0x20(%rsp), %rax
movq $0x0, 0x30(%rax)
movl 0x2c(%rsp), %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x48(%rax)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x2c(%rsp), %eax
jge 0x54b3
movq 0x20(%rsp), %rax
addq $0x50, %rax
movslq 0x14(%rsp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq $0x0, 0x8(%rax)
movq 0x20(%rsp), %rax
addq $0x50, %rax
movslq 0x14(%rsp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rcx
movl 0x14(%rsp), %eax
shll $0x18, %eax
movslq %eax, %rdx
xorl %eax, %eax
subq %rdx, %rax
shlq $0x2, %rax
addq %rax, %rcx
movq 0x20(%rsp), %rax
addq $0x50, %rax
movslq 0x14(%rsp), %rdx
imulq $0x28, %rdx, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movq 0x20(%rsp), %rax
addq $0x50, %rax
movslq 0x14(%rsp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq $0x0, 0x10(%rax)
movq 0x20(%rsp), %rax
addq $0x50, %rax
movslq 0x14(%rsp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movl $0x0, 0x1c(%rax)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x53f8
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/./../dynasm/dasm_x86.h
// Function: dasm_free
void dasm_free(Dst_DECL)
{
  dasm_State *D = Dst_REF;
  int i;
  for (i = 0; i < D->maxsection; i++)
    if (D->sections[i].buf)
      DASM_M_FREE(Dst, D->sections[i].buf, D->sections[i].bsize);
  if (D->pclabels) DASM_M_FREE(Dst, D->pclabels, D->pcsize);
  if (D->lglabels) DASM_M_FREE(Dst, D->lglabels, D->lgsize);
  DASM_M_FREE(Dst, D, D->psize);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
movq 0x8(%rsp), %rcx
cmpl 0x48(%rcx), %eax
jge 0x5535
movq 0x8(%rsp), %rax
addq $0x50, %rax
movslq 0x4(%rsp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, 0x8(%rax)
je 0x5526
movq 0x8(%rsp), %rax
addq $0x50, %rax
movslq 0x4(%rsp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
callq 0x5030
jmp 0x5528
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x54de
movq 0x8(%rsp), %rax
cmpq $0x0, 0x20(%rax)
je 0x554f
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x5030
movq 0x8(%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0x5569
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x5030
movq 0x8(%rsp), %rdi
callq 0x5030
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/./../dynasm/dasm_x86.h
// Function: dasm_growpc
void dasm_growpc(Dst_DECL, unsigned int maxpc)
{
  dasm_State *D = Dst_REF;
  size_t osz = D->pcsize;
  DASM_M_GROW(Dst, int, D->pclabels, D->pcsize, maxpc*sizeof(int));
  memset((void *)(((unsigned char *)D->pclabels)+osz), 0, D->pcsize-osz);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq 0x30(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq 0x28(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq 0x28(%rax), %rax
movq %rax, 0x10(%rsp)
movl 0x2c(%rsp), %eax
shlq $0x2, %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x8(%rsp), %rax
jae 0x5722
cmpq $0x10, 0x10(%rsp)
jae 0x56c0
movq $0x10, 0x10(%rsp)
jmp 0x56c2
movq 0x10(%rsp), %rax
cmpq 0x8(%rsp), %rax
jae 0x56df
movq 0x10(%rsp), %rax
addq 0x10(%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0x56c2
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0x5150
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x20(%rsp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x5714
movl $0x1, %edi
callq 0x5190
movq 0x10(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x28(%rax)
jmp 0x5724
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rdi
addq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x28(%rax), %rdx
subq 0x18(%rsp), %rdx
xorl %esi, %esi
callq 0x50c0
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/./../dynasm/dasm_x86.h
// Function: dasm_setup
void dasm_setup(Dst_DECL, const void *actionlist)
{
  dasm_State *D = Dst_REF;
  int i;
  D->actionlist = (dasm_ActList)actionlist;
  D->status = DASM_S_OK;
  D->section = &D->sections[0];
  memset((void *)D->lglabels, 0, D->lgsize);
  if (D->pclabels) memset((void *)D->pclabels, 0, D->pcsize);
  for (i = 0; i < D->maxsection; i++) {
    D->sections[i].pos = DASM_SEC2POS(i);
    D->sections[i].ofs = 0;
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rax
movl $0x0, 0x4c(%rax)
movq 0x10(%rsp), %rcx
addq $0x50, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x38(%rax)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rdx
xorl %esi, %esi
callq 0x50c0
movq 0x10(%rsp), %rax
cmpq $0x0, 0x20(%rax)
je 0x57d5
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rdi
movq 0x10(%rsp), %rax
movq 0x28(%rax), %rdx
xorl %esi, %esi
callq 0x50c0
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl 0x48(%rcx), %eax
jge 0x5833
movl 0xc(%rsp), %ecx
shll $0x18, %ecx
movq 0x10(%rsp), %rax
addq $0x50, %rax
movslq 0xc(%rsp), %rdx
imulq $0x28, %rdx, %rdx
addq %rdx, %rax
movl %ecx, 0x18(%rax)
movq 0x10(%rsp), %rax
addq $0x50, %rax
movslq 0xc(%rsp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movl $0x0, 0x20(%rax)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x57dd
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/buildvm.c
// Function: collect_reloc
static int collect_reloc(BuildCtx *ctx, uint8_t *addr, int idx, int type)
{
  if (ctx->nreloc >= BUILD_MAX_RELOC) {
    fprintf(stderr, "Error: too many relocations, increase BUILD_MAX_RELOC.\n");
    exit(1);
  }
  if (relocmap[idx] < 0) {
    relocmap[idx] = ctx->nrelocsym;
    ctx->relocsym[ctx->nrelocsym] = sym_decorate(ctx, "", extnames[idx]);
    ctx->nrelocsym++;
  }
  ctx->reloc[ctx->nreloc].ofs = (int32_t)(addr - ctx->code);
  ctx->reloc[ctx->nreloc].sym = relocmap[idx];
  ctx->reloc[ctx->nreloc].type = type;
  ctx->nreloc++;
#if LJ_TARGET_XBOX360
  return (int)(ctx->code - addr) + 4;  /* Encode symbol offset of .text. */
#else
  return 0;  /* Encode symbol offset of 0. */
#endif
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movl %edx, 0x4(%rsp)
movl %ecx, (%rsp)
movq 0x10(%rsp), %rax
cmpl $0xc8, 0x44(%rax)
jl 0x7265
movq 0x12dae(%rip), %rax     # 0x19ff8
movq (%rax), %rdi
leaq 0xd0b4(%rip), %rsi      # 0x14308
movb $0x0, %al
callq 0x5110
movl $0x1, %edi
callq 0x5190
movslq 0x4(%rsp), %rcx
leaq 0x12e9f(%rip), %rax     # 0x1a110
cmpl $0x0, (%rax,%rcx,4)
jge 0x72d6
movq 0x10(%rsp), %rax
movl 0x48(%rax), %edx
movslq 0x4(%rsp), %rcx
leaq 0x12e85(%rip), %rax     # 0x1a110
movl %edx, (%rax,%rcx,4)
movq 0x10(%rsp), %rdi
movslq 0x4(%rsp), %rcx
leaq 0x121b1(%rip), %rax     # 0x19450
movq (%rax,%rcx,8), %rdx
leaq 0xe7b4(%rip), %rsi      # 0x15a5e
callq 0x8510
movq %rax, %rdx
movq 0x10(%rsp), %rax
movq 0x60(%rax), %rax
movq 0x10(%rsp), %rcx
movslq 0x48(%rcx), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x10(%rsp), %rax
movl 0x48(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x48(%rax)
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movq 0x28(%rcx), %rcx
subq %rcx, %rax
movl %eax, %ecx
movq 0x10(%rsp), %rax
addq $0x90, %rax
movq 0x10(%rsp), %rdx
movslq 0x44(%rdx), %rdx
imulq $0xc, %rdx, %rdx
addq %rdx, %rax
movl %ecx, (%rax)
movslq 0x4(%rsp), %rcx
leaq 0x12dfe(%rip), %rax     # 0x1a110
movl (%rax,%rcx,4), %ecx
movq 0x10(%rsp), %rax
addq $0x90, %rax
movq 0x10(%rsp), %rdx
movslq 0x44(%rdx), %rdx
imulq $0xc, %rdx, %rdx
addq %rdx, %rax
movl %ecx, 0x4(%rax)
movl (%rsp), %ecx
movq 0x10(%rsp), %rax
addq $0x90, %rax
movq 0x10(%rsp), %rdx
movslq 0x44(%rdx), %rdx
imulq $0xc, %rdx, %rdx
addq %rdx, %rax
movl %ecx, 0x8(%rax)
movq 0x10(%rsp), %rax
movl 0x44(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x44(%rax)
xorl %eax, %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/./../dynasm/dasm_x86.h
// Function: dasm_getpclabel
int dasm_getpclabel(Dst_DECL, unsigned int pc)
{
  dasm_State *D = Dst_REF;
  if (pc*sizeof(int) < D->pcsize) {
    int pos = D->pclabels[pc];
    if (pos < 0) return *DASM_POS2PTR(D, -pos);
    if (pos > 0) return -1;  /* Undefined. */
  }
  return -2;  /* Unused or out of range. */
}

// Assembly:
movq %rdi, -0x10(%rsp)
movl %esi, -0x14(%rsp)
movq -0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rsp)
movl -0x14(%rsp), %eax
shlq $0x2, %rax
movq -0x20(%rsp), %rcx
cmpq 0x28(%rcx), %rax
jae 0x73f8
movq -0x20(%rsp), %rax
movq 0x20(%rax), %rax
movl -0x14(%rsp), %ecx
movl (%rax,%rcx,4), %eax
movl %eax, -0x24(%rsp)
cmpl $0x0, -0x24(%rsp)
jge 0x73e5
movq -0x20(%rsp), %rax
addq $0x50, %rax
xorl %ecx, %ecx
subl -0x24(%rsp), %ecx
sarl $0x18, %ecx
movslq %ecx, %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rax
xorl %ecx, %ecx
subl -0x24(%rsp), %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x4(%rsp)
jmp 0x7400
cmpl $0x0, -0x24(%rsp)
jle 0x73f6
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
jmp 0x7400
jmp 0x73f8
movl $0xfffffffe, -0x4(%rsp) # imm = 0xFFFFFFFE
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/./../dynasm/dasm_x86.h
// Function: dasm_checkstep
int dasm_checkstep(Dst_DECL, int secmatch)
{
  dasm_State *D = Dst_REF;
  if (D->status == DASM_S_OK) {
    int i;
    for (i = 1; i <= 9; i++) {
      if (D->lglabels[i] > 0) { D->status = DASM_S_UNDEF_L|i; break; }
      D->lglabels[i] = 0;
    }
  }
  if (D->status == DASM_S_OK && secmatch >= 0 &&
      D->section != &D->sections[secmatch])
    D->status = DASM_S_MATCH_SEC|(int)(D->section-D->sections);
  return D->status;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movq -0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rsp)
movq -0x18(%rsp), %rax
cmpl $0x0, 0x4c(%rax)
jne 0x748c
movl $0x1, -0x1c(%rsp)
cmpl $0x9, -0x1c(%rsp)
jg 0x748a
movq -0x18(%rsp), %rax
movq 0x10(%rax), %rax
movslq -0x1c(%rsp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jle 0x7468
movl -0x1c(%rsp), %ecx
orl $0x21000000, %ecx       # imm = 0x21000000
movq -0x18(%rsp), %rax
movl %ecx, 0x4c(%rax)
jmp 0x748a
movq -0x18(%rsp), %rax
movq 0x10(%rax), %rax
movslq -0x1c(%rsp), %rcx
movl $0x0, (%rax,%rcx,4)
movl -0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rsp)
jmp 0x7439
jmp 0x748c
movq -0x18(%rsp), %rax
cmpl $0x0, 0x4c(%rax)
jne 0x74f0
cmpl $0x0, -0xc(%rsp)
jl 0x74f0
movq -0x18(%rsp), %rax
movq 0x38(%rax), %rax
movq -0x18(%rsp), %rcx
addq $0x50, %rcx
movslq -0xc(%rsp), %rdx
imulq $0x28, %rdx, %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
je 0x74f0
movq -0x18(%rsp), %rax
movq 0x38(%rax), %rax
movq -0x18(%rsp), %rcx
addq $0x50, %rcx
subq %rcx, %rax
movl $0x28, %ecx
cqto
idivq %rcx
movl %eax, %ecx
orl $0x3000000, %ecx        # imm = 0x3000000
movq -0x18(%rsp), %rax
movl %ecx, 0x4c(%rax)
movq -0x18(%rsp), %rax
movl 0x4c(%rax), %eax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/buildvm.c
// Function: owrite
void owrite(BuildCtx *ctx, const void *ptr, size_t sz)
{
  if (fwrite(ptr, 1, sz, ctx->fp) != sz) {
    fprintf(stderr, "Error: cannot write to output file: %s\n",
	    strerror(errno));
    exit(1);
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rdx
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rcx
movl $0x1, %esi
callq 0x51a0
cmpq 0x10(%rsp), %rax
je 0x7572
movq 0x12aba(%rip), %rax     # 0x19ff8
movq (%rax), %rax
movq %rax, 0x8(%rsp)
callq 0x5040
movl (%rax), %edi
callq 0x51b0
movq 0x8(%rsp), %rdi
movq %rax, %rdx
leaq 0xc598(%rip), %rsi      # 0x13af9
movb $0x0, %al
callq 0x5110
movl $0x1, %edi
callq 0x5190
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zenkj[P]luajit-arm64/src/host/buildvm.c
// Function: parseargs
static void parseargs(BuildCtx *ctx, char **argv)
{
  const char *a;
  int i;
  ctx->mode = (BuildMode)-1;
  ctx->outname = "-";
  for (i = 1; (a = argv[i]) != NULL; i++) {
    if (a[0] != '-')
      break;
    switch (a[1]) {
    case '-':
      if (a[2]) goto err;
      i++;
      goto ok;
    case '\0':
      goto ok;
    case 'm':
      i++;
      if (a[2] || argv[i] == NULL) goto err;
      ctx->mode = parsemode(argv[i]);
      break;
    case 'o':
      i++;
      if (a[2] || argv[i] == NULL) goto err;
      ctx->outname = argv[i];
      break;
    default: err:
      usage();
      break;
    }
  }
ok:
  ctx->args = argv+i;
  if (ctx->mode == (BuildMode)-1) goto err;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movl $0xffffffff, 0x8(%rax)  # imm = 0xFFFFFFFF
movq 0x20(%rsp), %rax
leaq 0xebdf(%rip), %rcx      # 0x16415
movq %rcx, 0x18(%rax)
movl $0x1, 0xc(%rsp)
movq 0x18(%rsp), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x7976
movq 0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
je 0x7871
jmp 0x7976
movq 0x10(%rsp), %rax
movsbl 0x1(%rax), %eax
movl %eax, 0x8(%rsp)
testl %eax, %eax
je 0x78c8
jmp 0x7884
movl 0x8(%rsp), %eax
subl $0x2d, %eax
je 0x78a8
jmp 0x788f
movl 0x8(%rsp), %eax
subl $0x6d, %eax
je 0x78cd
jmp 0x789a
movl 0x8(%rsp), %eax
subl $0x6f, %eax
je 0x7918
jmp 0x795d
movq 0x10(%rsp), %rax
cmpb $0x0, 0x2(%rax)
je 0x78b8
jmp 0x795f
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x7978
jmp 0x7978
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rax
movsbl 0x2(%rax), %eax
cmpl $0x0, %eax
jne 0x78f7
movq 0x18(%rsp), %rax
movslq 0xc(%rsp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x78f9
jmp 0x795f
movq 0x18(%rsp), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x85e0
movl %eax, %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x8(%rax)
jmp 0x7964
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rax
movsbl 0x2(%rax), %eax
cmpl $0x0, %eax
jne 0x7942
movq 0x18(%rsp), %rax
movslq 0xc(%rsp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x7944
jmp 0x795f
movq 0x18(%rsp), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x18(%rax)
jmp 0x7964
jmp 0x795f
callq 0x8660
jmp 0x7966
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x7842
jmp 0x7978
movq 0x18(%rsp), %rcx
movslq 0xc(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x20(%rsp), %rax
cmpl $-0x1, 0x8(%rax)
jne 0x799f
jmp 0x795f
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)