LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/nerves-project[P]nerves_initramfs/src/script.c
// Function: term_new_identifier
struct term *term_new_identifier(const char *value)
{
    struct term *rv = alloc_heap(sizeof(struct term));
    rv->kind = term_identifier;
    rv->identifier = alloc_string(value);
    return rv;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq 0x8ed6(%rip), %rax      # 0xe650
addq $-0x4079, %rax          # imm = 0xBF87
cmpq $-0x409a, %rax          # imm = 0xBF66
ja 0x5796
leaq 0x4bff(%rip), %rdi      # 0xa38e
xorl %eax, %eax
callq 0x3358
movq 0x8ea3(%rip), %r13      # 0xe640
movslq 0x8eac(%rip), %rbp      # 0xe650
movq %r13, %r14
addq %rbp, %r14
leal 0x27(%rbp), %eax
andl $-0x8, %eax
movl %eax, 0x8e9a(%rip)      # 0xe650
movl $0x0, (%r13,%rbp)
movq %rbx, %rdi
callq 0x2190
leaq 0x1(%rax), %r15
movq %r15, %rdi
callq 0x559b
movq %rax, %r12
movq %rax, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x2340
movq %r12, 0x8(%r13,%rbp)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/nerves-project[P]nerves_initramfs/src/script.c
// Function: term_reverse
struct term *term_reverse(struct term *rv)
{
    struct term *prev = NULL;
    while (rv) {
        struct term *next = rv->next;
        rv->next = prev;
        prev = rv;
        rv = next;
    }
    return prev;
}

// Assembly:
testq %rdi, %rdi
je 0x5816
xorl %ecx, %ecx
movq %rdi, %rax
movq 0x18(%rdi), %rdi
movq %rcx, 0x18(%rax)
movq %rax, %rcx
testq %rdi, %rdi
jne 0x5802
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/nerves-project[P]nerves_initramfs/src/script.c
// Function: term_new_fun
struct term *term_new_fun(const char *name, struct term *parameters)
{
    int arity = 0;
    struct term *p = parameters;
    while (p) {
        arity++;
        p = p->next;
    }

    fun_handler fun = lookup_function(name, arity);
    if (!fun)
        return NULL;

    struct term *rv = alloc_heap(sizeof(struct term));
    rv->kind = term_fun;
    rv->fun.fun = fun;
    rv->fun.parameters = parameters;
    return rv;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
testq %rsi, %rsi
je 0x5837
xorl %esi, %esi
movq %rbx, %rax
incl %esi
movq 0x18(%rax), %rax
testq %rax, %rax
jne 0x582a
jmp 0x5839
xorl %esi, %esi
callq 0x58a4
testq %rax, %rax
je 0x589a
movq %rax, %r14
movslq 0x8e03(%rip), %rax      # 0xe650
addq $-0x4079, %rax          # imm = 0xBF87
cmpq $-0x409a, %rax          # imm = 0xBF66
ja 0x5869
leaq 0x4b2c(%rip), %rdi      # 0xa38e
xorl %eax, %eax
callq 0x3358
movq 0x8dd0(%rip), %rcx      # 0xe640
movslq 0x8dd9(%rip), %rdx      # 0xe650
leaq (%rcx,%rdx), %rax
leal 0x27(%rdx), %esi
andl $-0x8, %esi
movl %esi, 0x8dc9(%rip)      # 0xe650
movl $0x4, (%rcx,%rdx)
movq %r14, 0x8(%rcx,%rdx)
movq %rbx, 0x10(%rcx,%rdx)
jmp 0x589c
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/nerves-project[P]nerves_initramfs/src/script.c
// Function: lookup_function
fun_handler lookup_function(const char *name, int arity)
{
    struct function_info *entry = function_table;
    while (entry->name) {
        if (strcmp(entry->name, name) == 0 && arity >= entry->arity)
            return entry->handler;
        entry++;
    }
    return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x8a5b(%rip), %rdi      # 0xe310
testq %rdi, %rdi
je 0x58e5
movl %esi, %ebp
leaq 0x8a6d(%rip), %r15      # 0xe330
xorl %ebx, %ebx
movq %r14, %rsi
callq 0x2300
testl %eax, %eax
jne 0x58d7
cmpl %ebp, -0x18(%r15)
jle 0x58e9
movq (%r15), %rdi
addq $0x20, %r15
testq %rdi, %rdi
jne 0x58c5
jmp 0x58ed
xorl %ebx, %ebx
jmp 0x58ed
movq -0x10(%r15), %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/nerves-project[P]nerves_initramfs/src/script.c
// Function: inspect
void inspect(const struct term *rv)
{
    switch (rv->kind) {
    case term_identifier:
        fprintf(stderr, "%s", rv->identifier);
        break;
    case term_string:
        fprintf(stderr, "\"%s\"", rv->string);
        break;
    case term_number:
        fprintf(stderr, "%d", rv->number);
        break;
    case term_boolean:
        fprintf(stderr, "%s", rv->boolean ? "true" : "false");
        break;
    case term_fun: {
        const struct term *p = rv->fun.parameters;
        const struct function_info *fun_info = function_info_by_fun(rv->fun.fun);
        fprintf(stderr, "%s(", fun_info->name);
        for (int i = 0; i < fun_info->arity; i++) {
            inspect(p);
            p = p->next;
            if (p)
                fprintf(stderr, ",");
        }
        fprintf(stderr, ")");
        break;
    }
    case term_variable:
        fprintf(stderr, "%s=", rv->var.name);
        inspect(rv->var.value);
        break;
    default:
        fprintf(stderr, "Unknown");
        break;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x86e6(%rip), %r15      # 0xdff0
leaq 0x4a5b(%rip), %r14      # 0xa36c
movl (%rbx), %eax
cmpl $0x5, %eax
jne 0x592f
movq (%r15), %rdi
movq 0x8(%rbx), %rdx
movq %r14, %rsi
xorl %eax, %eax
callq 0x2310
movq 0x10(%rbx), %rbx
jmp 0x5911
jae 0x5975
movl %eax, %eax
leaq 0x4a0a(%rip), %rcx      # 0xa344
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rbx, %rdi
callq 0x270e
jmp 0x597a
movq %rbx, %rdi
callq 0x2621
jmp 0x597a
movq %rbx, %rdi
callq 0x26d1
jmp 0x597a
movq %rbx, %rdi
callq 0x26a9
jmp 0x597a
movq %rbx, %rdi
callq 0x26ef
jmp 0x597a
callq 0x2721
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/nerves-project[P]nerves_initramfs/src/script.c
// Function: run_functions
const struct term *run_functions(const struct term *rv)
{
    const struct term *last_result = NULL;
    while (rv) {
        last_result = run_function(rv);
        rv = rv->next;
    }
    return last_result;
}

// Assembly:
testq %rdi, %rdi
je 0x59c6
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x59b4
movq 0x10(%rbx), %rdi
callq *%rax
jmp 0x59bb
xorl %edi, %edi
callq 0x5714
movq 0x18(%rbx), %rbx
testq %rbx, %rbx
jne 0x59a3
popq %rbx
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/nerves-project[P]nerves_initramfs/src/script.c
// Function: term_resolve
const struct term *term_resolve(const struct term *rv)
{
    switch (rv->kind) {
    case term_identifier:
        return term_resolve(get_variable(rv->identifier));
    case term_fun:
        return run_function(rv);
    default:
        return rv;
    }
}

// Assembly:
pushq %rax
movq %rdi, %rax
movl (%rax), %ecx
testl %ecx, %ecx
jne 0x59de
movq 0x8(%rax), %rdi
callq 0x59fd
jmp 0x59cd
cmpl $0x4, %ecx
jne 0x59f3
movq 0x8(%rax), %rcx
testq %rcx, %rcx
je 0x59f5
movq 0x10(%rax), %rdi
popq %rax
jmpq *%rcx
popq %rcx
retq
xorl %edi, %edi
popq %rax
jmp 0x5714
// File: /workspace/github_c_makefile_star2_O1/nerves-project[P]nerves_initramfs/src/script.c
// Function: get_variable
const struct term *get_variable(const char *name)
{
    struct term *var = get_variable_impl(name);
    if (var)
        return var->var.value;
    else
        return term_new_string("");
}

// Assembly:
pushq %rax
callq 0x5b83
testq %rax, %rax
je 0x5a0e
movq 0x10(%rax), %rax
popq %rcx
retq
leaq 0x39f4(%rip), %rdi      # 0x9409
popq %rax
jmp 0x55e0
// File: /workspace/github_c_makefile_star2_O1/nerves-project[P]nerves_initramfs/src/script.c
// Function: term_compare
int term_compare(const struct term *left, const struct term *right)
{
    const struct term *rleft = term_resolve(left);
    const struct term *rright = term_resolve(right);

    // Make them the same...


    // Left and right are the same now.
    switch (rleft->kind) {
    case term_string:
        return strcmp(rleft->string, rright->string);
    case term_number:
        return rleft->number - rright->number;
    case term_boolean:
        // true > false
        return rleft->boolean - rright->boolean;
    default:
        return 1; // never happens
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
callq 0x59c9
movq %rax, %rbx
movq %r14, %rdi
callq 0x59c9
movl (%rbx), %edx
cmpl $0x3, %edx
je 0x5a64
cmpl $0x2, %edx
je 0x5a5c
movl $0x1, %ecx
cmpl $0x1, %edx
jne 0x5a6e
movq 0x8(%rbx), %rdi
movq 0x8(%rax), %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2300
movl 0x8(%rbx), %ecx
subl 0x8(%rax), %ecx
jmp 0x5a6e
movzbl 0x8(%rbx), %ecx
movzbl 0x8(%rax), %eax
subl %eax, %ecx
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/nerves-project[P]nerves_initramfs/src/script.c
// Function: term_to_boolean
bool term_to_boolean(const struct term *rv)
{
    rv = term_resolve(rv);
    switch (rv->kind) {
    case term_string:
        // empty strings, "0", and "false" are false. Everything else is true.
        if (strlen(rv->string) == 0 ||
            strcasecmp(rv->string, "0") == 0 ||
            strcasecmp(rv->string, "false") == 0)
            return false;
        else
            return true;
    case term_number:
        return rv->number != 0;
    case term_boolean:
        return rv->boolean;
    default:
        return false;
    }
}

// Assembly:
pushq %rbx
callq 0x59c9
movl (%rax), %ecx
cmpl $0x3, %ecx
je 0x5acb
cmpl $0x2, %ecx
je 0x5ac2
cmpl $0x1, %ecx
jne 0x5abe
movq 0x8(%rax), %rbx
cmpb $0x0, (%rbx)
je 0x5abe
leaq 0x388e(%rip), %rsi      # 0x932d
movq %rbx, %rdi
callq 0x2060
testl %eax, %eax
je 0x5abe
leaq 0x48b0(%rip), %rsi      # 0xa362
movq %rbx, %rdi
callq 0x2060
testl %eax, %eax
jmp 0x5ac6
xorl %eax, %eax
jmp 0x5ace
cmpl $0x0, 0x8(%rax)
setne %al
jmp 0x5ace
movb 0x8(%rax), %al
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/nerves-project[P]nerves_initramfs/src/script.c
// Function: term_to_number
int term_to_number(const struct term *rv)
{
    rv = term_resolve(rv);
    switch (rv->kind) {
    case term_string:
        return strtoull(rv->string, NULL, 0);
    case term_number:
        return rv->number;
    case term_boolean:
        return rv->boolean ? 1 : 0;
    default:
        return 0;
    }
}

// Assembly:
pushq %rax
callq 0x59c9
movl (%rax), %edx
cmpl $0x3, %edx
je 0x5b00
cmpl $0x2, %edx
je 0x5afb
xorl %ecx, %ecx
cmpl $0x1, %edx
jne 0x5b04
movq 0x8(%rax), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x22f0
movq %rax, %rcx
jmp 0x5b04
movl 0x8(%rax), %ecx
jmp 0x5b04
movzbl 0x8(%rax), %ecx
movl %ecx, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/nerves-project[P]nerves_initramfs/src/script.c
// Function: term_to_string
const struct term *term_to_string(const struct term *rv)
{
    rv = term_resolve(rv);
    switch (rv->kind) {
    case term_identifier:
        return term_to_string(get_variable(rv->identifier));
    case term_string:
        return rv;
    case term_number:
    {
        char buffer[32];
        sprintf(buffer, "%d", rv->number);
        return term_new_string(buffer);
    }
    case term_boolean:
        return term_new_string(rv->boolean ? "true" : "false");
    default:
        return term_new_string("");
    }
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
callq 0x59c9
movl (%rax), %ecx
testl %ecx, %ecx
jne 0x5b26
movq 0x8(%rax), %rdi
callq 0x59fd
movq %rax, %rdi
jmp 0x5b0d
cmpl $0x1, %ecx
je 0x5b6c
cmpl $0x2, %ecx
je 0x5b4d
cmpl $0x3, %ecx
jne 0x5b72
leaq 0x4821(%rip), %rcx      # 0xa35d
cmpb $0x0, 0x8(%rax)
leaq 0x481b(%rip), %rdi      # 0xa362
cmovneq %rcx, %rdi
jmp 0x5b79
movl 0x8(%rax), %edx
leaq 0x4b66(%rip), %rsi      # 0xa6bd
movq %rsp, %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2480
movq %rbx, %rdi
callq 0x55e0
addq $0x20, %rsp
popq %rbx
retq
leaq 0x3890(%rip), %rdi      # 0x9409
addq $0x20, %rsp
popq %rbx
jmp 0x55e0
// File: /workspace/github_c_makefile_star2_O1/nerves-project[P]nerves_initramfs/src/script.c
// Function: function_blkid
static const struct term *function_blkid(const struct term *parameters)
{
    (void)parameters;
    struct block_device_info *devices;

    probe_block_devices(&devices);

    for (struct block_device_info *device = devices; device; device = device->next) {
        fprintf(stderr, "%s: %sUUID=\"%s\"\n",
            device->path,
            device->type == BLOCK_DEVICE_DISK ? "DISK" : "PART",
            device->uuid);
    }

    free_block_devices(devices);
    return NULL;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x7db8
movq (%rbx), %rdi
testq %rdi, %rdi
jne 0x5d2e
movq 0x8(%rsp), %rdi
callq 0x8328
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
callq 0x273d
jmp 0x5d1c
// File: /workspace/github_c_makefile_star2_O1/nerves-project[P]nerves_initramfs/src/script.c
// Function: function_cmd
static const struct term *function_cmd(const struct term *parameters)
{
    const int max_args = 15;
    char *argv[max_args + 1];
    int index = 0;
    while (parameters && index < max_args) {
        const struct term *str = term_to_string(parameters);
        argv[index] = str->string;
        parameters = parameters->next;
        index++;
    }
    argv[index] = 0;

    char output_buffer[256];
    output_buffer[0] = '\0';
    if (system_cmd(argv, output_buffer, sizeof(output_buffer)) != 0)
        info("Ignoring non-zero exit from %s", argv[0]);

    // Trim the output before returning since that's what's expected
    // in practice. There's usually a newline to trim anyway.
    trim_string_in_place(output_buffer);

    return term_new_string(output_buffer);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x188, %rsp            # imm = 0x188
testq %rdi, %rdi
je 0x5d72
movq %rdi, %rbx
xorl %r14d, %r14d
movq %rbx, %rdi
callq 0x5b08
movq 0x8(%rax), %rax
movq %rax, (%rsp,%r14,8)
movq 0x18(%rbx), %rbx
leaq 0x1(%r14), %rax
testq %rbx, %rbx
je 0x5d74
cmpq $0xe, %r14
movq %rax, %r14
jb 0x5d4a
jmp 0x5d74
xorl %eax, %eax
movq $0x0, (%rsp,%rax,8)
leaq 0x80(%rsp), %rsi
movb $0x0, (%rsi)
movq %rsp, %rdi
movl $0x100, %edx            # imm = 0x100
callq 0x85a0
testl %eax, %eax
je 0x5daa
movq (%rsp), %rsi
leaq 0x4886(%rip), %rdi      # 0xa629
xorl %eax, %eax
callq 0x3270
leaq 0x80(%rsp), %rbx
movq %rbx, %rdi
callq 0x345c
movq %rbx, %rdi
callq 0x55e0
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/nerves-project[P]nerves_initramfs/src/script.c
// Function: function_fwup_revert
static const struct term *function_fwup_revert(const struct term *parameters)
{
    (void)parameters;

    const char *devpathspec = get_variable_as_string("uboot_env.path");
    char devpath[BLOCK_DEVICE_PATH_LEN];
    if (resolve_block_device_spec(devpathspec, devpath) < 0) {
        info("Failure to revert due to invalid uboot_env.path");
        return term_new_boolean(false);
    }

    char *const argv[7] = {"/usr/bin/fwup", "revert.fw", "-d", devpath, "-t", "revert", 0};

    char output_buffer[256];
    output_buffer[0] = '\0';
    if (system_cmd(argv, output_buffer, sizeof(output_buffer)) != 0) {
        info("Failure from fwup revert: %s", output_buffer);
        return term_new_boolean(false);
    }


    reboot(LINUX_REBOOT_CMD_RESTART);
    exit(EXIT_FAILURE);
}

// Assembly:
pushq %rbx
subq $0x160, %rsp            # imm = 0x160
leaq 0x4875(%rip), %rdi      # 0xa670
callq 0x5bba
movq %rsp, %rbx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x8448
testl %eax, %eax
js 0x5e84
leaq 0x4866(%rip), %rax      # 0xa67f
leaq 0x20(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x4865(%rip), %rax      # 0xa68d
movq %rax, 0x8(%rdi)
leaq 0x4864(%rip), %rax      # 0xa697
movq %rax, 0x10(%rdi)
movq %rbx, 0x18(%rdi)
leaq 0x4858(%rip), %rax      # 0xa69a
movq %rax, 0x20(%rdi)
leaq 0x45bc(%rip), %rax      # 0xa409
movq %rax, 0x28(%rdi)
movq $0x0, 0x30(%rdi)
leaq 0x60(%rsp), %rsi
movb $0x0, (%rsi)
movl $0x100, %edx            # imm = 0x100
callq 0x85a0
testl %eax, %eax
je 0x5ea2
leaq 0x4827(%rip), %rdi      # 0xa69d
leaq 0x60(%rsp), %rsi
xorl %eax, %eax
callq 0x3270
jmp 0x5e92
leaq 0x47c4(%rip), %rdi      # 0xa64f
xorl %eax, %eax
callq 0x3270
xorl %edi, %edi
callq 0x5714
addq $0x160, %rsp            # imm = 0x160
popq %rbx
retq
movl $0x1234567, %edi        # imm = 0x1234567
callq 0x24b0
movl $0x1, %edi
callq 0x2490
// File: /workspace/github_c_makefile_star2_O1/nerves-project[P]nerves_initramfs/src/script.c
// Function: function_getenv
static const struct term *function_getenv(const struct term *parameters)
{
    const char *name = term_to_string(parameters)->string;

    char *value;
    if (uboot_env_getenv(&working_uboot_env, name, &value) < 0) {
        return term_new_string("");
    } else {
        struct term *ret = term_new_string(value);
        free(value);
        return ret;
    }
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
callq 0x5b08
movq 0x8(%rax), %rsi
leaq 0x86d5(%rip), %rdi      # 0xe5a0
leaq 0x8(%rsp), %rdx
callq 0x37b3
testl %eax, %eax
js 0x5ef2
movq 0x8(%rsp), %rdi
callq 0x55e0
movq %rax, %rbx
movq 0x8(%rsp), %rdi
callq 0x2040
jmp 0x5f01
leaq 0x3510(%rip), %rdi      # 0x9409
callq 0x55e0
movq %rax, %rbx
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/nerves-project[P]nerves_initramfs/src/script.c
// Function: function_ls
static const struct term *function_ls(const struct term *parameters)
{
    const char *path = parameters ? term_to_string(parameters)->string : "/";

    struct dirent **namelist;
    int n = scandir(path,
                    &namelist,
                    NULL,
                    alphasort);
    int i;
    for (i = 0; i < n; i++) {
        fprintf(stderr, "%-32s%s\n",  namelist[i]->d_name, (namelist[i]->d_type == DT_DIR ? "<DIR>" : ""));
    }

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x6094
callq 0x5b08
movq 0x8(%rax), %rdi
jmp 0x609b
leaq 0x3323(%rip), %rdi      # 0x93be
movq 0x7f2e(%rip), %rcx      # 0xdfd0
movq %rsp, %rsi
xorl %edx, %edx
callq 0x2260
movl %eax, %ebx
testl %eax, %eax
jg 0x60e5
testl %ebx, %ebx
js 0x60db
je 0x60d2
movl %ebx, %ebx
xorl %r14d, %r14d
movq (%rsp), %rax
movq (%rax,%r14,8), %rdi
callq 0x2040
incq %r14
cmpq %r14, %rbx
jne 0x60bd
movq (%rsp), %rdi
callq 0x2040
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rsp, %rsi
movl %ebx, %edi
callq 0x27d0
jmp 0x60b2
// File: /workspace/github_c_makefile_star2_O1/nerves-project[P]nerves_initramfs/src/script.c
// Function: function_print
static const struct term *function_print(const struct term *parameters)
{
    while (parameters) {
        const struct term *str = term_to_string(parameters);
        fprintf(stderr, "%s", str->string);
        parameters = parameters->next;
    }
    fprintf(stderr, "\n");
    return NULL;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
jne 0x6124
movq 0x7edd(%rip), %rax      # 0xdff0
movq (%rax), %rsi
movl $0xa, %edi
callq 0x22b0
xorl %eax, %eax
popq %rcx
retq
callq 0x2838
jmp 0x610c
// File: /workspace/github_c_makefile_star2_O1/nerves-project[P]nerves_initramfs/src/script.c
// Function: function_readfile
static const struct term *function_readfile(const struct term *parameters)
{
    const char *path = term_to_string(parameters)->string;

    FILE *fp = fopen(path, "rb");
    if (fp) {
        char buffer[HEAP_SIZE / 4];
        size_t len = fread(buffer, 1, sizeof(buffer) - 1, fp);
        buffer[len] = 0;
        fclose(fp);
        return term_new_string(buffer);
    } else {
        info("Error reading %s", path);
        return term_new_string("");
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x1028, %rsp           # imm = 0x1028
callq 0x5b08
movq 0x8(%rax), %r14
leaq 0x4625(%rip), %rsi      # 0xa76a
movq %r14, %rdi
callq 0x2420
testq %rax, %rax
je 0x618c
movq %rax, %rbx
movq %rsp, %r14
movl $0x1, %esi
movl $0x1025, %edx           # imm = 0x1025
movq %r14, %rdi
movq %rax, %rcx
callq 0x2120
movb $0x0, (%rsp,%rax)
movq %rbx, %rdi
callq 0x2170
movq %r14, %rdi
callq 0x55e0
addq $0x1028, %rsp           # imm = 0x1028
popq %rbx
popq %r14
retq
leaq 0x45da(%rip), %rdi      # 0xa76d
movq %r14, %rsi
xorl %eax, %eax
callq 0x3270
leaq 0x3265(%rip), %rdi      # 0x9409
addq $0x1028, %rsp           # imm = 0x1028
popq %rbx
popq %r14
jmp 0x55e0
// File: /workspace/github_c_makefile_star2_O1/nerves-project[P]nerves_initramfs/src/script.c
// Function: function_saveenv
static const struct term *function_saveenv(const struct term *parameters)
{
    (void)parameters;

    const char *devpathspec = get_variable_as_string("uboot_env.path");
    char devpath[BLOCK_DEVICE_PATH_LEN];

    int block = get_variable_as_number("uboot_env.start");
    int block_count = get_variable_as_number("uboot_env.count");

    working_uboot_env.env_size = block_count * 512;
    int fd = open_block_device(devpathspec, O_WRONLY, devpath);
    if (fd < 0) {
        info("Could not open '%s'", devpathspec);
        return NULL;
    }
    if (lseek(fd, block * 512, SEEK_SET) < 0) {
        info("Could not seek to block %d (byte offset %d) in '%s'", block, block * 512, devpath);
        close(fd);
        return NULL;
    }
    char *buffer = malloc(working_uboot_env.env_size);
    if (uboot_env_write(&working_uboot_env, buffer) < 0) {
        free(buffer);
        return NULL;
    }

    ssize_t amount_written = write(fd, buffer, working_uboot_env.env_size);
    close(fd);
    free(buffer);

    if (amount_written != (ssize_t) working_uboot_env.env_size) {
        info("Could not write %d blocks (%d bytes) from '%s'", block_count, working_uboot_env.env_size, devpath);
        return NULL;
    }

    set_boolean_variable("uboot_env.modified", false);
    return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
leaq 0x4495(%rip), %rdi      # 0xa670
callq 0x5bba
movq %rax, %r12
leaq 0x3004(%rip), %rdi      # 0x91ee
callq 0x5bf6
movl %eax, %r15d
leaq 0x3005(%rip), %rdi      # 0x91fe
callq 0x5bf6
movl %eax, %ebx
shll $0x9, %eax
cltq
leaq 0x8394(%rip), %r14      # 0xe5a0
movq %rax, (%r14)
movq %rsp, %rdx
movq %r12, %rdi
movl $0x1, %esi
callq 0x8340
testl %eax, %eax
js 0x6296
movl %eax, %ebp
movl %r15d, %r12d
shll $0x9, %r12d
movslq %r12d, %rsi
movl %eax, %edi
xorl %edx, %edx
callq 0x2220
testq %rax, %rax
js 0x62a9
movq (%r14), %rdi
callq 0x2370
movq %rax, %r15
movq %r14, %rdi
movq %rax, %rsi
callq 0x380f
testl %eax, %eax
js 0x62c9
movq (%r14), %rdx
movl %ebp, %edi
movq %r15, %rsi
callq 0x2140
movq %rax, %r12
movl %ebp, %edi
callq 0x2280
movq %r15, %rdi
callq 0x2040
movq (%r14), %rdx
cmpq %rdx, %r12
jne 0x62d3
xorl %edi, %edi
callq 0x5714
leaq 0x2f4f(%rip), %rdi      # 0x91db
movq %rax, %rsi
callq 0x5443
jmp 0x62e6
leaq 0x4448(%rip), %rdi      # 0xa6e5
movq %r12, %rsi
xorl %eax, %eax
callq 0x3270
jmp 0x62e6
leaq 0x4449(%rip), %rdi      # 0xa6f9
movq %rsp, %rcx
movl %r15d, %esi
movl %r12d, %edx
xorl %eax, %eax
callq 0x3270
movl %ebp, %edi
callq 0x2280
jmp 0x62e6
movq %r15, %rdi
callq 0x2040
jmp 0x62e6
leaq 0x44a4(%rip), %rdi      # 0xa77e
movq %rsp, %rcx
movl %ebx, %esi
xorl %eax, %eax
callq 0x3270
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/nerves-project[P]nerves_initramfs/src/script.c
// Function: function_setenv
static const struct term *function_setenv(const struct term *parameters)
{
    const char *name = term_to_string(parameters)->string;
    const char *value = term_to_string(parameters->next)->string;

    if (uboot_env_setenv(&working_uboot_env, name, value) < 0) {
        info("Error setting uboot environment variable '%s' to '%s'", name, value);
    } else {
        set_boolean_variable("uboot_env.modified", true);
    }

    return parameters->next;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x5b08
movq 0x8(%rax), %r14
movq 0x18(%rbx), %rdi
callq 0x5b08
movq 0x8(%rax), %r15
leaq 0x8286(%rip), %rdi      # 0xe5a0
movq %r14, %rsi
movq %r15, %rdx
callq 0x369e
testl %eax, %eax
js 0x6344
movl $0x1, %edi
callq 0x5714
leaq 0x2ea1(%rip), %rdi      # 0x91db
movq %rax, %rsi
callq 0x5443
jmp 0x6358
leaq 0x4462(%rip), %rdi      # 0xa7ad
movq %r14, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x3270
movq 0x18(%rbx), %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/nerves-project[P]nerves_initramfs/src/script.c
// Function: function_vars
static const struct term *function_vars(const struct term *parameters)
{
    (void)parameters;

    for (const struct term *var = variables; var; var = var->next) {
        inspect(var);
        fprintf(stderr, "\n");
    }
    return NULL;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x82c6(%rip), %rbx      # 0xe648
testq %rbx, %rbx
je 0x63ac
movq 0x7c62(%rip), %r14      # 0xdff0
movq %rbx, %rdi
callq 0x58fb
movq (%r14), %rsi
movl $0xa, %edi
callq 0x22b0
movq 0x18(%rbx), %rbx
testq %rbx, %rbx
jne 0x638e
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O1/nerves-project[P]nerves_initramfs/src/linenoise.c
// Function: refreshShowHints
void refreshShowHints(struct abuf *ab, struct linenoiseState *l, int plen) {
    char seq[64];
    if (hintsCallback && plen+l->len < l->cols) {
        int color = -1, bold = 0;
        char *hint = hintsCallback(l->buf,&color,&bold);
        if (hint) {
            int hintlen = strlen(hint);
            int hintmaxlen = l->cols-(plen+l->len);
            if (hintlen > hintmaxlen) hintlen = hintmaxlen;
            if (bold == 1 && color == -1) color = 37;
            if (color != -1 || bold != 0)
                snprintf(seq,64,"\033[%d;%d;49m",bold,color);
            else
                seq[0] = '\0';
            abAppend(ab,seq,strlen(seq));
            abAppend(ab,hint,hintlen);
            if (color != -1 || bold != 0)
                abAppend(ab,"\033[0m",4);
            /* Call the function to free the hint returned. */
            if (freeHintsCallback) freeHintsCallback(hint);
        }
    }
}

// Assembly:
movq 0x81f0(%rip), %rax      # 0xe668
testq %rax, %rax
je 0x6595
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movl %edx, %r15d
movq %rsi, %r12
movslq %edx, %rcx
addq 0x38(%rsi), %rcx
cmpq 0x40(%rsi), %rcx
jae 0x6589
movq %rdi, %rbx
leaq 0x8(%rsp), %rsi
movl $0xffffffff, (%rsi)     # imm = 0xFFFFFFFF
leaq 0xc(%rsp), %rdx
movl $0x0, (%rdx)
movq 0x8(%r12), %rdi
callq *%rax
testq %rax, %rax
je 0x6589
movq %rax, %r14
movq %rax, %rdi
callq 0x2190
movl 0x40(%r12), %ebp
addl 0x38(%r12), %r15d
subl %r15d, %ebp
cmpl %ebp, %eax
cmovll %eax, %ebp
movl 0xc(%rsp), %ecx
cmpl $0x1, %ecx
jne 0x6502
cmpl $-0x1, 0x8(%rsp)
jne 0x6502
movl $0x25, 0x8(%rsp)
movl 0x8(%rsp), %r8d
movl %r8d, %eax
notl %eax
orl %ecx, %eax
je 0x652a
leaq 0x437d(%rip), %rdx      # 0xa894
leaq 0x10(%rsp), %rdi
movl $0x40, %esi
xorl %eax, %eax
callq 0x2210
jmp 0x652f
movb $0x0, 0x10(%rsp)
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x2190
movq %rbx, %rdi
movq %r15, %rsi
movl %eax, %edx
callq 0x6596
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x6596
cmpl $-0x1, 0x8(%rsp)
jne 0x6564
cmpl $0x0, 0xc(%rsp)
je 0x6578
leaq 0x2ca3(%rip), %rsi      # 0x920e
movq %rbx, %rdi
movl $0x4, %edx
callq 0x6596
movq 0x80f1(%rip), %rax      # 0xe670
testq %rax, %rax
je 0x6589
movq %r14, %rdi
callq *%rax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/nerves-project[P]nerves_initramfs/src/linenoise.c
// Function: abAppend
static void abAppend(struct abuf *ab, const char *s, int len) {
    char *new = realloc(ab->b,ab->len+len);

    if (new == NULL) return;
    memcpy(new+ab->len,s,len);
    ab->b = new;
    ab->len += len;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdi), %rdi
movslq 0x8(%rbx), %rsi
movslq %edx, %r14
addq %r14, %rsi
callq 0x23a0
testq %rax, %rax
je 0x65de
movq %rax, %r12
movslq 0x8(%rbx), %r13
movq %rax, %rdi
addq %r13, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x2340
movq %r12, (%rbx)
addl %r13d, %r14d
movl %r14d, 0x8(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/nerves-project[P]nerves_initramfs/src/linenoise.c
// Function: linenoiseHistorySave
int linenoiseHistorySave(const char *filename) {
    mode_t old_umask = umask(S_IXUSR|S_IRWXG|S_IRWXO);
    FILE *fp;
    int j;

    fp = fopen(filename,"w");
    umask(old_umask);
    if (fp == NULL) return -1;
    chmod(filename,S_IRUSR|S_IWUSR);
    for (j = 0; j < history_len; j++)
        fprintf(fp,"%s\n",history[j]);
    fclose(fp);
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x7f, %edi
callq 0x2320
movl %eax, %ebp
leaq 0x2b3d(%rip), %rsi      # 0xa695
movq %r14, %rdi
callq 0x2420
movq %rax, %rbx
movl %ebp, %edi
callq 0x2320
testq %rbx, %rbx
je 0x7bc2
movq %r14, %rdi
movl $0x180, %esi            # imm = 0x180
callq 0x23c0
cmpl $0x0, 0x6af5(%rip)      # 0xe678
jle 0x7bb6
leaq 0x27fe(%rip), %r14      # 0xa38a
xorl %r15d, %r15d
movq 0x6aea(%rip), %rax      # 0xe680
movq (%rax,%r15,8), %rdx
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x2310
incq %r15
movslq 0x6ac7(%rip), %rax      # 0xe678
cmpq %rax, %r15
jl 0x7b8f
movq %rbx, %rdi
callq 0x2170
xorl %eax, %eax
jmp 0x7bc7
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/nerves-project[P]nerves_initramfs/src/block_device.c
// Function: free_block_devices
void free_block_devices(struct block_device_info *devices)
{
    while (devices) {
        struct block_device_info *next = devices->next;
        free(devices);
        devices = next;
    }
}

// Assembly:
testq %rdi, %rdi
je 0x833f
pushq %rbx
movq (%rdi), %rbx
callq 0x2040
movq %rbx, %rdi
testq %rbx, %rbx
jne 0x832e
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/nerves-project[P]nerves_initramfs/src/block_device.c
// Function: open_block_device
int open_block_device(const char *spec, int flags, char *path)
{
    // If this is called multiple times and we've exhausted the wait time, then
    // don't wait any longer. We don't want a longer cumulative wait that depends on
    // the contents of the script.
    static int tries = 1000; // Wait 1000 * 1ms = 1 second total
    int fd = open_block_device_impl(spec, flags, path);
    while (fd < 0 && tries > 0) {
        usleep(1000);
        fd = open_block_device_impl(spec, flags, path);
        tries--;
    }

    if (fd < 0)
        info("Could not open block device '%s' even after waiting!", spec);

    return fd;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %rbx
callq 0x83c0
movl %eax, %ebp
shrl $0x1f, %eax
testl %ebp, %ebp
jns 0x839e
cmpl $0x0, 0x622f(%rip)      # 0xe594
jle 0x839e
movl $0x3e8, %edi            # imm = 0x3E8
callq 0x2520
movq %rbx, %rdi
movl %r15d, %esi
movq %r14, %rdx
callq 0x83c0
movl %eax, %ebp
movl 0x620d(%rip), %ecx      # 0xe594
leal -0x1(%rcx), %eax
movl %eax, 0x6204(%rip)      # 0xe594
movl %ebp, %eax
shrl $0x1f, %eax
testl %ebp, %ebp
jns 0x839e
cmpl $0x1, %ecx
jg 0x8367
testb %al, %al
je 0x83b3
leaq 0x25db(%rip), %rdi      # 0xa984
movq %rbx, %rsi
xorl %eax, %eax
callq 0x3270
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/nerves-project[P]nerves_initramfs/src/block_device.c
// Function: find_block_device_by_uuid
static int find_block_device_by_uuid(enum block_device_type type, const char *uuid, char *path)
{
    struct block_device_info *devices;
    if (probe_block_devices(&devices) < 0)
        return -1;

    int rc = -1;
    for (struct block_device_info *device = devices; device; device = device->next) {
        // strcasecmp to avoid being picky on UUID hex digit capitalization
        if (type == device->type && strcasecmp(uuid, device->uuid) == 0) {
            strcpy(path, device->path);
            rc = 0;
            break;
        }
    }
    free_block_devices(devices);
    return rc;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rsi, %r15
movl %edi, %ebp
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x7db8
movq (%rbx), %r12
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
testq %r12, %r12
je 0x8575
cmpl %ebp, 0x8(%r12)
jne 0x855e
leaq 0x2c(%r12), %rsi
movq %r15, %rdi
callq 0x2060
testl %eax, %eax
je 0x8564
movq (%r12), %r12
jmp 0x8541
addq $0xc, %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x20a0
xorl %ebx, %ebx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x858f
movq (%rdi), %r14
callq 0x2040
movq %r14, %rdi
testq %r14, %r14
jne 0x857f
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/nerves-project[P]nerves_initramfs/src/rootdisk.c
// Function: create_dev_symlink
static void create_dev_symlink(const char *partition_suffix, const char *devname)
{
    char symlinkpath[SHORT_PATH_MAX];
    char devpath[SHORT_PATH_MAX];

    snprintf(symlinkpath, sizeof(symlinkpath), "/dev/rootdisk%s", partition_suffix);
    snprintf(devpath, sizeof(devpath), "/dev/%s", devname);
    if (symlink(devpath, symlinkpath) < 0)
        info("Could not create symlink '%s'->'%s': %s", symlinkpath, devpath, strerror(errno));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x200, %rsp            # imm = 0x200
movq %rsi, %rbx
movq %rdi, %rcx
leaq 0x2091(%rip), %rdx      # 0xab3c
leaq 0x100(%rsp), %r14
movl $0x100, %esi            # imm = 0x100
movq %r14, %rdi
xorl %eax, %eax
callq 0x2210
leaq 0x2083(%rip), %rdx      # 0xab4c
movq %rsp, %r15
movl $0x100, %esi            # imm = 0x100
movq %r15, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2210
movq %r15, %rdi
movq %r14, %rsi
callq 0x2200
testl %eax, %eax
jns 0x8b15
callq 0x2070
movl (%rax), %edi
callq 0x24d0
leaq 0x2054(%rip), %rdi      # 0xab54
leaq 0x100(%rsp), %rsi
movq %rsp, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x3270
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/nerves-project[P]nerves_initramfs/src/rootdisk.c
// Function: read_dev_file
static dev_t read_dev_file(const char *base, const char *name)
{
    char fname[SHORT_PATH_MAX];
    snprintf(fname, sizeof(fname), "%.64s/%.32s/dev", base, name);
    FILE *fp = fopen(fname, "r");
    if (!fp)
        return 0;

    unsigned int dev_major;
    unsigned int dev_minor;

    dev_t d = 0;
    if (fscanf(fp, "%u:%u", &dev_major, &dev_minor) == 2) {
#if defined(__APPLE__)
        d = (dev_major << 8) + dev_minor;
#else
        d = makedev(dev_major, dev_minor);
#endif
    }

    fclose(fp);
    return d;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
movq %rsi, %r8
movq %rdi, %rcx
leaq 0x1f94(%rip), %rdx      # 0xaad7
xorl %ebx, %ebx
leaq 0x10(%rsp), %r14
movl $0x100, %esi            # imm = 0x100
movq %r14, %rdi
xorl %eax, %eax
callq 0x2210
leaq 0x5b2(%rip), %rsi       # 0x9112
movq %r14, %rdi
callq 0x2420
testq %rax, %rax
je 0x8baa
movq %rax, %r14
leaq 0x1f70(%rip), %rsi      # 0xaae7
xorl %ebx, %ebx
leaq 0xc(%rsp), %rdx
leaq 0x8(%rsp), %rcx
movq %rax, %rdi
xorl %eax, %eax
callq 0x20c0
cmpl $0x2, %eax
jne 0x8ba2
movl 0xc(%rsp), %edi
movl 0x8(%rsp), %esi
callq 0x24e0
movq %rax, %rbx
movq %r14, %rdi
callq 0x2170
movq %rbx, %rax
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x8(%rdi), %rax
movl $0x1, %ebx
cmpl $0x0, (%rax)
jne 0x79d4
movl %r9d, %r14d
movq %rcx, %r12
movq %rdx, %r13
movq %rdi, %r15
movq %r8, -0x30(%rbp)
addq $0x188, %r15            # imm = 0x188
movl $0x7, %edx
movq %rsi, %rdi
movq %rcx, %rsi
movq %r15, %rcx
xorl %r8d, %r8d
callq 0x7100
testl %eax, %eax
je 0x79e5
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %r14d, %eax
cmpl $0x0, (%r15,%rax,8)
js 0x79d4
movslq 0x4(%r15,%rax,8), %rax
addq %rax, %r12
movq -0x30(%rbp), %rax
movq %r12, (%rax)
movl $0x7, %edx
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rcx
xorl %r8d, %r8d
callq 0x7100
testl %eax, %eax
jne 0x79d4
movslq (%r15), %rax
testq %rax, %rax
js 0x79d4
movq -0x30(%rbp), %rcx
addq (%rcx), %rax
movq %rax, 0x8(%rcx)
xorl %ebx, %ebx
jmp 0x79d4
// File: /workspace/github_c_makefile_star2_O1/jaroslov[P]docoptc/./docopt.h
// Function: docopt_get
docopt_str_t* docopt_get(docopt_t doc, const char* cmd, int idx)
{
    struct docopt_entries* dE   = (struct docopt_entries*)doc;
    assert(!dE->error || (dE->error == DOCOPT_PRINTED_HELP));
    struct docopt_str str       = { cmd, cmd + strlen(cmd) };
    struct docopt_entry* owner  = 0;
    struct docopt_str* result   = 0;
    int entry                   = 0;
    if ((entry = docopt_entries_get_entry(dE, &str)) < 0)
        return 0;
    owner                       = docopt_fetch_entry(dE, entry);
    for (int i = 0; (i < dE->nargs) && (idx >= 0); ++i)
        if (dE->args[i].owner == owner)
        {
            if (dE->args[i].value.fst)
                result  = &dE->args[i].value;
            else
                result  = &owner->defvalue;
            --idx;
        }
    if ((idx >= 0) && owner->defvalue.fst)
    {
        return &owner->defvalue;
    }
    return (idx < 0) ? result : 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
movl (%rdi), %eax
testl %eax, %eax
je 0x862c
cmpl $0x5, %eax
jne 0x86e2
leaq -0x30(%rbp), %r12
movq %r15, (%r12)
movq %r15, %rdi
callq 0x7070
addq %r15, %rax
movq %rax, 0x8(%r12)
movq %r14, %rdi
movq %r12, %rsi
callq 0x8701
testl %eax, %eax
js 0x86b5
movl %eax, %eax
imulq $0x38, %rax, %rax
movslq 0x30(%r14), %rdx
addq 0x28(%r14), %rax
testq %rdx, %rdx
setle %cl
testl %ebx, %ebx
setns %r9b
sets %sil
orb %cl, %sil
jne 0x86b9
movq 0x38(%r14), %rsi
leaq 0x28(%rax), %rdi
addq $0x8, %rsi
movl $0x1, %r8d
xorl %ecx, %ecx
cmpq %rax, -0x8(%rsi)
jne 0x869d
cmpq $0x0, (%rsi)
movq %rsi, %rcx
cmoveq %rdi, %rcx
decl %ebx
testl %ebx, %ebx
setns %r9b
cmpq %rdx, %r8
jae 0x86bb
addq $0x18, %rsi
incq %r8
testl %ebx, %ebx
jns 0x868a
jmp 0x86bb
xorl %eax, %eax
jmp 0x86d5
xorl %ecx, %ecx
testb %r9b, %r9b
je 0x86cd
cmpq $0x0, 0x28(%rax)
je 0x86cd
addq $0x28, %rax
jmp 0x86d5
xorl %eax, %eax
testl %ebx, %ebx
cmovsq %rcx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1a1d(%rip), %rdi      # 0xa106
leaq 0x1a47(%rip), %rsi      # 0xa137
leaq 0x1a4b(%rip), %rcx      # 0xa142
movl $0x3fe, %edx            # imm = 0x3FE
callq 0x7080
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movslq 0x20(%rdi), %r13
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testq %r13, %r13
jle 0x879d
movq %rdi, %r14
movq (%rsi), %rax
movq 0x8(%rsi), %rbx
movq %rax, -0x30(%rbp)
subq %rax, %rbx
movl %ebx, %eax
movq %rax, -0x38(%rbp)
movl $0x10, %r15d
xorl %r12d, %r12d
testl %ebx, %ebx
je 0x8787
movq 0x28(%r14), %rax
movl -0x8(%rax,%r15), %ecx
movq -0x10(%rax,%r15), %rsi
subl %esi, %ecx
cmpl %ecx, %ebx
jne 0x8769
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rdx
callq 0x7040
testl %eax, %eax
je 0x879a
cmpl $0x2, %ebx
jne 0x8787
movq 0x28(%r14), %rsi
addq %r15, %rsi
movl $0x2, %edx
movq -0x30(%rbp), %rdi
callq 0x7040
testl %eax, %eax
je 0x879a
incq %r12
addq $0x38, %r15
cmpq %r12, %r13
jne 0x8740
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x879d
movl %r12d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
testq %rdi, %rdi
je 0x87e4
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
testq %rdi, %rdi
je 0x87c8
callq 0x7030
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x87d6
callq 0x7030
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x7030
retq
// File: /workspace/github_c_makefile_star2_O1/jaroslov[P]docoptc/test.c
// Function: check_test
int check_test(docopt_t doc, int i)
{
    for (int j = 0; tests[i].checks[j].key; ++j)
    {
        struct docopt_str* get  = docopt_get(doc, tests[i].checks[j].key, tests[i].checks[j].index);
        if (!get)
        {
            fprintf(stdout, "(%d): %s\n", i, usages[tests[i].usage]);
            fprintf(stdout, "Failed to get (%d.%d.%d) %s\n", i, j, tests[i].usage, tests[i].checks[j].key);
            return 1;
        }
        else
        {
            if (tests[i].checks[j].value)
            {
                if ((strlen(tests[i].checks[j].value) != docopt_str_len(get)) ||
                    strncmp(tests[i].checks[j].value, get->fst, docopt_str_len(get)))
                {
                    fprintf(stdout, "(%d): %s\n", i, usages[tests[i].usage]);
                    fprintf(stdout, "Mismatch (%d.%d.%d) %s wants='%s' gots='%s'\n", i, j, tests[i].usage, tests[i].checks[j].key, tests[i].checks[j].value, get->fst);
                    return 1;
                }
            }
        }
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, -0x38(%rbp)
movslq %esi, %rax
imulq $0x3c8, %rax, %rax      # imm = 0x3C8
leaq 0x5788(%rip), %rcx      # 0xe210
movq 0xf8(%rax,%rcx), %r14
testq %r14, %r14
setne %dl
je 0x8bd2
movl %esi, -0x30(%rbp)
leaq (%rcx,%rax), %rsi
movq %rsi, -0x40(%rbp)
leaq (%rax,%rcx), %r12
addq $0x110, %r12            # imm = 0x110
xorl %r15d, %r15d
movb %dl, -0x29(%rbp)
movl -0x10(%r12), %edx
movq -0x38(%rbp), %rdi
movq %r14, %rsi
callq 0x8606
testq %rax, %rax
je 0x8b7f
movq -0x8(%r12), %rbx
testq %rbx, %rbx
je 0x8b02
movq %rax, %r13
movq %rbx, %rdi
callq 0x7070
movl 0x8(%r13), %edx
movq (%r13), %rsi
subl %esi, %edx
cmpq %rdx, %rax
jne 0x8b1a
movq %rbx, %rdi
callq 0x7040
testl %eax, %eax
jne 0x8b1a
movq (%r12), %r14
incl %r15d
addq $0x18, %r12
testq %r14, %r14
setne %dl
jne 0x8ab5
jmp 0x8bd2
movq 0x284b7(%rip), %rax     # 0x30fd8
movq (%rax), %rdi
movq -0x40(%rbp), %rax
movslq (%rax), %rcx
movq %rcx, -0x38(%rbp)
leaq 0x2858a(%rip), %rax     # 0x310c0
movq (%rax,%rcx,8), %rcx
leaq 0x338a(%rip), %rsi      # 0xbecb
movl -0x30(%rbp), %r12d
movl %r12d, %edx
xorl %eax, %eax
callq 0x70f0
movq 0x28482(%rip), %rax     # 0x30fd8
movq (%rax), %rdi
leaq 0x3392(%rip), %rsi      # 0xbef2
movl %r12d, %edx
movl %r15d, %ecx
movq -0x38(%rbp), %r8
movq %r14, %r9
xorl %eax, %eax
pushq (%r13)
pushq %rbx
callq 0x70f0
addq $0x10, %rsp
jmp 0x8bcf
movq 0x28452(%rip), %r12     # 0x30fd8
movq (%r12), %rdi
movq -0x40(%rbp), %rax
movslq (%rax), %rbx
leaq 0x28528(%rip), %rax     # 0x310c0
movq (%rax,%rbx,8), %rcx
leaq 0x3328(%rip), %rsi      # 0xbecb
movl -0x30(%rbp), %r13d
movl %r13d, %edx
xorl %eax, %eax
callq 0x70f0
movq (%r12), %rdi
leaq 0x3319(%rip), %rsi      # 0xbed5
movl %r13d, %edx
movl %r15d, %ecx
movl %ebx, %r8d
movq %r14, %r9
xorl %eax, %eax
callq 0x70f0
movb -0x29(%rbp), %dl
movzbl %dl, %eax
andl $0x1, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r15d
movq %rdi, %rbx
movslq 0x1c(%rdi), %r14
leal 0x1(%r14), %eax
movslq 0x18(%rdi), %rsi
cmpl %esi, %eax
jl 0x8c1e
leal (%rsi,%rsi), %eax
movl %eax, 0x18(%rbx)
movq 0x20(%rbx), %rdi
shlq $0x4, %rsi
callq 0x7110
movq %rax, 0x20(%rbx)
movq 0x20(%rbx), %rax
movq $0x0, (%rax,%r14,8)
movq 0x20(%rbx), %rax
movl 0x4(%rax,%r14,8), %ecx
andl $0x1f, %r15d
andl $-0x20, %ecx
orl %r15d, %ecx
movl %ecx, 0x4(%rax,%r14,8)
incl 0x1c(%rbx)
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x8(%rdi), %rax
cmpl $0x0, (%rax)
jne 0x9517
movq %rsi, %rbx
movq (%rsi), %r14
movq 0x8(%rsi), %r12
cmpq %r12, %r14
jae 0x9517
leaq 0x1752(%rip), %r15      # 0xac1a
movl $0x3, %edx
movq %r15, %rdi
movq %r14, %rsi
callq 0x7040
testl %eax, %eax
je 0x9517
movsbl (%r14), %r13d
movl $0x6, %edx
leaq 0x2d4e(%rip), %rdi      # 0xc23a
movl %r13d, %esi
callq 0x70c0
testq %rax, %rax
jne 0x9517
movslq %r13d, %r13
callq 0x7150
movq (%rax), %rax
testb $0x20, 0x1(%rax,%r13,2)
jne 0x9517
incq %r14
movq %r14, (%rbx)
cmpq %r12, %r14
jne 0x94c8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %rbx
pushq %rax
movl %esi, %ebx
movl %edi, %ebp
movslq %esi, %rax
movslq %edx, %rdi
imulq %rax, %rdi
addq $0x18, %rdi
testb %cl, %cl
je 0x83a1
movl $0x1, %esi
callq 0x80e0
jmp 0x83a6
callq 0x81d0
testq %rax, %rax
je 0x83b8
movl %ebp, (%rax)
movl %ebx, 0x10(%rax)
movq $0x0, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq