LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/ieyasu[P]funit/build_rule.c
// Function: have_thing
static int have_thing(char **things, size_t n_things, const char *thing)
{
    for (size_t i = 0; i < n_things; i++) {
        if (!strcmp(things[i], thing)) {
            return TRUE;
        }
    }
    return FALSE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x37d9
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x20(%rbp), %rsi
callq 0x2190
cmpl $0x0, %eax
jne 0x37c9
movl $0x1, -0x4(%rbp)
jmp 0x37e0
jmp 0x37cb
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x379c
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ieyasu[P]funit/build_rule.c
// Function: expand_mods_with
static void expand_mods_with(struct StringBuffer *sb,
                             const struct TestFile *tf,
                             const char *ext)
{
    // count modules and allocate array to keep track of already appended mods
    size_t n_mods = 0;
    struct TestSet *set = tf->sets;
    while (set) {
        n_mods += set->n_mods;
        set = set->next;
    }

    if (n_mods == 0) return; // no modules - done!

    char **mods = NEWA(char *, n_mods);

    n_mods = 0; // haven't added any modules yet
    for (set = tf->sets; set != NULL; set = set->next) {
        for (struct TestModule *mod = set->mods; mod!=NULL; mod = mod->next) {
            if (!have_thing(mods, n_mods, mod->name)) {
                mods[n_mods++] = mod->name;
                sb_add_nstr(sb, mod->name, mod->len);
                if (ext) sb_add_str(sb, ext);
                sb_add_char(sb, ' ');
            }
        }
    }
    sb->len--; // remove trailing space

    free(mods);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x383c
movq -0x28(%rbp), %rax
movq 0x40(%rax), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x3818
cmpq $0x0, -0x20(%rbp)
jne 0x3848
jmp 0x3940
movq -0x20(%rbp), %rdi
shlq $0x3, %rdi
callq 0x21e0
movq %rax, -0x30(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x3927
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x3915
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rdx
callq 0x3780
cmpl $0x0, %eax
jne 0x3903
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, -0x20(%rbp)
movq %rdx, (%rax,%rcx,8)
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x38(%rbp), %rax
movq 0x18(%rax), %rdx
callq 0x9420
cmpq $0x0, -0x18(%rbp)
je 0x38f5
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x9480
movq -0x8(%rbp), %rdi
movl $0x20, %esi
callq 0x93d0
jmp 0x3905
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x3884
jmp 0x3917
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x386d
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x10(%rax)
movq -0x30(%rbp), %rdi
callq 0x2040
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ieyasu[P]funit/build_rule.c
// Function: len_without_ext
static size_t len_without_ext(const char *s, const char *ext, size_t extlen,
                              const char *what, const char *for_)
{
    size_t len = strlen(s);
    if (!strcmp(s + len - extlen, ext)) {
        len -= extlen;
    } else {
        fprintf(stderr, "Warning: %s '%s' is missing the %s extension '%s'\n",
                what, s, for_, ext);
    }
    return len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x20d0
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
addq -0x30(%rbp), %rdi
xorl %eax, %eax
subq -0x18(%rbp), %rax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x2190
cmpl $0x0, %eax
jne 0x39a9
movq -0x18(%rbp), %rcx
movq -0x30(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x30(%rbp)
jmp 0x39d1
movq 0xb648(%rip), %rax      # 0xeff8
movq (%rax), %rdi
movq -0x20(%rbp), %rdx
movq -0x8(%rbp), %rcx
movq -0x28(%rbp), %r8
movq -0x10(%rbp), %r9
leaq 0x6db0(%rip), %rsi      # 0xa77a
movb $0x0, %al
callq 0x21a0
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ieyasu[P]funit/build_rule.c
// Function: ensure_fragments
static void ensure_fragments(struct BRFragments *f)
{
    if (f->cap >= f->n + 1) return;

    f->cap += 2; // probably okay to grow slowly
    f->frags = realloc(f->frags, f->cap * sizeof(struct BRFragment));
    if (!f->frags) abort(); // XXX or handle allocation better?
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
addq $0x1, %rcx
cmpq %rcx, %rax
jb 0x3a07
jmp 0x3a48
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x2, %rcx
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
shlq $0x4, %rsi
callq 0x2200
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x3a48
callq 0x2050
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ieyasu[P]funit/config.c
// Function: read_config
int read_config(struct Config *conf)
{
    char config_path[PATH_MAX + 1];
    struct ParseState ps;
    int r;

    memset(conf, 0, sizeof(struct Config));

    if (find_config_file(config_path, &ps)) {
        fprintf(stderr, "FUnit: warning: config file not found\n");
        r = 0;
    } else {
        r = parse_config(&ps, conf);
        close_parse_file(&ps);
    }

    if (r == 0) {
        set_defaults(conf);
    }

    return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1070, %rsp           # imm = 0x1070
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x38, %edx
callq 0x2140
leaq -0x1010(%rbp), %rdi
leaq -0x1060(%rbp), %rsi
callq 0x3af0
cmpl $0x0, %eax
je 0x3aab
movq 0xb56a(%rip), %rax      # 0xeff8
movq (%rax), %rdi
leaq 0x6d15(%rip), %rsi      # 0xa7ad
movb $0x0, %al
callq 0x21a0
movl $0x0, -0x1064(%rbp)
jmp 0x3acd
movq -0x8(%rbp), %rsi
leaq -0x1060(%rbp), %rdi
callq 0x3c40
movl %eax, -0x1064(%rbp)
leaq -0x1060(%rbp), %rdi
callq 0x6cc0
cmpl $0x0, -0x1064(%rbp)
jne 0x3adf
movq -0x8(%rbp), %rdi
callq 0x3d10
movl -0x1064(%rbp), %eax
addq $0x1070, %rsp           # imm = 0x1070
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ieyasu[P]funit/config.c
// Function: find_config_file
static int find_config_file(char *buf, struct ParseState *ps)
{
    // try current directory
    strcpy(buf, ".funit");
    if (!try_open_file(buf, ps))
        return 0;

    // try $HOME
    char *h = getenv("HOME");
    if (h) {
        size_t hlen = strlen(h);
        if (hlen > PATH_MAX - 7) {
            fprintf(stderr, "Warning: value for 'HOME' environment variable is too long\n");
        } else {
            strcpy(buf, h);
            if (buf[hlen-1] != '/') {
                buf[hlen] = '/';
                hlen++;
            }
            strcpy(buf+hlen, ".funit");
            if (!try_open_file(buf, ps))
                return 0;
        }
    } else {
        fprintf(stderr, "Warning: environment variable 'HOME' not set\n");
    }

    // try /etc/funitrc
    strcpy(buf, "/etc/funitrc");
    if (!try_open_file(buf, ps))
        return 0;

    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x6d01(%rip), %rsi      # 0xa80c
callq 0x2090
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3ea0
cmpl $0x0, %eax
jne 0x3b2e
movl $0x0, -0x4(%rbp)
jmp 0x3c31
leaq 0x6cde(%rip), %rdi      # 0xa813
callq 0x2030
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x3be7
movq -0x20(%rbp), %rdi
callq 0x20d0
movq %rax, -0x28(%rbp)
cmpq $0xff9, -0x28(%rbp)     # imm = 0xFF9
jbe 0x3b7a
movq 0xb491(%rip), %rax      # 0xeff8
movq (%rax), %rdi
leaq 0x6ca7(%rip), %rsi      # 0xa818
movb $0x0, %al
callq 0x21a0
jmp 0x3be5
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x2090
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2f, %eax
je 0x3bb4
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movb $0x2f, (%rax,%rcx)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
addq -0x28(%rbp), %rdi
leaq 0x6c49(%rip), %rsi      # 0xa80c
callq 0x2090
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3ea0
cmpl $0x0, %eax
jne 0x3be3
movl $0x0, -0x4(%rbp)
jmp 0x3c31
jmp 0x3be5
jmp 0x3bff
movq 0xb40a(%rip), %rax      # 0xeff8
movq (%rax), %rdi
leaq 0x6c5c(%rip), %rsi      # 0xa854
movb $0x0, %al
callq 0x21a0
movq -0x10(%rbp), %rdi
leaq 0x6c78(%rip), %rsi      # 0xa882
callq 0x2090
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3ea0
cmpl $0x0, %eax
jne 0x3c2a
movl $0x0, -0x4(%rbp)
jmp 0x3c31
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ieyasu[P]funit/config.c
// Function: parse_config
static int parse_config(struct ParseState *ps, struct Config *conf)
{
    while (next_line(ps)) {
        skip_next_ws(ps);
        char c = *ps->next_pos;
        switch (c) {
        case '\r':
        case '\n':
        case '#':
            continue; // start of comment or end of line
        default:
            // config keys always start with a letter
            if (c < 'A' || (c > 'Z' && c < 'a') || c > 'z') {
                syntax_error(ps);
                return -1;
            }
            break;
        }
        if (parse_config_setting(ps, conf)) {
            return -1;
        }
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x66b0
cmpq $0x0, %rax
je 0x3cf5
movq -0x10(%rbp), %rdi
callq 0x6920
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movb (%rax), %al
movb %al, -0x19(%rbp)
movsbl -0x19(%rbp), %eax
movl %eax, -0x20(%rbp)
subl $0xa, %eax
je 0x3c9b
jmp 0x3c87
movl -0x20(%rbp), %eax
subl $0xd, %eax
je 0x3c9b
jmp 0x3c91
movl -0x20(%rbp), %eax
subl $0x23, %eax
jne 0x3c9d
jmp 0x3c9b
jmp 0x3c50
movsbl -0x19(%rbp), %eax
cmpl $0x41, %eax
jl 0x3cc1
movsbl -0x19(%rbp), %eax
cmpl $0x5a, %eax
jle 0x3cb8
movsbl -0x19(%rbp), %eax
cmpl $0x61, %eax
jl 0x3cc1
movsbl -0x19(%rbp), %eax
cmpl $0x7a, %eax
jle 0x3cd3
movq -0x10(%rbp), %rdi
callq 0x6680
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3cfc
jmp 0x3cd5
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3f60
cmpl $0x0, %eax
je 0x3cf0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3cfc
jmp 0x3c50
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/config.c
// Function: set_defaults
static void set_defaults(struct Config *conf)
{
    if (!conf->build) {
        conf->build = fu_strdup("make {{EXE}}");
        conf->build_len = 12;
    } else {
        SELF_STRNDUP(conf->build);
    }
    conf->build_fragments = parse_build_rule(conf->build);

    if (!conf->fortran_ext) {
        conf->fortran_ext = fu_strdup(".F90");
        conf->fortran_ext_len = 4;
    } else {
        SELF_STRNDUP(conf->fortran_ext);
    }

    if (!conf->template_ext) {
        conf->template_ext = fu_strdup(".fun");
        conf->template_ext_len = 4;
    } else {
        SELF_STRNDUP(conf->template_ext);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x3d4a
leaq 0x6ced(%rip), %rdi      # 0xaa1a
callq 0x90c0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq $0xc, 0x20(%rax)
jmp 0x3d68
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x9070
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x2bf0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x3daf
leaq 0x6c96(%rip), %rdi      # 0xaa27
callq 0x90c0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x4, 0x28(%rax)
jmp 0x3dcf
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rsi
callq 0x9070
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x3dff
leaq 0x6c4b(%rip), %rdi      # 0xaa2c
callq 0x90c0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq $0x4, 0x30(%rax)
jmp 0x3e1f
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rsi
callq 0x9070
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ieyasu[P]funit/config.c
// Function: free_config
void free_config(struct Config *conf)
{
    assert(conf != NULL);

    free(conf->build);
    free_build_fragments(conf->build_fragments);
    free(conf->fortran_ext);
    free(conf->template_ext);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3e45
jmp 0x3e64
leaq 0x6988(%rip), %rdi      # 0xa7d4
leaq 0x698e(%rip), %rsi      # 0xa7e1
movl $0x11b, %edx            # imm = 0x11B
leaq 0x698b(%rip), %rcx      # 0xa7ea
callq 0x2120
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x2040
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3260
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2040
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x2040
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ieyasu[P]funit/config.c
// Function: try_open_file
static int try_open_file(const char *path, struct ParseState *ps)
{
    struct stat statbuf;
    if (stat(path, &statbuf)) {
        if (errno == ENOENT) {
            return -1;
        } else {
            fprintf(stderr, "error stat()ing '%s': %s\n",
                    path, strerror(errno));
            abort();
        }
    }
    if (statbuf.st_size <= 0) {
        return -1;
    }

    return open_file_for_parsing(path, ps);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x21b0
cmpl $0x0, %eax
je 0x3f27
callq 0x2060
cmpl $0x2, (%rax)
jne 0x3edb
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3f47
movq 0xb116(%rip), %rax      # 0xeff8
movq (%rax), %rax
movq %rax, -0xb8(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xb0(%rbp)
callq 0x2060
movl (%rax), %edi
callq 0x2280
movq -0xb8(%rbp), %rdi
movq -0xb0(%rbp), %rdx
movq %rax, %rcx
leaq 0x6974(%rip), %rsi      # 0xa88f
movb $0x0, %al
callq 0x21a0
callq 0x2050
cmpq $0x0, -0x78(%rbp)
jg 0x3f37
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3f47
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x6a60
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xc0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ieyasu[P]funit/config.c
// Function: key_end_finder
static void key_end_finder(struct ParseState *ps)
{
    while (ps->next_pos < ps->next_line_pos) {
        char c = *ps->next_pos;
        if (c < 'A' || (c > 'Z' && c < 'a' &&  c != '_') || c > 'z')
            return;
        ps->next_pos++;
    }
}

// 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 0x42f8
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movb (%rax), %al
movb %al, -0x9(%rbp)
movsbl -0x9(%rbp), %eax
cmpl $0x41, %eax
jl 0x42e4
movsbl -0x9(%rbp), %eax
cmpl $0x5a, %eax
jle 0x42db
movsbl -0x9(%rbp), %eax
cmpl $0x61, %eax
jge 0x42db
movsbl -0x9(%rbp), %eax
cmpl $0x5f, %eax
jne 0x42e4
movsbl -0x9(%rbp), %eax
cmpl $0x7a, %eax
jle 0x42e6
jmp 0x42f8
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x40(%rax)
jmp 0x4298
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ieyasu[P]funit/config.c
// Function: next_quoted_string
static char *next_quoted_string(struct ParseState *ps, size_t *len,
                                int *escapes)
{
    char quote_char = *ps->read_pos;
    assert(quote_char == '"' || quote_char == '\'');
    ps->next_pos = ++ps->read_pos;
    while (ps->next_pos < ps->next_line_pos) {
        if (*ps->next_pos == '\\' && (ps->next_pos[1] == '"' ||
                                      ps->next_pos[1] == '\'')) {
            *escapes = TRUE;
            ps->next_pos++; // skip the '\', *and* skip the quote below
        } else if (*ps->next_pos == quote_char) {
            *len = ps->next_pos - ps->read_pos;
            ps->next_pos++;
            return ps->read_pos;
        }
        ps->next_pos++;
    }
    parse_fail(ps, ps->next_pos, "expected close quote at end of string");
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movb (%rax), %al
movb %al, -0x21(%rbp)
movsbl -0x21(%rbp), %eax
cmpl $0x22, %eax
je 0x4333
movsbl -0x21(%rbp), %eax
cmpl $0x27, %eax
jne 0x4335
jmp 0x4354
leaq 0x6651(%rip), %rdi      # 0xa98d
leaq 0x649e(%rip), %rsi      # 0xa7e1
movl $0x5e, %edx
leaq 0x6666(%rip), %rcx      # 0xa9b5
callq 0x2120
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x38(%rax)
movq -0x10(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x30(%rcx), %rax
jae 0x4432
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movsbl (%rax), %eax
cmpl $0x5c, %eax
jne 0x43d0
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movsbl 0x1(%rax), %eax
cmpl $0x22, %eax
je 0x43b4
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movsbl 0x1(%rax), %eax
cmpl $0x27, %eax
jne 0x43d0
movq -0x20(%rbp), %rax
movl $0x1, (%rax)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x40(%rax)
jmp 0x441d
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movsbl (%rax), %eax
movsbl -0x21(%rbp), %ecx
cmpl %ecx, %eax
jne 0x441b
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 0x40(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x40(%rax)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x4452
jmp 0x441d
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x40(%rax)
jmp 0x436c
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rsi
leaq 0x65af(%rip), %rdx      # 0xa9f4
callq 0x63e0
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/config.c
// Function: value_end_finder
static void value_end_finder(struct ParseState *ps)
{
    while (ps->next_pos < ps->next_line_pos) {
        switch (*ps->next_pos) {
        case ' ':
        case '\t':
        case '#':
        case '\r':
        case '\n':
            return;
        }
        ps->next_pos++;
    }
}

// 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 0x44c4
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movsbl (%rax), %eax
movl %eax, -0xc(%rbp)
addl $-0x9, %eax
subl $0x2, %eax
jb 0x44b0
jmp 0x4492
movl -0xc(%rbp), %eax
subl $0xd, %eax
je 0x44b0
jmp 0x449c
movl -0xc(%rbp), %eax
subl $0x20, %eax
je 0x44b0
jmp 0x44a6
movl -0xc(%rbp), %eax
subl $0x23, %eax
jne 0x44b2
jmp 0x44b0
jmp 0x44c4
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x40(%rax)
jmp 0x4468
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ieyasu[P]funit/config.c
// Function: copy_escaped_string
static char *copy_escaped_string(const char *s, size_t len)
{
    char *buf = malloc(len);
    size_t srci = 0, desti = 0;
    while (srci < len) {
        if (s[srci] == '\\' && (s[srci + 1] == '"' || s[srci + 1] == '\'')) {
            srci++; // skip past backslash to just copy quote
        }
        buf[desti++] = s[srci++];
    }
    buf[desti] = '\0';
    return buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x21e0
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x4576
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x5c, %eax
jne 0x4548
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movsbl 0x1(%rax,%rcx), %eax
cmpl $0x22, %eax
je 0x453c
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movsbl 0x1(%rax,%rcx), %eax
cmpl $0x27, %eax
jne 0x4548
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb (%rax,%rcx), %dl
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, -0x28(%rbp)
movb %dl, (%rax,%rcx)
jmp 0x44fd
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ieyasu[P]funit/generate_code.c
// Function: generate_code_file
int generate_code_file(struct TestSet *set, FILE *file_out)
{
    // set file-wide out file pointer
    fout = file_out;

    // XXX look for this file and emit it if not present
    fputs(module_code, fout);

    int set_i = 0;
    if (generate_set(set, &set_i))
        return -1;
    set_i = 0;
    generate_main(set, &set_i);

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, 0xcce5(%rip)      # 0x11290
movq 0xccde(%rip), %rsi      # 0x11290
leaq 0x6527(%rip), %rdi      # 0xaae0
callq 0x2130
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
callq 0x4610
cmpl $0x0, %eax
je 0x45e0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x45fb
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
callq 0x47f0
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/generate_code.c
// Function: generate_main
static void generate_main(struct TestSet *file, int *set_i)
{
    fputs("\n\nprogram main\n", fout);
    fputs("  use funit\n\n",  fout);
    fputs("  call clear_stats\n", fout);
    generate_set_call(file, set_i);
    fputs("\n  call report_stats\n", fout);
    fprintf(fout, "end program main\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0xca89(%rip), %rsi      # 0x11290
leaq 0x74ea(%rip), %rdi      # 0xbcf8
callq 0x2130
movq 0xca76(%rip), %rsi      # 0x11290
leaq 0x74e7(%rip), %rdi      # 0xbd08
callq 0x2130
movq 0xca63(%rip), %rsi      # 0x11290
leaq 0x74e2(%rip), %rdi      # 0xbd16
callq 0x2130
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x6340
movq 0xca43(%rip), %rsi      # 0x11290
leaq 0x74d6(%rip), %rdi      # 0xbd2a
callq 0x2130
movq 0xca30(%rip), %rdi      # 0x11290
leaq 0x74d9(%rip), %rsi      # 0xbd40
movb $0x0, %al
callq 0x21a0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x48a2
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x4880
movq 0xc9e7(%rip), %rsi      # 0x11290
leaq 0x6b44(%rip), %rdi      # 0xb3f4
callq 0x2130
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rsi
movq 0xc9c4(%rip), %rcx      # 0x11290
movl $0x1, %edx
callq 0x2270
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jbe 0x4902
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rsi
movq 0xc998(%rip), %rcx      # 0x11290
movl $0x1, %edx
callq 0x2270
movq 0xc987(%rip), %rsi      # 0x11290
leaq 0x74e5(%rip), %rdi      # 0xbdf5
callq 0x2130
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ieyasu[P]funit/generate_code.c
// Function: generate_code
static int generate_code(struct Code *code, double tolerance)
{
    switch (code->type) {
    case FORTRAN_CODE:
        PRINT_CODE(code);
        break;
    case MACRO_CODE:
        if (generate_assert(code, tolerance))
            return -1;
        break;
    default: // arg code
        fprintf(stderr, "near %s:%li: bad code type %i in generate_code\n",
                test_set_file_name, code->lineno, (int)code->type);
        abort();
        break;
    }
    if (code->next)
        return generate_code(code->next, tolerance);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x1c(%rbp)
testl %eax, %eax
je 0x494b
jmp 0x4941
movl -0x1c(%rbp), %eax
subl $0x1, %eax
je 0x496e
jmp 0x498c
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
movq 0xc92e(%rip), %rcx      # 0x11290
movl $0x1, %edx
callq 0x2270
jmp 0x49c0
movq -0x10(%rbp), %rdi
movsd -0x18(%rbp), %xmm0
callq 0x4cc0
cmpl $0x0, %eax
je 0x498a
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x49e7
jmp 0x49c0
movq 0xa665(%rip), %rax      # 0xeff8
movq (%rax), %rdi
movq 0xc8fb(%rip), %rdx      # 0x11298
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
movl 0x8(%rax), %r8d
leaq 0x6a47(%rip), %rsi      # 0xb3fb
movb $0x0, %al
callq 0x21a0
callq 0x2050
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x49e0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movsd -0x18(%rbp), %xmm0
callq 0x4920
movl %eax, -0x4(%rbp)
jmp 0x49e7
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x4a5a
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x4a20
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq 0xc824(%rip), %rsi      # 0x11290
leaq 0x7382(%rip), %rdi      # 0xbdf5
callq 0x2130
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x4a98
movq 0xc806(%rip), %rdi      # 0x11290
leaq 0x709a(%rip), %rsi      # 0xbb2b
movb $0x0, %al
callq 0x21a0
movq 0xc7f1(%rip), %rdi      # 0x11290
movq -0x18(%rbp), %rax
movl (%rax), %edx
leaq 0x7093(%rip), %rsi      # 0xbb3f
movb $0x0, %al
callq 0x21a0
movq 0xc7d6(%rip), %rsi      # 0x11290
leaq 0x70b2(%rip), %rdi      # 0xbb73
callq 0x2130
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
movq 0xc7b3(%rip), %rcx      # 0x11290
movl $0x1, %edx
callq 0x2270
movq 0xc7a2(%rip), %rdi      # 0x11290
movq -0x20(%rbp), %rax
movl %eax, %edx
leaq 0x70aa(%rip), %rsi      # 0xbba5
movb $0x0, %al
callq 0x21a0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x4b20
movq 0xc77c(%rip), %rsi      # 0x11290
leaq 0x7092(%rip), %rdi      # 0xbbad
callq 0x2130
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ieyasu[P]funit/generate_code.c
// Function: generate_test
static int generate_test(struct TestCase *test, int *test_i, double tolerance)
{
    if (test->next)
        generate_test(test->next, test_i, tolerance);

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

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

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

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movsd %xmm0, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x4bc4
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
movsd -0x20(%rbp), %xmm0
callq 0x4b90
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq 0xc6ba(%rip), %rdi      # 0x11290
movq -0x18(%rbp), %rax
movl (%rax), %edx
leaq 0x7015(%rip), %rsi      # 0xbbf8
movb $0x0, %al
callq 0x21a0
movq 0xc69f(%rip), %rsi      # 0x11290
leaq 0x703a(%rip), %rdi      # 0xbc32
callq 0x2130
movq 0xc68c(%rip), %rsi      # 0x11290
leaq 0x703b(%rip), %rdi      # 0xbc46
callq 0x2130
movq 0xc679(%rip), %rsi      # 0x11290
leaq 0x7053(%rip), %rdi      # 0xbc71
callq 0x2130
movq -0x10(%rbp), %rax
cmpl $0x0, 0x18(%rax)
je 0x4c40
movq 0xc65c(%rip), %rsi      # 0x11290
leaq 0x7067(%rip), %rdi      # 0xbca2
callq 0x2130
movq 0xc649(%rip), %rsi      # 0x11290
leaq 0x71a7(%rip), %rdi      # 0xbdf5
callq 0x2130
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x4c80
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
movsd -0x20(%rbp), %xmm0
callq 0x4920
cmpl $0x0, %eax
je 0x4c7e
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4cb5
jmp 0x4c80
movq 0xc609(%rip), %rsi      # 0x11290
leaq 0x702d(%rip), %rdi      # 0xbcbb
callq 0x2130
movq 0xc5f6(%rip), %rdi      # 0x11290
movq -0x18(%rbp), %rax
movl (%rax), %edx
leaq 0x7031(%rip), %rsi      # 0xbcd8
movb $0x0, %al
callq 0x21a0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ieyasu[P]funit/generate_code.c
// Function: generate_assert
static int generate_assert(struct Code *macro, double tolerance)
{
    assert(macro->type == MACRO_CODE);

    switch (macro->u.m.type) {
    case ASSERT_TRUE:
        return generate_assert_true(macro);
    case ASSERT_FALSE:
        return generate_assert_false(macro);
    case ASSERT_EQUAL:
        return generate_assert_equal(macro);
    case ASSERT_NOT_EQUAL:
        return generate_assert_not_equal(macro);
    case ASSERT_EQUAL_WITH:
        return generate_assert_equal_with(macro, tolerance);
    case ASSERT_ARRAY_EQUAL:
        return generate_assert_array_equal(macro);
    case ASSERT_ARRAY_EQUAL_WITH:
        return generate_assert_array_equal_with(macro, tolerance);
    case FLUNK:
        return generate_flunk(macro);
    default:
        fprintf(stderr, "unknown assert type %i\n", macro->u.m.type);
        abort();
    }
    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x1, 0x8(%rax)
jne 0x4cdd
jmp 0x4cfc
leaq 0x6747(%rip), %rdi      # 0xb42b
leaq 0x675a(%rip), %rsi      # 0xb445
movl $0x211, %edx            # imm = 0x211
leaq 0x675e(%rip), %rcx      # 0xb455
callq 0x2120
movq -0x10(%rbp), %rax
movl 0x18(%rax), %eax
movq %rax, -0x20(%rbp)
subq $0x7, %rax
ja 0x4da5
movq -0x20(%rbp), %rax
leaq 0x5d24(%rip), %rcx      # 0xaa40
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rdi
callq 0x4de0
movl %eax, -0x4(%rbp)
jmp 0x4dc9
movq -0x10(%rbp), %rdi
callq 0x4f00
movl %eax, -0x4(%rbp)
jmp 0x4dc9
movq -0x10(%rbp), %rdi
callq 0x5020
movl %eax, -0x4(%rbp)
jmp 0x4dc9
movq -0x10(%rbp), %rdi
callq 0x51d0
movl %eax, -0x4(%rbp)
jmp 0x4dc9
movq -0x10(%rbp), %rdi
movsd -0x18(%rbp), %xmm0
callq 0x5380
movl %eax, -0x4(%rbp)
jmp 0x4dc9
movq -0x10(%rbp), %rdi
callq 0x5610
movl %eax, -0x4(%rbp)
jmp 0x4dc9
movq -0x10(%rbp), %rdi
movsd -0x18(%rbp), %xmm0
callq 0x5850
movl %eax, -0x4(%rbp)
jmp 0x4dc9
movq -0x10(%rbp), %rdi
callq 0x5ba0
movl %eax, -0x4(%rbp)
jmp 0x4dc9
movq 0xa24c(%rip), %rax      # 0xeff8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movl 0x18(%rax), %edx
leaq 0x66c3(%rip), %rsi      # 0xb480
movb $0x0, %al
callq 0x21a0
callq 0x2050
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ieyasu[P]funit/generate_code.c
// Function: generate_assert_true
static int generate_assert_true(struct Code *macro)
{
    struct Code *arg = macro->u.m.args;

    if (check_assert_args("assert_true", macro, arg, 1) != 1)
        return -1;

    fputs("! assert_true()\n", fout);
    fputs("    if (.not. (", fout);
    PRINT_CODE(arg);
    fputs(")) then\n", fout);
    fputs("      write(funit_message_,*) \"'", fout);
    print_macro_arg(arg);
    fputs("' is false\"\n", fout);
    fputs("      funit_passed_ = .false.\n", fout);
    fputs("      return\n", fout);
    fputs("    end if", fout);

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq 0x6691(%rip), %rdi      # 0xb498
movl $0x1, %ecx
callq 0x5c80
cmpl $0x1, %eax
je 0x4e22
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4eeb
movq 0xc467(%rip), %rsi      # 0x11290
leaq 0x6674(%rip), %rdi      # 0xb4a4
callq 0x2130
movq 0xc454(%rip), %rsi      # 0x11290
leaq 0x6672(%rip), %rdi      # 0xb4b5
callq 0x2130
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rsi
movq 0xc431(%rip), %rcx      # 0x11290
movl $0x1, %edx
callq 0x2270
movq 0xc420(%rip), %rsi      # 0x11290
leaq 0x6a58(%rip), %rdi      # 0xb8cf
callq 0x2130
movq 0xc40d(%rip), %rsi      # 0x11290
leaq 0x663b(%rip), %rdi      # 0xb4c5
callq 0x2130
movq -0x18(%rbp), %rdi
callq 0x5cc0
movq 0xc3f1(%rip), %rsi      # 0x11290
leaq 0x6640(%rip), %rdi      # 0xb4e6
callq 0x2130
movq 0xc3de(%rip), %rsi      # 0x11290
leaq 0x6ab2(%rip), %rdi      # 0xb96b
callq 0x2130
movq 0xc3cb(%rip), %rsi      # 0x11290
leaq 0x6ac0(%rip), %rdi      # 0xb98c
callq 0x2130
movq 0xc3b8(%rip), %rsi      # 0x11290
leaq 0x6614(%rip), %rdi      # 0xb4f3
callq 0x2130
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/generate_code.c
// Function: generate_assert_false
static int generate_assert_false(struct Code *macro)
{
    struct Code *arg = macro->u.m.args;

    if (check_assert_args("assert_false", macro, arg, 1) != 1)
        return -1;

    fputs("! assert_false()\n", fout);
    fputs("    if (", fout);
    PRINT_CODE(arg);
    fputs(") then\n", fout);
    fputs("      write(funit_message_,*) \"'", fout);
    print_macro_arg(arg);
    fputs("' is true\"\n", fout);
    fputs("      funit_passed_ = .false.\n", fout);
    fputs("      return\n", fout);
    fputs("    end if", fout);

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq 0x677c(%rip), %rdi      # 0xb6a3
movl $0x1, %ecx
callq 0x5c80
cmpl $0x1, %eax
je 0x4f42
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x500b
movq 0xc347(%rip), %rsi      # 0x11290
leaq 0x6760(%rip), %rdi      # 0xb6b0
callq 0x2130
movq 0xc334(%rip), %rsi      # 0x11290
leaq 0x694b(%rip), %rdi      # 0xb8ae
callq 0x2130
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rsi
movq 0xc311(%rip), %rcx      # 0x11290
movl $0x1, %edx
callq 0x2270
movq 0xc300(%rip), %rsi      # 0x11290
leaq 0x6939(%rip), %rdi      # 0xb8d0
callq 0x2130
movq 0xc2ed(%rip), %rsi      # 0x11290
leaq 0x651b(%rip), %rdi      # 0xb4c5
callq 0x2130
movq -0x18(%rbp), %rdi
callq 0x5cc0
movq 0xc2d1(%rip), %rsi      # 0x11290
leaq 0x66fc(%rip), %rdi      # 0xb6c2
callq 0x2130
movq 0xc2be(%rip), %rsi      # 0x11290
leaq 0x6992(%rip), %rdi      # 0xb96b
callq 0x2130
movq 0xc2ab(%rip), %rsi      # 0x11290
leaq 0x69a0(%rip), %rdi      # 0xb98c
callq 0x2130
movq 0xc298(%rip), %rsi      # 0x11290
leaq 0x64f4(%rip), %rdi      # 0xb4f3
callq 0x2130
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/generate_code.c
// Function: generate_assert_equal
static int generate_assert_equal(struct Code *macro)
{
    struct Code *a = macro->u.m.args, *b;

    if (check_assert_args("assert_equal", macro, a, 2) != 2)
        return -1;
    b = a->next;

    fputs("! assert_equal()\n", fout);
    fputs("    if ((", fout);
    PRINT_CODE(a);
    fputs(") /= (", fout);
    PRINT_CODE(b);
    fputs(")) then\n", fout);
    fputs("      write(funit_message_,*) \"'",fout);
    print_macro_arg(a);
    fputs("' (\", ", fout);
    PRINT_CODE(a);
    fputs(", &\n\") is not equal to '", fout);
    print_macro_arg(b);
    fputs("'\"\n", fout);
    fputs("      funit_passed_ = .false.\n", fout);
    fputs("      return\n", fout);
    fputs("    end if", fout);

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq 0x6687(%rip), %rdi      # 0xb6ce
movl $0x2, %ecx
callq 0x5c80
cmpl $0x2, %eax
je 0x5062
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x51ba
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq 0xc21c(%rip), %rsi      # 0x11290
leaq 0x6660(%rip), %rdi      # 0xb6db
callq 0x2130
movq 0xc209(%rip), %rsi      # 0x11290
leaq 0x665f(%rip), %rdi      # 0xb6ed
callq 0x2130
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rsi
movq 0xc1e6(%rip), %rcx      # 0x11290
movl $0x1, %edx
callq 0x2270
movq 0xc1d5(%rip), %rsi      # 0x11290
leaq 0x6635(%rip), %rdi      # 0xb6f7
callq 0x2130
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rsi
movq 0xc1b2(%rip), %rcx      # 0x11290
movl $0x1, %edx
callq 0x2270
movq 0xc1a1(%rip), %rsi      # 0x11290
leaq 0x67d9(%rip), %rdi      # 0xb8cf
callq 0x2130
movq 0xc18e(%rip), %rsi      # 0x11290
leaq 0x63bc(%rip), %rdi      # 0xb4c5
callq 0x2130
movq -0x18(%rbp), %rdi
callq 0x5cc0
movq 0xc172(%rip), %rsi      # 0x11290
leaq 0x65d9(%rip), %rdi      # 0xb6fe
callq 0x2130
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rsi
movq 0xc14f(%rip), %rcx      # 0x11290
movl $0x1, %edx
callq 0x2270
movq 0xc13e(%rip), %rsi      # 0x11290
leaq 0x65ac(%rip), %rdi      # 0xb705
callq 0x2130
movq -0x20(%rbp), %rdi
callq 0x5cc0
movq 0xc122(%rip), %rsi      # 0x11290
leaq 0x65a9(%rip), %rdi      # 0xb71e
callq 0x2130
movq 0xc10f(%rip), %rsi      # 0x11290
leaq 0x67e3(%rip), %rdi      # 0xb96b
callq 0x2130
movq 0xc0fc(%rip), %rsi      # 0x11290
leaq 0x67f1(%rip), %rdi      # 0xb98c
callq 0x2130
movq 0xc0e9(%rip), %rsi      # 0x11290
leaq 0x6345(%rip), %rdi      # 0xb4f3
callq 0x2130
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/generate_code.c
// Function: generate_assert_not_equal
static int generate_assert_not_equal(struct Code *macro)
{
    struct Code *a = macro->u.m.args, *b;

    if (check_assert_args("assert_not_equal", macro, a, 2) != 2)
        return -1;
    b = a->next;

    fputs("! assert_not_equal()\n", fout);
    fputs("    if ((", fout);
    PRINT_CODE(a);
    fputs(") == (", fout);
    PRINT_CODE(b);
    fputs(")) then\n", fout);
    fputs("      write(funit_message_,*) \"'",fout);
    print_macro_arg(a);
    fputs("' (\", ", fout);
    PRINT_CODE(a);
    fputs(", &\n\") is equal to '", fout);
    print_macro_arg(b);
    fputs("'\"\n", fout);
    fputs("      funit_passed_ = .false.\n", fout);
    fputs("      return\n", fout);
    fputs("    end if", fout);

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq 0x652b(%rip), %rdi      # 0xb722
movl $0x2, %ecx
callq 0x5c80
cmpl $0x2, %eax
je 0x5212
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x536a
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq 0xc06c(%rip), %rsi      # 0x11290
leaq 0x6508(%rip), %rdi      # 0xb733
callq 0x2130
movq 0xc059(%rip), %rsi      # 0x11290
leaq 0x64af(%rip), %rdi      # 0xb6ed
callq 0x2130
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rsi
movq 0xc036(%rip), %rcx      # 0x11290
movl $0x1, %edx
callq 0x2270
movq 0xc025(%rip), %rsi      # 0x11290
leaq 0x64d7(%rip), %rdi      # 0xb749
callq 0x2130
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rsi
movq 0xc002(%rip), %rcx      # 0x11290
movl $0x1, %edx
callq 0x2270
movq 0xbff1(%rip), %rsi      # 0x11290
leaq 0x6629(%rip), %rdi      # 0xb8cf
callq 0x2130
movq 0xbfde(%rip), %rsi      # 0x11290
leaq 0x620c(%rip), %rdi      # 0xb4c5
callq 0x2130
movq -0x18(%rbp), %rdi
callq 0x5cc0
movq 0xbfc2(%rip), %rsi      # 0x11290
leaq 0x6429(%rip), %rdi      # 0xb6fe
callq 0x2130
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rsi
movq 0xbf9f(%rip), %rcx      # 0x11290
movl $0x1, %edx
callq 0x2270
movq 0xbf8e(%rip), %rsi      # 0x11290
leaq 0x6447(%rip), %rdi      # 0xb750
callq 0x2130
movq -0x20(%rbp), %rdi
callq 0x5cc0
movq 0xbf72(%rip), %rsi      # 0x11290
leaq 0x63f9(%rip), %rdi      # 0xb71e
callq 0x2130
movq 0xbf5f(%rip), %rsi      # 0x11290
leaq 0x6633(%rip), %rdi      # 0xb96b
callq 0x2130
movq 0xbf4c(%rip), %rsi      # 0x11290
leaq 0x6641(%rip), %rdi      # 0xb98c
callq 0x2130
movq 0xbf39(%rip), %rsi      # 0x11290
leaq 0x6195(%rip), %rdi      # 0xb4f3
callq 0x2130
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/generate_code.c
// Function: generate_flunk
static int generate_flunk(struct Code *macro)
{
    struct Code *arg = macro->u.m.args;

    if (check_assert_args("flunk", macro, arg, 1) != 1)
        return -1;

    fputs("! flunk()\n", fout);
    fputs("    write(funit_message_,*) ", fout);
    PRINT_CODE(arg);
    fputs("\n", fout);
    fputs("    funit_passed_ = .false.\n", fout);
    fputs("    return\n", fout);

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq 0x5f36(%rip), %rdi      # 0xbafd
movl $0x1, %ecx
callq 0x5c80
cmpl $0x1, %eax
je 0x5be2
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5c69
movq 0xb6a7(%rip), %rsi      # 0x11290
leaq 0x5f13(%rip), %rdi      # 0xbb03
callq 0x2130
movq 0xb694(%rip), %rsi      # 0x11290
leaq 0x5f0b(%rip), %rdi      # 0xbb0e
callq 0x2130
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rsi
movq 0xb671(%rip), %rcx      # 0x11290
movl $0x1, %edx
callq 0x2270
movq 0xb660(%rip), %rsi      # 0x11290
leaq 0x61be(%rip), %rdi      # 0xbdf5
callq 0x2130
movq 0xb64d(%rip), %rsi      # 0x11290
leaq 0x5d23(%rip), %rdi      # 0xb96d
callq 0x2130
movq 0xb63a(%rip), %rsi      # 0x11290
leaq 0x5d31(%rip), %rdi      # 0xb98e
callq 0x2130
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/generate_code.c
// Function: find_line_continuation
static char *find_line_continuation(char *s, char *end, int in_string)
{
    char *line_start;

    assert(*s == '\n' || *s == '\r');

 skip_line:
    while (s < end) {
        switch (*s) {
        case '\r':
            if (*(s + 1) == '\n')
                s++;
            // fallthrough
        case '\n':
            s++;
            goto eol;
        default:
            break;
        }
        s++;
    }
 eol:
    line_start = s;

    // find first non-ws char
    while (s < end && (*s == ' ' || *s == '\t'))
        s++;
    switch (*s) {
    case '!':
        goto skip_line;
    case '&':
        if (in_string)
            return s + 1; // skip past whitespace eater
        // fallthrough
    default:
        return line_start;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
je 0x604b
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xd, %eax
jne 0x604d
jmp 0x606c
leaq 0x5604(%rip), %rdi      # 0xb658
leaq 0x53ea(%rip), %rsi      # 0xb445
movl $0x3e, %edx
leaq 0x560a(%rip), %rcx      # 0xb671
callq 0x2120
jmp 0x606e
jmp 0x6070
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x60ce
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0x2c(%rbp)
subl $0xa, %eax
je 0x60b0
jmp 0x608b
movl -0x2c(%rbp), %eax
subl $0xd, %eax
jne 0x60be
jmp 0x6095
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0xa, %eax
jne 0x60ae
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x60b0
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x60d0
jmp 0x60c0
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x6070
jmp 0x60d0
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq -0x18(%rbp), %rcx
movb %al, -0x2d(%rbp)
jae 0x610e
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x20, %ecx
movb %al, -0x2e(%rbp)
je 0x6108
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x9, %eax
sete %al
movb %al, -0x2e(%rbp)
movb -0x2e(%rbp), %al
movb %al, -0x2d(%rbp)
movb -0x2d(%rbp), %al
testb $0x1, %al
jne 0x6117
jmp 0x6125
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x60d8
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0x34(%rbp)
subl $0x21, %eax
je 0x6140
jmp 0x6136
movl -0x34(%rbp), %eax
subl $0x26, %eax
je 0x6145
jmp 0x615b
jmp 0x606e
cmpl $0x0, -0x1c(%rbp)
je 0x6159
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x6163
jmp 0x615b
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)