LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/ieyasu[P]funit/parse.c
// Function: parse_fail
void parse_fail(struct ParseState *ps, const char *col, const char *message)
{
    assert(ps->line_pos != NULL);

    // file:line:
    assert(ps->path != NULL);
    fprintf(stderr, "%s:%li:\n\n", ps->path, ps->lineno);
    // code
    fwrite(ps->line_pos, ps->next_line_pos - ps->line_pos, 1, stderr);
    fputs("\n", stderr);
    // column indicator
    if (col) {
        int n = col - ps->line_pos;
        int spaces = n > 2 ? n - 2 : n;
        while (spaces > 0) {
            fputs(" ", stderr);
            spaces--;
        }
        if (n > 2)
            fputs("--", stderr);
        fputs("^", stderr);
        if (n <= 2)
            fputs("--", stderr);
        fputs("\n", stderr);
    }
    // error message
    fprintf(stderr, "Error: %s\n", message);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
cmpq $0x0, 0x28(%rdi)
je 0x50e2
movq %rdx, %rbx
movq %rdi, %r15
movq (%rdi), %rdx
testq %rdx, %rdx
je 0x5101
movq %rsi, %r14
movq 0x6fc9(%rip), %r12      # 0xbff8
movq (%r12), %rdi
movq 0x48(%r15), %rcx
leaq 0x3bca(%rip), %rsi      # 0x8c08
xorl %eax, %eax
callq 0x2190
movq 0x28(%r15), %rdi
movq 0x30(%r15), %rsi
subq %rdi, %rsi
movq (%r12), %rcx
movl $0x1, %edx
callq 0x2250
movq (%r12), %rsi
leaq 0x3ba7(%rip), %rdi      # 0x8c10
callq 0x2130
testq %r14, %r14
je 0x50c2
subl 0x28(%r15), %r14d
leal -0x2(%r14), %edi
cmpl $0x3, %r14d
cmovll %r14d, %edi
testl %edi, %edi
jle 0x508c
callq 0x2545
cmpl $0x3, %r14d
jl 0x5097
callq 0x2574
movq (%r12), %rsi
leaq 0x3b73(%rip), %rdi      # 0x8c15
callq 0x2130
cmpl $0x2, %r14d
jg 0x50b2
callq 0x258a
movq (%r12), %rsi
leaq 0x3b53(%rip), %rdi      # 0x8c10
callq 0x2130
movq (%r12), %rdi
leaq 0x3b4a(%rip), %rsi      # 0x8c17
movq %rbx, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2190
leaq 0x3ab0(%rip), %rdi      # 0x8b99
leaq 0x3abe(%rip), %rsi      # 0x8bae
leaq 0x3abf(%rip), %rcx      # 0x8bb6
movl $0x16, %edx
callq 0x2120
leaq 0x3aef(%rip), %rdi      # 0x8bf7
leaq 0x3a9f(%rip), %rsi      # 0x8bae
leaq 0x3aa0(%rip), %rcx      # 0x8bb6
movl $0x19, %edx
callq 0x2120
// File: /workspace/github_c_makefile_star2_O1/ieyasu[P]funit/parse.c
// Function: next_line
char *next_line(struct ParseState *ps)
{
    char *prev_line;

    assert(ps->file_buf != NULL);

    if (ps->line_pos) {
        assert(ps->next_line_pos >= ps->line_pos ||
               ps->line_pos == ps->file_end);
        prev_line = ps->line_pos;
        ps->line_pos = ps->next_line_pos;
        // read past \r\n
        while (ps->line_pos < ps->file_end) {
            if (*ps->line_pos == '\n') {
                ps->line_pos++;
                ps->lineno++;
                break;
            } else if (*ps->line_pos == '\r') {
                if (ps->line_pos + 1 < ps->file_end &&
                    *(ps->line_pos + 1) == '\n')
                    ps->line_pos += 2;
                else
                    ps->line_pos++;
                ps->lineno++;
                break;
            }
            ps->line_pos++;
        }
        if (ps->line_pos >= ps->file_end) {
            ps->line_pos = prev_line;
            ps->lineno--;
            ps->read_pos = ps->file_end;
            return NULL;
        }
    } else { // very first line
        ps->line_pos = ps->file_buf;
        ps->lineno = 1;
    }
    ps->read_pos = ps->next_pos = ps->line_pos;

    // find next \r\n
    ps->next_line_pos = ps->line_pos;
    while (ps->next_line_pos < ps->file_end) {
        switch (*ps->next_line_pos) {
        case '\n':
        case '\r':
            goto eol;
        default:
            ps->next_line_pos++;
            break;
        }
    }
 eol:
    return ps->line_pos;
}

// Assembly:
pushq %rax
movq 0x18(%rdi), %rcx
testq %rcx, %rcx
je 0x52ab
movq 0x28(%rdi), %rax
testq %rax, %rax
je 0x5238
movq 0x30(%rdi), %rdx
cmpq %rax, %rdx
jae 0x5208
cmpq 0x20(%rdi), %rax
jne 0x52ca
movq 0x20(%rdi), %rcx
movq %rdx, 0x28(%rdi)
cmpq %rcx, %rdx
jae 0x525e
incq %rdx
movzbl -0x1(%rdx), %esi
cmpl $0xa, %esi
je 0x5256
cmpl $0xd, %esi
je 0x5246
movq %rdx, 0x28(%rdi)
leaq 0x1(%rdx), %rsi
cmpq %rcx, %rdx
movq %rsi, %rdx
jne 0x5218
jmp 0x525e
movq %rcx, 0x28(%rdi)
movq $0x1, 0x48(%rdi)
jmp 0x5264
cmpq %rcx, %rdx
jae 0x5256
leaq 0x1(%rdx), %rsi
cmpb $0xa, (%rdx)
cmoveq %rsi, %rdx
movq %rdx, 0x28(%rdi)
incq 0x48(%rdi)
cmpq %rcx, 0x28(%rdi)
jae 0x529b
movq 0x20(%rdi), %rcx
movq 0x28(%rdi), %rax
movq %rax, 0x40(%rdi)
movq %rax, 0x38(%rdi)
movq %rax, 0x30(%rdi)
cmpq %rcx, %rax
jae 0x52a9
movq %rax, %rdx
movzbl (%rdx), %esi
cmpl $0xa, %esi
je 0x52a9
cmpl $0xd, %esi
je 0x52a9
incq %rdx
movq %rdx, 0x30(%rdi)
cmpq %rcx, %rdx
jne 0x5280
jmp 0x52a9
movq %rax, 0x28(%rdi)
decq 0x48(%rdi)
movq %rcx, 0x38(%rdi)
xorl %eax, %eax
popq %rcx
retq
leaq 0x397d(%rip), %rdi      # 0x8c2f
leaq 0x38f5(%rip), %rsi      # 0x8bae
leaq 0x3984(%rip), %rcx      # 0x8c44
movl $0x49, %edx
callq 0x2120
leaq 0x3998(%rip), %rdi      # 0x8c69
leaq 0x38d6(%rip), %rsi      # 0x8bae
leaq 0x3965(%rip), %rcx      # 0x8c44
movl $0x4d, %edx
callq 0x2120
// File: /workspace/github_c_makefile_star2_O1/ieyasu[P]funit/parse.c
// Function: skip_next_ws
char *skip_next_ws(struct ParseState *ps)
{
    assert(ps->next_pos != NULL);

    while (ps->next_pos < ps->next_line_pos) {
        switch (*ps->next_pos) {
        case ' ':
        case '\t':
            ps->next_pos++;
            break;
        default:
            goto eol;
        }
    }
 eol:
    return ps->next_pos;
}

// Assembly:
pushq %rax
cmpq $0x0, 0x40(%rdi)
je 0x5319
movq 0x30(%rdi), %rcx
movq 0x40(%rdi), %rax
cmpq %rcx, %rax
jae 0x5317
movzbl (%rax), %edx
cmpl $0x20, %edx
je 0x530b
cmpl $0x9, %edx
jne 0x5317
incq %rax
movq %rax, 0x40(%rdi)
cmpq %rcx, %rax
jne 0x52fe
popq %rcx
retq
leaq 0x398b(%rip), %rdi      # 0x8cab
leaq 0x3887(%rip), %rsi      # 0x8bae
leaq 0x3992(%rip), %rcx      # 0x8cc0
movl $0x82, %edx
callq 0x2120
// File: /workspace/github_c_makefile_star2_O1/ieyasu[P]funit/parse.c
// Function: next_thing
char *next_thing(struct ParseState *ps, size_t *len, end_finder_fun end_fun)
{
    skip_next_ws(ps);
    ps->read_pos = ps->next_pos;

    end_fun(ps);

    if (ps->next_pos - ps->read_pos > 0) {
        if (len)
            *len = ps->next_pos - ps->read_pos;
        return ps->read_pos;
    }
    return (char *)END_OF_LINE;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
callq 0x52e9
movq 0x40(%r15), %rax
movq %rax, 0x38(%r15)
movq %r15, %rdi
callq *%r14
movq 0x38(%r15), %rax
movq 0x40(%r15), %rcx
subq %rax, %rcx
testq %rcx, %rcx
jle 0x5373
testq %rbx, %rbx
je 0x5378
movq %rcx, (%rbx)
jmp 0x5378
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/ieyasu[P]funit/parse.c
// Function: open_file_for_parsing
int open_file_for_parsing(const char *path, struct ParseState *ps)
{
    struct stat statbuf;

    ps->fd = open(path, O_RDONLY);
    if (ps->fd == -1) {
        fprintf(stderr, "Opening file %s: %s\n", path, strerror(errno));
        return -1;
    }
    ps->path = path;

    if (fstat(ps->fd, &statbuf)) {
        fprintf(stderr, "Stat file %s: %s\n", path, strerror(errno));
        goto close_it;
    }
    if (statbuf.st_size < 1) {
        fprintf(stderr, "File %s is empty!\n", path);
        goto close_it;
    } else if (statbuf.st_size > MAX_PARSE_SIZE) {
        fprintf(stderr, "File %s is too big (> %lu bytes)!\n", path,
                (unsigned long)MAX_PARSE_SIZE);
        goto close_it;
    }
    ps->bufsize = (size_t)statbuf.st_size;

    ps->file_buf = (char *)mmap(NULL, ps->bufsize, PROT_READ, MAP_SHARED,
                                ps->fd, 0);
    if (!ps->file_buf) {
        fprintf(stderr, "Mapping file %s: %s\n", path, strerror(errno));
        goto close_it;
    }

    ps->file_end = ps->file_buf + ps->bufsize;
    ps->line_pos = ps->next_line_pos = NULL;
    ps->read_pos = ps->next_pos = NULL;
    ps->lineno = 0;
    return 0;

 close_it:
    close_parse_file(ps);
    return -1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorl %esi, %esi
xorl %eax, %eax
callq 0x2200
movl %eax, 0x8(%rbx)
cmpl $-0x1, %eax
je 0x540a
movq %r14, (%rbx)
movq %rsp, %rsi
movl %eax, %edi
callq 0x2270
testl %eax, %eax
jne 0x5414
movq 0x30(%rsp), %rsi
testq %rsi, %rsi
jle 0x541e
cmpq $0x800001, %rsi         # imm = 0x800001
jge 0x543b
movq %rsi, 0x10(%rbx)
movl 0x8(%rbx), %r8d
xorl %r15d, %r15d
xorl %edi, %edi
movl $0x1, %edx
movl $0x1, %ecx
xorl %r9d, %r9d
callq 0x20e0
movq %rax, 0x18(%rbx)
testq %rax, %rax
je 0x545d
addq 0x10(%rbx), %rax
movq %rax, 0x20(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rbx)
movups %xmm0, 0x38(%rbx)
movq $0x0, 0x48(%rbx)
jmp 0x5473
movq %r14, %rdi
callq 0x2616
jmp 0x546d
movq %r14, %rdi
callq 0x25a0
jmp 0x5465
movq 0x6bd3(%rip), %rax      # 0xbff8
movq (%rax), %rdi
leaq 0x38e0(%rip), %rsi      # 0x8d0f
movq %r14, %rdx
xorl %eax, %eax
callq 0x2190
jmp 0x5465
movq 0x6bb6(%rip), %rax      # 0xbff8
movq (%rax), %rdi
leaq 0x38d6(%rip), %rsi      # 0x8d22
movl $0x800000, %ecx         # imm = 0x800000
movq %r14, %rdx
xorl %eax, %eax
callq 0x2190
jmp 0x5465
movq %r14, %rdi
callq 0x25db
movq %rbx, %rdi
callq 0x5483
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
movl %r15d, %eax
addq $0x90, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/ieyasu[P]funit/parse.c
// Function: close_parse_file
void close_parse_file(struct ParseState *ps)
{
    assert(ps != NULL);

    if (ps->file_buf) {
        if (!munmap(ps->file_buf, ps->bufsize)) {
            ps->file_buf = NULL;
        } else {
            fprintf(stderr, "Unmapping file %s: %s\n", ps->path,
                    strerror(errno));
            abort();
        }
    }

    if (ps->fd && !close(ps->fd)) {
        ps->fd = 0;
    } else {
        fprintf(stderr, "Closing file %s: %s\n", ps->path, strerror(errno));
        abort();
    }
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x54cb
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x54aa
movq 0x10(%rbx), %rsi
callq 0x21f0
testl %eax, %eax
jne 0x54ea
movq $0x0, 0x18(%rbx)
movl 0x8(%rbx), %edi
testl %edi, %edi
je 0x54c3
callq 0x2140
testl %eax, %eax
jne 0x54c3
movl $0x0, 0x8(%rbx)
popq %rbx
retq
movq %rbx, %rdi
callq 0x268a
leaq 0x3888(%rip), %rdi      # 0x8d5a
leaq 0x36d5(%rip), %rsi      # 0x8bae
leaq 0x3885(%rip), %rcx      # 0x8d65
movl $0xd1, %edx
callq 0x2120
movq %rbx, %rdi
callq 0x2651
nop
// File: /workspace/github_c_makefile_star2_O1/ieyasu[P]funit/parse_test_file.c
// Function: close_testfile
void close_testfile(struct TestFile *tf)
{
    assert(tf != NULL);

    free((void *)tf->path);

    if (tf->sets)
        free_sets(tf->sets);

    close_parse_file(&tf->ps);

    free(tf);
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x5525
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x2040
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x5513
callq 0x5544
leaq 0x18(%rbx), %rdi
callq 0x5483
movq %rbx, %rdi
popq %rbx
jmp 0x2040
leaq 0x38bc(%rip), %rdi      # 0x8de8
leaq 0x38c0(%rip), %rsi      # 0x8df3
leaq 0x38cb(%rip), %rcx      # 0x8e05
movl $0x5b, %edx
callq 0x2120
// File: /workspace/github_c_makefile_star2_O1/ieyasu[P]funit/parse_test_file.c
// Function: free_sets
static void free_sets(struct TestSet *set)
{
    if (set->next)
        free_sets(set->next);
    if (set->deps)
        free_deps(set->deps);
    if (set->setup)
        free_code(set->setup);
    if (set->teardown)
        free_code(set->teardown);
    if (set->tests)
        free_cases(set->tests);
    if (set->code)
        free_code(set->code);
    free(set);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x5555
callq 0x5544
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x5563
callq 0x5cd8
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x5571
callq 0x5cf2
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x557f
callq 0x5cf2
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x558d
callq 0x5d20
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x559b
callq 0x5cf2
movq %rbx, %rdi
popq %rbx
jmp 0x2040
// File: /workspace/github_c_makefile_star2_O1/ieyasu[P]funit/parse_test_file.c
// Function: free_code
static void free_code(struct Code *code)
{
    if (code->next)
        free_code(code->next);
    if (code->type == MACRO_CODE) {
        if (code->u.m.args)
            free_code(code->u.m.args);
    }
    free(code);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x5d03
callq 0x5cf2
cmpl $0x1, 0x8(%rbx)
jne 0x5d17
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x5d17
callq 0x5cf2
movq %rbx, %rdi
popq %rbx
jmp 0x2040
// File: /workspace/github_c_makefile_star2_O1/ieyasu[P]funit/parse_test_file.c
// Function: free_cases
static void free_cases(struct TestCase *test)
{
    if (test->next)
        free_cases(test->next);
    if (test->code)
        free_code(test->code);
    free(test);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x5d31
callq 0x5d20
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x5d3f
callq 0x5cf2
movq %rbx, %rdi
popq %rbx
jmp 0x2040
// File: /workspace/github_c_makefile_star2_O1/ieyasu[P]funit/parse_test_file.c
// Function: expect_eol
static int expect_eol(struct ParseState *ps)
{
    char *tok = next_token(ps, NULL);
    assert(tok != NULL);
    if (tok != END_OF_LINE) {
        syntax_error(ps);
        return -1;
    }
    if (!next_line(ps)) {
        parse_fail(ps, ps->read_pos, "expected a newline");
        return -1;
    }
    return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq -0x85(%rip), %rdx       # 0x5d48
xorl %r14d, %r14d
xorl %esi, %esi
callq 0x5338
cmpq $0x1, %rax
je 0x5dec
testq %rax, %rax
je 0x5e1d
movq %rbx, %rdi
callq 0x51ce
jmp 0x5e0c
movq %rbx, %rdi
callq 0x51de
testq %rax, %rax
jne 0x5e12
movq 0x38(%rbx), %rsi
leaq 0x316d(%rip), %rdx      # 0x8f71
movq %rbx, %rdi
callq 0x5000
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x311d(%rip), %rdi      # 0x8f41
leaq 0x2fc8(%rip), %rsi      # 0x8df3
leaq 0x311b(%rip), %rcx      # 0x8f4d
movl $0x233, %edx            # imm = 0x233
callq 0x2120
// File: /workspace/github_c_makefile_star2_O1/ieyasu[P]funit/parse_test_file.c
// Function: parse_support
static struct Code *parse_support(struct ParseState *ps, const char *kind)
{
    struct Code *code = NULL;

    if (expect_eol(ps))
        goto err;

    code = parse_fortran(ps, NULL);
    if (!code)
        goto err;

    if (parse_end_sequence(ps, kind, NULL, 0))
        goto err;

    return code;
 err:
    if (code)
        free_code(code);
    return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
callq 0x5dbf
xorl %r12d, %r12d
testl %eax, %eax
je 0x5e74
testq %r12, %r12
je 0x5e63
movq %r12, %rdi
callq 0x5cf2
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %r15, %rdi
xorl %esi, %esi
callq 0x5e9e
testq %rax, %rax
je 0x5e56
movq %rax, %rbx
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x658f
movq %rbx, %r12
testl %eax, %eax
jne 0x5e56
jmp 0x5e65
// File: /workspace/github_c_makefile_star2_O1/ieyasu[P]funit/parse_test_file.c
// Function: name_end_finder
static void name_end_finder(struct ParseState *ps)
{
    while (ps->next_pos < ps->next_line_pos) {
        switch (*ps->next_pos) {
        case '!':
        case '\r':
        case '\n':
            return;
        default:
            ps->next_pos++;
            break;
        }
    }
}

// Assembly:
movq 0x30(%rdi), %rax
movq 0x40(%rdi), %rcx
cmpq %rax, %rcx
jae 0x6799
movabsq $0x200002400, %rdx      # imm = 0x200002400
movzbl (%rcx), %esi
cmpq $0x21, %rsi
ja 0x678d
btq %rsi, %rdx
jb 0x6799
incq %rcx
movq %rcx, 0x40(%rdi)
cmpq %rax, %rcx
jne 0x677e
retq
// File: /workspace/github_c_makefile_star2_O1/ieyasu[P]funit/parse_test_file.c
// Function: quoted_string_end_finder
static void quoted_string_end_finder(struct ParseState *ps)
{
    if (*ps->next_pos != '"')
        return;
    ps->next_pos++;
    while (ps->next_pos < ps->next_line_pos) {
        switch (*ps->next_pos) {
        case '"':
            ps->next_pos++;
            return;
        case '!':
        case '\r':
        case '\n':
            return;
        default:
            ps->next_pos++;
            break;
        }
    }
}

// Assembly:
movq 0x40(%rdi), %rax
cmpb $0x22, (%rax)
jne 0x67d8
movq 0x30(%rdi), %rcx
incq %rax
movq %rax, 0x40(%rdi)
cmpq %rcx, %rax
jae 0x67d8
movzbl (%rax), %edx
incq %rax
cmpl $0x20, %edx
jg 0x67ca
cmpl $0xa, %edx
je 0x67d8
cmpl $0xd, %edx
jne 0x67aa
jmp 0x67d8
cmpl $0x21, %edx
je 0x67d8
cmpl $0x22, %edx
jne 0x67aa
movq %rax, 0x40(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/ieyasu[P]funit/parse_test_file.c
// Function: strncasestr
static char *strncasestr(char *haystack, size_t haystack_len,
                         const char *needle, size_t needle_len)
{
    size_t i, j;

    assert(needle_len > 0);
#ifndef NDEBUG
    for (i = 0; i < needle_len; i++)
        assert(needle[i] == tolower(needle[i]));
#endif

    i = j = 0;
    while (i < haystack_len) {
        if (tolower(haystack[i]) == needle[j]) {
            j++;
            if (j == needle_len) // needle found
                return haystack + i - needle_len + 1;
        } else {
            j = 0;
        }
        i++;
    }
    return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
testq %rcx, %rcx
je 0x680e
callq 0x2290
movq (%rax), %rax
xorl %ecx, %ecx
movsbq (%r15,%rcx), %rdx
cmpl %edx, (%rax,%rdx,4)
jne 0x6861
incq %rcx
cmpq %rcx, %rbx
jne 0x67fc
testq %r12, %r12
je 0x6847
callq 0x2290
movq (%rax), %rdx
xorl %eax, %eax
xorl %ecx, %ecx
xorl %esi, %esi
movsbq (%r14,%rcx), %rdi
movsbl (%r15,%rsi), %r8d
cmpl %r8d, (%rdx,%rdi,4)
jne 0x683b
incq %rsi
cmpq %rbx, %rsi
jne 0x683d
jmp 0x684b
xorl %esi, %esi
incq %rcx
cmpq %rcx, %r12
jne 0x6821
jmp 0x6855
xorl %eax, %eax
jmp 0x6855
subq %rbx, %r14
leaq (%r14,%rcx), %rax
incq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x28bb(%rip), %rdi      # 0x9123
leaq 0x2584(%rip), %rsi      # 0x8df3
leaq 0x2875(%rip), %rcx      # 0x90eb
movl $0xc4, %edx
callq 0x2120
// File: /workspace/github_c_makefile_star2_O1/ieyasu[P]funit/parse_test_file.c
// Function: skip_line_continuation
static char *skip_line_continuation(struct ParseState *ps, int in_string)
{
    assert(*ps->next_pos == '&');
    ps->next_pos++;

    // expect ' ' or '\t' only until next_line_pos
    skip_next_ws(ps);
    if (ps->next_pos < ps->next_line_pos) {
        parse_fail(ps, ps->next_pos, "expected newline after '&'");
        return NULL;
    }
    while (ps->next_pos < ps->file_end) {
        char *save_read_pos = ps->read_pos;
        if (!next_line(ps))
            break;
        ps->read_pos = save_read_pos;
        skip_next_ws(ps);
        switch (*ps->next_pos) {
        case '!': // skip comment lines
            break;
        case '&':
            if (in_string)
                ps->next_pos++; // skip past whitespace truncator
            // FALLTHROUGH
        default:
            return ps->next_pos;
        }
    }
    syntax_error(ps);
    return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x40(%rdi), %rax
cmpb $0x26, (%rax)
jne 0x6b8c
movl %esi, %ebp
movq %rdi, %rbx
incq %rax
movq %rax, 0x40(%rdi)
callq 0x52e9
movq 0x40(%rbx), %rsi
cmpq 0x30(%rbx), %rsi
jae 0x6b13
leaq 0x2774(%rip), %rdx      # 0x927d
movq %rbx, %rdi
callq 0x5000
jmp 0x6b7b
movq 0x40(%rbx), %rax
cmpq 0x20(%rbx), %rax
jae 0x6b73
movq 0x38(%rbx), %r15
movq %rbx, %rdi
callq 0x51de
testq %rax, %rax
je 0x6b61
movq %r15, 0x38(%rbx)
movq %rbx, %rdi
callq 0x52e9
movq 0x40(%rbx), %rax
movzbl (%rax), %ecx
cmpl $0x21, %ecx
je 0x6b68
cmpl $0x26, %ecx
jne 0x6b56
testl %ebp, %ebp
je 0x6b56
incq %rax
movq %rax, 0x40(%rbx)
movq 0x40(%rbx), %r14
movl $0x1, %eax
jmp 0x6b6a
movl $0x3, %eax
jmp 0x6b6a
xorl %eax, %eax
testl %eax, %eax
je 0x6b13
cmpl $0x1, %eax
je 0x6b7e
movq %rbx, %rdi
callq 0x51ce
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x266a(%rip), %rdi      # 0x91fd
leaq 0x2259(%rip), %rsi      # 0x8df3
leaq 0x26a5(%rip), %rcx      # 0x9246
movl $0xd7, %edx
callq 0x2120
nop
// File: /workspace/github_c_makefile_star2_O1/ieyasu[P]funit/util.c
// Function: fu_strndup
char *fu_strndup(const char *str, size_t len)
{
    char *copy = malloc(len + 1);
    strncpy(copy, str, len);
    copy[len] = '\0';
    return copy;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x1(%rsi), %rdi
callq 0x21c0
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x2070
movb $0x0, (%r15,%rbx)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/ieyasu[P]funit/util.c
// Function: fu_file_exists
int fu_file_exists(const char *path)
{
    struct stat sb;

    if (stat(path, &sb)) {
        if (errno != ENOENT) {
            fprintf(stderr, "Error stat()ing %s: %s\n", path, strerror(errno));
        }
        return FALSE;
    }

    if (sb.st_mode & (S_IFREG | S_IFLNK)) {
        return TRUE;
    }
    return FALSE;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq %rdi, %rbx
movq %rsp, %rsi
callq 0x21a0
testl %eax, %eax
je 0x6c69
callq 0x2060
movl (%rax), %edi
xorl %ebp, %ebp
cmpl $0x2, %edi
je 0x6c74
movq 0x53b2(%rip), %rax      # 0xbff8
movq (%rax), %r14
callq 0x2260
leaq 0x272b(%rip), %rsi      # 0x9380
xorl %ebp, %ebp
movq %r14, %rdi
movq %rbx, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x2190
jmp 0x6c74
xorl %ebp, %ebp
testb $-0x60, 0x19(%rsp)
setne %bpl
movl %ebp, %eax
addq $0x90, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ieyasu[P]funit/util.c
// Function: fu_sub_file_ext
char *fu_sub_file_ext(const char *path, const char *oldext, const char *newext)
{
    static char buf[PATH_MAX + 1];

    char *dot = strrchr(path, '.');

    if (dot && !strcmp(dot, oldext)) {
        if (dot - path + strlen(newext) > PATH_MAX) goto too_long;

        strncpy(buf, path, dot - path);
        strcpy(buf + (dot - path), newext);
    } else { // unrecognized or missing extension, just append extension
        if (strlen(path) + strlen(newext) > PATH_MAX) goto too_long;

        strcpy(buf, path);
        strcat(buf, newext);
    }

    return fu_strdup(buf);
 too_long:
    fprintf(stderr, "FUnit: the file name '%s' is too long\n", path);
    abort();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r14
movl $0x2e, %esi
callq 0x2110
testq %rax, %rax
je 0x6cb4
movq %rax, %r15
movq %rax, %rdi
movq %r12, %rsi
callq 0x2180
testl %eax, %eax
je 0x6cf1
movq %r14, %rdi
callq 0x20d0
movq %rax, %r15
movq %rbx, %rdi
callq 0x20d0
addq %r15, %rax
cmpq $0x1000, %rax           # imm = 0x1000
ja 0x6d41
leaq 0x7527(%rip), %r15      # 0xe200
movq %r15, %rdi
movq %r14, %rsi
callq 0x2090
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2230
jmp 0x6d2a
subq %r14, %r15
movq %rbx, %rdi
callq 0x20d0
addq %r15, %rax
cmpq $0x1000, %rax           # imm = 0x1000
ja 0x6d41
leaq 0x74f2(%rip), %r12      # 0xe200
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x2070
addq %r15, %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x2090
leaq 0x74cf(%rip), %rdi      # 0xe200
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x6bdf
movq %r14, %rdi
callq 0x26c3
// File: /workspace/github_c_makefile_star2_O1/ieyasu[P]funit/util.c
// Function: sb_ensure
void sb_ensure(struct StringBuffer *sb, size_t at_least)
{
    if (sb->cap >= sb->len + at_least) return;

    while (sb->cap < sb->len + at_least) sb->cap += sb->cap;

    sb->s = realloc(sb->s, sb->cap);
    if (!sb->s) abort(); // XXX or handle allocation better?
}

// Assembly:
pushq %rbx
movq %rsi, %rax
addq 0x10(%rdi), %rax
cmpq %rax, 0x8(%rdi)
jae 0x6db0
movq %rdi, %rbx
movq 0x8(%rdi), %rsi
cmpq %rax, %rsi
jae 0x6da0
addq %rsi, %rsi
cmpq %rax, %rsi
jb 0x6d94
movq %rsi, 0x8(%rbx)
movq (%rbx), %rdi
callq 0x21e0
movq %rax, (%rbx)
testq %rax, %rax
je 0x6db2
popq %rbx
retq
callq 0x2050
// File: /workspace/github_c_makefile_star2_O1/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_6/exercise_6_01/count_c_keywords.c
// Function: main
int main(void)
{
  int n;
  char word[MAX_WORD_LEN];

  while (get_word(word, MAX_WORD_LEN) != EOF)
  {
    if (isalpha(word[0]))
    {
      if ((n = bin_search(word, keytab, NR_OF_KEYS)) >= 0)
      {
        keytab[n].count++;
      }
    }
  }

  for (size_t i = 0; i < NR_OF_KEYS; ++i)
  {
    if (keytab[i].count)
    {
      printf("%4d %s\n", keytab[i].count, keytab[i].word);
    }
  }

  return EXIT_SUCCESS;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rsp, %rdi
movl $0x64, %esi
callq 0x122d
cmpl $-0x1, %eax
je 0x11e9
callq 0x1070
movq %rax, %rbx
movq %rsp, %r14
leaq 0x2ea7(%rip), %r15      # 0x4050
movq (%rbx), %rax
movsbq (%rsp), %rcx
testb $0x4, 0x1(%rax,%rcx,2)
je 0x11d7
movq %r14, %rdi
movq %r15, %rsi
movl $0x21, %edx
callq 0x1330
testl %eax, %eax
js 0x11d7
movl %eax, %eax
shlq $0x4, %rax
incl 0x8(%rax,%r15)
movq %r14, %rdi
movl $0x64, %esi
callq 0x122d
cmpl $-0x1, %eax
jne 0x11a9
movl $0x8, %r14d
leaq 0x2e5a(%rip), %r15      # 0x4050
leaq 0xecd(%rip), %rbx       # 0x20ca
movl (%r14,%r15), %esi
testl %esi, %esi
je 0x1214
movq -0x8(%r14,%r15), %rdx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1030
addq $0x10, %r14
cmpq $0x218, %r14            # imm = 0x218
jne 0x11fd
xorl %eax, %eax
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_6/exercise_6_01/count_c_keywords.c
// Function: bin_search
int bin_search(char *word, struct key arr[], int arr_len)
{
  int low = 0;
  int high = arr_len - 1;
  int mid;

  while (low <= high)
  {
    mid = (low + high) / 2;

    int cond = strcmp(word, arr[mid].word);
    if (cond < 0)
    {
      high = mid - 1;
    }
    else if (cond > 0)
    {
      low = mid + 1;
    }
    else
    {
      return mid;
    }
  }

  return -1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r15d
movq %rsi, %rbx
movq %rdi, %r14
decl %r15d
xorl %r12d, %r12d
cmpl %r15d, %r12d
jg 0x138e
leal (%r12,%r15), %r13d
shrl %r13d
movq %r13, %rax
shlq $0x4, %rax
movq (%rbx,%rax), %rsi
movq %r14, %rdi
callq 0x1040
testl %eax, %eax
jns 0x1377
decl %r13d
movb $0x1, %al
movl %r13d, %r15d
jmp 0x1388
je 0x1383
incl %r13d
movb $0x1, %al
movl %r13d, %r12d
jmp 0x1388
xorl %eax, %eax
movl %r13d, %ebp
testb %al, %al
jne 0x134a
jmp 0x1393
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ThomasMadappattu[P]Sandmacs/basic.c
// Function: gotoline
int gotoline (int f, int n)
{
  if (n < 1)		       /* if a bogus argument...then leave */
    return (FALSE);

  /* first, we go to the start of the buffer */
  curwp->w_dotp = lforw (curbp->b_linep);
  curwp->w_doto = 0;
  return (forwline (f, n - 1));
}

// Assembly:
testl %esi, %esi
jle 0x2471
pushq %rax
leaq 0xb408(%rip), %rax      # 0xd848
movq (%rax), %rax
movq 0x28(%rax), %rax
movq (%rax), %rax
leaq 0xb407(%rip), %rcx      # 0xd858
movq (%rcx), %rcx
movq %rax, 0x18(%rcx)
movq $0x0, 0x20(%rcx)
decl %esi
callq 0x2474
movl $0x1, %eax
addq $0x8, %rsp
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/ThomasMadappattu[P]Sandmacs/basic.c
// Function: gotobop
int gotobop (int f, int n)
{
  int suc;			/* success of last backchar */

  if (n < 0)			/* the other way.. */
    return (gotoeop (f, -n));

  while (n-- > 0)
    {				/* for each one asked for */
      /* first scan back until we are in a word */
      suc = backchar (FALSE, 1);
      while (!inword () && suc)
	suc = backchar (FALSE, 1);
      curwp->w_doto = 0;	/* and go to the B-O-Line */

      /* and scan back until we hit a <NL><NL> or <NL><TAB> or a <NL><SPACE> */
      while (lback (curwp->w_dotp) != curbp->b_linep)
	if (llength (curwp->w_dotp) != 0 &&
	    lgetc (curwp->w_dotp, curwp->w_doto) != TAB &&
	    lgetc (curwp->w_dotp, curwp->w_doto) != ' ')
	  curwp->w_dotp = lback (curwp->w_dotp);
	else
	  break;

      /* and then forward until we are in a word */
      suc = forwchar (FALSE, 1);
      while (suc && !inword ())
	suc = forwchar (FALSE, 1);
    }
  curwp->w_flag |= WFMOVE;	/* force screen update */
  return (TRUE);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
testl %esi, %esi
js 0x2697
je 0x2687
leaq 0xb261(%rip), %r14      # 0xd858
leaq 0xb24a(%rip), %r15      # 0xd848
xorl %edi, %edi
movl $0x1, %esi
callq 0x2372
movl %eax, %ebp
xorl %eax, %eax
callq 0x7f04
testl %eax, %eax
jne 0x261b
testl %ebp, %ebp
jne 0x25fe
movq (%r14), %rax
movq $0x0, 0x20(%rax)
movq (%r15), %rcx
movq 0x28(%rcx), %rcx
movq 0x18(%rax), %rdx
movq 0x8(%rdx), %rdi
cmpq %rcx, %rdi
je 0x265e
cmpl $0x0, 0x14(%rdx)
je 0x265e
movzbl 0x18(%rdx), %edx
cmpl $0x9, %edx
je 0x265e
cmpl $0x20, %edx
je 0x265e
movq %rdi, %rsi
movq %rdi, 0x18(%rax)
movq 0x8(%rdi), %rdi
movq %rsi, %rdx
jmp 0x2635
xorl %edi, %edi
movl $0x1, %esi
callq 0x23d0
testl %eax, %eax
je 0x2679
xorl %eax, %eax
callq 0x7f04
testl %eax, %eax
je 0x265e
leal -0x1(%rbx), %eax
cmpl $0x1, %ebx
movl %eax, %ebx
jg 0x25fe
leaq 0xb1ca(%rip), %rax      # 0xd858
movq (%rax), %rax
orb $0x2, 0x3b(%rax)
jmp 0x26a0
negl %ebx
movl %ebx, %esi
callq 0x26b0
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ThomasMadappattu[P]Sandmacs/basic.c
// Function: gotoeop
int gotoeop (int f, int n)
{
  int suc;			/* success of last backchar */

  if (n < 0)			/* the other way.. */
    return (gotobop (f, -n));

  while (n-- > 0)
    {				/* for each one asked for */
      /* first scan forward until we are in a word */
      suc = forwchar (FALSE, 1);
      while (!inword () && suc)
	suc = forwchar (FALSE, 1);
      curwp->w_doto = 0;	/* and go to the B-O-Line */
      if (suc)			/* of next line if not at EOF */
	curwp->w_dotp = lforw (curwp->w_dotp);

      /* and scan forword until hit a <NL><NL> or <NL><TAB> or a <NL><SPACE> */
      while (curwp->w_dotp != curbp->b_linep)
	{
	  if (llength (curwp->w_dotp) != 0 &&
	      lgetc (curwp->w_dotp, curwp->w_doto) != TAB &&
	      lgetc (curwp->w_dotp, curwp->w_doto) != ' ')
	    curwp->w_dotp = lforw (curwp->w_dotp);
	  else
	    break;
	}

      /* and then backward until we are in a word */
      suc = backchar (FALSE, 1);
      while (suc && !inword ())
	{
	  suc = backchar (FALSE, 1);
	}
      curwp->w_doto = llength (curwp->w_dotp); /* and to the EOL */
    }
  curwp->w_flag |= WFMOVE;	/* force screen update */
  return (TRUE);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
testl %esi, %esi
js 0x27ab
je 0x279b
leaq 0xb18a(%rip), %r14      # 0xd858
leaq 0xb173(%rip), %r15      # 0xd848
xorl %edi, %edi
movl $0x1, %esi
callq 0x23d0
movl %eax, %ebp
xorl %eax, %eax
callq 0x7f04
testl %eax, %eax
sete %al
testl %ebp, %ebp
setne %cl
andb %cl, %al
cmpb $0x1, %al
jne 0x271c
xorl %edi, %edi
movl $0x1, %esi
callq 0x23d0
movl %eax, %ebp
xorl %eax, %eax
callq 0x7f04
testl %ebp, %ebp
setne %cl
testl %eax, %eax
jne 0x271c
testl %ebp, %ebp
jne 0x26fa
movq (%r14), %rax
movq $0x0, 0x20(%rax)
testb %cl, %cl
je 0x2736
movq 0x18(%rax), %rcx
movq (%rcx), %rcx
movq %rcx, 0x18(%rax)
movq (%r15), %rcx
movq 0x28(%rcx), %rcx
movq 0x18(%rax), %rdx
cmpq %rcx, %rdx
je 0x2763
cmpl $0x0, 0x14(%rdx)
je 0x2763
movzbl 0x18(%rdx), %esi
cmpl $0x9, %esi
je 0x2763
cmpl $0x20, %esi
je 0x2763
movq (%rdx), %rdx
movq %rdx, 0x18(%rax)
jmp 0x2741
xorl %edi, %edi
movl $0x1, %esi
callq 0x2372
testl %eax, %eax
je 0x277e
xorl %eax, %eax
callq 0x7f04
testl %eax, %eax
je 0x2763
leal -0x1(%rbx), %eax
movq (%r14), %rcx
movq 0x18(%rcx), %rdx
movslq 0x14(%rdx), %rdx
movq %rdx, 0x20(%rcx)
cmpl $0x1, %ebx
movl %eax, %ebx
jg 0x26d5
leaq 0xb0b6(%rip), %rax      # 0xd858
movq (%rax), %rax
orb $0x2, 0x3b(%rax)
jmp 0x27b4
negl %ebx
movl %ebx, %esi
callq 0x25d9
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ThomasMadappattu[P]Sandmacs/buffer.c
// Function: usebuffer
int usebuffer (int f, int n)
{
  BUFFER *bp;
  char bufn[NBUFN];
  int s;

  if ((s = mlreply ("Use buffer: ", bufn, NBUFN)) != TRUE)
    return (s);
  if ((bp = bfind (bufn, TRUE, 0)) == NULL)
    return (FALSE);
  return (swbuffer (bp));
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
leaq 0x6609(%rip), %rdi      # 0x900f
movq %rsp, %rsi
movl $0x10, %edx
callq 0x4464
movl %eax, %ebx
cmpl $0x1, %eax
jne 0x2a3d
movq %rsp, %rdi
xorl %ebx, %ebx
movl $0x1, %esi
xorl %edx, %edx
callq 0x2a45
testq %rax, %rax
je 0x2a3d
movq %rax, %rdi
callq 0x28fc
movl $0x1, %ebx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/ThomasMadappattu[P]Sandmacs/buffer.c
// Function: killbuffer
int killbuffer (int f, int n)
{
  BUFFER *bp;
  char bufn[NBUFN];
  int s;

  if ((s = mlreply ("Kill buffer: ", bufn, NBUFN)) != TRUE)
    return (s);
  if ((bp = bfind (bufn, FALSE, 0)) == NULL) /* Easy if unknown */
    return (TRUE);
  return (zotbuf (bp));
}

// Assembly:
subq $0x18, %rsp
leaq 0x6481(%rip), %rdi      # 0x901c
movq %rsp, %rsi
movl $0x10, %edx
callq 0x4464
cmpl $0x1, %eax
jne 0x2bcd
movq %rsp, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2a45
testq %rax, %rax
je 0x2bc8
movq %rax, %rdi
callq 0x2bd2
jmp 0x2bcd
movl $0x1, %eax
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/ThomasMadappattu[P]Sandmacs/buffer.c
// Function: zotbuf
int zotbuf (BUFFER *bp)
{
  BUFFER *bp1, *bp2;
  int s;

  if (bp->b_nwnd != 0)
    {				/* Error if on screen */
      mlwrite ("Buffer is being displayed");
      return (FALSE);
    }
  if ((s = bclear (bp)) != TRUE) /* Blow text away */
    return (s);
  free (bp->b_linep);		/* Release header line */
  bp1 = 0;			/* Find the header */
  bp2 = bheadp;
  while (bp2 != bp)
    {
      bp1 = bp2;
      bp2 = bp2->b_bufp;
    }
  bp2 = bp2->b_bufp;		/* Next one in chain */
  if (bp1 == NULL)		/* Unlink it */
    bheadp = bp2;
  else
    bp1->b_bufp = bp2;
  free (bp);			/* Release buffer block */
  return (TRUE);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
cmpb $0x0, 0x31(%rdi)
je 0x2bed
leaq 0x6448(%rip), %rdi      # 0x902a
xorl %ebp, %ebp
xorl %eax, %eax
callq 0x446e
jmp 0x2c3b
movq %rdi, %rbx
callq 0x2c44
movl %eax, %ebp
cmpl $0x1, %eax
jne 0x2c3b
movq 0x28(%rbx), %rdi
callq 0x2040
leaq 0xac74(%rip), %rdx      # 0xd880
xorl %ecx, %ecx
movq %rcx, %rax
movq (%rdx), %rcx
movq %rcx, %rdx
cmpq %rbx, %rcx
jne 0x2c0e
movq (%rcx), %rcx
testq %rax, %rax
jne 0x2c2b
leaq 0xac55(%rip), %rax      # 0xd880
movq %rcx, (%rax)
movq %rbx, %rdi
callq 0x2040
movl $0x1, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ThomasMadappattu[P]Sandmacs/buffer.c
// Function: namebuffer
int namebuffer (int f, int n)
{
  BUFFER *bp;			/* pointer to scan through all buffers */
  char bufn[NBUFN];		/* buffer to hold buffer name */

  /* prompt for and get the new buffer name */
 ask:
  if (mlreply ("Change buffer name to: ", bufn, NBUFN) != TRUE)
    return (FALSE);

  /* and check for duplicates */
  bp = bheadp;
  while (bp != 0)
    {
      if (bp != curbp)
	{
	  /* if the names the same */
	  if (strcmp (bufn, bp->b_bname) == 0)
	    goto ask;		/* try again */
	}
      bp = bp->b_bufp;		/* onward */
    }

  strncpy (curbp->b_bname, bufn, NBUFN); /* copy buffer name to structure */
  curwp->w_flag |= WFMODE;		 /* make mode line replot */
  mlerase ();
  return (TRUE);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
leaq 0x639c(%rip), %rdi      # 0x9044
movq %rsp, %rsi
movl $0x10, %edx
callq 0x4464
xorl %ebx, %ebx
cmpl $0x1, %eax
jne 0x2d4c
leaq 0xabb9(%rip), %r13      # 0xd880
leaq 0xab7a(%rip), %r12      # 0xd848
movq %rsp, %r14
movq (%r13), %rbp
testq %rbp, %rbp
je 0x2d1c
movq (%r12), %r15
cmpq %r15, %rbp
je 0x2cf6
leaq 0x83(%rbp), %rsi
movq %r14, %rdi
callq 0x2130
testl %eax, %eax
je 0x2d01
movq (%rbp), %rbp
testq %rbp, %rbp
jne 0x2cde
jmp 0x2d1c
leaq 0x633c(%rip), %rdi      # 0x9044
movq %r14, %rsi
movl $0x10, %edx
callq 0x4464
cmpl $0x1, %eax
je 0x2cd1
jmp 0x2d4c
movl $0x83, %edi
addq (%r12), %rdi
movq %rsp, %rsi
movl $0x10, %edx
callq 0x2060
leaq 0xab1f(%rip), %rax      # 0xd858
movq (%rax), %rax
orb $0x10, 0x3b(%rax)
xorl %eax, %eax
callq 0x3130
movl $0x1, %ebx
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ThomasMadappattu[P]Sandmacs/display.c
// Function: mlwrite
void mlwrite (char *fmt, int arg)
{
  int c;
  char *ap;

  if (eolexist == FALSE)
    {
      mlerase ();
      (*term.t_flush) ();
    }
  movecursor (term.t_nrow, 0);
  ap = (char *) &arg;
  while ((c = *fmt++) != 0)
    {
      if (c != '%')
	{
	  (*term.t_putchar) (c);
	  ++ttcol;
	}
      else
	{
	  c = *fmt++;
	  switch (c)
	    {
	    case 'd':
	      mlputi (*(int *) ap, 10);
	      ap += sizeof (int);
	      break;

	    case 'o':
	      mlputi (*(int *) ap, 8);
	      ap += sizeof (int);
	      break;

	    case 'x':
	      mlputi (*(int *) ap, 16);
	      ap += sizeof (int);
	      break;

	    case 'D':
	      mlputli (*(long *) ap, 10);
	      ap += sizeof (long);
	      break;

	    case 's':
	      mlputs (*(char **) &ap);
	      ap += sizeof (char *);
	      break;

	    case 'c':
	      (*term.t_putchar) (*ap);
	      ++ttcol;
	      ap += sizeof (char *);
	      break;

	    default:
	      (*term.t_putchar) (c);
	      ++ttcol;
	    }
	}
    }
  if (eolexist == TRUE)
    (*term.t_eeol) ();
  (*term.t_flush) ();
  mpresf = TRUE;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl %esi, 0xc(%rsp)
leaq 0x8e9b(%rip), %r14      # 0xd324
cmpl $0x0, (%r14)
jne 0x44a0
callq 0x3130
leaq 0x92f5(%rip), %rcx      # 0xd790
xorl %eax, %eax
callq *0x30(%rcx)
leaq 0x92e9(%rip), %r15      # 0xd790
movl (%r15), %edi
cmpl %edi, 0x8c60(%rip)      # 0xd110
jne 0x44bb
cmpl $0x0, 0x8c5b(%rip)      # 0xd114
je 0x44d3
movl %edi, 0x8c4f(%rip)      # 0xd110
movl $0x0, 0x8c49(%rip)      # 0xd114
xorl %esi, %esi
xorl %eax, %eax
callq *0x38(%r15)
leaq 0xc(%rsp), %r12
movzbl (%rbx), %eax
cmpl $0x25, %eax
je 0x44fc
testl %eax, %eax
je 0x45a7
incq %rbx
movsbl %al, %edi
xorl %eax, %eax
callq *0x28(%r15)
incl 0x8c1a(%rip)            # 0xd114
jmp 0x44d8
movzbl 0x1(%rbx), %eax
addq $0x2, %rbx
cmpl $0x6e, %eax
jg 0x4523
cmpl $0x44, %eax
je 0x453d
cmpl $0x63, %eax
je 0x4564
cmpl $0x64, %eax
jne 0x44eb
movl (%r12), %edi
movl $0xa, %esi
jmp 0x4556
cmpl $0x6f, %eax
je 0x454d
cmpl $0x73, %eax
je 0x4577
cmpl $0x78, %eax
jne 0x44eb
movl (%r12), %edi
movl $0x10, %esi
jmp 0x4556
movq (%r12), %rdi
movl $0xa, %esi
callq 0x462c
jmp 0x459e
movl (%r12), %edi
movl $0x8, %esi
callq 0x45d4
addq $0x4, %r12
jmp 0x44d8
movsbl (%r12), %edi
xorl %eax, %eax
callq *0x28(%r15)
incl 0x8b9f(%rip)            # 0xd114
jmp 0x459e
movb (%r12), %al
testb %al, %al
je 0x459e
leaq 0x1(%r12), %r13
movsbl %al, %edi
xorl %eax, %eax
callq *0x28(%r15)
incl 0x8b81(%rip)            # 0xd114
movb (%r13), %al
incq %r13
testb %al, %al
jne 0x4584
addq $0x8, %r12
jmp 0x44d8
cmpl $0x1, (%r14)
jne 0x45b3
xorl %eax, %eax
callq *0x40(%r15)
xorl %eax, %eax
callq *0x30(%r15)
leaq 0x9284(%rip), %rax      # 0xd844
movl $0x1, (%rax)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/ThomasMadappattu[P]Sandmacs/display.c
// Function: mlputi
void mlputi (int i, int r)
{
  int q;
  static char hexdigits[] = "0123456789abcdef";

  if (i < 0)
    {
      i = -i;
      (*term.t_putchar) ('-');
    }
  q = i / r;

  if (q != 0)
    mlputi (q, r);

  (*term.t_putchar) (hexdigits[i % r]);
  ++ttcol;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebx
movl %edi, %ebp
testl %edi, %edi
jns 0x45f2
negl %ebp
leaq 0x91a8(%rip), %rcx      # 0xd790
movl $0x2d, %edi
xorl %eax, %eax
callq *0x28(%rcx)
movl %ebp, %eax
cltd
idivl %ebx
movl %edx, %ebp
testl %eax, %eax
je 0x4606
movl %eax, %edi
movl %ebx, %esi
callq 0x45d4
leaq 0x9183(%rip), %rcx      # 0xd790
movl %ebp, %eax
leaq 0x4aba(%rip), %rdx      # 0x90d0
movsbl (%rax,%rdx), %edi
xorl %eax, %eax
callq *0x28(%rcx)
incl 0x8aef(%rip)            # 0xd114
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ThomasMadappattu[P]Sandmacs/display.c
// Function: mlputli
void mlputli (long l, int r)
{
  long q;

  if (l < 0)
    {
      l = -l;
      (*term.t_putchar) ('-');
    }
  q = l / r;

  if (q != 0)
    mlputli (q, r);

  (*term.t_putchar) ((int) (l % r) + '0');
  ++ttcol;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
testq %rdi, %rdi
jns 0x464e
negq %r14
leaq 0x914c(%rip), %rcx      # 0xd790
movl $0x2d, %edi
xorl %eax, %eax
callq *0x28(%rcx)
movslq %ebx, %rcx
movq %r14, %rax
cqto
idivq %rcx
movq %rdx, %r14
testq %rax, %rax
je 0x466b
movq %rax, %rdi
movl %ebx, %esi
callq 0x462c
leaq 0x911e(%rip), %rcx      # 0xd790
addl $0x30, %r14d
movl %r14d, %edi
xorl %eax, %eax
callq *0x28(%rcx)
incl 0x8a90(%rip)            # 0xd114
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/ThomasMadappattu[P]Sandmacs/file.c
// Function: filename
int filename (int f, int n)
{
  WINDOW *wp;
  char fname[NFILEN];
  int s;

  if ((s = mlreply ("Name: ", fname, NFILEN)) == ABORT)
    return (s);
  if (s == FALSE)
    strncpy (curbp->b_fname, "", 1);
  else
    strncpy (curbp->b_fname, fname, NFILEN);
  wp = wheadp;			/* update mode lines */
  while (wp != NULL)
    {
      if (wp->w_bufp == curbp)
	wp->w_flag |= WFMODE;
      wp = wp->w_wndp;
    }
  return (TRUE);
}

// Assembly:
subq $0x58, %rsp
leaq 0x438d(%rip), %rdi      # 0x91f8
movq %rsp, %rsi
movl $0x50, %edx
callq 0x4464
cmpl $0x2, %eax
je 0x4edc
testl %eax, %eax
jne 0x4e91
leaq 0x89c0(%rip), %rax      # 0xd848
movq (%rax), %rax
movb $0x0, 0x33(%rax)
jmp 0x4eac
leaq 0x89b0(%rip), %rax      # 0xd848
movq (%rax), %rdi
addq $0x33, %rdi
movq %rsp, %rsi
movl $0x50, %edx
callq 0x2060
leaq 0x89bd(%rip), %rax      # 0xd870
movq (%rax), %rcx
movl $0x1, %eax
testq %rcx, %rcx
je 0x4edc
leaq 0x8981(%rip), %rdx      # 0xd848
movq (%rdx), %rdx
cmpq %rdx, 0x8(%rcx)
jne 0x4ed4
orb $0x10, 0x3b(%rcx)
movq (%rcx), %rcx
testq %rcx, %rcx
jne 0x4eca
addq $0x58, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/ThomasMadappattu[P]Sandmacs/line.c
// Function: kinsert
int kinsert (int c)
{
  char *nbufp;

  if (kused == ksize)
    {
      if (ksize == 0)	       /* first time through? */
	nbufp = malloc (KBLOCK); /* alloc the first block */
      else		       /* or re allocate a bigger block */
	nbufp = realloc (kbufp, ksize + KBLOCK);
      if (nbufp == NULL)	       /* abort if it fails */
	return (FALSE);
      kbufp = nbufp;	       /* point our global at it */
      ksize += KBLOCK;	       /* and adjust the size */
    }
  kbufp[kused++] = c;
  return (TRUE);
}

// Assembly:
pushq %rbx
movl %edi, %ebx
movq 0x81df(%rip), %rsi      # 0xd830
cmpq %rsi, 0x81d0(%rip)      # 0xd828
jne 0x5695
testq %rsi, %rsi
je 0x5674
movq 0x81ba(%rip), %rdi      # 0xd820
addq $0x400, %rsi            # imm = 0x400
callq 0x2180
jmp 0x567e
movl $0x400, %edi            # imm = 0x400
callq 0x2150
testq %rax, %rax
je 0x56b8
movq %rax, 0x8196(%rip)      # 0xd820
addq $0x400, 0x819b(%rip) # imm = 0x400
movq 0x8184(%rip), %rax      # 0xd820
movq 0x8185(%rip), %rcx      # 0xd828
leaq 0x1(%rcx), %rdx
movq %rdx, 0x817a(%rip)      # 0xd828
movb %bl, (%rax,%rcx)
movl $0x1, %eax
popq %rbx
retq
xorl %eax, %eax
jmp 0x56b6
// File: /workspace/github_c_makefile_star2_O1/ThomasMadappattu[P]Sandmacs/main.c
// Function: execute
int execute (int c, int f, int n)
{
  KEYTAB *ktp;
  int status;

  ktp = &keytab[0];	       /* Look in key table */
  while (ktp->k_fp != NULL)
    {
      if (ktp->k_code == c)
	{
	  thisflag = 0;
	  status = (*ktp->k_fp) (f, n);
	  lastflag = thisflag;
	  return (status);
	}
      ++ktp;
    }

  if ((c >= 0x20 && c <= 0x7E)	/* Self inserting */
      || (c >= 0xA0 && c <= 0xFE))
    {
      if (n <= 0)
	{			/* Fenceposts */
	  lastflag = 0;
	  return (n < 0 ? FALSE : TRUE);
	}
      thisflag = 0;		/* For the future */

      status = linsert (n, c);

      lastflag = thisflag;
      return (status);
    }
  mlwrite ("\007[Key not bound]"); /* complain */
  lastflag = 0;			/* Fake last flags */
  return (FALSE);
}

// Assembly:
pushq %rbx
movl %edi, %eax
movq 0x75cc(%rip), %rcx      # 0xd338
testq %rcx, %rcx
je 0x5dad
movswl 0x75b8(%rip), %edi      # 0xd330
cmpl %eax, %edi
je 0x5d99
leaq 0x75c5(%rip), %rdi      # 0xd348
movq (%rdi), %rcx
testq %rcx, %rcx
je 0x5dad
movswl -0x8(%rdi), %r8d
addq $0x10, %rdi
cmpl %eax, %r8d
jne 0x5d83
movl $0x0, 0x7ad5(%rip)      # 0xd878
movl %esi, %edi
movl %edx, %esi
xorl %eax, %eax
callq *%rcx
jmp 0x5dd4
movl %eax, %ecx
andl $0xffffff7f, %ecx       # imm = 0xFFFFFF7F
addl $-0x20, %ecx
cmpl $0x5e, %ecx
ja 0x5de2
testl %edx, %edx
jle 0x5dfe
movl $0x0, 0x7aad(%rip)      # 0xd878
movl %edx, %edi
movl %eax, %esi
callq 0x51ad
movl 0x7a9e(%rip), %ecx      # 0xd878
movl %ecx, 0x7a70(%rip)      # 0xd850
jmp 0x5e10
leaq 0x359b(%rip), %rdi      # 0x9384
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x446e
movl $0x0, 0x7a54(%rip)      # 0xd850
jmp 0x5e0e
movl $0x0, 0x7a48(%rip)      # 0xd850
sete %al
movzbl %al, %ebx
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/ThomasMadappattu[P]Sandmacs/main.c
// Function: quickexit
int quickexit (int f, int n)
{
  BUFFER *bp;			/* scanning pointer to buffers */

  bp = bheadp;
  while (bp != NULL)
    {
      if ((bp->b_flag & BFCHG) != 0 /* Changed */
	  && (bp->b_flag & BFTEMP) == 0)
	{			/* Real */
	  curbp = bp;		/* make that buffer current */
	  mlwrite ("[Saving %s]", (int*)bp->b_fname);
	  filesave (f, n);
	}
      bp = bp->b_bufp;		/* on to the next buffer */
    }
  return quit (f, n);		/* conditionally quit */
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
movq 0x79ef(%rip), %r15      # 0xd880
testq %r15, %r15
je 0x5ed1
movl %esi, %ebp
leaq 0x34f6(%rip), %r14      # 0x9395
movb 0x32(%r15), %al
andb $0x3, %al
cmpb $0x2, %al
jne 0x5ec9
movq %r15, 0x7998(%rip)      # 0xd848
leaq 0x33(%r15), %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0x446e
movl %ebx, %edi
movl %ebp, %esi
xorl %eax, %eax
callq 0x4df6
movq (%r15), %r15
testq %r15, %r15
jne 0x5e9f
movl %ebx, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x5ee2