LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/meirdev[P]HexViewer/./CLI11.hpp
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> CLI::detail::join<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 join(const T &v, std::string delim = ",") {
    std::ostringstream s;
    size_t start = 0;
    for(const auto &i : v) {
        if(start++ > 0)
            s << delim;
        s << i;
    }
    return s.str();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x178, %rsp            # imm = 0x178
movq %rdx, %r14
movq %rsi, %r13
movq %rdi, %rbx
movq %rsp, %r15
movq %r15, %rdi
callq 0x53d0
movq (%r13), %r12
movq 0x8(%r13), %r13
xorl %ebp, %ebp
cmpq %r13, %r12
je 0xaf35
subq $0x1, %rbp
jb 0xaf24
movq %r15, %rdi
movq %r14, %rsi
callq 0x52a0
movq %r15, %rdi
movq %r12, %rsi
callq 0x52a0
addq $0x20, %r12
jmp 0xaf0e
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x5490
movq %rsp, %rdi
callq 0x50b0
movq %rbx, %rax
addq $0x178, %rsp            # imm = 0x178
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xaf61
movq %rax, %rbx
movq %rsp, %rdi
callq 0x50b0
movq %rbx, %rdi
callq 0x5510
// File: /workspace/github_cpp_makefile_star2_O2/meirdev[P]HexViewer/./CLI11.hpp
// Function: CLI::App::remove_option(CLI::Option*)
bool remove_option(Option *opt) {
        // Make sure no links exist
        for(Option_p &op : options_) {
            op->remove_needs(opt);
            op->remove_excludes(opt);
        }

        if(help_ptr_ == opt)
            help_ptr_ = nullptr;
        if(help_all_ptr_ == opt)
            help_all_ptr_ = nullptr;

        auto iterator =
            std::find_if(std::begin(options_), std::end(options_), [opt](const Option_p &v) { return v.get() == opt; });
        if(iterator != std::end(options_)) {
            options_.erase(iterator);
            return true;
        }
        return false;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x98(%rdi), %rbx
movq 0x98(%rdi), %r12
movq 0xa0(%rdi), %r13
cmpq %r13, %r12
je 0xb3f9
movq (%r12), %rdi
movq %r15, %rsi
callq 0xb5c8
movq (%r12), %rdi
movq %r15, %rsi
callq 0xb61c
addq $0x8, %r12
jmp 0xb3d6
cmpq %r15, 0xd0(%r14)
jne 0xb40a
andq $0x0, 0xd0(%r14)
cmpq %r15, 0xd8(%r14)
jne 0xb41b
andq $0x0, 0xd8(%r14)
movq 0x98(%r14), %rdi
movq 0xa0(%r14), %rsi
movq %r15, %rdx
callq 0xb6f0
movq %rax, %r15
movq 0xa0(%r14), %r14
cmpq %r14, %rax
je 0xb44b
movq %rbx, %rdi
movq %r15, %rsi
callq 0xb670
cmpq %r14, %r15
setne %al
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/meirdev[P]HexViewer/./CLI11.hpp
// Function: CLI::App::add_flag(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Option *add_flag(std::string flag_name, std::string description = "") {
        CLI::callback_t fun = [](CLI::results_t) { return true; };

        Option *opt = add_option(flag_name, fun, description, false);
        if(opt->get_positional())
            throw IncorrectConstruction::PositionalFlag(flag_name);
        opt->type_size(0);
        return opt;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xa8, %rsp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
leaq 0x86e(%rip), %rax       # 0xbcee
movq %rax, 0x18(%rsp)
leaq 0x868(%rip), %rax       # 0xbcf4
movq %rax, 0x10(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x53f0
leaq 0x48(%rsp), %rdi
movq %rsp, %rsi
callq 0xbc54
leaq 0x28(%rsp), %rdi
movq %r15, %rsi
callq 0x53f0
leaq 0x68(%rsp), %rsi
leaq 0x48(%rsp), %rdx
leaq 0x28(%rsp), %rcx
movq %r14, %rdi
xorl %r8d, %r8d
callq 0xb9bc
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x5180
leaq 0x48(%rsp), %rdi
callq 0xad42
leaq 0x68(%rsp), %rdi
callq 0x5180
cmpq $0x0, 0x60(%r14)
jne 0xb51d
andl $0x0, 0xfc(%r14)
movb $0x0, 0x20(%r14)
movq %rsp, %rdi
callq 0xad42
movq %r14, %rax
addq $0xa8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x38
popq %rdi
callq 0x51a0
movq %rax, %r14
leaq 0x88(%rsp), %rdi
movq %rbx, %rsi
callq 0x53f0
movb $0x1, %bpl
leaq 0x88(%rsp), %rsi
movq %r14, %rdi
callq 0xbc9a
xorl %ebp, %ebp
leaq 0x1c07c(%rip), %rsi     # 0x275d0
leaq 0x8cab(%rip), %rdx      # 0x14206
movq %r14, %rdi
callq 0x54e0
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0x5180
testb %bpl, %bpl
jne 0xb57d
jmp 0xb5b7
movq %rax, %rbx
movq %r14, %rdi
callq 0x5240
jmp 0xb5b7
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x5180
jmp 0xb599
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0xad42
jmp 0xb5a8
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x5180
jmp 0xb5b7
movq %rax, %rbx
movq %rsp, %rdi
callq 0xad42
movq %rbx, %rdi
callq 0x5510
nop
// File: /workspace/github_cpp_makefile_star2_O2/meirdev[P]HexViewer/./CLI11.hpp
// Function: CLI::Option::remove_needs(CLI::Option*)
bool remove_needs(Option *opt) {
        auto iterator = std::find(std::begin(needs_), std::end(needs_), opt);

        if(iterator != std::end(needs_)) {
            needs_.erase(iterator);
            return true;
        } else {
            return false;
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
leaq 0x8(%rsp), %rdx
movq %rsi, (%rdx)
movq 0x138(%rdi), %rdi
leaq 0x128(%r14), %rbx
movq %rbx, %rsi
callq 0xb675
movq %rax, %r15
cmpq %rbx, %rax
je 0xb60c
addq $0x120, %r14            # imm = 0x120
movq %r14, %rdi
movq %r15, %rsi
callq 0xb6a2
cmpq %rbx, %r15
setne %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/meirdev[P]HexViewer/./CLI11.hpp
// Function: CLI::Option::remove_excludes(CLI::Option*)
bool remove_excludes(Option *opt) {
        auto iterator = std::find(std::begin(excludes_), std::end(excludes_), opt);

        if(iterator != std::end(excludes_)) {
            excludes_.erase(iterator);
            return true;
        } else {
            return false;
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
leaq 0x8(%rsp), %rdx
movq %rsi, (%rdx)
movq 0x168(%rdi), %rdi
leaq 0x158(%r14), %rbx
movq %rbx, %rsi
callq 0xb675
movq %rax, %r15
cmpq %rbx, %rax
je 0xb660
addq $0x150, %r14            # imm = 0x150
movq %r14, %rdi
movq %r15, %rsi
callq 0xb6a2
cmpq %rbx, %r15
setne %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/meirdev[P]HexViewer/./CLI11.hpp
// Function: void CLI::OptionBase<CLI::OptionDefaults>::copy_to<CLI::Option>(CLI::Option*) const
void copy_to(T *other) const {
        other->group(group_);
        other->required(required_);
        other->ignore_case(ignore_case_);
        other->ignore_underscore(ignore_underscore_);
        other->configurable(configurable_);
        other->multi_option_policy(multi_option_policy_);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x53f0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x51c0
movq %rsp, %rdi
callq 0x5180
movb 0x20(%r14), %al
movb %al, 0x20(%rbx)
movzbl 0x21(%r14), %esi
movq %rbx, %rdi
callq 0xe2dc
movzbl 0x22(%r14), %esi
movq %rbx, %rdi
callq 0xe39c
movb 0x23(%r14), %al
movb %al, 0x23(%rbx)
movl 0x24(%r14), %esi
movq %rbx, %rdi
callq 0xe45c
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x5180
movq %rbx, %rdi
callq 0x5510
nop
// File: /workspace/github_cpp_makefile_star2_O2/meirdev[P]HexViewer/./CLI11.hpp
// Function: CLI::detail::split_names(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
inline std::vector<std::string> split_names(std::string current) {
    std::vector<std::string> output;
    size_t val;
    while((val = current.find(",")) != std::string::npos) {
        output.push_back(trim_copy(current.substr(0, val)));
        current = current.substr(val + 1);
    }
    output.push_back(trim_copy(current));
    return output;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
leaq 0x28(%rsp), %r12
leaq 0x8(%rsp), %r13
pushq $-0x1
popq %rbp
movq %r14, %rdi
leaq 0xcce4(%rip), %rsi      # 0x19270
xorl %edx, %edx
callq 0x5590
cmpq $-0x1, %rax
je 0xc5fb
movq %rax, %r15
movq %r12, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x52f0
movq %r13, %rdi
movq %r12, %rsi
callq 0xce62
movq %rbx, %rdi
movq %r13, %rsi
callq 0xaf74
movq %r13, %rdi
callq 0x5180
movq %r12, %rdi
callq 0x5180
incq %r15
movq %r13, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %rbp, %rcx
callq 0x52f0
movq %r14, %rdi
movq %r13, %rsi
callq 0x5360
movq %r13, %rdi
callq 0x5180
jmp 0xc582
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0xce62
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xaf74
leaq 0x8(%rsp), %rdi
callq 0x5180
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x8(%rsp), %rdi
jmp 0xc656
jmp 0xc65d
jmp 0xc65d
movq %rax, %r14
jmp 0xc651
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x5180
leaq 0x28(%rsp), %rdi
callq 0x5180
jmp 0xc660
movq %rax, %r14
movq %rbx, %rdi
callq 0x6542
movq %r14, %rdi
callq 0x5510
// File: /workspace/github_cpp_makefile_star2_O2/meirdev[P]HexViewer/./CLI11.hpp
// Function: CLI::Option::operator==(CLI::Option const&) const
bool operator==(const Option &other) const {
        for(const std::string &sname : snames_)
            if(other.check_sname(sname))
                return true;
        for(const std::string &lname : lnames_)
            if(other.check_lname(lname))
                return true;
        // We need to do the inverse, just in case we are ignore_case or ignore underscore
        for(const std::string &sname : other.snames_)
            if(check_sname(sname))
                return true;
        for(const std::string &lname : other.lnames_)
            if(check_lname(lname))
                return true;
        return false;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r15
movq %rdi, %r14
movq 0x28(%rdi), %r12
movq 0x30(%rdi), %r13
leaq 0x68(%rsp), %rbx
cmpq %r13, %r12
je 0xd482
movq %rbx, %rdi
movq %r12, %rsi
callq 0x53f0
movq %r15, %rdi
movq %rbx, %rsi
callq 0xd56c
movl %eax, %ebp
movq %rbx, %rdi
callq 0x5180
addq $0x20, %r12
testb %bpl, %bpl
je 0xd452
jmp 0xd4fa
movq 0x40(%r14), %r12
movq 0x48(%r14), %r13
leaq 0x48(%rsp), %rbx
cmpq %r13, %r12
je 0xd4bf
movq %rbx, %rdi
movq %r12, %rsi
callq 0x53f0
movq %r15, %rdi
movq %rbx, %rsi
callq 0xd60a
movl %eax, %ebp
movq %rbx, %rdi
callq 0x5180
addq $0x20, %r12
testb %bpl, %bpl
je 0xd48f
jmp 0xd4fa
movq 0x28(%r15), %r12
movq 0x30(%r15), %r13
leaq 0x28(%rsp), %rbx
cmpq %r13, %r12
je 0xd511
movq %rbx, %rdi
movq %r12, %rsi
callq 0x53f0
movq %r14, %rdi
movq %rbx, %rsi
callq 0xd56c
movl %eax, %ebp
movq %rbx, %rdi
callq 0x5180
addq $0x20, %r12
testb %bpl, %bpl
je 0xd4cc
movb $0x1, %bpl
movl %ebp, %eax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x40(%r15), %r12
movq 0x48(%r15), %r13
leaq 0x8(%rsp), %rbx
cmpq %r13, %r12
setne %bpl
je 0xd4fd
movq %rbx, %rdi
movq %r12, %rsi
callq 0x53f0
movq %r14, %rdi
movq %rbx, %rsi
callq 0xd60a
movl %eax, %r15d
movq %rbx, %rdi
callq 0x5180
addq $0x20, %r12
testb %r15b, %r15b
je 0xd51e
jmp 0xd4fd
jmp 0xd559
jmp 0xd559
jmp 0xd559
movq %rax, %r14
movq %rbx, %rdi
callq 0x5180
movq %r14, %rdi
callq 0x5510
// File: /workspace/github_cpp_makefile_star2_O2/meirdev[P]HexViewer/./CLI11.hpp
// Function: CLI::Option::check_sname(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) const
bool check_sname(std::string name) const {
        if(ignore_case_) { // there can be no extra underscores in check_sname
            name = detail::to_lower(name);
            return std::find_if(std::begin(snames_), std::end(snames_), [&name](std::string local_sname) {
                       return detail::to_lower(local_sname) == name;
                   }) != std::end(snames_);
        } else
            return std::find(std::begin(snames_), std::end(snames_), name) != std::end(snames_);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x1, 0x21(%rdi)
jne 0xd5d2
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x53f0
leaq 0x20(%rsp), %rdi
movq %r15, %rsi
callq 0xd7ac
leaq 0x20(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5360
movq %r15, %rdi
callq 0x5180
movq %rsp, %rdi
callq 0x5180
leaq 0x30(%r14), %r15
movq 0x28(%r14), %rdi
movq 0x30(%r14), %rsi
movq %rbx, %rdx
callq 0xd87b
jmp 0xd5e6
leaq 0x30(%r14), %r15
movq 0x28(%r14), %rdi
movq 0x30(%r14), %rsi
movq %rbx, %rdx
callq 0xda4e
cmpq (%r15), %rax
setne %al
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x5180
movq %rbx, %rdi
callq 0x5510
nop
// File: /workspace/github_cpp_makefile_star2_O2/meirdev[P]HexViewer/./CLI11.hpp
// Function: CLI::Option::check_lname(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) const
bool check_lname(std::string name) const {
        if(ignore_case_) {
            if(ignore_underscore_) {
                name = detail::to_lower(detail::remove_underscore(name));
                return std::find_if(std::begin(lnames_), std::end(lnames_), [&name](std::string local_sname) {
                           return detail::to_lower(detail::remove_underscore(local_sname)) == name;
                       }) != std::end(lnames_);
            } else {
                name = detail::to_lower(name);
                return std::find_if(std::begin(lnames_), std::end(lnames_), [&name](std::string local_sname) {
                           return detail::to_lower(local_sname) == name;
                       }) != std::end(lnames_);
            }

        } else if(ignore_underscore_) {
            name = detail::remove_underscore(name);
            return std::find_if(std::begin(lnames_), std::end(lnames_), [&name](std::string local_sname) {
                       return detail::remove_underscore(local_sname) == name;
                   }) != std::end(lnames_);
        } else
            return std::find(std::begin(lnames_), std::end(lnames_), name) != std::end(lnames_);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xa0, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movb 0x22(%rdi), %al
cmpb $0x1, 0x21(%rdi)
jne 0xd6a0
testb %al, %al
je 0xd6f9
leaq 0x80(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x53f0
leaq 0x20(%rsp), %rdi
movq %r15, %rsi
callq 0xdb38
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
callq 0xd7ac
movq %rsp, %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5360
movq %r15, %rdi
callq 0x5180
leaq 0x20(%rsp), %rdi
callq 0x5180
leaq 0x80(%rsp), %rdi
callq 0x5180
leaq 0x48(%r14), %r15
movq 0x40(%r14), %rdi
movq 0x48(%r14), %rsi
movq %rbx, %rdx
callq 0xdc48
jmp 0xd75e
testb %al, %al
je 0xd74a
leaq 0x40(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x53f0
movq %rsp, %rdi
movq %r15, %rsi
callq 0xdb38
movq %rsp, %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5360
movq %r15, %rdi
callq 0x5180
leaq 0x40(%rsp), %rdi
callq 0x5180
leaq 0x48(%r14), %r15
movq 0x40(%r14), %rdi
movq 0x48(%r14), %rsi
movq %rbx, %rdx
callq 0xdfab
jmp 0xd75e
leaq 0x60(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x53f0
movq %rsp, %rdi
movq %r15, %rsi
callq 0xd7ac
movq %rsp, %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5360
movq %r15, %rdi
callq 0x5180
leaq 0x60(%rsp), %rdi
callq 0x5180
leaq 0x48(%r14), %r15
movq 0x40(%r14), %rdi
movq 0x48(%r14), %rsi
movq %rbx, %rdx
callq 0xde0d
jmp 0xd75e
leaq 0x48(%r14), %r15
movq 0x40(%r14), %rdi
movq 0x48(%r14), %rsi
movq %rbx, %rdx
callq 0xda4e
cmpq (%r15), %rax
setne %al
addq $0xa0, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x5180
jmp 0xd797
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
jmp 0xd79f
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
jmp 0xd79f
movq %rax, %rbx
leaq 0x80(%rsp), %rdi
callq 0x5180
movq %rbx, %rdi
callq 0x5510
// File: /workspace/github_cpp_makefile_star2_O2/meirdev[P]HexViewer/./CLI11.hpp
// Function: CLI::detail::to_lower(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
inline std::string to_lower(std::string str) {
    std::transform(std::begin(str), std::end(str), std::begin(str), [](const std::string::value_type &x) {
        return std::tolower(x, std::locale());
    });
    return str;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rdi
movq 0x8(%rsi), %rsi
addq %rdi, %rsi
movq %rdi, %rdx
callq 0xd7de
movq %r14, %rdi
movq %rbx, %rsi
callq 0x53b0
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/meirdev[P]HexViewer/./CLI11.hpp
// Function: CLI::Option* CLI::Option::ignore_case<CLI::App>(bool)
Option *ignore_case(bool value = true) {
        ignore_case_ = value;
        auto *parent = dynamic_cast<T *>(parent_);

        for(const Option_p &opt : parent->options_)
            if(opt.get() != this && *opt == *this)
                throw OptionAlreadyAdded(opt->get_name(true, true));

        return this;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movb %sil, 0x21(%rdi)
movq 0x180(%rdi), %rax
movq 0x98(%rax), %r14
movq 0xa0(%rax), %r15
cmpq %r15, %r14
je 0xe321
movq (%r14), %rdi
cmpq %rbx, %rdi
je 0xe31b
movq %rbx, %rsi
callq 0xd42e
testb %al, %al
jne 0xe32f
addq $0x8, %r14
jmp 0xe302
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x38
popq %rdi
callq 0x51a0
movq %rax, %rbx
movq (%r14), %rsi
leaq 0x8(%rsp), %rdi
pushq $0x1
popq %rcx
movl %ecx, %edx
callq 0xa9b8
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xc0e8
xorl %ebp, %ebp
leaq 0x19293(%rip), %rsi     # 0x275f8
leaq 0x5e9a(%rip), %rdx      # 0x14206
movq %rbx, %rdi
callq 0x54e0
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x5180
testb %bpl, %bpl
jne 0xe38b
jmp 0xe393
movq %rax, %r14
movq %rbx, %rdi
callq 0x5240
movq %r14, %rdi
callq 0x5510
nop
// File: /workspace/github_cpp_makefile_star2_O2/meirdev[P]HexViewer/./CLI11.hpp
// Function: CLI::Option* CLI::Option::ignore_underscore<CLI::App>(bool)
Option *ignore_underscore(bool value = true) {
        ignore_underscore_ = value;
        auto *parent = dynamic_cast<T *>(parent_);
        for(const Option_p &opt : parent->options_)
            if(opt.get() != this && *opt == *this)
                throw OptionAlreadyAdded(opt->get_name(true, true));

        return this;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movb %sil, 0x22(%rdi)
movq 0x180(%rdi), %rax
movq 0x98(%rax), %r14
movq 0xa0(%rax), %r15
cmpq %r15, %r14
je 0xe3e1
movq (%r14), %rdi
cmpq %rbx, %rdi
je 0xe3db
movq %rbx, %rsi
callq 0xd42e
testb %al, %al
jne 0xe3ef
addq $0x8, %r14
jmp 0xe3c2
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x38
popq %rdi
callq 0x51a0
movq %rax, %rbx
movq (%r14), %rsi
leaq 0x8(%rsp), %rdi
pushq $0x1
popq %rcx
movl %ecx, %edx
callq 0xa9b8
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xc0e8
xorl %ebp, %ebp
leaq 0x191d3(%rip), %rsi     # 0x275f8
leaq 0x5dda(%rip), %rdx      # 0x14206
movq %rbx, %rdi
callq 0x54e0
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x5180
testb %bpl, %bpl
jne 0xe44b
jmp 0xe453
movq %rax, %r14
movq %rbx, %rdi
callq 0x5240
movq %r14, %rdi
callq 0x5510
nop
// File: /workspace/github_cpp_makefile_star2_O2/meirdev[P]HexViewer/./CLI11.hpp
// Function: CLI::Option::multi_option_policy(CLI::MultiOptionPolicy)
Option *multi_option_policy(MultiOptionPolicy value = MultiOptionPolicy::Throw) {

        if(get_items_expected() < 0)
            throw IncorrectConstruction::MultiOptionPolicy(get_name());
        multi_option_policy_ = value;
        return this;
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %esi, %ebx
movq %rdi, %r14
callq 0x6880
testl %eax, %eax
js 0xe482
movl %ebx, 0x24(%r14)
movq %r14, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x38
popq %rdi
callq 0x51a0
movq %rax, %rbx
movq %rsp, %rdi
movq %r14, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xa9b8
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
callq 0xe4e8
xorl %ebp, %ebp
leaq 0x1911d(%rip), %rsi     # 0x275d0
leaq 0x5d4c(%rip), %rdx      # 0x14206
movq %rbx, %rdi
callq 0x54e0
movq %rax, %r14
movq %rsp, %rdi
callq 0x5180
testb %bpl, %bpl
jne 0xe4d7
jmp 0xe4df
movq %rax, %r14
movq %rbx, %rdi
callq 0x5240
movq %r14, %rdi
callq 0x5510
nop
// File: /workspace/github_cpp_makefile_star2_O2/meirdev[P]HexViewer/./CLI11.hpp
// Function: CLI::App::parse(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 parse(std::vector<std::string> &args) {
        // Clear if parsed
        if(parsed_ > 0)
            clear();

        // _parse is incremented in commands/subcommands,
        // but placed here to make sure this is cleared when
        // running parse after an error is thrown, even by _validate.
        parsed_ = 1;
        _validate();
        parsed_ = 0;

        _parse(args);
        run_callback();
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, 0x180(%rdi)
je 0xea80
movq %rbx, %rdi
callq 0xebd4
movq $0x1, 0x180(%rbx)
movq %rbx, %rdi
callq 0xec62
andq $0x0, 0x180(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xed16
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xed9a
nop
// File: /workspace/github_cpp_makefile_star2_O2/meirdev[P]HexViewer/./CLI11.hpp
// Function: CLI::App::clear()
void clear() {

        parsed_ = false;
        missing_.clear();
        parsed_subcommands_.clear();

        for(const Option_p &opt : options_) {
            opt->clear();
        }
        for(const App_p &app : subcommands_) {
            app->clear();
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
andq $0x0, 0x180(%rdi)
addq $0x110, %rdi            # imm = 0x110
callq 0xee0c
movq 0x140(%rbx), %rax
cmpq %rax, 0x148(%rbx)
je 0xec0a
movq %rax, 0x148(%rbx)
movq 0x98(%rbx), %r14
movq 0xa0(%rbx), %r15
movl $0x1a8, %r12d           # imm = 0x1A8
cmpq %r15, %r14
je 0xec34
movq (%r14), %rdi
addq %r12, %rdi
callq 0xee44
addq $0x8, %r14
jmp 0xec1e
movq 0x158(%rbx), %r14
movq 0x160(%rbx), %rbx
cmpq %rbx, %r14
je 0xec55
movq (%r14), %rdi
callq 0xebd4
addq $0x8, %r14
jmp 0xec42
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/meirdev[P]HexViewer/./CLI11.hpp
// Function: CLI::App::_validate() const
void _validate() const {
        auto pcount = std::count_if(std::begin(options_), std::end(options_), [](const Option_p &opt) {
            return opt->get_items_expected() < 0 && opt->get_positional();
        });
        if(pcount > 1)
            throw InvalidError(name_);
        for(const App_p &app : subcommands_)
            app->_validate();
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %r14
movq 0x98(%rdi), %rdi
movq 0xa0(%r14), %rsi
callq 0xeecf
cmpq $0x2, %rax
jge 0xecb0
movq 0x158(%r14), %rbx
movq 0x160(%r14), %r14
cmpq %r14, %rbx
je 0xeca7
movq (%rbx), %rdi
callq 0xec62
addq $0x8, %rbx
jmp 0xec94
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x38
popq %rdi
callq 0x51a0
movq %rax, %rbx
addq $0x8, %r14
movq %rsp, %rdi
movq %r14, %rsi
callq 0x53f0
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
callq 0xee7c
xorl %ebp, %ebp
leaq 0x18a2f(%rip), %rsi     # 0x27710
leaq 0x551e(%rip), %rdx      # 0x14206
movq %rbx, %rdi
callq 0x54e0
movq %rax, %r14
movq %rsp, %rdi
callq 0x5180
testb %bpl, %bpl
jne 0xed05
jmp 0xed0d
movq %rax, %r14
movq %rbx, %rdi
callq 0x5240
movq %r14, %rdi
callq 0x5510
nop
// File: /workspace/github_cpp_makefile_star2_O2/meirdev[P]HexViewer/./CLI11.hpp
// Function: CLI::App::_parse(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 _parse(std::vector<std::string> &args) {
        parsed_++;
        bool positional_only = false;

        while(!args.empty()) {
            _parse_single(args, positional_only);
        }

        if(parent_ == nullptr) {
            _process();

            // Throw error if any items are left over (depending on settings)
            _process_extras(args);

            // Convert missing (pairs) to extras (string only)
            args = remaining(false);
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %r14
incq 0x180(%rdi)
movq %rsi, %rbx
leaq 0x7(%rsp), %r15
movb $0x0, (%r15)
movq (%rbx), %rax
cmpq 0x8(%rbx), %rax
je 0xed4e
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0xf07c
jmp 0xed35
cmpq $0x0, 0x178(%r14)
jne 0xed90
movq %r14, %rdi
callq 0xf12e
movq %r14, %rdi
movq %rbx, %rsi
callq 0xf15c
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0xf24e
movq %rbx, %rdi
movq %r15, %rsi
callq 0xd2d8
movq %r15, %rdi
callq 0x6542
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/meirdev[P]HexViewer/./CLI11.hpp
// Function: CLI::App::run_callback()
void run_callback() {
        pre_callback();
        if(callback_)
            callback_();
        for(App *subc : get_subcommands()) {
            subc->run_callback();
        }
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x10(%rax)
cmpq $0x0, 0x60(%rbx)
je 0xedba
leaq 0x50(%rbx), %rdi
callq 0x143d6
addq $0x140, %rbx            # imm = 0x140
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x13fc2
movq (%r14), %rbx
movq 0x8(%r14), %r14
cmpq %r14, %rbx
je 0xede9
movq (%rbx), %rdi
callq 0xed9a
addq $0x8, %rbx
jmp 0xedd6
movq %rsp, %rdi
callq 0xe91c
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0xe91c
movq %rbx, %rdi
callq 0x5510
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r15
cmpb $0x0, (%rdx)
je 0xf0a4
movq %r15, %rdi
movq %rbx, %rsi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0xfde2
movq %rdx, %r14
movq 0x8(%rbx), %rsi
addq $-0x20, %rsi
movq %r15, %rdi
callq 0xf316
movl %eax, 0xc(%rsp)
cmpl $0x5, %eax
ja 0xf110
movl %eax, %ecx
leaq 0x9f57(%rip), %rdx      # 0x19020
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movq %r15, %rdi
movq %rbx, %rsi
movl %eax, %edx
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0xf616
addq $0x110, %r15            # imm = 0x110
movq 0x8(%rbx), %rdx
addq $-0x20, %rdx
leaq 0xc(%rsp), %rsi
movq %r15, %rdi
callq 0xf408
movq %rbx, %rdi
callq 0xf44a
movb $0x1, (%r14)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %r15, %rdi
movq %rbx, %rsi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0xf45e
// File: /workspace/github_cpp_makefile_star2_O2/meirdev[P]HexViewer/./CLI11.hpp
// Function: CLI::App::_process()
void _process() {
        _process_ini();
        _process_env();
        _process_callbacks();
        _process_help_flags();
        _process_requirements();
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x1147a
movq %rbx, %rdi
callq 0x11544
movq %rbx, %rdi
callq 0x1167c
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x116e6
movq %rbx, %rdi
popq %rbx
jmp 0x117d0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x0, 0x48(%rdi)
jne 0xf188
cmpb $0x0, 0x4a(%r14)
jne 0xf188
movq %r14, %rdi
xorl %esi, %esi
callq 0x140ce
testq %rax, %rax
jne 0xf1c1
movq 0x158(%r14), %r15
movq 0x160(%r14), %r14
cmpq %r14, %r15
je 0xf1b6
movq (%r15), %rdi
cmpq $0x0, 0x180(%rdi)
je 0xf1b0
movq %rbx, %rsi
callq 0xf15c
addq $0x8, %r15
jmp 0xf196
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x20(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0xf24e
movq %rbx, %rdi
movq %r15, %rsi
callq 0xd2d8
movq %r15, %rdi
callq 0x6542
pushq $0x38
popq %rdi
callq 0x51a0
movq %rax, %r14
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x9abe
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x1412c
xorl %ebp, %ebp
leaq 0x18861(%rip), %rsi     # 0x27a78
leaq 0x4fe8(%rip), %rdx      # 0x14206
movq %r14, %rdi
callq 0x54e0
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x6542
testb %bpl, %bpl
jne 0xf23d
jmp 0xf245
movq %rax, %rbx
movq %r14, %rdi
callq 0x5240
movq %rbx, %rdi
callq 0x5510
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq 0x110(%rsi), %r15
movq 0x118(%rsi), %r12
cmpq %r12, %r15
je 0xf295
addq $0x8, %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0xb27e
addq $0x20, %r15
jmp 0xf27b
testb %bpl, %bpl
je 0xf2e2
movq 0x140(%r14), %r15
movq 0x148(%r14), %r12
leaq 0x8(%rsp), %r14
pushq $0x1
popq %rbp
cmpq %r12, %r15
je 0xf2e2
movq (%r15), %rsi
movq %r14, %rdi
movl %ebp, %edx
callq 0xf24e
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %rbx, %rdx
callq 0x1439e
movq %r14, %rdi
callq 0x6542
addq $0x8, %r15
jmp 0xf2b0
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0xf303
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x6542
jmp 0xf306
movq %rax, %r14
movq %rbx, %rdi
callq 0x6542
movq %r14, %rdi
callq 0x5510
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x38(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
xorl %ecx, %ecx
movb %cl, (%rax)
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb %cl, (%rax)
leaq 0x9f21(%rip), %rsi      # 0x1926d
movq %rbx, %rdi
callq 0xc7ec
testb %al, %al
je 0xf35c
pushq $0x1
jmp 0xf3a1
movq %r14, %rdi
movq %rbx, %rsi
callq 0xff62
testb %al, %al
je 0xf36f
pushq $0x5
jmp 0xf3a1
leaq 0x28(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x10045
testb %al, %al
je 0xf389
pushq $0x3
jmp 0xf3a1
leaq 0x28(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x1018a
testb %al, %al
je 0xf3c0
pushq $0x2
popq %rbx
leaq 0x8(%rsp), %rdi
callq 0x5180
leaq 0x28(%rsp), %rdi
callq 0x5180
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
cmpb $0x1, 0x173(%r14)
jne 0xf3e4
leaq 0x28(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x10221
testb %al, %al
je 0xf3e4
pushq $0x4
jmp 0xf3a1
xorl %ebx, %ebx
jmp 0xf3a2
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5180
leaq 0x28(%rsp), %rdi
callq 0x5180
movq %rbx, %rdi
callq 0x5510
nop
// File: /workspace/github_cpp_makefile_star2_O2/meirdev[P]HexViewer/./CLI11.hpp
// Function: CLI::App::_parse_subcommand(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 _parse_subcommand(std::vector<std::string> &args) {
        if(_count_remaining_positionals(/* required */ true) > 0)
            return _parse_positional(args);
        for(const App_p &com : subcommands_) {
            if(com->check_name(args.back())) {
                args.pop_back();
                if(std::find(std::begin(parsed_subcommands_), std::end(parsed_subcommands_), com.get()) ==
                   std::end(parsed_subcommands_))
                    parsed_subcommands_.push_back(com.get());
                com->_parse(args);
                return;
            }
        }
        if(parent_ != nullptr)
            return parent_->_parse_subcommand(args);
        else
            throw HorribleError("Subcommand " + args.back() + " missing");
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x1
popq %rsi
callq 0x10702
testq %rax, %rax
je 0xf498
movq %r14, %rdi
movq %rbx, %rsi
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xfde2
movq 0x158(%r14), %r13
movq %r14, (%rsp)
movq 0x160(%r14), %r14
leaq 0x48(%rsp), %r15
cmpq %r14, %r13
je 0xf4e8
movq (%r13), %r12
movq 0x8(%rbx), %rsi
addq $-0x20, %rsi
movq %r15, %rdi
callq 0x53f0
movq %r12, %rdi
movq %r15, %rsi
callq 0x10312
movl %eax, %ebp
movq %r15, %rdi
callq 0x5180
testb %bpl, %bpl
jne 0xf502
addq $0x8, %r13
jmp 0xf4af
movq (%rsp), %rax
movq 0x178(%rax), %rdi
testq %rdi, %rdi
je 0xf56c
movq %rbx, %rsi
callq 0xf45e
jmp 0xf55d
movq %rbx, %rdi
callq 0xf44a
movq (%rsp), %r14
movq 0x140(%r14), %rdi
movq 0x148(%r14), %rsi
movq (%r13), %rax
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
callq 0x1081b
cmpq 0x148(%r14), %rax
jne 0xf551
addq $0x140, %r14            # imm = 0x140
movq (%r13), %rax
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %r14, %rdi
callq 0x108a8
movq (%r13), %rdi
movq %rbx, %rsi
callq 0xed16
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x38
popq %rdi
callq 0x51a0
movq %rax, %r14
movq 0x8(%rbx), %rdx
addq $-0x20, %rdx
leaq 0x9e56(%rip), %rsi      # 0x193dc
leaq 0x8(%rsp), %rdi
callq 0x94d9
leaq 0x9e51(%rip), %rdx      # 0x193e8
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x69e3
movb $0x1, %bpl
leaq 0x28(%rsp), %rsi
movq %r14, %rdi
callq 0x10796
xorl %ebp, %ebp
leaq 0x181b9(%rip), %rsi     # 0x27778
leaq 0x4c40(%rip), %rdx      # 0x14206
movq %r14, %rdi
callq 0x54e0
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x5180
jmp 0xf5e3
movq %rax, %rbx
movb $0x1, %bpl
leaq 0x8(%rsp), %rdi
callq 0x5180
testb %bpl, %bpl
jne 0xf5f7
jmp 0xf60e
movq %rax, %rbx
movq %r14, %rdi
callq 0x5240
jmp 0xf60e
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x5180
movq %rbx, %rdi
callq 0x5510
// File: /workspace/github_cpp_makefile_star2_O2/meirdev[P]HexViewer/./CLI11.hpp
// Function: CLI::App::_parse_positional(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 _parse_positional(std::vector<std::string> &args) {

        std::string positional = args.back();
        for(const Option_p &opt : options_) {
            // Eat options, one by one, until done
            if(opt->get_positional() &&
               (static_cast<int>(opt->count()) < opt->get_items_expected() || opt->get_items_expected() < 0)) {

                opt->add_result(positional);
                parse_order_.push_back(opt.get());
                args.pop_back();
                return;
            }
        }

        if(parent_ != nullptr && fallthrough_)
            return parent_->_parse_positional(args);
        else {
            args.pop_back();
            missing_.emplace_back(detail::Classifier::NONE, positional);

            if(prefix_command_) {
                while(!args.empty()) {
                    missing_.emplace_back(detail::Classifier::NONE, args.back());
                    args.pop_back();
                }
            }
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %rsi
addq $-0x20, %rsi
leaq 0x10(%rsp), %rdi
callq 0x53f0
movq 0x98(%r14), %r12
movq 0xa0(%r14), %r15
cmpq %r15, %r12
je 0xfea7
movq (%r12), %rdi
cmpq $0x0, 0x60(%rdi)
je 0xfe52
movq 0x1b0(%rdi), %r13
subq 0x1a8(%rdi), %r13
shrq $0x5, %r13
callq 0x6880
cmpl %r13d, %eax
jg 0xfe58
movq (%r12), %rdi
callq 0x6880
testl %eax, %eax
js 0xfe58
addq $0x8, %r12
jmp 0xfe15
movq (%r12), %r15
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x53f0
leaq 0x30(%rsp), %rsi
movq %r15, %rdi
callq 0x10b3c
leaq 0x30(%rsp), %rdi
callq 0x5180
addq $0x128, %r14            # imm = 0x128
movq (%r12), %rax
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %r14, %rdi
callq 0x10f64
movq %rbx, %rdi
callq 0xf44a
jmp 0xff1e
movq 0x178(%r14), %rdi
testq %rdi, %rdi
je 0xfec7
cmpb $0x1, 0x172(%r14)
jne 0xfec7
movq %rbx, %rsi
callq 0xfde2
jmp 0xff1e
movq %rbx, %rdi
callq 0xf44a
leaq 0x110(%r14), %r15
leaq 0x8(%rsp), %rsi
andl $0x0, (%rsi)
leaq 0x10(%rsp), %rdx
movq %r15, %rdi
callq 0x1130a
cmpb $0x1, 0x4a(%r14)
jne 0xff1e
leaq 0x8(%rsp), %r14
movq 0x8(%rbx), %rdx
cmpq %rdx, (%rbx)
je 0xff1e
andl $0x0, 0x8(%rsp)
addq $-0x20, %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x1130a
movq %rbx, %rdi
callq 0xf44a
jmp 0xfef7
leaq 0x10(%rsp), %rdi
callq 0x5180
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0xff4d
jmp 0xff4d
jmp 0xff4d
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x5180
jmp 0xff50
jmp 0xff4d
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x5180
movq %rbx, %rdi
callq 0x5510
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x190(%r14), %rax
testq %rax, %rax
je 0xffa7
movq 0x148(%r14), %rcx
subq 0x140(%r14), %rcx
sarq $0x3, %rcx
cmpq %rax, %rcx
jb 0xffa7
movq 0x178(%r14), %r14
testq %r14, %r14
jne 0xff76
jmp 0x1001b
movq 0x158(%r14), %r13
movq 0x160(%r14), %rbp
leaq 0x8(%rsp), %r15
cmpq %rbp, %r13
je 0x10005
movq (%r13), %r12
movq %r15, %rdi
movq %rbx, %rsi
callq 0x53f0
movq %r12, %rdi
movq %r15, %rsi
callq 0x10312
testb %al, %al
je 0xfff7
movq (%r13), %rax
movq 0x180(%rax), %r12
movq %r15, %rdi
callq 0x5180
testq %r12, %r12
jne 0xffff
jmp 0x1001f
movq %r15, %rdi
callq 0x5180
addq $0x8, %r13
jmp 0xffba
movq 0x178(%r14), %rdi
testq %rdi, %rdi
je 0x1001b
movq %rbx, %rsi
callq 0xff62
jmp 0x10021
xorl %eax, %eax
jmp 0x10021
movb $0x1, %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5180
movq %rbx, %rdi
callq 0x5510
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
cmpq $0x3, 0x8(%rdi)
jb 0x10128
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x8(%rsp), %r12
pushq $0x2
popq %rcx
movq %r12, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x52f0
leaq 0x91ea(%rip), %rsi      # 0x1926d
movq %r12, %rdi
callq 0xc7ec
testb %al, %al
je 0x1011e
movq (%r14), %rax
movsbl 0x2(%rax), %edi
callq 0xc712
movl %eax, %ebp
leaq 0x8(%rsp), %rdi
callq 0x5180
testb %bpl, %bpl
je 0x10128
pushq $0x3d
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x53c0
cmpq $-0x1, %rax
je 0x10139
movq %rax, %r12
leaq -0x2(%rax), %rcx
leaq 0x8(%rsp), %r13
pushq $0x2
popq %rdx
movq %r13, %rdi
movq %r14, %rsi
callq 0x52f0
movq %r15, %rdi
movq %r13, %rsi
callq 0x5360
movq %r13, %rdi
callq 0x5180
incq %r12
leaq 0x8(%rsp), %r15
pushq $-0x1
popq %rcx
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x52f0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5360
movq %r15, %rdi
callq 0x5180
jmp 0x10171
leaq 0x8(%rsp), %rdi
callq 0x5180
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x8(%rsp), %r12
pushq $0x2
popq %rdx
pushq $-0x1
popq %rcx
movq %r12, %rdi
movq %r14, %rsi
callq 0x52f0
movq %r15, %rdi
movq %r12, %rsi
callq 0x5360
movq %r12, %rdi
callq 0x5180
leaq 0x963f(%rip), %rsi      # 0x197a8
movq %rbx, %rdi
callq 0x5570
movb $0x1, %al
jmp 0x1012a
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5180
movq %rbx, %rdi
callq 0x5510
// File: /workspace/github_cpp_makefile_star2_O2/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:
cmpq $0x2, 0x8(%rdi)
jb 0x10210
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
movq (%rdi), %rax
cmpb $0x2d, (%rax)
jne 0x10213
movq %rdx, %rbx
movq %rsi, %r15
movsbl 0x1(%rax), %edi
callq 0xc712
testb %al, %al
je 0x10213
leaq 0x8(%rsp), %r12
pushq $0x1
popq %rcx
movq %r12, %rdi
movq %r14, %rsi
movq %rcx, %rdx
callq 0x52f0
movq %r15, %rdi
movq %r12, %rsi
callq 0x5360
movq %r12, %rdi
callq 0x5180
leaq 0x8(%rsp), %r15
pushq $0x2
popq %rdx
pushq $-0x1
popq %rcx
movq %r15, %rdi
movq %r14, %rsi
callq 0x52f0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5360
movq %r15, %rdi
callq 0x5180
movb $0x1, %al
jmp 0x10215
xorl %eax, %eax
retq
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
cmpq $0x2, 0x8(%rdi)
jb 0x102c5
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %r14
movq (%rdi), %rax
cmpb $0x2f, (%rax)
jne 0x102c8
movq %rdx, %rbx
movq %rsi, %r15
movsbl 0x1(%rax), %edi
callq 0xc712
testb %al, %al
je 0x102c8
pushq $0x3a
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x53c0
cmpq $-0x1, %rax
je 0x102cc
movq %rax, %r12
leaq -0x1(%rax), %rcx
movq %rsp, %r13
pushq $0x1
popq %rdx
movq %r13, %rdi
movq %r14, %rsi
callq 0x52f0
movq %r15, %rdi
movq %r13, %rsi
callq 0x5360
movq %r13, %rdi
callq 0x5180
incq %r12
movq %rsp, %r15
pushq $-0x1
popq %rcx
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x52f0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5360
movq %r15, %rdi
callq 0x5180
jmp 0x10302
xorl %eax, %eax
retq
xorl %eax, %eax
jmp 0x10304
movq %rsp, %r12
pushq $0x1
popq %rdx
pushq $-0x1
popq %rcx
movq %r12, %rdi
movq %r14, %rsi
callq 0x52f0
movq %r15, %rdi
movq %r12, %rsi
callq 0x5360
movq %r12, %rdi
callq 0x5180
leaq 0x94ae(%rip), %rsi      # 0x197a8
movq %rbx, %rdi
callq 0x5570
movb $0x1, %al
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq