LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0xb109(%rip), %rsi      # 0x11290
leaq 0x5825(%rip), %rdi      # 0xb9b3
callq 0x2130
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rsi
movq 0xb0e6(%rip), %rcx      # 0x11290
movl $0x1, %edx
callq 0x2270
movq 0xb0d5(%rip), %rsi      # 0x11290
leaq 0x57ff(%rip), %rdi      # 0xb9c1
callq 0x2130
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
movq 0xb0b2(%rip), %rcx      # 0x11290
movl $0x1, %edx
callq 0x2270
movq 0xb0a1(%rip), %rsi      # 0x11290
leaq 0x56d9(%rip), %rdi      # 0xb8cf
callq 0x2130
movq 0xb08e(%rip), %rsi      # 0x11290
leaq 0x52bc(%rip), %rdi      # 0xb4c5
callq 0x2130
movq -0x8(%rbp), %rdi
callq 0x5cc0
movq 0xb072(%rip), %rsi      # 0x11290
leaq 0x57a7(%rip), %rdi      # 0xb9cc
callq 0x2130
movq -0x10(%rbp), %rdi
callq 0x5cc0
movq 0xb056(%rip), %rsi      # 0x11290
leaq 0x5793(%rip), %rdi      # 0xb9d4
callq 0x2130
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rsi
movq 0xb033(%rip), %rcx      # 0x11290
movl $0x1, %edx
callq 0x2270
movq 0xb022(%rip), %rsi      # 0x11290
leaq 0x578d(%rip), %rdi      # 0xba02
callq 0x2130
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
movq 0xafff(%rip), %rcx      # 0x11290
movl $0x1, %edx
callq 0x2270
movq 0xafee(%rip), %rsi      # 0x11290
leaq 0x5abe(%rip), %rdi      # 0xbd67
callq 0x2130
movq 0xafdb(%rip), %rsi      # 0x11290
leaq 0x56af(%rip), %rdi      # 0xb96b
callq 0x2130
movq 0xafc8(%rip), %rsi      # 0x11290
leaq 0x56bd(%rip), %rdi      # 0xb98c
callq 0x2130
movq 0xafb5(%rip), %rsi      # 0x11290
leaq 0x56ba(%rip), %rdi      # 0xb99c
callq 0x2130
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ieyasu[P]funit/generate_code.c
// Function: max_name_width
static void max_name_width(struct TestCase *test, size_t *max)
{
    if (test->namelen > *max)
        *max = test->namelen;
    if (test->next)
        max_name_width(test->next, max);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jbe 0x6320
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x633a
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x62f0
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x636a
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x6340
movq -0x10(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq 0xaf14(%rip), %rsi      # 0x11290
leaq 0x59cf(%rip), %rdi      # 0xbd52
callq 0x2130
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rsi
movq 0xaef1(%rip), %rcx      # 0x11290
movl $0x1, %edx
callq 0x2270
movq 0xaee0(%rip), %rsi      # 0x11290
leaq 0x59af(%rip), %rdi      # 0xbd66
callq 0x2130
movq 0xaecd(%rip), %rdi      # 0x11290
movq -0x10(%rbp), %rax
movl (%rax), %edx
leaq 0x599a(%rip), %rsi      # 0xbd6a
movb $0x0, %al
callq 0x21a0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x6401
jmp 0x6420
leaq 0x5976(%rip), %rdi      # 0xbd7e
leaq 0x5984(%rip), %rsi      # 0xbd93
movl $0x16, %edx
leaq 0x5980(%rip), %rcx      # 0xbd9b
callq 0x2120
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x642c
jmp 0x644b
leaq 0x59a9(%rip), %rdi      # 0xbddc
leaq 0x5959(%rip), %rsi      # 0xbd93
movl $0x19, %edx
leaq 0x5955(%rip), %rcx      # 0xbd9b
callq 0x2120
movq 0x8ba6(%rip), %rax      # 0xeff8
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rdx
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rcx
leaq 0x5982(%rip), %rsi      # 0xbded
movb $0x0, %al
callq 0x21a0
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rsi
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
subq %rax, %rsi
movq 0x8b64(%rip), %rax      # 0xeff8
movq (%rax), %rcx
movl $0x1, %edx
callq 0x2270
movq 0x8b50(%rip), %rax      # 0xeff8
movq (%rax), %rsi
leaq 0x5943(%rip), %rdi      # 0xbdf5
callq 0x2130
cmpq $0x0, -0x10(%rbp)
je 0x657c
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x28(%rcx), %rcx
subq %rcx, %rax
movl %eax, -0x1c(%rbp)
cmpl $0x2, -0x1c(%rbp)
jle 0x64e5
movl -0x1c(%rbp), %eax
subl $0x2, %eax
movl %eax, -0x24(%rbp)
jmp 0x64eb
movl -0x1c(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jle 0x6518
movq 0x8afa(%rip), %rax      # 0xeff8
movq (%rax), %rsi
leaq 0x5621(%rip), %rdi      # 0xbb29
callq 0x2130
movl -0x20(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x64f1
cmpl $0x2, -0x1c(%rbp)
jle 0x6534
movq 0x8ad3(%rip), %rax      # 0xeff8
movq (%rax), %rsi
leaq 0x58c8(%rip), %rdi      # 0xbdf7
callq 0x2130
movq 0x8abd(%rip), %rax      # 0xeff8
movq (%rax), %rsi
leaq 0x58b5(%rip), %rdi      # 0xbdfa
callq 0x2130
cmpl $0x2, -0x1c(%rbp)
jg 0x6566
movq 0x8aa1(%rip), %rax      # 0xeff8
movq (%rax), %rsi
leaq 0x5896(%rip), %rdi      # 0xbdf7
callq 0x2130
movq 0x8a8b(%rip), %rax      # 0xeff8
movq (%rax), %rsi
leaq 0x587e(%rip), %rdi      # 0xbdf5
callq 0x2130
movq 0x8a75(%rip), %rax      # 0xeff8
movq (%rax), %rdi
movq -0x18(%rbp), %rdx
leaq 0x586b(%rip), %rsi      # 0xbdfc
movb $0x0, %al
callq 0x21a0
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x40(%rax)
je 0x6939
jmp 0x6958
leaq 0x5550(%rip), %rdi      # 0xbe90
leaq 0x544c(%rip), %rsi      # 0xbd93
movl $0x82, %edx
leaq 0x5552(%rip), %rcx      # 0xbea5
callq 0x2120
jmp 0x695a
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x30(%rcx), %rax
jae 0x69a1
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movsbl (%rax), %eax
movl %eax, -0xc(%rbp)
subl $0x9, %eax
je 0x698b
jmp 0x6981
movl -0xc(%rbp), %eax
subl $0x20, %eax
jne 0x699d
jmp 0x698b
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x40(%rax)
jmp 0x699f
jmp 0x69a3
jmp 0x695a
jmp 0x69a3
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6920
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rdi
callq *%rax
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x38(%rcx), %rcx
subq %rcx, %rax
cmpq $0x0, %rax
jle 0x6a3f
cmpq $0x0, -0x18(%rbp)
je 0x6a31
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
subq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x6a48
movl $0x1, %eax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x6cd5
jmp 0x6cf4
leaq 0x5263(%rip), %rdi      # 0xbf3f
leaq 0x50b0(%rip), %rsi      # 0xbd93
movl $0xd1, %edx
leaq 0x525b(%rip), %rcx      # 0xbf4a
callq 0x2120
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x6d6c
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x2210
cmpl $0x0, %eax
jne 0x6d27
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
jmp 0x6d6a
movq 0x82ca(%rip), %rax      # 0xeff8
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
callq 0x2060
movl (%rax), %edi
callq 0x2280
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq %rax, %rcx
leaq 0x5217(%rip), %rsi      # 0xbf75
movb $0x0, %al
callq 0x21a0
callq 0x2050
jmp 0x6d6c
movq -0x8(%rbp), %rax
cmpl $0x0, 0x8(%rax)
je 0x6d94
movq -0x8(%rbp), %rax
movl 0x8(%rax), %edi
callq 0x2150
cmpl $0x0, %eax
jne 0x6d94
movq -0x8(%rbp), %rax
movl $0x0, 0x8(%rax)
jmp 0x6dd7
movq 0x825d(%rip), %rax      # 0xeff8
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
callq 0x2060
movl (%rax), %edi
callq 0x2280
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq %rax, %rcx
leaq 0x51c1(%rip), %rsi      # 0xbf8c
movb $0x0, %al
callq 0x21a0
callq 0x2050
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x6df5
jmp 0x6e14
leaq 0x5298(%rip), %rdi      # 0xc094
leaq 0x529c(%rip), %rsi      # 0xc09f
movl $0x5b, %edx
leaq 0x52a2(%rip), %rcx      # 0xc0b1
callq 0x2120
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x2040
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x6e38
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x6e60
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
callq 0x6cc0
movq -0x8(%rbp), %rdi
callq 0x2040
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x6e82
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x6e60
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x6e9a
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x75f0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x6eb2
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x7630
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x6eca
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x7630
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x6ee2
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x7690
movq -0x8(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x6efa
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x7630
movq -0x8(%rbp), %rdi
callq 0x2040
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ieyasu[P]funit/parse_test_file.c
// Function: parse_test_file
struct TestFile *parse_test_file(const char *path)
{
    struct TestFile *tf = NEW0(struct TestFile);
    struct ParseState *ps = &tf->ps;
    tf->path = fu_strdup(path);

    if (open_file_for_parsing(path, ps) != 0) {
        free(tf);
        return NULL;
    }

    if (!next_line(ps)) {
        syntax_error(ps);
        goto close_it;
    }

    for (;;) {
        size_t toklen;
        char *token = next_token(ps, &toklen);
        if (same_token("set", 3, token, toklen)) {
            struct TestSet *set = parse_set(ps);
            if (!set) // parse failure already reported
                goto close_it;
            set->next = tf->sets;
            tf->sets = set;
        } else if (token == END_OF_LINE) {
            if (!next_line(ps)) { // EOF
                if (!tf->sets) {
                    goto no_sets;
                }
                goto done;
            }
            // else swallow blank line
        } else {
no_sets:
            parse_fail(ps, ps->read_pos, "expected a test set");
            goto close_it;
        }
    }

 close_it:
    close_testfile(tf);
 done:
    return tf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl $0x1, %edi
movl $0x68, %esi
callq 0x2180
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x90c0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x6a60
cmpl $0x0, %eax
je 0x6f76
movq -0x18(%rbp), %rdi
callq 0x2040
movq $0x0, -0x8(%rbp)
jmp 0x7056
movq -0x20(%rbp), %rdi
callq 0x66b0
cmpq $0x0, %rax
jne 0x6f93
movq -0x20(%rbp), %rdi
callq 0x6680
jmp 0x7045
jmp 0x6f95
movq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x7060
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdx
movq -0x28(%rbp), %rcx
leaq 0x5223(%rip), %rdi      # 0xc1d8
movl $0x3, %esi
callq 0x7090
cmpl $0x0, %eax
je 0x6ff7
movq -0x20(%rbp), %rdi
callq 0x7100
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x6fda
jmp 0x7045
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x7040
movl $0x1, %eax
cmpq %rax, -0x30(%rbp)
jne 0x7022
movq -0x20(%rbp), %rdi
callq 0x66b0
cmpq $0x0, %rax
jne 0x7020
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x701e
jmp 0x7024
jmp 0x704e
jmp 0x703e
jmp 0x7024
movq -0x20(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x38(%rax), %rsi
leaq 0x50a1(%rip), %rdx      # 0xc0d8
callq 0x63e0
jmp 0x7045
jmp 0x7040
jmp 0x6f95
movq -0x18(%rbp), %rdi
callq 0x6de0
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x7652
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x7630
movq -0x8(%rbp), %rax
cmpl $0x1, 0x8(%rax)
jne 0x7676
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x7674
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x7630
jmp 0x7676
movq -0x8(%rbp), %rdi
callq 0x2040
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x76b2
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x7690
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x76ca
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x7630
movq -0x8(%rbp), %rdi
callq 0x2040
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ieyasu[P]funit/parse_test_file.c
// Function: expect_name
static char *expect_name(struct ParseState *ps, size_t *len, const char *kind)
{
    char *name = next_name(ps, len);
    if (!name || name == END_OF_LINE) {
        parse_vfail(ps, ps->read_pos, "expected %s name", kind);
        return NULL;
    }
    return name;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x7fc0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x7787
movl $0x1, %eax
cmpq %rax, -0x28(%rbp)
jne 0x77af
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rsi
movq -0x20(%rbp), %rcx
leaq 0x4a3e(%rip), %rdx      # 0xc1dc
movb $0x0, %al
callq 0x65a0
movq $0x0, -0x8(%rbp)
jmp 0x77b7
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x7060
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x77f6
jmp 0x7815
leaq 0x49f0(%rip), %rdi      # 0xc1ed
leaq 0x489b(%rip), %rsi      # 0xc09f
movl $0x233, %edx            # imm = 0x233
leaq 0x49e9(%rip), %rcx      # 0xc1f9
callq 0x2120
movl $0x1, %eax
cmpq %rax, -0x18(%rbp)
je 0x7832
movq -0x10(%rbp), %rdi
callq 0x6680
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x7869
movq -0x10(%rbp), %rdi
callq 0x66b0
cmpq $0x0, %rax
jne 0x7862
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rsi
leaq 0x49c9(%rip), %rdx      # 0xc21d
callq 0x63e0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x7869
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ieyasu[P]funit/parse_test_file.c
// Function: parse_dependency
static struct TestDependency *parse_dependency(struct ParseState *ps)
{
    struct TestDependency *dep = NEW0(struct TestDependency);

    dep->filename = next_quoted_string(ps, &dep->len);
    if (!dep->filename) {
        free(dep);
        return NULL;
    }
    if (expect_eol(ps)) {
        free(dep);
        return NULL;
    }
    return dep;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x1, %edi
movl $0x18, %esi
callq 0x2180
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x10, %rsi
callq 0x8050
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x78d9
movq -0x18(%rbp), %rdi
callq 0x2040
movq $0x0, -0x8(%rbp)
jmp 0x7902
movq -0x10(%rbp), %rdi
callq 0x77d0
cmpl $0x0, %eax
je 0x78fa
movq -0x18(%rbp), %rdi
callq 0x2040
movq $0x0, -0x8(%rbp)
jmp 0x7902
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ieyasu[P]funit/parse_test_file.c
// Function: parse_module
static struct TestModule *parse_module(struct ParseState *ps)
{
    struct TestModule *mod = NEW0(struct TestModule);

    mod->name = next_token(ps, &mod->len);
    if (mod->name == END_OF_LINE) {
        parse_fail(ps, ps->read_pos, "expected a module name");
        free(mod);
        return NULL;
    }

    // there might be Fortran code after the use <mod name>
    if (ps->next_pos < ps->next_line_pos) {
        ps->read_pos = ps->next_pos;
        ps->next_pos = ps->next_line_pos;
        mod->extra = ps->read_pos;
        mod->elen = ps->next_pos - ps->read_pos;
    }

    if (expect_eol(ps)) {
        free(mod);
        return NULL;
    }
    return mod;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x1, %edi
movl $0x28, %esi
callq 0x2180
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x18, %rsi
callq 0x7060
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movl $0x1, %ecx
cmpq %rcx, 0x8(%rax)
jne 0x7988
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rsi
leaq 0x4948(%rip), %rdx      # 0xc2b5
callq 0x63e0
movq -0x18(%rbp), %rdi
callq 0x2040
movq $0x0, -0x8(%rbp)
jmp 0x7a0e
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x30(%rcx), %rax
jae 0x79e5
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
subq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rdi
callq 0x77d0
cmpl $0x0, %eax
je 0x7a06
movq -0x18(%rbp), %rdi
callq 0x2040
movq $0x0, -0x8(%rbp)
jmp 0x7a0e
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x77d0
cmpl $0x0, %eax
je 0x7a48
jmp 0x7a87
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x7bd0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x7a62
jmp 0x7a87
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x7de0
cmpl $0x0, %eax
je 0x7a7d
jmp 0x7a87
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x7a9f
cmpq $0x0, -0x20(%rbp)
je 0x7a97
movq -0x20(%rbp), %rdi
callq 0x7630
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ieyasu[P]funit/parse_test_file.c
// Function: parse_test_case
static struct TestCase *parse_test_case(struct ParseState *ps)
{
    struct TestCase *test = NEW0(struct TestCase);

    test->name = expect_name(ps, &test->namelen, "test");
    if (!test->name)
        goto err;
    if (memchr(test->name, '"', test->namelen)) {
        parse_fail(ps, ps->read_pos, "double quotes (\") not allowed in test names");
        goto err;
    }

    if (expect_eol(ps))
        goto err;

    test->need_array_iterator = 0;
    test->code = parse_fortran(ps, &test->need_array_iterator);
    if (!test->code)
        goto err;

    if (parse_end_sequence(ps, "test", test->name, test->namelen))
        goto err;

    return test;
 err:
    free_cases(test);
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x1, %edi
movl $0x28, %esi
callq 0x2180
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x10, %rsi
leaq 0x46e4(%rip), %rdx      # 0xc1c6
callq 0x7750
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x7b02
jmp 0x7bb1
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdx
movl $0x22, %esi
callq 0x2170
cmpq $0x0, %rax
je 0x7b3c
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rsi
leaq 0x4797(%rip), %rdx      # 0xc2cc
callq 0x63e0
jmp 0x7bb1
movq -0x10(%rbp), %rdi
callq 0x77d0
cmpl $0x0, %eax
je 0x7b4c
jmp 0x7bb1
movq -0x18(%rbp), %rax
movl $0x0, 0x18(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x18, %rsi
callq 0x7bd0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x7b80
jmp 0x7bb1
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
leaq 0x462b(%rip), %rsi      # 0xc1c6
callq 0x7de0
cmpl $0x0, %eax
je 0x7ba7
jmp 0x7bb1
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x7bc2
movq -0x18(%rbp), %rdi
callq 0x7690
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x30(%rcx), %rax
jae 0x8047
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movsbl (%rax), %eax
movl %eax, -0xc(%rbp)
subl $0xa, %eax
je 0x8033
jmp 0x801f
movl -0xc(%rbp), %eax
subl $0xd, %eax
je 0x8033
jmp 0x8029
movl -0xc(%rbp), %eax
subl $0x21, %eax
jne 0x8035
jmp 0x8033
jmp 0x8047
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x40(%rax)
jmp 0x7ff8
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ieyasu[P]funit/parse_test_file.c
// Function: next_quoted_string
static char *next_quoted_string(struct ParseState *ps, size_t *len)
{
    char *s = next_thing(ps, len, quoted_string_end_finder);
    assert(s != NULL);
    if (s == END_OF_LINE || *s != '"') {
        parse_fail(ps, s, "expected a quote (\") to begin a string");
        return NULL;
    }

    if (ps->next_pos == s || *(ps->next_pos - 1) != '"') {
        parse_fail(ps, ps->next_pos, "expected a quote(\") to end the string");
        return NULL;
    }

    ps->read_pos++; // skip past leading "
    *len = ps->next_pos - ps->read_pos - 1;
    return ps->read_pos;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq 0xf1(%rip), %rdx        # 0x8160
callq 0x69c0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x8081
jmp 0x80a0
leaq 0x3d01(%rip), %rdi      # 0xbd89
leaq 0x4010(%rip), %rsi      # 0xc09f
movl $0xa8, %edx
leaq 0x4195(%rip), %rcx      # 0xc230
callq 0x2120
movl $0x1, %eax
cmpq %rax, -0x20(%rbp)
je 0x80b7
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x22, %eax
je 0x80d5
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
leaq 0x41a2(%rip), %rdx      # 0xc268
callq 0x63e0
movq $0x0, -0x8(%rbp)
jmp 0x8150
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
cmpq -0x20(%rbp), %rax
je 0x80f4
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movsbl -0x1(%rax), %eax
cmpl $0x22, %eax
je 0x8116
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rsi
leaq 0x4188(%rip), %rdx      # 0xc28f
callq 0x63e0
movq $0x0, -0x8(%rbp)
jmp 0x8150
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x38(%rax)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
subq %rax, %rcx
subq $0x1, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movsbl (%rax), %eax
cmpl $0x22, %eax
je 0x817a
jmp 0x81ef
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x40(%rax)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x30(%rcx), %rax
jae 0x81ef
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movsbl (%rax), %eax
addl $-0xa, %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x18, %eax
ja 0x81dd
movq -0x10(%rbp), %rax
leaq 0x3de4(%rip), %rcx      # 0xbfa4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x40(%rax)
jmp 0x81ef
jmp 0x81ef
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x40(%rax)
jmp 0x818a
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ieyasu[P]funit/parse_test_file.c
// Function: is_test_token
static int is_test_token(char *tok, size_t len)
{
    return (tok != END_OF_LINE &&
            (same_token(tok, len, "test",        4) ||
             same_token(tok, len, "setup",       5) ||
             same_token(tok, len, "teardown",    8) ||
             same_token(tok, len, "dep",         3) ||
             // XXX add 'use'?
             same_token(tok, len, "tolerance",   9)));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
xorl %eax, %eax
movl $0x1, %ecx
cmpq %rcx, -0x8(%rbp)
movb %al, -0x11(%rbp)
je 0x82e4
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq 0x3f93(%rip), %rdx      # 0xc1c6
movl $0x4, %ecx
callq 0x7090
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x12(%rbp)
jne 0x82de
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq 0x316d(%rip), %rdx      # 0xb3c9
movl $0x5, %ecx
callq 0x7090
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x12(%rbp)
jne 0x82de
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq 0x314e(%rip), %rdx      # 0xb3cf
movl $0x8, %ecx
callq 0x7090
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x12(%rbp)
jne 0x82de
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq 0x3e91(%rip), %rdx      # 0xc137
movl $0x3, %ecx
callq 0x7090
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x12(%rbp)
jne 0x82de
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq 0x3e74(%rip), %rdx      # 0xc13f
movl $0x9, %ecx
callq 0x7090
cmpl $0x0, %eax
setne %al
movb %al, -0x12(%rbp)
movb -0x12(%rbp), %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ieyasu[P]funit/parse_test_file.c
// Function: next_is_test_end_token
static int next_is_test_end_token(struct ParseState *ps)
{
    char *tok;
    size_t len;

    tok = next_token(ps, &len);
    assert(tok != NULL);

    return (tok != END_OF_LINE &&
            (same_token(tok, len, "test",        4) ||
             same_token(tok, len, "setup",       5) ||
             same_token(tok, len, "teardown",    8) ||
             same_token(tok, len, "set", 3)));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x7060
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x8326
jmp 0x8345
leaq 0x3ec0(%rip), %rdi      # 0xc1ed
leaq 0x3d6b(%rip), %rsi      # 0xc09f
movl $0x1f2, %edx            # imm = 0x1F2
leaq 0x3fef(%rip), %rcx      # 0xc32f
callq 0x2120
xorl %eax, %eax
movl $0x1, %ecx
cmpq %rcx, -0x10(%rbp)
movb %al, -0x19(%rbp)
je 0x83f0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq 0x3e5e(%rip), %rdx      # 0xc1c6
movl $0x4, %ecx
callq 0x7090
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x1a(%rbp)
jne 0x83ea
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq 0x303c(%rip), %rdx      # 0xb3c9
movl $0x5, %ecx
callq 0x7090
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x1a(%rbp)
jne 0x83ea
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq 0x301d(%rip), %rdx      # 0xb3cf
movl $0x8, %ecx
callq 0x7090
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x1a(%rbp)
jne 0x83ea
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq 0x3e01(%rip), %rdx      # 0xc1d8
movl $0x3, %ecx
callq 0x7090
cmpl $0x0, %eax
setne %al
movb %al, -0x1a(%rbp)
movb -0x1a(%rbp), %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ieyasu[P]funit/parse_test_file.c
// Function: parse_macro
static struct Code *
parse_macro(struct ParseState *ps, enum MacroType mtype, int *need_array_it)
{
    struct Code *code = NEW0(struct Code);
    int error = 0;

    code->type = MACRO_CODE;
    code->lineno = ps->lineno;
    code->u.m.type = mtype;
    code->u.m.args = parse_macro_args(ps, &error);
    if (error)
        goto cleanup;
    if (code->u.m.args) {
        ps->read_pos = ps->next_pos + 1;
        code->next = parse_fortran(ps, need_array_it);
        if (code->next)
            return code;
    }
    parse_fail(ps, ps->read_pos, "expected macro argument");
 cleanup:
    free_code(code);
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x1, %edi
movl $0x28, %esi
callq 0x2180
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x28(%rbp), %rax
movl $0x1, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movl -0x14(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x10(%rbp), %rdi
leaq -0x2c(%rbp), %rsi
callq 0x8a60
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x20(%rax)
cmpl $0x0, -0x2c(%rbp)
je 0x8882
jmp 0x88e6
movq -0x28(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x88ce
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rcx
addq $0x1, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x7bd0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
cmpq $0x0, (%rax)
je 0x88cc
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x88f7
jmp 0x88ce
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rsi
leaq 0x3b1d(%rip), %rdx      # 0xc3fe
callq 0x63e0
movq -0x28(%rbp), %rdi
callq 0x7630
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jbe 0x8931
jmp 0x8950
leaq 0x3a5f(%rip), %rdi      # 0xc397
leaq 0x3760(%rip), %rsi      # 0xc09f
movl $0xc1, %edx
leaq 0x3a5b(%rip), %rcx      # 0xc3a6
callq 0x2120
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x89bc
movq -0x20(%rbp), %rax
movq -0x30(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movl %eax, -0x3c(%rbp)
movq -0x20(%rbp), %rax
movq -0x30(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x21d0
movl %eax, %ecx
movl -0x3c(%rbp), %eax
cmpl %ecx, %eax
jne 0x898d
jmp 0x89ac
leaq 0x3a4a(%rip), %rdi      # 0xc3de
leaq 0x3704(%rip), %rsi      # 0xc09f
movl $0xc4, %edx
leaq 0x39ff(%rip), %rcx      # 0xc3a6
callq 0x2120
jmp 0x89ae
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x8958
movq $0x0, -0x38(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x8a40
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x21d0
movq -0x20(%rbp), %rcx
movq -0x38(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jne 0x8a2a
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x28(%rbp), %rax
jne 0x8a28
movq -0x10(%rbp), %rax
addq -0x30(%rbp), %rax
xorl %ecx, %ecx
subq -0x28(%rbp), %rcx
addq %rcx, %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x8a48
jmp 0x8a32
movq $0x0, -0x38(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x89cc
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ieyasu[P]funit/parse_test_file.c
// Function: parse_macro_args
static struct Code *parse_macro_args(struct ParseState *ps, int *error)
{
    struct Code *code;

    if (!split_macro_arg(ps)) {
        *error = 1;
        return NULL;
    }

    code = NEW0(struct Code);
    code->type = ARG_CODE;
    code->lineno = ps->lineno;
    code->u.c.str = ps->read_pos;
    code->u.c.len = ps->next_pos - ps->read_pos;
    if (*ps->next_pos == ',') {
        ps->next_pos++;
        skip_next_ws(ps);
        ps->read_pos = ps->next_pos;
        code->next = parse_macro_args(ps, error);
        if (*error) {
            free(code);
            return NULL;
        }
    }
    assert(*ps->next_pos == ')');
    return code;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8ba0
cmpq $0x0, %rax
jne 0x8a96
movq -0x18(%rbp), %rax
movl $0x1, (%rax)
movq $0x0, -0x8(%rbp)
jmp 0x8b96
movl $0x1, %edi
movl $0x28, %esi
callq 0x2180
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl $0x2, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
subq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movsbl (%rax), %eax
cmpl $0x2c, %eax
jne 0x8b5d
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x40(%rax)
movq -0x10(%rbp), %rdi
callq 0x6920
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x8a60
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x8b5b
movq -0x20(%rbp), %rdi
callq 0x2040
movq $0x0, -0x8(%rbp)
jmp 0x8b96
jmp 0x8b5d
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movsbl (%rax), %eax
cmpl $0x29, %eax
jne 0x8b6f
jmp 0x8b8e
leaq 0x38a0(%rip), %rdi      # 0xc416
leaq 0x3522(%rip), %rsi      # 0xc09f
movl $0x163, %edx            # imm = 0x163
leaq 0x38a2(%rip), %rcx      # 0xc42b
callq 0x2120
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ieyasu[P]funit/parse_test_file.c
// Function: skip_ampersand_in_string
static char *skip_ampersand_in_string(struct ParseState *ps)
{
    char *amp_pos = ps->next_pos;

    assert(*ps->next_pos == '&');
    ps->next_pos++;

    skip_next_ws(ps);
    if (ps->next_pos < ps->next_line_pos &&
        *ps->next_pos != '\r' && *ps->next_pos != '\n') {
        // not a line continuation
        ps->next_pos--;
        return ps->next_pos;
    }
    ps->next_pos = amp_pos;
    return skip_line_continuation(ps, 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movsbl (%rax), %eax
cmpl $0x26, %eax
jne 0x8dba
jmp 0x8dd9
leaq 0x36f7(%rip), %rdi      # 0xc4b8
leaq 0x32d7(%rip), %rsi      # 0xc09f
movl $0xf9, %edx
leaq 0x36f9(%rip), %rcx      # 0xc4cd
callq 0x2120
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x40(%rax)
movq -0x10(%rbp), %rdi
callq 0x6920
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x30(%rcx), %rax
jae 0x8e42
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movsbl (%rax), %eax
cmpl $0xd, %eax
je 0x8e42
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
je 0x8e42
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x40(%rax)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x8e60
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x8e70
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movsbl (%rax), %eax
cmpl $0x26, %eax
jne 0x8e91
jmp 0x8eb0
leaq 0x3620(%rip), %rdi      # 0xc4b8
leaq 0x3200(%rip), %rsi      # 0xc09f
movl $0xd7, %edx
leaq 0x3656(%rip), %rcx      # 0xc501
callq 0x2120
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x40(%rax)
movq -0x10(%rbp), %rdi
callq 0x6920
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x30(%rcx), %rax
jae 0x8f00
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rsi
leaq 0x364a(%rip), %rdx      # 0xc538
callq 0x63e0
movq $0x0, -0x8(%rbp)
jmp 0x8fa3
jmp 0x8f02
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jae 0x8f92
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x66b0
cmpq $0x0, %rax
jne 0x8f31
jmp 0x8f92
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x10(%rbp), %rdi
callq 0x6920
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movsbl (%rax), %eax
movl %eax, -0x24(%rbp)
subl $0x21, %eax
je 0x8f65
jmp 0x8f5b
movl -0x24(%rbp), %eax
subl $0x26, %eax
je 0x8f67
jmp 0x8f7f
jmp 0x8f8d
cmpl $0x0, -0x14(%rbp)
je 0x8f7d
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x40(%rax)
jmp 0x8f7f
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x8fa3
jmp 0x8f02
movq -0x10(%rbp), %rdi
callq 0x6680
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ieyasu[P]funit/parse_test_file.c
// Function: expect_token
static int
expect_token(struct ParseState *ps, const char *expected, const char *message)
{
    char *tok;
    size_t len;

    tok = next_token(ps, &len);
    assert(tok != NULL);
    if (tok == END_OF_LINE ||
        !same_token(expected, strlen(expected),tok, len)) {
        parse_vfail(ps, ps->read_pos, "\"%s\" expected", message);
        return -1;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x7060
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x8fde
jmp 0x8ffd
leaq 0x3208(%rip), %rdi      # 0xc1ed
leaq 0x30b3(%rip), %rsi      # 0xc09f
movl $0x246, %edx            # imm = 0x246
leaq 0x35d0(%rip), %rcx      # 0xc5c8
callq 0x2120
movl $0x1, %eax
cmpq %rax, -0x28(%rbp)
je 0x9032
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x20d0
movq -0x38(%rbp), %rdi
movq %rax, %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
callq 0x7090
cmpl $0x0, %eax
jne 0x9059
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rsi
movq -0x20(%rbp), %rcx
leaq 0x35c1(%rip), %rdx      # 0xc60a
movb $0x0, %al
callq 0x65a0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x9060
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0x1, %rdi
callq 0x21e0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x2070
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)