LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/nerves-project[P]nerves_initramfs/src/rootdisk.c
// Function: scan_for_partitions
static void scan_for_partitions(struct block_device_info *parent,
            struct block_device_info **infos)
{
    char base_dir[SHORT_PATH_MAX];
    snprintf(base_dir, sizeof(base_dir), "/sys/block/%s", parent->name);

    struct dirent **namelist;
    int n = scandir(base_dir,
                    &namelist,
                    directory_filter,
                    alphasort);
    int i;
    for (i = 0; i < n; i++) {
        dev_t dev = read_dev_file(base_dir, namelist[i]->d_name);
        unsigned int partition_number = read_partition_file(base_dir, namelist[i]->d_name);
        if (dev == 0 || partition_number == 0)
            continue;

        struct block_device_info *info = malloc(sizeof(struct block_device_info));
        info->next = *infos;
        info->name = strdup(namelist[i]->d_name);
        info->dev = dev;
        info->partition_number = partition_number;
        info->parent = parent;
        *infos = info;
    }

    if (n >= 0) {
        for (i = 0; i < n; i++)
            free(namelist[i]);
        free(namelist);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp            # imm = 0x140
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x110(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movl $0x100, %esi            # imm = 0x100
leaq 0x2291(%rip), %rdx      # 0xdcff
movb $0x0, %al
callq 0x21f0
leaq -0x110(%rbp), %rdi
leaq -0x118(%rbp), %rsi
leaq 0x196(%rip), %rdx       # 0xbc20
movq 0x5547(%rip), %rcx      # 0x10fd8
callq 0x2230
movl %eax, -0x11c(%rbp)
movl $0x0, -0x120(%rbp)
movl -0x120(%rbp), %eax
cmpl -0x11c(%rbp), %eax
jge 0xbbbf
leaq -0x110(%rbp), %rdi
movq -0x118(%rbp), %rax
movslq -0x120(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
addq $0x13, %rsi
callq 0xb960
movq %rax, -0x128(%rbp)
leaq -0x110(%rbp), %rdi
movq -0x118(%rbp), %rax
movslq -0x120(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
addq $0x13, %rsi
callq 0xbc60
movl %eax, -0x12c(%rbp)
cmpq $0x0, -0x128(%rbp)
je 0xbb1c
cmpl $0x0, -0x12c(%rbp)
jne 0xbb21
jmp 0xbbab
movl $0x28, %edi
callq 0x2330
movq %rax, -0x138(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x138(%rbp), %rax
movq %rcx, (%rax)
movq -0x118(%rbp), %rax
movslq -0x120(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
addq $0x13, %rdi
callq 0x2480
movq %rax, %rcx
movq -0x138(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x128(%rbp), %rcx
movq -0x138(%rbp), %rax
movq %rcx, 0x10(%rax)
movl -0x12c(%rbp), %ecx
movq -0x138(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x8(%rbp), %rcx
movq -0x138(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x138(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl -0x120(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x120(%rbp)
jmp 0xbaa6
cmpl $0x0, -0x11c(%rbp)
jl 0xbc14
movl $0x0, -0x120(%rbp)
movl -0x120(%rbp), %eax
cmpl -0x11c(%rbp), %eax
jge 0xbc08
movq -0x118(%rbp), %rax
movslq -0x120(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2040
movl -0x120(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x120(%rbp)
jmp 0xbbd2
movq -0x118(%rbp), %rdi
callq 0x2040
addq $0x140, %rsp            # imm = 0x140
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nerves-project[P]nerves_initramfs/src/rootdisk.c
// Function: read_partition_file
static unsigned int read_partition_file(const char *base, const char *name)
{
    char fname[SHORT_PATH_MAX];
    snprintf(fname, sizeof(fname), "%.64s/%.32s/partition", base, name);
    FILE *fp = fopen(fname, "r");
    if (!fp)
        return 0;

    unsigned int partition;
    if (fscanf(fp, "%u", &partition) != 1)
        partition = 0;

    fclose(fp);

    return partition;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq -0x120(%rbp), %rdi
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %r8
movl $0x100, %esi            # imm = 0x100
leaq 0x207f(%rip), %rdx      # 0xdd0d
movb $0x0, %al
callq 0x21f0
leaq -0x120(%rbp), %rdi
leaq 0x443(%rip), %rsi       # 0xc0e6
callq 0x23e0
movq %rax, -0x128(%rbp)
cmpq $0x0, -0x128(%rbp)
jne 0xbcc2
movl $0x0, -0x4(%rbp)
jmp 0xbd02
movq -0x128(%rbp), %rdi
leaq 0x202c(%rip), %rsi      # 0xdcfc
leaq -0x12c(%rbp), %rdx
movb $0x0, %al
callq 0x20b0
cmpl $0x1, %eax
je 0xbced
movl $0x0, -0x12c(%rbp)
movq -0x128(%rbp), %rdi
callq 0x2150
movl -0x12c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jaroslov[P]docoptc/./docopt.h
// Function: docopt_print_help
void docopt_print_help(struct docopt_parse_state* dS, int moreInfo)
{
    dS->entries->error  = DOCOPT_PRINTED_HELP;
    if (dS->entries->flags & DOCOPT_NO_HELP) return;
    if (moreInfo)
    {
        docopt_strip(&dS->entries->docstr, "\n");
        fprintf(stderr, "%.*s\n", DOCOPT_PR((&dS->entries->docstr)));
    }
    else
    {
        fprintf(stderr, "%s", "Usage:\n");
        docopt_strip(&dS->usage_section, "\n");
        fprintf(stderr, "%.*s\n", DOCOPT_PR((&dS->usage_section)));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl $0x5, (%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x18(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x7285
jmp 0x734e
cmpl $0x0, -0xc(%rbp)
je 0x72e4
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
addq $0x8, %rdi
leaq 0x4e27(%rip), %rsi      # 0xc0c5
callq 0x7360
movq 0x2bd4e(%rip), %rax     # 0x32ff8
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
addq $0x8, %rdi
callq 0x7420
movq -0x18(%rbp), %rdi
movl %eax, %edx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rcx
leaq 0x4d59(%rip), %rsi      # 0xc034
movb $0x0, %al
callq 0x70e0
jmp 0x734e
movq 0x2bd0d(%rip), %rax     # 0x32ff8
movq (%rax), %rdi
leaq 0x4d45(%rip), %rsi      # 0xc03a
leaq 0x4d41(%rip), %rdx      # 0xc03d
movb $0x0, %al
callq 0x70e0
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
leaq 0x4db3(%rip), %rsi      # 0xc0c5
callq 0x7360
movq 0x2bcda(%rip), %rax     # 0x32ff8
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
callq 0x7420
movq -0x20(%rbp), %rdi
movl %eax, %edx
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rcx
leaq 0x4ced(%rip), %rsi      # 0xc034
movb $0x0, %al
callq 0x70e0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jaroslov[P]docoptc/./docopt.h
// Function: docopt_get_section
static int docopt_get_section(struct docopt_parse_state* dS, regex_t* start, regex_t* stop, const char* fst, struct docopt_str* sec, int pidx, int qidx)
{
    if (dS->entries->error) return 1;
    if (regexec(start, fst, DOCOPT_NUM_PMATCHES, &dS->docopt_pmatches[0], 0))
        return 1;
    if (dS->docopt_pmatches[pidx].rm_so < 0) return 1;
    sec->fst    = dS->docopt_pmatches[pidx].rm_eo + fst;
    if (regexec(stop, sec->fst, DOCOPT_NUM_PMATCHES, &dS->docopt_pmatches[0], 0)) return 1;
    if (dS->docopt_pmatches[qidx].rm_so < 0) return 1;
    sec->lst    = dS->docopt_pmatches[qidx].rm_so + sec->fst;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movl %r9d, -0x34(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0x0, (%rax)
je 0x7bbc
movl $0x1, -0x4(%rbp)
jmp 0x7ca0
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x10(%rbp), %rcx
addq $0x188, %rcx            # imm = 0x188
movl $0x7, %edx
xorl %r8d, %r8d
callq 0x7100
cmpl $0x0, %eax
je 0x7bed
movl $0x1, -0x4(%rbp)
jmp 0x7ca0
movq -0x10(%rbp), %rax
movslq -0x34(%rbp), %rcx
cmpl $0x0, 0x188(%rax,%rcx,8)
jge 0x7c0b
movl $0x1, -0x4(%rbp)
jmp 0x7ca0
movq -0x10(%rbp), %rax
movslq -0x34(%rbp), %rcx
movl 0x18c(%rax,%rcx,8), %eax
movq -0x28(%rbp), %rcx
cltq
addq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rdi
movq -0x30(%rbp), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rcx
addq $0x188, %rcx            # imm = 0x188
movl $0x7, %edx
xorl %r8d, %r8d
callq 0x7100
cmpl $0x0, %eax
je 0x7c5b
movl $0x1, -0x4(%rbp)
jmp 0x7ca0
movq -0x10(%rbp), %rax
movslq 0x10(%rbp), %rcx
cmpl $0x0, 0x188(%rax,%rcx,8)
jge 0x7c76
movl $0x1, -0x4(%rbp)
jmp 0x7ca0
movq -0x10(%rbp), %rax
movslq 0x10(%rbp), %rcx
movl 0x188(%rax,%rcx,8), %eax
movq -0x30(%rbp), %rcx
movq (%rcx), %rcx
cltq
addq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jaroslov[P]docoptc/./docopt.h
// Function: docopt_parse_state_free
static void docopt_parse_state_free(struct docopt_parse_state* dS)
{
    if (!dS) return;
    if (dS->terms) free(dS->terms);
    dS->entries     = 0;
    regfree(&dS->re_pname), regfree(&dS->re_upper_argument), regfree(&dS->re_argument),
    regfree(&dS->re_default), regfree(&dS->re_optshort), regfree(&dS->re_long),
    regfree(&dS->re_repeat), regfree(&dS->re_reserved), regfree(&dS->re_usage_section_start),
    regfree(&dS->re_option_section_start), regfree(&dS->re_option_statement_start),
    regfree(&dS->re_naked_shorts), regfree(&dS->re_arged_shorts), regfree(&dS->re_usage_statement_start),
    regfree(&dS->re_optref); regfree(&dS->re_usage_section_start);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x8e28
jmp 0x8f4c
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x8e40
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x7030
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rdi
addq $0x1c0, %rdi            # imm = 0x1C0
callq 0x7060
movq -0x8(%rbp), %rdi
addq $0x200, %rdi            # imm = 0x200
callq 0x7060
movq -0x8(%rbp), %rdi
addq $0x240, %rdi            # imm = 0x240
callq 0x7060
movq -0x8(%rbp), %rdi
addq $0x280, %rdi            # imm = 0x280
callq 0x7060
movq -0x8(%rbp), %rdi
addq $0x2c0, %rdi            # imm = 0x2C0
callq 0x7060
movq -0x8(%rbp), %rdi
addq $0x300, %rdi            # imm = 0x300
callq 0x7060
movq -0x8(%rbp), %rdi
addq $0x340, %rdi            # imm = 0x340
callq 0x7060
movq -0x8(%rbp), %rdi
addq $0x380, %rdi            # imm = 0x380
callq 0x7060
movq -0x8(%rbp), %rdi
addq $0x3c0, %rdi            # imm = 0x3C0
callq 0x7060
movq -0x8(%rbp), %rdi
addq $0x480, %rdi            # imm = 0x480
callq 0x7060
movq -0x8(%rbp), %rdi
addq $0x4c0, %rdi            # imm = 0x4C0
callq 0x7060
movq -0x8(%rbp), %rdi
addq $0x500, %rdi            # imm = 0x500
callq 0x7060
movq -0x8(%rbp), %rdi
addq $0x540, %rdi            # imm = 0x540
callq 0x7060
movq -0x8(%rbp), %rdi
addq $0x440, %rdi            # imm = 0x440
callq 0x7060
movq -0x8(%rbp), %rdi
addq $0x580, %rdi            # imm = 0x580
callq 0x7060
movq -0x8(%rbp), %rdi
addq $0x3c0, %rdi            # imm = 0x3C0
callq 0x7060
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jaroslov[P]docoptc/./docopt.h
// Function: docopt_entries_get_entry
static int docopt_entries_get_entry(struct docopt_entries* dE, struct docopt_str* str)
{
    for (int i = 0; i < dE->curentry; ++i)
    {
        if (((docopt_str_len(str) > 0) &&
                docopt_str_len(str) == docopt_str_len(&dE->entries[i].name)) &&
                !strncmp(str->fst, dE->entries[i].name.fst, docopt_str_len(str)))
            return i;
        if ((docopt_str_len(str) == 2) && (strncmp(str->fst, &dE->entries[i].short_name[0], 2) == 0))
            return i;
    }
    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x20(%rcx), %eax
jge 0x9221
movq -0x18(%rbp), %rdi
callq 0x7420
cmpl $0x0, %eax
jbe 0x91ce
movq -0x18(%rbp), %rdi
callq 0x7420
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
movslq -0x1c(%rbp), %rax
imulq $0x38, %rax, %rax
addq %rax, %rdi
callq 0x7420
movl %eax, %ecx
movl -0x20(%rbp), %eax
cmpl %ecx, %eax
jne 0x91ce
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x38, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x7420
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl %eax, %eax
movl %eax, %edx
callq 0x7040
cmpl $0x0, %eax
jne 0x91ce
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x9228
movq -0x18(%rbp), %rdi
callq 0x7420
cmpl $0x2, %eax
jne 0x9211
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
movslq -0x1c(%rbp), %rax
imulq $0x38, %rax, %rax
addq %rax, %rsi
addq $0x10, %rsi
movl $0x2, %edx
callq 0x7040
cmpl $0x0, %eax
jne 0x9211
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x9228
jmp 0x9213
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x9137
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jaroslov[P]docoptc/./docopt.h
// Function: docopt_free
void docopt_free(docopt_t doc)
{
    struct docopt_entries* dE   = (struct docopt_entries*)doc;
    if (dE)
    {
        if (dE->entries) free(dE->entries);
        if (dE->args) free(dE->args);
        free(dE);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x92e4
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x92c3
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x7030
movq -0x10(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0x92db
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x7030
movq -0x10(%rbp), %rdi
callq 0x7030
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jaroslov[P]docoptc/./docopt.h
// Function: docopt_new_term
static int docopt_new_term(struct docopt_parse_state* dS, enum DOCOPT_TYPE type)
{
    int hterm                   = dS->curterm;
    if ((dS->curterm+1) >= dS->nterms)
    {
        dS->nterms      *= 2;
        dS->terms       = (struct docopt_term*)realloc(dS->terms, sizeof(struct docopt_term) * dS->nterms);
    }
    memset(docopt_fetch_term(dS, hterm), 0x0, sizeof(struct docopt_term));
    docopt_fetch_term(dS, hterm)->type = type;
    ++dS->curterm;
    return hterm;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %eax
addl $0x1, %eax
movq -0x8(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jl 0x999c
movq -0x8(%rbp), %rax
movl 0x18(%rax), %ecx
shll %ecx
movl %ecx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0x18(%rax), %rsi
shlq $0x3, %rsi
callq 0x7110
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0x99f0
movq %rax, %rdi
xorl %esi, %esi
movl $0x8, %edx
callq 0x70a0
movl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0x99f0
movl -0x14(%rbp), %edx
movl 0x4(%rax), %ecx
andl $0x1f, %edx
andl $-0x20, %ecx
orl %edx, %ecx
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x1c(%rax)
movl -0x10(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/jaroslov[P]docoptc/./docopt.h
// Function: docopt_parse_seq
int docopt_parse_seq(struct docopt_parse_state* dS, struct docopt_str* usestmt)
{
    if (dS->entries->error) return 0;
    struct docopt_str olduse    = *usestmt;
    int hterm                   = docopt_new_term(dS, DOCOPT_TYPE_SEQ);
    int atom                    = -1;
    docopt_eat_ws(usestmt);
    atom                        = dS->curterm;
    while ((usestmt->fst < usestmt->lst) && docopt_parse_atom(dS, usestmt))
    {
        docopt_eat_ws(usestmt);
        if (strncmp(DOCOPT_REPEAT, usestmt->fst, strlen(DOCOPT_REPEAT)) == 0)
        {
            DO_TM(atom)->repeat = 1;
            usestmt->fst        += 3;
        }
        atom                    = dS->curterm;
    }
    if ((hterm + 1) == dS->curterm)
    {
        *usestmt        = olduse;
        dS->curterm     = hterm;
        return 0;
    }
    DO_TM(hterm)->length = dS->curterm - hterm;
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0x0, (%rax)
je 0x9f19
movl $0x0, -0x4(%rbp)
jmp 0xa056
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x28(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl $0xb, %esi
callq 0x9940
movl %eax, -0x2c(%rbp)
movl $0xffffffff, -0x30(%rbp) # imm = 0xFFFFFFFF
movq -0x18(%rbp), %rdi
callq 0x9a10
movq -0x10(%rbp), %rax
movl 0x1c(%rax), %eax
movl %eax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rdx
xorl %eax, %eax
cmpq 0x8(%rdx), %rcx
movb %al, -0x31(%rbp)
jae 0x9f83
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xa060
cmpl $0x0, %eax
setne %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x9f8c
jmp 0x9fe7
movq -0x18(%rbp), %rdi
callq 0x9a10
movq -0x18(%rbp), %rax
movq (%rax), %rsi
leaq 0x2c42(%rip), %rdi      # 0xcbe5
movl $0x3, %edx
callq 0x7040
cmpl $0x0, %eax
jne 0x9fd8
movq -0x10(%rbp), %rdi
movl -0x30(%rbp), %esi
callq 0x99f0
movl 0x4(%rax), %ecx
andl $-0x41, %ecx
orl $0x40, %ecx
movl %ecx, 0x4(%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rcx
addq $0x3, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movl 0x1c(%rax), %eax
movl %eax, -0x30(%rbp)
jmp 0x9f57
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movq -0x10(%rbp), %rcx
cmpl 0x1c(%rcx), %eax
jne 0xa01c
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl -0x2c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x1c(%rax)
movl $0x0, -0x4(%rbp)
jmp 0xa056
movq -0x10(%rbp), %rax
movl 0x1c(%rax), %eax
subl -0x2c(%rbp), %eax
movl %eax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movl -0x2c(%rbp), %esi
callq 0x99f0
movl -0x38(%rbp), %edx
movl 0x4(%rax), %ecx
andl $0xfffff, %edx          # imm = 0xFFFFF
shll $0x7, %edx
andl $0xf800007f, %ecx       # imm = 0xF800007F
orl %edx, %ecx
movl %ecx, 0x4(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jaroslov[P]docoptc/./docopt.h
// Function: docopt_parse_command
static void docopt_parse_command(struct docopt_parse_state* dS, struct docopt_str* usestmt)
{
    if (dS->entries->error) return;
    while (
        (usestmt->fst < usestmt->lst) &&
        (strncmp(DOCOPT_REPEAT, usestmt->fst, strlen(DOCOPT_REPEAT)) != 0) &&
        (strchr("()[]|", usestmt->fst[0]) == 0) &&
        !isspace(usestmt->fst[0]) &&
        1)
        ++usestmt->fst;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0x0, (%rax)
je 0xa742
jmp 0xa7ee
jmp 0xa744
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rdx
xorl %eax, %eax
cmpq 0x8(%rdx), %rcx
movb %al, -0x11(%rbp)
jae 0xa7d2
movq -0x10(%rbp), %rax
movq (%rax), %rsi
leaq 0x247d(%rip), %rdi      # 0xcbe5
movl $0x3, %edx
callq 0x7040
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x11(%rbp)
je 0xa7d2
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %esi
leaq 0x3a85(%rip), %rdi      # 0xe214
callq 0x7080
movq %rax, %rcx
xorl %eax, %eax
cmpq $0x0, %rcx
movb %al, -0x11(%rbp)
jne 0xa7d2
callq 0x7140
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %ecx
andl $0x2000, %ecx           # imm = 0x2000
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x11(%rbp)
jne 0xa7d2
movb $0x1, %al
movb %al, -0x11(%rbp)
jmp 0xa7d2
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0xa7db
jmp 0xa7ee
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0xa744
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/heltilda[P]cicada/lnklst.c
// Function: newSublist(int, int, int, char)
sublistHeader *newSublist(ccInt numberOfElements, ccInt maximumElements, ccInt elementSize, ccBool ifCleared)
{
    sublistHeader *temp;
    
    if (ifCleared)
        temp = (sublistHeader *) calloc((size_t) maximumElements*elementSize + sublistHeaderSize, (size_t) 1);
    else 
        temp = (sublistHeader *) malloc((size_t) maximumElements*elementSize + sublistHeaderSize);
    
    if (temp != NULL)  {
        temp->numElements = numberOfElements;
        temp->maxElements = maximumElements;
        temp->nextSublist = NULL;     }
    
    return temp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %cl, %al
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movb %al, -0xd(%rbp)
cmpb $0x0, -0xd(%rbp)
je 0x839c
movslq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rax
imulq %rax, %rdi
addq $0x18, %rdi
movl $0x1, %esi
callq 0x80f0
movq %rax, -0x18(%rbp)
jmp 0x83b5
movslq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rax
imulq %rax, %rdi
addq $0x18, %rdi
callq 0x81d0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x83db
movl -0x4(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl -0x8(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/heltilda[P]cicada/lnklst.c
// Function: findSublist(linkedlist*, int, int*)
sublistHeader *findSublist(linkedlist *theList, ccInt theElement, ccInt *bottomRtrn)
{
    sublistHeader *currentSublist = theList->memory;
    ccInt bottom = 1, top = currentSublist->numElements;
    
    while (theElement > top)  {
        currentSublist = currentSublist->nextSublist;
        bottom = top+1;
        top += currentSublist->numElements;    }
    
    *bottomRtrn = bottom;
    return currentSublist;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movl $0x1, -0x24(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x28(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x28(%rbp), %eax
jle 0x8446
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
addl -0x28(%rbp), %eax
movl %eax, -0x28(%rbp)
jmp 0x841b
movl -0x24(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/heltilda[P]cicada/lnklst.c
// Function: newLinkedList
ccInt newLinkedList(linkedlist *theList, ccInt numberOfElements, ccInt elementSize, ccFloat spareRoom, ccBool ifCleared)
{
    ccInt maxElements;
    sublistHeader *temp;
    
    if ((numberOfElements < 0) || (elementSize < 0) || (spareRoom < 0.))  return out_of_range_err;
    
    maxElements = numberOfElements + floor(numberOfElements*spareRoom);
    if (maxElements < 1)  maxElements = 1;
    
    temp = newSublist(numberOfElements, maxElements, elementSize, ifCleared);      // allocate one sublist
    theList->memory = temp;
    if (temp == NULL)  return out_of_memory_err;
    
    theList->elementSize = elementSize;
    theList->elementNum = numberOfElements;
    theList->spareRoom = spareRoom;
    
    return passed;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %cl, %al
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movsd %xmm0, -0x20(%rbp)
movb %al, -0x21(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0x8492
cmpl $0x0, -0x18(%rbp)
jl 0x8492
xorps %xmm0, %xmm0
ucomisd -0x20(%rbp), %xmm0
jbe 0x849e
movl $0x2, -0x4(%rbp)
jmp 0x8531
cvtsi2sdl -0x14(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
cvtsi2sdl -0x14(%rbp), %xmm0
mulsd -0x20(%rbp), %xmm0
callq 0x8220
movaps %xmm0, %xmm1
movsd -0x38(%rbp), %xmm0
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0x28(%rbp)
cmpl $0x1, -0x28(%rbp)
jge 0x84d7
movl $0x1, -0x28(%rbp)
movl -0x14(%rbp), %edi
movl -0x28(%rbp), %esi
movl -0x18(%rbp), %edx
movsbl -0x21(%rbp), %ecx
callq 0x8360
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
cmpq $0x0, -0x30(%rbp)
jne 0x8509
movl $0x1, -0x4(%rbp)
jmp 0x8531
movl -0x18(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x10(%rax)
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movsd -0x20(%rbp), %xmm0
movq -0x10(%rbp), %rax
movsd %xmm0, 0x18(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/heltilda[P]cicada/lnklst.c
// Function: deleteLinkedList
void deleteLinkedList(linkedlist *theList)
{
    sublistHeader *currentSublist, *nextSublist;
    
    nextSublist = theList->memory;
    while (nextSublist != NULL)  {
        currentSublist = nextSublist;
        nextSublist = currentSublist->nextSublist;
        free((void *) currentSublist);    }
    
    theList->memory = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x857e
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x81c0
jmp 0x8558
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/heltilda[P]cicada/lnklst.c
// Function: resizeLinkedList
ccInt resizeLinkedList(linkedlist *theList, ccInt newTop, ccBool ifCleared)
{
    if (theList->memory == NULL)  return init_err;
    
    if (theList->elementNum < newTop)
        return addElements(theList, newTop-theList->elementNum, ifCleared);
    else if (theList->elementNum > newTop)
        return deleteElements(theList, newTop+1, theList->elementNum);
    else  return passed;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movb %al, -0x15(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x8f08
movl $0x3, -0x4(%rbp)
jmp 0x8f5a
movq -0x10(%rbp), %rax
movl (%rax), %eax
cmpl -0x14(%rbp), %eax
jge 0x8f2e
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x10(%rbp), %rax
subl (%rax), %esi
movsbl -0x15(%rbp), %edx
callq 0x8e70
movl %eax, -0x4(%rbp)
jmp 0x8f5a
movq -0x10(%rbp), %rax
movl (%rax), %eax
cmpl -0x14(%rbp), %eax
jle 0x8f53
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
addl $0x1, %esi
movq -0x10(%rbp), %rax
movl (%rax), %edx
callq 0x8880
movl %eax, -0x4(%rbp)
jmp 0x8f5a
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/heltilda[P]cicada/lnklst.c
// Function: defragmentLinkedList
ccInt defragmentLinkedList(linkedlist *theList)
{
    linkedlist oldList;
    ccInt defLL_rtrn;
    
    if (theList->memory == NULL)  return init_err;
    if (theList->elementNum == theList->memory->numElements)  return passed;
    
    oldList = *theList;
    defLL_rtrn = newLinkedList(theList, oldList.elementNum, oldList.elementSize, oldList.spareRoom, ccFalse);
    if (defLL_rtrn != passed)  {
        *theList = oldList;
        return defLL_rtrn;    }
    
    theList->spareRoom = oldList.spareRoom;
    
    if (theList->elementNum > 0)  {
        defLL_rtrn = copyElements(&oldList, 1, theList, 1, oldList.elementNum);
        if (defLL_rtrn != passed)  return defLL_rtrn;         }
    
    deleteLinkedList(&oldList);
    
    return passed;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x8f93
movl $0x3, -0x4(%rbp)
jmp 0x9070
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
cmpl (%rcx), %eax
jne 0x8fb1
movl $0x0, -0x4(%rbp)
jmp 0x9070
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x30(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x28(%rbp)
movq 0x10(%rax), %rcx
movq %rcx, -0x20(%rbp)
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl -0x30(%rbp), %esi
movl -0x20(%rbp), %edx
movsd -0x18(%rbp), %xmm0
xorl %ecx, %ecx
callq 0x8460
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
je 0x901e
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x18(%rax)
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x9070
movsd -0x18(%rbp), %xmm0
movq -0x10(%rbp), %rax
movsd %xmm0, 0x18(%rax)
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
jle 0x9060
movq -0x10(%rbp), %rdx
movl -0x30(%rbp), %r8d
leaq -0x30(%rbp), %rdi
movl $0x1, %ecx
movl %ecx, %esi
callq 0x8a90
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
je 0x905e
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x9070
jmp 0x9060
leaq -0x30(%rbp), %rdi
callq 0x8540
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/heltilda[P]cicada/lnklst.c
// Function: fillElements
ccInt fillElements(linkedlist *theList, ccInt firstElement, ccInt lastElement, char fillValue)
{
    ccInt firstFilled, lastFilled, top, bottom;
    sublistHeader *currentSublist;
    
    if (theList->memory == NULL)  return init_err;
    if ((!elementExists(theList, firstElement)) || (!elementExists(theList, lastElement)))
        return out_of_range_err;
    
    firstFilled = firstElement;
    lastFilled = firstElement-1;
    currentSublist = findSublist(theList, firstElement, &bottom);
    
    while (lastFilled < lastElement)
    {
        top = bottom + currentSublist->numElements - 1;
        lastFilled = lastElement;
        if (top < lastElement) lastFilled = top;
        
        memset((void *) ((char *) currentSublist + (firstFilled-bottom)*theList->elementSize + sublistHeaderSize), fillValue,
                (size_t) theList->elementSize*(lastFilled - firstFilled + 1));
        
        bottom = top+1;
        firstFilled = lastFilled+1;
        currentSublist = currentSublist->nextSublist;
    }
    
    return passed;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %cl, %al
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x92de
movl $0x3, -0x4(%rbp)
jmp 0x93c7
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x8830
cmpl $0x0, %eax
je 0x9300
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x8830
cmpl $0x0, %eax
jne 0x930c
movl $0x2, -0x4(%rbp)
jmp 0x93c7
movl -0x14(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x14(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
leaq -0x2c(%rbp), %rdx
callq 0x83f0
movq %rax, -0x38(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x93c0
movl -0x2c(%rbp), %eax
movq -0x38(%rbp), %rcx
addl (%rcx), %eax
subl $0x1, %eax
movl %eax, -0x28(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x935e
movl -0x28(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x38(%rbp), %rdi
movl -0x20(%rbp), %eax
subl -0x2c(%rbp), %eax
movq -0x10(%rbp), %rcx
imull 0x10(%rcx), %eax
cltq
addq %rax, %rdi
addq $0x18, %rdi
movsbl -0x19(%rbp), %eax
movq -0x10(%rbp), %rcx
movslq 0x10(%rcx), %rdx
movl -0x24(%rbp), %ecx
subl -0x20(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
imulq %rcx, %rdx
movzbl %al, %esi
callq 0x80d0
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x932f
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/heltilda[P]cicada/lnklst.c
// Function: setElements
ccInt setElements(linkedlist *theList, ccInt firstElement, ccInt lastElement, void *readAddress)
{
    ccInt firstSet, lastSet, top, bottom;
    sublistHeader *currentSublist;
    
    firstSet = firstElement;
    lastSet = 0;
    
    if (theList->memory == NULL)  return init_err;
    if (lastElement < firstElement)  return passed;
    if ((!elementExists(theList, firstElement)) || (!elementExists(theList, lastElement)))
        return out_of_range_err;
    
    currentSublist = findSublist(theList, firstElement, &bottom);
    
    while (lastSet < lastElement)
    {
        top = bottom + currentSublist->numElements - 1;
        lastSet = lastElement;
        if (top < lastElement) lastSet = top;
        
        memmove((void *) ((char *) currentSublist + (firstSet-bottom)*theList->elementSize + sublistHeaderSize),
                (void *) ((char *) readAddress + (firstSet-firstElement)*theList->elementSize),
                theList->elementSize*(lastSet-firstSet+1));
        
        bottom = top + 1;
        firstSet = lastSet + 1;
        currentSublist = currentSublist->nextSublist;
    }
    
    return passed;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x940a
movl $0x3, -0x4(%rbp)
jmp 0x9506
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x941e
movl $0x0, -0x4(%rbp)
jmp 0x9506
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x8830
cmpl $0x0, %eax
je 0x9440
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x8830
cmpl $0x0, %eax
jne 0x944c
movl $0x2, -0x4(%rbp)
jmp 0x9506
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
leaq -0x30(%rbp), %rdx
callq 0x83f0
movq %rax, -0x38(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x94ff
movl -0x30(%rbp), %eax
movq -0x38(%rbp), %rcx
addl (%rcx), %eax
subl $0x1, %eax
movl %eax, -0x2c(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x948f
movl -0x2c(%rbp), %eax
movl %eax, -0x28(%rbp)
movq -0x38(%rbp), %rdi
movl -0x24(%rbp), %eax
subl -0x30(%rbp), %eax
movq -0x10(%rbp), %rcx
imull 0x10(%rcx), %eax
cltq
addq %rax, %rdi
addq $0x18, %rdi
movq -0x20(%rbp), %rsi
movl -0x24(%rbp), %eax
subl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
imull 0x10(%rcx), %eax
cltq
addq %rax, %rsi
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
movl -0x28(%rbp), %ecx
subl -0x24(%rbp), %ecx
addl $0x1, %ecx
imull %ecx, %eax
movslq %eax, %rdx
callq 0x8200
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x9460
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/heltilda[P]cicada/lnklst.c
// Function: getElements
ccInt getElements(linkedlist *theList, ccInt firstElement, ccInt lastElement, void *writeAddress)
{
    ccInt firstGet, lastGet, top, bottom;
    sublistHeader *currentSublist;
    
    firstGet = firstElement;
    lastGet = 0;
    
    if (theList->memory == NULL)  return init_err;
    if (lastElement < firstElement)  return passed;
    if ((!elementExists(theList, firstElement)) || (!elementExists(theList, lastElement)))
        return out_of_range_err;
    
    currentSublist = findSublist(theList, firstElement, &bottom);
    
    while (lastGet < lastElement)
    {
        top = bottom + currentSublist->numElements - 1;
        lastGet = lastElement;
        if (top < lastElement) lastGet = top;
        
        memmove((void *) ((char *) writeAddress + (firstGet-firstElement)*theList->elementSize),
                (void *) ((char *) currentSublist + (firstGet-bottom)*theList->elementSize + sublistHeaderSize),
                    theList->elementSize*(lastGet - firstGet + 1));
        
        bottom = top + 1;
        firstGet = lastGet + 1;
        currentSublist = currentSublist->nextSublist;
    }
    
    return passed;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x957a
movl $0x3, -0x4(%rbp)
jmp 0x9676
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x958e
movl $0x0, -0x4(%rbp)
jmp 0x9676
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x8830
cmpl $0x0, %eax
je 0x95b0
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x8830
cmpl $0x0, %eax
jne 0x95bc
movl $0x2, -0x4(%rbp)
jmp 0x9676
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
leaq -0x30(%rbp), %rdx
callq 0x83f0
movq %rax, -0x38(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x966f
movl -0x30(%rbp), %eax
movq -0x38(%rbp), %rcx
addl (%rcx), %eax
subl $0x1, %eax
movl %eax, -0x2c(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x95ff
movl -0x2c(%rbp), %eax
movl %eax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movl -0x24(%rbp), %eax
subl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
imull 0x10(%rcx), %eax
cltq
addq %rax, %rdi
movq -0x38(%rbp), %rsi
movl -0x24(%rbp), %eax
subl -0x30(%rbp), %eax
movq -0x10(%rbp), %rcx
imull 0x10(%rcx), %eax
cltq
addq %rax, %rsi
addq $0x18, %rsi
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
movl -0x28(%rbp), %ecx
subl -0x24(%rbp), %ecx
addl $0x1, %ecx
imull %ecx, %eax
movslq %eax, %rdx
callq 0x8200
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x95d0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/heltilda[P]cicada/lnklst.c
// Function: skipElements
void *skipElements(linkedlist *theList, sublistHeader **theSublist, ccInt *localIndex, ccInt numberToSkip)
{
    *localIndex += numberToSkip;
    while (*localIndex >= (*theSublist)->numElements)  {
        *localIndex -= (*theSublist)->numElements;
        *theSublist = (*theSublist)->nextSublist;      }
    
    return (void *) ((char *) (*theSublist) + sublistHeaderSize + theList->elementSize*(*localIndex));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl -0x1c(%rbp), %ecx
movq -0x18(%rbp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
cmpl (%rcx), %eax
jl 0x97a6
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl (%rax), %edx
movq -0x18(%rbp), %rax
movl (%rax), %ecx
subl %edx, %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0x976e
movq -0x10(%rbp), %rax
movq (%rax), %rax
addq $0x18, %rax
movq -0x8(%rbp), %rcx
movl 0x10(%rcx), %ecx
movq -0x18(%rbp), %rdx
imull (%rdx), %ecx
movslq %ecx, %rcx
addq %rcx, %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/heltilda[P]cicada/lnklst.c
// Function: newPLL
ccInt newPLL(pinned_LL *basePLL, ccInt numElements, ccInt dataSize, ccFloat spareRoom)
{
    ccInt rtrn;
    
    rtrn = newLinkedList(&(basePLL->data), numElements, dataSize, spareRoom, ccFalse);
    if (rtrn != passed)  return rtrn;
    rtrn = newLinkedList(&(basePLL->references), numElements, sizeof(ccInt), spareRoom, ccTrue);
    if (rtrn != passed)  return rtrn;
    basePLL->lowestFreeSpot = 1;
    basePLL->highestFreeSpot = numElements;
    
    return passed;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movsd %xmm0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
movsd -0x20(%rbp), %xmm0
xorl %ecx, %ecx
callq 0x8460
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x980e
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x985a
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
movl -0x14(%rbp), %esi
movsd -0x20(%rbp), %xmm0
movl $0x4, %edx
movl $0x1, %ecx
callq 0x8460
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x983e
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x985a
movq -0x10(%rbp), %rax
movl $0x1, 0x40(%rax)
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x44(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/heltilda[P]cicada/lnklst.c
// Function: derefPLLPtr
void derefPLLPtr(pinned_LL *basePLL, ccInt elementIndex, ccInt *referencePtr)
{
    (*referencePtr)--;
    if (*referencePtr == 0)  {
        if (elementIndex < basePLL->lowestFreeSpot)  basePLL->lowestFreeSpot = elementIndex;
        if (elementIndex > basePLL->highestFreeSpot)  basePLL->highestFreeSpot = elementIndex;    }
    
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x9af1
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x40(%rcx), %eax
jge 0x9ad9
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x40(%rax)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x44(%rcx), %eax
jle 0x9aef
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x44(%rax)
jmp 0x9af1
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/heltilda[P]cicada/lnklst.c
// Function: newStack
ccInt newStack(stack *theStack, ccInt elementSize, ccInt InitialAllocation, ccFloat spareRoom)
{
    ccInt rtrn;
    
    rtrn = newLinkedList(&(theStack->data), (InitialAllocation/(1.+spareRoom)), elementSize, spareRoom, ccFalse);
    if (rtrn != passed)  return rtrn;
    
    theStack->top = 0;
    
    return passed;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movsd %xmm0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
cvtsi2sdl -0x18(%rbp), %xmm0
movsd 0x184dc(%rip), %xmm1    # 0x22008
addsd -0x20(%rbp), %xmm1
divsd %xmm1, %xmm0
cvttsd2si %xmm0, %esi
movl -0x14(%rbp), %edx
movsd -0x20(%rbp), %xmm0
xorl %ecx, %ecx
callq 0x8460
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x9b59
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x9b6a
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/heltilda[P]cicada/lnklst.c
// Function: pushStack
ccInt pushStack(stack *theStack, void **newElementPtr)
{
    ccInt rtrn;
    
    if (theStack->top == theStack->data.elementNum)  {
        rtrn = addElements(&(theStack->data), 1, ccFalse);
        if (rtrn != passed)  return rtrn;         }
    
    (theStack->top)++;
    *newElementPtr = element(&(theStack->data), theStack->top);
    
    return passed;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jne 0x9be6
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x8e70
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x9be4
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x9c15
jmp 0x9be6
movq -0x10(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rax
movl (%rax), %esi
callq 0x9700
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/heltilda[P]cicada/cmpile.c
// Function: freeCompiler
void freeCompiler(compiler_type *compiler)
{
    ccInt loopList, loopTokenString;
    
    deleteLinkedList(&(compiler->tokenSpecs));
    deleteLinkedList(&(compiler->allCodeWords));
    
    free((void *) compiler->OoOdirections);
    
    for (loopList = 0; loopList < 128; loopList++)  {
        linkedlist *theList = compiler->tokens + loopList;
        if (theList->memory != NULL)  {
        for (loopTokenString = 1; loopTokenString <= theList->elementNum; loopTokenString++)  {
            free((void *) (((tokenStringType *) element(theList, loopTokenString))->name));
        }}
        deleteLinkedList(theList);       }
    
    freeBytecode(compiler);
    
    deleteLinkedList(&(compiler->scriptTokens));
    deleteLinkedList(&(compiler->bytecode));
    deleteLinkedList(&(compiler->opCharNum));
    deleteLinkedList(&(compiler->varNames));
    free((void *) compiler);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x1200, %rdi           # imm = 0x1200
callq 0x8540
movq -0x8(%rbp), %rdi
addq $0x1220, %rdi           # imm = 0x1220
callq 0x8540
movq -0x8(%rbp), %rax
movq 0x1240(%rax), %rdi
callq 0x81c0
movl $0x0, -0xc(%rbp)
cmpl $0x80, -0xc(%rbp)
jge 0xb661
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xb64d
movl $0x1, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jg 0xb64b
movq -0x18(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0x9700
movq (%rax), %rdi
callq 0x81c0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xb621
jmp 0xb64d
movq -0x18(%rbp), %rdi
callq 0x8540
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xb5f3
movq -0x8(%rbp), %rdi
callq 0xd3e0
movq -0x8(%rbp), %rdi
addq $0x1440, %rdi           # imm = 0x1440
callq 0x8540
movq -0x8(%rbp), %rdi
addq $0x1460, %rdi           # imm = 0x1460
callq 0x8540
movq -0x8(%rbp), %rdi
addq $0x1480, %rdi           # imm = 0x1480
callq 0x8540
movq -0x8(%rbp), %rdi
addq $0x14a0, %rdi           # imm = 0x14A0
callq 0x8540
movq -0x8(%rbp), %rdi
callq 0x81c0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/heltilda[P]cicada/cmpile.c
// Function: reorderTokens
ccInt reorderTokens(compiler_type *compiler, ccInt expressionType, ccBool replaceCommandWords)
{
    ccInt firstCmd, *lastOrderedToken = &firstCmd, firstToken = 1, rtrn;
    ccInt dummyLastTokenToFix;
    ccBool dummyRtrnTypes[11], *dummyRtrnTypePtr = &(dummyRtrnTypes[0]);       // this extra step prevents a warning message
    
    rtrn = defragmentLinkedList(&(compiler->scriptTokens));
    if (rtrn != passed)  return rtrn;
    
    resizeLinkedList(&(compiler->bytecode), 0, ccFalse);
    resizeLinkedList(&(compiler->opCharNum), 0, ccFalse);
    
    if (compiler->scriptTokens.elementNum == 0)  return passed;
    
    rtrn = relinkExpression(compiler, &firstToken, compiler->scriptTokens.elementNum, 0, expressionType, &lastOrderedToken,
        &dummyRtrnTypePtr, &dummyLastTokenToFix);
    if (rtrn != passed)  return rtrn;
    *lastOrderedToken = 0;         // so the reorderer knows it's finished here
    
    rtrn = writeTokenOps(compiler, firstCmd, replaceCommandWords);
    if (rtrn == passed)  rtrn = defragmentLinkedList(&(compiler->bytecode));
    
    return rtrn;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movb %al, -0x15(%rbp)
leaq -0x1c(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x1, -0x2c(%rbp)
leaq -0x3f(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
addq $0x1440, %rdi           # imm = 0x1440
callq 0x8f70
movl %eax, -0x30(%rbp)
cmpl $0x0, -0x30(%rbp)
je 0xcf0f
movl -0x30(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xcfcc
movq -0x10(%rbp), %rdi
addq $0x1460, %rdi           # imm = 0x1460
xorl %edx, %edx
movl %edx, %esi
callq 0x8ee0
movq -0x10(%rbp), %rdi
addq $0x1480, %rdi           # imm = 0x1480
xorl %edx, %edx
movl %edx, %esi
callq 0x8ee0
movq -0x10(%rbp), %rax
cmpl $0x0, 0x1440(%rax)
jne 0xcf4d
movl $0x0, -0x4(%rbp)
jmp 0xcfcc
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x1440(%rax), %edx
movl -0x14(%rbp), %r8d
leaq -0x2c(%rbp), %rsi
xorl %ecx, %ecx
leaq -0x28(%rbp), %r9
leaq -0x48(%rbp), %r10
leaq -0x34(%rbp), %rax
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0xdc30
movl %eax, -0x30(%rbp)
cmpl $0x0, -0x30(%rbp)
je 0xcf90
movl -0x30(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xcfcc
movq -0x28(%rbp), %rax
movl $0x0, (%rax)
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
movsbl -0x15(%rbp), %edx
callq 0xdf00
movl %eax, -0x30(%rbp)
cmpl $0x0, -0x30(%rbp)
jne 0xcfc6
movq -0x10(%rbp), %rdi
addq $0x1460, %rdi           # imm = 0x1460
callq 0x8f70
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)