LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/meirdev[P]HexViewer/./CLI11.hpp
// Function: CLI::App::set_help_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 *set_help_flag(std::string flag_name = "", std::string description = "") {
        if(help_ptr_ != nullptr) {
            remove_option(help_ptr_);
            help_ptr_ = nullptr;
        }

        // Empty name will simply remove the help flag
        if(!flag_name.empty()) {
            help_ptr_ = add_flag(flag_name, description);
            help_ptr_->configurable(false);
        }

        return help_ptr_;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0xd0(%rdi), %rsi
testq %rsi, %rsi
je 0xd245
movq %rbx, %rdi
callq 0xe43e
movq $0x0, 0xd0(%rbx)
movq 0x8(%r15), %rdx
testq %rdx, %rdx
je 0xd2db
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%r15), %rsi
addq %rsi, %rdx
leaq 0x28(%rsp), %rdi
callq 0x1eb20
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x1eb20
leaq 0x28(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0xe4ec
movq %rax, 0xd0(%rbx)
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0xd2b9
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x52c0
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0xd2d0
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x52c0
movq 0xd0(%rbx), %rax
movb $0x0, 0x23(%rax)
movq 0xd0(%rbx), %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0xd30d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x52c0
jmp 0xd30d
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0xd324
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x52c0
movq %rbx, %rdi
callq 0x5510
// File: /workspace/github_cpp_makefile_star2_O1/meirdev[P]HexViewer/./CLI11.hpp
// Function: CLI::App::set_help_all_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 *set_help_all_flag(std::string help_name = "", std::string description = "") {
        if(help_all_ptr_ != nullptr) {
            remove_option(help_all_ptr_);
            help_all_ptr_ = nullptr;
        }

        // Empty name will simply remove the help all flag
        if(!help_name.empty()) {
            help_all_ptr_ = add_flag(help_name, description);
            help_all_ptr_->configurable(false);
        }

        return help_all_ptr_;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0xd8(%rdi), %rsi
testq %rsi, %rsi
je 0xd9f5
movq %rbx, %rdi
callq 0xe43e
movq $0x0, 0xd8(%rbx)
movq 0x8(%r15), %rdx
testq %rdx, %rdx
je 0xda8b
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%r15), %rsi
addq %rsi, %rdx
leaq 0x28(%rsp), %rdi
callq 0x1eb20
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x1eb20
leaq 0x28(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0xe4ec
movq %rax, 0xd8(%rbx)
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0xda69
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x52c0
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0xda80
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x52c0
movq 0xd8(%rbx), %rax
movb $0x0, 0x23(%rax)
movq 0xd8(%rbx), %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0xdabd
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x52c0
jmp 0xdabd
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0xdad4
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x52c0
movq %rbx, %rdi
callq 0x5510
// File: /workspace/github_cpp_makefile_star2_O1/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, %r15
movq %rdi, %rbx
movq %rsp, %rdi
callq 0x53e0
movq (%r15), %r12
movq 0x8(%r15), %r13
cmpq %r13, %r12
je 0xdde8
xorl %ebp, %ebp
movq %rsp, %r15
subq $0x1, %rbp
jb 0xddce
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %r15, %rdi
callq 0x5320
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %r15, %rdi
callq 0x5320
addq $0x20, %r12
cmpq %r13, %r12
jne 0xddb9
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x5480
movq 0x221bc(%rip), %rsi     # 0x2ffb8
movq %rsp, %rdi
callq 0x5190
leaq 0x70(%rsp), %rdi
callq 0x5100
movq %rbx, %rax
addq $0x178, %rsp            # imm = 0x178
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xde25
movq %rax, %rbx
movq 0x22189(%rip), %rsi     # 0x2ffb8
movq %rsp, %rdi
callq 0x5190
leaq 0x70(%rsp), %rdi
callq 0x5100
movq %rbx, %rdi
callq 0x5510
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x98(%rdi), %r15
movq 0xa0(%rdi), %r12
cmpq %r12, %r15
je 0xe47b
movq (%r15), %rdi
movq %r14, %rsi
callq 0xe72c
movq (%r15), %rdi
movq %r14, %rsi
callq 0xe78c
addq $0x8, %r15
jmp 0xe45a
cmpq %r14, 0xd0(%rbx)
jne 0xe48f
movq $0x0, 0xd0(%rbx)
cmpq %r14, 0xd8(%rbx)
jne 0xe4a3
movq $0x0, 0xd8(%rbx)
movq 0x98(%rbx), %rdi
movq 0xa0(%rbx), %rsi
movq %r14, %rdx
callq 0xe828
movq %rax, %r14
movq 0xa0(%rbx), %r15
cmpq %r15, %rax
je 0xe4da
addq $0x98, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xe8bc
cmpq %r15, %r14
setne %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
leaq 0xb0a(%rip), %rax       # 0xf01e
movq %rax, 0x18(%rsp)
leaq 0xb36(%rip), %rax       # 0xf056
movq %rax, 0x10(%rsp)
leaq 0x58(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rsi), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
leaq 0x48(%rsp), %rdi
callq 0x1eb20
leaq 0x68(%rsp), %rdi
movq %rsp, %rsi
callq 0xef2a
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %rdi
callq 0x1eb20
leaq 0x48(%rsp), %rsi
leaq 0x68(%rsp), %rdx
leaq 0x28(%rsp), %rcx
movq %r14, %rdi
xorl %r8d, %r8d
callq 0xeb54
movq %rax, %r14
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0xe5a1
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x52c0
movq 0x78(%rsp), %rax
testq %rax, %rax
je 0xe5ba
leaq 0x68(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x48(%rsp), %rdi
cmpq %r12, %rdi
je 0xe5d1
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x52c0
cmpq $0x0, 0x60(%r14)
jne 0xe614
movl $0x0, 0xfc(%r14)
movb $0x0, 0x20(%r14)
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0xe5ff
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %r14, %rax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x38, %edi
callq 0x5170
movq %rax, %r14
leaq 0x98(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
leaq 0x88(%rsp), %rdi
callq 0x1eb20
movb $0x1, %bpl
leaq 0x88(%rsp), %rsi
movq %r14, %rdi
callq 0xef90
xorl %ebp, %ebp
leaq 0x20f78(%rip), %rsi     # 0x2f5d8
leaq 0xd653(%rip), %rdx      # 0x1bcba
movq %r14, %rdi
callq 0x54d0
movq %rax, %rbx
movq 0x88(%rsp), %rdi
cmpq %r15, %rdi
je 0xe697
movq 0x98(%rsp), %rsi
incq %rsi
callq 0x52c0
jmp 0xe697
movq %rax, %rbx
movb $0x1, %bpl
testb %bpl, %bpl
je 0xe705
movq %r14, %rdi
callq 0x5230
jmp 0xe705
jmp 0xe724
jmp 0xe724
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0xe6c9
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x52c0
jmp 0xe6c9
movq %rax, %rbx
movq 0x78(%rsp), %rax
testq %rax, %rax
je 0xe6e9
leaq 0x68(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0xe6e9
jmp 0xe724
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %r12, %rdi
je 0xe705
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x52c0
jmp 0xe705
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0xe71c
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x5510
movq %rax, %rdi
callq 0x861b
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x138(%rdi), %rbx
leaq 0x128(%rdi), %r12
cmpq %r12, %rbx
je 0xe763
movq %rsi, %r15
cmpq %r15, 0x20(%rbx)
je 0xe763
movq %rbx, %rdi
callq 0x5330
movq %rax, %rbx
cmpq %r12, %rax
jne 0xe74d
cmpq %r12, %rbx
je 0xe77a
addq $0x120, %r14            # imm = 0x120
movq %r14, %rdi
movq %rbx, %rsi
callq 0xe7ec
cmpq %r12, %rbx
setne %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x168(%rdi), %rbx
leaq 0x158(%rdi), %r12
cmpq %r12, %rbx
je 0xe7c3
movq %rsi, %r15
cmpq %r15, 0x20(%rbx)
je 0xe7c3
movq %rbx, %rdi
callq 0x5330
movq %rax, %rbx
cmpq %r12, %rax
jne 0xe7ad
cmpq %r12, %rbx
je 0xe7da
addq $0x150, %r14            # imm = 0x150
movq %r14, %rdi
movq %rbx, %rsi
callq 0xe7ec
cmpq %r12, %rbx
setne %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rdi), %rsi
movq 0x8(%rdi), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x1eb20
movq %rbx, %rdi
movq %r15, %rsi
callq 0x51a0
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0xf532
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x52c0
movb 0x20(%r14), %al
movb %al, 0x20(%rbx)
movzbl 0x21(%r14), %esi
movq %rbx, %rdi
callq 0x12492
movzbl 0x22(%r14), %esi
movq %rbx, %rdi
callq 0x1256c
movb 0x23(%r14), %al
movb %al, 0x23(%rbx)
movl 0x24(%r14), %esi
movq %rbx, %rdi
callq 0x12646
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0xf58c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x52c0
movq %rbx, %rdi
callq 0x5510
// File: /workspace/github_cpp_makefile_star2_O1/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)
movq $0x0, 0x10(%rdi)
leaq 0x13663(%rip), %rsi     # 0x23270
movl $0x1, %ecx
movq %r14, %rdi
xorl %edx, %edx
callq 0x5500
cmpq $-0x1, %rax
je 0xfcee
movq %rax, %rbp
leaq 0x18(%rsp), %r13
leaq 0x28(%rsp), %r15
leaq 0x8(%rsp), %r12
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %rbp, %rcx
callq 0x52e0
movq %r12, %rdi
movq %r15, %rsi
callq 0x10881
movq %rbx, %rdi
movq %r12, %rsi
callq 0xde4a
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0xfc75
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x52c0
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0xfc91
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x52c0
incq %rbp
movq %r12, %rdi
movq %r14, %rsi
movq %rbp, %rdx
movq $-0x1, %rcx
callq 0x52e0
movq %r14, %rdi
movq %r12, %rsi
callq 0x5370
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0xfccb
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x52c0
movl $0x1, %ecx
movq %r14, %rdi
leaq 0x13596(%rip), %rsi     # 0x23270
xorl %edx, %edx
callq 0x5500
movq %rax, %rbp
cmpq $-0x1, %rax
jne 0xfc38
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x10881
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xde4a
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xfd23
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x52c0
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xfd91
movq 0x18(%rsp), %rsi
jmp 0xfd84
jmp 0xfd8e
jmp 0xfd8e
movq %rax, %r14
jmp 0xfd70
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0xfd70
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x52c0
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0xfd91
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x52c0
jmp 0xfd91
movq %rax, %r14
movq %rbx, %rdi
callq 0x7172
movq %r14, %rdi
callq 0x5510
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x1, 0x21(%rdi)
jne 0x110e9
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
movq %rsp, %r15
movq %r15, %rdi
callq 0x1eb20
movq (%r15), %rdi
movq 0x8(%r15), %rsi
addq %rdi, %rsi
movq %rdi, %rdx
callq 0x115bb
leaq 0x30(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rsp), %rax
cmpq %r12, %rax
je 0x110ff
movq %rax, 0x20(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x11109
leaq 0x30(%r14), %r15
movq 0x28(%r14), %rdi
movq 0x30(%r14), %rsi
movq %rbx, %rdx
callq 0x118c0
jmp 0x11173
movups (%r12), %xmm0
movups %xmm0, (%r13)
movq 0x8(%rsp), %rax
leaq 0x20(%rsp), %r15
movq %rax, 0x8(%r15)
movq %r12, (%rsp)
movq $0x0, 0x8(%rsp)
movb $0x0, 0x10(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5370
movq (%r15), %rdi
cmpq %r13, %rdi
je 0x11149
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x52c0
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x1115f
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x52c0
leaq 0x30(%r14), %r15
movq 0x28(%r14), %rdi
movq 0x30(%r14), %rsi
movq %rbx, %rdx
callq 0x11637
cmpq (%r15), %rax
setne %al
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x111a0
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x52c0
movq %rbx, %rdi
callq 0x5510
// File: /workspace/github_cpp_makefile_star2_O1/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 0x124d7
movq (%r14), %rdi
cmpq %rbx, %rdi
je 0x124d1
movq %rbx, %rsi
callq 0x10e22
testb %al, %al
jne 0x124e5
addq $0x8, %r14
jmp 0x124b8
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x38, %edi
callq 0x5170
movq %rax, %rbx
movq (%r14), %rsi
leaq 0x8(%rsp), %rdi
movl $0x1, %edx
movl $0x1, %ecx
callq 0xd6b2
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xf594
xorl %ebp, %ebp
leaq 0x1d0de(%rip), %rsi     # 0x2f600
leaq 0x9791(%rip), %rdx      # 0x1bcba
movq %rbx, %rdi
callq 0x54d0
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x12557
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x52c0
jmp 0x12557
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x12564
movq %rbx, %rdi
callq 0x5230
movq %r14, %rdi
callq 0x5510
// File: /workspace/github_cpp_makefile_star2_O1/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 0x125b1
movq (%r14), %rdi
cmpq %rbx, %rdi
je 0x125ab
movq %rbx, %rsi
callq 0x10e22
testb %al, %al
jne 0x125bf
addq $0x8, %r14
jmp 0x12592
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x38, %edi
callq 0x5170
movq %rax, %rbx
movq (%r14), %rsi
leaq 0x8(%rsp), %rdi
movl $0x1, %edx
movl $0x1, %ecx
callq 0xd6b2
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xf594
xorl %ebp, %ebp
leaq 0x1d004(%rip), %rsi     # 0x2f600
leaq 0x96b7(%rip), %rdx      # 0x1bcba
movq %rbx, %rdi
callq 0x54d0
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x12631
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x52c0
jmp 0x12631
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x1263e
movq %rbx, %rdi
callq 0x5230
movq %r14, %rdi
callq 0x5510
// File: /workspace/github_cpp_makefile_star2_O1/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
movq %rdi, %r14
movl 0xfc(%rdi), %edx
movl 0x100(%rdi), %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpl $0x0, 0x24(%rdi)
jne 0x12679
movl $0x1, %ecx
testl %eax, %eax
jns 0x12679
movl %edx, %ecx
sarl $0x1f, %ecx
orl $0x1, %ecx
imull %edx, %eax
movl %eax, %edx
negl %edx
cmovsl %eax, %edx
imull %ecx, %edx
testl %edx, %edx
js 0x1269a
movl %esi, 0x24(%r14)
movq %r14, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x38, %edi
callq 0x5170
movq %rax, %rbx
movq %rsp, %rdi
movq %r14, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xd6b2
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x12718
xorl %ebp, %ebp
leaq 0x1cf0b(%rip), %rsi     # 0x2f5d8
leaq 0x95e6(%rip), %rdx      # 0x1bcba
movq %rbx, %rdi
callq 0x54d0
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x12702
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x52c0
jmp 0x12702
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x1270f
movq %rbx, %rdi
callq 0x5230
movq %r14, %rdi
callq 0x5510
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x12c8c
movq %rbx, %rdi
callq 0x12e90
movq $0x1, 0x180(%rbx)
movq %rbx, %rdi
callq 0x12f24
movq $0x0, 0x180(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x13000
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x130d4
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
movq $0x0, 0x180(%rdi)
addq $0x110, %rdi            # imm = 0x110
movq 0x110(%rbx), %rsi
callq 0x13160
movq 0x140(%rbx), %rax
cmpq %rax, 0x148(%rbx)
je 0x12ecd
movq %rax, 0x148(%rbx)
movq 0x98(%rbx), %r14
movq 0xa0(%rbx), %r15
cmpq %r15, %r14
je 0x12efc
movq (%r14), %rdi
movq 0x1a8(%rdi), %rsi
addq $0x1a8, %rdi            # imm = 0x1A8
callq 0x131b2
addq $0x8, %r14
jmp 0x12edb
movq 0x158(%rbx), %r14
movq 0x160(%rbx), %rbx
cmpq %rbx, %r14
je 0x12f1d
movq (%r14), %rdi
callq 0x12e90
addq $0x8, %r14
jmp 0x12f0a
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
movq 0x98(%rdi), %rdi
movq 0xa0(%r14), %rsi
callq 0x13293
cmpq $0x2, %rax
jge 0x12f76
movq 0x158(%r14), %rbx
movq 0x160(%r14), %r14
cmpq %r14, %rbx
je 0x12f6b
movq (%rbx), %rdi
callq 0x12f24
addq $0x8, %rbx
jmp 0x12f58
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x38, %edi
callq 0x5170
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x1eb20
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x13204
xorl %ebp, %ebp
leaq 0x1c75e(%rip), %rsi     # 0x2f718
leaq 0x8cf9(%rip), %rdx      # 0x1bcba
movq %rbx, %rdi
callq 0x54d0
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x12feb
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x52c0
jmp 0x12feb
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x12ff8
movq %rbx, %rdi
callq 0x5230
movq %r14, %rdi
callq 0x5510
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x40, %rsp
movq %rsi, %rbx
movq %rdi, %r14
incq 0x180(%rdi)
movb $0x0, 0xf(%rsp)
movq (%rsi), %rax
cmpq 0x8(%rsi), %rax
je 0x13040
leaq 0xf(%rsp), %r15
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x1357e
movq (%rbx), %rax
cmpq 0x8(%rbx), %rax
jne 0x13029
cmpq $0x0, 0x178(%r14)
jne 0x130c9
movq %r14, %rdi
callq 0x1364e
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1367c
leaq 0x28(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x1378e
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq (%rbx), %rax
movups 0x8(%rbx), %xmm0
movq (%r15), %rcx
movq %rcx, (%rbx)
movq 0x8(%r15), %rcx
movq %rcx, 0x8(%rbx)
movq 0x10(%r15), %rcx
movq %rcx, 0x10(%rbx)
movq (%rdi), %rcx
movq 0x8(%rdi), %rdx
movq 0x10(%rdi), %rsi
movq %rax, (%rdi)
movups %xmm0, 0x8(%rdi)
movq %rcx, (%r15)
movq %rdx, 0x8(%r15)
movq %rsi, 0x10(%r15)
callq 0x7172
movq %r15, %rdi
callq 0x7172
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x130f2
leaq 0x50(%rbx), %rdi
callq *0x68(%rbx)
addq $0x140, %rbx            # imm = 0x140
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1b9aa
movq (%r14), %rbx
movq 0x8(%r14), %r14
cmpq %r14, %rbx
je 0x13121
movq (%rbx), %rdi
callq 0x130d4
addq $0x8, %rbx
jmp 0x1310e
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x13137
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x52c0
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x13158
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x52c0
movq %rbx, %rdi
callq 0x5510
// File: /workspace/github_cpp_makefile_star2_O1/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 %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %eax, %eax
cmpb $0x0, (%rdx)
jne 0x135a7
movq 0x8(%r14), %rsi
addq $-0x20, %rsi
movq %r15, %rdi
callq 0x13878
movl %eax, 0xc(%rsp)
cmpl $0x5, %eax
ja 0x1362f
movl %eax, %ecx
leaq 0xfa67(%rip), %rdx      # 0x23020
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movq %r15, %rdi
movq %r14, %rsi
movl %eax, %edx
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x13c90
movq %r15, %rdi
movq %r14, %rsi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x148d0
addq $0x110, %r15            # imm = 0x110
movq 0x8(%r14), %rdx
addq $-0x20, %rdx
leaq 0xc(%rsp), %rsi
movq %r15, %rdi
callq 0x139a8
movq 0x8(%r14), %rax
leaq -0x20(%rax), %rcx
movq %rcx, 0x8(%r14)
movq -0x20(%rax), %rdi
addq $-0x10, %rax
cmpq %rax, %rdi
je 0x1362c
movq (%rax), %rsi
incq %rsi
callq 0x52c0
movb $0x1, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %r15, %rdi
movq %r14, %rsi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x139f4
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x16b2c
movq %rbx, %rdi
callq 0x16bf6
movq %rbx, %rdi
callq 0x16dc6
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x16e30
movq %rbx, %rdi
popq %rbx
jmp 0x16f1e
// File: /workspace/github_cpp_makefile_star2_O1/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, %rsi
cmpb $0x0, 0x48(%rdi)
jne 0x136c7
cmpb $0x0, 0x4a(%rsi)
jne 0x136c7
movq 0x110(%rsi), %rax
movq 0x118(%rsi), %rcx
cmpq %rcx, %rax
je 0x136c7
xorl %edx, %edx
xorl %edi, %edi
cmpl $0x1, (%rax)
setne %dil
addq %rdi, %rdx
addq $0x28, %rax
cmpq %rcx, %rax
jne 0x136ad
testq %rdx, %rdx
jne 0x13700
movq 0x158(%rsi), %r14
movq 0x160(%rsi), %r15
cmpq %r15, %r14
je 0x136f5
movq (%r14), %rdi
cmpq $0x0, 0x180(%rdi)
je 0x136ef
movq %rbx, %rsi
callq 0x1367c
addq $0x8, %r14
jmp 0x136d5
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x20(%rsp), %r14
movq %r14, %rdi
xorl %edx, %edx
callq 0x1378e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x10cbe
movq %r14, %rdi
callq 0x7172
movl $0x38, %edi
callq 0x5170
movq %rax, %r14
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0xc46c
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x1bb28
xorl %ebp, %ebp
leaq 0x1c32b(%rip), %rsi     # 0x2fa80
leaq 0x855e(%rip), %rdx      # 0x1bcba
movq %r14, %rdi
callq 0x54d0
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x7172
jmp 0x13779
movq %rax, %rbx
movb $0x1, %bpl
testb %bpl, %bpl
je 0x13786
movq %r14, %rdi
callq 0x5230
movq %rbx, %rdi
callq 0x5510
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x110(%rsi), %r15
movq 0x118(%rsi), %r12
cmpq %r12, %r15
je 0x137d7
leaq 0x8(%r15), %rsi
movq %rbx, %rdi
callq 0xe21c
addq $0x28, %r15
jmp 0x137c0
testb %bpl, %bpl
je 0x13844
movq 0x140(%r14), %r12
movq 0x148(%r14), %r13
cmpq %r13, %r12
je 0x13844
movq %rsp, %r14
movq (%r12), %rsi
movq %r14, %rdi
movl $0x1, %edx
callq 0x1378e
movq (%rsp), %r15
movq 0x8(%rsp), %rbp
subq %r15, %rbp
sarq $0x5, %rbp
testq %rbp, %rbp
jle 0x13833
incq %rbp
movq %rbx, %rdi
movq %r15, %rsi
callq 0xe21c
addq $0x20, %r15
decq %rbp
cmpq $0x1, %rbp
jg 0x1381b
movq %r14, %rdi
callq 0x7172
addq $0x8, %r12
cmpq %r13, %r12
jne 0x137f2
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x13858
movq %rax, %r14
jmp 0x13868
movq %rax, %r14
movq %rsp, %rdi
callq 0x7172
movq %rbx, %rdi
callq 0x7172
movq %r14, %rdi
callq 0x5510
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
xorl %eax, %eax
movq %rax, -0x8(%r15)
movb %al, (%r15)
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq %rax, -0x8(%r12)
movb %al, (%r12)
leaq 0xf9b7(%rip), %rsi      # 0x2326d
movq %rbx, %rdi
callq 0x50d0
testl %eax, %eax
je 0x1392f
movq %r14, %rdi
movq %rbx, %rsi
callq 0x14b76
movl $0x5, %ebp
testb %al, %al
jne 0x13934
leaq 0x20(%rsp), %rsi
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x14cbd
movl $0x3, %ebp
testb %al, %al
jne 0x13934
leaq 0x20(%rsp), %rsi
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x14e6d
movl $0x2, %ebp
testb %al, %al
jne 0x13934
cmpb $0x1, 0x173(%r14)
jne 0x1392b
leaq 0x20(%rsp), %rsi
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x14f3a
movl $0x4, %ebp
testb %al, %al
jne 0x13934
xorl %ebp, %ebp
jmp 0x13934
movl $0x1, %ebp
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x1394a
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x52c0
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x13961
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x52c0
movl %ebp, %eax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x13989
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x52c0
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x139a0
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x52c0
movq %rbx, %rdi
callq 0x5510
// File: /workspace/github_cpp_makefile_star2_O1/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 0x190(%rdi), %rax
testq %rax, %rax
je 0x14bae
movq 0x148(%rdi), %rcx
subq 0x140(%rdi), %rcx
sarq $0x3, %rcx
cmpq %rax, %rcx
jae 0x14c5a
movq 0x158(%rdi), %r13
movq %rdi, 0x20(%rsp)
movq 0x160(%rdi), %rbp
cmpq %rbp, %r13
sete %r14b
je 0x14c6b
movq %rsp, %r15
movq (%r13), %r12
leaq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x1eb20
movq %r12, %rdi
movq %r15, %rsi
callq 0x1507e
testb %al, %al
je 0x14c2c
movq (%r13), %rax
movq 0x180(%rax), %r12
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x14c25
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x52c0
testq %r12, %r12
jne 0x14c47
jmp 0x14c63
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x14c47
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x52c0
addq $0x8, %r13
cmpq %rbp, %r13
sete %r14b
jne 0x14bd1
jmp 0x14c6b
movq 0x178(%rdi), %rdi
jmp 0x14c77
movb $0x1, %al
testb $0x1, %r14b
je 0x14c88
movq 0x20(%rsp), %rax
movq 0x178(%rax), %rdi
testq %rdi, %rdi
je 0x14c86
movq %rbx, %rsi
callq 0x14b76
jmp 0x14c88
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x14cb5
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x52c0
movq %rbx, %rdi
callq 0x5510
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x48, %rsp
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
movq 0x8(%rdi), %rbp
xorl %ebx, %ebx
cmpq $0x3, %rbp
jb 0x14d18
leaq 0x28(%rsp), %r13
movl $0x2, %ecx
movq %r13, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x52e0
leaq 0xe56f(%rip), %rsi      # 0x2326d
movq %r13, %rdi
callq 0x50d0
testl %eax, %eax
jne 0x14d18
movq (%r15), %rax
movsbl 0x2(%rax), %edi
callq 0xfe22
movl %eax, %ebx
cmpq $0x3, %rbp
jb 0x14d39
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x14d39
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x52c0
testb %bl, %bl
je 0x14e36
movq %r15, %rdi
movl $0x3d, %esi
xorl %edx, %edx
callq 0x53c0
cmpq $-0x1, %rax
je 0x14ddc
movq %rax, %r13
leaq -0x2(%rax), %rcx
leaq 0x8(%rsp), %rbp
movl $0x2, %edx
movq %rbp, %rdi
movq %r15, %rsi
callq 0x52e0
movq %r12, %rdi
movq %rbp, %rsi
callq 0x5370
movq (%rbp), %rdi
leaq 0x18(%rsp), %rbp
cmpq %rbp, %rdi
je 0x14d9c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x52c0
incq %r13
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
movq $-0x1, %rcx
callq 0x52e0
movq %r14, %rdi
movq %r12, %rsi
callq 0x5370
movq (%r12), %rdi
cmpq %rbp, %rdi
je 0x14e36
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x52c0
jmp 0x14e36
leaq 0x8(%rsp), %r13
movl $0x2, %edx
movq %r13, %rdi
movq %r15, %rsi
movq $-0x1, %rcx
callq 0x52e0
movq %r12, %rdi
movq %r13, %rsi
callq 0x5370
movq (%r13), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x14e1e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x52c0
movq 0x8(%r14), %rdx
leaq 0xe935(%rip), %rcx      # 0x2375e
movq %r14, %rdi
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x5460
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x14e65
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x52c0
movq %rbx, %rdi
callq 0x5510
// File: /workspace/github_cpp_makefile_star2_O1/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 0x14f29
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
movq (%rdi), %rax
cmpb $0x2d, (%rax)
jne 0x14f2c
movq %rdx, %rbx
movq %rsi, %r15
movsbl 0x1(%rax), %edi
callq 0xfe22
testb %al, %al
je 0x14f2c
leaq 0x8(%rsp), %r12
movl $0x1, %edx
movl $0x1, %ecx
movq %r12, %rdi
movq %r14, %rsi
callq 0x52e0
movq %r15, %rdi
movq %r12, %rsi
callq 0x5370
movq (%r12), %rdi
leaq 0x18(%rsp), %r12
cmpq %r12, %rdi
je 0x14ee9
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x52c0
leaq 0x8(%rsp), %r15
movl $0x2, %edx
movq %r15, %rdi
movq %r14, %rsi
movq $-0x1, %rcx
callq 0x52e0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5370
movq (%r15), %rdi
cmpq %r12, %rdi
je 0x14f25
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x52c0
movb $0x1, %al
jmp 0x14f2e
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_O1/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 0x1500e
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %r14
movq (%rdi), %rax
cmpb $0x2f, (%rax)
jne 0x15011
movq %rdx, %rbx
movq %rsi, %r15
movsbl 0x1(%rax), %edi
callq 0xfe22
testb %al, %al
je 0x15011
movq %r14, %rdi
movl $0x3a, %esi
xorl %edx, %edx
callq 0x53c0
cmpq $-0x1, %rax
je 0x15015
movq %rax, %r12
leaq -0x1(%rax), %rcx
movq %rsp, %r13
movl $0x1, %edx
movq %r13, %rdi
movq %r14, %rsi
callq 0x52e0
movq %r15, %rdi
movq %r13, %rsi
callq 0x5370
movq (%r13), %rdi
leaq 0x10(%rsp), %r13
cmpq %r13, %rdi
je 0x14fd1
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x52c0
incq %r12
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq $-0x1, %rcx
callq 0x52e0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5370
movq (%r15), %rdi
cmpq %r13, %rdi
je 0x1506d
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x52c0
jmp 0x1506d
xorl %eax, %eax
retq
xorl %eax, %eax
jmp 0x1506f
movq %rsp, %r12
movl $0x1, %edx
movq %r12, %rdi
movq %r14, %rsi
movq $-0x1, %rcx
callq 0x52e0
movq %r15, %rdi
movq %r12, %rsi
callq 0x5370
movq (%r12), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x15055
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x52c0
movq 0x8(%rbx), %rdx
leaq 0xe6fe(%rip), %rcx      # 0x2375e
movq %rbx, %rdi
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x5460
movb $0x1, %al
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0x1e0(%rdi), %rdi
testq %rdi, %rdi
je 0x16b99
movq 0x1a8(%rdi), %rax
cmpq 0x1b0(%rdi), %rax
je 0x16b60
callq 0x1743a
movb $0x1, 0x1d8(%rbx)
cmpq $0x0, 0x1c0(%rbx)
je 0x16b99
leaq 0x1b8(%rbx), %rdx
movq 0x1e8(%rbx), %rsi
leaq 0x8(%rsp), %rdi
callq 0x17c30
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x17d32
leaq 0x8(%rsp), %rdi
callq 0xe0cc
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rdx, %r15
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0xe0cc
jmp 0x16bbb
movq %rdx, %r15
movq %rax, %r14
cmpl $0x1, %r15d
jne 0x16be6
movq %r14, %rdi
callq 0x5140
cmpb $0x1, 0x1d8(%rbx)
je 0x16bd9
callq 0x54b0
jmp 0x16b99
callq 0x5420
movq %rax, %r14
callq 0x54b0
movq %r14, %rdi
callq 0x5510
movq %rax, %rdi
callq 0x861b
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x98(%rdi), %r14
movq 0xa0(%rdi), %r15
cmpq %r15, %r14
je 0x16e08
movq (%r14), %rdi
movq 0x1b0(%rdi), %rax
cmpq 0x1a8(%rdi), %rax
je 0x16e02
cmpb $0x0, 0x1c0(%rdi)
jne 0x16e02
callq 0x1743a
addq $0x8, %r14
jmp 0x16ddc
movq 0x158(%rbx), %r14
movq 0x160(%rbx), %rbx
cmpq %rbx, %r14
je 0x16e29
movq (%r14), %rdi
callq 0x16dc6
addq $0x8, %r14
jmp 0x16e16
popq %rbx
popq %r14
popq %r15
retq
nop