LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/meirdev[P]HexViewer/./CLI11.hpp
// Function: CLI::App::get_subcommands(std::function<bool (CLI::App const*)> const&) const
std::vector<const App *> get_subcommands(const std::function<bool(const App *)> &filter) const {
        std::vector<const App *> subcomms(subcommands_.size());
        std::transform(std::begin(subcommands_), std::end(subcommands_), std::begin(subcomms), [](const App_p &v) {
            return v.get();
        });

        if(filter) {
            subcomms.erase(std::remove_if(std::begin(subcomms),
                                          std::end(subcomms),
                                          [&filter](const App *app) { return !filter(app); }),
                           std::end(subcomms));
        }

        return subcomms;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x160(%rsi), %rsi
subq 0x158(%r15), %rsi
sarq $0x3, %rsi
leaq 0xf(%rsp), %rdx
callq 0xc7cc
movq 0x158(%r15), %rax
movq 0x160(%r15), %rcx
cmpq %rcx, %rax
je 0x76d7
movq (%rbx), %rdx
movq (%rax), %rsi
movq %rsi, (%rdx)
addq $0x8, %rax
addq $0x8, %rdx
cmpq %rcx, %rax
jne 0x76c4
cmpq $0x0, 0x10(%r14)
je 0x76f7
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
movq %r14, %rdx
callq 0xc875
cmpq 0x8(%rbx), %rax
je 0x76f7
movq %rax, 0x8(%rbx)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x771b
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x52c0
movq %r14, %rdi
callq 0x5510
nop
// File: /workspace/github_cpp_makefile_star2_O3/meirdev[P]HexViewer/./CLI11.hpp
// Function: CLI::Formatter::make_group(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, std::vector<CLI::Option const*, std::allocator<CLI::Option const*>>) const
inline std::string
Formatter::make_group(std::string group, bool is_positional, std::vector<const Option *> opts) const {
    std::stringstream out;

    out << "\n" << group << ":\n";
    for(const Option *opt : opts) {
        out << make_option(opt, is_positional);
    }

    return out.str();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b8, %rsp            # imm = 0x1B8
movq %r8, %r12
movl %ecx, %ebp
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x30(%rsp), %rdi
callq 0x5210
leaq 0x40(%rsp), %rdi
leaq 0x1c004(%rip), %rsi     # 0x2375d
movl $0x1, %edx
callq 0x5320
movq (%r13), %rsi
movq 0x8(%r13), %rdx
leaq 0x40(%rsp), %rdi
callq 0x5320
leaq 0x1b8ec(%rip), %rsi     # 0x23068
movl $0x2, %edx
movq %rax, %rdi
callq 0x5320
movq %rbx, 0x8(%rsp)
movq (%r12), %r13
movq 0x8(%r12), %rbx
cmpq %rbx, %r13
je 0x77f0
leaq 0x20(%rsp), %r15
movzbl %bpl, %ebp
leaq 0x10(%rsp), %r12
movq (%r13), %rdx
movq (%r14), %rax
movq %r12, %rdi
movq %r14, %rsi
movl %ebp, %ecx
callq *0x58(%rax)
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
leaq 0x40(%rsp), %rdi
callq 0x5320
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x77e7
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x52c0
addq $0x8, %r13
cmpq %rbx, %r13
jne 0x77aa
leaq 0x48(%rsp), %rsi
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x5480
movq 0x2878f(%rip), %rsi     # 0x2ff98
leaq 0x30(%rsp), %rdi
callq 0x5240
leaq 0xb0(%rsp), %rdi
callq 0x5100
movq %rbx, %rax
addq $0x1b8, %rsp            # imm = 0x1B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x7837
movq %rax, %rbx
jmp 0x7856
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x7856
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x52c0
movq 0x2873b(%rip), %rsi     # 0x2ff98
leaq 0x30(%rsp), %rdi
callq 0x5240
leaq 0xb0(%rsp), %rdi
callq 0x5100
movq %rbx, %rdi
callq 0x5510
// File: /workspace/github_cpp_makefile_star2_O3/meirdev[P]HexViewer/./CLI11.hpp
// Function: CLI::Option* CLI::App::add_option<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, (CLI::detail::enabler)0>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 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_option(std::string option_name,
                       T &variable, ///< The variable to set
                       std::string description = "") {

        CLI::callback_t fun = [&variable](CLI::results_t res) { return detail::lexical_cast(res[0], variable); };

        Option *opt = add_option(option_name, fun, description, false);
        opt->type_name(detail::type_name<T>());
        return opt;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rcx, %r14
movq %rdi, %rbx
movq $0x0, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
leaq 0x16e97(%rip), %rax     # 0x1e8e6
movq %rax, 0x20(%rsp)
leaq 0x16e91(%rip), %rax     # 0x1e8ec
movq %rax, 0x18(%rsp)
leaq 0x78(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq 0x68(%rsp), %rdi
movq %rax, %rsi
callq 0x1e780
leaq 0x88(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xeeca
leaq 0x58(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x48(%rsp), %rdi
callq 0x1e780
leaq 0x68(%rsp), %rsi
leaq 0x88(%rsp), %rdx
leaq 0x48(%rsp), %rcx
movq %rbx, %rdi
xorl %r8d, %r8d
callq 0xeace
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %r12, %rdi
je 0x7ae7
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x52c0
movq 0x98(%rsp), %rax
testq %rax, %rax
je 0x7b06
leaq 0x88(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x68(%rsp), %rdi
cmpq %r15, %rdi
je 0x7b1d
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x52c0
leaq 0x38(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x1bcfd(%rip), %rsi     # 0x2382a
leaq 0x1bcfa(%rip), %rdx     # 0x2382e
leaq 0x28(%rsp), %rdi
callq 0xc736
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x1e816
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0x7b62
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x52c0
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x7b7b
leaq 0x8(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x7c2f
jmp 0x7c2f
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0x7c0e
movq 0x38(%rsp), %rsi
jmp 0x7c01
jmp 0x7c0b
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %r12, %rdi
je 0x7bcc
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x52c0
jmp 0x7bcc
movq %rax, %rbx
movq 0x98(%rsp), %rax
testq %rax, %rax
je 0x7bf2
leaq 0x88(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x7bf2
jmp 0x7c2f
movq %rax, %rbx
movq 0x68(%rsp), %rdi
cmpq %r15, %rdi
je 0x7c0e
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x52c0
jmp 0x7c0e
movq %rax, %rbx
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x7c27
leaq 0x8(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x5510
movq %rax, %rdi
callq 0x85dd
nop
// File: /workspace/github_cpp_makefile_star2_O3/meirdev[P]HexViewer/./CLI11.hpp
// Function: CLI::App::parse(int, char const* const*)
void parse(int argc, const char *const *argv) {
        // If the name is not set, read from command line
        if(name_.empty())
            name_ = argv[0];

        std::vector<std::string> args;
        for(int i = argc - 1; i > 0; i--)
            args.emplace_back(argv[i]);
        parse(args);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
cmpq $0x0, 0x10(%rdi)
jne 0x82f2
leaq 0x8(%rbx), %r15
movq (%r14), %r12
movq %r12, %rdi
callq 0x5160
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
movq %r12, %rcx
movq %rax, %r8
callq 0x5460
xorps %xmm0, %xmm0
movq %rsp, %r15
movaps %xmm0, (%r15)
movq $0x0, 0x10(%r15)
movl %ebp, %eax
incl %ebp
leaq (%r14,%rax,8), %rsi
addq $-0x8, %rsi
decl %ebp
cmpl $0x1, %ebp
jle 0x8328
leaq -0x8(%rsi), %r14
movq %r15, %rdi
callq 0x12b6a
movq %r14, %rsi
jmp 0x8310
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x12bb6
movq %rsp, %rdi
callq 0x714a
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x834a
movq %rax, %rbx
movq %rsp, %rdi
callq 0x714a
movq %rbx, %rdi
callq 0x5510
nop
// File: /workspace/github_cpp_makefile_star2_O3/meirdev[P]HexViewer/./CLI11.hpp
// Function: CLI::Formatter::make_positionals[abi:cxx11](CLI::App const*) const
inline std::string Formatter::make_positionals(const App *app) const {
    std::vector<const Option *> opts =
        app->get_options([](const Option *opt) { return !opt->get_group().empty() && opt->get_positional(); });

    if(opts.empty())
        return std::string();
    else
        return make_group(get_label("Positionals"), true, opts);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x70(%rsp), %rax
movaps %xmm0, (%rax)
leaq 0x13ae4(%rip), %rcx     # 0x1c54e
movq %rcx, 0x18(%rax)
leaq 0x13aef(%rip), %rcx     # 0x1c564
movq %rcx, 0x10(%rax)
movq %rsp, %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0x70a6
movq 0x80(%rsp), %rax
testq %rax, %rax
je 0x8aa3
leaq 0x70(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq (%rsp), %rax
cmpq 0x8(%rsp), %rax
je 0x8b58
leaq 0x40(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1ac86(%rip), %rsi     # 0x23748
leaq 0x1ac8a(%rip), %rdx     # 0x23753
leaq 0x30(%rsp), %rdi
callq 0xc736
leaq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %rdx
movq %r14, %rsi
callq 0x1c4b2
leaq 0x18(%rsp), %rdi
movq %rsp, %rsi
callq 0x1c204
movq (%r14), %rax
leaq 0x50(%rsp), %rdx
leaq 0x18(%rsp), %r8
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %ecx
callq *0x18(%rax)
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x8b24
movq 0x28(%rsp), %rsi
subq %rdi, %rsi
callq 0x52c0
leaq 0x60(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8b3f
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x52c0
movq 0x30(%rsp), %rdi
cmpq %r15, %rdi
je 0x8b6b
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x52c0
jmp 0x8b6b
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x8b81
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x52c0
movq %rbx, %rax
addq $0x90, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x8bb0
movq 0x28(%rsp), %rsi
subq %rdi, %rsi
callq 0x52c0
jmp 0x8bb0
movq %rax, %rbx
leaq 0x60(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8bd0
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x52c0
jmp 0x8bd0
movq %rax, %rbx
movq 0x30(%rsp), %rdi
cmpq %r15, %rdi
je 0x8bec
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x52c0
jmp 0x8bec
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x8c25
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x52c0
jmp 0x8c25
jmp 0x8c2d
movq %rax, %rbx
movq 0x80(%rsp), %rax
testq %rax, %rax
je 0x8c25
leaq 0x70(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x5510
movq %rax, %rdi
callq 0x85dd
nop
// File: /workspace/github_cpp_makefile_star2_O3/meirdev[P]HexViewer/./CLI11.hpp
// Function: CLI::Formatter::make_footer[abi:cxx11](CLI::App const*) const
inline std::string Formatter::make_footer(const App *app) const {
    std::string footer = app->get_footer();
    if(!footer.empty())
        return footer + "\n";
    else
        return "";
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0xb0(%rdx), %rsi
movq 0xb8(%rdx), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x1e780
movq 0x8(%r14), %rdx
testq %rdx, %rdx
je 0x9952
leaq 0x10(%rbx), %r12
movq %r12, (%rbx)
movq 0x8(%rsp), %rsi
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x1e780
leaq 0x19e15(%rip), %rsi     # 0x2375d
movq %rbx, %rdi
callq 0x5570
jmp 0x996b
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x19dfe(%rip), %rdx     # 0x2375e
movq %rbx, %rdi
movq %rdx, %rsi
callq 0xc736
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x9982
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x52c0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x99ac
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x99af
movq (%r12), %rsi
incq %rsi
callq 0x52c0
jmp 0x99af
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x99c6
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x52c0
movq %r14, %rdi
callq 0x5510
// File: /workspace/github_cpp_makefile_star2_O3/meirdev[P]HexViewer/./CLI11.hpp
// Function: CLI::Formatter::make_description[abi:cxx11](CLI::App const*) const
inline std::string Formatter::make_description(const App *app) const {
    std::string desc = app->get_description();

    if(!desc.empty())
        return desc + "\n";
    else
        return "";
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0x28(%rdx), %rsi
movq 0x30(%rdx), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x1e780
movq 0x8(%r14), %rdx
testq %rdx, %rdx
je 0x9a2e
leaq 0x10(%rbx), %r12
movq %r12, (%rbx)
movq 0x8(%rsp), %rsi
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x1e780
leaq 0x19d39(%rip), %rsi     # 0x2375d
movq %rbx, %rdi
callq 0x5570
jmp 0x9a47
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x19d22(%rip), %rdx     # 0x2375e
movq %rbx, %rdi
movq %rdx, %rsi
callq 0xc736
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x9a5e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x52c0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x9a88
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x9a8b
movq (%r12), %rsi
incq %rsi
callq 0x52c0
jmp 0x9a8b
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x9aa2
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x52c0
movq %r14, %rdi
callq 0x5510
// File: /workspace/github_cpp_makefile_star2_O3/meirdev[P]HexViewer/./CLI11.hpp
// Function: CLI::Formatter::make_option_name[abi:cxx11](CLI::Option const*, bool) const
inline std::string Formatter::make_option_name(const Option *opt, bool is_positional) const {
    if(is_positional)
        return opt->get_name(true, false);
    else
        return opt->get_name(false, true);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
testl %ecx, %ecx
je 0xa4de
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x58(%rdx), %rsi
movq 0x60(%rdx), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x1e780
jmp 0xa4f0
movq %rbx, %rdi
movq %rdx, %rsi
xorl %edx, %edx
movl $0x1, %ecx
callq 0xd604
movq %rbx, %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xd1a1
movq %rbx, %rdi
callq 0xe3ae
movq $0x0, 0xd0(%rbx)
movq 0x8(%r15), %rdx
testq %rdx, %rdx
je 0xd239
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%r15), %rsi
addq %rsi, %rdx
leaq 0x28(%rsp), %rdi
callq 0x1e780
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x1e780
leaq 0x28(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0xe45c
movq %rax, 0xd0(%rbx)
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0xd215
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x52c0
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0xd22c
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x52c0
movq 0xd0(%rbx), %rax
movb $0x0, 0x23(%rax)
jmp 0xd23b
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0xd266
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x52c0
jmp 0xd266
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0xd27d
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x52c0
movq %rbx, %rdi
callq 0x5510
// File: /workspace/github_cpp_makefile_star2_O3/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 0xd999
movq %rbx, %rdi
callq 0xe3ae
movq $0x0, 0xd8(%rbx)
movq 0x8(%r15), %rdx
testq %rdx, %rdx
je 0xda31
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%r15), %rsi
addq %rsi, %rdx
leaq 0x28(%rsp), %rdi
callq 0x1e780
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x1e780
leaq 0x28(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0xe45c
movq %rax, 0xd8(%rbx)
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0xda0d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x52c0
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0xda24
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x52c0
movq 0xd8(%rbx), %rax
movb $0x0, 0x23(%rax)
jmp 0xda33
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0xda5e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x52c0
jmp 0xda5e
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0xda75
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x52c0
movq %rbx, %rdi
callq 0x5510
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xdd89
xorl %ebp, %ebp
movq %rsp, %r15
subq $0x1, %rbp
jb 0xdd6f
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 0xdd5a
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x5480
movq 0x2221b(%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 0xddc6
movq %rax, %rbx
movq 0x221e8(%rip), %rsi     # 0x2ffb8
movq %rsp, %rdi
callq 0x5190
leaq 0x70(%rsp), %rdi
callq 0x5100
movq %rbx, %rdi
callq 0x5510
// File: /workspace/github_cpp_makefile_star2_O3/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 0xe3eb
movq (%r15), %rdi
movq %r14, %rsi
callq 0xe69a
movq (%r15), %rdi
movq %r14, %rsi
callq 0xe6fa
addq $0x8, %r15
jmp 0xe3ca
cmpq %r14, 0xd0(%rbx)
jne 0xe3ff
movq $0x0, 0xd0(%rbx)
cmpq %r14, 0xd8(%rbx)
jne 0xe413
movq $0x0, 0xd8(%rbx)
movq 0x98(%rbx), %rdi
movq 0xa0(%rbx), %rsi
movq %r14, %rdx
callq 0xe796
movq %rax, %r14
movq 0xa0(%rbx), %r15
cmpq %r15, %rax
je 0xe44a
addq $0x98, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xe832
cmpq %r15, %r14
setne %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xb32(%rip), %rax       # 0xefb6
movq %rax, 0x18(%rsp)
leaq 0xb56(%rip), %rax       # 0xefe6
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 0x1e780
leaq 0x68(%rsp), %rdi
movq %rsp, %rsi
callq 0xeeca
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %rdi
callq 0x1e780
leaq 0x48(%rsp), %rsi
leaq 0x68(%rsp), %rdx
leaq 0x28(%rsp), %rcx
movq %r14, %rdi
xorl %r8d, %r8d
callq 0xeace
movq %rax, %r14
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0xe511
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x52c0
movq 0x78(%rsp), %rax
testq %rax, %rax
je 0xe52a
leaq 0x68(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x48(%rsp), %rdi
cmpq %r12, %rdi
je 0xe541
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x52c0
cmpq $0x0, 0x60(%r14)
jne 0xe584
movl $0x0, 0xfc(%r14)
movb $0x0, 0x20(%r14)
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0xe56f
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 0x1e780
movb $0x1, %bpl
leaq 0x88(%rsp), %rsi
movq %r14, %rdi
callq 0xef28
xorl %ebp, %ebp
leaq 0x21008(%rip), %rsi     # 0x2f5d8
leaq 0xd3b1(%rip), %rdx      # 0x1b988
movq %r14, %rdi
callq 0x54d0
movq %rax, %rbx
movq 0x88(%rsp), %rdi
cmpq %r15, %rdi
je 0xe5ff
movq 0x98(%rsp), %rsi
incq %rsi
callq 0x52c0
testb %bpl, %bpl
jne 0xe609
jmp 0xe672
movq %rax, %rbx
movq %r14, %rdi
callq 0x5230
jmp 0xe672
jmp 0xe691
jmp 0xe691
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0xe636
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x52c0
jmp 0xe636
movq %rax, %rbx
movq 0x78(%rsp), %rax
testq %rax, %rax
je 0xe656
leaq 0x68(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0xe656
jmp 0xe691
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %r12, %rdi
je 0xe672
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x52c0
jmp 0xe672
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0xe689
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x5510
movq %rax, %rdi
callq 0x85dd
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xe6d1
movq %rsi, %r15
cmpq %r15, 0x20(%rbx)
je 0xe6d1
movq %rbx, %rdi
callq 0x5330
movq %rax, %rbx
cmpq %r12, %rax
jne 0xe6bb
cmpq %r12, %rbx
je 0xe6e8
addq $0x120, %r14            # imm = 0x120
movq %r14, %rdi
movq %rbx, %rsi
callq 0xe75a
cmpq %r12, %rbx
setne %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xe731
movq %rsi, %r15
cmpq %r15, 0x20(%rbx)
je 0xe731
movq %rbx, %rdi
callq 0x5330
movq %rax, %rbx
cmpq %r12, %rax
jne 0xe71b
cmpq %r12, %rbx
je 0xe748
addq $0x150, %r14            # imm = 0x150
movq %r14, %rdi
movq %rbx, %rsi
callq 0xe75a
cmpq %r12, %rbx
setne %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1e780
movq %rbx, %rdi
movq %r15, %rsi
callq 0x51a0
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0xf498
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x52c0
movb 0x20(%r14), %al
movb %al, 0x20(%rbx)
movzbl 0x21(%r14), %esi
movq %rbx, %rdi
callq 0x123de
movzbl 0x22(%r14), %esi
movq %rbx, %rdi
callq 0x124b6
movb 0x23(%r14), %al
movb %al, 0x23(%rbx)
movl 0x24(%r14), %esi
movq %rbx, %rdi
callq 0x1258e
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0xf4f2
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x52c0
movq %rbx, %rdi
callq 0x5510
// File: /workspace/github_cpp_makefile_star2_O3/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 0x13709(%rip), %rsi     # 0x23270
movl $0x1, %ecx
movq %r14, %rdi
xorl %edx, %edx
callq 0x5500
cmpq $-0x1, %rax
je 0xfc48
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 0x107b5
movq %rbx, %rdi
movq %r12, %rsi
callq 0xddea
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0xfbcf
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x52c0
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0xfbeb
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 0xfc25
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x52c0
movl $0x1, %ecx
movq %r14, %rdi
leaq 0x1363c(%rip), %rsi     # 0x23270
xorl %edx, %edx
callq 0x5500
movq %rax, %rbp
cmpq $-0x1, %rax
jne 0xfb92
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x107b5
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xddea
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xfc7d
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 0xfceb
movq 0x18(%rsp), %rsi
jmp 0xfcde
jmp 0xfce8
jmp 0xfce8
movq %rax, %r14
jmp 0xfcca
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0xfcca
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x52c0
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0xfceb
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x52c0
jmp 0xfceb
movq %rax, %r14
movq %rbx, %rdi
callq 0x714a
movq %r14, %rdi
callq 0x5510
nop
// File: /workspace/github_cpp_makefile_star2_O3/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, %r14
movq 0x28(%rdi), %r13
movq %rdi, (%rsp)
movq 0x30(%rdi), %rbx
cmpq %rbx, %r13
je 0x10e61
leaq 0x78(%rsp), %r12
leaq 0x68(%rsp), %r15
movq %r12, 0x68(%rsp)
movq (%r13), %rsi
movq 0x8(%r13), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x1e780
movq %r14, %rdi
movq %r15, %rsi
callq 0x10fee
movl %eax, %ebp
movq 0x68(%rsp), %rdi
cmpq %r12, %rdi
je 0x10e4f
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x52c0
testb %bpl, %bpl
jne 0x10f93
addq $0x20, %r13
cmpq %rbx, %r13
jne 0x10e13
movq (%rsp), %rax
movq 0x40(%rax), %r13
movq 0x48(%rax), %rbx
cmpq %rbx, %r13
je 0x10eca
leaq 0x58(%rsp), %r12
leaq 0x48(%rsp), %r15
movq %r12, 0x48(%rsp)
movq (%r13), %rsi
movq 0x8(%r13), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x1e780
movq %r14, %rdi
movq %r15, %rsi
callq 0x1111a
movl %eax, %ebp
movq 0x48(%rsp), %rdi
cmpq %r12, %rdi
je 0x10eb8
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x52c0
testb %bpl, %bpl
jne 0x10f93
addq $0x20, %r13
cmpq %rbx, %r13
jne 0x10e7c
movq 0x28(%r14), %r13
movq 0x30(%r14), %rbx
cmpq %rbx, %r13
je 0x10f2c
leaq 0x38(%rsp), %r12
leaq 0x28(%rsp), %r15
movq %r12, 0x28(%rsp)
movq (%r13), %rsi
movq 0x8(%r13), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x1e780
movq (%rsp), %rdi
movq %r15, %rsi
callq 0x10fee
movl %eax, %ebp
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x10f1e
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x52c0
testb %bpl, %bpl
jne 0x10f93
addq $0x20, %r13
cmpq %rbx, %r13
jne 0x10ee1
movq 0x40(%r14), %rbx
movq 0x48(%r14), %r15
cmpq %r15, %rbx
je 0x10faa
leaq 0x18(%rsp), %r12
leaq 0x8(%rsp), %r14
movq (%rsp), %r13
movq %r12, 0x8(%rsp)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
movq %r14, %rdi
callq 0x1e780
movq %r13, %rdi
movq %r14, %rsi
callq 0x1111a
movl %eax, %ebp
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x10f82
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x52c0
addq $0x20, %rbx
cmpq %r15, %rbx
sete %al
orb %bpl, %al
je 0x10f47
jmp 0x10f96
movb $0x1, %bpl
movl %ebp, %eax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %ebp, %ebp
jmp 0x10f96
movq %rax, %rbx
movq 0x28(%rsp), %rdi
jmp 0x10fd4
movq %rax, %rbx
movq 0x8(%rsp), %rdi
jmp 0x10fd4
movq %rax, %rbx
movq 0x48(%rsp), %rdi
jmp 0x10fd4
movq %rax, %rbx
movq 0x68(%rsp), %rdi
cmpq %r12, %rdi
je 0x10fe5
movq (%r12), %rsi
incq %rsi
callq 0x52c0
movq %rbx, %rdi
callq 0x5510
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1105b
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 0x1e780
movq (%r15), %rdi
movq 0x8(%r15), %rsi
addq %rdi, %rsi
movq %rdi, %rdx
callq 0x1152b
leaq 0x30(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rsp), %rax
cmpq %r12, %rax
je 0x11071
movq %rax, 0x20(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x1107b
leaq 0x30(%r14), %r15
movq 0x28(%r14), %rdi
movq 0x30(%r14), %rsi
movq %rbx, %rdx
callq 0x1182b
jmp 0x110e5
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 0x110bb
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x52c0
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x110d1
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x52c0
leaq 0x30(%r14), %r15
movq 0x28(%r14), %rdi
movq 0x30(%r14), %rsi
movq %rbx, %rdx
callq 0x115a7
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 0x11112
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x52c0
movq %rbx, %rdi
callq 0x5510
// File: /workspace/github_cpp_makefile_star2_O3/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 0x12423
movq (%r14), %rdi
cmpq %rbx, %rdi
je 0x1241d
movq %rbx, %rsi
callq 0x10de4
testb %al, %al
jne 0x12431
addq $0x8, %r14
jmp 0x12404
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 0xd604
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xf4fa
xorl %ebp, %ebp
leaq 0x1d192(%rip), %rsi     # 0x2f600
leaq 0x9513(%rip), %rdx      # 0x1b988
movq %rbx, %rdi
callq 0x54d0
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1249b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x52c0
testb %bpl, %bpl
jne 0x124a5
jmp 0x124ad
movq %rax, %r14
movq %rbx, %rdi
callq 0x5230
movq %r14, %rdi
callq 0x5510
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x124fb
movq (%r14), %rdi
cmpq %rbx, %rdi
je 0x124f5
movq %rbx, %rsi
callq 0x10de4
testb %al, %al
jne 0x12509
addq $0x8, %r14
jmp 0x124dc
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 0xd604
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xf4fa
xorl %ebp, %ebp
leaq 0x1d0ba(%rip), %rsi     # 0x2f600
leaq 0x943b(%rip), %rdx      # 0x1b988
movq %rbx, %rdi
callq 0x54d0
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x12573
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x52c0
testb %bpl, %bpl
jne 0x1257d
jmp 0x12585
movq %rax, %r14
movq %rbx, %rdi
callq 0x5230
movq %r14, %rdi
callq 0x5510
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x125c1
movl $0x1, %ecx
testl %eax, %eax
jns 0x125c1
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 0x125e2
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 0xd604
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x1265c
xorl %ebp, %ebp
leaq 0x1cfc3(%rip), %rsi     # 0x2f5d8
leaq 0x936c(%rip), %rdx      # 0x1b988
movq %rbx, %rdi
callq 0x54d0
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x12642
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x52c0
testb %bpl, %bpl
jne 0x1264c
jmp 0x12654
movq %rax, %r14
movq %rbx, %rdi
callq 0x5230
movq %r14, %rdi
callq 0x5510
// File: /workspace/github_cpp_makefile_star2_O3/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 0x12bd2
movq %rbx, %rdi
callq 0x12dc0
movq $0x1, 0x180(%rbx)
movq %rbx, %rdi
callq 0x12e54
movq $0x0, 0x180(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x12f2e
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x12fe6
// File: /workspace/github_cpp_makefile_star2_O3/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 0x13078
movq 0x140(%rbx), %rax
cmpq %rax, 0x148(%rbx)
je 0x12dfd
movq %rax, 0x148(%rbx)
movq 0x98(%rbx), %r14
movq 0xa0(%rbx), %r15
cmpq %r15, %r14
je 0x12e2c
movq (%r14), %rdi
movq 0x1a8(%rdi), %rsi
addq $0x1a8, %rdi            # imm = 0x1A8
callq 0x130ca
addq $0x8, %r14
jmp 0x12e0b
movq 0x158(%rbx), %r14
movq 0x160(%rbx), %rbx
cmpq %rbx, %r14
je 0x12e4d
movq (%r14), %rdi
callq 0x12dc0
addq $0x8, %r14
jmp 0x12e3a
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x131ab
cmpq $0x2, %rax
jge 0x12ea6
movq 0x158(%r14), %rbx
movq 0x160(%r14), %r14
cmpq %r14, %rbx
je 0x12e9b
movq (%rbx), %rdi
callq 0x12e54
addq $0x8, %rbx
jmp 0x12e88
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 0x1e780
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x1311c
xorl %ebp, %ebp
leaq 0x1c82e(%rip), %rsi     # 0x2f718
leaq 0x8a97(%rip), %rdx      # 0x1b988
movq %rbx, %rdi
callq 0x54d0
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x12f13
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x52c0
testb %bpl, %bpl
jne 0x12f1d
jmp 0x12f25
movq %rax, %r14
movq %rbx, %rdi
callq 0x5230
movq %r14, %rdi
callq 0x5510
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x50, %rsp
movq %rsi, %rbx
movq %rdi, %r14
incq 0x180(%rdi)
movb $0x0, 0xf(%rsp)
movq (%rsi), %rax
cmpq 0x8(%rsi), %rax
je 0x12f6e
leaq 0xf(%rsp), %r15
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x13492
movq (%rbx), %rax
cmpq 0x8(%rbx), %rax
jne 0x12f57
cmpq $0x0, 0x178(%r14)
jne 0x12fdb
movq %r14, %rdi
callq 0x13560
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1358e
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x13698
movq 0x10(%rbx), %rax
movaps (%r15), %xmm0
movq 0x10(%r15), %rcx
movq %rcx, 0x10(%rbx)
movups (%rbx), %xmm1
movups %xmm0, (%rbx)
leaq 0x30(%rsp), %rdi
movaps %xmm1, (%rdi)
movq %rax, 0x10(%rdi)
xorps %xmm0, %xmm0
movaps %xmm0, (%r15)
movq $0x0, 0x10(%r15)
callq 0x714a
movq %r15, %rdi
callq 0x714a
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x13004
leaq 0x50(%rbx), %rdi
callq *0x68(%rbx)
addq $0x140, %rbx            # imm = 0x140
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1b678
movq (%r14), %rbx
movq 0x8(%r14), %r14
cmpq %r14, %rbx
je 0x1303a
movq (%rbx), %rdi
callq 0x12fe6
addq $0x8, %rbx
cmpq %r14, %rbx
jne 0x13025
movq (%rsp), %rbx
testq %rbx, %rbx
je 0x1304f
movq 0x10(%rsp), %rsi
subq %rbx, %rsi
movq %rbx, %rdi
callq 0x52c0
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x13070
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x52c0
movq %rbx, %rdi
callq 0x5510
// File: /workspace/github_cpp_makefile_star2_O3/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, %r14
movq %rdi, %r15
cmpb $0x0, (%rdx)
je 0x134ba
movq %r15, %rdi
movq %r14, %rsi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x147f0
movq %rdx, %rbx
movq 0x8(%r14), %rsi
addq $-0x20, %rsi
movq %r15, %rdi
callq 0x13782
movl %eax, 0xc(%rsp)
cmpl $0x5, %eax
ja 0x13541
movl %eax, %ecx
leaq 0xfb41(%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 0x13b8e
addq $0x110, %r15            # imm = 0x110
movq 0x8(%r14), %rdx
addq $-0x20, %rdx
leaq 0xc(%rsp), %rsi
movq %r15, %rdi
callq 0x138b2
movq 0x8(%r14), %rax
leaq -0x20(%rax), %rcx
movq %rcx, 0x8(%r14)
movq -0x20(%rax), %rdi
addq $-0x10, %rax
cmpq %rax, %rdi
je 0x1353e
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 0x13906
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x16a1a
movq %rbx, %rdi
callq 0x16ae4
movq %rbx, %rdi
callq 0x16cb2
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x16d1c
movq %rbx, %rdi
popq %rbx
jmp 0x16e0a