LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/ieyasu[P]funit/generate_code.c
// Function: generate_test
static int generate_test(struct TestCase *test, int *test_i, double tolerance)
{
    if (test->next)
        generate_test(test->next, test_i, tolerance);

    *test_i += 1;
    fprintf(fout, "  subroutine funit_test%i(funit_passed_, funit_message_)\n",
            *test_i);
    fputs("    implicit none\n\n", fout);
    fputs("    logical, intent(out) :: funit_passed_\n", fout);
    fputs("    character(*), intent(out) :: funit_message_\n", fout);
    if (test->need_array_iterator)
        fputs("    integer :: funit_i_\n", fout);
    fputs("\n", fout);

    if (test->code) {
        if (generate_code(test->code, tolerance))
            return -1;
    }

    fputs("\n    funit_passed_ = .true.\n", fout);
    fprintf(fout, "  end subroutine funit_test%i\n\n", *test_i);

    return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
testq %rdi, %rdi
movsd %xmm0, 0x8(%rsp)
je 0x4928
movq %rbx, %rsi
movsd 0x8(%rsp), %xmm0
callq 0x48fe
movl (%rbx), %edx
incl %edx
movl %edx, (%rbx)
movq 0x98bb(%rip), %rdi      # 0xe1f0
leaq 0x3fe7(%rip), %rsi      # 0x8923
xorl %eax, %eax
callq 0x2190
movq 0x98a6(%rip), %rsi      # 0xe1f0
leaq 0x400c(%rip), %rdi      # 0x895d
callq 0x2130
movq 0x9893(%rip), %rsi      # 0xe1f0
leaq 0x400d(%rip), %rdi      # 0x8971
callq 0x2130
movq 0x9880(%rip), %rsi      # 0xe1f0
leaq 0x4025(%rip), %rdi      # 0x899c
callq 0x2130
cmpl $0x0, 0x18(%r14)
je 0x4996
movq 0x9866(%rip), %rsi      # 0xe1f0
leaq 0x403c(%rip), %rdi      # 0x89cd
callq 0x2130
movq 0x9853(%rip), %rsi      # 0xe1f0
leaq 0x417c(%rip), %rdi      # 0x8b20
callq 0x2130
movq 0x20(%r14), %rdi
testq %rdi, %rdi
je 0x49c6
movsd 0x8(%rsp), %xmm0
callq 0x3d87
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testl %eax, %eax
jne 0x49f2
movq 0x9823(%rip), %rsi      # 0xe1f0
leaq 0x4012(%rip), %rdi      # 0x89e6
callq 0x2130
movq 0x9810(%rip), %rdi      # 0xe1f0
movl (%rbx), %edx
leaq 0x401a(%rip), %rsi      # 0x8a03
xorl %ebp, %ebp
xorl %eax, %eax
callq 0x2190
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ieyasu[P]funit/generate_code.c
// Function: check_assert_args2
static int check_assert_args2(const char *macro_name, struct Code *macro,
                              struct Code *args, int min_args, int max_args)
{
    long lineno;
    int n;

    assert(min_args > 0 && min_args <= max_args);

    if (!args) {
        fprintf(stderr, "near %s:%li: no arguments to %s()\n",
                test_set_file_name, macro->lineno, macro_name);
        return -1;
    }
    n = 0;
    while (args) {
        lineno = args->lineno;
        n++;
        if (n > max_args)
            goto badargs;
        args = args->next;
    }
    if (n < min_args)
        goto badargs;
    return n;
 badargs:
    if (min_args == max_args) {
        fprintf(stderr, "near %s:%li: expected %i argument%s to %s()\n",
                test_set_file_name, lineno, max_args,
                (max_args > 1) ? "s" : "", macro_name);
    } else {
        assert(min_args + 1 == max_args);
        fprintf(stderr, "near %s:%li: expected %i or %i arguments to %s()\n",
                test_set_file_name, lineno, min_args, max_args, macro_name);
    }
    return -1;
}

// Assembly:
pushq %rax
movl %r8d, %r9d
cmpl %r8d, %ecx
jg 0x4cf8
movq %rdi, %r10
testq %rdx, %rdx
je 0x4c9a
movl %ecx, %r8d
xorl %eax, %eax
testl %r9d, %r9d
movl $0x0, %esi
cmovgl %r9d, %esi
movq %rdx, %rcx
cmpl %eax, %esi
je 0x4c56
incl %eax
movq (%rcx), %rdx
testq %rdx, %rdx
jne 0x4c3e
cmpl %r8d, %eax
jl 0x4c56
popq %rcx
retq
movq 0x10(%rcx), %rcx
cmpl %r9d, %r8d
jne 0x4cc2
movq 0x7392(%rip), %rax      # 0xbff8
movq (%rax), %rdi
movq 0x9588(%rip), %rdx      # 0xe1f8
cmpl $0x2, %r8d
leaq 0x42df(%rip), %rax      # 0x8f5a
leaq 0x3e9f(%rip), %r9       # 0x8b21
cmovgeq %rax, %r9
movq %r10, (%rsp)
leaq 0x362d(%rip), %rsi      # 0x82be
xorl %eax, %eax
callq 0x2190
jmp 0x4cee
movq 0x7357(%rip), %rax      # 0xbff8
movq (%rax), %rdi
movq 0x954d(%rip), %rdx      # 0xe1f8
movq 0x10(%rsi), %rcx
leaq 0x35e5(%rip), %rsi      # 0x829b
movq %r10, %r8
xorl %eax, %eax
callq 0x2190
jmp 0x4cee
leal 0x1(%r8), %eax
cmpl %r9d, %eax
jne 0x4d17
movq 0x7326(%rip), %rax      # 0xbff8
movq (%rax), %rdi
movq 0x951c(%rip), %rdx      # 0xe1f8
movq %r10, (%rsp)
leaq 0x361d(%rip), %rsi      # 0x8304
xorl %eax, %eax
callq 0x2190
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x4c54
leaq 0x352a(%rip), %rdi      # 0x8229
leaq 0x3495(%rip), %rsi      # 0x819b
leaq 0x3541(%rip), %rcx      # 0x824e
movl $0x12, %edx
callq 0x2120
leaq 0x35cd(%rip), %rdi      # 0x82eb
leaq 0x3476(%rip), %rsi      # 0x819b
leaq 0x3522(%rip), %rcx      # 0x824e
movl $0x2a, %edx
callq 0x2120
// File: /workspace/github_c_makefile_star2_O3/ieyasu[P]funit/generate_code.c
// Function: print_array_size_check
static void print_array_size_check(struct Code *a, struct Code *b)
{
    fputs("    if (size(", fout);
    PRINT_CODE(a);
    fputs(") /= size(", fout);
    PRINT_CODE(b);
    fputs(")) then\n", fout);
    fputs("      write(funit_message_,*) \"'",fout);
    print_macro_arg(a);
    fputs("' and '", fout);
    print_macro_arg(b);
    fputs("' &\n        &are not the same length:\", size(", fout);
    PRINT_CODE(a);
    fputs("), \"vs.\", size(", fout);
    PRINT_CODE(b);
    fputs(")\n", fout);
    fputs("      funit_passed_ = .false.\n", fout);
    fputs("      return\n", fout);
    fputs("    end if\n", fout);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x94a9(%rip), %rsi      # 0xe1f0
leaq 0x3990(%rip), %rdi      # 0x86de
callq 0x2130
movq 0x18(%r14), %rdi
movq 0x20(%r14), %rsi
movq 0x948e(%rip), %rcx      # 0xe1f0
movl $0x1, %edx
callq 0x2250
movq 0x947d(%rip), %rsi      # 0xe1f0
leaq 0x3972(%rip), %rdi      # 0x86ec
callq 0x2130
movq 0x18(%rbx), %rdi
movq 0x20(%rbx), %rsi
movq 0x9462(%rip), %rcx      # 0xe1f0
movl $0x1, %edx
callq 0x2250
movq 0x9451(%rip), %rsi      # 0xe1f0
leaq 0x3854(%rip), %rdi      # 0x85fa
callq 0x2130
movq 0x943e(%rip), %rsi      # 0xe1f0
leaq 0x3437(%rip), %rdi      # 0x81f0
callq 0x2130
movq %r14, %rdi
callq 0x49fd
movq 0x9423(%rip), %rsi      # 0xe1f0
leaq 0x3923(%rip), %rdi      # 0x86f7
callq 0x2130
movq %rbx, %rdi
callq 0x49fd
movq 0x9408(%rip), %rsi      # 0xe1f0
leaq 0x3910(%rip), %rdi      # 0x86ff
callq 0x2130
movq 0x18(%r14), %rdi
movq 0x20(%r14), %rsi
movq 0x93ed(%rip), %rcx      # 0xe1f0
movl $0x1, %edx
callq 0x2250
movq 0x93dc(%rip), %rsi      # 0xe1f0
leaq 0x3912(%rip), %rdi      # 0x872d
callq 0x2130
movq 0x18(%rbx), %rdi
movq 0x20(%rbx), %rsi
movq 0x93c1(%rip), %rcx      # 0xe1f0
movl $0x1, %edx
callq 0x2250
movq 0x93b0(%rip), %rsi      # 0xe1f0
leaq 0x3c4b(%rip), %rdi      # 0x8a92
callq 0x2130
movq 0x939d(%rip), %rsi      # 0xe1f0
leaq 0x383c(%rip), %rdi      # 0x8696
callq 0x2130
movq 0x938a(%rip), %rsi      # 0xe1f0
leaq 0x384a(%rip), %rdi      # 0x86b7
callq 0x2130
movq 0x9377(%rip), %rsi      # 0xe1f0
leaq 0x3847(%rip), %rdi      # 0x86c7
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2130
// File: /workspace/github_c_makefile_star2_O3/ieyasu[P]funit/generate_code.c
// Function: generate_set_call
static void generate_set_call(struct TestSet *set, int *set_i)
{
    if (set->next)
        generate_set_call(set->next, set_i);

    (*set_i)++;
    fputs("\n  call start_set(\"", fout);
    fwrite(set->name, set->namelen, 1, fout);
    fputs("\")\n", fout);
    fprintf(fout, "  call funit_set%i\n", *set_i);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x4ea6
movq %rbx, %rsi
callq 0x4e8c
incl (%rbx)
movq 0x9341(%rip), %rsi      # 0xe1f0
leaq 0x3bc7(%rip), %rdi      # 0x8a7d
callq 0x2130
movq 0x50(%r14), %rdi
movq 0x58(%r14), %rsi
movq 0x9326(%rip), %rcx      # 0xe1f0
movl $0x1, %edx
callq 0x2250
movq 0x9315(%rip), %rsi      # 0xe1f0
leaq 0x3baf(%rip), %rdi      # 0x8a91
callq 0x2130
movq 0x9302(%rip), %rdi      # 0xe1f0
movl (%rbx), %edx
leaq 0x3b9e(%rip), %rsi      # 0x8a95
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2190
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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 0x4ff6
movq %rdx, %rbx
movq %rdi, %r15
movq (%rdi), %rdx
testq %rdx, %rdx
je 0x5015
movq %rsi, %r14
movq 0x70c1(%rip), %r12      # 0xbff8
movq (%r12), %rdi
movq 0x48(%r15), %rcx
leaq 0x3bd2(%rip), %rsi      # 0x8b18
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 0x3baf(%rip), %rdi      # 0x8b20
callq 0x2130
testq %r14, %r14
je 0x4fd6
subl 0x28(%r15), %r14d
leal -0x2(%r14), %edi
cmpl $0x3, %r14d
cmovll %r14d, %edi
testl %edi, %edi
jle 0x4f94
callq 0x24cc
cmpl $0x3, %r14d
movq (%r12), %rsi
leaq 0x3b7f(%rip), %r14      # 0x8b22
leaq 0x3b7b(%rip), %rax      # 0x8b25
movq %rax, %rdi
cmovgeq %r14, %rdi
cmovgeq %rax, %r14
callq 0x2130
movq (%r12), %rsi
movq %r14, %rdi
callq 0x2130
movq (%r12), %rsi
leaq 0x3b4f(%rip), %rdi      # 0x8b20
callq 0x2130
movq (%r12), %rdi
leaq 0x3b46(%rip), %rsi      # 0x8b27
movq %rbx, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2190
leaq 0x3aac(%rip), %rdi      # 0x8aa9
leaq 0x3aba(%rip), %rsi      # 0x8abe
leaq 0x3abb(%rip), %rcx      # 0x8ac6
movl $0x16, %edx
callq 0x2120
leaq 0x3aeb(%rip), %rdi      # 0x8b07
leaq 0x3a9b(%rip), %rsi      # 0x8abe
leaq 0x3a9c(%rip), %rcx      # 0x8ac6
movl $0x19, %edx
callq 0x2120
// File: /workspace/github_c_makefile_star2_O3/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), %rax
testq %rax, %rax
je 0x51ca
movq 0x28(%rdi), %rdx
testq %rdx, %rdx
je 0x5157
movq 0x20(%rdi), %rcx
movq 0x30(%rdi), %rax
cmpq %rdx, %rax
setae %sil
cmpq %rcx, %rdx
sete %r8b
orb %sil, %r8b
je 0x51e9
movq %rax, 0x28(%rdi)
cmpq %rcx, %rax
jae 0x5181
incq %rax
movzbl -0x1(%rax), %esi
cmpl $0xa, %esi
je 0x5179
cmpl $0xd, %esi
je 0x5169
movq %rax, 0x28(%rdi)
leaq 0x1(%rax), %rsi
cmpq %rcx, %rax
movq %rsi, %rax
jne 0x5134
movq %rcx, %rax
jmp 0x5181
movq %rax, 0x28(%rdi)
movq $0x1, 0x48(%rdi)
movq 0x20(%rdi), %rcx
jmp 0x5186
cmpq %rcx, %rax
jae 0x5179
leaq 0x1(%rax), %rsi
cmpb $0xa, (%rax)
cmoveq %rsi, %rax
movq %rax, 0x28(%rdi)
incq 0x48(%rdi)
cmpq %rcx, %rax
jae 0x51ba
movq %rax, 0x40(%rdi)
movq %rax, 0x38(%rdi)
movq %rax, 0x30(%rdi)
cmpq %rcx, %rax
jae 0x51c8
subq %rax, %rcx
leaq 0x1(%rax), %rdx
movzbl -0x1(%rdx), %esi
cmpl $0xa, %esi
je 0x51c8
cmpl $0xd, %esi
je 0x51c8
movq %rdx, 0x30(%rdi)
incq %rdx
decq %rcx
jne 0x519e
jmp 0x51c8
movq %rdx, 0x28(%rdi)
decq 0x48(%rdi)
movq %rcx, 0x38(%rdi)
xorl %eax, %eax
popq %rcx
retq
leaq 0x396e(%rip), %rdi      # 0x8b3f
leaq 0x38e6(%rip), %rsi      # 0x8abe
leaq 0x3975(%rip), %rcx      # 0x8b54
movl $0x49, %edx
callq 0x2120
leaq 0x3989(%rip), %rdi      # 0x8b79
leaq 0x38c7(%rip), %rsi      # 0x8abe
leaq 0x3956(%rip), %rcx      # 0x8b54
movl $0x4d, %edx
callq 0x2120
// File: /workspace/github_c_makefile_star2_O3/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
movq 0x40(%rdi), %rax
testq %rax, %rax
je 0x5239
movq 0x30(%rdi), %rcx
cmpq %rcx, %rax
jae 0x5237
movzbl (%rax), %edx
cmpl $0x20, %edx
je 0x5228
cmpl $0x9, %edx
jne 0x5237
incq %rax
movq %rax, 0x40(%rdi)
cmpq %rcx, %rax
jne 0x521b
movq %rcx, %rax
popq %rcx
retq
leaq 0x397b(%rip), %rdi      # 0x8bbb
leaq 0x3877(%rip), %rsi      # 0x8abe
leaq 0x3982(%rip), %rcx      # 0x8bd0
movl $0x82, %edx
callq 0x2120
// File: /workspace/github_c_makefile_star2_O3/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 0x5208
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 0x5293
testq %rbx, %rbx
je 0x5298
movq %rcx, (%rbx)
jmp 0x5298
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x532a
movq %r14, (%rbx)
movq %rsp, %rsi
movl %eax, %edi
callq 0x2270
testl %eax, %eax
jne 0x5334
movq 0x30(%rsp), %rsi
testq %rsi, %rsi
jle 0x533e
cmpq $0x800001, %rsi         # imm = 0x800001
jae 0x535b
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 0x537d
addq 0x10(%rbx), %rax
movq %rax, 0x20(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rbx)
movups %xmm0, 0x38(%rbx)
movq $0x0, 0x48(%rbx)
jmp 0x5393
movq %r14, %rdi
callq 0x2571
jmp 0x538d
movq %r14, %rdi
callq 0x24fb
jmp 0x5385
movq 0x6cb3(%rip), %rax      # 0xbff8
movq (%rax), %rdi
leaq 0x38d0(%rip), %rsi      # 0x8c1f
movq %r14, %rdx
xorl %eax, %eax
callq 0x2190
jmp 0x5385
movq 0x6c96(%rip), %rax      # 0xbff8
movq (%rax), %rdi
leaq 0x38c6(%rip), %rsi      # 0x8c32
movl $0x800000, %ecx         # imm = 0x800000
movq %r14, %rdx
xorl %eax, %eax
callq 0x2190
jmp 0x5385
movq %r14, %rdi
callq 0x2536
movq %rbx, %rdi
callq 0x53a3
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
movl %r15d, %eax
addq $0x90, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x53eb
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x53ca
movq 0x10(%rbx), %rsi
callq 0x21f0
testl %eax, %eax
jne 0x540a
movq $0x0, 0x18(%rbx)
movl 0x8(%rbx), %edi
testl %edi, %edi
je 0x53e3
callq 0x2140
testl %eax, %eax
jne 0x53e3
movl $0x0, 0x8(%rbx)
popq %rbx
retq
movq %rbx, %rdi
callq 0x25e5
leaq 0x3878(%rip), %rdi      # 0x8c6a
leaq 0x36c5(%rip), %rsi      # 0x8abe
leaq 0x3875(%rip), %rcx      # 0x8c75
movl $0xd1, %edx
callq 0x2120
movq %rbx, %rdi
callq 0x25ac
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x5445
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x2040
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x5433
callq 0x5464
leaq 0x18(%rbx), %rdi
callq 0x53a3
movq %rbx, %rdi
popq %rbx
jmp 0x2040
leaq 0x38ac(%rip), %rdi      # 0x8cf8
leaq 0x38b0(%rip), %rsi      # 0x8d03
leaq 0x38bb(%rip), %rcx      # 0x8d15
movl $0x5b, %edx
callq 0x2120
// File: /workspace/github_c_makefile_star2_O3/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 0x5475
callq 0x5464
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x5483
callq 0x5b86
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x5491
callq 0x5ba0
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x549f
callq 0x5ba0
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x54ad
callq 0x5bce
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x54bb
callq 0x5ba0
movq %rbx, %rdi
popq %rbx
jmp 0x2040
// File: /workspace/github_c_makefile_star2_O3/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 0x5bb1
callq 0x5ba0
cmpl $0x1, 0x8(%rbx)
jne 0x5bc5
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x5bc5
callq 0x5ba0
movq %rbx, %rdi
popq %rbx
jmp 0x2040
// File: /workspace/github_c_makefile_star2_O3/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 0x5bdf
callq 0x5bce
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x5bed
callq 0x5ba0
movq %rbx, %rdi
popq %rbx
jmp 0x2040
// File: /workspace/github_c_makefile_star2_O3/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       # 0x5bf6
xorl %r14d, %r14d
xorl %esi, %esi
callq 0x5258
cmpq $0x1, %rax
je 0x5c9a
testq %rax, %rax
je 0x5ccb
movq %rbx, %rdi
callq 0x50e2
jmp 0x5cba
movq %rbx, %rdi
callq 0x50f2
testq %rax, %rax
jne 0x5cc0
movq 0x38(%rbx), %rsi
leaq 0x31cf(%rip), %rdx      # 0x8e81
movq %rbx, %rdi
callq 0x4f08
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x317f(%rip), %rdi      # 0x8e51
leaq 0x302a(%rip), %rsi      # 0x8d03
leaq 0x317d(%rip), %rcx      # 0x8e5d
movl $0x233, %edx            # imm = 0x233
callq 0x2120
// File: /workspace/github_c_makefile_star2_O3/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, %rbx
movq %rdi, %r14
callq 0x5c6d
testl %eax, %eax
je 0x5d13
xorl %r12d, %r12d
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
xorl %r12d, %r12d
movq %r14, %rdi
xorl %esi, %esi
callq 0x5d4a
testq %rax, %rax
je 0x5d04
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x6361
testl %eax, %eax
je 0x5d45
movq %r15, %rdi
callq 0x5ba0
jmp 0x5d01
movq %r15, %r12
jmp 0x5d04
// File: /workspace/github_c_makefile_star2_O3/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 0x6560
movabsq $0x200002400, %rdx      # imm = 0x200002400
movzbl (%rcx), %esi
cmpq $0x21, %rsi
ja 0x6554
btq %rsi, %rdx
jb 0x6560
incq %rcx
movq %rcx, 0x40(%rdi)
cmpq %rax, %rcx
jne 0x6545
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x659f
movq 0x30(%rdi), %rcx
incq %rax
movq %rax, 0x40(%rdi)
cmpq %rcx, %rax
jae 0x659f
movzbl (%rax), %edx
incq %rax
cmpl $0x20, %edx
jg 0x6591
cmpl $0xa, %edx
je 0x659f
cmpl $0xd, %edx
jne 0x6571
jmp 0x659f
cmpl $0x21, %edx
je 0x659f
cmpl $0x22, %edx
jne 0x6571
movq %rax, 0x40(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x65d5
callq 0x2290
movq (%rax), %rax
xorl %ecx, %ecx
movsbq (%r15,%rcx), %rdx
cmpl %edx, (%rax,%rdx,4)
jne 0x6628
incq %rcx
cmpq %rcx, %rbx
jne 0x65c3
testq %r12, %r12
je 0x660e
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 0x6602
incq %rsi
cmpq %rbx, %rsi
jne 0x6604
jmp 0x6612
xorl %esi, %esi
incq %rcx
cmpq %rcx, %r12
jne 0x65e8
jmp 0x661c
xorl %eax, %eax
jmp 0x661c
subq %rbx, %r14
leaq (%r14,%rcx), %rax
incq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x2a04(%rip), %rdi      # 0x9033
leaq 0x26cd(%rip), %rsi      # 0x8d03
leaq 0x29be(%rip), %rcx      # 0x8ffb
movl $0xc4, %edx
callq 0x2120
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
movq 0x40(%rdi), %rax
cmpb $0x26, (%rax)
jne 0x68e1
movl %esi, %ebp
movq %rdi, %rbx
incq %rax
movq %rax, 0x40(%rdi)
callq 0x5208
movq 0x40(%rbx), %rax
cmpq 0x30(%rbx), %rax
jae 0x6891
leaq 0x2899(%rip), %rdx      # 0x911d
movq %rbx, %rdi
movq %rax, %rsi
callq 0x4f08
jmp 0x68da
cmpq 0x20(%rbx), %rax
jae 0x68d2
movq 0x38(%rbx), %r14
movq %rbx, %rdi
callq 0x50f2
testq %rax, %rax
je 0x68d2
movq %r14, 0x38(%rbx)
movq %rbx, %rdi
callq 0x5208
movq 0x40(%rbx), %rax
movzbl (%rax), %ecx
cmpl $0x21, %ecx
je 0x6891
cmpl $0x26, %ecx
jne 0x68dc
testl %ebp, %ebp
je 0x68dc
incq %rax
movq %rax, 0x40(%rbx)
jmp 0x68dc
movq %rbx, %rdi
callq 0x50e2
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x27e9(%rip), %rdi      # 0x90d1
leaq 0x2414(%rip), %rsi      # 0x8d03
leaq 0x27f0(%rip), %rcx      # 0x90e6
movl $0xd7, %edx
callq 0x2120
// File: /workspace/github_c_makefile_star2_O3/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 0x69bd
callq 0x2060
movl (%rax), %edi
xorl %ebp, %ebp
cmpl $0x2, %edi
je 0x69c8
movq 0x565e(%rip), %rax      # 0xbff8
movq (%rax), %r14
callq 0x2260
leaq 0x2877(%rip), %rsi      # 0x9220
xorl %ebp, %ebp
movq %r14, %rdi
movq %rbx, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x2190
jmp 0x69c8
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_O3/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 0x6a08
movq %rax, %r15
movq %rax, %rdi
movq %r12, %rsi
callq 0x2180
testl %eax, %eax
je 0x6a45
movq %r14, %rdi
callq 0x20d0
movq %rax, %r15
movq %rbx, %rdi
callq 0x20d0
addq %r15, %rax
cmpq $0x1000, %rax           # imm = 0x1000
ja 0x6a95
leaq 0x77d3(%rip), %r15      # 0xe200
movq %r15, %rdi
movq %r14, %rsi
callq 0x2090
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2230
jmp 0x6a7e
subq %r14, %r15
movq %rbx, %rdi
callq 0x20d0
addq %r15, %rax
cmpq $0x1000, %rax           # imm = 0x1000
ja 0x6a95
leaq 0x779e(%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 0x777b(%rip), %rdi      # 0xe200
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x6933
movq %r14, %rdi
callq 0x261e
// File: /workspace/github_c_makefile_star2_O3/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
movq 0x8(%rdi), %rsi
addq 0x10(%rdi), %rax
cmpq %rax, %rsi
jae 0x6afe
movq %rdi, %rbx
addq %rsi, %rsi
cmpq %rax, %rsi
jb 0x6ae2
movq %rsi, 0x8(%rbx)
movq (%rbx), %rdi
callq 0x21e0
movq %rax, (%rbx)
testq %rax, %rax
je 0x6b00
popq %rbx
retq
callq 0x2050
// File: /workspace/github_c_makefile_star2_O3/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 $0xffffffff, %ebx       # imm = 0xFFFFFFFF
testl %edx, %edx
jle 0x1389
movl %edx, %r12d
movq %rsi, %r14
movq %rdi, %r15
decl %r12d
xorl %r13d, %r13d
leal (%r12,%r13), %ebp
shrl %ebp
movq %rbp, %rax
shlq $0x4, %rax
movq (%r14,%rax), %rsi
movq %r15, %rdi
callq 0x1040
testl %eax, %eax
jns 0x1379
decl %ebp
movl %ebp, %r12d
jmp 0x1380
je 0x1387
incl %ebp
movl %ebp, %r13d
cmpl %r12d, %r13d
jle 0x1355
jmp 0x1389
movl %ebp, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2799
je 0x27a4
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 0x7dea
testl %eax, %eax
sete %al
testl %ebp, %ebp
setne %dl
andb %dl, %al
cmpb $0x1, %al
jne 0x271c
xorl %edi, %edi
movl $0x1, %esi
callq 0x23d0
movl %eax, %ebp
xorl %eax, %eax
callq 0x7dea
testl %ebp, %ebp
setne %dl
testl %eax, %eax
jne 0x271c
testl %ebp, %ebp
jne 0x26fa
movq (%r14), %rax
movq $0x0, 0x20(%rax)
movq 0x18(%rax), %rcx
testb %dl, %dl
je 0x2736
movq (%rcx), %rcx
movq %rcx, 0x18(%rax)
movq (%r15), %rdx
movq 0x28(%rdx), %rdx
cmpq %rdx, %rcx
je 0x275f
cmpl $0x0, 0x14(%rcx)
je 0x275f
movzbl 0x18(%rcx), %esi
cmpl $0x9, %esi
je 0x275f
cmpl $0x20, %esi
je 0x275f
movq (%rcx), %rcx
movq %rcx, 0x18(%rax)
jmp 0x273d
xorl %edi, %edi
movl $0x1, %esi
callq 0x2372
testl %eax, %eax
je 0x277a
xorl %eax, %eax
callq 0x7dea
testl %eax, %eax
je 0x275f
leal -0x1(%rbx), %ecx
movq (%r14), %rax
movq 0x18(%rax), %rdx
movslq 0x14(%rdx), %rdx
movq %rdx, 0x20(%rax)
cmpl $0x1, %ebx
movl %ecx, %ebx
jg 0x26d5
jmp 0x27ae
negl %ebx
movl %ebx, %esi
callq 0x25d9
jmp 0x27b2
leaq 0xb0ad(%rip), %rax      # 0xd858
movq (%rax), %rax
orb $0x2, 0x3b(%rax)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x661d(%rip), %rdi      # 0x900f
movq %rsp, %rsi
movl $0x10, %edx
callq 0x4348
movl %eax, %ebx
cmpl $0x1, %eax
jne 0x2a29
movq %rsp, %rdi
xorl %ebx, %ebx
movl $0x1, %esi
xorl %edx, %edx
callq 0x2a31
testq %rax, %rax
je 0x2a29
movq %rax, %rdi
callq 0x28e8
movl $0x1, %ebx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x6495(%rip), %rdi      # 0x901c
movq %rsp, %rsi
movl $0x10, %edx
callq 0x4348
cmpl $0x1, %eax
jne 0x2bb9
movq %rsp, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2a31
testq %rax, %rax
je 0x2bb4
movq %rax, %rdi
callq 0x2bbe
jmp 0x2bb9
movl $0x1, %eax
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2bd9
leaq 0x645c(%rip), %rdi      # 0x902a
xorl %ebp, %ebp
xorl %eax, %eax
callq 0x4352
jmp 0x2c27
movq %rdi, %rbx
callq 0x2c30
movl %eax, %ebp
cmpl $0x1, %eax
jne 0x2c27
movq 0x28(%rbx), %rdi
callq 0x2040
leaq 0xac88(%rip), %rdx      # 0xd880
xorl %ecx, %ecx
movq %rcx, %rax
movq (%rdx), %rcx
movq %rcx, %rdx
cmpq %rbx, %rcx
jne 0x2bfa
movq (%rcx), %rcx
testq %rax, %rax
jne 0x2c17
leaq 0xac69(%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_O3/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 0x63a8(%rip), %rdi      # 0x9044
movq %rsp, %rsi
movl $0x10, %edx
callq 0x4348
xorl %ebx, %ebx
cmpl $0x1, %eax
jne 0x2d3b
leaq 0xabc5(%rip), %r13      # 0xd880
leaq 0xab86(%rip), %rbp      # 0xd848
movq %rsp, %r14
movq (%r13), %r15
movq (%rbp), %r12
testq %r15, %r15
je 0x2d0a
cmpq %r12, %r15
je 0x2cea
leaq 0x83(%r15), %rsi
movq %r14, %rdi
callq 0x2130
testl %eax, %eax
je 0x2cef
movq (%r15), %r15
jmp 0x2ccd
leaq 0x634e(%rip), %rdi      # 0x9044
movq %r14, %rsi
movl $0x10, %edx
callq 0x4348
cmpl $0x1, %eax
je 0x2cc5
jmp 0x2d3b
addq $0x83, %r12
movq %rsp, %rsi
movl $0x10, %edx
movq %r12, %rdi
callq 0x2060
leaq 0xab30(%rip), %rax      # 0xd858
movq (%rax), %rax
orb $0x10, 0x3b(%rax)
xorl %eax, %eax
callq 0x3108
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_O3/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 0x8fb7(%rip), %r14      # 0xd324
cmpl $0x0, (%r14)
jne 0x4384
callq 0x3108
leaq 0x9411(%rip), %rcx      # 0xd790
xorl %eax, %eax
callq *0x30(%rcx)
leaq 0x9405(%rip), %r15      # 0xd790
movl (%r15), %edi
cmpl %edi, 0x8d7c(%rip)      # 0xd110
jne 0x439f
cmpl $0x0, 0x8d77(%rip)      # 0xd114
je 0x43b7
movl %edi, 0x8d6b(%rip)      # 0xd110
movl $0x0, 0x8d65(%rip)      # 0xd114
xorl %esi, %esi
xorl %eax, %eax
callq *0x38(%r15)
leaq 0xc(%rsp), %r12
movzbl (%rbx), %eax
cmpl $0x25, %eax
je 0x43e0
testl %eax, %eax
je 0x448b
incq %rbx
movsbl %al, %edi
xorl %eax, %eax
callq *0x28(%r15)
incl 0x8d36(%rip)            # 0xd114
jmp 0x43bc
movzbl 0x1(%rbx), %eax
addq $0x2, %rbx
cmpl $0x6e, %eax
jg 0x4407
cmpl $0x44, %eax
je 0x4421
cmpl $0x63, %eax
je 0x4448
cmpl $0x64, %eax
jne 0x43cf
movl (%r12), %edi
movl $0xa, %esi
jmp 0x443a
cmpl $0x6f, %eax
je 0x4431
cmpl $0x73, %eax
je 0x445b
cmpl $0x78, %eax
jne 0x43cf
movl (%r12), %edi
movl $0x10, %esi
jmp 0x443a
movq (%r12), %rdi
movl $0xa, %esi
callq 0x4510
jmp 0x4482
movl (%r12), %edi
movl $0x8, %esi
callq 0x44b8
addq $0x4, %r12
jmp 0x43bc
movsbl (%r12), %edi
xorl %eax, %eax
callq *0x28(%r15)
incl 0x8cbb(%rip)            # 0xd114
jmp 0x4482
movb (%r12), %al
testb %al, %al
je 0x4482
leaq 0x1(%r12), %r13
movsbl %al, %edi
xorl %eax, %eax
callq *0x28(%r15)
incl 0x8c9d(%rip)            # 0xd114
movb (%r13), %al
incq %r13
testb %al, %al
jne 0x4468
addq $0x8, %r12
jmp 0x43bc
cmpl $0x1, (%r14)
jne 0x4497
xorl %eax, %eax
callq *0x40(%r15)
xorl %eax, %eax
callq *0x30(%r15)
leaq 0x93a0(%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_O3/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 0x44d6
negl %ebp
leaq 0x92c4(%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 0x44ea
movl %eax, %edi
movl %ebx, %esi
callq 0x44b8
leaq 0x929f(%rip), %rcx      # 0xd790
movl %ebp, %eax
leaq 0x4bd6(%rip), %rdx      # 0x90d0
movsbl (%rax,%rdx), %edi
xorl %eax, %eax
callq *0x28(%rcx)
incl 0x8c0b(%rip)            # 0xd114
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4532
negq %r14
leaq 0x9268(%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 0x454f
movq %rax, %rdi
movl %ebx, %esi
callq 0x4510
leaq 0x923a(%rip), %rcx      # 0xd790
addl $0x30, %r14d
movl %r14d, %edi
xorl %eax, %eax
callq *0x28(%rcx)
incl 0x8bac(%rip)            # 0xd114
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbx
subq $0x50, %rsp
leaq 0x4468(%rip), %rdi      # 0x91f8
movq %rsp, %rsi
movl $0x50, %edx
callq 0x4348
cmpl $0x2, %eax
je 0x4df4
testl %eax, %eax
jne 0x4db6
leaq 0x8a9b(%rip), %rax      # 0xd848
movq (%rax), %rbx
movb $0x0, 0x33(%rbx)
jmp 0x4dd1
leaq 0x8a8b(%rip), %rax      # 0xd848
movq (%rax), %rbx
leaq 0x33(%rbx), %rdi
movq %rsp, %rsi
movl $0x50, %edx
callq 0x2060
leaq 0x8a98(%rip), %rax      # 0xd870
movq (%rax), %rcx
movl $0x1, %eax
testq %rcx, %rcx
je 0x4df4
cmpq %rbx, 0x8(%rcx)
jne 0x4def
orb $0x10, 0x3b(%rcx)
movq (%rcx), %rcx
jmp 0x4de0
addq $0x50, %rsp
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x82b3(%rip), %rsi      # 0xd828
cmpq 0x82b4(%rip), %rsi      # 0xd830
jne 0x5598
testq %rsi, %rsi
je 0x55a1
movq 0x8296(%rip), %rdi      # 0xd820
addq $0x400, %rsi            # imm = 0x400
callq 0x2180
jmp 0x55ab
movq 0x8281(%rip), %rax      # 0xd820
jmp 0x55c9
movl $0x400, %edi            # imm = 0x400
callq 0x2150
testq %rax, %rax
je 0x55de
movq %rax, 0x8269(%rip)      # 0xd820
addq $0x400, 0x826e(%rip) # imm = 0x400
movq 0x825f(%rip), %rsi      # 0xd828
leaq 0x1(%rsi), %rcx
movq %rcx, 0x8254(%rip)      # 0xd828
movb %bl, (%rax,%rsi)
movl $0x1, %eax
popq %rbx
retq
xorl %eax, %eax
jmp 0x55dc