LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/ieyasu[P]funit/generate_code.c
// Function: generate_set
static int generate_set(struct TestSet *set, int *set_i)
{
    int test_i;

    if (set->next)
        generate_set(set->next, set_i);

    (*set_i)++;
    fprintf(fout, "subroutine funit_set%i\n", *set_i);
    fputs("  use funit\n", fout);
    
    if (set->mods)
        print_use(set->mods);
    
    fputs("\n", fout);
    fputs("  implicit none\n\n", fout);
    fputs("  character*1024 :: funit_message_\n", fout);
    fputs("  logical :: funit_passed_\n\n", fout);
    
    if (set->code)
        generate_code(set->code, set->tolerance);

    if (set->tests) {
        size_t max_name = max_test_name_width(set->tests);
        test_i = 0;
        generate_test_call(set, set->tests, &test_i, max_name);
    }
    
    fputs("contains\n\n", fout);
    
    if (set->setup)
        generate_support(set, "setup");
    if (set->teardown)
        generate_support(set, "teardown");
    if (set->tests) {
        test_i = 0;
        if (generate_test(set->tests, &test_i, set->tolerance))
            return -1;
    }

    fprintf(fout, "end subroutine funit_set%i\n", *set_i);

    return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x37c0
movq %rbx, %rsi
callq 0x37a6
movl (%rbx), %edx
incl %edx
movl %edx, (%rbx)
movq 0xaa23(%rip), %rdi      # 0xe1f0
leaq 0x4978(%rip), %rsi      # 0x814c
xorl %eax, %eax
callq 0x2190
movq 0xaa0e(%rip), %rsi      # 0xe1f0
leaq 0x48f7(%rip), %rdi      # 0x80e0
callq 0x2130
movq 0x10(%r14), %rdi
testq %rdi, %rdi
je 0x37fc
callq 0x3921
movq 0xa9ed(%rip), %rsi      # 0xe1f0
leaq 0x5316(%rip), %rdi      # 0x8b20
callq 0x2130
movq 0xa9da(%rip), %rsi      # 0xe1f0
leaq 0x5142(%rip), %rdi      # 0x895f
callq 0x2130
movq 0xa9c7(%rip), %rsi      # 0xe1f0
leaq 0x48bd(%rip), %rdi      # 0x80ed
callq 0x2130
movq 0xa9b4(%rip), %rsi      # 0xe1f0
leaq 0x48ce(%rip), %rdi      # 0x8111
callq 0x2130
movq 0x30(%r14), %rdi
testq %rdi, %rdi
je 0x385c
movsd 0x60(%r14), %xmm0
callq 0x398c
movq 0x28(%r14), %rsi
testq %rsi, %rsi
je 0x389a
xorl %ecx, %ecx
xorl %eax, %eax
movq %rsi, %rdx
movq 0x10(%rdx), %rdi
cmpq %rax, %rdi
cmovaq %rdi, %rcx
cmovaq %rdi, %rax
movq (%rdx), %rdi
movq %rdi, %rdx
testq %rdi, %rdi
jne 0x386c
addq $0x2, %rcx
leaq 0x4(%rsp), %rdx
andl $0x0, (%rdx)
movq %r14, %rdi
callq 0x439d
movq 0xa94f(%rip), %rsi      # 0xe1f0
leaq 0x4886(%rip), %rdi      # 0x812e
callq 0x2130
cmpq $0x0, 0x18(%r14)
je 0x38c3
leaq 0x487e(%rip), %rsi      # 0x8139
movq %r14, %rdi
callq 0x448a
cmpq $0x0, 0x20(%r14)
je 0x38d9
leaq 0x486e(%rip), %rsi      # 0x813f
movq %r14, %rdi
callq 0x448a
movq 0x28(%r14), %rdi
testq %rdi, %rdi
je 0x38fe
leaq 0x4(%rsp), %rsi
andl $0x0, (%rsi)
movsd 0x60(%r14), %xmm0
callq 0x44da
testl %eax, %eax
je 0x38fe
pushq $-0x1
popq %rbx
jmp 0x3917
movq 0xa8eb(%rip), %rdi      # 0xe1f0
movl (%rbx), %edx
leaq 0x483a(%rip), %rsi      # 0x8148
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x2190
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/ieyasu[P]funit/generate_code.c
// Function: print_use
static void print_use(struct TestModule *mod)
{
    if (mod->next)
        print_use(mod->next);

    fputs("  use ", fout);
    fwrite(mod->name, mod->len, 1, fout);
    if (mod->elen > 0) {
        fwrite(mod->extra, mod->elen, 1, fout);
    }
    fputs("\n", fout);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x3932
callq 0x3921
movq 0xa8b7(%rip), %rsi      # 0xe1f0
leaq 0x4824(%rip), %rdi      # 0x8164
callq 0x2130
movq 0x8(%rbx), %rdi
movq 0x18(%rbx), %rsi
movq 0xa89c(%rip), %rcx      # 0xe1f0
pushq $0x1
popq %rdx
callq 0x2250
movq 0x20(%rbx), %rsi
testq %rsi, %rsi
je 0x3978
movq 0x10(%rbx), %rdi
movq 0xa880(%rip), %rcx      # 0xe1f0
pushq $0x1
popq %rdx
callq 0x2250
movq 0xa871(%rip), %rsi      # 0xe1f0
leaq 0x519a(%rip), %rdi      # 0x8b20
popq %rbx
jmp 0x2130
// File: /workspace/github_c_makefile_star2_O2/ieyasu[P]funit/generate_code.c
// Function: generate_test_call
static void generate_test_call(struct TestSet *set,
                               struct TestCase *test, int *test_i,
                               size_t max_name)
{
    if (test->next)
        generate_test_call(set, test->next, test_i, max_name);

    *test_i += 1;

    fputs("\n", fout);
    if (set->setup)
        fprintf(fout, "  call funit_setup\n");
    fprintf(fout, "  call funit_test%i(funit_passed_, funit_message_)\n",
            *test_i);
    fputs("  call pass_fail(funit_passed_, funit_message_, \"", fout);
    fwrite(test->name, test->namelen, 1, fout);
    fprintf(fout, "\", %u)\n", (unsigned int)max_name);
    if (set->teardown)
        fputs("  call funit_teardown\n\n", fout);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
movq (%rsi), %rsi
testq %rsi, %rsi
je 0x43c7
movq %rbx, %rdi
movq %r12, %rdx
movq %r14, %rcx
callq 0x439d
incl (%r12)
movq 0x9e1e(%rip), %rsi      # 0xe1f0
leaq 0x4747(%rip), %rdi      # 0x8b20
callq 0x2130
cmpq $0x0, 0x18(%rbx)
je 0x43fe
movq 0x9e04(%rip), %rcx      # 0xe1f0
leaq 0x4463(%rip), %rdi      # 0x8856
pushq $0x13
popq %rsi
pushq $0x1
popq %rdx
callq 0x2250
movq 0x9deb(%rip), %rdi      # 0xe1f0
movl (%r12), %edx
leaq 0x445a(%rip), %rsi      # 0x886a
xorl %eax, %eax
callq 0x2190
movq 0x9dd2(%rip), %rsi      # 0xe1f0
leaq 0x4479(%rip), %rdi      # 0x889e
callq 0x2130
movq 0x8(%r15), %rdi
movq 0x10(%r15), %rsi
movq 0x9db7(%rip), %rcx      # 0xe1f0
pushq $0x1
popq %rdx
callq 0x2250
movq 0x9da8(%rip), %rdi      # 0xe1f0
leaq 0x4481(%rip), %rsi      # 0x88d0
movl %r14d, %edx
xorl %eax, %eax
callq 0x2190
cmpq $0x0, 0x20(%rbx)
je 0x447e
movq 0x9d89(%rip), %rsi      # 0xe1f0
leaq 0x446a(%rip), %rdi      # 0x88d8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2130
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
testq %rdi, %rdi
movsd %xmm0, (%rsp)
je 0x44fe
movq %rbx, %rsi
movsd (%rsp), %xmm0
callq 0x44da
movl (%rbx), %edx
incl %edx
movl %edx, (%rbx)
movq 0x9ce5(%rip), %rdi      # 0xe1f0
leaq 0x4411(%rip), %rsi      # 0x8923
xorl %eax, %eax
callq 0x2190
movq 0x9cd0(%rip), %rsi      # 0xe1f0
leaq 0x4436(%rip), %rdi      # 0x895d
callq 0x2130
movq 0x9cbd(%rip), %rsi      # 0xe1f0
leaq 0x4437(%rip), %rdi      # 0x8971
callq 0x2130
movq 0x9caa(%rip), %rsi      # 0xe1f0
leaq 0x444f(%rip), %rdi      # 0x899c
callq 0x2130
cmpl $0x0, 0x18(%r14)
je 0x456c
movq 0x9c90(%rip), %rsi      # 0xe1f0
leaq 0x4466(%rip), %rdi      # 0x89cd
callq 0x2130
movq 0x9c7d(%rip), %rsi      # 0xe1f0
leaq 0x45a6(%rip), %rdi      # 0x8b20
callq 0x2130
movq 0x20(%r14), %rdi
testq %rdi, %rdi
je 0x459b
movsd (%rsp), %xmm0
callq 0x398c
testl %eax, %eax
je 0x459b
pushq $-0x1
popq %rbx
jmp 0x45c7
movq 0x9c4e(%rip), %rsi      # 0xe1f0
leaq 0x443d(%rip), %rdi      # 0x89e6
callq 0x2130
movq 0x9c3b(%rip), %rdi      # 0xe1f0
movl (%rbx), %edx
leaq 0x4445(%rip), %rsi      # 0x8a03
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x2190
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x4870
movq %rdi, %r10
testq %rdx, %rdx
je 0x4814
movl %ecx, %r8d
xorl %eax, %eax
testl %r9d, %r9d
movl $0x0, %esi
cmovgl %r9d, %esi
testq %rdx, %rdx
je 0x47cd
movq 0x10(%rdx), %rcx
cmpl %eax, %esi
je 0x47d4
incl %eax
movq (%rdx), %rdx
jmp 0x47b9
cmpl %r8d, %eax
jl 0x47d4
popq %rcx
retq
cmpl %r9d, %r8d
jne 0x483c
movq 0x7818(%rip), %rax      # 0xbff8
movq (%rax), %rdi
movq 0x9a0e(%rip), %rdx      # 0xe1f8
cmpl $0x2, %r8d
leaq 0x4765(%rip), %rax      # 0x8f5a
leaq 0x4325(%rip), %r9       # 0x8b21
cmovgeq %rax, %r9
movq %r10, (%rsp)
leaq 0x3ab3(%rip), %rsi      # 0x82be
xorl %eax, %eax
callq 0x2190
jmp 0x4868
movq 0x77dd(%rip), %rax      # 0xbff8
movq (%rax), %rdi
movq 0x99d3(%rip), %rdx      # 0xe1f8
movq 0x10(%rsi), %rcx
leaq 0x3a6b(%rip), %rsi      # 0x829b
movq %r10, %r8
xorl %eax, %eax
callq 0x2190
jmp 0x4868
leal 0x1(%r8), %eax
cmpl %r9d, %eax
jne 0x4889
movq 0x77ac(%rip), %rax      # 0xbff8
movq (%rax), %rdi
movq 0x99a2(%rip), %rdx      # 0xe1f8
movq %r10, (%rsp)
leaq 0x3aa3(%rip), %rsi      # 0x8304
xorl %eax, %eax
callq 0x2190
pushq $-0x1
popq %rax
jmp 0x47d2
leaq 0x39b2(%rip), %rdi      # 0x8229
leaq 0x391d(%rip), %rsi      # 0x819b
leaq 0x39c9(%rip), %rcx      # 0x824e
pushq $0x12
jmp 0x48a0
leaq 0x3a5b(%rip), %rdi      # 0x82eb
leaq 0x3904(%rip), %rsi      # 0x819b
leaq 0x39b0(%rip), %rcx      # 0x824e
pushq $0x2a
popq %rdx
callq 0x2120
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
movq 0x9938(%rip), %rsi      # 0xe1f0
leaq 0x3e1f(%rip), %rdi      # 0x86de
callq 0x2130
movq 0x18(%r15), %rdi
movq 0x20(%r15), %rsi
movq 0x991d(%rip), %rcx      # 0xe1f0
pushq $0x1
popq %r14
movq %r14, %rdx
callq 0x2250
movq 0x990a(%rip), %rsi      # 0xe1f0
leaq 0x3dff(%rip), %rdi      # 0x86ec
callq 0x2130
movq 0x18(%rbx), %rdi
movq 0x20(%rbx), %rsi
movq 0x98ef(%rip), %rcx      # 0xe1f0
movq %r14, %rdx
callq 0x2250
movq 0x98e0(%rip), %rsi      # 0xe1f0
leaq 0x3ce3(%rip), %rdi      # 0x85fa
callq 0x2130
movq 0x98cd(%rip), %rsi      # 0xe1f0
leaq 0x38c6(%rip), %rdi      # 0x81f0
callq 0x2130
movq %r15, %rdi
callq 0x45d9
movq 0x98b2(%rip), %rsi      # 0xe1f0
leaq 0x3db2(%rip), %rdi      # 0x86f7
callq 0x2130
movq %rbx, %rdi
callq 0x45d9
movq 0x9897(%rip), %rsi      # 0xe1f0
leaq 0x3d9f(%rip), %rdi      # 0x86ff
callq 0x2130
movq 0x18(%r15), %rdi
movq 0x20(%r15), %rsi
movq 0x987c(%rip), %rcx      # 0xe1f0
movq %r14, %rdx
callq 0x2250
movq 0x986d(%rip), %rsi      # 0xe1f0
leaq 0x3da3(%rip), %rdi      # 0x872d
callq 0x2130
movq 0x18(%rbx), %rdi
movq 0x20(%rbx), %rsi
movq 0x9852(%rip), %rcx      # 0xe1f0
movq %r14, %rdx
callq 0x2250
movq 0x9843(%rip), %rsi      # 0xe1f0
leaq 0x40de(%rip), %rdi      # 0x8a92
callq 0x2130
movq 0x9830(%rip), %rsi      # 0xe1f0
leaq 0x3ccf(%rip), %rdi      # 0x8696
callq 0x2130
movq 0x981d(%rip), %rsi      # 0xe1f0
leaq 0x3cdd(%rip), %rdi      # 0x86b7
callq 0x2130
movq 0x980a(%rip), %rsi      # 0xe1f0
leaq 0x3cda(%rip), %rdi      # 0x86c7
popq %rbx
popq %r14
popq %r15
jmp 0x2130
// File: /workspace/github_c_makefile_star2_O2/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 0x4a11
movq %rbx, %rsi
callq 0x49f7
incl (%rbx)
movq 0x97d6(%rip), %rsi      # 0xe1f0
leaq 0x405c(%rip), %rdi      # 0x8a7d
callq 0x2130
movq 0x50(%r14), %rdi
movq 0x58(%r14), %rsi
movq 0x97bb(%rip), %rcx      # 0xe1f0
pushq $0x1
popq %rdx
callq 0x2250
movq 0x97ac(%rip), %rsi      # 0xe1f0
leaq 0x4046(%rip), %rdi      # 0x8a91
callq 0x2130
movq 0x9799(%rip), %rdi      # 0xe1f0
movl (%rbx), %edx
leaq 0x4035(%rip), %rsi      # 0x8a95
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2190
nop
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
cmpq $0x0, 0x28(%rdi)
je 0x4b75
movq %rdx, %rbx
movq %rdi, %r15
movq (%rdi), %rdx
testq %rdx, %rdx
je 0x4b8e
movq %rsi, %r14
movq 0x7559(%rip), %r12      # 0xbff8
movq (%r12), %rdi
movq 0x48(%r15), %rcx
leaq 0x406a(%rip), %rsi      # 0x8b18
xorl %eax, %eax
callq 0x2190
movq 0x28(%r15), %rdi
movq 0x30(%r15), %rsi
subq %rdi, %rsi
movq (%r12), %rcx
pushq $0x1
popq %rdx
callq 0x2250
movq (%r12), %rsi
leaq 0x4049(%rip), %rdi      # 0x8b20
callq 0x2130
testq %r14, %r14
je 0x4b58
subl 0x28(%r15), %r14d
leal -0x2(%r14), %ebp
cmpl $0x3, %r14d
cmovll %r14d, %ebp
leaq 0x3d5c(%rip), %r15      # 0x8854
testl %ebp, %ebp
jle 0x4b0c
movq (%r12), %rsi
movq %r15, %rdi
callq 0x2130
decl %ebp
jmp 0x4af8
cmpl $0x3, %r14d
jl 0x4b22
movq (%r12), %rsi
leaq 0x4005(%rip), %rdi      # 0x8b22
callq 0x2130
movq (%r12), %rsi
leaq 0x3ff8(%rip), %rdi      # 0x8b25
callq 0x2130
cmpl $0x2, %r14d
jg 0x4b48
movq (%r12), %rsi
leaq 0x3fdf(%rip), %rdi      # 0x8b22
callq 0x2130
movq (%r12), %rsi
leaq 0x3fcd(%rip), %rdi      # 0x8b20
callq 0x2130
movq (%r12), %rdi
leaq 0x3fc4(%rip), %rsi      # 0x8b27
movq %rbx, %rdx
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2190
leaq 0x3f2d(%rip), %rdi      # 0x8aa9
leaq 0x3f3b(%rip), %rsi      # 0x8abe
leaq 0x3f3c(%rip), %rcx      # 0x8ac6
pushq $0x16
jmp 0x4ba5
leaq 0x3f72(%rip), %rdi      # 0x8b07
leaq 0x3f22(%rip), %rsi      # 0x8abe
leaq 0x3f23(%rip), %rcx      # 0x8ac6
pushq $0x19
popq %rdx
callq 0x2120
// File: /workspace/github_c_makefile_star2_O2/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 0x4d1f
movq 0x28(%rdi), %rdx
testq %rdx, %rdx
je 0x4ce9
movq 0x20(%rdi), %rcx
movq 0x30(%rdi), %rax
cmpq %rdx, %rax
setae %sil
cmpq %rcx, %rdx
sete %r8b
orb %sil, %r8b
cmpb $0x1, %r8b
jne 0x4d38
movq %rax, 0x28(%rdi)
cmpq %rcx, %rax
jae 0x4cd4
movzbl (%rax), %esi
incq %rax
cmpl $0xa, %esi
je 0x4ccc
cmpl $0xd, %esi
jne 0x4ca3
cmpq %rcx, %rax
jae 0x4ccc
leaq 0x1(%rax), %rsi
cmpb $0xa, (%rax)
cmoveq %rsi, %rax
movq %rax, 0x28(%rdi)
incq 0x48(%rdi)
cmpq %rcx, %rax
jb 0x4cf9
movq %rdx, 0x28(%rdi)
decq 0x48(%rdi)
movq %rcx, 0x38(%rdi)
xorl %eax, %eax
popq %rcx
retq
movq %rax, 0x28(%rdi)
movq $0x1, 0x48(%rdi)
movq 0x20(%rdi), %rcx
movq %rax, 0x40(%rdi)
movq %rax, 0x38(%rdi)
movq %rax, %rdx
movq %rdx, 0x30(%rdi)
cmpq %rcx, %rdx
jae 0x4ce7
movzbl (%rdx), %esi
cmpl $0xa, %esi
je 0x4ce7
cmpl $0xd, %esi
je 0x4ce7
incq %rdx
jmp 0x4d04
leaq 0x3e19(%rip), %rdi      # 0x8b3f
leaq 0x3d91(%rip), %rsi      # 0x8abe
leaq 0x3e20(%rip), %rcx      # 0x8b54
pushq $0x49
jmp 0x4d4f
leaq 0x3e3a(%rip), %rdi      # 0x8b79
leaq 0x3d78(%rip), %rsi      # 0x8abe
leaq 0x3e07(%rip), %rcx      # 0x8b54
pushq $0x4d
popq %rdx
callq 0x2120
// File: /workspace/github_c_makefile_star2_O2/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 0x4d80
movq 0x30(%rdi), %rcx
cmpq %rcx, %rax
jae 0x4d7e
movzbl (%rax), %edx
cmpl $0x20, %edx
je 0x4d75
cmpl $0x9, %edx
jne 0x4d7e
incq %rax
movq %rax, 0x40(%rdi)
jmp 0x4d63
popq %rcx
retq
leaq 0x3e34(%rip), %rdi      # 0x8bbb
leaq 0x3d30(%rip), %rsi      # 0x8abe
leaq 0x3e3b(%rip), %rcx      # 0x8bd0
movl $0x82, %edx
callq 0x2120
// File: /workspace/github_c_makefile_star2_O2/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 0x4d55
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 0x4dda
testq %rbx, %rbx
je 0x4ddd
movq %rcx, (%rbx)
jmp 0x4ddd
pushq $0x1
popq %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x4e7a
movq %r14, (%rbx)
movq %rsp, %rsi
movl %eax, %edi
callq 0x2270
testl %eax, %eax
jne 0x4eac
movq 0x30(%rsp), %rsi
testq %rsi, %rsi
jle 0x4ecb
cmpq $0x800001, %rsi         # imm = 0x800001
jae 0x4ee8
movq %rsi, 0x10(%rbx)
movl 0x8(%rbx), %r8d
xorl %r15d, %r15d
pushq $0x1
popq %rcx
xorl %edi, %edi
movl %ecx, %edx
xorl %r9d, %r9d
callq 0x20e0
movq %rax, 0x18(%rbx)
testq %rax, %rax
je 0x4f03
addq 0x10(%rbx), %rax
movq %rax, 0x20(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rbx)
movups %xmm0, 0x38(%rbx)
andq $0x0, 0x48(%rbx)
jmp 0x4f3c
movq 0x7177(%rip), %rax      # 0xbff8
movq (%rax), %rbx
callq 0x2060
movl (%rax), %edi
callq 0x2260
leaq 0x3d61(%rip), %rsi      # 0x8bf8
movq %rbx, %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x2190
jmp 0x4f38
movq 0x7145(%rip), %rax      # 0xbff8
movq (%rax), %r15
callq 0x2060
movl (%rax), %edi
callq 0x2260
leaq 0x3d44(%rip), %rsi      # 0x8c0d
jmp 0x4f20
movq 0x7126(%rip), %rax      # 0xbff8
movq (%rax), %rdi
leaq 0x3d43(%rip), %rsi      # 0x8c1f
movq %r14, %rdx
xorl %eax, %eax
callq 0x2190
jmp 0x4f30
movq 0x7109(%rip), %rax      # 0xbff8
movq (%rax), %rdi
leaq 0x3d39(%rip), %rsi      # 0x8c32
movl $0x800000, %ecx         # imm = 0x800000
movq %r14, %rdx
jmp 0x4f29
movq 0x70ee(%rip), %rax      # 0xbff8
movq (%rax), %r15
callq 0x2060
movl (%rax), %edi
callq 0x2260
leaq 0x3d35(%rip), %rsi      # 0x8c55
movq %r15, %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x2190
movq %rbx, %rdi
callq 0x4f4c
pushq $-0x1
popq %r15
movl %r15d, %eax
addq $0x90, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x4fb1
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x4f73
movq 0x10(%rbx), %rsi
callq 0x21f0
testl %eax, %eax
jne 0x4fd0
andq $0x0, 0x18(%rbx)
movl 0x8(%rbx), %edi
testl %edi, %edi
je 0x4f8f
callq 0x2140
testl %eax, %eax
jne 0x4f8f
andl $0x0, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x7062(%rip), %rax      # 0xbff8
movq (%rax), %r14
movq (%rbx), %rbx
callq 0x2060
movl (%rax), %edi
callq 0x2260
leaq 0x3d08(%rip), %rsi      # 0x8cb7
jmp 0x4ff0
leaq 0x3cb2(%rip), %rdi      # 0x8c6a
leaq 0x3aff(%rip), %rsi      # 0x8abe
leaq 0x3caf(%rip), %rcx      # 0x8c75
movl $0xd1, %edx
callq 0x2120
movq 0x7021(%rip), %rax      # 0xbff8
movq (%rax), %r14
movq (%rbx), %rbx
callq 0x2060
movl (%rax), %edi
callq 0x2260
leaq 0x3cb0(%rip), %rsi      # 0x8ca0
movq %r14, %rdi
movq %rbx, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x2190
callq 0x2050
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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 0x5039
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x2040
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x5027
callq 0x5056
leaq 0x18(%rbx), %rdi
callq 0x4f4c
movq %rbx, %rdi
popq %rbx
jmp 0x2040
leaq 0x3cb8(%rip), %rdi      # 0x8cf8
leaq 0x3cbc(%rip), %rsi      # 0x8d03
leaq 0x3cc7(%rip), %rcx      # 0x8d15
pushq $0x5b
popq %rdx
callq 0x2120
// File: /workspace/github_c_makefile_star2_O2/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 0x5067
callq 0x5056
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x5075
callq 0x5707
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x5083
callq 0x5721
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x5091
callq 0x5721
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x509f
callq 0x574f
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x50ad
callq 0x5721
movq %rbx, %rdi
popq %rbx
jmp 0x2040
// File: /workspace/github_c_makefile_star2_O2/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 0x5732
callq 0x5721
cmpl $0x1, 0x8(%rbx)
jne 0x5746
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x5746
callq 0x5721
movq %rbx, %rdi
popq %rbx
jmp 0x2040
// File: /workspace/github_c_makefile_star2_O2/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 0x5760
callq 0x574f
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x576e
callq 0x5721
movq %rbx, %rdi
popq %rbx
jmp 0x2040
// File: /workspace/github_c_makefile_star2_O2/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
xorl %r14d, %r14d
xorl %esi, %esi
callq 0x56c9
cmpq $0x1, %rax
je 0x580a
testq %rax, %rax
je 0x5839
movq %rbx, %rdi
callq 0x4c59
jmp 0x582a
movq %rbx, %rdi
callq 0x4c69
testq %rax, %rax
jne 0x582e
movq 0x38(%rbx), %rsi
leaq 0x365f(%rip), %rdx      # 0x8e81
movq %rbx, %rdi
callq 0x4a70
pushq $-0x1
popq %r14
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x3611(%rip), %rdi      # 0x8e51
leaq 0x34bc(%rip), %rsi      # 0x8d03
leaq 0x360f(%rip), %rcx      # 0x8e5d
movl $0x233, %edx            # imm = 0x233
callq 0x2120
// File: /workspace/github_c_makefile_star2_O2/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 0x57e4
testl %eax, %eax
je 0x5881
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 0x58b8
testq %rax, %rax
je 0x5872
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x5e14
testl %eax, %eax
je 0x58b3
movq %r15, %rdi
callq 0x5721
jmp 0x586f
movq %r15, %r12
jmp 0x5872
// File: /workspace/github_c_makefile_star2_O2/ieyasu[P]funit/parse_test_file.c
// Function: parse_end_sequence
static int parse_end_sequence(struct ParseState *ps, const char *kind,
                              const char *name, size_t namelen)
{
    char message[32] = "end ";
    char *tok;
    size_t len;

    strncpy(message + 4, kind, sizeof(message) - 4);
    if (expect_token(ps, "end", message))
        return -1;
    // expect kind
    tok = next_token(ps, &len);
    assert(tok != NULL);
    if (tok == END_OF_LINE) {
        syntax_error(ps);
        return -1;
    }
    if (!same_token(kind, strlen(kind), tok, len)) {
        parse_vfail(ps, ps->read_pos, "expected \"end %s\"", kind);
        return -1;
    }
    // check end name if given and present
    if (name) {
        tok = next_name(ps, &len);
        assert(tok != NULL);
        if (tok != END_OF_LINE && !same_token(name, namelen, tok, len)) {
            parse_vfail(ps, ps->read_pos, "mismatched %s name", kind);
            return -1;
        }
    }
    return expect_eol(ps);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
movaps 0x33cc(%rip), %xmm0     # 0x9200
leaq 0x14(%rsp), %rdi
movaps %xmm0, -0x4(%rdi)
pushq $0x1c
popq %rdx
callq 0x2070
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x56c9
cmpq $0x1, %rax
je 0x5f08
testq %rax, %rax
je 0x5f5d
movq 0x8(%rsp), %rcx
leaq 0x2d46(%rip), %rdi      # 0x8bb7
pushq $0x3
popq %rsi
movq %rax, %rdx
callq 0x56d5
testl %eax, %eax
je 0x5f08
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x56c9
cmpq $0x1, %rax
je 0x5f33
movq %rax, %r13
testq %rax, %rax
je 0x5f7c
movq %r14, %rdi
callq 0x20d0
movq 0x8(%rsp), %rcx
movq %r14, %rdi
movq %rax, %rsi
movq %r13, %rdx
callq 0x56d5
testl %eax, %eax
je 0x5f3d
testq %r12, %r12
je 0x5efe
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x5fba
cmpq $0x1, %rax
je 0x5efe
testq %rax, %rax
je 0x5f9b
movq 0x8(%rsp), %rcx
movq %r12, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x56d5
testl %eax, %eax
je 0x5f50
movq %rbx, %rdi
callq 0x57e4
jmp 0x5f25
movq 0x38(%rbx), %rsi
leaq 0x32dc(%rip), %rdx      # 0x91ef
leaq 0x10(%rsp), %rcx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4bab
pushq $-0x1
popq %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rbx, %rdi
callq 0x4c59
jmp 0x5f22
movq 0x38(%rbx), %rsi
leaq 0x3240(%rip), %rdx      # 0x9188
movq %rbx, %rdi
movq %r14, %rcx
jmp 0x5f1b
movq 0x38(%rbx), %rsi
leaq 0x323f(%rip), %rdx      # 0x919a
jmp 0x5f48
leaq 0x2eed(%rip), %rdi      # 0x8e51
leaq 0x2d98(%rip), %rsi      # 0x8d03
leaq 0x323b(%rip), %rcx      # 0x91ad
movl $0x246, %edx            # imm = 0x246
callq 0x2120
leaq 0x2ece(%rip), %rdi      # 0x8e51
leaq 0x2d79(%rip), %rsi      # 0x8d03
leaq 0x31a7(%rip), %rcx      # 0x9138
movl $0x265, %edx            # imm = 0x265
callq 0x2120
leaq 0x2eaf(%rip), %rdi      # 0x8e51
leaq 0x2d5a(%rip), %rsi      # 0x8d03
leaq 0x3188(%rip), %rcx      # 0x9138
movl $0x271, %edx            # imm = 0x271
callq 0x2120
// File: /workspace/github_c_makefile_star2_O2/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
movabsq $0x200002400, %rdx      # imm = 0x200002400
cmpq %rax, %rcx
jae 0x5ff5
movzbl (%rcx), %esi
cmpq $0x21, %rsi
ja 0x5fec
btq %rsi, %rdx
jb 0x5ff5
incq %rcx
movq %rcx, 0x40(%rdi)
jmp 0x5fd8
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x602d
movq 0x30(%rdi), %rcx
incq %rax
movq %rax, 0x40(%rdi)
cmpq %rcx, %rax
jae 0x602d
movzbl (%rax), %edx
cmpl $0xa, %edx
je 0x602d
cmpl $0xd, %edx
je 0x602d
cmpl $0x21, %edx
je 0x602d
incq %rax
cmpl $0x22, %edx
jne 0x6006
movq %rax, 0x40(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
xorl %r13d, %r13d
cmpq %r13, %rbx
je 0x6081
movsbq (%r15,%r13), %rbp
callq 0x2290
movq (%rax), %rax
incq %r13
cmpl %ebp, (%rax,%rbp,4)
je 0x6048
leaq 0x2fca(%rip), %rdi      # 0x9033
leaq 0x2c93(%rip), %rsi      # 0x8d03
leaq 0x2f84(%rip), %rcx      # 0x8ffb
movl $0xc4, %edx
callq 0x2120
xorl %r13d, %r13d
xorl %ebp, %ebp
cmpq %rbp, %r12
je 0x60b4
callq 0x2290
movq (%rax), %rax
movsbq (%r14,%rbp), %rcx
movsbl (%r15,%r13), %edx
cmpl %edx, (%rax,%rcx,4)
jne 0x60ac
incq %r13
cmpq %rbx, %r13
jne 0x60af
jmp 0x60b8
xorl %r13d, %r13d
incq %rbp
jmp 0x6086
xorl %eax, %eax
jmp 0x60c2
subq %rbx, %r14
leaq (%r14,%rbp), %rax
incq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x6366
movl %esi, %ebp
movq %rdi, %rbx
incq %rax
movq %rax, 0x40(%rdi)
callq 0x4d55
movq 0x40(%rbx), %rax
cmpq 0x30(%rbx), %rax
jae 0x6316
leaq 0x2e14(%rip), %rdx      # 0x911d
movq %rbx, %rdi
movq %rax, %rsi
callq 0x4a70
jmp 0x635f
cmpq 0x20(%rbx), %rax
jae 0x6357
movq 0x38(%rbx), %r14
movq %rbx, %rdi
callq 0x4c69
testq %rax, %rax
je 0x6357
movq %r14, 0x38(%rbx)
movq %rbx, %rdi
callq 0x4d55
movq 0x40(%rbx), %rax
movzbl (%rax), %ecx
cmpl $0x21, %ecx
je 0x6316
cmpl $0x26, %ecx
jne 0x6361
testl %ebp, %ebp
je 0x6361
incq %rax
movq %rax, 0x40(%rbx)
jmp 0x6361
movq %rbx, %rdi
callq 0x4c59
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x2d64(%rip), %rdi      # 0x90d1
leaq 0x298f(%rip), %rsi      # 0x8d03
leaq 0x2d6b(%rip), %rcx      # 0x90e6
movl $0xd7, %edx
callq 0x2120
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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 0x6422
callq 0x2060
movl (%rax), %edi
xorl %ebp, %ebp
cmpl $0x2, %edi
je 0x642d
movq 0x5bf9(%rip), %rax      # 0xbff8
movq (%rax), %r14
callq 0x2260
leaq 0x2e12(%rip), %rsi      # 0x9220
xorl %ebp, %ebp
movq %r14, %rdi
movq %rbx, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x2190
jmp 0x642d
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_O2/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
pushq $0x2e
popq %rsi
callq 0x2110
testq %rax, %rax
je 0x646b
movq %rax, %r15
movq %rax, %rdi
movq %r12, %rsi
callq 0x2180
testl %eax, %eax
je 0x64a8
movq %r14, %rdi
callq 0x20d0
movq %rax, %r15
movq %rbx, %rdi
callq 0x20d0
addq %r15, %rax
cmpq $0x1000, %rax           # imm = 0x1000
ja 0x64f8
leaq 0x7d70(%rip), %r15      # 0xe200
movq %r15, %rdi
movq %r14, %rsi
callq 0x2090
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2230
jmp 0x64e1
subq %r14, %r15
movq %rbx, %rdi
callq 0x20d0
addq %r15, %rax
cmpq $0x1000, %rax           # imm = 0x1000
ja 0x64f8
leaq 0x7d3b(%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 0x7d18(%rip), %rdi      # 0xe200
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x63bb
movq 0x5af9(%rip), %rax      # 0xbff8
movq (%rax), %rdi
leaq 0x2d2f(%rip), %rsi      # 0x9238
movq %r14, %rdx
xorl %eax, %eax
callq 0x2190
callq 0x2050
// File: /workspace/github_c_makefile_star2_O2/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 0x6578
movq %rdi, %rbx
cmpq %rax, %rsi
jae 0x6568
addq %rsi, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x655a
movq (%rbx), %rdi
callq 0x21e0
movq %rax, (%rbx)
testq %rax, %rax
je 0x657a
popq %rbx
retq
callq 0x2050
// File: /workspace/github_c_makefile_star2_O2/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_6/exercise_6_01/count_c_keywords.c
// Function: main
int main(void)
{
  int n;
  char word[MAX_WORD_LEN];

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

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

  return EXIT_SUCCESS;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rsp, %r14
pushq $0x64
popq %rbp
leaq 0x2ebd(%rip), %rbx      # 0x4050
pushq $0x21
popq %r15
movq %r14, %rdi
movl %ebp, %esi
callq 0x1216
cmpl $-0x1, %eax
je 0x11d8
callq 0x1070
movq (%rax), %rax
movsbq (%rsp), %rcx
testb $0x4, 0x1(%rax,%rcx,2)
je 0x1197
movq %r14, %rdi
movq %rbx, %rsi
movl %r15d, %edx
callq 0x12e1
testl %eax, %eax
js 0x1197
movl %eax, %eax
shlq $0x4, %rax
incl 0x8(%rax,%rbx)
jmp 0x1197
pushq $0x8
popq %r15
leaq 0xee7(%rip), %r14       # 0x20ca
cmpq $0x218, %r15            # imm = 0x218
je 0x1209
movl (%r15,%rbx), %esi
testl %esi, %esi
je 0x1203
movq -0x8(%r15,%rbx), %rdx
movq %r14, %rdi
xorl %eax, %eax
callq 0x1030
addq $0x10, %r15
jmp 0x11e3
xorl %eax, %eax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_6/exercise_6_01/count_c_keywords.c
// Function: bin_search
int bin_search(char *word, struct key arr[], int arr_len)
{
  int low = 0;
  int high = arr_len - 1;
  int mid;

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

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

  return -1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %r12
xorl %ebx, %ebx
leal -0x1(%r15), %ebp
cmpl %r15d, %ebx
jge 0x132d
leal (%rbx,%rbp), %r13d
shrl %r13d
movq %r13, %rax
shlq $0x4, %rax
movq (%r14,%rax), %rsi
movq %r12, %rdi
callq 0x1040
testl %eax, %eax
js 0x1328
je 0x1332
incl %r13d
movl %r13d, %ebx
jmp 0x12fb
movl %r13d, %r15d
jmp 0x12f7
pushq $-0x1
popq %rax
jmp 0x1335
movl %r13d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ThomasMadappattu[P]Sandmacs/basic.c
// Function: gotoline
int gotoline (int f, int n)
{
  if (n < 1)		       /* if a bogus argument...then leave */
    return (FALSE);

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

// Assembly:
testl %esi, %esi
jle 0x2447
pushq %rax
leaq 0xa41d(%rip), %rax      # 0xc838
movq (%rax), %rax
movq 0x28(%rax), %rax
movq (%rax), %rax
leaq 0xa41c(%rip), %rcx      # 0xc848
movq (%rcx), %rcx
movq %rax, 0x18(%rcx)
andq $0x0, 0x20(%rcx)
decl %esi
callq 0x244a
pushq $0x1
popq %rax
addq $0x8, %rsp
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/ThomasMadappattu[P]Sandmacs/basic.c
// Function: gotobop
int gotobop (int f, int n)
{
  int suc;			/* success of last backchar */

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

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

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebx
testl %esi, %esi
js 0x2643
pushq $0x1
popq %rbp
leaq 0xa28b(%rip), %r15      # 0xc848
leaq 0xa274(%rip), %r12      # 0xc838
testl %ebx, %ebx
jle 0x263a
decl %ebx
xorl %edi, %edi
movl %ebp, %esi
callq 0x2357
movl %eax, %r14d
xorl %eax, %eax
callq 0x74a9
testl %eax, %eax
jne 0x25e6
testl %r14d, %r14d
jne 0x25ca
movq (%r15), %rax
andq $0x0, 0x20(%rax)
movq (%r12), %rcx
movq 0x28(%rcx), %rcx
movq 0x18(%rax), %rsi
movq 0x8(%rsi), %rdx
cmpq %rcx, %rdx
je 0x2620
cmpl $0x0, 0x14(%rsi)
je 0x2620
movzbl 0x18(%rsi), %esi
cmpl $0x9, %esi
je 0x2620
cmpl $0x20, %esi
je 0x2620
movq %rdx, 0x18(%rax)
movq %rdx, %rsi
jmp 0x25fa
xorl %edi, %edi
movl %ebp, %esi
callq 0x23b3
testl %eax, %eax
je 0x25c4
xorl %eax, %eax
callq 0x74a9
testl %eax, %eax
je 0x2620
jmp 0x25c4
movq (%r15), %rax
orb $0x2, 0x3b(%rax)
jmp 0x264c
negl %ebx
movl %ebx, %esi
callq 0x2658
pushq $0x1
popq %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq