LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/ridiculousfish[P]docopt_fish/./docopt_fish_types.h
// Function: docopt_fish::rstring_t::trim_whitespace() const
rstring_t trim_whitespace() const {
        size_t left = 0, right = this->length();
        while (left < right && char_is_whitespace(this->at(left))) {
            left++;
        }
        while (right > left && char_is_whitespace(this->at(right - 1))) {
            right--;
        }
        assert(left <= right);
        return this->substr(left, right - left);
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rsi), %rax
movabsq $0x100002600, %rdi      # imm = 0x100002600
testq %rax, %rax
je 0xe647
movq (%rsi), %rcx
shlq $0x2, %rcx
addq 0x10(%rsi), %rcx
xorl %edx, %edx
movl (%rcx,%rdx,4), %r8d
cmpq $0x20, %r8
ja 0xe649
btq %r8, %rdi
jae 0xe649
incq %rdx
cmpq %rdx, %rax
jne 0xe62a
movq %rax, %rdx
jmp 0xe649
xorl %edx, %edx
cmpq %rdx, %rax
jbe 0xe686
movq (%rsi), %rcx
movq 0x10(%rsi), %r8
leaq (%r8,%rcx,4), %r8
addq $-0x4, %r8
movq %rax, %rcx
leaq -0x1(%rcx), %r9
cmpq %r9, %rax
jb 0xe69b
movl (%r8,%rcx,4), %r10d
cmpq $0x20, %r10
ja 0xe689
btq %r10, %rdi
jae 0xe689
movq %r9, %rcx
cmpq %rdx, %r9
ja 0xe660
movq %rdx, %rcx
jmp 0xe689
movq %rax, %rcx
subq %rdx, %rcx
jb 0xe6ba
movq %rbx, %rdi
callq 0x9e70
movq %rbx, %rax
popq %rbx
retq
leaq 0x13f2c(%rip), %rdi     # 0x225ce
leaq 0x13ee2(%rip), %rsi     # 0x2258b
leaq 0x13f33(%rip), %rcx     # 0x225e3
movl $0x76, %edx
callq 0x7120
leaq 0x14512(%rip), %rdi     # 0x22bd3
leaq 0x13ec3(%rip), %rsi     # 0x2258b
leaq 0x14512(%rip), %rcx     # 0x22be1
movl $0x13c, %edx            # imm = 0x13C
callq 0x7120
nop
// File: /workspace/github_cpp_makefile_star2_O1/ridiculousfish[P]docopt_fish/./docopt_fish_types.h
// Function: docopt_fish::rstring_t::find_case_insensitive(char const*) const
inline size_t find_internal(const char *needle) const {
        // Empty string always found first
        if (needle[0] == '\0') {
            return 0;
        }
        
        auto does_match = [](char_t a, char b){
            if (static_cast<long>(a) >= CHAR_MAX) {
                // Outside of ASCII, no match possible
                return false;
            }
            return a == b || (case_insensitive && tolower(a) == tolower(b));
        };
        
        const char_t *result = std::search(this->begin(), this->end(),
                                           needle, needle + strlen(needle),
                                           does_match);
        return result == this->end() ? npos : result - this->begin();
    }

// Assembly:
cmpb $0x0, (%rsi)
je 0xe746
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %r15
movq 0x8(%rdi), %rax
shlq $0x2, %r15
addq 0x10(%rdi), %r15
leaq (%r15,%rax,4), %r12
movq %rsi, %rdi
callq 0x70b0
leaq (%rax,%r14), %rcx
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0xe907
movq (%rbx), %rcx
movq 0x8(%rbx), %rdx
shlq $0x2, %rcx
addq 0x10(%rbx), %rcx
leaq (%rcx,%rdx,4), %rdx
cmpq %rdx, %rax
leaq 0x8(%rsp), %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
je 0xe749
subq %rcx, %rax
sarq $0x2, %rax
retq
xorl %eax, %eax
retq
movq $-0x1, %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/ridiculousfish[P]docopt_fish/./docopt_fish_types.h
// Function: docopt_fish::option_t::merge_from(docopt_fish::option_t const&)
void merge_from(const option_t &rhs) {
        for (size_t i = 0; i < NAME_TYPE_COUNT; i++) {
            this->names[i].replace_if_empty(rhs.names[i]);
        }
        this->flags |= rhs.flags;
        this->value.replace_if_empty(rhs.value);
        this->default_value.replace_if_empty(rhs.default_value);
    }

// Assembly:
leaq 0x8(%rdi), %rax
xorl %ecx, %ecx
cmpq $0x0, (%rax,%rcx)
jne 0xed5f
leaq (%rax,%rcx), %rdx
addq $-0x8, %rdx
movq 0x10(%rsi,%rcx), %r8
movq %r8, 0x10(%rdx)
movups (%rsi,%rcx), %xmm0
movups %xmm0, (%rdx)
addq $0x18, %rcx
cmpq $0x48, %rcx
jne 0xed40
movl 0x78(%rsi), %eax
orl %eax, 0x78(%rdi)
cmpq $0x0, 0x50(%rdi)
jne 0xed86
movq 0x58(%rsi), %rax
movq %rax, 0x58(%rdi)
movups 0x48(%rsi), %xmm0
movups %xmm0, 0x48(%rdi)
cmpq $0x0, 0x68(%rdi)
je 0xed8e
retq
movq 0x70(%rsi), %rax
movq %rax, 0x70(%rdi)
movups 0x60(%rsi), %xmm0
movups %xmm0, 0x60(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/ridiculousfish[P]docopt_fish/./docopt_fish_types.h
// Function: docopt_fish::option_t::has_same_name(docopt_fish::option_t const&) const
bool has_same_name(const option_t &opt2) const {
        bool result = false;
        for (size_t i = 0; i < NAME_TYPE_COUNT; i++) {
            const rstring_t &s1 = this->names[i], &s2 = opt2.names[i];
            if (s1.length() > 0 && s1 == s2) {
                result = true;
                break;
            }
        }
        return result;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %r12d, %r12d
xorl %r15d, %r15d
movq 0x8(%r14,%r12), %rax
testq %rax, %rax
je 0xf5d8
cmpq 0x8(%rbx,%r12), %rax
jne 0xf5d8
leaq (%r14,%r12), %rdi
leaq (%rbx,%r12), %rsi
callq 0xbfd4
testl %eax, %eax
je 0xf5ee
xorl %eax, %eax
testb %al, %al
jne 0xf5f5
leaq 0x18(%r12), %rax
cmpq $0x30, %r12
movq %rax, %r12
jne 0xf5b6
jmp 0xf5f5
movb $0x1, %al
movb $0x1, %r15b
jmp 0xf5da
andb $0x1, %r15b
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x68, %rsp
movq %rcx, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %rcx
leaq 0x30(%rsp), %rax
movq %rcx, 0x10(%rax)
movups (%rsi), %xmm0
movaps %xmm0, (%rax)
movq %rdx, 0x18(%rax)
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rax)
movq $0x0, 0x30(%rax)
movq %rsp, %rdi
movq %rax, %rsi
callq 0x10db4
testq %r14, %r14
je 0x1084d
movq 0x50(%rsp), %rdi
movq 0x58(%rsp), %rsi
movq %r14, %rdx
callq 0x101fa
movq 0x50(%rsp), %rax
cmpq 0x58(%rsp), %rax
je 0x10869
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
jmp 0x108a5
movq 0x10(%rsp), %rax
movq %rax, 0x10(%rbx)
movups (%rsp), %xmm0
movups %xmm0, (%rbx)
movq 0x18(%rsp), %rax
movq %rax, 0x18(%rbx)
movq 0x20(%rsp), %rax
movq %rax, 0x20(%rbx)
movq 0x28(%rsp), %rax
movq %rax, 0x28(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rsp)
movq $0x0, 0x28(%rsp)
leaq 0x18(%rsp), %rdi
callq 0xf894
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x108c6
movq 0x60(%rsp), %rsi
subq %rdi, %rsi
callq 0x7200
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0xf894
jmp 0x108e3
movq %rax, %rbx
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x108fa
movq 0x60(%rsp), %rsi
subq %rdi, %rsi
callq 0x7200
movq %rbx, %rdi
callq 0x7360
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r15
movq %rdi, %r14
leaq 0x8(%rsp), %rbx
movl $0x0, -0x8(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movq %rsp, %rdi
callq 0x1282a
movq %rsp, %rsi
movq %r15, %rdi
callq 0x12924
leaq 0x10(%r14), %r12
movq %r12, (%r14)
movq $0x0, 0x8(%r14)
movl $0x0, 0x10(%r14)
movq 0x8(%rsp), %r15
movq 0x10(%rsp), %r13
cmpq %r13, %r15
je 0x10cde
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r14, %rdi
callq 0x7250
movq %r14, %rdi
movl $0xa, %esi
callq 0x7090
addq $0x20, %r15
jmp 0x10cb7
movq %rbx, %rdi
callq 0xc1d0
movq %r14, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r15
jmp 0x10d18
movq %rax, %r15
movq (%r14), %rdi
cmpq %r12, %rdi
je 0x10d18
movq (%r12), %rax
leaq 0x4(,%rax,4), %rsi
callq 0x7200
movq %rbx, %rdi
callq 0xc1d0
movq %r15, %rdi
callq 0x7360
// File: /workspace/github_cpp_makefile_star2_O1/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
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movq (%rsi), %r15
movq 0x8(%rsi), %r12
cmpq %r12, %r15
je 0x10d6a
movq %rsp, %r14
leaq 0x18(%r15), %rdi
movq %r14, %rsi
callq 0x13b78
addq $0x30, %r15
cmpq %r12, %r15
jne 0x10d55
movq (%rsp), %rax
movq %rax, (%rbx)
movq 0x8(%rsp), %rax
movq %rax, 0x8(%rbx)
movq 0x10(%rsp), %rax
movq %rax, 0x10(%rbx)
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x10dab
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x7200
movq %rbx, %rdi
callq 0x7360
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
leaq 0x8(%rsp), %rdi
callq 0x1138a
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x111a4
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rbx)
movups 0x8(%rsp), %xmm0
movups %xmm0, (%rbx)
cmpq $0x0, 0x8(%rbx)
je 0x10e49
leaq 0x18(%rbx), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x11086
movq 0x20(%rbx), %rsi
cmpq %rsi, 0x18(%rbx)
jne 0x10e3c
cmpq 0x28(%rbx), %rsi
je 0x10e34
xorps %xmm0, %xmm0
movups %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
addq $0x18, 0x20(%rbx)
jmp 0x10e3c
movq %r15, %rdi
callq 0x12212
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x12094(%rip), %rdi     # 0x22ee4
leaq 0x12095(%rip), %rsi     # 0x22eec
leaq 0x120a9(%rip), %rcx     # 0x22f07
movl $0x9e, %edx
callq 0x7120
movq %rax, %r14
addq $0x18, %rbx
movq %rbx, %rdi
callq 0xf894
movq %r14, %rdi
callq 0x7360
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x1138a
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x111a4
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_O1/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 $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl $0x1, %esi
movq %rbx, %rdi
callq 0x10e80
xorl %r13d, %r13d
leaq 0x20(%rsp), %r15
leaq 0x11e90(%rip), %rbp     # 0x22f46
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
testq %r13, %r13
je 0x110ff
movq %r15, %rdi
movq %r14, %rsi
callq 0x1138a
movq %r15, %rdi
movq %r14, %rsi
movq %rbp, %rdx
callq 0x11706
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x20(%rsp), %xmm0
movaps %xmm0, (%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x11165
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movq $0x0, 0x30(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x1178a
movl %eax, %r12d
testb %al, %al
je 0x11141
movq %rbx, %rdi
movq %r15, %rsi
callq 0x10fea
movq %r15, %rdi
callq 0xf8d6
testb %r12b, %r12b
je 0x11149
incq %r13
movb $0x1, %al
jmp 0x11167
movq %r15, %rdi
callq 0xf8d6
testq %r13, %r13
je 0x11165
movq %r14, %rdi
movq %rsp, %rsi
movl $0xe, %edx
leaq 0x11de8(%rip), %rcx     # 0x22f48
callq 0x11574
xorl %eax, %eax
testb %al, %al
jne 0x110b6
movq %r14, %rdi
movq %rbx, %rsi
callq 0x115d2
testq %r13, %r13
setne %al
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xf8d6
movq %rbx, %rdi
callq 0x7360
// File: /workspace/github_cpp_makefile_star2_O1/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 0x116c7
movq %rsi, %rbx
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
subq %rax, %rcx
cmpq $0x30, %rcx
jne 0x116c1
movq (%rax), %rcx
movq 0x8(%rax), %rdx
subq %rcx, %rdx
cmpq $0x68, %rdx
jne 0x11614
movq (%rcx), %rcx
testq %rcx, %rcx
je 0x11619
movq (%rcx), %rcx
jmp 0x1161b
xorl %r14d, %r14d
jmp 0x11626
xorl %ecx, %ecx
leaq 0x18(%rcx), %r14
testq %rcx, %rcx
cmoveq %rcx, %r14
movq 0x18(%rax), %rcx
movq 0x20(%rax), %rax
subq %rcx, %rax
cmpq $0x68, %rax
jne 0x11644
movq (%rcx), %rax
testq %rax, %rax
je 0x11649
movq (%rax), %rax
jmp 0x1164b
xorl %r15d, %r15d
jmp 0x11656
xorl %eax, %eax
leaq 0x18(%rax), %r15
testq %rax, %rax
cmoveq %rax, %r15
testq %r14, %r14
je 0x116c1
testq %r15, %r15
je 0x116c1
movq 0x50(%r14), %rax
cmpq 0x50(%r15), %rax
jne 0x116c1
leaq 0x48(%r15), %rsi
leaq 0x48(%r14), %rdi
callq 0xbfd4
testl %eax, %eax
jne 0x116c1
movl $0x8, %eax
cmpq $0x0, (%r14,%rax)
je 0x1168e
cmpq $0x0, (%r15,%rax)
jne 0x116c1
addq $0x18, %rax
cmpq $0x50, %rax
jne 0x11680
movq %r14, %rdi
movq %r15, %rsi
callq 0xed3a
movq 0x8(%rbx), %rdi
addq $-0x18, %rdi
movq %rdi, 0x8(%rbx)
callq 0xf8d6
movq 0x8(%rbx), %rax
subq (%rbx), %rax
cmpq $0x18, %rax
jne 0x116e6
popq %rbx
popq %r14
popq %r15
retq
leaq 0x11982(%rip), %rdi     # 0x23050
leaq 0x11817(%rip), %rsi     # 0x22eec
leaq 0x11984(%rip), %rcx     # 0x23060
movl $0x170, %edx            # imm = 0x170
callq 0x7120
leaq 0x119cb(%rip), %rdi     # 0x230b8
leaq 0x117f8(%rip), %rsi     # 0x22eec
leaq 0x11965(%rip), %rcx     # 0x23060
movl $0x188, %edx            # imm = 0x188
callq 0x7120
nop
// File: /workspace/github_cpp_makefile_star2_O1/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)
movq $0x0, 0x10(%rdi)
movq %rdx, %rdi
callq 0x70b0
cmpq 0x8(%r14), %rax
ja 0x11781
testq %rax, %rax
sete %sil
je 0x1176e
movq (%r14), %rcx
movq 0x10(%r14), %rdx
movsbl (%r15), %esi
cmpl %esi, (%rdx,%rcx,4)
jne 0x11781
leaq (%rdx,%rcx,4), %rcx
movl $0x1, %edx
cmpq %rdx, %rax
sete %sil
je 0x1176e
movsbl (%r15,%rdx), %esi
leaq 0x1(%rdx), %rdi
cmpl %esi, (%rcx,%rdx,4)
movq %rdi, %rdx
je 0x11752
jmp 0x11781
testb %sil, %sil
je 0x11781
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xbc26
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %rax
movq %rax, 0x10(%rsp)
movups (%rdi), %xmm0
movaps %xmm0, (%rsp)
leaq 0x18(%rsp), %rdi
movq %r14, %rsi
callq 0x1138a
leaq 0x18(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x11706
cmpq $0x0, 0x8(%r15)
setne %al
movq 0x10(%rsp), %rcx
movq %rcx, 0x10(%r14)
movaps (%rsp), %xmm0
movups %xmm0, (%r14)
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xc8, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %rax
movq %rax, 0x10(%rsp)
movups (%rdi), %xmm0
movaps %xmm0, (%rsp)
leaq 0x30(%rsp), %rdi
movq %r14, %rsi
callq 0x1138a
leaq 0x18(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x111a4
movq 0x10(%rsp), %rax
movq %rax, 0x10(%r14)
movaps (%rsp), %xmm0
movups %xmm0, (%r14)
movq 0x8(%r15), %rax
testq %rax, %rax
je 0x11d52
movq 0x18(%rsp), %rcx
movq 0x28(%rsp), %rdx
movl (%rdx,%rcx,4), %ecx
cmpl $0x2d, %ecx
je 0x11d56
cmpl $0x3c, %ecx
jne 0x11d5c
xorps %xmm0, %xmm0
movq %rsp, %r15
movaps %xmm0, (%r15)
movq $0x0, 0x10(%r15)
leaq 0x30(%rsp), %rdi
movq %r14, %rsi
callq 0x1138a
movq %r15, %rdi
movq %r14, %rsi
callq 0x111a4
cmpq $0x0, 0x8(%r15)
setne %bpl
je 0x11dd4
addq $0x10, %rbx
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x11e3d
jmp 0x11dd4
xorl %ebp, %ebp
jmp 0x11dd4
cmpq $0x1, %rax
jne 0x11da2
xorps %xmm0, %xmm0
movq %rsp, %r15
movaps %xmm0, (%r15)
movq $0x0, 0x10(%r15)
leaq 0x30(%rsp), %rdi
movq %r14, %rsi
callq 0x1138a
movq %r15, %rdi
movq %r14, %rsi
callq 0x111a4
cmpq $0x0, 0x8(%r15)
setne %bpl
je 0x11dd4
addq $0x8, %rbx
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x121cb
jmp 0x11dd4
leaq 0x30(%rsp), %r15
movl $0x94, %edx
movq %r15, %rdi
xorl %esi, %esi
callq 0x70e0
movq %r14, %rdi
movq %r15, %rsi
callq 0x11e84
movl %eax, %ebp
testb %al, %al
je 0x11dd4
leaq 0x30(%rsp), %rsi
movq %rbx, %rdi
callq 0x12183
movl %ebp, %eax
addq $0xc8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/ridiculousfish[P]docopt_fish/docopt_fish_parse_tree.cpp
// Function: void docopt_fish::node_dumper_t::accept<docopt_fish::alternation_list_t>(docopt_fish::alternation_list_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 %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
movl (%rdi), %esi
addl %esi, %esi
leaq 0x38(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x28(%rsp), %rdi
movl $0x20, %edx
callq 0x73b0
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x48(%rsp), %rsi
movq $0x10, (%rsi)
leaq 0x8(%rsp), %rdi
xorl %edx, %edx
callq 0x7370
movq %rax, 0x8(%rsp)
movq 0x48(%rsp), %rcx
movq %rcx, 0x18(%rsp)
movups 0x100a8(%rip), %xmm0    # 0x230ed
movups %xmm0, (%rax)
movq %rcx, 0x10(%rsp)
movq 0x8(%rsp), %rax
movb $0x0, (%rax,%rcx)
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %r8
addq %rcx, %r8
leaq 0x28(%rsp), %rdi
movq 0x8(%rdi), %rdx
shlq $0x2, %rdx
addq (%rdi), %rdx
movq %rdx, %rsi
callq 0x1299e
addq $0x8, %rbx
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x12960
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x130a3
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x7200
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0x130bf
movq 0x38(%rsp), %rax
leaq 0x4(,%rax,4), %rsi
callq 0x7200
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
jmp 0x130e8
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x130e8
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x7200
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0x13104
movq 0x38(%rsp), %rax
leaq 0x4(,%rax,4), %rsi
callq 0x7200
movq %rbx, %rdi
callq 0x7360
// File: /workspace/github_cpp_makefile_star2_O1/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
incl (%rsi)
movq %rsi, %rdi
movq %r14, %rsi
callq 0x13426
leaq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0x12bfe
leaq 0x20(%r14), %rsi
movq %rbx, %rdi
callq 0x1391c
leaq 0x28(%r14), %rsi
movq %rbx, %rdi
callq 0x12bfe
decl (%rbx)
leaq 0x40(%r14), %rsi
movq %rbx, %rdi
callq 0x133fa
addq $0x60, %r14
incl (%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x13a52
decl (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x15e40
testb %al, %al
je 0x1413c
cmpq $0x0, 0x8(%r15)
je 0x1413c
movq %r14, %rdi
movq %r12, %rsi
callq 0x15e7a
addq $0x18, %r15
movq %rsp, %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x15dda
movq %r15, %rdi
movq %r13, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x1415d
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0xc244
movq -0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x1412d
callq 0x167a2
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1413c
callq 0x167a2
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x158a2
movq %rbx, %rdi
callq 0x7360
// File: /workspace/github_cpp_makefile_star2_O1/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 $0xe8, %rsp
movq %rcx, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x8(%rdi), %rcx
movq (%rdi), %rax
subq %rax, %rcx
je 0x142d4
movq %rdi, %rbp
sarq $0x3, %rcx
movabsq $-0x5555555555555555, %rax # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rcx
movq %rcx, 0x8(%rsp)
cmpq $0x2, %rcx
jb 0x14244
movq 0x8(%rsp), %rax
leaq -0x1(%rax), %r14
xorl %r15d, %r15d
leaq 0x28(%rsp), %r13
xorl %r12d, %r12d
movq (%rbp), %rbx
movq 0x8(%rbp), %rdx
subq %rbx, %rdx
sarq $0x3, %rdx
movabsq $-0x5555555555555555, %rax # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rdx
cmpq %r12, %rdx
jbe 0x142e6
addq %r15, %rbx
movq %r13, %rdi
movq 0x10(%rsp), %rsi
callq 0x16bc0
movq %rbx, %rdi
movq %r13, %rsi
movq 0x18(%rsp), %rdx
movq 0x20(%rsp), %rcx
callq 0x14315
leaq 0x50(%rsp), %rdi
callq 0xc244
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x14229
callq 0x167a2
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x14238
callq 0x167a2
incq %r12
addq $0x18, %r15
cmpq %r12, %r14
jne 0x141c5
movq 0x8(%rsp), %rsi
decq %rsi
movq (%rbp), %rax
movq 0x8(%rbp), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rdx
cmpq %rsi, %rdx
jbe 0x142f7
leaq (%rsi,%rsi,2), %rcx
leaq (%rax,%rcx,8), %rbx
leaq 0x88(%rsp), %r13
movq %r13, %rdi
movq 0x10(%rsp), %rsi
callq 0x15dda
movq %rbx, %rdi
movq %r13, %rsi
movq 0x18(%rsp), %rdx
movq 0x20(%rsp), %rcx
callq 0x14315
leaq 0xb0(%rsp), %rbx
movq %rbx, %rdi
callq 0xc244
movq -0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x142c2
callq 0x167a2
movq 0x90(%rsp), %rdi
testq %rdi, %rdi
je 0x142d4
callq 0x167a2
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xeb32(%rip), %rdi      # 0x22e1f
movq %r12, %rsi
xorl %eax, %eax
callq 0x7300
leaq 0xeb21(%rip), %rdi      # 0x22e1f
jmp 0x142f0
jmp 0x14302
movq %rax, %rbx
movq %r13, %rdi
callq 0x158a2
movq %rbx, %rdi
callq 0x7360
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x28, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x15c89
movl 0x8(%rax), %eax
cmpl $0x1, %eax
je 0x15cd6
movq (%rbx), %rcx
leaq 0x18(%rsp), %rdi
movq $0x0, -0x8(%rdi)
leaq 0x10(%rsp), %r14
leaq 0xf(%rsp), %rdx
movq %r14, %rsi
callq 0x16ee4
movaps (%r14), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, (%r14)
movq 0x8(%rbx), %rdi
movups %xmm0, (%rbx)
testq %rdi, %rdi
je 0x15cc7
callq 0x167a2
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x15cd6
callq 0x167a2
movq (%rbx), %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
callq 0x15e40
testb %al, %al
je 0x16419
xorl %eax, %eax
jmp 0x16440
movq 0x10(%rbx), %rax
movq (%rax), %rdi
movq 0x10(%rax), %rbx
movl 0x18(%rax), %ebp
xorl %esi, %esi
movq %rbx, %rdx
movl %ebp, %ecx
callq 0x16447
cmpq %rbx, %rax
sete %cl
cmpl %ebp, %edx
sete %al
andb %cl, %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq $0x0, 0x8(%rdi)
movl $0x0, 0x10(%rdi)
movq %rdx, %rdi
callq 0x70b0
leaq (%rax,%r15), %rdx
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x21084
movq 0x8(%r14), %rax
cmpq (%r14), %rax
je 0x17662
movl $0x8, %ebp
xorl %r15d, %r15d
movabsq $-0x71c71c71c71c71c7, %r13 # imm = 0x8E38E38E38E38E39
testq %r15, %r15
je 0x1761c
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x7250
movq (%r14), %rax
movq 0x8(%r14), %rdx
subq %rax, %rdx
sarq $0x4, %rdx
imulq %r13, %rdx
cmpq %r15, %rdx
jbe 0x17695
movq -0x8(%rax,%rbp), %rsi
movq (%rax,%rbp), %rdx
movq %rbx, %rdi
callq 0x7250
incq %r15
movq 0x8(%r14), %rax
subq (%r14), %rax
sarq $0x4, %rax
imulq %r13, %rax
addq $0x90, %rbp
cmpq %rax, %r15
jb 0x17605
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x17683
movq 0x18(%rsp), %rax
leaq 0x4(,%rax,4), %rsi
callq 0x7200
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xb783(%rip), %rdi      # 0x22e1f
movq %r15, %rsi
xorl %eax, %eax
callq 0x7300
movq %rax, %r14
jmp 0x176d1
jmp 0x176ad
movq %rax, %r14
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x176d1
movq 0x18(%rsp), %rax
leaq 0x4(,%rax,4), %rsi
callq 0x7200
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x176ea
movq (%r12), %rax
leaq 0x4(,%rax,4), %rsi
callq 0x7200
movq %r14, %rdi
callq 0x7360
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq $0x0, 0x8(%rdi)
movl $0x0, 0x10(%rdi)
movq %rdx, %rdi
callq 0x70b0
leaq (%rax,%r15), %rdx
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x21084
movq 0x8(%r14), %rax
cmpq (%r14), %rax
je 0x177a4
movl $0x8, %ebp
xorl %r15d, %r15d
testq %r15, %r15
je 0x17769
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x7250
movq (%r14), %rax
movq 0x8(%r14), %rdx
subq %rax, %rdx
sarq $0x5, %rdx
cmpq %r15, %rdx
jbe 0x177d2
movq -0x8(%rax,%rbp), %rsi
movq (%rax,%rbp), %rdx
movq %rbx, %rdi
callq 0x7250
movq 0x8(%r14), %rax
subq (%r14), %rax
incq %r15
sarq $0x5, %rax
addq $0x20, %rbp
cmpq %rax, %r15
jb 0x17752
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x177c0
movq 0x18(%rsp), %rax
leaq 0x4(,%rax,4), %rsi
callq 0x7200
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xb646(%rip), %rdi      # 0x22e1f
movq %r15, %rsi
xorl %eax, %eax
callq 0x7300
movq %rax, %r14
jmp 0x17809
jmp 0x177ea
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x17809
movq 0x18(%rsp), %rax
leaq 0x4(,%rax,4), %rsi
callq 0x7200
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x17822
movq (%r12), %rax
leaq 0x4(,%rax,4), %rsi
callq 0x7200
movq %r14, %rdi
callq 0x7360
// File: /workspace/github_cpp_makefile_star2_O1/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 0x17acd
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 0x1f75d(%rip), %al      # 0x37230
testb %al, %al
je 0x17b71
leaq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0xe0(%rsp), %rax
movq %rax, 0x8(%rsp)
incq 0x1f727(%rip)           # 0x37220
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rsp)
cmpb $0x1, 0x1f71a(%rip)     # 0x37228
jne 0x17b26
movq 0x1f499(%rip), %rax     # 0x36fb0
movq (%rax), %rsi
leaq 0xbef5(%rip), %rdi      # 0x23a16
callq 0x7270
leaq 0xbeef(%rip), %rdi      # 0x23a1c
xorl %eax, %eax
callq 0x7030
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x7220
cmpb $0x1, 0x1f6e2(%rip)     # 0x37228
jne 0x17b5e
movq 0x1f461(%rip), %rax     # 0x36fb0
movq (%rax), %rsi
leaq 0xbecb(%rip), %rdi      # 0x23a24
callq 0x7270
movl $0xa, %edi
callq 0x72a0
addq $0xd0, %rsp
popq %rbx
retq
callq 0x75a1
jmp 0x17adb
// File: /workspace/github_cpp_makefile_star2_O1/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, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
leaq 0x18(%rsp), %r13
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movl %ebp, %esi
callq 0x7080
movq %rax, %r12
testq %rax, %rax
jne 0x1d8a3
movq %r14, %rdi
callq 0x70b0
movq %rax, %r12
addq %r14, %r12
cmpq %r14, %r12
jbe 0x1d8e2
movq %r13, 0x8(%rsp)
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x21084
movq %rbx, %rdi
movq %r15, %rsi
callq 0xde04
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x1d8e2
movq 0x18(%rsp), %rax
leaq 0x4(,%rax,4), %rsi
callq 0x7200
decq %r12
movb 0x1(%r12), %al
incq %r12
cmpb %bpl, %al
je 0x1d8e5
testb %al, %al
cmovneq %r12, %r14
jne 0x1d883
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x1d930
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x1d930
movq 0x18(%rsp), %rax
leaq 0x4(,%rax,4), %rsi
callq 0x7200
movq %rbx, %rdi
callq 0xc1d0
movq %r14, %rdi
callq 0x7360
// File: /workspace/github_cpp_makefile_star2_O1/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 0x19af3(%rip), %al      # 0x37440
testb %al, %al
je 0x1d9ad
movl 0x19af1(%rip), %eax     # 0x37448
incl %eax
andl $0xf, %eax
movq %rax, 0x19ae5(%rip)     # 0x37448
shll $0x5, %eax
leaq 0x198d3(%rip), %r14     # 0x37240
leaq (%r14,%rax), %rdi
movq $0x0, 0x8(%rax,%r14)
movq (%rax,%r14), %rdx
movl $0x0, (%rdx)
movq (%rbx), %rcx
movq 0x8(%rbx), %r8
addq %rcx, %r8
movq %rdx, %rsi
callq 0x1299e
movq 0x19aab(%rip), %rax     # 0x37448
shlq $0x5, %rax
movq (%rax,%r14), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x75d7
jmp 0x1d951
// File: /workspace/github_cpp_makefile_star2_O1/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 %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq %rdx, %rdi
callq 0x70b0
leaq (%rax,%r15), %rdx
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x21084
leaq 0x38(%rsp), %rbp
xorl %r13d, %r13d
leaq 0x28(%rsp), %r15
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rcx
movq %r14, %rdi
movq %r13, %rdx
callq 0x7350
movq %rax, %r12
cmpq $-0x1, %rax
jne 0x1dbf5
movq 0x8(%r14), %r12
movq %r12, %rcx
subq %r13, %rcx
movq %r15, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x70c0
movq %rbx, %rdi
movq %r15, %rsi
callq 0xde04
movq 0x28(%rsp), %rdi
cmpq %rbp, %rdi
je 0x1dc30
movq 0x38(%rsp), %rax
leaq 0x4(,%rax,4), %rsi
callq 0x7200
addq 0x10(%rsp), %r12
movq %r12, %r13
cmpq 0x8(%r14), %r12
jbe 0x1dbd3
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x1dc5f
movq 0x18(%rsp), %rax
leaq 0x4(,%rax,4), %rsi
callq 0x7200
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x1dcbb
movq %rax, %r14
jmp 0x1dc9a
movq %rax, %r14
movq 0x28(%rsp), %rdi
cmpq %rbp, %rdi
je 0x1dc9a
movq 0x38(%rsp), %rax
leaq 0x4(,%rax,4), %rsi
callq 0x7200
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x1dcbb
movq 0x18(%rsp), %rax
leaq 0x4(,%rax,4), %rsi
callq 0x7200
movq %rbx, %rdi
callq 0xc1d0
movq %r14, %rdi
callq 0x7360
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %ecx, %ebp
movq %rdx, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
xorl %eax, %eax
movq %rax, 0x8(%rdi)
movl %eax, 0x10(%rdi)
leaq 0x30(%rdi), %rcx
movq %rcx, 0x20(%rdi)
movq %rax, 0x28(%rdi)
movl %eax, 0x30(%rdi)
leaq 0x50(%rdi), %rcx
movq %rcx, 0x40(%rdi)
movq %rax, 0x48(%rdi)
movl %eax, 0x50(%rdi)
movl %eax, 0x60(%rdi)
leaq 0x38(%rsp), %r14
movq %r14, -0x10(%r14)
movq %rax, -0x8(%r14)
movl %eax, (%r14)
leaq 0x18(%rsp), %r13
testq %rsi, %rsi
je 0x1dd4d
movq %rsi, %r12
movq %rsi, %rdi
callq 0x70b0
leaq (%rax,%r12), %rdx
leaq 0x8(%rsp), %rdi
movq %r13, (%rdi)
movq %r12, %rsi
callq 0x21084
jmp 0x1dd60
leaq 0x8(%rsp), %rdi
movq %r13, (%rdi)
movq %r14, %rsi
movq %r14, %rdx
callq 0x10742
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x72f0
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x1dd89
movq 0x18(%rsp), %rax
leaq 0x4(,%rax,4), %rsi
callq 0x7200
leaq 0x8(%rsp), %rdi
movq %r13, (%rdi)
leaq 0x51ad(%rip), %rdx      # 0x22f45
movq %rdx, %rsi
callq 0x21084
leaq 0x40(%rbx), %rdi
leaq 0x8(%rsp), %rsi
callq 0x72f0
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x1ddca
movq 0x18(%rsp), %rax
leaq 0x4(,%rax,4), %rsi
callq 0x7200
testq %r15, %r15
je 0x1dded
movq %r15, %rdi
callq 0x70b0
leaq (%rax,%r15), %rdx
leaq 0x8(%rsp), %rdi
movq %r13, (%rdi)
movq %r15, %rsi
callq 0x21084
jmp 0x1de08
leaq 0x8(%rsp), %rdi
movq %r13, (%rdi)
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rax
leaq (%rsi,%rax,4), %rdx
callq 0x10742
leaq 0x20(%rbx), %rdi
leaq 0x8(%rsp), %rsi
callq 0x72f0
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x1de32
movq 0x18(%rsp), %rax
leaq 0x4(,%rax,4), %rsi
callq 0x7200
movl %ebp, 0x60(%rbx)
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0x1de51
movq 0x38(%rsp), %rax
leaq 0x4(,%rax,4), %rsi
callq 0x7200
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1de6b
jmp 0x1de8c
jmp 0x1de6b
jmp 0x1de8c
movq %rax, %r15
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x1de8f
movq 0x18(%rsp), %rax
leaq 0x4(,%rax,4), %rsi
callq 0x7200
jmp 0x1de8f
movq %rax, %r15
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0x1deab
movq 0x38(%rsp), %rax
leaq 0x4(,%rax,4), %rsi
callq 0x7200
movq %rbx, %rdi
callq 0xbe66
movq %r15, %rdi
callq 0x7360
// File: /workspace/github_cpp_makefile_star2_O1/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 0x11834
movl %eax, %r14d
movq %r15, %rdi
callq 0x10abc
movl %eax, %ebp
callq 0x3060
cvtsi2sd %eax, %xmm0
divsd 0x19013(%rip), %xmm0    # 0x24260
movsd %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x18e10
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x10(%rsp)
movsd (%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0xb2b9
addl %r14d, %ebp
movl %ebp, %eax
imull %eax, %eax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
movsd %xmm0, 0x8(%rsp)
movq %rbx, %rdi
callq 0x18e06
addl %ebp, %eax
xorps %xmm1, %xmm1
cvtsi2sd %rax, %xmm1
movsd 0x8(%rsp), %xmm0
divsd %xmm1, %xmm0
callq 0x32c0
cvttsd2si %xmm0, %rsi
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
jmp 0xb33f
leaq 0x18(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x108c2
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq 0x23cf1(%rip), %rdi     # 0x2efc8
callq 0x31e0
movq %rax, %rbx
leaq 0x18fce(%rip), %rsi     # 0x242b4
movl $0x14, %edx
movq %rax, %rdi
callq 0x31e0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3190
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3100
leaq 0x28(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb335
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x31b0
movl $0x16e360, %edi         # imm = 0x16E360
callq 0x3260
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 0x28(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb376
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x31b0
movq %rbx, %rdi
callq 0x32f0