LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, -0x28(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq $0x0, -0x10(%rbp)
callq 0xbf20
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq -0x18(%rbp), %rcx
movb %al, -0x31(%rbp)
jae 0x1bb03
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xfb70
movl %eax, %edi
callq 0x1c130
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x1bb0c
jmp 0x1bb1a
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x1badd
jmp 0x1bb1c
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpq -0x10(%rbp), %rcx
movb %al, -0x32(%rbp)
jbe 0x1bb46
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
subq $0x1, %rsi
callq 0xfb70
movl %eax, %edi
callq 0x1c130
movb %al, -0x32(%rbp)
movb -0x32(%rbp), %al
testb $0x1, %al
jne 0x1bb4f
jmp 0x1bb5d
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x1bb1c
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
ja 0x1bb69
jmp 0x1bb88
leaq 0x300ad(%rip), %rdi     # 0x4bc1d
leaq 0x2fa88(%rip), %rsi     # 0x4b5ff
movl $0x13c, %edx            # imm = 0x13C
leaq 0x300a8(%rip), %rcx     # 0x4bc2b
callq 0x81e0
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
subq -0x10(%rbp), %rcx
callq 0xc520
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: ridiculousfish[P]docopt_fish/./docopt_fish_types.h
// Function: docopt_fish::rstring_t::char_is_whitespace(wchar_t)
static bool char_is_whitespace(rstring_t::char_t c) {
        switch (c) {
            case '\t':
            case '\n':
            case '\r':
            case ' ':
                return true;
            default:
                return false;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0xc(%rbp)
addl $-0x9, %eax
subl $0x2, %eax
jb 0x1c15b
jmp 0x1c147
movl -0xc(%rbp), %eax
subl $0xd, %eax
je 0x1c15b
jmp 0x1c151
movl -0xc(%rbp), %eax
subl $0x20, %eax
jne 0x1c161
jmp 0x1c15b
movb $0x1, -0x1(%rbp)
jmp 0x1c165
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax)
// File: ridiculousfish[P]docopt_fish/./docopt_fish_types.h
// Function: unsigned long docopt_fish::rstring_t::find_internal<true>(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:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x1c1a1
movq $0x0, -0x8(%rbp)
jmp 0x1c245
movq -0x38(%rbp), %rdi
callq 0xf960
movq -0x38(%rbp), %rdi
movq %rax, -0x58(%rbp)
callq 0x10030
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x18(%rbp), %rdi
callq 0x8110
movq -0x60(%rbp), %rcx
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
addq %rax, %rcx
callq 0x1c250
movq -0x38(%rbp), %rdi
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
callq 0x10030
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jne 0x1c21a
movq $-0x1, %rax
movq %rax, -0x68(%rbp)
jmp 0x1c23d
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %rax
movq %rax, -0x70(%rbp)
callq 0xf960
movq %rax, %rcx
movq -0x70(%rbp), %rax
subq %rcx, %rax
sarq $0x2, %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nop
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x3, -0x18(%rbp)
jae 0x1d10f
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xc7b0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x14d00
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x1d800
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x1d0d0
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x78(%rax), %eax
orl 0x78(%rdi), %eax
movl %eax, 0x78(%rdi)
addq $0x48, %rdi
movq -0x10(%rbp), %rsi
addq $0x48, %rsi
callq 0x1d800
movq -0x20(%rbp), %rdi
addq $0x60, %rdi
movq -0x10(%rbp), %rsi
addq $0x60, %rsi
callq 0x1d800
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movb $0x0, -0x11(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0x3, -0x20(%rbp)
jae 0x1f385
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x14d00
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x14d00
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0xbf20
cmpq $0x0, %rax
jbe 0x1f375
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x14ca0
testb $0x1, %al
jne 0x1f36f
jmp 0x1f375
movb $0x1, -0x11(%rbp)
jmp 0x1f385
jmp 0x1f377
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x1f324
movb -0x11(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
// File: ridiculousfish[P]docopt_fish/./docopt_fish_types.h
// Function: docopt_fish::option_t::best_name() const
const rstring_t &best_name() const {
        size_t idx = NAME_TYPE_COUNT;
        while (idx--) {
            const rstring_t &name = this->names[idx];
            if (!name.empty()) {
                return name;
            }
        }
        return this->names[single_short];  // is empty
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq $0x3, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x18(%rbp)
cmpq $0x0, %rax
je 0x1f3eb
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x14d00
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0xbe30
testb $0x1, %al
jne 0x1f3e9
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1f3fc
jmp 0x1f3ac
movq -0x28(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x14d00
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0xd8(%rbp)
movq %rdi, %rax
movq %rax, -0xd0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x58(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0x27410
movq -0xc8(%rbp), %rsi
leaq -0x88(%rbp), %rdi
callq 0x27460
jmp 0x26c39
cmpq $0x0, -0x20(%rbp)
je 0x26cf8
leaq -0x38(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
callq 0xc340
movq -0xe8(%rbp), %rdi
movq %rax, -0xa0(%rbp)
callq 0xc370
movq %rax, -0xa8(%rbp)
movq -0x20(%rbp), %rdi
callq 0xc3a0
movq %rax, -0xe0(%rbp)
jmp 0x26c80
movq -0xe0(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq -0xa0(%rbp), %rdi
movq -0xa8(%rbp), %rsi
movq -0xb0(%rbp), %rdx
callq 0xc2d0
movq %rax, -0xf0(%rbp)
jmp 0x26cb1
movq -0xf0(%rbp), %rax
movq %rax, -0xb8(%rbp)
jmp 0x26cf8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
jmp 0x26d75
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x1bf80
jmp 0x26d75
leaq -0x58(%rbp), %rdi
addq $0x20, %rdi
callq 0xbfd0
testb $0x1, %al
jne 0x26d0b
jmp 0x26d2a
movq -0xd8(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x1f8d0
movl $0x1, -0xbc(%rbp)
jmp 0x26d50
movq -0xd8(%rbp), %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
callq 0x27550
jmp 0x26d46
movl $0x1, -0xbc(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x1bf80
leaq -0x58(%rbp), %rdi
callq 0x27580
movq -0xd0(%rbp), %rax
addq $0xf0, %rsp
popq %rbp
retq
leaq -0x58(%rbp), %rdi
callq 0x27580
movq -0x90(%rbp), %rdi
callq 0x85d0
nopw (%rax,%rax)
// File: ridiculousfish[P]docopt_fish/docopt_fish_parse_tree.cpp
// Function: docopt_fish::dump_usage[abi:cxx11](docopt_fish::usage_t const&)
string_t dump_usage(const usage_t &usage) {
    node_dumper_t dumper;
    dumper.begin(usage);
    string_t result;
    for (const string_t &line : dumper.lines) {
        result.append(line);
        result.push_back('\n');
    }
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x278e0
movq -0x68(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x27910
jmp 0x2725a
movq -0x78(%rbp), %rdi
movb $0x0, -0x3d(%rbp)
callq 0x8150
leaq -0x30(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
callq 0x19820
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rdi
callq 0x14b00
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x27940
testb $0x1, %al
jne 0x272a0
jmp 0x272fe
leaq -0x50(%rbp), %rdi
callq 0x14b70
movq -0x78(%rbp), %rdi
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rsi
callq 0x8600
jmp 0x272bc
movq -0x78(%rbp), %rdi
movl $0xa, %esi
callq 0x80d0
jmp 0x272cc
jmp 0x272ce
leaq -0x50(%rbp), %rdi
callq 0x27980
jmp 0x2728d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x27327
movq -0x78(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x8590
jmp 0x27327
movb $0x1, -0x3d(%rbp)
testb $0x1, -0x3d(%rbp)
jne 0x27311
movq -0x78(%rbp), %rdi
callq 0x8590
leaq -0x30(%rbp), %rdi
callq 0x279a0
movq -0x70(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x279a0
movq -0x38(%rbp), %rdi
callq 0x85d0
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x279c0
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x18b10
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0x18b40
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x18b70
testb $0x1, %al
jne 0x27399
jmp 0x273d9
leaq -0x38(%rbp), %rdi
callq 0x18bb0
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x279e0
jmp 0x273b5
jmp 0x273b7
leaq -0x38(%rbp), %rdi
callq 0x18c50
jmp 0x27386
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x27a40
jmp 0x273f9
movq -0x68(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x27a10
leaq -0x28(%rbp), %rdi
callq 0x27a40
movq -0x60(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x85d0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x27550
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x27a60
movb %al, -0x25(%rbp)
jmp 0x2749e
movb -0x25(%rbp), %al
andb $0x1, %al
movb %al, -0x12(%rbp)
testb $0x1, -0x12(%rbp)
je 0x274ae
jmp 0x274e4
leaq 0x24a6b(%rip), %rdi     # 0x4bf20
leaq 0x24a6c(%rip), %rsi     # 0x4bf28
movl $0x9e, %edx
leaq 0x24a7b(%rip), %rcx     # 0x4bf43
callq 0x81e0
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x1bf80
jmp 0x27538
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
addq $0x18, %rsi
callq 0x27ac0
jmp 0x274f7
movq -0x30(%rbp), %rdi
addq $0x18, %rdi
callq 0x27b80
testb $0x1, %al
jne 0x2750a
jmp 0x2751b
movq -0x30(%rbp), %rdi
addq $0x18, %rdi
callq 0x27bc0
jmp 0x27519
jmp 0x2751b
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x2752e
movq -0x30(%rbp), %rdi
callq 0x1bf80
movq -0x40(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x85d0
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x27c30
movq -0x30(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x27c50
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rdi
callq 0xbe30
xorb $-0x1, %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x275d0
leaq -0x30(%rbp), %rdi
callq 0xbe70
cmpq $0x0, -0x18(%rbp)
jbe 0x27b18
movq -0x38(%rbp), %rdi
leaq 0x24479(%rip), %rsi     # 0x4bf82
leaq -0x30(%rbp), %rdx
callq 0x27db0
testb $0x1, %al
jne 0x27b18
jmp 0x27b59
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x27e10
testb $0x1, %al
jne 0x27b4b
cmpq $0x0, -0x18(%rbp)
jbe 0x27b49
movq -0x38(%rbp), %rdi
leaq -0x30(%rbp), %rsi
movl $0xe, %edx
leaq 0x24440(%rip), %rcx     # 0x4bf84
callq 0x27ea0
jmp 0x27b59
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x27aee
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x27f10
cmpq $0x0, -0x18(%rbp)
seta %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ridiculousfish[P]docopt_fish/docopt_fish_parse_tree.cpp
// Function: bool docopt_fish::parse_context_t::try_parse_appending<docopt_fish::expression_list_t>(std::vector<docopt_fish::expression_list_t, std::allocator<docopt_fish::expression_list_t>>*)
inline bool try_parse_appending(vector<T> *vec) {
        T val;
        bool parsed = this->parse(&val);
        if (parsed) {
            vec->push_back(std::move(val));
        }
        return parsed;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x28100
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x28120
movb %al, -0x3d(%rbp)
jmp 0x27e47
movb -0x3d(%rbp), %al
andb $0x1, %al
movb %al, -0x29(%rbp)
testb $0x1, -0x29(%rbp)
je 0x27e7d
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x27810
jmp 0x27e64
jmp 0x27e7d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x20130
jmp 0x27e97
movb -0x29(%rbp), %al
movb %al, -0x51(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x20130
movb -0x51(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x85d0
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x27f29
jmp 0x27f48
leaq 0x24188(%rip), %rdi     # 0x4c0b8
leaq 0x23ff1(%rip), %rsi     # 0x4bf28
movl $0x170, %edx            # imm = 0x170
leaq 0x24185(%rip), %rcx     # 0x4c0c8
callq 0x81e0
movq -0x10(%rbp), %rdi
callq 0x29eb0
cmpq $0x2, %rax
je 0x27f5c
jmp 0x2806e
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x29f80
movq %rax, %rdi
callq 0x29ee0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x29f80
movq %rax, %rdi
callq 0x29ee0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x2806e
cmpq $0x0, -0x20(%rbp)
je 0x2806e
movq -0x18(%rbp), %rdi
addq $0x48, %rdi
movq -0x20(%rbp), %rsi
addq $0x48, %rsi
callq 0x14ca0
testb $0x1, %al
jne 0x27fc3
jmp 0x2806e
movb $0x0, -0x21(%rbp)
movq $0x0, -0x30(%rbp)
cmpq $0x3, -0x30(%rbp)
jae 0x2801e
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0xc7b0
movq %rax, %rdi
callq 0xbe30
testb $0x1, %al
jne 0x2800e
movq -0x20(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0xc7b0
movq %rax, %rdi
callq 0xbe30
testb $0x1, %al
jne 0x2800e
movb $0x1, -0x21(%rbp)
jmp 0x2801e
jmp 0x28010
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x27fcf
testb $0x1, -0x21(%rbp)
jne 0x2806c
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1d0b0
movq -0x10(%rbp), %rdi
callq 0x29fa0
movq -0x10(%rbp), %rdi
callq 0x29eb0
cmpq $0x1, %rax
jne 0x2804b
jmp 0x2806a
leaq 0x240ce(%rip), %rdi     # 0x4c120
leaq 0x23ecf(%rip), %rsi     # 0x4bf28
movl $0x188, %edx            # imm = 0x188
leaq 0x24063(%rip), %rcx     # 0x4c0c8
callq 0x81e0
jmp 0x2806c
jmp 0x2806e
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0xbe70
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xbf40
testb $0x1, %al
jne 0x280bb
jmp 0x280ef
movq -0x10(%rbp), %rdi
callq 0x8110
movq -0x30(%rbp), %rsi
movq %rax, %rdx
leaq -0x28(%rbp), %rdi
callq 0x10070
movq -0x40(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: ridiculousfish[P]docopt_fish/docopt_fish_parse_tree.cpp
// Function: bool docopt_fish::parse_context_t::try_parse_unique<docopt_fish::alternation_list_t>(std::unique_ptr<docopt_fish::alternation_list_t, std::default_delete<docopt_fish::alternation_list_t>>*)
inline bool try_parse_unique(unique_ptr<T> *p) {
        T val;
        bool parsed = this->parse(&val);
        if (parsed) {
            emplace_unique(p, std::move(val));
        }
        return parsed;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x28a60
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x27ac0
movb %al, -0x3d(%rbp)
jmp 0x288b7
movb -0x3d(%rbp), %al
andb $0x1, %al
movb %al, -0x29(%rbp)
testb $0x1, -0x29(%rbp)
je 0x288ed
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x28a80
jmp 0x288d4
jmp 0x288ed
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x1ff90
jmp 0x28907
movb -0x29(%rbp), %al
movb %al, -0x51(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x1ff90
movb -0x51(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x85d0
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq (%rax), %rcx
movq %rcx, -0x28(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x20(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xbe70
movq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x40(%rbp), %rdx
callq 0x27db0
movb %al, %cl
movq -0x50(%rbp), %rax
andb $0x1, %cl
movb %cl, -0x41(%rbp)
movq -0x28(%rbp), %rcx
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x10(%rax)
movb -0x41(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x40(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x290d0
leaq -0x30(%rbp), %rdi
callq 0xbe30
testb $0x1, %al
jne 0x28ca0
jmp 0x28ca6
movb $0x0, -0x1(%rbp)
jmp 0x28d13
leaq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x110a0
movl %eax, -0x34(%rbp)
cmpl $0x3c, -0x34(%rbp)
jne 0x28cd4
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x10, %rsi
callq 0x29140
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x28d13
cmpl $0x2d, -0x34(%rbp)
jne 0x28cfd
leaq -0x30(%rbp), %rdi
callq 0xbf20
cmpq $0x1, %rax
jbe 0x28cfd
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x291a0
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x28d13
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x8, %rsi
callq 0x29210
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nop
// File: ridiculousfish[P]docopt_fish/docopt_fish_parse_tree.cpp
// Function: docopt_fish::parse_context_t::peek_word()
rstring_t peek_word() {
        const rstring_t saved = this->remaining;
        rstring_t tok;
        scan_word(&tok);
        this->remaining = saved;
        return tok;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq (%rax), %rcx
movq %rcx, -0x20(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x18(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
callq 0xbe70
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdi
callq 0x27a60
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rdx
movq %rdx, (%rcx)
movq -0x18(%rbp), %rdx
movq %rdx, 0x8(%rcx)
movq -0x10(%rbp), %rdx
movq %rdx, 0x10(%rcx)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: ridiculousfish[P]docopt_fish/docopt_fish_parse_tree.cpp
// Function: docopt_fish::parse_context_t::single_option(docopt_fish::expression_list_t*)
static option_t *single_option(expression_list_t *list) {
        if (list->expressions.size() != 1) {
            return nullptr;
        }
        expression_t *expr = &list->expressions[0];
        simple_clause_t *simple_clause = expr->simple_clause.get();
        option_clause_t *option_clause = simple_clause ? simple_clause->option.get() : nullptr;
        return option_clause ? &option_clause->option : nullptr;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x29fd0
cmpq $0x1, %rax
je 0x29f05
movq $0x0, -0x8(%rbp)
jmp 0x29f6e
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2a000
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2a020
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x29f39
movq -0x20(%rbp), %rdi
callq 0x2a050
movq %rax, -0x30(%rbp)
jmp 0x29f41
xorl %eax, %eax
movq %rax, -0x30(%rbp)
jmp 0x29f41
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x29f5e
movq -0x28(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x38(%rbp)
jmp 0x29f66
xorl %eax, %eax
movq %rax, -0x38(%rbp)
jmp 0x29f66
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: ridiculousfish[P]docopt_fish/docopt_fish_parse_tree.cpp
// Function: void docopt_fish::node_dumper_t::accept<docopt_fish::usage_t>(docopt_fish::usage_t const&)
void accept(const NODE_TYPE &node) {
        string_t result(2 * depth, ' ');
        const std::string name = node.name();
        result.append(name.begin(), name.end());
        lines.push_back(result);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
movl (%rax), %eax
addl %eax, %eax
movq %rax, -0x88(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x8130
movq -0x88(%rbp), %rsi
movq -0x80(%rbp), %rcx
leaq -0x30(%rbp), %rdi
movl $0x20, %edx
callq 0x2bc80
jmp 0x2bb71
leaq -0x31(%rbp), %rdi
callq 0x85f0
movq -0x10(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x2bcf0
jmp 0x2bb89
leaq -0x68(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x82f0
movq -0x98(%rbp), %rdi
movq %rax, -0x70(%rbp)
callq 0x8670
movq %rax, -0x78(%rbp)
movq -0x70(%rbp), %rsi
movq -0x78(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0x2bd60
jmp 0x2bbc0
movq -0x90(%rbp), %rdi
addq $0x8, %rdi
leaq -0x30(%rbp), %rsi
callq 0x2bde0
jmp 0x2bbd6
leaq -0x68(%rbp), %rdi
callq 0x81c0
leaq -0x30(%rbp), %rdi
callq 0x8590
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x31(%rbp), %rdi
callq 0x85f0
jmp 0x2bc34
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x2bc2b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x81c0
leaq -0x30(%rbp), %rdi
callq 0x8590
movq -0x40(%rbp), %rdi
callq 0x85d0
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2dd80
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x8, %rsi
callq 0x2caf0
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x20, %rsi
callq 0x2ddc0
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x28, %rsi
callq 0x2caf0
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x40, %rsi
callq 0x2de00
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x60, %rsi
callq 0x2de40
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rsi, -0x98(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x32b60
testb $0x1, %al
jne 0x30121
jmp 0x30196
movq -0x8(%rbp), %rdi
callq 0xbe30
testb $0x1, %al
jne 0x30130
jmp 0x30132
jmp 0x30196
movq -0x98(%rbp), %rsi
movq -0x18(%rbp), %rdi
callq 0x32bf0
movq -0x98(%rbp), %rdi
movq -0x8(%rbp), %rax
addq $0x18, %rax
movq %rax, -0xa8(%rbp)
callq 0x32ae0
movq %rax, %rsi
leaq -0x80(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x32af0
movq -0xa8(%rbp), %rdi
movq -0xa0(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x301d0
jmp 0x3018d
leaq -0x80(%rbp), %rdi
callq 0x321f0
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x321f0
movq -0x88(%rbp), %rdi
callq 0x85d0
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rsi, -0x108(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x29eb0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x3020b
jmp 0x3030f
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
cmpq -0x28(%rbp), %rax
jae 0x302ad
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x32d30
movq -0x108(%rbp), %rsi
movq %rax, -0x118(%rbp)
leaq -0x90(%rbp), %rdi
movq %rdi, -0x110(%rbp)
callq 0x32ab0
movq -0x118(%rbp), %rdi
movq -0x110(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x30350
jmp 0x30270
leaq -0x90(%rbp), %rdi
callq 0x321f0
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x30213
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x321f0
jmp 0x30336
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
decq %rsi
callq 0x32d30
movq -0x108(%rbp), %rdi
movq %rax, -0x128(%rbp)
callq 0x32ae0
movq %rax, %rsi
leaq -0x100(%rbp), %rdi
movq %rdi, -0x120(%rbp)
callq 0x32af0
movq -0x128(%rbp), %rdi
movq -0x120(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x30350
jmp 0x30303
leaq -0x100(%rbp), %rdi
callq 0x321f0
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
leaq -0x100(%rbp), %rdi
callq 0x321f0
movq -0x98(%rbp), %rdi
callq 0x85d0
nopw %cs:(%rax,%rax)
// File: ridiculousfish[P]docopt_fish/docopt_matching.cpp
// Function: docopt_fish::match(docopt_fish::simple_clause_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 simple_clause_t &node, match_state_t state, const match_context_t &ctx,
                  match_state_list_t *resulting_states) {
    if (node.option.get()) {
        match(*node.option, state.move(), ctx, resulting_states);
    } else if (node.fixed.get()) {
        match(*node.fixed, state.move(), ctx, resulting_states);
    } else if (node.variable.get()) {
        match(*node.variable, state.move(), ctx, resulting_states);
    } else {
        assert(0 && "Bug in docopt parser: No children of simple_clause.");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x190, %rsp            # imm = 0x190
movq %rsi, -0x158(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2a050
cmpq $0x0, %rax
je 0x30e3b
movq -0x8(%rbp), %rdi
callq 0x2e2d0
movq -0x158(%rbp), %rdi
movq %rax, -0x168(%rbp)
callq 0x32ae0
movq %rax, %rsi
leaq -0x80(%rbp), %rdi
movq %rdi, -0x160(%rbp)
callq 0x32af0
movq -0x168(%rbp), %rdi
movq -0x160(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x31830
jmp 0x30e0d
leaq -0x80(%rbp), %rdi
callq 0x321f0
jmp 0x30f94
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x321f0
jmp 0x30f9d
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0x2e540
cmpq $0x0, %rax
je 0x30ed9
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0x2e5b0
movq -0x158(%rbp), %rdi
movq %rax, -0x178(%rbp)
callq 0x32ae0
movq %rax, %rsi
leaq -0xf0(%rbp), %rdi
movq %rdi, -0x170(%rbp)
callq 0x32af0
movq -0x178(%rbp), %rdi
movq -0x170(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x31930
jmp 0x30ea5
leaq -0xf0(%rbp), %rdi
callq 0x321f0
jmp 0x30f92
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0xf0(%rbp), %rdi
callq 0x321f0
jmp 0x30f9d
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
callq 0x2e8b0
cmpq $0x0, %rax
je 0x30f71
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
callq 0x2e920
movq -0x158(%rbp), %rdi
movq %rax, -0x188(%rbp)
callq 0x32ae0
movq %rax, %rsi
leaq -0x150(%rbp), %rdi
movq %rdi, -0x180(%rbp)
callq 0x32af0
movq -0x188(%rbp), %rdi
movq -0x180(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x31a60
jmp 0x30f43
leaq -0x150(%rbp), %rdi
callq 0x321f0
jmp 0x30f90
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0x150(%rbp), %rdi
callq 0x321f0
jmp 0x30f9d
leaq 0x1b4bc(%rip), %rdi     # 0x4c434
leaq 0x1b2b4(%rip), %rsi     # 0x4c233
movl $0x258, %edx            # imm = 0x258
leaq 0x1b4e4(%rip), %rcx     # 0x4c46f
callq 0x81e0
jmp 0x30f92
jmp 0x30f94
addq $0x190, %rsp            # imm = 0x190
popq %rbp
retq
movq -0x88(%rbp), %rdi
callq 0x85d0
nopl (%rax)
// File: ridiculousfish[P]docopt_fish/docopt_matching.cpp
// Function: docopt_fish::match(docopt_fish::option_clause_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 option_clause_t &node, match_state_t state, const match_context_t &ctx,
                  match_state_list_t *resulting_states) {
    // Matching an option like --foo
    const option_list_t options_in_doc(1, node.option);
    bool matched = match_options(options_in_doc, &state, ctx);
    if (matched || (ctx.flags & flag_match_allow_incomplete)) {
        resulting_states->push_back(state.move());
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rsi, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x60(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x11e20
movq -0x60(%rbp), %rdx
movq -0x58(%rbp), %rcx
leaq -0x38(%rbp), %rdi
movl $0x1, %esi
callq 0x336e0
jmp 0x31880
leaq -0x39(%rbp), %rdi
callq 0x25460
movq -0x68(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x38(%rbp), %rdi
callq 0x31310
movb %al, -0x69(%rbp)
jmp 0x3189f
movb -0x69(%rbp), %al
andb $0x1, %al
movb %al, -0x4d(%rbp)
testb $0x1, -0x4d(%rbp)
jne 0x318bb
movq -0x18(%rbp), %rax
movl (%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x31911
movq -0x68(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, -0x80(%rbp)
callq 0x32ae0
movq %rax, -0x78(%rbp)
jmp 0x318d2
movq -0x78(%rbp), %rsi
movq -0x80(%rbp), %rdi
callq 0x32d70
jmp 0x318e1
jmp 0x31911
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x39(%rbp), %rdi
callq 0x25460
jmp 0x31923
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xcb80
jmp 0x31923
leaq -0x38(%rbp), %rdi
callq 0xcb80
addq $0x80, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x85d0
nopl (%rax)
// File: ridiculousfish[P]docopt_fish/docopt_matching.cpp
// Function: docopt_fish::match(docopt_fish::fixed_clause_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 fixed_clause_t &node, match_state_t state, const match_context_t &ctx,
                  match_state_list_t *resulting_states) {
    // Fixed argument
    // Compare the next positional to this static argument
    if (ctx.has_more_positionals(state)) {
        const positional_argument_t &positional = ctx.next_positional(&state);
        rstring_t name = rstring_t(ctx.argv.at(positional.idx_in_argv));
        if (node.word == name) {
            // The static argument matches
            state.argument_values.mut()[name].count += 1;
            ctx.acquire_next_positional(&state);
            ctx.try_mark_fully_consumed(&state);
            resulting_states->push_back(state.move());
        }
    } else {
        // No more positionals. Maybe suggest one.
        if (ctx.flags & flag_generate_suggestions) {
            state.suggested_next_arguments.insert(node.word);
        }
        // Append the state if we are allowing incomplete
        if (ctx.flags & flag_match_allow_incomplete) {
            resulting_states->push_back(state.move());
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rsi, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x32b60
testb $0x1, %al
jne 0x3195e
jmp 0x31a04
movq -0x58(%rbp), %rsi
movq -0x18(%rbp), %rdi
callq 0x33a40
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rsi
callq 0xc930
movq %rax, %rsi
leaq -0x40(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
movq $-0x1, %rcx
callq 0xc430
movq -0x8(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x14ca0
testb $0x1, %al
jne 0x319ad
jmp 0x31a02
movq -0x58(%rbp), %rdi
callq 0x32840
movq %rax, %rdi
leaq -0x40(%rbp), %rsi
callq 0x33ac0
movq -0x58(%rbp), %rsi
movl 0x18(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x18(%rax)
movq -0x18(%rbp), %rdi
callq 0x32bf0
movq -0x58(%rbp), %rsi
movq -0x18(%rbp), %rdi
callq 0x33ba0
movq -0x58(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, -0x60(%rbp)
callq 0x32ae0
movq -0x60(%rbp), %rdi
movq %rax, %rsi
callq 0x32d70
jmp 0x31a59
movq -0x18(%rbp), %rax
movl (%rax), %eax
andl $0x10000, %eax          # imm = 0x10000
cmpl $0x0, %eax
je 0x31a2c
movq -0x58(%rbp), %rdi
addq $0x28, %rdi
movq -0x8(%rbp), %rsi
callq 0x18bd0
movq %rax, -0x50(%rbp)
movb %dl, -0x48(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x31a57
movq -0x58(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, -0x68(%rbp)
callq 0x32ae0
movq -0x68(%rbp), %rdi
movq %rax, %rsi
callq 0x32d70
jmp 0x31a59
addq $0x70, %rsp
popq %rbp
retq
nop
// File: ridiculousfish[P]docopt_fish/docopt_matching.cpp
// Function: docopt_fish::match(docopt_fish::variable_clause_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 variable_clause_t &node, match_state_t state, const match_context_t &ctx,
                  match_state_list_t *resulting_states) {
    // Variable argument
    const rstring_t &name = node.word;
    if (ctx.has_more_positionals(state)) {
        // Note we retain the brackets <> in the variable name
        // Note also that 'arg' points into an entry in the state argument value map
        const positional_argument_t &positional = ctx.acquire_next_positional(&state);
        const string_t &positional_value = ctx.argv.at(positional.idx_in_argv);
        option_rmap_t &args = state.argument_values.mut();
        args[name].values.push_back(positional_value);
        ctx.try_mark_fully_consumed(&state);
        resulting_states->push_back(state.move());
    } else {
        // No more positionals. Suggest one.
        if (ctx.flags & flag_generate_suggestions) {
            state.suggested_next_arguments.insert(name);
        }
        if (ctx.flags & flag_match_allow_incomplete) {
            resulting_states->push_back(state.move());
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rsi, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x32b60
testb $0x1, %al
jne 0x31a93
jmp 0x31b0e
movq -0x58(%rbp), %rsi
movq -0x18(%rbp), %rdi
callq 0x32bf0
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x30(%rbp), %rax
movq (%rax), %rsi
callq 0xc930
movq -0x58(%rbp), %rdi
movq %rax, -0x38(%rbp)
callq 0x32840
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x33ac0
movq %rax, %rdi
movq -0x38(%rbp), %rsi
callq 0x2bde0
movq -0x58(%rbp), %rsi
movq -0x18(%rbp), %rdi
callq 0x33ba0
movq -0x58(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, -0x60(%rbp)
callq 0x32ae0
movq -0x60(%rbp), %rdi
movq %rax, %rsi
callq 0x32d70
jmp 0x31b63
movq -0x18(%rbp), %rax
movl (%rax), %eax
andl $0x10000, %eax          # imm = 0x10000
cmpl $0x0, %eax
je 0x31b36
movq -0x58(%rbp), %rdi
addq $0x28, %rdi
movq -0x28(%rbp), %rsi
callq 0x18bd0
movq %rax, -0x50(%rbp)
movb %dl, -0x48(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x31b61
movq -0x58(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, -0x68(%rbp)
callq 0x32ae0
movq -0x68(%rbp), %rdi
movq %rax, %rsi
callq 0x32d70
jmp 0x31b63
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x3a9b0
testb $0x1, %al
jne 0x32888
movq -0x20(%rbp), %rdi
callq 0x3a9e0
movq %rax, %rsi
leaq -0x18(%rbp), %rdi
callq 0x38ff0
movq -0x20(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x35b40
leaq -0x18(%rbp), %rdi
callq 0x38cf0
movq -0x20(%rbp), %rdi
callq 0x3a9e0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)