LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/ridiculousfish[P]docopt_fish/docopt_fish_parse_tree.cpp
// Function: docopt_fish::parse_one_usage(docopt_fish::rstring_t const&, std::vector<docopt_fish::option_t, std::allocator<docopt_fish::option_t>> const&, std::vector<docopt_fish::error_t, std::allocator<docopt_fish::error_t>>*)
usage_t parse_one_usage(const rstring_t &source, const option_list_t &shortcut_options,
                        vector<error_t> *out_errors) {
    parse_context_t ctx(source, shortcut_options);
    usage_t result = ctx.parse_usage();

    // Return errors
    if (out_errors) {
        std::move(ctx.errors.begin(), ctx.errors.end(), std::back_inserter(*out_errors));
    }

    // Be careful not to return the usage in case of error
    // It may be an invalid usage, i.e. not respect the invariants
    // expected in match()
    if (ctx.errors.empty()) {
        return result;
    } else {
        return usage_t();
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rcx, %r15
movq %rdi, %r14
movq 0x10(%rsi), %rax
leaq 0x50(%rsp), %rbx
movq %rax, -0x10(%rbx)
movups (%rsi), %xmm0
movaps %xmm0, -0x20(%rbx)
movq %rdx, -0x8(%rbx)
xorps %xmm0, %xmm0
movaps %xmm0, (%rbx)
andq $0x0, 0x10(%rbx)
movq %rsp, %rdi
leaq 0x30(%rsp), %rsi
callq 0xf7fc
testq %r15, %r15
je 0xf39e
movq 0x50(%rsp), %rdi
movq 0x58(%rsp), %rsi
movq %r15, %rdx
callq 0xed00
movq 0x50(%rsp), %rax
cmpq 0x58(%rsp), %rax
je 0xf3bd
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%r14)
movups %xmm0, 0x10(%r14)
movups %xmm0, (%r14)
jmp 0xf3ef
movq 0x10(%rsp), %rax
movq %rax, 0x10(%r14)
movups (%rsp), %xmm0
movups %xmm0, (%r14)
movups 0x18(%rsp), %xmm0
movups %xmm0, 0x18(%r14)
movq 0x28(%rsp), %rax
movq %rax, 0x28(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rsp)
andq $0x0, 0x28(%rsp)
leaq 0x18(%rsp), %rdi
callq 0xe282
movq %rbx, %rdi
callq 0xebbc
movq %r14, %rax
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0xe282
jmp 0xf420
movq %rax, %r14
movq %rbx, %rdi
callq 0xebbc
movq %r14, %rdi
callq 0x7390
// File: /workspace/github_cpp_makefile_star2_O2/ridiculousfish[P]docopt_fish/docopt_fish_parse_tree.cpp
// Function: docopt_fish::dump_usage[abi:cxx11](docopt_fish::usage_t const&)
string_t dump_usage(const usage_t &usage) {
    node_dumper_t dumper;
    dumper.begin(usage);
    string_t result;
    for (const string_t &line : dumper.lines) {
        result.append(line);
        result.push_back('\n');
    }
    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %r14
leaq 0x8(%rsp), %rbx
andl $0x0, -0x8(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
andq $0x0, 0x10(%rbx)
movq %rsp, %rdi
callq 0x10c16
leaq 0x10(%r14), %rax
movq %rax, (%r14)
andq $0x0, 0x8(%r14)
andl $0x0, 0x10(%r14)
movq 0x8(%rsp), %r15
movq 0x10(%rsp), %r12
pushq $0xa
popq %rbp
cmpq %r12, %r15
je 0xf742
movq %r14, %rdi
movq %r15, %rsi
callq 0x73a0
movq %r14, %rdi
movl %ebp, %esi
callq 0x70a0
addq $0x20, %r15
jmp 0xf722
movq %rbx, %rdi
callq 0xb092
movq %r14, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
jmp 0xf76a
movq %rax, %r15
movq %r14, %rdi
callq 0x7050
movq %rbx, %rdi
callq 0xb092
movq %r15, %rdi
callq 0x7390
// File: /workspace/github_cpp_makefile_star2_O2/ridiculousfish[P]docopt_fish/docopt_fish_parse_tree.cpp
// Function: docopt_fish::collect_options(std::vector<docopt_fish::usage_t, std::allocator<docopt_fish::usage_t>> const&)
option_list_t collect_options(const std::vector<usage_t> &usages) {
    option_collector_t collector;
    for (const usage_t &usage : usages) {
        collector.begin(usage);
    }
    return std::move(collector.options);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq %rsp, %r14
andq $0x0, 0x10(%r14)
xorps %xmm0, %xmm0
movaps %xmm0, (%r14)
movq (%rsi), %r15
movq 0x8(%rsi), %r12
cmpq %r12, %r15
je 0xf7b8
addq $0x18, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x11cca
addq $0x18, %r15
jmp 0xf79e
movq %rsp, %rdi
movaps (%rdi), %xmm0
movups %xmm0, (%rbx)
movq 0x10(%rdi), %rax
movq %rax, 0x10(%rbx)
xorps %xmm0, %xmm0
movaps %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
callq 0xef34
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0xef34
movq %rbx, %rdi
callq 0x7390
nop
// File: /workspace/github_cpp_makefile_star2_O2/ridiculousfish[P]docopt_fish/docopt_fish_parse_tree.cpp
// Function: docopt_fish::parse_context_t::parse_usage()
usage_t parse_usage() {
        usage_t result;
        bool scanned = this->scan_word(&result.prog_name);
        assert(scanned);  // else we should not have tried to parse this as a usage
        parse(&result.alternation_list);

        // We may get an empty alternation list if we are just the program name.
        // In that case, ensure we have at least one.
        if (result.alternation_list.alternations.empty()) {
            result.alternation_list.alternations.emplace_back();
        }
        return result;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movq %rsi, %rdi
movq %rbx, %rsi
callq 0xf9a2
testb %al, %al
je 0xf84e
leaq 0x18(%rbx), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0xf9e8
movq 0x18(%rbx), %rax
cmpq 0x20(%rbx), %rax
jne 0xf845
movq %r15, %rdi
callq 0xfa8c
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0xd68f(%rip), %rdi      # 0x1cee4
leaq 0xd690(%rip), %rsi      # 0x1ceec
leaq 0xd6a4(%rip), %rcx      # 0x1cf07
movl $0x9e, %edx
callq 0x7150
movq %rax, %r14
addq $0x18, %rbx
movq %rbx, %rdi
callq 0xe282
movq %r14, %rdi
callq 0x7390
// File: /workspace/github_cpp_makefile_star2_O2/ridiculousfish[P]docopt_fish/docopt_fish_parse_tree.cpp
// Function: docopt_fish::parse_context_t::scan_word(docopt_fish::rstring_t*)
bool scan_word(rstring_t *tok) {
        this->consume_leading_whitespace();
        // A word may have embedded <>
        // These may abut: --foo<abc_def>bar' is one word.
        *tok = this->remaining.scan_while<char_is_valid_in_word>();
        return !tok->empty();
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0xfac6
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xfada
movq 0x10(%r15), %rax
movq %rax, 0x10(%rbx)
movups (%r15), %xmm0
movups %xmm0, (%rbx)
cmpq $0x0, 0x8(%rbx)
setne %al
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ridiculousfish[P]docopt_fish/docopt_fish_parse_tree.cpp
// Function: docopt_fish::parse_context_t::parse(docopt_fish::alternation_list_t*)
bool parse(alternation_list_t *result) {
        size_t count = 0;
        // We expect only one alternation
        result->alternations.reserve(1);
        for (;;) {
            // Scan a vert bar if we're not first
            rstring_t bar;
            if (count > 0 && !this->scan("|", &bar)) {
                break;
            }
            if (!try_parse_appending(&result->alternations)) {
                if (count > 0) {
                    error(bar, error_trailing_vertical_bar, "Trailing vertical bar");
                }
                break;
            }
            count++;
        }

        // If we have an alternation like [-e | --erase], mark them as the same
        // option
        // This is kind of a hackish place to do this
        collapse_corresponding_options(result);

        return count > 0;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0xf884
xorl %r13d, %r13d
leaq 0xd535(%rip), %r15      # 0x1cf46
movq %rsp, %r12
xorl %ebp, %ebp
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
andq $0x0, 0x10(%rsp)
subq $0x1, %rbp
jb 0xfa3b
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0xfbc8
testb %al, %al
je 0xfa69
movq %r14, %rdi
movq %rbx, %rsi
callq 0xfc18
testb %al, %al
je 0xfa4f
movq %rbp, %r13
jmp 0xfa16
testq %r13, %r13
je 0xfa6e
leaq 0xd4ed(%rip), %rcx      # 0x1cf48
movq %rsp, %rsi
pushq $0xe
popq %rdx
movq %r14, %rdi
callq 0xfc6c
movb $0x1, %bpl
jmp 0xfa70
xorl %ebp, %ebp
movq %r14, %rdi
movq %rbx, %rsi
callq 0xfc88
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/ridiculousfish[P]docopt_fish/docopt_fish_parse_tree.cpp
// Function: bool docopt_fish::parse_context_t::try_parse_appending<docopt_fish::expression_list_t>(std::vector<docopt_fish::expression_list_t, std::allocator<docopt_fish::expression_list_t>>*)
inline bool try_parse_appending(vector<T> *vec) {
        T val;
        bool parsed = this->parse(&val);
        if (parsed) {
            vec->push_back(std::move(val));
        }
        return parsed;
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
andq $0x0, 0x10(%rsi)
callq 0xfdaa
movl %eax, %ebx
testb %al, %al
je 0xfc46
movq %rsp, %rsi
movq %r14, %rdi
callq 0xf958
movq %rsp, %rdi
callq 0xe2f0
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0xe2f0
movq %rbx, %rdi
callq 0x7390
nop
// File: /workspace/github_cpp_makefile_star2_O2/ridiculousfish[P]docopt_fish/docopt_fish_parse_tree.cpp
// Function: docopt_fish::parse_context_t::collapse_corresponding_options(docopt_fish::alternation_list_t*)
void collapse_corresponding_options(alternation_list_t *list) {
        assert(list != nullptr);
        // Must have exactly 2 alternations
        if (list->alternations.size() != 2) {
            return;
        }
        option_t *opt1 = single_option(&list->alternations[0]);
        option_t *opt2 = single_option(&list->alternations[1]);

        // Both options must be non-NULL, and they must not have overlapping name types, and their
        // values must agree (perhaps both empty)
        if (opt1 && opt2 && opt1->value == opt2->value) {
            // check to see if their name types overlap
            bool names_overlap = false;
            for (size_t i=0; i < option_t::NAME_TYPE_COUNT; i++) {
                if (!opt1->names[i].empty() && !opt2->names[i].empty()) {
                    names_overlap = true;
                    break;
                }
            }
            if (! names_overlap) {
                // Merge them. Note: this merge_from call writes deep into our tree!
                // Then delete the second alternation
                opt1->merge_from(*opt2);
                list->alternations.pop_back();
                assert(list->alternations.size() == 1);
            }
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rsi, %rsi
je 0xfd24
movq %rsi, %rbx
movq (%rsi), %rdi
movq 0x8(%rsi), %rax
subq %rdi, %rax
cmpq $0x30, %rax
jne 0xfd1e
callq 0x106b4
movq %rax, %r14
movq (%rbx), %rdi
addq $0x18, %rdi
callq 0x106b4
movq %rax, %r15
testq %r14, %r14
sete %al
testq %r15, %r15
sete %cl
orb %al, %cl
jne 0xfd1e
leaq 0x48(%r14), %rdi
leaq 0x48(%r15), %rsi
callq 0xb81e
testb %al, %al
je 0xfd1e
pushq $0x8
popq %rax
cmpq $0x50, %rax
je 0xfcfe
cmpq $0x0, (%r14,%rax)
je 0xfcf8
cmpq $0x0, (%r15,%rax)
jne 0xfd1e
addq $0x18, %rax
jmp 0xfce4
movq %r14, %rdi
movq %r15, %rsi
callq 0xd734
movq %rbx, %rdi
callq 0x106e2
movq 0x8(%rbx), %rax
subq (%rbx), %rax
cmpq $0x18, %rax
jne 0xfd43
popq %rbx
popq %r14
popq %r15
retq
leaq 0xd351(%rip), %rdi      # 0x1d07c
leaq 0xd1ba(%rip), %rsi      # 0x1ceec
leaq 0xd353(%rip), %rcx      # 0x1d08c
movl $0x170, %edx            # imm = 0x170
callq 0x7150
leaq 0xd39a(%rip), %rdi      # 0x1d0e4
leaq 0xd19b(%rip), %rsi      # 0x1ceec
leaq 0xd334(%rip), %rcx      # 0x1d08c
movl $0x188, %edx            # imm = 0x188
callq 0x7150
// File: /workspace/github_cpp_makefile_star2_O2/ridiculousfish[P]docopt_fish/./docopt_fish_types.h
// Function: docopt_fish::rstring_t::scan_string(char const*)
rstring_t scan_string(const char *c) {
        // Here we hope the compiler can effectively optimize strlen(),
        // since it will be called again within has_prefix
        rstring_t result;
        if (this->has_prefix(c)) {
            result = this->chop_length(strlen(c));
        }
        return result;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x8f1a
testb %al, %al
je 0xfda0
movq %r15, %rdi
callq 0x70c0
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xaa86
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ridiculousfish[P]docopt_fish/docopt_fish_parse_tree.cpp
// Function: docopt_fish::node_dumper_t::accept(docopt_fish::rstring_t const&)
inline bool try_parse_unique(unique_ptr<T> *p) {
        T val;
        bool parsed = this->parse(&val);
        if (parsed) {
            emplace_unique(p, std::move(val));
        }
        return parsed;
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0xa8, %rsp
cmpq $0x0, 0x8(%rsi)
je 0x1117f
movq %rsi, %r14
movq %rdi, %rbx
movl (%rdi), %esi
addl %esi, %esi
leaq 0x38(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x28(%rsp), %rdi
pushq $0x20
popq %rdx
callq 0x7400
leaq 0x58(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x48(%rsp), %rdi
pushq $0x1
popq %rsi
pushq $0x27
popq %rdx
callq 0x7400
leaq 0x68(%rsp), %rdi
movq %r14, %rsi
callq 0xac82
leaq 0x88(%rsp), %rdi
leaq 0x48(%rsp), %rsi
leaq 0x68(%rsp), %rdx
callq 0x111fd
movq %rsp, %rdi
leaq 0x88(%rsp), %rsi
leaq 0x48(%rsp), %rdx
callq 0x111de
leaq 0x28(%rsp), %rdi
movq %rsp, %rsi
callq 0x73a0
movq %rsp, %rdi
callq 0x7050
leaq 0x88(%rsp), %rdi
callq 0x7050
leaq 0x68(%rsp), %rdi
callq 0x7050
movq (%r14), %rcx
movq 0x8(%r14), %r8
cmpq $0x1, %r8
jne 0x1112a
leaq 0xbfee(%rip), %rdx      # 0x1d109
movq %rsp, %rdi
pushq $0x20
popq %rsi
xorl %eax, %eax
callq 0x7360
jmp 0x1113e
leaq 0xbfde(%rip), %rdx      # 0x1d10f
movq %rsp, %rdi
pushq $0x20
popq %rsi
xorl %eax, %eax
callq 0x7360
movq %rsp, %r14
movq %r14, %rdi
callq 0x70c0
leaq (%rsp,%rax), %rdx
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq 0x11222
addq $0x8, %rbx
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x10d3c
leaq 0x48(%rsp), %rdi
callq 0x7050
leaq 0x28(%rsp), %rdi
callq 0x7050
addq $0xa8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x7050
jmp 0x1119a
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0x7050
jmp 0x111ac
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x7050
jmp 0x111c2
jmp 0x111bf
movq %rax, %rbx
jmp 0x111cc
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x7050
leaq 0x28(%rsp), %rdi
callq 0x7050
movq %rbx, %rdi
callq 0x7390
// File: /workspace/github_cpp_makefile_star2_O2/ridiculousfish[P]docopt_fish/docopt_fish_parse_tree.cpp
// Function: docopt_fish::parse_context_t::peek(char const*)
bool peek(const char *s) {
        const rstring_t saved = this->remaining;
        rstring_t tok;
        bool result = scan(s, &tok);
        this->remaining = saved;
        return result;
    }

// Assembly:
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %rax
movq %rax, 0x10(%rsp)
movups (%rdi), %xmm0
movaps %xmm0, (%rsp)
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rdx
movaps %xmm0, (%rdx)
andq $0x0, 0x10(%rdx)
callq 0xfbc8
movaps (%rsp), %xmm0
movups %xmm0, (%rbx)
movq 0x10(%rsp), %rcx
movq %rcx, 0x10(%rbx)
addq $0x40, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ridiculousfish[P]docopt_fish/docopt_fish_parse_tree.cpp
// Function: docopt_fish::parse_context_t::parse(docopt_fish::simple_clause_t*)
bool parse(simple_clause_t *result) {
        rstring_t word = this->peek_word();
        if (word.empty()) {
            // Nothing remaining to parse
            return false;
        }

        rstring_t::char_t c = word[0];
        if (c == '<') {
            return this->try_parse_unique(&result->variable);
        } else if (c == '-' && word.length() > 1) {
            // A naked '-', is to be treated as a fixed value
            return this->try_parse_unique(&result->option);
        } else {
            return this->try_parse_unique(&result->fixed);
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x101be
cmpq $0x0, 0x8(%r15)
je 0x1015b
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0xa94e
cmpl $0x2d, %eax
je 0x1015f
cmpl $0x3c, %eax
jne 0x10174
addq $0x10, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1020c
jmp 0x10183
xorl %eax, %eax
jmp 0x10183
cmpq $0x2, 0x10(%rsp)
jb 0x10174
movq %r14, %rdi
movq %rbx, %rsi
callq 0x10242
jmp 0x10183
addq $0x8, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x10294
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/ridiculousfish[P]docopt_fish/docopt_fish_parse_tree.cpp
// Function: docopt_fish::parse_context_t::peek_word()
rstring_t peek_word() {
        const rstring_t saved = this->remaining;
        rstring_t tok;
        scan_word(&tok);
        this->remaining = saved;
        return tok;
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rsi), %rax
movq %rax, 0x10(%rsp)
movups (%rsi), %xmm0
movaps %xmm0, (%rsp)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
movq %rsi, %rdi
movq %r14, %rsi
callq 0xf9a2
movaps (%rsp), %xmm0
movups %xmm0, (%rbx)
movq 0x10(%rsp), %rax
movq %rax, 0x10(%rbx)
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/ridiculousfish[P]docopt_fish/docopt_fish_parse_tree.cpp
// Function: void docopt_fish::node_dumper_t::accept<docopt_fish::usage_t>(docopt_fish::usage_t const&)
void accept(const NODE_TYPE &node) {
        string_t result(2 * depth, ' ');
        const std::string name = node.name();
        result.append(name.begin(), name.end());
        lines.push_back(result);
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl (%rdi), %esi
addl %esi, %esi
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x8(%rsp), %rdi
pushq $0x20
popq %rdx
callq 0x7400
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq 0x10d00
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x10d22
addq $0x8, %rbx
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x10d3c
leaq 0x28(%rsp), %rdi
callq 0x70e0
leaq 0x8(%rsp), %rdi
callq 0x7050
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
jmp 0x10cc2
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x70e0
leaq 0x8(%rsp), %rdi
callq 0x7050
movq %rbx, %rdi
callq 0x7390
// File: /workspace/github_cpp_makefile_star2_O2/ridiculousfish[P]docopt_fish/./docopt_fish_grammar.h
// Function: void docopt_fish::expression_t::visit_children<docopt_fish::node_dumper_t>(docopt_fish::node_dumper_t*) const
void visit_children(T *v) const {
        v->visit(simple_clause);
        v->visit(open_token);
        v->visit(alternation_list);
        v->visit(close_token);
        v->visit(opt_ellipsis);
        v->visit(options_shortcut);
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
movq %r14, %rsi
callq 0x116be
leaq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0x11034
leaq 0x20(%r14), %rsi
movq %rbx, %rdi
callq 0x116ce
leaq 0x28(%r14), %rsi
movq %rbx, %rdi
callq 0x11034
leaq 0x40(%r14), %rsi
movq %rbx, %rdi
callq 0x116de
addq $0x60, %r14
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x116ee
nop
// File: /workspace/github_cpp_makefile_star2_O2/ridiculousfish[P]docopt_fish/docopt_matching.cpp
// Function: docopt_fish::match(docopt_fish::usage_t const&, docopt_fish::match_state_t, docopt_fish::match_context_t const&, std::vector<docopt_fish::match_state_t, std::allocator<docopt_fish::match_state_t>>*)
static void match(const usage_t &node, match_state_t state, const match_context_t &ctx,
                  match_state_list_t *resulting_states) {
    if (!ctx.has_more_positionals(state)) {
        // todo: error handling
        return;
    }

    if (node.prog_name.empty()) {
        // This is the final terminating usage. It does not match anything.
        return;
    }

    // Program name, then match against our contents
    ctx.acquire_next_positional(&state);
    match(node.alternation_list, state.move(), ctx, resulting_states);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
movq %rdx, %rdi
callq 0x13474
testb %al, %al
je 0x120b1
cmpq $0x0, 0x8(%r15)
je 0x120b1
movq %r14, %rdi
movq %r12, %rsi
callq 0x134ae
addq $0x18, %r15
movq %rsp, %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x1341a
movq %r15, %rdi
movq %r13, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x120d2
movq %rsp, %rdi
callq 0x130ce
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x130ce
movq %rbx, %rdi
callq 0x7390
// File: /workspace/github_cpp_makefile_star2_O2/ridiculousfish[P]docopt_fish/docopt_matching.cpp
// Function: docopt_fish::match(docopt_fish::alternation_list_t const&, docopt_fish::match_state_t, docopt_fish::match_context_t const&, std::vector<docopt_fish::match_state_t, std::allocator<docopt_fish::match_state_t>>*)
static void match(const alternation_list_t &node, match_state_t state,
                  const match_context_t &ctx, match_state_list_t *resulting_states) {
    size_t count = node.alternations.size();
    if (count == 0) {
        return;
    }
    for (size_t i = 0; i + 1 < count; i++) {
        match(node.alternations.at(i), state.copy(), ctx, resulting_states);
    }
    match(node.alternations.at(count - 1), state.move(), ctx, resulting_states);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rcx, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq %rsi, %r12
movq %rdi, %r13
movq 0x8(%rdi), %rcx
movq (%rdi), %rsi
movq %rcx, %rax
subq %rsi, %rax
pushq $0x18
popq %rdi
cqto
idivq %rdi
cmpq %rsi, %rcx
je 0x1219c
movq %rax, %rbp
xorl %esi, %esi
leaq 0x78(%rsp), %r15
leaq 0x1(%rsi), %r14
cmpq %rbp, %r14
jae 0x1215c
movq %r13, %rdi
callq 0x13538
movq %rax, %rbx
movq %r15, %rdi
movq %r12, %rsi
callq 0x14754
movq %rbx, %rdi
movq %r15, %rsi
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rcx
callq 0x121c3
movq %r15, %rdi
callq 0x130ce
movq %r14, %rsi
jmp 0x1211b
decq %rbp
movq %r13, %rdi
movq %rbp, %rsi
callq 0x13538
movq %rax, %r13
leaq 0x18(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x1341a
movq %r13, %rdi
movq %r15, %rsi
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rcx
callq 0x121c3
leaq 0x18(%rsp), %rdi
callq 0x130ce
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x121b0
movq %rax, %rbx
movq %r15, %rdi
callq 0x130ce
movq %rbx, %rdi
callq 0x7390
// File: /workspace/github_cpp_makefile_star2_O2/ridiculousfish[P]docopt_fish/docopt_matching.cpp
// Function: void docopt_fish::match_list<docopt_fish::expression_t>(docopt_fish::expression_t const&, std::vector<docopt_fish::match_state_t, std::allocator<docopt_fish::match_state_t>>&&, docopt_fish::match_context_t const&, std::vector<docopt_fish::match_state_t, std::allocator<docopt_fish::match_state_t>>*, bool)
static void match_list(const T &node, match_state_list_t &&incoming_state_list, const match_context_t &ctx,
                       match_state_list_t *resulting_states, bool require_progress = false) {
    for (match_state_t &state : incoming_state_list) {
        // If we require that this makes progress, then get the current progress so
        // we can compare
        size_t init_progress = npos;
        size_t init_size = -1;
        if (require_progress) {
            init_progress = state.progress();
            init_size = resulting_states->size();
        }

        match(node, state.move(), ctx, resulting_states);

        if (require_progress) {
            // Keep only those results that have increased in progress. States after
            // init_size are new.
            size_t idx = resulting_states->size();
            assert(idx >= init_size);
            while (idx-- > init_size) {  // last processed idx will be init_size
                size_t new_progress = resulting_states->at(idx).progress();
                assert(new_progress >= init_progress);  // should never go backwards
                if (new_progress == init_progress) {
                    // No progress was made, toss this state
                    resulting_states->erase(resulting_states->begin() + idx);
                }
            }
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r15
movq (%rsi), %r12
movq 0x8(%rsi), %rbp
leaq 0x8(%rsp), %r13
cmpq %rbp, %r12
je 0x128cf
movq %r13, %rdi
movq %r12, %rsi
callq 0x1341a
movq %r15, %rdi
movq %r13, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x12377
movq %r13, %rdi
callq 0x130ce
addq $0x60, %r12
jmp 0x128a0
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x130ce
movq %rbx, %rdi
callq 0x7390
// File: /workspace/github_cpp_makefile_star2_O2/ridiculousfish[P]docopt_fish/docopt_matching.cpp
// Function: docopt_fish::cow_ref_t<std::map<docopt_fish::rstring_t, docopt_fish::argument_t, std::less<docopt_fish::rstring_t>, std::allocator<std::pair<docopt_fish::rstring_t const, docopt_fish::argument_t>>>>::mut()
T& mut() {
        // perform the copy-on-write if there is no unique owner
        if (! ptr.unique()) {
            ptr = std::make_shared<T>(*ptr);
        }
        return *ptr;
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x133a9
movl 0x8(%rax), %eax
cmpl $0x1, %eax
je 0x133ce
movq (%rbx), %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x14a19
movq %rbx, %rdi
movq %r14, %rsi
callq 0x13fd8
leaq 0x10(%rsp), %rdi
callq 0x14006
movq (%rbx), %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ridiculousfish[P]docopt_fish/docopt_matching.cpp
// Function: docopt_fish::match_context_t::has_consumed_everything(docopt_fish::match_state_t const&) const
bool has_consumed_everything(const match_state_t &state) const {
        if (has_more_positionals(state)) {
            // Unconsumed positional
            return false;
        }

        // Now return whether all of our consumed options are true
        const std::vector<bool> &ops = *state.consumed_options;
        return std::all_of(ops.begin(), ops.end(), [](bool v) { return v; });
    }

// Assembly:
pushq %rbx
movq %rsi, %rbx
callq 0x13474
testb %al, %al
je 0x13c19
xorl %eax, %eax
popq %rbx
retq
movq 0x10(%rbx), %rax
movq (%rax), %rdi
movq 0x10(%rax), %rdx
movl 0x18(%rax), %ecx
xorl %esi, %esi
popq %rbx
jmp 0x13c2f
// File: /workspace/github_cpp_makefile_star2_O2/ridiculousfish[P]docopt_fish/docopt_matching.cpp
// Function: docopt_fish::match_state_t::progress() const
size_t progress() const {
        // Add in positionals
        size_t result = this->next_positional_index;

        // Add in arguments by counting set bits in the bitmap
        result += std::accumulate(this->consumed_options->cbegin(),
                                  this->consumed_options->cend(),
                                  0);

        // Add in number of suggestions
        result += suggested_next_arguments.size();

        return result;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rax
movq 0x20(%rdi), %r14
movq (%rax), %rdi
movq 0x10(%rax), %rdx
movl 0x18(%rax), %ecx
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x13ecd
cltq
addq %r14, %rax
addq 0x50(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/ridiculousfish[P]docopt_fish/docopt_fish_test.cpp
// Function: join[abi:cxx11](std::vector<docopt_fish::suggestion_t, std::allocator<docopt_fish::suggestion_t>> const&, char const*)
string_t join(const suggestion_list_t &vec, const char *delim) {
    string_t result;
    const string_t delim_string = to_string(delim);
    for (size_t i=0; i < vec.size(); i++) {
        if (i > 0) {
            result.append(delim_string);
        }
        result.append(vec.at(i).token);
    }
    return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rsi, %r14
andl $0x0, 0x10(%rdi)
movq %rsp, %rdi
movq %rdx, %rsi
callq 0x15160
xorl %r15d, %r15d
movl $0x90, %r13d
movq %rsp, %r12
movq 0x8(%r14), %rax
subq (%r14), %rax
cqto
idivq %r13
cmpq %rax, %r15
jae 0x15209
testq %r15, %r15
je 0x151ee
movq %rbx, %rdi
movq %r12, %rsi
callq 0x73a0
movq %r14, %rdi
movq %r15, %rsi
callq 0x19dba
movq %rbx, %rdi
movq %rax, %rsi
callq 0x73a0
incq %r15
jmp 0x151cd
movq %rsp, %rdi
callq 0x7050
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
jmp 0x15232
movq %rax, %r14
movq %rsp, %rdi
callq 0x7050
movq %rbx, %rdi
callq 0x7050
movq %r14, %rdi
callq 0x7390
// File: /workspace/github_cpp_makefile_star2_O2/ridiculousfish[P]docopt_fish/docopt_fish_test.cpp
// Function: join(std::vector<std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>, std::allocator<std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>>> const&, char const*)
string_t join(const string_list_t &vec, const char *delim) {
    string_t result;
    const string_t delim_string = to_string(delim);
    for (size_t i=0; i < vec.size(); i++) {
        if (i > 0) {
            result.append(delim_string);
        }
        result.append(vec.at(i));
    }
    return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rsi, %r14
andl $0x0, 0x10(%rdi)
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0x15160
xorl %r15d, %r15d
leaq 0x8(%rsp), %r12
movq 0x8(%r14), %rax
subq (%r14), %rax
sarq $0x5, %rax
cmpq %rax, %r15
jae 0x152b3
testq %r15, %r15
je 0x15298
movq %rbx, %rdi
movq %r12, %rsi
callq 0x73a0
movq %r14, %rdi
movq %r15, %rsi
callq 0x9290
movq %rbx, %rdi
movq %rax, %rsi
callq 0x73a0
incq %r15
jmp 0x15278
leaq 0x8(%rsp), %rdi
callq 0x7050
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
jmp 0x152de
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x7050
movq %rbx, %rdi
callq 0x7050
movq %r14, %rdi
callq 0x7390
// File: /workspace/github_cpp_makefile_star2_O2/ridiculousfish[P]docopt_fish/docopt_fish_test.cpp
// Function: err(char const*, ...)
__attribute__ ((format (printf, 1, 2)))
static void err(const char *blah, ...)
{
    static bool has_term = !! getenv("TERM");
    va_list va;
    va_start(va, blah);
    err_count++;
    
    // show errors in red
    if (has_term) {
        fputs("\x1b[31m", stdout);
    }
    
    printf("Error: ");
    vprintf(blah, va);
    va_end(va);
    
    if (has_term) {
        // return to normal color
        fputs("\x1b[0m", stdout);
    }
    
    printf("\n");
}

// Assembly:
pushq %rbx
subq $0xd0, %rsp
movq %rdi, %rbx
movq %rsi, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0x154fc
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movb 0x1fd5e(%rip), %al      # 0x35260
testb %al, %al
je 0x1559e
leaq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0xe0(%rsp), %rax
movq %rax, 0x8(%rsp)
incq 0x1fd28(%rip)           # 0x35250
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rsp)
cmpb $0x1, 0x1fd1b(%rip)     # 0x35258
jne 0x15555
movq 0x1fa6a(%rip), %rax     # 0x34fb0
movq (%rax), %rsi
leaq 0x852e(%rip), %rdi      # 0x1da7e
callq 0x72b0
leaq 0x8528(%rip), %rdi      # 0x1da84
xorl %eax, %eax
callq 0x7040
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x7280
cmpb $0x1, 0x1fce3(%rip)     # 0x35258
jne 0x1558d
movq 0x1fa32(%rip), %rax     # 0x34fb0
movq (%rax), %rsi
leaq 0x8504(%rip), %rdi      # 0x1da8c
callq 0x72b0
pushq $0xa
popq %rdi
callq 0x72e0
addq $0xd0, %rsp
popq %rbx
retq
leaq 0x1fcbb(%rip), %rdi     # 0x35260
callq 0x73e0
testl %eax, %eax
je 0x1550a
leaq 0x84c0(%rip), %rdi      # 0x1da79
callq 0x72d0
testq %rax, %rax
setne 0x1fc90(%rip)           # 0x35258
leaq 0x1fc91(%rip), %rdi     # 0x35260
callq 0x7140
jmp 0x1550a
// File: /workspace/github_cpp_makefile_star2_O2/ridiculousfish[P]docopt_fish/docopt_fish_test.cpp
// Function: split_nonempty[abi:cxx11](char const*, char)
static string_list_t split_nonempty(const char *str, char delimiter) {
    string_list_t result;
    const char *cursor = str;
    for (;;) {
        const char *next = strchr(cursor, delimiter);
        if (next == nullptr) {
            next = cursor + strlen(cursor);
        }
        
        /* Insert the token if it is not empty */
        if (next > cursor) {
            result.push_back(string_t(cursor, next));
        }
        
        // Skip over delimeters
        while (*next == delimiter) {
            next++;
        }
        // Break if we're done
        if (*next == '\0') {
            break;
        }
        cursor = next;
    }
    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
leaq 0x18(%rsp), %r13
leaq 0x8(%rsp), %r14
movq %r15, %rdi
movl %ebp, %esi
callq 0x7090
movq %rax, %r12
testq %rax, %rax
jne 0x18eab
movq %r15, %rdi
callq 0x70c0
movq %rax, %r12
addq %r15, %r12
cmpq %r15, %r12
jbe 0x18ed6
movq %r13, 0x8(%rsp)
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x1b7e6
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc8d0
movq %r14, %rdi
callq 0x7050
decq %r12
movq %r12, %r15
movb 0x1(%r15), %al
incq %r15
cmpb %bpl, %al
je 0x18edc
testb %al, %al
jne 0x18e8b
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x18f10
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x7050
movq %rbx, %rdi
callq 0xb092
movq %r14, %rdi
callq 0x7390
// File: /workspace/github_cpp_makefile_star2_O2/ridiculousfish[P]docopt_fish/docopt_fish_test.cpp
// Function: wide(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
static const wchar_t *wide(const string &t) {
    static wstring result[16];
    static size_t idx = 0;
    idx = (idx + 1) % 16;
    result[idx].erase();
    result[idx].insert(result[idx].begin(), t.begin(), t.end());
    return result[idx].c_str();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb 0x1c543(%rip), %al      # 0x35470
testb %al, %al
je 0x18f93
movl 0x1c541(%rip), %edi     # 0x35478
incl %edi
andl $0xf, %edi
movq %rdi, 0x1c535(%rip)     # 0x35478
shll $0x5, %edi
leaq 0x1c323(%rip), %r14     # 0x35270
addq %r14, %rdi
pushq $-0x1
popq %rdx
xorl %esi, %esi
callq 0x7030
movq 0x1c517(%rip), %rax     # 0x35478
shlq $0x5, %rax
leaq (%r14,%rax), %rdi
movq (%rax,%r14), %rsi
movq (%rbx), %rdx
movq 0x8(%rbx), %rcx
addq %rdx, %rcx
callq 0x19fd8
movq 0x1c4f5(%rip), %rax     # 0x35478
shlq $0x5, %rax
movq (%rax,%r14), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x1c4d6(%rip), %rdi     # 0x35470
callq 0x73e0
testl %eax, %eax
je 0x18f31
xorl %eax, %eax
leaq 0x1c2c4(%rip), %rcx     # 0x35270
leaq (%rax,%rcx), %rdx
addq $0x10, %rdx
movq %rdx, -0x10(%rdx)
andq $0x0, -0x8(%rdx)
andl $0x0, (%rdx)
addq $0x20, %rax
cmpq $0x200, %rax            # imm = 0x200
jne 0x18fac
leaq -0x11b0e(%rip), %rdi    # 0x74c5
leaq 0x1c24e(%rip), %rdx     # 0x35228
xorl %esi, %esi
callq 0x71e0
leaq 0x1c488(%rip), %rdi     # 0x35470
callq 0x7140
jmp 0x18f31
// File: /workspace/github_cpp_makefile_star2_O2/ridiculousfish[P]docopt_fish/docopt_fish_test.cpp
// Function: parse_expected_results[abi:cxx11](char const*)
static map<string_t, string_t> parse_expected_results(const char *joined_expected_results) {
    map<string_t, string_t> expected;
    string_list_t expected_lines = split_nonempty(joined_expected_results, '\n');
    for (size_t i=0; i < expected_lines.size(); i++) {
        const string_t &str = expected_lines.at(i);
        size_t colon = str.find(':');
        assert(colon != string_t::npos);
        
        const string_t key(str, 0, colon);
        const string_t value(str, colon + 1);
        expected[key] = value;
    }
    return expected;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
leaq 0x8(%rdi), %rax
andl $0x0, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
andq $0x0, 0x28(%rdi)
leaq 0x10(%rsp), %rdi
pushq $0xa
popq %rdx
callq 0x18e60
xorl %r14d, %r14d
leaq 0x48(%rsp), %r12
leaq 0x28(%rsp), %r13
movq 0x18(%rsp), %rax
subq 0x10(%rsp), %rax
sarq $0x5, %rax
cmpq %rax, %r14
jae 0x190c4
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
callq 0x1a022
movq %rax, %rbp
movq %rax, %rdi
pushq $0x3a
popq %rsi
xorl %edx, %edx
callq 0x71f0
cmpq $-0x1, %rax
je 0x190e0
movq %rax, %r15
movq %r12, %rdi
movq %rbp, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x7200
incq %r15
movq %r13, %rdi
movq %rbp, %rsi
movq %r15, %rdx
leaq 0xf(%rsp), %rcx
callq 0x71c0
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1a044
movq %rax, %rdi
movq %r13, %rsi
callq 0x7330
movq %r13, %rdi
callq 0x7050
movq %r12, %rdi
callq 0x7050
incq %r14
jmp 0x19037
leaq 0x10(%rsp), %rdi
callq 0xb092
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x6a10(%rip), %rdi      # 0x1faf7
leaq 0x6915(%rip), %rsi      # 0x1fa03
leaq 0x6a1a(%rip), %rcx      # 0x1fb0f
movl $0x9c, %edx
callq 0x7150
movq %rax, %r14
jmp 0x19131
jmp 0x1910b
movq %rax, %r14
jmp 0x1911d
movq %rax, %r14
jmp 0x19127
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x7050
leaq 0x48(%rsp), %rdi
callq 0x7050
leaq 0x10(%rsp), %rdi
callq 0xb092
movq %rbx, %rdi
callq 0x1a584
movq %r14, %rdi
callq 0x7390
// File: /workspace/github_cpp_makefile_star2_O2/ridiculousfish[P]docopt_fish/docopt_fish_test.cpp
// Function: split(std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>> const&, char const*)
static string_list_t split(const string_t &str, const char *delim) {
    string_list_t result;
    const string_t delim_string = to_string(delim);
    size_t cursor = 0;
    while (cursor <= str.size()) {
        size_t delim_pos = str.find(delim_string, cursor);
        if (delim_pos == string_t::npos) {
            delim_pos = str.size();
        }
        result.push_back(str.substr(cursor, delim_pos - cursor));
        cursor = delim_pos + delim_string.size();
    }
    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0x15160
xorl %ebp, %ebp
leaq 0x8(%rsp), %r15
leaq 0x28(%rsp), %r12
cmpq 0x8(%r14), %rbp
ja 0x1921a
movq %r14, %rdi
movq %r15, %rsi
movq %rbp, %rdx
callq 0x7420
movq %rax, %r13
cmpq $-0x1, %rax
jne 0x191e9
movq 0x8(%r14), %r13
movq %r13, %rcx
subq %rbp, %rcx
movq %r12, %rdi
movq %r14, %rsi
movq %rbp, %rdx
callq 0x70f0
movq %rbx, %rdi
movq %r12, %rsi
callq 0xc8d0
movq %r12, %rdi
callq 0x7050
addq 0x10(%rsp), %r13
movq %r13, %rbp
jmp 0x191c8
leaq 0x8(%rsp), %rdi
callq 0x7050
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x19257
movq %rax, %r14
jmp 0x1924d
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x7050
leaq 0x8(%rsp), %rdi
callq 0x7050
movq %rbx, %rdi
callq 0xb092
movq %r14, %rdi
callq 0x7390
// File: /workspace/github_cpp_makefile_star2_O2/ridiculousfish[P]docopt_fish/docopt_fish_test.cpp
// Function: build_metadata[abi:cxx11](char const*, char const*, char const*, int)
static metadata_t build_metadata(const char *command, const char *description, const char *condition, int tag) {
    metadata_t result;
    const string_t empty;
    result.command = command ? to_string(command) : empty;
    result.description = description ? to_string(description) : empty;
    result.condition = condition ? to_string(condition) : empty;
    result.tag = tag;
    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0xabee
leaq 0x38(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
andl $0x0, (%rax)
testq %r15, %r15
je 0x192a6
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x15160
jmp 0x192b5
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x71d0
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x7330
leaq 0x8(%rsp), %rdi
callq 0x7050
leaq 0x3c72(%rip), %rsi      # 0x1cf45
leaq 0x8(%rsp), %rdi
callq 0x15160
leaq 0x40(%rbx), %rdi
leaq 0x8(%rsp), %rsi
callq 0x7330
leaq 0x8(%rsp), %rdi
callq 0x7050
testq %r14, %r14
je 0x19309
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x15160
jmp 0x19318
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x71d0
leaq 0x20(%rbx), %rdi
leaq 0x8(%rsp), %rsi
callq 0x7330
leaq 0x8(%rsp), %rdi
callq 0x7050
movl %ebp, 0x60(%rbx)
leaq 0x28(%rsp), %rdi
callq 0x7050
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x19353
jmp 0x19362
jmp 0x19353
jmp 0x19362
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x7050
jmp 0x19365
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x7050
movq %rbx, %rdi
callq 0xac62
movq %r14, %rdi
callq 0x7390
// File: /workspace/github_cpp_makefile_star2_O2/eecs280staff[P]unit_test_framework/test/string_equal.cpp
// Function: string_equal()
TEST(string_equal) {
  std::string s1 = "hello";
  ASSERT_EQUAL(s1, "hello");
  ASSERT_EQUAL("hello", s1);
  char cs[] = "hello";
  ASSERT_EQUAL(s1, cs);
  ASSERT_EQUAL(cs, s1);

  std::string s2 = "world";
  ASSERT_NOT_EQUAL(s2, "hello");
  ASSERT_NOT_EQUAL("hello", s2);
  ASSERT_NOT_EQUAL(s2, cs);
  ASSERT_NOT_EQUAL(cs, s2);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x58, %rsp
leaq 0x2b75(%rip), %rbx      # 0x506f
leaq 0x38(%rsp), %r14
leaq 0x18(%rsp), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2660
leaq 0x2b25(%rip), %rcx      # 0x503b
pushq $0x6
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2da2
leaq 0x2b44(%rip), %rdi      # 0x506f
leaq 0x2b23(%rip), %rcx      # 0x5055
leaq 0x38(%rsp), %rsi
pushq $0x7
popq %rdx
callq 0x2eba
leaq 0x10(%rsp), %rsi
movw $0x6f, 0x4(%rsi)
movl $0x6c6c6568, (%rsi)     # imm = 0x6C6C6568
leaq 0x2b1e(%rip), %rcx      # 0x5075
leaq 0x38(%rsp), %rdi
pushq $0x9
popq %rdx
callq 0x2fd2
leaq 0x2b1f(%rip), %rcx      # 0x508a
leaq 0x10(%rsp), %rdi
leaq 0x38(%rsp), %rsi
pushq $0xa
popq %rdx
callq 0x30ea
leaq 0x2b1b(%rip), %rsi      # 0x509f
leaq 0x18(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x2660
leaq 0x2ad5(%rip), %rsi      # 0x506f
leaq 0x2b04(%rip), %rcx      # 0x50a5
leaq 0x18(%rsp), %rdi
pushq $0xd
popq %rdx
callq 0x3202
leaq 0x2aba(%rip), %rdi      # 0x506f
leaq 0x2b07(%rip), %rcx      # 0x50c3
leaq 0x18(%rsp), %rsi
pushq $0xe
popq %rdx
callq 0x332a
leaq 0x2b11(%rip), %rcx      # 0x50e1
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
pushq $0xf
popq %rdx
callq 0x3452
leaq 0x2b11(%rip), %rcx      # 0x50fa
leaq 0x10(%rsp), %rdi
leaq 0x18(%rsp), %rsi
pushq $0x10
popq %rdx
callq 0x357a
leaq 0x18(%rsp), %rdi
callq 0x20c0
leaq 0x38(%rsp), %rdi
callq 0x20c0
addq $0x58, %rsp
popq %rbx
popq %r14
retq
jmp 0x261b
jmp 0x261b
movq %rax, %rbx
jmp 0x262d
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x20c0
leaq 0x38(%rsp), %rdi
callq 0x20c0
movq %rbx, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O2/MichaelXanth[P]RPG_Game/Battle/Battle.cpp
// Function: Battle::AttackWithWeapon(Hero&, Monster&)
bool Battle::AttackWithWeapon(Hero& hero, Monster& monster)
{
    unsigned int totalDamage = hero.GetWeaponDamage() + hero.GetStrength();

    if ((double)rand() / RAND_MAX > monster.MonsterGetAvoidance()) {
        monster.ChangeHealth(floor((double)(totalDamage * totalDamage) / (totalDamage + monster.MonsterGetDefence())));
        //changes the monster's health according to the function (damage*damage)/(damage + armor)
        return true;
    
    } else {
        cout << monster.Living::GetName() << " avoided the attack!" << endl;
        usleep(1500000);
        return false;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %r15
callq 0xdb3a
movl %eax, %r14d
movq %r15, %rdi
callq 0xd066
movl %eax, %ebp
callq 0x3060
cvtsi2sd %eax, %xmm0
divsd 0x11e51(%rip), %xmm0    # 0x1b260
movsd %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x1280a
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x10(%rsp)
movsd (%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x9472
addl %r14d, %ebp
movl %ebp, %eax
imull %eax, %eax
cvtsi2sd %rax, %xmm0
movsd %xmm0, 0x8(%rsp)
movq %rbx, %rdi
callq 0x12800
addl %ebp, %eax
cvtsi2sd %rax, %xmm1
movsd 0x8(%rsp), %xmm0
divsd %xmm1, %xmm0
callq 0x3300
cvttsd2si %xmm0, %rsi
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
jmp 0x94bc
leaq 0x18(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0xced6
movq 0x1db3f(%rip), %rdi     # 0x26fc8
movq %r14, %rsi
callq 0x3190
leaq 0x11e1c(%rip), %rsi     # 0x1b2b4
movq %rax, %rdi
callq 0x31d0
movq %rax, %rdi
callq 0x30d0
leaq 0x18(%rsp), %rdi
callq 0x30c0
movl $0x16e360, %edi         # imm = 0x16E360
callq 0x32a0
movsd (%rsp), %xmm0
ucomisd 0x10(%rsp), %xmm0
seta %al
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x30c0
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/MichaelXanth[P]RPG_Game/Battle/Battle.cpp
// Function: Battle::CastSpell(Hero&, Monster&)
bool Battle::CastSpell(Hero& hero, Monster& monster) 
{
    unsigned int totalDamage;
    unsigned int slotNumber;
    unsigned int typeOfSpell;
    Spell* chosenSpell;

    if (hero.DisplaySpells(chosenSpell , slotNumber , typeOfSpell) == false)
        return false;

    // Checks if the hero has enough magic power
    if (hero.UseSpell(*chosenSpell) == true) { 
        hero.ReduceMagicPower(chosenSpell->GetReqEnergy()); // Reduces the hero's magic power
        totalDamage = chosenSpell->HeroDamage(hero);        // Gets the total damage that will be caused
        monster.ChangeHealth(floor((double)(totalDamage * totalDamage) / (totalDamage + monster.MonsterGetDefence())));
        monster.HitBySpell(chosenSpell);                    // Applies the after attack effects of the spell
        hero.SpellUsed(slotNumber , typeOfSpell);           // Deletes the spell
        
        if (monster.Fainted()) {
            cout << "The hero " << hero.GetName() << " defeated the monster " << monster.GetName() << endl;
            return true;
        }
    }
    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, %r15
movq %rsp, %rsi
leaq 0xc(%rsp), %rdx
leaq 0x8(%rsp), %rcx
callq 0xf948
movl %eax, %ebx
testb %al, %al
je 0x9630
movq (%rsp), %rsi
movq %r15, %rdi
callq 0xd168
testb %al, %al
je 0x9630
movq (%rsp), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
leaq 0x38(%rsp), %rsi
movl %eax, (%rsi)
movq %r15, %rdi
callq 0xd05c
movq (%rsp), %rdi
movq %r15, %rsi
callq 0x195e2
movl %eax, %ebp
imull %eax, %eax
cvtsi2sd %rax, %xmm0
movsd %xmm0, 0x10(%rsp)
movq %r14, %rdi
callq 0x12800
addl %ebp, %eax
cvtsi2sd %rax, %xmm1
movsd 0x10(%rsp), %xmm0
divsd %xmm1, %xmm0
callq 0x3300
cvttsd2si %xmm0, %rsi
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movq (%rsp), %rsi
movq %r14, %rdi
callq 0x12816
movl 0xc(%rsp), %esi
movl 0x8(%rsp), %edx
movq %r15, %rdi
callq 0xd838
movq %r14, %rdi
callq 0xcecc
testb %al, %al
je 0x9630
movq 0x1da0a(%rip), %rdi     # 0x26fc8
leaq 0x11cca(%rip), %rsi     # 0x1b28f
callq 0x31d0
movq %rax, %r12
leaq 0x38(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0xced6
movq %r12, %rdi
movq %r13, %rsi
callq 0x3190
leaq 0x11caa(%rip), %rsi     # 0x1b299
movq %rax, %rdi
callq 0x31d0
movq %rax, %r15
leaq 0x18(%rsp), %rdi
movq %r14, %rsi
callq 0xced6
leaq 0x18(%rsp), %rsi
movq %r15, %rdi
callq 0x3190
movq %rax, %rdi
callq 0x30d0
leaq 0x18(%rsp), %rdi
callq 0x30c0
leaq 0x38(%rsp), %rdi
callq 0x30c0
movl %ebx, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x9652
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x30c0
jmp 0x9655
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x30c0
movq %rbx, %rdi
callq 0x3330
nop