LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/ridiculousfish[P]docopt_fish/docopt_fish.cpp
// Function: docopt_fish::compute_indent(docopt_fish::rstring_t const&, docopt_fish::rstring_t const&)
static size_t compute_indent(const rstring_t &src, const rstring_t &trimmed_src) {
    assert(trimmed_src.offset() >= src.offset() && trimmed_src.end_offset() <= src.end_offset());
    const size_t tabstop = 4;
    // Walk over the prefix of src, up to trimmed_src
    size_t result = 0;
    size_t length = trimmed_src.offset() - src.offset();
    for (size_t i = 0; i < length; i++) {
        if (src.at(i) != '\t') {
            // not a tab
            result += 1;
        } else {
            // is a tab. Round up to the next highest multiple of tabstop.
            // If we're already a multiple of tabstop, we want to go bigger.
            result = (result + tabstop) / tabstop * tabstop;
        }
    }
    return result;
}

// Assembly:
pushq %rax
movq (%rdi), %rcx
cmpq %rsi, %rcx
ja 0x89aa
addq %rsi, %rdx
jb 0x898b
movq 0x8(%rdi), %rax
movq %rax, %r8
addq %rcx, %r8
jb 0x898b
cmpq %r8, %rdx
ja 0x89aa
cmpq %rsi, %rcx
jne 0x8959
xorl %eax, %eax
jmp 0x8989
movq %rcx, %rdx
notq %rdx
addq %rsi, %rdx
cmpq %rdx, %rax
jb 0x89c9
movq 0x10(%rdi), %rdx
xorl %eax, %eax
leaq 0x1(%rax), %rdi
andq $-0x4, %rax
addq $0x4, %rax
cmpl $0x9, (%rdx,%rcx,4)
cmovneq %rdi, %rax
incq %rcx
cmpq %rcx, %rsi
jne 0x896d
popq %rcx
retq
leaq 0x18212(%rip), %rdi     # 0x20ba4
leaq 0x17c22(%rip), %rsi     # 0x205bb
leaq 0x18231(%rip), %rcx     # 0x20bd1
movl $0x67, %edx
callq 0x6120
leaq 0x1829a(%rip), %rdi     # 0x20c4b
leaq 0x176ac(%rip), %rsi     # 0x20064
leaq 0x182e1(%rip), %rcx     # 0x20ca0
movl $0x162, %edx            # imm = 0x162
callq 0x6120
leaq 0x17c2e(%rip), %rdi     # 0x205fe
leaq 0x17be4(%rip), %rsi     # 0x205bb
leaq 0x17c35(%rip), %rcx     # 0x20613
movl $0x76, %edx
callq 0x6120
// File: /workspace/github_cpp_makefile_star2_O3/ridiculousfish[P]docopt_fish/./docopt_fish_types.h
// Function: docopt_fish::option_t::option_t(docopt_fish::option_t::name_type_t, docopt_fish::rstring_t const&, docopt_fish::rstring_t const&, unsigned int)
option_t(name_type_t type, const rstring_t &name, const rstring_t &v, option_flags_t f)
        : value(v), flags(f) {
        assert(type < NAME_TYPE_COUNT);
        assert(name.length() >= 2);
        assert(name[0] == '-');
        if (type == double_long) {
            assert(name.length() >= 3);
            assert(name[1] == '-');
        }
        this->names[type] = name;
    }

// Assembly:
pushq %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
xorl %eax, %eax
movq %rax, 0x40(%rdi)
movups (%rcx), %xmm1
movups %xmm1, 0x48(%rdi)
movq 0x10(%rcx), %rcx
movq %rcx, 0x58(%rdi)
movups %xmm0, 0x60(%rdi)
movq %rax, 0x70(%rdi)
movl %r8d, 0x78(%rdi)
cmpl $0x3, %esi
jge 0x8c9c
movq 0x8(%rdx), %rax
cmpq $0x1, %rax
jbe 0x8cbb
movq (%rdx), %rcx
movq 0x10(%rdx), %r8
cmpl $0x2d, (%r8,%rcx,4)
jne 0x8cda
cmpl $0x2, %esi
jne 0x8c84
cmpq $0x2, %rax
je 0x8cf9
cmpl $0x2d, 0x4(%r8,%rcx,4)
jne 0x8d18
movl %esi, %eax
leaq (%rax,%rax,2), %rax
movq 0x10(%rdx), %rcx
movq %rcx, 0x10(%rdi,%rax,8)
movups (%rdx), %xmm0
movups %xmm0, (%rdi,%rax,8)
popq %rax
retq
leaq 0x17a5d(%rip), %rdi     # 0x20700
leaq 0x17911(%rip), %rsi     # 0x205bb
leaq 0x17a66(%rip), %rcx     # 0x20717
movl $0x188, %edx            # imm = 0x188
callq 0x6120
leaq 0x17ab8(%rip), %rdi     # 0x2077a
leaq 0x178f2(%rip), %rsi     # 0x205bb
leaq 0x17a47(%rip), %rcx     # 0x20717
movl $0x189, %edx            # imm = 0x189
callq 0x6120
leaq 0x17aac(%rip), %rdi     # 0x2078d
leaq 0x178d3(%rip), %rsi     # 0x205bb
leaq 0x17a28(%rip), %rcx     # 0x20717
movl $0x18a, %edx            # imm = 0x18A
callq 0x6120
leaq 0x17a9c(%rip), %rdi     # 0x2079c
leaq 0x178b4(%rip), %rsi     # 0x205bb
leaq 0x17a09(%rip), %rcx     # 0x20717
movl $0x18c, %edx            # imm = 0x18C
callq 0x6120
leaq 0x17a90(%rip), %rdi     # 0x207af
leaq 0x17895(%rip), %rsi     # 0x205bb
leaq 0x179ea(%rip), %rcx     # 0x20717
movl $0x18d, %edx            # imm = 0x18D
callq 0x6120
nop
// File: /workspace/github_cpp_makefile_star2_O3/ridiculousfish[P]docopt_fish/docopt_fish.cpp
// Function: docopt_fish::docopt_impl::get_command_names[abi:cxx11]() const
std::vector<string_t> get_command_names() const {
        // Get the command names.
        // We store a set of seen names so we only return each name once,
        // but in the order matching their appearance in the usage spec.
        std::vector<string_t> result;
        std::set<rstring_t> seen;
        for (const usage_t &usage : this->usages) {
            const rstring_t &name = usage.prog_name;
            if (!name.empty() && seen.insert(name).second) {
                result.push_back(name.std_string());
            }
        }
        return result;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
xorl %eax, %eax
movq %rax, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
leaq 0x30(%rsp), %rcx
movl $0x0, (%rcx)
movq %rax, 0x8(%rcx)
movq %rcx, 0x10(%rcx)
movq %rcx, 0x18(%rcx)
movq %rax, 0x20(%rcx)
movq (%rsi), %r14
movq 0x8(%rsi), %rbp
cmpq %rbp, %r14
je 0x9af9
leaq 0x18(%rsp), %r13
leaq 0x28(%rsp), %r15
leaq 0x8(%rsp), %r12
cmpq $0x0, 0x8(%r14)
je 0x9af0
movq %r15, %rdi
movq %r14, %rsi
callq 0xcc78
testb $0x1, %dl
je 0x9af0
movq %r12, %rdi
movq %r14, %rsi
callq 0xaf0c
movq %rbx, %rdi
movq %r12, %rsi
callq 0xcdb8
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x9af0
movq 0x18(%rsp), %rax
leaq 0x4(,%rax,4), %rsi
callq 0x6200
addq $0x30, %r14
cmpq %rbp, %r14
jne 0x9aa7
leaq 0x28(%rsp), %rdi
callq 0xb254
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x9b3b
movq 0x18(%rsp), %rax
leaq 0x4(,%rax,4), %rsi
callq 0x6200
jmp 0x9b3b
jmp 0x9b38
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0xb254
movq %rbx, %rdi
callq 0xb1e0
movq %r14, %rdi
callq 0x6360
nop
// File: /workspace/github_cpp_makefile_star2_O3/ridiculousfish[P]docopt_fish/./docopt_fish_types.h
// Function: docopt_fish::rstring_t::chop_length(unsigned long)
rstring_t chop_length(size_t len) {
        assert(len <= this->length());
        rstring_t result = this->substr(0, len);
        this->start_ += len;
        this->length_ -= len;
        return result;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
cmpq %rdx, 0x8(%rsi)
jb 0xac8a
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
xorl %edx, %edx
movq %rbx, %rcx
callq 0x8e00
addq %rbx, (%r15)
subq %rbx, 0x8(%r15)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x159bb(%rip), %rdi     # 0x2064c
leaq 0x15923(%rip), %rsi     # 0x205bb
leaq 0x159c3(%rip), %rcx     # 0x20662
movl $0x56, %edx
callq 0x6120
// File: /workspace/github_cpp_makefile_star2_O3/ridiculousfish[P]docopt_fish/./docopt_fish_types.h
// Function: docopt_fish::rstring_t::compare(docopt_fish::rstring_t const&) const
int compare(const rstring_t &rhs) const {
        if (this == &rhs) {
            return 0;
        }
        if (this->base_ == rhs.base_ && this->start_ == rhs.start_ &&
            this->length_ == rhs.length_) {
            return 0;
        }

        return compare_internal(*this, rhs);
    }

// Assembly:
cmpq %rsi, %rdi
je 0xb045
movq 0x10(%rdi), %rax
cmpq 0x10(%rsi), %rax
jne 0xb048
movq (%rdi), %rax
cmpq (%rsi), %rax
jne 0xb048
movq 0x8(%rdi), %rax
cmpq 0x8(%rsi), %rax
jne 0xb048
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/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), %rcx
testq %rcx, %rcx
je 0xd5f9
movq (%rsi), %rdi
shlq $0x2, %rdi
addq 0x10(%rsi), %rdi
xorl %edx, %edx
movabsq $0x100002600, %rax      # imm = 0x100002600
movl (%rdi,%rdx,4), %r8d
cmpq $0x20, %r8
ja 0xd60d
btq %r8, %rax
jae 0xd60d
incq %rdx
cmpq %rdx, %rcx
jne 0xd5dc
movq %rcx, %rdx
jmp 0xd5fd
xorl %ecx, %ecx
xorl %edx, %edx
subq %rdx, %rcx
movq %rbx, %rdi
callq 0x8e00
movq %rbx, %rax
popq %rbx
retq
cmpq %rdx, %rcx
jbe 0xd64a
movq (%rsi), %rdi
movq 0x10(%rsi), %r8
leaq (%r8,%rdi,4), %r8
addq $-0x4, %r8
movq %rcx, %rdi
leaq -0x1(%rdi), %r9
cmpq %r9, %rcx
jb 0xd676
movl (%r8,%rdi,4), %r10d
cmpq $0x20, %r10
ja 0xd671
btq %r10, %rax
jae 0xd671
movq %r9, %rdi
cmpq %rdx, %r9
ja 0xd624
movq %rdx, %rcx
jmp 0xd5fd
movq %rcx, %rdi
cmpq %rdi, %rdx
jbe 0xd5fd
leaq 0x135aa(%rip), %rdi     # 0x20c03
leaq 0x12f5b(%rip), %rsi     # 0x205bb
leaq 0x135aa(%rip), %rcx     # 0x20c11
movl $0x13c, %edx            # imm = 0x13C
callq 0x6120
movq %rdi, %rcx
jmp 0xd64d
leaq 0x12f81(%rip), %rdi     # 0x205fe
leaq 0x12f37(%rip), %rsi     # 0x205bb
leaq 0x12f88(%rip), %rcx     # 0x20613
movl $0x76, %edx
callq 0x6120
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xd702
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 0x60b0
leaq (%rax,%r14), %rcx
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0xd8c0
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 0xd705
subq %rcx, %rax
sarq $0x2, %rax
retq
xorl %eax, %eax
retq
movq $-0x1, %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xdcf1
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 0xdcd2
movl 0x78(%rsi), %eax
orl %eax, 0x78(%rdi)
cmpq $0x0, 0x50(%rdi)
jne 0xdd18
movq 0x58(%rsi), %rax
movq %rax, 0x58(%rdi)
movups 0x48(%rsi), %xmm0
movups %xmm0, 0x48(%rdi)
cmpq $0x0, 0x68(%rdi)
je 0xdd20
retq
movq 0x70(%rsi), %rax
movq %rax, 0x70(%rdi)
movups 0x60(%rsi), %xmm0
movups %xmm0, 0x60(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movb $0x1, %bpl
xorl %r15d, %r15d
movq 0x8(%r14), %rax
testq %rax, %rax
je 0xe575
cmpq 0x8(%rbx), %rax
jne 0xe575
movq %r14, %rdi
movq %rbx, %rsi
callq 0xb018
testl %eax, %eax
je 0xe592
cmpq $0x2, %r15
leaq 0x1(%r15), %rax
setb %bpl
addq $0x18, %r14
addq $0x18, %rbx
movq %rax, %r15
cmpq $0x3, %rax
jne 0xe557
andb $0x1, %bpl
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xfd82
testq %r14, %r14
je 0xf835
movq 0x50(%rsp), %rdi
movq 0x58(%rsp), %rsi
movq %r14, %rdx
callq 0xf1da
movq 0x50(%rsp), %rax
cmpq 0x58(%rsp), %rax
je 0xf851
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
jmp 0xf884
movq 0x10(%rsp), %rax
movq %rax, 0x10(%rbx)
movups (%rsp), %xmm0
movups %xmm0, (%rbx)
movups 0x18(%rsp), %xmm0
movups %xmm0, 0x18(%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 0xe816
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0xf8a5
movq 0x60(%rsp), %rsi
subq %rdi, %rsi
callq 0x6200
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0xe816
jmp 0xf8c2
movq %rax, %rbx
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0xf8d9
movq 0x60(%rsp), %rsi
subq %rdi, %rsi
callq 0x6200
movq %rbx, %rdi
callq 0x6360
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1179a
movq %rsp, %rsi
movq %r15, %rdi
callq 0x11894
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 0xfcb2
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r14, %rdi
callq 0x6250
movq %r14, %rdi
movl $0xa, %esi
callq 0x6090
addq $0x20, %r15
jmp 0xfc8b
movq %rbx, %rdi
callq 0xb1e0
movq %r14, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r15
jmp 0xfcec
movq %rax, %r15
movq (%r14), %rdi
cmpq %r12, %rdi
je 0xfcec
movq (%r12), %rax
leaq 0x4(,%rax,4), %rsi
callq 0x6200
movq %rbx, %rdi
callq 0xb1e0
movq %r15, %rdi
callq 0x6360
// File: /workspace/github_cpp_makefile_star2_O3/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 0xfd49
movq %rsp, %r14
leaq 0x18(%r15), %rdi
movq %r14, %rsi
callq 0x12aca
addq $0x30, %r15
cmpq %r12, %r15
jne 0xfd29
movaps (%rsp), %xmm0
movq 0x10(%rsp), %rax
jmp 0xfd4b
xorl %eax, %eax
movups %xmm0, (%rbx)
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 0xfd7a
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x6200
movq %rbx, %rdi
callq 0x6360
// File: /workspace/github_cpp_makefile_star2_O3/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 0x10358
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x10158
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rbx)
movups 0x8(%rsp), %xmm0
movups %xmm0, (%rbx)
cmpq $0x0, 0x8(%rbx)
je 0xfe1a
leaq 0x18(%rbx), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x10058
movq 0x18(%rbx), %rax
movq 0x20(%rbx), %rsi
cmpq %rsi, %rax
jne 0xfe0d
cmpq 0x28(%rbx), %rax
je 0xfe05
xorps %xmm0, %xmm0
movups %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
addq $0x18, 0x20(%rbx)
jmp 0xfe0d
movq %r15, %rdi
callq 0x111a0
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x11073(%rip), %rdi     # 0x20e94
leaq 0x11074(%rip), %rsi     # 0x20e9c
leaq 0x11088(%rip), %rcx     # 0x20eb7
movl $0x9e, %edx
callq 0x6120
movq %rax, %r14
addq $0x18, %rbx
movq %rbx, %rdi
callq 0xe816
movq %r14, %rdi
callq 0x6360
// File: /workspace/github_cpp_makefile_star2_O3/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 0x10358
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x10158
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_O3/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 0xfe50
xorl %r12d, %r12d
leaq 0x20(%rsp), %r15
movq %rsp, %r13
xorl %ebp, %ebp
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
subq $0x1, %rbp
jb 0x100c1
movq %r15, %rdi
movq %r14, %rsi
callq 0x10358
movq %r13, %rdi
movq %r14, %rsi
leaq 0x10e42(%rip), %rdx     # 0x20ef6
callq 0x106ea
cmpq $0x0, 0x8(%rsp)
je 0x1011f
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movq $0x0, 0x30(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x10750
testb %al, %al
je 0x100f9
movq %rbx, %rdi
movq %r15, %rsi
callq 0xffbc
movq %r15, %rdi
callq 0xe85e
movq %rbp, %r12
jmp 0x10086
leaq 0x20(%rsp), %rdi
callq 0xe85e
testq %r12, %r12
je 0x10124
leaq 0x10de9(%rip), %rcx     # 0x20ef8
movq %rsp, %rsi
movq %r14, %rdi
movl $0xe, %edx
callq 0x1055c
movb $0x1, %bpl
jmp 0x10126
xorl %ebp, %ebp
movq %r14, %rdi
movq %rbx, %rsi
callq 0x105bc
movl %ebp, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xe85e
movq %rbx, %rdi
callq 0x6360
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x106ac
movq %rsi, %rbx
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
subq %rax, %rcx
cmpq $0x30, %rcx
jne 0x106a6
movq (%rax), %rcx
movq 0x8(%rax), %rdx
subq %rcx, %rdx
cmpq $0x68, %rdx
jne 0x105fe
movq (%rcx), %rcx
testq %rcx, %rcx
je 0x10603
movq (%rcx), %rcx
jmp 0x10605
xorl %r14d, %r14d
jmp 0x10610
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 0x106a6
movq (%rcx), %rax
testq %rax, %rax
je 0x106a6
movq (%rax), %rsi
leaq 0x18(%rsi), %r15
testq %rsi, %rsi
cmoveq %rsi, %r15
testq %r14, %r14
je 0x106a6
testq %rsi, %rsi
je 0x106a6
movq 0x50(%r14), %rax
cmpq 0x68(%rsi), %rax
jne 0x106a6
addq $0x60, %rsi
leaq 0x48(%r14), %rdi
callq 0xb018
testl %eax, %eax
jne 0x106a6
movl $0x8, %eax
cmpq $0x0, (%r14,%rax)
je 0x10673
cmpq $0x0, (%r15,%rax)
jne 0x106a6
addq $0x18, %rax
cmpq $0x50, %rax
jne 0x10665
movq %r14, %rdi
movq %r15, %rsi
callq 0xdccc
movq 0x8(%rbx), %rdi
addq $-0x18, %rdi
movq %rdi, 0x8(%rbx)
callq 0xe85e
movq 0x8(%rbx), %rax
subq (%rbx), %rax
cmpq $0x18, %rax
jne 0x106cb
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1094d(%rip), %rdi     # 0x21000
leaq 0x107e2(%rip), %rsi     # 0x20e9c
leaq 0x1094f(%rip), %rcx     # 0x21010
movl $0x170, %edx            # imm = 0x170
callq 0x6120
leaq 0x10996(%rip), %rdi     # 0x21068
leaq 0x107c3(%rip), %rsi     # 0x20e9c
leaq 0x10930(%rip), %rcx     # 0x21010
movl $0x188, %edx            # imm = 0x188
callq 0x6120
// File: /workspace/github_cpp_makefile_star2_O3/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 0x60b0
cmpq 0x8(%r14), %rax
ja 0x10746
testq %rax, %rax
je 0x10738
movq (%r14), %rcx
shlq $0x2, %rcx
addq 0x10(%r14), %rcx
xorl %edx, %edx
movsbl (%r15,%rdx), %esi
cmpl %esi, (%rcx,%rdx,4)
jne 0x10746
incq %rdx
cmpq %rdx, %rax
jne 0x10726
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xac5c
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x10358
leaq 0x18(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x106ea
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_O3/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 0x10358
leaq 0x18(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x10158
movq 0x10(%rsp), %rax
movq %rax, 0x10(%r14)
movaps (%rsp), %xmm0
movups %xmm0, (%r14)
movq 0x8(%r15), %rax
testq %rax, %rax
je 0x10d04
movq 0x18(%rsp), %rcx
movq 0x28(%rsp), %rdx
movl (%rdx,%rcx,4), %ecx
cmpl $0x2d, %ecx
je 0x10d08
cmpl $0x3c, %ecx
jne 0x10d0e
xorps %xmm0, %xmm0
movq %rsp, %r15
movaps %xmm0, (%r15)
movq $0x0, 0x10(%r15)
leaq 0x30(%rsp), %rdi
movq %r14, %rsi
callq 0x10358
movq %r15, %rdi
movq %r14, %rsi
callq 0x10158
cmpq $0x0, 0x8(%r15)
setne %bpl
je 0x10d86
addq $0x10, %rbx
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x10de8
jmp 0x10d86
xorl %ebp, %ebp
jmp 0x10d86
cmpq $0x1, %rax
jne 0x10d54
xorps %xmm0, %xmm0
movq %rsp, %r15
movaps %xmm0, (%r15)
movq $0x0, 0x10(%r15)
leaq 0x30(%rsp), %rdi
movq %r14, %rsi
callq 0x10358
movq %r15, %rdi
movq %r14, %rsi
callq 0x10158
cmpq $0x0, 0x8(%r15)
setne %bpl
je 0x10d86
addq $0x8, %rbx
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x11159
jmp 0x10d86
leaq 0x30(%rsp), %r15
movl $0x94, %edx
movq %r15, %rdi
xorl %esi, %esi
callq 0x60e0
movq %r14, %rdi
movq %r15, %rsi
callq 0x10e2e
movl %eax, %ebp
testb %al, %al
je 0x10d86
leaq 0x30(%rsp), %rsi
movq %rbx, %rdi
callq 0x11111
movl %ebp, %eax
addq $0xc8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x63b0
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x48(%rsp), %rsi
movq $0x10, (%rsi)
leaq 0x8(%rsp), %rdi
xorl %edx, %edx
callq 0x6370
movq %rax, 0x8(%rsp)
movq 0x48(%rsp), %rcx
movq %rcx, 0x18(%rsp)
movups 0xf116(%rip), %xmm0     # 0x2109d
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 0x1190e
addq $0x8, %rbx
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x118d0
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x11fe5
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6200
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0x12001
movq 0x38(%rsp), %rax
leaq 0x4(,%rax,4), %rsi
callq 0x6200
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
jmp 0x1202a
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x1202a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6200
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0x12046
movq 0x38(%rsp), %rax
leaq 0x4(,%rax,4), %rsi
callq 0x6200
movq %rbx, %rdi
callq 0x6360
// File: /workspace/github_cpp_makefile_star2_O3/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 0x12378
leaq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0x11b42
leaq 0x20(%r14), %rsi
movq %rbx, %rdi
callq 0x1286e
leaq 0x28(%r14), %rsi
movq %rbx, %rdi
callq 0x11b42
decl (%rbx)
leaq 0x40(%r14), %rsi
movq %rbx, %rdi
callq 0x1234c
addq $0x60, %r14
incl (%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x129a4
decl (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x14c9e
testb %al, %al
je 0x13070
cmpq $0x0, 0x8(%r15)
je 0x13070
movq %r14, %rdi
movq %r12, %rsi
callq 0x14cd8
addq $0x18, %r15
movq %rsp, %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x14c48
movq %r15, %rdi
movq %r13, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x13091
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0xb254
movq -0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x13061
callq 0x1563c
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x13070
callq 0x1563c
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x1475a
movq %rbx, %rdi
callq 0x6360
// File: /workspace/github_cpp_makefile_star2_O3/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, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq (%rdi), %rax
movq 0x8(%rdi), %rsi
subq %rax, %rsi
je 0x13206
sarq $0x3, %rsi
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rsi
movq %rsi, %rdx
cmpq $0x2, %rsi
jb 0x13198
movq %rdi, %rbp
movq %rsi, 0x20(%rsp)
leaq -0x1(%rsi), %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 0x13218
addq %r15, %rbx
movq %r13, %rdi
movq 0x8(%rsp), %rsi
callq 0x15a4c
movq %rbx, %rdi
movq %r13, %rsi
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rcx
callq 0x13247
leaq 0x50(%rsp), %rdi
callq 0xb254
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x1315b
callq 0x1563c
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x1316a
callq 0x1563c
incq %r12
addq $0x18, %r15
cmpq %r12, %r14
jne 0x130f7
movq (%rbp), %rax
movq 0x8(%rbp), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rdx
movq 0x20(%rsp), %rsi
decq %rsi
cmpq %rsi, %rdx
jbe 0x13229
leaq (%rsi,%rsi,2), %rcx
leaq (%rax,%rcx,8), %rbx
leaq 0x88(%rsp), %r13
movq %r13, %rdi
movq 0x8(%rsp), %rsi
callq 0x14c48
movq %rbx, %rdi
movq %r13, %rsi
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rcx
callq 0x13247
leaq 0xb0(%rsp), %rbx
movq %rbx, %rdi
callq 0xb254
movq -0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x131f4
callq 0x1563c
movq 0x90(%rsp), %rdi
testq %rdi, %rdi
je 0x13206
callq 0x1563c
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xdbaf(%rip), %rdi      # 0x20dce
movq %r12, %rsi
xorl %eax, %eax
callq 0x6300
leaq 0xdb9e(%rip), %rdi      # 0x20dce
jmp 0x13222
jmp 0x13234
movq %rax, %rbx
movq %r13, %rdi
callq 0x1475a
movq %rbx, %rdi
callq 0x6360
// File: /workspace/github_cpp_makefile_star2_O3/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 0x14b03
movl 0x8(%rax), %eax
cmpl $0x1, %eax
je 0x14b50
movq (%rbx), %rcx
leaq 0x18(%rsp), %rdi
movq $0x0, -0x8(%rdi)
leaq 0x10(%rsp), %r14
leaq 0xf(%rsp), %rdx
movq %r14, %rsi
callq 0x15d62
movaps (%r14), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, (%r14)
movq 0x8(%rbx), %rdi
movups %xmm0, (%rbx)
testq %rdi, %rdi
je 0x14b50
callq 0x1563c
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x14b50
callq 0x1563c
movq (%rbx), %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x14c9e
testb %al, %al
je 0x1527f
xorl %eax, %eax
jmp 0x152a6
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 0x152ad
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_O3/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 0x60b0
leaq (%rax,%r15), %rdx
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x1fe82
movq (%r14), %rax
movq 0x8(%r14), %rdx
cmpq %rax, %rdx
je 0x164e3
movl $0x8, %ebp
xorl %r15d, %r15d
movabsq $-0x71c71c71c71c71c7, %r13 # imm = 0x8E38E38E38E38E39
testq %r15, %r15
je 0x1649e
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x6250
movq (%r14), %rax
movq 0x8(%r14), %rdx
subq %rax, %rdx
sarq $0x4, %rdx
imulq %r13, %rdx
cmpq %r15, %rdx
jbe 0x16516
movq -0x8(%rax,%rbp), %rsi
movq (%rax,%rbp), %rdx
movq %rbx, %rdi
callq 0x6250
incq %r15
movq (%r14), %rax
movq 0x8(%r14), %rdx
movq %rdx, %rcx
subq %rax, %rcx
sarq $0x4, %rcx
imulq %r13, %rcx
addq $0x90, %rbp
cmpq %rcx, %r15
jb 0x16480
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x16504
movq 0x18(%rsp), %rax
leaq 0x4(,%rax,4), %rsi
callq 0x6200
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xa8b1(%rip), %rdi      # 0x20dce
movq %r15, %rsi
xorl %eax, %eax
callq 0x6300
movq %rax, %r14
jmp 0x16552
jmp 0x1652e
movq %rax, %r14
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x16552
movq 0x18(%rsp), %rax
leaq 0x4(,%rax,4), %rsi
callq 0x6200
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x1656b
movq (%r12), %rax
leaq 0x4(,%rax,4), %rsi
callq 0x6200
movq %r14, %rdi
callq 0x6360
// File: /workspace/github_cpp_makefile_star2_O3/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 0x60b0
leaq (%rax,%r15), %rdx
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x1fe82
movq (%r14), %rax
movq 0x8(%r14), %rdx
cmpq %rax, %rdx
je 0x1662e
movl $0x8, %ebp
xorl %r15d, %r15d
testq %r15, %r15
je 0x165f4
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x6250
movq (%r14), %rax
movq 0x8(%r14), %rdx
subq %rax, %rdx
sarq $0x5, %rdx
cmpq %r15, %rdx
jbe 0x1665c
movq -0x8(%rax,%rbp), %rsi
movq (%rax,%rbp), %rdx
movq %rbx, %rdi
callq 0x6250
incq %r15
movq (%r14), %rax
movq 0x8(%r14), %rdx
movq %rdx, %rcx
subq %rax, %rcx
sarq $0x5, %rcx
addq $0x20, %rbp
cmpq %rcx, %r15
jb 0x165d6
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x1664a
movq 0x18(%rsp), %rax
leaq 0x4(,%rax,4), %rsi
callq 0x6200
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xa76b(%rip), %rdi      # 0x20dce
movq %r15, %rsi
xorl %eax, %eax
callq 0x6300
movq %rax, %r14
jmp 0x16693
jmp 0x16674
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x16693
movq 0x18(%rsp), %rax
leaq 0x4(,%rax,4), %rsi
callq 0x6200
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x166ac
movq (%r12), %rax
leaq 0x4(,%rax,4), %rsi
callq 0x6200
movq %r14, %rdi
callq 0x6360
// File: /workspace/github_cpp_makefile_star2_O3/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 0x16955
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 0x1e8d5(%rip), %al      # 0x35230
testb %al, %al
je 0x169f9
leaq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0xe0(%rsp), %rax
movq %rax, 0x8(%rsp)
incq 0x1e89f(%rip)           # 0x35220
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rsp)
cmpb $0x1, 0x1e892(%rip)     # 0x35228
jne 0x169ae
movq 0x1e611(%rip), %rax     # 0x34fb0
movq (%rax), %rsi
leaq 0xb01d(%rip), %rdi      # 0x219c6
callq 0x6270
leaq 0xb017(%rip), %rdi      # 0x219cc
xorl %eax, %eax
callq 0x6030
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x6220
cmpb $0x1, 0x1e85a(%rip)     # 0x35228
jne 0x169e6
movq 0x1e5d9(%rip), %rax     # 0x34fb0
movq (%rax), %rsi
leaq 0xaff3(%rip), %rdi      # 0x219d4
callq 0x6270
movl $0xa, %edi
callq 0x62a0
addq $0xd0, %rsp
popq %rbx
retq
callq 0x6589
jmp 0x16963
// File: /workspace/github_cpp_makefile_star2_O3/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
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
leaq 0x18(%rsp), %r13
leaq 0x8(%rsp), %r14
movq %r15, %rdi
movl %ebp, %esi
callq 0x6080
movq %rax, %r12
testq %rax, %rax
jne 0x1c735
movq %r15, %rdi
callq 0x60b0
movq %rax, %r12
addq %r15, %r12
cmpq %r15, %r12
jbe 0x1c774
movq %r13, 0x8(%rsp)
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x1fe82
movq %rbx, %rdi
movq %r14, %rsi
callq 0xcdb8
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x1c774
movq 0x18(%rsp), %rax
leaq 0x4(,%rax,4), %rsi
callq 0x6200
decq %r12
movq %r12, %r15
movb 0x1(%r15), %al
incq %r15
cmpb %bpl, %al
je 0x1c77a
testb %al, %al
jne 0x1c715
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x1c7bd
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x1c7bd
movq 0x18(%rsp), %rax
leaq 0x4(,%rax,4), %rsi
callq 0x6200
movq %rbx, %rdi
callq 0xb1e0
movq %r14, %rdi
callq 0x6360
// File: /workspace/github_cpp_makefile_star2_O3/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 0x18c66(%rip), %al      # 0x35440
testb %al, %al
je 0x1c83a
movl 0x18c64(%rip), %eax     # 0x35448
incl %eax
andl $0xf, %eax
movq %rax, 0x18c58(%rip)     # 0x35448
shll $0x5, %eax
leaq 0x18a46(%rip), %r14     # 0x35240
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 0x1190e
movq 0x18c1e(%rip), %rax     # 0x35448
shlq $0x5, %rax
movq (%rax,%r14), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x65bf
jmp 0x1c7de