LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: meirdev[P]HexViewer/./CLI11.hpp
// Function: CLI::App::_parse_single(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&, bool&)
void _parse_single(std::vector<std::string> &args, bool &positional_only) {

        detail::Classifier classifier = positional_only ? detail::Classifier::NONE : _recognize(args.back());
        switch(classifier) {
        case detail::Classifier::POSITIONAL_MARK:
            missing_.emplace_back(classifier, args.back());
            args.pop_back();
            positional_only = true;
            break;
        case detail::Classifier::SUBCOMMAND:
            _parse_subcommand(args);
            break;
        case detail::Classifier::LONG:
        case detail::Classifier::SHORT:
        case detail::Classifier::WINDOWS:
            // If already parsed a subcommand, don't accept options_
            _parse_arg(args, classifier);
            break;
        case detail::Classifier::NONE:
            // Probably a positional or something for a parent (sub)command
            _parse_positional(args);
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
testb $0x1, (%rax)
je 0x237cc
xorl %eax, %eax
movl %eax, -0x2c(%rbp)
jmp 0x237e4
movq -0x10(%rbp), %rdi
callq 0x162e0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x23cc0
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq %rax, -0x38(%rbp)
subq $0x5, %rax
ja 0x23872
movq -0x38(%rbp), %rax
leaq 0x1d952(%rip), %rcx     # 0x41154
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x28(%rbp), %rax
addq $0x110, %rax            # imm = 0x110
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x162e0
movq -0x40(%rbp), %rdi
movq %rax, %rdx
leaq -0x1c(%rbp), %rsi
callq 0x23e40
movq -0x10(%rbp), %rdi
callq 0x23ec0
movq -0x18(%rbp), %rax
movb $0x1, (%rax)
jmp 0x23872
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x23ef0
jmp 0x23872
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x24210
jmp 0x23872
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x25010
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: meirdev[P]HexViewer/./CLI11.hpp
// Function: CLI::App::_process()
void _process() {
        _process_ini();
        _process_env();
        _process_callbacks();
        _process_help_flags();
        _process_requirements();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x28f30
movq -0x10(%rbp), %rdi
callq 0x29070
movq -0x10(%rbp), %rdi
callq 0x29300
movq -0x10(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x29410
movq -0x10(%rbp), %rdi
callq 0x295c0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: meirdev[P]HexViewer/./CLI11.hpp
// Function: CLI::App::_process_extras(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&)
void _process_extras(std::vector<std::string> &args) {
        if(!(allow_extras_ || prefix_command_)) {
            size_t num_left_over = remaining_size();
            if(num_left_over > 0) {
                args = remaining(false);
                throw ExtrasError(args);
            }
        }

        for(App_p &sub : subcommands_) {
            if(sub->count() > 0)
                sub->_process_extras(args);
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
testb $0x1, 0x48(%rax)
jne 0x239e6
movq -0x80(%rbp), %rax
testb $0x1, 0x4a(%rax)
jne 0x239e6
movq -0x80(%rbp), %rdi
xorl %esi, %esi
callq 0x2f3b0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jbe 0x239e4
movq -0x80(%rbp), %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x90(%rbp)
xorl %edx, %edx
callq 0x23a80
movq -0x90(%rbp), %rsi
movq -0x10(%rbp), %rdi
callq 0x1d9a0
movq -0x90(%rbp), %rdi
callq 0x8710
movb $0x1, -0x55(%rbp)
movl $0x38, %edi
callq 0x6200
movq %rax, -0x88(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x115e0
jmp 0x23973
movq -0x88(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x2f490
jmp 0x23985
movq -0x88(%rbp), %rdi
movb $0x0, -0x55(%rbp)
leaq 0x3a089(%rip), %rsi     # 0x5da20
leaq 0xbc52(%rip), %rdx      # 0x2f5f0
callq 0x6700
jmp 0x23a79
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x239cb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x8710
testb $0x1, -0x55(%rbp)
jne 0x239d3
jmp 0x239df
movq -0x88(%rbp), %rdi
callq 0x6310
jmp 0x23a70
jmp 0x239e6
movq -0x80(%rbp), %rax
addq $0x158, %rax            # imm = 0x158
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rdi
callq 0x230a0
movq %rax, -0x68(%rbp)
movq -0x60(%rbp), %rdi
callq 0x230d0
movq %rax, -0x70(%rbp)
leaq -0x68(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x23100
testb $0x1, %al
jne 0x23a21
jmp 0x23a67
leaq -0x68(%rbp), %rdi
callq 0x23140
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rdi
callq 0x23160
movq %rax, %rdi
callq 0x2eaf0
cmpq $0x0, %rax
jbe 0x23a5a
movq -0x78(%rbp), %rdi
callq 0x23160
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x238d0
jmp 0x23a5c
leaq -0x68(%rbp), %rdi
callq 0x23180
jmp 0x23a0e
addq $0x90, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x6750
nopl (%rax)
// File: meirdev[P]HexViewer/./CLI11.hpp
// Function: CLI::App::remaining[abi:cxx11](bool) const
std::vector<std::string> remaining(bool recurse = false) const {
        std::vector<std::string> miss_list;
        for(const std::pair<detail::Classifier, std::string> &miss : missing_) {
            miss_list.push_back(std::get<1>(miss));
        }

        // Recurse into subcommands
        if(recurse) {
            for(const App *sub : parsed_subcommands_) {
                std::vector<std::string> output = sub->remaining(recurse);
                std::copy(std::begin(output), std::end(output), std::back_inserter(miss_list));
            }
        }
        return miss_list;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0xb8(%rbp)
movb %dl, %al
movq %rdi, %rcx
movq %rcx, -0xb0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xa8(%rbp)
movb $0x0, -0x12(%rbp)
callq 0x15e10
movq -0xa8(%rbp), %rax
addq $0x110, %rax            # imm = 0x110
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2f840
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2f890
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x2f740
testb $0x1, %al
jne 0x23afd
jmp 0x23b42
leaq -0x28(%rbp), %rdi
callq 0x2f810
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x2fb30
movq -0xb8(%rbp), %rdi
movq %rax, %rsi
callq 0x173f0
jmp 0x23b24
jmp 0x23b26
leaq -0x28(%rbp), %rdi
callq 0x2f7c0
jmp 0x23aea
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x23c9d
testb $0x1, -0x11(%rbp)
je 0x23c77
movq -0xa8(%rbp), %rax
addq $0x140, %rax            # imm = 0x140
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
callq 0x2e090
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rdi
callq 0x2e0c0
movq %rax, -0x60(%rbp)
leaq -0x58(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x2e0f0
testb $0x1, %al
jne 0x23b8d
jmp 0x23c75
leaq -0x58(%rbp), %rdi
callq 0x2e130
movq (%rax), %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rsi
movzbl -0x11(%rbp), %edx
andl $0x1, %edx
leaq -0x80(%rbp), %rdi
callq 0x23a80
jmp 0x23bb3
leaq -0x80(%rbp), %rdi
callq 0x2fbc0
movq %rax, -0xc0(%rbp)
jmp 0x23bc5
movq -0xc0(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x2fbf0
movq %rax, -0xc8(%rbp)
jmp 0x23be5
movq -0xb8(%rbp), %rdi
movq -0xc8(%rbp), %rax
movq %rax, -0x90(%rbp)
callq 0x2fc20
movq %rax, -0xd0(%rbp)
jmp 0x23c08
movq -0xd0(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x88(%rbp), %rdi
movq -0x90(%rbp), %rsi
movq -0x98(%rbp), %rdx
callq 0x2fb50
movq %rax, -0xd8(%rbp)
jmp 0x23c39
movq -0xd8(%rbp), %rax
movq %rax, -0xa0(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x8710
leaq -0x58(%rbp), %rdi
callq 0x2e150
jmp 0x23b77
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x8710
jmp 0x23c9d
jmp 0x23c77
movb $0x1, -0x12(%rbp)
testb $0x1, -0x12(%rbp)
jne 0x23c8d
movq -0xb8(%rbp), %rdi
callq 0x8710
movq -0xb0(%rbp), %rax
addq $0xe0, %rsp
popq %rbp
retq
movq -0xb8(%rbp), %rdi
callq 0x8710
movq -0x40(%rbp), %rdi
callq 0x6750
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: meirdev[P]HexViewer/./CLI11.hpp
// Function: CLI::App::_recognize(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
detail::Classifier _recognize(const std::string &current) const {
        std::string dummy1, dummy2;

        if(current == "--")
            return detail::Classifier::POSITIONAL_MARK;
        if(_valid_subcommand(current))
            return detail::Classifier::SUBCOMMAND;
        if(detail::split_long(current, dummy1, dummy2))
            return detail::Classifier::LONG;
        if(detail::split_short(current, dummy1, dummy2))
            return detail::Classifier::SHORT;
        if((allow_windows_style_options_) && (detail::split_windows(current, dummy1, dummy2)))
            return detail::Classifier::WINDOWS;
        return detail::Classifier::NONE;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x65f0
leaq -0x58(%rbp), %rdi
callq 0x65f0
movq -0x18(%rbp), %rdi
leaq 0x1d74f(%rip), %rsi     # 0x41447
callq 0x1be30
testb $0x1, %al
jne 0x23d03
jmp 0x23d16
movl $0x1, -0x4(%rbp)
movl $0x1, -0x5c(%rbp)
jmp 0x23e0f
movq -0x78(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x252e0
movb %al, -0x79(%rbp)
jmp 0x23d28
movb -0x79(%rbp), %al
testb $0x1, %al
jne 0x23d31
jmp 0x23d67
movl $0x5, -0x4(%rbp)
movl $0x1, -0x5c(%rbp)
jmp 0x23e0f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x6280
leaq -0x38(%rbp), %rdi
callq 0x6280
jmp 0x23e2d
movq -0x18(%rbp), %rdi
leaq -0x38(%rbp), %rsi
leaq -0x58(%rbp), %rdx
callq 0x254c0
movb %al, -0x7a(%rbp)
jmp 0x23d7d
movb -0x7a(%rbp), %al
testb $0x1, %al
jne 0x23d86
jmp 0x23d96
movl $0x3, -0x4(%rbp)
movl $0x1, -0x5c(%rbp)
jmp 0x23e0f
movq -0x18(%rbp), %rdi
leaq -0x38(%rbp), %rsi
leaq -0x58(%rbp), %rdx
callq 0x256a0
movb %al, -0x7b(%rbp)
jmp 0x23dac
movb -0x7b(%rbp), %al
testb $0x1, %al
jne 0x23db5
jmp 0x23dc5
movl $0x2, -0x4(%rbp)
movl $0x1, -0x5c(%rbp)
jmp 0x23e0f
movq -0x78(%rbp), %rax
testb $0x1, 0x173(%rax)
je 0x23e01
movq -0x18(%rbp), %rdi
leaq -0x38(%rbp), %rsi
leaq -0x58(%rbp), %rdx
callq 0x25770
movb %al, -0x7c(%rbp)
jmp 0x23de8
movb -0x7c(%rbp), %al
testb $0x1, %al
jne 0x23df1
jmp 0x23e01
movl $0x4, -0x4(%rbp)
movl $0x1, -0x5c(%rbp)
jmp 0x23e0f
movl $0x0, -0x4(%rbp)
movl $0x1, -0x5c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x6280
leaq -0x38(%rbp), %rdi
callq 0x6280
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x6750
nopw %cs:(%rax,%rax)
// File: meirdev[P]HexViewer/./CLI11.hpp
// Function: CLI::App::_valid_subcommand(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
bool _valid_subcommand(const std::string &current) const {
        // Don't match if max has been reached - but still check parents
        if(require_subcommand_max_ != 0 && parsed_subcommands_.size() >= require_subcommand_max_) {
            return parent_ != nullptr && parent_->_valid_subcommand(current);
        }

        for(const App_p &com : subcommands_)
            if(com->check_name(current) && !*com)
                return true;

        // Check parent if exists, else return false
        return parent_ != nullptr && parent_->_valid_subcommand(current);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
cmpq $0x0, 0x190(%rax)
je 0x25359
movq -0x70(%rbp), %rdi
addq $0x140, %rdi            # imm = 0x140
callq 0x258c0
movq -0x70(%rbp), %rcx
cmpq 0x190(%rcx), %rax
jb 0x25359
movq -0x70(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, 0x178(%rcx)
movb %al, -0x71(%rbp)
je 0x2534c
movq -0x70(%rbp), %rax
movq 0x178(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x252e0
movb %al, -0x71(%rbp)
movb -0x71(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x254a9
movq -0x70(%rbp), %rax
addq $0x158, %rax            # imm = 0x158
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x13280
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x132d0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x13110
testb $0x1, %al
jne 0x25397
jmp 0x2546e
leaq -0x28(%rbp), %rdi
callq 0x13170
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x23160
movq %rax, -0x88(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x58(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x61d0
movq -0x88(%rbp), %rdi
movq -0x80(%rbp), %rsi
callq 0x258e0
movb %al, -0x72(%rbp)
jmp 0x253da
movb -0x72(%rbp), %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x89(%rbp)
jne 0x253ec
jmp 0x25420
movq -0x38(%rbp), %rdi
callq 0x25b60
movq %rax, -0x98(%rbp)
jmp 0x253fe
movq -0x98(%rbp), %rdi
callq 0x25b90
movb %al, -0x99(%rbp)
jmp 0x25412
movb -0x99(%rbp), %al
xorb $-0x1, %al
movb %al, -0x89(%rbp)
movb -0x89(%rbp), %al
movb %al, -0x9a(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x6280
movb -0x9a(%rbp), %al
testb $0x1, %al
jne 0x25441
jmp 0x2545e
movb $0x1, -0x1(%rbp)
jmp 0x254a9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x6280
jmp 0x254b7
jmp 0x25460
leaq -0x28(%rbp), %rdi
callq 0x13190
jmp 0x25381
movq -0x70(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, 0x178(%rcx)
movb %al, -0x9b(%rbp)
je 0x2549e
movq -0x70(%rbp), %rax
movq 0x178(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x252e0
movb %al, -0x9b(%rbp)
movb -0x9b(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xa0, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x6750
// File: meirdev[P]HexViewer/./CLI11.hpp
// Function: CLI::detail::split_long(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
inline bool split_long(const std::string &current, std::string &name, std::string &value) {
    if(current.size() > 2 && current.substr(0, 2) == "--" && valid_first_char(current[2])) {
        auto loc = current.find_first_of('=');
        if(loc != std::string::npos) {
            name = current.substr(2, loc - 2);
            value = current.substr(loc + 1);
        } else {
            name = current.substr(2);
            value = "";
        }
        return true;
    } else
        return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x62d0
movq %rax, %rcx
movb $0x0, -0x41(%rbp)
xorl %eax, %eax
cmpq $0x2, %rcx
movb %al, -0xc1(%rbp)
jbe 0x2555c
movq -0x10(%rbp), %rsi
leaq -0x40(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
movl $0x2, %ecx
callq 0x6420
movb $0x1, -0x41(%rbp)
leaq -0x40(%rbp), %rdi
leaq 0x1bf2d(%rip), %rsi     # 0x41447
callq 0x1be30
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0xc1(%rbp)
jne 0x25530
jmp 0x2555c
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x6480
movsbl (%rax), %edi
callq 0x1bc80
movb %al, -0xc2(%rbp)
jmp 0x2554e
movb -0xc2(%rbp), %al
movb %al, -0xc1(%rbp)
jmp 0x2555c
movb -0xc1(%rbp), %al
movb %al, -0xc3(%rbp)
testb $0x1, -0x41(%rbp)
jne 0x25570
jmp 0x25579
leaq -0x40(%rbp), %rdi
callq 0x6280
movb -0xc3(%rbp), %al
testb $0x1, %al
jne 0x25588
jmp 0x25683
movq -0x10(%rbp), %rdi
movl $0x3d, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x6290
movq %rax, -0x60(%rbp)
cmpq $-0x1, -0x60(%rbp)
je 0x25635
movq -0x10(%rbp), %rsi
movq -0x60(%rbp), %rcx
subq $0x2, %rcx
leaq -0x80(%rbp), %rdi
movl $0x2, %edx
callq 0x6420
movq -0x18(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x6520
leaq -0x80(%rbp), %rdi
callq 0x6280
movq -0x10(%rbp), %rsi
movq -0x60(%rbp), %rdx
addq $0x1, %rdx
leaq -0xa0(%rbp), %rdi
movq $-0x1, %rcx
callq 0x6420
movq -0x20(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x6520
leaq -0xa0(%rbp), %rdi
callq 0x6280
jmp 0x2567d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
testb $0x1, -0x41(%rbp)
jne 0x2562a
jmp 0x25633
leaq -0x40(%rbp), %rdi
callq 0x6280
jmp 0x25695
movq -0x10(%rbp), %rsi
leaq -0xc0(%rbp), %rdi
movl $0x2, %edx
movq $-0x1, %rcx
callq 0x6420
movq -0x18(%rbp), %rdi
leaq -0xc0(%rbp), %rsi
callq 0x6520
leaq -0xc0(%rbp), %rdi
callq 0x6280
movq -0x20(%rbp), %rdi
leaq 0x1c30a(%rip), %rsi     # 0x41982
callq 0x65e0
movb $0x1, -0x1(%rbp)
jmp 0x25687
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xd0, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x6750
nop
// File: meirdev[P]HexViewer/./CLI11.hpp
// Function: CLI::detail::split_short(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
inline bool split_short(const std::string &current, std::string &name, std::string &rest) {
    if(current.size() > 1 && current[0] == '-' && valid_first_char(current[1])) {
        name = current.substr(1, 1);
        rest = current.substr(2);
        return true;
    } else
        return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x62d0
cmpq $0x1, %rax
jbe 0x25758
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x6480
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x25758
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x6480
movsbl (%rax), %edi
callq 0x1bc80
testb $0x1, %al
jne 0x256f8
jmp 0x25758
movq -0x10(%rbp), %rsi
leaq -0x40(%rbp), %rdi
movl $0x1, %ecx
movq %rcx, %rdx
callq 0x6420
movq -0x18(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x6520
leaq -0x40(%rbp), %rdi
callq 0x6280
movq -0x10(%rbp), %rsi
leaq -0x60(%rbp), %rdi
movl $0x2, %edx
movq $-0x1, %rcx
callq 0x6420
movq -0x20(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x6520
leaq -0x60(%rbp), %rdi
callq 0x6280
movb $0x1, -0x1(%rbp)
jmp 0x2575c
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: meirdev[P]HexViewer/./CLI11.hpp
// Function: CLI::detail::split_windows(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
inline bool split_windows(const std::string &current, std::string &name, std::string &value) {
    if(current.size() > 1 && current[0] == '/' && valid_first_char(current[1])) {
        auto loc = current.find_first_of(':');
        if(loc != std::string::npos) {
            name = current.substr(1, loc - 1);
            value = current.substr(loc + 1);
        } else {
            name = current.substr(1);
            value = "";
        }
        return true;
    } else
        return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x62d0
cmpq $0x1, %rax
jbe 0x258a1
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x6480
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0x258a1
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x6480
movsbl (%rax), %edi
callq 0x1bc80
testb $0x1, %al
jne 0x257d2
jmp 0x258a1
movq -0x10(%rbp), %rdi
movl $0x3a, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x6290
movq %rax, -0x28(%rbp)
cmpq $-0x1, -0x28(%rbp)
je 0x25853
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rcx
subq $0x1, %rcx
leaq -0x48(%rbp), %rdi
movl $0x1, %edx
callq 0x6420
movq -0x18(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x6520
leaq -0x48(%rbp), %rdi
callq 0x6280
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
addq $0x1, %rdx
leaq -0x68(%rbp), %rdi
movq $-0x1, %rcx
callq 0x6420
movq -0x20(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x6520
leaq -0x68(%rbp), %rdi
callq 0x6280
jmp 0x2589b
movq -0x10(%rbp), %rsi
leaq -0x88(%rbp), %rdi
movl $0x1, %edx
movq $-0x1, %rcx
callq 0x6420
movq -0x18(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x6520
leaq -0x88(%rbp), %rdi
callq 0x6280
movq -0x20(%rbp), %rdi
leaq 0x1c0ec(%rip), %rsi     # 0x41982
callq 0x65e0
movb $0x1, -0x1(%rbp)
jmp 0x258a5
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: meirdev[P]HexViewer/./CLI11.hpp
// Function: CLI::App::check_name(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) const
bool check_name(std::string name_to_check) const {
        std::string local_name = name_;
        if(ignore_underscore_) {
            local_name = detail::remove_underscore(name_);
            name_to_check = detail::remove_underscore(name_to_check);
        }
        if(ignore_case_) {
            local_name = detail::to_lower(name_);
            name_to_check = detail::to_lower(name_to_check);
        }

        return local_name == name_to_check;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x170, %rsp            # imm = 0x170
movq %rsi, -0x150(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x148(%rbp)
addq $0x8, %rsi
leaq -0x30(%rbp), %rdi
callq 0x61d0
movq -0x148(%rbp), %rax
testb $0x1, 0x171(%rax)
je 0x25a13
movq -0x148(%rbp), %rsi
addq $0x8, %rsi
leaq -0x70(%rbp), %rdi
callq 0x61d0
jmp 0x2593c
leaq -0x50(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x1f5f0
jmp 0x2594b
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rsi
movq %rsi, -0x158(%rbp)
callq 0x6520
movq -0x158(%rbp), %rdi
callq 0x6280
leaq -0x70(%rbp), %rdi
callq 0x6280
movq -0x150(%rbp), %rsi
leaq -0xc0(%rbp), %rdi
callq 0x61d0
jmp 0x25989
leaq -0xa0(%rbp), %rdi
leaq -0xc0(%rbp), %rsi
callq 0x1f5f0
jmp 0x2599e
movq -0x150(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x6520
leaq -0xa0(%rbp), %rdi
callq 0x6280
leaq -0xc0(%rbp), %rdi
callq 0x6280
jmp 0x25a13
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x25b3f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x6280
jmp 0x25b3f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0xc0(%rbp), %rdi
callq 0x6280
jmp 0x25b3f
movq -0x148(%rbp), %rax
testb $0x1, 0x170(%rax)
je 0x25b0f
movq -0x148(%rbp), %rsi
addq $0x8, %rsi
leaq -0x100(%rbp), %rdi
callq 0x61d0
jmp 0x25a40
leaq -0xe0(%rbp), %rdi
leaq -0x100(%rbp), %rsi
callq 0x1eae0
jmp 0x25a55
leaq -0x30(%rbp), %rdi
leaq -0xe0(%rbp), %rsi
movq %rsi, -0x160(%rbp)
callq 0x6520
movq -0x160(%rbp), %rdi
callq 0x6280
leaq -0x100(%rbp), %rdi
callq 0x6280
movq -0x150(%rbp), %rsi
leaq -0x140(%rbp), %rdi
callq 0x61d0
jmp 0x25a99
leaq -0x120(%rbp), %rdi
leaq -0x140(%rbp), %rsi
callq 0x1eae0
jmp 0x25aae
movq -0x150(%rbp), %rdi
leaq -0x120(%rbp), %rsi
callq 0x6520
leaq -0x120(%rbp), %rdi
callq 0x6280
leaq -0x140(%rbp), %rdi
callq 0x6280
jmp 0x25b0f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x100(%rbp), %rdi
callq 0x6280
jmp 0x25b3f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x140(%rbp), %rdi
callq 0x6280
jmp 0x25b3f
movq -0x150(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x1f1f0
movb %al, -0x161(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x6280
movb -0x161(%rbp), %al
andb $0x1, %al
addq $0x170, %rsp            # imm = 0x170
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x6280
movq -0x78(%rbp), %rdi
callq 0x6750
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: meirdev[P]HexViewer/./CLI11.hpp
// Function: CLI::App::_count_remaining_positionals(bool) const
size_t _count_remaining_positionals(bool required = false) const {
        size_t retval = 0;
        for(const Option_p &opt : options_)
            if(opt->get_positional() && (!required || opt->get_required()) && opt->get_items_expected() > 0 &&
               static_cast<int>(opt->count()) < opt->get_items_expected())
                retval = static_cast<size_t>(opt->get_items_expected()) - opt->count();

        return retval;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, -0x18(%rbp)
addq $0x98, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x10b50
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x10ba0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x109e0
testb $0x1, %al
jne 0x265ea
jmp 0x266b8
leaq -0x28(%rbp), %rdi
callq 0x10a40
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x17be0
movq %rax, %rdi
callq 0x19c40
testb $0x1, %al
jne 0x26611
jmp 0x266a8
testb $0x1, -0x9(%rbp)
je 0x2662e
movq -0x38(%rbp), %rdi
callq 0x17be0
movq %rax, %rdi
callq 0x268f0
testb $0x1, %al
jne 0x2662e
jmp 0x266a8
movq -0x38(%rbp), %rdi
callq 0x17be0
movq %rax, %rdi
callq 0x8f80
cmpl $0x0, %eax
jle 0x266a8
movq -0x38(%rbp), %rdi
callq 0x17be0
movq %rax, %rdi
callq 0x8830
movl %eax, -0x3c(%rbp)
movq -0x38(%rbp), %rdi
callq 0x17be0
movq %rax, %rdi
callq 0x8f80
movl %eax, %ecx
movl -0x3c(%rbp), %eax
cmpl %ecx, %eax
jge 0x266a8
movq -0x38(%rbp), %rdi
callq 0x17be0
movq %rax, %rdi
callq 0x8f80
cltq
movq %rax, -0x48(%rbp)
movq -0x38(%rbp), %rdi
callq 0x17be0
movq %rax, %rdi
callq 0x8830
movq %rax, %rcx
movq -0x48(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x18(%rbp)
jmp 0x266aa
leaq -0x28(%rbp), %rdi
callq 0x10a60
jmp 0x265d4
movq -0x18(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: meirdev[P]HexViewer/./CLI11.hpp
// Function: CLI::App::_process_ini()
void _process_ini() {
        // Process an INI file
        if(config_ptr_ != nullptr) {
            if(*config_ptr_) {
                config_ptr_->run_callback();
                config_required_ = true;
            }
            if(!config_name_.empty()) {
                try {
                    std::vector<ConfigItem> values = config_formatter_->from_file(config_name_);
                    _parse_config(values);
                } catch(const FileError &) {
                    if(config_required_)
                        throw;
                }
            }
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, 0x1e0(%rax)
je 0x2904f
movq -0x40(%rbp), %rax
movq 0x1e0(%rax), %rdi
callq 0x29d30
testb $0x1, %al
jne 0x28f68
jmp 0x28f83
movq -0x40(%rbp), %rax
movq 0x1e0(%rax), %rdi
callq 0x29d60
movq -0x40(%rbp), %rax
movb $0x1, 0x1d8(%rax)
movq -0x40(%rbp), %rdi
addq $0x1b8, %rdi            # imm = 0x1B8
callq 0x66e0
testb $0x1, %al
jne 0x2904d
movq -0x40(%rbp), %rdi
addq $0x1e8, %rdi            # imm = 0x1E8
callq 0x2aa60
movq -0x40(%rbp), %rdx
movq %rax, %rsi
addq $0x1b8, %rdx            # imm = 0x1B8
leaq -0x20(%rbp), %rdi
callq 0x2aa80
jmp 0x28fc4
movq -0x40(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x2ac20
jmp 0x28fd3
leaq -0x20(%rbp), %rdi
callq 0x16f00
jmp 0x29049
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x29001
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x16f00
movl -0x2c(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x29055
movq -0x28(%rbp), %rdi
callq 0x61a0
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, -0x38(%rbp)
testb $0x1, 0x1d8(%rax)
je 0x29044
callq 0x6620
jmp 0x29066
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x66d0
jmp 0x2904b
callq 0x66d0
jmp 0x2904d
jmp 0x29055
jmp 0x2904f
addq $0x40, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x6750
movq %rax, %rdi
callq 0xa740
nopw %cs:(%rax,%rax)
// File: meirdev[P]HexViewer/./CLI11.hpp
// Function: CLI::App::_process_callbacks()
void _process_callbacks() {
        for(const Option_p &opt : options_) {
            if(opt->count() > 0 && !opt->get_callback_run()) {
                opt->run_callback();
            }
        }

        for(App_p &sub : subcommands_) {
            sub->_process_callbacks();
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
addq $0x98, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x17b20
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x17b50
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x17b80
testb $0x1, %al
jne 0x2934b
jmp 0x293a2
leaq -0x18(%rbp), %rdi
callq 0x17bc0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x17be0
movq %rax, %rdi
callq 0x8830
cmpq $0x0, %rax
jbe 0x29395
movq -0x28(%rbp), %rdi
callq 0x17be0
movq %rax, %rdi
callq 0x2e030
testb $0x1, %al
jne 0x29395
movq -0x28(%rbp), %rdi
callq 0x17be0
movq %rax, %rdi
callq 0x29d60
jmp 0x29397
leaq -0x18(%rbp), %rdi
callq 0x17d60
jmp 0x29338
movq -0x50(%rbp), %rax
addq $0x158, %rax            # imm = 0x158
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x230a0
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0x230d0
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x23100
testb $0x1, %al
jne 0x293dd
jmp 0x29406
leaq -0x38(%rbp), %rdi
callq 0x23140
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
callq 0x23160
movq %rax, %rdi
callq 0x29300
leaq -0x38(%rbp), %rdi
callq 0x23180
jmp 0x293ca
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: meirdev[P]HexViewer/./CLI11.hpp
// Function: CLI::App::_process_help_flags(bool, bool) const
void _process_help_flags(bool trigger_help = false, bool trigger_all_help = false) const {
        const Option *help_ptr = get_help_ptr();
        const Option *help_all_ptr = get_help_all_ptr();

        if(help_ptr != nullptr && help_ptr->count() > 0)
            trigger_help = true;
        if(help_all_ptr != nullptr && help_all_ptr->count() > 0)
            trigger_all_help = true;

        // If there were parsed subcommands, call those. First subcommand wins if there are multiple ones.
        if(!parsed_subcommands_.empty()) {
            for(const App *sub : parsed_subcommands_)
                sub->_process_help_flags(trigger_help, trigger_all_help);

            // Only the final subcommand should call for help. All help wins over help.
        } else if(trigger_all_help) {
            throw CallForAllHelp();
        } else if(trigger_help) {
            throw CallForHelp();
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movb %dl, %al
movb %sil, %cl
movq %rdi, -0x8(%rbp)
andb $0x1, %cl
movb %cl, -0x9(%rbp)
andb $0x1, %al
movb %al, -0xa(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x15e30
movq -0x58(%rbp), %rdi
movq %rax, -0x18(%rbp)
callq 0x15e80
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x29464
movq -0x18(%rbp), %rdi
callq 0x8830
cmpq $0x0, %rax
jbe 0x29464
movb $0x1, -0x9(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x2947e
movq -0x20(%rbp), %rdi
callq 0x8830
cmpq $0x0, %rax
jbe 0x2947e
movb $0x1, -0xa(%rbp)
movq -0x58(%rbp), %rdi
addq $0x140, %rdi            # imm = 0x140
callq 0x2e050
testb $0x1, %al
jne 0x29507
movq -0x58(%rbp), %rax
addq $0x140, %rax            # imm = 0x140
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x2e090
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x2e0c0
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x2e0f0
testb $0x1, %al
jne 0x294cd
jmp 0x29502
leaq -0x30(%rbp), %rdi
callq 0x2e130
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
movb -0x9(%rbp), %cl
movb -0xa(%rbp), %al
andb $0x1, %cl
andb $0x1, %al
movzbl %cl, %esi
movzbl %al, %edx
callq 0x29410
leaq -0x30(%rbp), %rdi
callq 0x2e150
jmp 0x294ba
jmp 0x295a9
testb $0x1, -0xa(%rbp)
je 0x29556
movl $0x38, %edi
callq 0x6200
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x60(%rbp)
callq 0x2e170
jmp 0x29528
movq -0x60(%rbp), %rdi
leaq 0x343ad(%rip), %rsi     # 0x5d8e0
leaq 0x4cd6(%rip), %rdx      # 0x2e210
callq 0x6700
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
callq 0x6310
jmp 0x295af
testb $0x1, -0x9(%rbp)
je 0x295a5
movl $0x38, %edi
callq 0x6200
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x68(%rbp)
callq 0x2e230
jmp 0x29577
movq -0x68(%rbp), %rdi
leaq 0x34376(%rip), %rsi     # 0x5d8f8
leaq 0x4d47(%rip), %rdx      # 0x2e2d0
callq 0x6700
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
callq 0x6310
jmp 0x295af
jmp 0x295a7
jmp 0x295a9
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x6750
nopl (%rax,%rax)
// File: meirdev[P]HexViewer/./CLI11.hpp
// Function: CLI::Config::from_file(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::vector<ConfigItem> from_file(const std::string &name) {
        std::ifstream input{name};
        if(!input.good())
            throw FileError::Missing(name);

        return from_config(input);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x280, %rsp            # imm = 0x280
movq %rdi, -0x270(%rbp)
movq %rdi, %rax
movq %rax, -0x268(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x260(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x220(%rbp), %rdi
movl $0x8, %edx
callq 0x66b0
movq -0x220(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x220(%rbp,%rax), %rdi
callq 0x66f0
movb %al, -0x252(%rbp)
jmp 0x2aae8
movb -0x252(%rbp), %al
testb $0x1, %al
jne 0x2abbf
jmp 0x2aaf8
movb $0x1, -0x251(%rbp)
movl $0x38, %edi
callq 0x6200
movq %rax, -0x278(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x250(%rbp), %rdi
callq 0x61d0
jmp 0x2ab22
movq -0x278(%rbp), %rdi
leaq -0x250(%rbp), %rsi
callq 0x2c560
jmp 0x2ab37
movq -0x278(%rbp), %rdi
movb $0x0, -0x251(%rbp)
leaq 0x32c54(%rip), %rsi     # 0x5d7a0
leaq 0x1a7d(%rip), %rdx      # 0x2c5d0
callq 0x6700
jmp 0x2ac13
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
jmp 0x2abfb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
jmp 0x2aba6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
leaq -0x250(%rbp), %rdi
callq 0x6280
testb $0x1, -0x251(%rbp)
jne 0x2abb1
jmp 0x2abbd
movq -0x278(%rbp), %rdi
callq 0x6310
jmp 0x2abfb
movq -0x260(%rbp), %rsi
movq -0x270(%rbp), %rdi
movq (%rsi), %rax
movq 0x8(%rax), %rax
leaq -0x220(%rbp), %rdx
callq *%rax
jmp 0x2abdf
leaq -0x220(%rbp), %rdi
callq 0x6100
movq -0x268(%rbp), %rax
addq $0x280, %rsp            # imm = 0x280
popq %rbp
retq
leaq -0x220(%rbp), %rdi
callq 0x6100
movq -0x228(%rbp), %rdi
callq 0x6750
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: meirdev[P]HexViewer/./CLI11.hpp
// Function: CLI::App::get_subcommand(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) const
App *get_subcommand(std::string subcom) const {
        for(const App_p &subcomptr : subcommands_)
            if(subcomptr->check_name(subcom))
                return subcomptr.get();
        throw OptionNotFound(subcom);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rsi, -0x90(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq $0x158, %rax            # imm = 0x158
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x13280
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x132d0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x13110
testb $0x1, %al
jne 0x2cfb8
jmp 0x2d058
leaq -0x20(%rbp), %rdi
callq 0x13170
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x23160
movq -0x90(%rbp), %rsi
movq %rax, -0xa8(%rbp)
leaq -0x50(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x61d0
movq -0xa8(%rbp), %rdi
movq -0xa0(%rbp), %rsi
callq 0x258e0
movb %al, -0x91(%rbp)
jmp 0x2d007
leaq -0x50(%rbp), %rdi
callq 0x6280
movb -0x91(%rbp), %al
testb $0x1, %al
jne 0x2d01c
jmp 0x2d048
movq -0x30(%rbp), %rdi
callq 0x131c0
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x6280
jmp 0x2d0f3
jmp 0x2d04a
leaq -0x20(%rbp), %rdi
callq 0x13190
jmp 0x2cfa2
movb $0x1, -0x81(%rbp)
movl $0x38, %edi
callq 0x6200
movq -0x90(%rbp), %rsi
movq %rax, -0xb0(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x61d0
jmp 0x2d082
movq -0xb0(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x2d430
jmp 0x2d094
movq -0xb0(%rbp), %rdi
movb $0x0, -0x81(%rbp)
leaq 0x307cf(%rip), %rsi     # 0x5d878
leaq 0x3f0(%rip), %rdx       # 0x2d4a0
callq 0x6700
jmp 0x2d0fc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x2d0da
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x6280
testb $0x1, -0x81(%rbp)
jne 0x2d0e5
jmp 0x2d0f1
movq -0xb0(%rbp), %rdi
callq 0x6310
jmp 0x2d0f3
movq -0x58(%rbp), %rdi
callq 0x6750
nopl (%rax)
// File: meirdev[P]HexViewer/./CLI11.hpp
// Function: CLI::App::get_option(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Option *get_option(std::string option_name) {
        for(Option_p &opt : options_) {
            if(opt->check_name(option_name)) {
                return opt.get();
            }
        }
        throw OptionNotFound(option_name);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rsi, -0x90(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq $0x98, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x17b20
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x17b50
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x17b80
testb $0x1, %al
jne 0x2d198
jmp 0x2d238
leaq -0x20(%rbp), %rdi
callq 0x17bc0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x17be0
movq -0x90(%rbp), %rsi
movq %rax, -0xa8(%rbp)
leaq -0x50(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x61d0
movq -0xa8(%rbp), %rdi
movq -0xa0(%rbp), %rsi
callq 0x2d640
movb %al, -0x91(%rbp)
jmp 0x2d1e7
leaq -0x50(%rbp), %rdi
callq 0x6280
movb -0x91(%rbp), %al
testb $0x1, %al
jne 0x2d1fc
jmp 0x2d228
movq -0x30(%rbp), %rdi
callq 0x10a90
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x6280
jmp 0x2d2d3
jmp 0x2d22a
leaq -0x20(%rbp), %rdi
callq 0x17d60
jmp 0x2d182
movb $0x1, -0x81(%rbp)
movl $0x38, %edi
callq 0x6200
movq -0x90(%rbp), %rsi
movq %rax, -0xb0(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x61d0
jmp 0x2d262
movq -0xb0(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x2d430
jmp 0x2d274
movq -0xb0(%rbp), %rdi
movb $0x0, -0x81(%rbp)
leaq 0x305ef(%rip), %rsi     # 0x5d878
leaq 0x210(%rip), %rdx       # 0x2d4a0
callq 0x6700
jmp 0x2d2dc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x2d2ba
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x6280
testb $0x1, -0x81(%rbp)
jne 0x2d2c5
jmp 0x2d2d1
movq -0xb0(%rbp), %rdi
callq 0x6310
jmp 0x2d2d3
movq -0x58(%rbp), %rdi
callq 0x6750
nopl (%rax)
// File: meirdev[P]HexViewer/./CLI11.hpp
// Function: CLI::RequiredError::Subcommand(unsigned long)
static RequiredError Subcommand(size_t min_subcom) {
        if(min_subcom == 1)
            return RequiredError("A subcommand");
        else
            return RequiredError("Requires at least " + std::to_string(min_subcom) + " subcommands",
                                 ExitCodes::RequiredError);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0xb8(%rbp)
movq %rdi, %rax
movq %rax, -0xb0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x1, -0x10(%rbp)
jne 0x2ea02
leaq -0x31(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x6770
movq -0xc0(%rbp), %rdx
leaq 0x12f40(%rip), %rsi     # 0x418dd
leaq -0x30(%rbp), %rdi
callq 0x8eb0
jmp 0x2e9a8
movq -0xb8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x2e6e0
jmp 0x2e9ba
leaq -0x30(%rbp), %rdi
callq 0x6280
leaq -0x31(%rbp), %rdi
callq 0x6460
jmp 0x2ead3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x2e9f4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x6280
leaq -0x31(%rbp), %rdi
callq 0x6460
jmp 0x2eae3
movq -0x10(%rbp), %rsi
leaq -0xa8(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0x8b80
movq -0xc8(%rbp), %rdx
leaq 0x12ec3(%rip), %rsi     # 0x418ea
leaq -0x88(%rbp), %rdi
callq 0x15ea0
jmp 0x2ea35
leaq 0x12ec1(%rip), %rdx     # 0x418fd
leaq -0x68(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x9500
jmp 0x2ea4e
movq -0xb8(%rbp), %rdi
leaq -0x68(%rbp), %rsi
movl $0x6a, %edx
callq 0x2f2c0
jmp 0x2ea65
leaq -0x68(%rbp), %rdi
callq 0x6280
leaq -0x88(%rbp), %rdi
callq 0x6280
leaq -0xa8(%rbp), %rdi
callq 0x6280
jmp 0x2ead3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x2eac5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x2eab9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x6280
leaq -0x88(%rbp), %rdi
callq 0x6280
leaq -0xa8(%rbp), %rdi
callq 0x6280
jmp 0x2eae3
movq -0xb0(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x6750
nopl (%rax)
// File: meirdev[P]HexViewer/./CLI11.hpp
// Function: CLI::App::remaining_size(bool) const
size_t remaining_size(bool recurse = false) const {
        auto remaining_options = static_cast<size_t>(std::count_if(
            std::begin(missing_), std::end(missing_), [](const std::pair<detail::Classifier, std::string> &val) {
                return val.first != detail::Classifier::POSITIONAL_MARK;
            }));
        if(recurse) {
            for(const App_p &sub : subcommands_) {
                remaining_options += sub->remaining_size(recurse);
            }
        }
        return remaining_options;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x58(%rbp)
addq $0x110, %rdi            # imm = 0x110
callq 0x2f650
movq -0x58(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x110, %rdi            # imm = 0x110
callq 0x2f680
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x2f610
movq %rax, -0x18(%rbp)
testb $0x1, -0x9(%rbp)
je 0x2f47d
movq -0x58(%rbp), %rax
addq $0x158, %rax            # imm = 0x158
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x13280
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
callq 0x132d0
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x13110
testb $0x1, %al
jne 0x2f442
jmp 0x2f47b
leaq -0x40(%rbp), %rdi
callq 0x13170
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
callq 0x23160
movq %rax, %rdi
movb -0x9(%rbp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x2f3b0
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x13190
jmp 0x2f42f
jmp 0x2f47d
movq -0x18(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: meirdev[P]HexViewer/./CLI11.hpp
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> CLI::detail::rjoin<std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::string rjoin(const T &v, std::string delim = ",") {
    std::ostringstream s;
    for(size_t start = 0; start < v.size(); start++) {
        if(start > 0)
            s << delim;
        s << v[v.size() - start - 1];
    }
    return s.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1d0, %rsp            # imm = 0x1D0
movq %rdx, -0x1c0(%rbp)
movq %rdi, -0x1b8(%rbp)
movq %rdi, %rax
movq %rax, -0x1b0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x190(%rbp), %rdi
callq 0x65c0
movq $0x0, -0x198(%rbp)
movq -0x198(%rbp), %rax
movq %rax, -0x1c8(%rbp)
movq -0x10(%rbp), %rdi
callq 0x116d0
movq %rax, %rcx
movq -0x1c8(%rbp), %rax
cmpq %rcx, %rax
jae 0x2f9c7
cmpq $0x0, -0x198(%rbp)
jbe 0x2f974
movq -0x1c0(%rbp), %rsi
leaq -0x190(%rbp), %rdi
callq 0x6390
jmp 0x2f94f
jmp 0x2f974
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
leaq -0x190(%rbp), %rdi
callq 0x60e0
jmp 0x2f9f8
movq -0x10(%rbp), %rdi
movq %rdi, -0x1d0(%rbp)
callq 0x116d0
movq -0x1d0(%rbp), %rdi
movq -0x198(%rbp), %rsi
notq %rsi
addq %rax, %rsi
callq 0x87f0
movq %rax, %rsi
leaq -0x190(%rbp), %rdi
callq 0x6390
jmp 0x2f9ae
jmp 0x2f9b0
movq -0x198(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x198(%rbp)
jmp 0x2f906
movq -0x1b8(%rbp), %rdi
leaq -0x190(%rbp), %rsi
callq 0x6410
jmp 0x2f9dc
leaq -0x190(%rbp), %rdi
callq 0x60e0
movq -0x1b0(%rbp), %rax
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbp
retq
movq -0x1a0(%rbp), %rdi
callq 0x6750
nopw %cs:(%rax,%rax)
nop
// File: meirdev[P]HexViewer/./CLI11.hpp
// Function: CLI::App::get_groups[abi:cxx11]() const
std::vector<std::string> get_groups() const {
        std::vector<std::string> groups;

        for(const Option_p &opt : options_) {
            // Add group if it is not already in there
            if(std::find(groups.begin(), groups.end(), opt->get_group()) == groups.end()) {
                groups.push_back(opt->get_group());
            }
        }

        return groups;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x15e10
movq -0x70(%rbp), %rax
addq $0x98, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x10b50
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x10ba0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x109e0
testb $0x1, %al
jne 0x307dd
jmp 0x308bb
leaq -0x28(%rbp), %rdi
callq 0x10a40
movq -0x80(%rbp), %rdi
movq %rax, -0x38(%rbp)
callq 0x11de0
movq -0x80(%rbp), %rdi
movq %rax, -0x48(%rbp)
callq 0x11e10
movq %rax, -0x50(%rbp)
movq -0x38(%rbp), %rdi
callq 0x17be0
movq %rax, %rdi
callq 0x30b80
movq %rax, -0x88(%rbp)
jmp 0x3081e
movq -0x88(%rbp), %rdx
movq -0x48(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x30b30
movq %rax, -0x90(%rbp)
jmp 0x3083b
movq -0x80(%rbp), %rdi
movq -0x90(%rbp), %rax
movq %rax, -0x40(%rbp)
callq 0x11e10
movq %rax, -0x68(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x30af0
testb $0x1, %al
jne 0x30866
jmp 0x308ab
movq -0x38(%rbp), %rdi
callq 0x17be0
movq %rax, %rdi
callq 0x30b80
movq %rax, -0x98(%rbp)
jmp 0x30880
movq -0x98(%rbp), %rsi
movq -0x80(%rbp), %rdi
callq 0x173f0
jmp 0x30892
jmp 0x308ab
movq -0x80(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
callq 0x8710
jmp 0x308db
jmp 0x308ad
leaq -0x28(%rbp), %rdi
callq 0x10a60
jmp 0x307c7
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x308ce
movq -0x80(%rbp), %rdi
callq 0x8710
movq -0x78(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x6750
nopw %cs:(%rax,%rax)
nop