LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
addq $0x8, %rdi
callq 0x66e0
testb $0x1, %al
jne 0xa2ca
jmp 0xa2de
movq -0x50(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
addq $0x8, %rdi
callq 0x65e0
leaq -0x30(%rbp), %rdi
callq 0x15e10
movl -0xc(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jle 0xa331
movq -0x18(%rbp), %rax
movslq -0x34(%rbp), %rcx
leaq (%rax,%rcx,8), %rsi
leaq -0x30(%rbp), %rdi
callq 0x22840
jmp 0xa30d
jmp 0xa30f
movl -0x34(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0xa2f0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x8710
jmp 0xa34f
movq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x228c0
jmp 0xa340
leaq -0x30(%rbp), %rdi
callq 0x8710
addq $0x50, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x6750
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0xf0(%rbp)
movq %rdi, %rax
movq %rax, -0xe8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xe0(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0xd8(%rbp)
leaq -0x50(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
leaq -0x51(%rbp), %rsi
callq 0x31660
movq -0xd8(%rbp), %rsi
movq -0xd0(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0x82e0
jmp 0xacdb
leaq -0x50(%rbp), %rdi
callq 0x85a0
leaq -0x30(%rbp), %rdi
callq 0x30990
testb $0x1, %al
jne 0xacf3
jmp 0xad25
movq -0xf0(%rbp), %rdi
callq 0x65f0
movl $0x1, -0x68(%rbp)
jmp 0xae58
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x85a0
jmp 0xae71
leaq -0xa9(%rbp), %rdi
movq %rdi, -0xf8(%rbp)
callq 0x6770
movq -0xf8(%rbp), %rdx
leaq 0x36c26(%rip), %rsi     # 0x4196c
leaq -0xa8(%rbp), %rdi
callq 0x8eb0
jmp 0xad54
movq -0xe0(%rbp), %rsi
leaq -0x88(%rbp), %rdi
leaq -0xa8(%rbp), %rdx
callq 0x316f0
jmp 0xad70
leaq -0xc8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x309d0
jmp 0xad82
movq -0xe0(%rbp), %rsi
movq -0xf0(%rbp), %rdi
movq (%rsi), %rax
movq 0x18(%rax), %rax
leaq -0x88(%rbp), %rdx
movl $0x1, %ecx
leaq -0xc8(%rbp), %r8
callq *%rax
jmp 0xadae
leaq -0xc8(%rbp), %rdi
callq 0x9110
leaq -0x88(%rbp), %rdi
callq 0x6280
leaq -0xa8(%rbp), %rdi
callq 0x6280
leaq -0xa9(%rbp), %rdi
callq 0x6460
movl $0x1, -0x68(%rbp)
jmp 0xae58
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0xae41
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0xae35
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0xae29
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0xc8(%rbp), %rdi
callq 0x9110
leaq -0x88(%rbp), %rdi
callq 0x6280
leaq -0xa8(%rbp), %rdi
callq 0x6280
leaq -0xa9(%rbp), %rdi
callq 0x6460
leaq -0x30(%rbp), %rdi
callq 0x9110
jmp 0xae71
leaq -0x30(%rbp), %rdi
callq 0x9110
movq -0xe8(%rbp), %rax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x6750
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x32cf0
leaq -0x38(%rbp), %rdi
callq 0x66e0
testb $0x1, %al
jne 0xbca6
movq -0x60(%rbp), %rdi
leaq 0x35cfd(%rip), %rdx     # 0x41981
leaq -0x38(%rbp), %rsi
callq 0x21520
jmp 0xbc8f
movl $0x1, -0x48(%rbp)
jmp 0xbcf2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0xbd05
leaq -0x49(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x6770
movq -0x60(%rbp), %rdi
movq -0x68(%rbp), %rdx
leaq 0x35cc0(%rip), %rsi     # 0x41982
callq 0x8eb0
jmp 0xbcc9
leaq -0x49(%rbp), %rdi
callq 0x6460
movl $0x1, -0x48(%rbp)
jmp 0xbcf2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x49(%rbp), %rdi
callq 0x6460
jmp 0xbd05
leaq -0x38(%rbp), %rdi
callq 0x6280
movq -0x58(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
leaq -0x38(%rbp), %rdi
callq 0x6280
movq -0x40(%rbp), %rdi
callq 0x6750
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x32ab0
leaq -0x38(%rbp), %rdi
callq 0x66e0
testb $0x1, %al
jne 0xbd86
movq -0x60(%rbp), %rdi
leaq 0x35c1d(%rip), %rdx     # 0x41981
leaq -0x38(%rbp), %rsi
callq 0x21520
jmp 0xbd6f
movl $0x1, -0x48(%rbp)
jmp 0xbdd2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0xbde5
leaq -0x49(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x6770
movq -0x60(%rbp), %rdi
movq -0x68(%rbp), %rdx
leaq 0x35be0(%rip), %rsi     # 0x41982
callq 0x8eb0
jmp 0xbda9
leaq -0x49(%rbp), %rdi
callq 0x6460
movl $0x1, -0x48(%rbp)
jmp 0xbdd2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x49(%rbp), %rdi
callq 0x6460
jmp 0xbde5
leaq -0x38(%rbp), %rdi
callq 0x6280
movq -0x58(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
leaq -0x38(%rbp), %rdi
callq 0x6280
movq -0x40(%rbp), %rdi
callq 0x6750
nopw (%rax,%rax)
// File: meirdev[P]HexViewer/./CLI11.hpp
// Function: CLI::Formatter::make_option[abi:cxx11](CLI::Option const*, bool) const
virtual std::string make_option(const Option *opt, bool is_positional) const {
        std::stringstream out;
        detail::format_help(
            out, make_option_name(opt, is_positional) + make_option_opts(opt), make_option_desc(opt), column_width_);
        return out.str();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x260, %rsp            # imm = 0x260
movq %rdi, -0x258(%rbp)
movb %cl, %al
movq %rdi, %rcx
movq %rcx, -0x250(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x248(%rbp)
leaq -0x1a8(%rbp), %rdi
callq 0x62e0
movq -0x248(%rbp), %rsi
leaq -0x198(%rbp), %rax
movq %rax, -0x240(%rbp)
movq -0x18(%rbp), %rdx
movq (%rsi), %rax
movq 0x60(%rax), %rax
movzbl -0x19(%rbp), %ecx
andl $0x1, %ecx
leaq -0x1e8(%rbp), %rdi
callq *%rax
jmp 0xc818
movq -0x248(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq (%rsi), %rax
movq 0x68(%rax), %rax
leaq -0x218(%rbp), %rdi
callq *%rax
jmp 0xc835
leaq -0x1c8(%rbp), %rdi
leaq -0x1e8(%rbp), %rsi
leaq -0x218(%rbp), %rdx
callq 0x125c0
jmp 0xc851
movq -0x248(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq (%rsi), %rax
movq 0x70(%rax), %rax
leaq -0x238(%rbp), %rdi
callq *%rax
jmp 0xc86e
movq -0x240(%rbp), %rdi
movq -0x248(%rbp), %rax
movq 0x8(%rax), %rcx
leaq -0x1c8(%rbp), %rsi
leaq -0x238(%rbp), %rdx
callq 0x329a0
jmp 0xc895
leaq -0x238(%rbp), %rdi
callq 0x6280
leaq -0x1c8(%rbp), %rdi
callq 0x6280
leaq -0x218(%rbp), %rdi
callq 0x6280
leaq -0x1e8(%rbp), %rdi
callq 0x6280
movq -0x258(%rbp), %rdi
leaq -0x1a8(%rbp), %rsi
callq 0x63c0
jmp 0xc8da
leaq -0x1a8(%rbp), %rdi
callq 0x6320
movq -0x250(%rbp), %rax
addq $0x260, %rsp            # imm = 0x260
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1f0(%rbp)
movl %eax, -0x1f4(%rbp)
jmp 0xc988
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1f0(%rbp)
movl %eax, -0x1f4(%rbp)
jmp 0xc97c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1f0(%rbp)
movl %eax, -0x1f4(%rbp)
jmp 0xc970
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1f0(%rbp)
movl %eax, -0x1f4(%rbp)
jmp 0xc964
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1f0(%rbp)
movl %eax, -0x1f4(%rbp)
leaq -0x238(%rbp), %rdi
callq 0x6280
leaq -0x1c8(%rbp), %rdi
callq 0x6280
leaq -0x218(%rbp), %rdi
callq 0x6280
leaq -0x1e8(%rbp), %rdi
callq 0x6280
leaq -0x1a8(%rbp), %rdi
callq 0x6320
movq -0x1f0(%rbp), %rdi
callq 0x6750
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x30(%rbp)
movb %cl, %al
movq %rdi, %rcx
movq %rcx, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
je 0xc9e2
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x14b70
jmp 0xc9f6
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %edx, %edx
movl $0x1, %ecx
callq 0x14b70
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rsi, -0x80(%rbp)
movq %rdx, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
cmpq $0x0, 0xd0(%rax)
je 0x14480
movq -0x70(%rbp), %rdi
movq 0xd0(%rdi), %rsi
callq 0x17730
movq -0x70(%rbp), %rax
movq $0x0, 0xd0(%rax)
movq -0x80(%rbp), %rdi
callq 0x66e0
testb $0x1, %al
jne 0x1452d
movq -0x80(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x61d0
movq -0x78(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0x61d0
jmp 0x144ad
movq -0x70(%rbp), %rdi
leaq -0x38(%rbp), %rsi
leaq -0x58(%rbp), %rdx
callq 0x178c0
movq %rax, -0x88(%rbp)
jmp 0x144c7
movq -0x70(%rbp), %rax
movq -0x88(%rbp), %rcx
movq %rcx, 0xd0(%rax)
leaq -0x58(%rbp), %rdi
callq 0x6280
leaq -0x38(%rbp), %rdi
callq 0x6280
movq -0x70(%rbp), %rax
movq 0xd0(%rax), %rdi
xorl %esi, %esi
callq 0x17b00
jmp 0x1452d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x14522
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x6280
leaq -0x38(%rbp), %rdi
callq 0x6280
jmp 0x14541
movq -0x70(%rbp), %rax
movq 0xd0(%rax), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x6750
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rsi, -0x80(%rbp)
movq %rdx, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
cmpq $0x0, 0xd8(%rax)
je 0x15070
movq -0x70(%rbp), %rdi
movq 0xd8(%rdi), %rsi
callq 0x17730
movq -0x70(%rbp), %rax
movq $0x0, 0xd8(%rax)
movq -0x80(%rbp), %rdi
callq 0x66e0
testb $0x1, %al
jne 0x1511d
movq -0x80(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x61d0
movq -0x78(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0x61d0
jmp 0x1509d
movq -0x70(%rbp), %rdi
leaq -0x38(%rbp), %rsi
leaq -0x58(%rbp), %rdx
callq 0x178c0
movq %rax, -0x88(%rbp)
jmp 0x150b7
movq -0x70(%rbp), %rax
movq -0x88(%rbp), %rcx
movq %rcx, 0xd8(%rax)
leaq -0x58(%rbp), %rdi
callq 0x6280
leaq -0x38(%rbp), %rdi
callq 0x6280
movq -0x70(%rbp), %rax
movq 0xd8(%rax), %rdi
xorl %esi, %esi
callq 0x17b00
jmp 0x1511d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x15112
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x6280
leaq -0x38(%rbp), %rdi
callq 0x6280
jmp 0x15131
movq -0x70(%rbp), %rax
movq 0xd8(%rax), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x6750
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x1e0, %rsp            # imm = 0x1E0
movq %rdx, -0x1e0(%rbp)
movq %rdi, -0x1d8(%rbp)
movq %rdi, %rax
movq %rax, -0x1d0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x190(%rbp), %rdi
callq 0x65c0
movq $0x0, -0x198(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1a0(%rbp)
movq -0x1a0(%rbp), %rdi
callq 0x117f0
movq %rax, -0x1a8(%rbp)
movq -0x1a0(%rbp), %rdi
callq 0x11820
movq %rax, -0x1b0(%rbp)
leaq -0x1a8(%rbp), %rdi
leaq -0x1b0(%rbp), %rsi
callq 0x11bd0
testb $0x1, %al
jne 0x15f83
jmp 0x16010
leaq -0x1a8(%rbp), %rdi
callq 0x11c40
movq %rax, -0x1b8(%rbp)
movq -0x198(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x198(%rbp)
cmpq $0x0, %rax
jbe 0x15fe8
movq -0x1e0(%rbp), %rsi
leaq -0x190(%rbp), %rdi
callq 0x6390
jmp 0x15fc6
jmp 0x15fe8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c0(%rbp)
movl %eax, -0x1c4(%rbp)
leaq -0x190(%rbp), %rdi
callq 0x60e0
jmp 0x16041
movq -0x1b8(%rbp), %rsi
leaq -0x190(%rbp), %rdi
callq 0x6390
jmp 0x15ffd
jmp 0x15fff
leaq -0x1a8(%rbp), %rdi
callq 0x11c60
jmp 0x15f67
movq -0x1d8(%rbp), %rdi
leaq -0x190(%rbp), %rsi
callq 0x6410
jmp 0x16025
leaq -0x190(%rbp), %rdi
callq 0x60e0
movq -0x1d0(%rbp), %rax
addq $0x1e0, %rsp            # imm = 0x1E0
popq %rbp
retq
movq -0x1c0(%rbp), %rdi
callq 0x6750
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
addq $0x98, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x17b20
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x17b50
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x17b80
testb $0x1, %al
jne 0x17782
jmp 0x177c4
leaq -0x28(%rbp), %rdi
callq 0x17bc0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x17be0
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x17c00
movq -0x38(%rbp), %rdi
callq 0x17be0
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x17cb0
leaq -0x28(%rbp), %rdi
callq 0x17d60
jmp 0x1776f
movq -0x78(%rbp), %rax
movq 0xd0(%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0x177e4
movq -0x78(%rbp), %rax
movq $0x0, 0xd0(%rax)
movq -0x78(%rbp), %rax
movq 0xd8(%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0x17804
movq -0x78(%rbp), %rax
movq $0x0, 0xd8(%rax)
movq -0x78(%rbp), %rdi
addq $0x98, %rdi
callq 0x17de0
movq -0x78(%rbp), %rdi
movq %rax, -0x48(%rbp)
addq $0x98, %rdi
callq 0x17e10
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x48(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq -0x58(%rbp), %rdx
callq 0x17d80
movq -0x78(%rbp), %rdi
movq %rax, -0x40(%rbp)
addq $0x98, %rdi
callq 0x17e10
movq %rax, -0x60(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x17b80
testb $0x1, %al
jne 0x17870
jmp 0x178a2
movq -0x78(%rbp), %rax
addq $0x98, %rax
movq %rax, -0x80(%rbp)
leaq -0x68(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x17eb0
movq -0x80(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0x17e40
movq %rax, -0x70(%rbp)
movb $0x1, -0x1(%rbp)
jmp 0x178a6
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rsi, -0xe8(%rbp)
movq %rdx, -0xf8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xf0(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x39(%rbp), %rsi
callq 0x19640
movq -0xe8(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x61d0
jmp 0x1790f
leaq -0x98(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x19b90
jmp 0x17921
movq -0xf8(%rbp), %rsi
leaq -0xb8(%rbp), %rdi
callq 0x61d0
jmp 0x17936
movq -0xf0(%rbp), %rdi
leaq -0x68(%rbp), %rsi
leaq -0x98(%rbp), %rdx
leaq -0xb8(%rbp), %rcx
xorl %r8d, %r8d
callq 0x196d0
movq %rax, -0x100(%rbp)
jmp 0x17960
leaq -0xb8(%rbp), %rdi
callq 0x6280
leaq -0x98(%rbp), %rdi
callq 0x190f0
leaq -0x68(%rbp), %rdi
callq 0x6280
movq -0x100(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
callq 0x19c40
movb %al, -0x101(%rbp)
jmp 0x1799d
movb -0x101(%rbp), %al
testb $0x1, %al
jne 0x179ac
jmp 0x17aaf
movb $0x1, -0xd9(%rbp)
movl $0x38, %edi
callq 0x6200
movq -0xe8(%rbp), %rsi
movq %rax, -0x110(%rbp)
leaq -0xd8(%rbp), %rdi
callq 0x61d0
jmp 0x179d9
movq -0x110(%rbp), %rdi
leaq -0xd8(%rbp), %rsi
callq 0x19c70
jmp 0x179ee
movq -0x110(%rbp), %rdi
movb $0x0, -0xd9(%rbp)
leaq 0x45b75(%rip), %rsi     # 0x5d578
leaq 0x22d6(%rip), %rdx      # 0x19ce0
callq 0x6700
jmp 0x17af2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x17ae0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x17a65
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x17a59
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0xb8(%rbp), %rdi
callq 0x6280
leaq -0x98(%rbp), %rdi
callq 0x190f0
leaq -0x68(%rbp), %rdi
callq 0x6280
jmp 0x17ae0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x17a96
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0xd8(%rbp), %rdi
callq 0x6280
testb $0x1, -0xd9(%rbp)
jne 0x17aa1
jmp 0x17aad
movq -0x110(%rbp), %rdi
callq 0x6310
jmp 0x17ae0
movq -0x48(%rbp), %rdi
xorl %esi, %esi
callq 0x19d00
jmp 0x17abc
movq -0x48(%rbp), %rax
movq %rax, -0x118(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x190f0
movq -0x118(%rbp), %rax
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
leaq -0x38(%rbp), %rdi
callq 0x190f0
movq -0x70(%rbp), %rdi
callq 0x6750
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x50(%rbp)
addq $0x120, %rdi            # imm = 0x120
callq 0x17f70
movq -0x50(%rbp), %rdi
movq %rax, -0x28(%rbp)
addq $0x120, %rdi            # imm = 0x120
callq 0x17fa0
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0x17f20
movq -0x50(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x120, %rdi            # imm = 0x120
callq 0x17fa0
movq %rax, -0x38(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x17fd0
testb $0x1, %al
jne 0x17c78
jmp 0x17c9e
movq -0x50(%rbp), %rdi
addq $0x120, %rdi            # imm = 0x120
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rsi
callq 0x18000
movq %rax, -0x48(%rbp)
movb $0x1, -0x1(%rbp)
jmp 0x17ca2
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x50(%rbp)
addq $0x150, %rdi            # imm = 0x150
callq 0x17f70
movq -0x50(%rbp), %rdi
movq %rax, -0x28(%rbp)
addq $0x150, %rdi            # imm = 0x150
callq 0x17fa0
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0x17f20
movq -0x50(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x150, %rdi            # imm = 0x150
callq 0x17fa0
movq %rax, -0x38(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x17fd0
testb $0x1, %al
jne 0x17d28
jmp 0x17d4e
movq -0x50(%rbp), %rdi
addq $0x150, %rdi            # imm = 0x150
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rsi
callq 0x18000
movq %rax, -0x48(%rbp)
movb $0x1, -0x1(%rbp)
jmp 0x17d52
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: meirdev[P]HexViewer/./CLI11.hpp
// Function: CLI::Option::type_size(int)
Option *type_size(int option_type_size) {
        type_size_ = option_type_size;
        if(type_size_ == 0)
            required_ = false;
        if(option_type_size < 0)
            expected_ = -1;
        return this;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %ecx
movl %ecx, 0xfc(%rax)
cmpl $0x0, 0xfc(%rax)
jne 0x19d2d
movq -0x18(%rbp), %rax
movb $0x0, 0x20(%rax)
cmpl $0x0, -0xc(%rbp)
jge 0x19d41
movq -0x18(%rbp), %rax
movl $0xffffffff, 0x100(%rax) # imm = 0xFFFFFFFF
movq -0x18(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x58(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x61d0
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x210d0
jmp 0x1a70c
leaq -0x30(%rbp), %rdi
callq 0x6280
movq -0x58(%rbp), %rax
movq -0x10(%rbp), %rdi
movb 0x20(%rax), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x9c10
movq -0x58(%rbp), %rax
movq -0x10(%rbp), %rdi
movb 0x21(%rax), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x21100
movq -0x58(%rbp), %rax
movq -0x10(%rbp), %rdi
movb 0x22(%rax), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x21270
movq -0x58(%rbp), %rax
movq -0x10(%rbp), %rdi
movb 0x23(%rax), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x17b00
movq -0x58(%rbp), %rax
movq -0x10(%rbp), %rdi
movl 0x24(%rax), %esi
callq 0x213e0
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x6280
movq -0x38(%rbp), %rdi
callq 0x6750
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rsi, -0xc8(%rbp)
movq %rdi, -0xc0(%rbp)
movq %rdi, %rax
movq %rax, -0xb8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x15e10
movq -0xc8(%rbp), %rdi
leaq 0x261f8(%rip), %rsi     # 0x4144a
xorl %eax, %eax
movl %eax, %edx
callq 0x6800
movq %rax, -0x20(%rbp)
cmpq $-0x1, %rax
je 0x1b33c
movq -0xc8(%rbp), %rsi
movq -0x20(%rbp), %rcx
xorl %eax, %eax
movl %eax, %edx
leaq -0x60(%rbp), %rdi
callq 0x6420
jmp 0x1b283
leaq -0x40(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x1cca0
jmp 0x1b292
movq -0xc0(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x15e50
jmp 0x1b2a4
leaq -0x40(%rbp), %rdi
callq 0x6280
leaq -0x60(%rbp), %rdi
callq 0x6280
movq -0xc8(%rbp), %rsi
movq -0x20(%rbp), %rdx
incq %rdx
leaq -0x90(%rbp), %rdi
movq $-0x1, %rcx
callq 0x6420
jmp 0x1b2d9
movq -0xc8(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x6520
leaq -0x90(%rbp), %rdi
callq 0x6280
jmp 0x1b244
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x1b3b4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x1b331
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x6280
leaq -0x60(%rbp), %rdi
callq 0x6280
jmp 0x1b3b4
movq -0xc8(%rbp), %rsi
leaq -0xb0(%rbp), %rdi
callq 0x1cca0
jmp 0x1b351
movq -0xc0(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
callq 0x15e50
jmp 0x1b366
leaq -0xb0(%rbp), %rdi
callq 0x6280
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x1b3a4
jmp 0x1b398
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x6280
jmp 0x1b3b4
movq -0xc0(%rbp), %rdi
callq 0x8710
movq -0xb8(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
movq -0xc0(%rbp), %rdi
callq 0x8710
movq -0x68(%rbp), %rdi
callq 0x6750
nopl (%rax)
// File: meirdev[P]HexViewer/./CLI11.hpp
// Function: CLI::detail::valid_name_string(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline bool valid_name_string(const std::string &str) {
    if(str.empty() || !valid_first_char(str[0]))
        return false;
    for(auto c : str.substr(1))
        if(!valid_later_char(c))
            return false;
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x66e0
testb $0x1, %al
jne 0x1be92
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x6480
movsbl (%rax), %edi
callq 0x1bc80
testb $0x1, %al
jne 0x1be9b
movb $0x0, -0x1(%rbp)
jmp 0x1bf5d
movq -0x10(%rbp), %rsi
leaq -0x38(%rbp), %rdi
movl $0x1, %edx
movq $-0x1, %rcx
callq 0x6420
leaq -0x38(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6370
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6240
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x1c900
testb $0x1, %al
jne 0x1bef0
movl $0x2, -0x4c(%rbp)
jmp 0x1bf46
leaq -0x40(%rbp), %rdi
callq 0x1c940
movb (%rax), %al
movb %al, -0x4d(%rbp)
movsbl -0x4d(%rbp), %edi
callq 0x1c960
movb %al, -0x5d(%rbp)
jmp 0x1bf0c
movb -0x5d(%rbp), %al
testb $0x1, %al
jne 0x1bf39
jmp 0x1bf15
movb $0x0, -0x1(%rbp)
movl $0x1, -0x4c(%rbp)
jmp 0x1bf46
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x6280
jmp 0x1bf68
jmp 0x1bf3b
leaq -0x40(%rbp), %rdi
callq 0x1ca10
jmp 0x1bed6
leaq -0x38(%rbp), %rdi
callq 0x6280
movl -0x4c(%rbp), %eax
subl $0x1, %eax
je 0x1bf5d
jmp 0x1bf59
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x6750
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rsi, -0xc0(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xb8(%rbp)
testb $0x1, 0x21(%rax)
je 0x1e616
movq -0xc0(%rbp), %rsi
leaq -0x58(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0x61d0
movq -0xc8(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x1eae0
jmp 0x1e558
movq -0xc0(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x6520
leaq -0x38(%rbp), %rdi
callq 0x6280
leaq -0x58(%rbp), %rdi
callq 0x6280
movq -0xb8(%rbp), %rdi
addq $0x28, %rdi
callq 0x1ebc0
movq -0xb8(%rbp), %rdi
movq %rax, -0x78(%rbp)
addq $0x28, %rdi
callq 0x1ebf0
movq %rax, %rcx
movq -0xc0(%rbp), %rax
movq %rcx, -0x80(%rbp)
movq %rax, -0x88(%rbp)
movq -0x78(%rbp), %rdi
movq -0x80(%rbp), %rsi
movq -0x88(%rbp), %rdx
callq 0x1eb60
movq -0xb8(%rbp), %rdi
movq %rax, -0x70(%rbp)
addq $0x28, %rdi
callq 0x1ebf0
movq %rax, -0x90(%rbp)
leaq -0x70(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x11bd0
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x1e694
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x6280
jmp 0x1e6a2
movq -0xb8(%rbp), %rdi
addq $0x28, %rdi
callq 0x1ebc0
movq -0xb8(%rbp), %rdi
movq %rax, -0xa0(%rbp)
addq $0x28, %rdi
callq 0x1ebf0
movq -0xc0(%rbp), %rdx
movq %rax, -0xa8(%rbp)
movq -0xa0(%rbp), %rdi
movq -0xa8(%rbp), %rsi
callq 0x1ec20
movq -0xb8(%rbp), %rdi
movq %rax, -0x98(%rbp)
addq $0x28, %rdi
callq 0x1ebf0
movq %rax, -0xb0(%rbp)
leaq -0x98(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
callq 0x11bd0
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xd0, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x6750
nopl (%rax,%rax)
// File: meirdev[P]HexViewer/./CLI11.hpp
// Function: CLI::detail::to_lower(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)::'lambda'(char const&)::operator()(char const&) const
inline std::string to_lower(std::string str) {
    std::transform(std::begin(str), std::end(str), std::begin(str), [](const std::string::value_type &x) {
        return std::tolower(x, std::locale());
    });
    return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0x34(%rbp)
leaq -0x18(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x6850
movl -0x34(%rbp), %edi
movq -0x30(%rbp), %rsi
callq 0x1edc0
movb %al, -0x25(%rbp)
jmp 0x1ed88
leaq -0x18(%rbp), %rdi
callq 0x6600
movb -0x25(%rbp), %al
addq $0x40, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x6600
movq -0x20(%rbp), %rdi
callq 0x6750
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x80, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
movb -0x9(%rbp), %cl
andb $0x1, %cl
movb %cl, 0x21(%rax)
movq 0x180(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x98, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x17b20
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x17b50
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x17b80
testb $0x1, %al
jne 0x21171
jmp 0x21254
leaq -0x28(%rbp), %rdi
callq 0x17bc0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x10a90
movq -0x70(%rbp), %rcx
cmpq %rcx, %rax
je 0x21244
movq -0x38(%rbp), %rdi
callq 0x1e120
movq -0x70(%rbp), %rsi
movq %rax, %rdi
callq 0x1e150
testb $0x1, %al
jne 0x211b2
jmp 0x21244
movb $0x1, -0x65(%rbp)
movl $0x38, %edi
callq 0x6200
movq %rax, -0x78(%rbp)
movq -0x38(%rbp), %rdi
callq 0x17be0
movq %rax, %rsi
leaq -0x58(%rbp), %rdi
movl $0x1, %ecx
movl %ecx, %edx
callq 0x14b70
jmp 0x211e2
movq -0x78(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x1a7a0
jmp 0x211f1
movq -0x78(%rbp), %rdi
movb $0x0, -0x65(%rbp)
leaq 0x3c3a0(%rip), %rsi     # 0x5d5a0
leaq -0x69f7(%rip), %rdx     # 0x1a810
callq 0x6700
jmp 0x2126a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x21231
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x6280
testb $0x1, -0x65(%rbp)
jne 0x21239
jmp 0x21242
movq -0x78(%rbp), %rdi
callq 0x6310
jmp 0x21261
jmp 0x21246
leaq -0x28(%rbp), %rdi
callq 0x17d60
jmp 0x2115b
movq -0x70(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x6750
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x80, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
movb -0x9(%rbp), %cl
andb $0x1, %cl
movb %cl, 0x22(%rax)
movq 0x180(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x98, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x17b20
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x17b50
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x17b80
testb $0x1, %al
jne 0x212e1
jmp 0x213c4
leaq -0x28(%rbp), %rdi
callq 0x17bc0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x10a90
movq -0x70(%rbp), %rcx
cmpq %rcx, %rax
je 0x213b4
movq -0x38(%rbp), %rdi
callq 0x1e120
movq -0x70(%rbp), %rsi
movq %rax, %rdi
callq 0x1e150
testb $0x1, %al
jne 0x21322
jmp 0x213b4
movb $0x1, -0x65(%rbp)
movl $0x38, %edi
callq 0x6200
movq %rax, -0x78(%rbp)
movq -0x38(%rbp), %rdi
callq 0x17be0
movq %rax, %rsi
leaq -0x58(%rbp), %rdi
movl $0x1, %ecx
movl %ecx, %edx
callq 0x14b70
jmp 0x21352
movq -0x78(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x1a7a0
jmp 0x21361
movq -0x78(%rbp), %rdi
movb $0x0, -0x65(%rbp)
leaq 0x3c230(%rip), %rsi     # 0x5d5a0
leaq -0x6b67(%rip), %rdx     # 0x1a810
callq 0x6700
jmp 0x213da
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x213a1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x6280
testb $0x1, -0x65(%rbp)
jne 0x213a9
jmp 0x213b2
movq -0x78(%rbp), %rdi
callq 0x6310
jmp 0x213d1
jmp 0x213b6
leaq -0x28(%rbp), %rdi
callq 0x17d60
jmp 0x212cb
movq -0x70(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x6750
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x8f80
cmpl $0x0, %eax
jge 0x2148c
movb $0x1, -0x3d(%rbp)
movl $0x38, %edi
callq 0x6200
movq -0x48(%rbp), %rsi
movq %rax, -0x50(%rbp)
leaq -0x30(%rbp), %rdi
xorl %ecx, %ecx
movl %ecx, %edx
callq 0x14b70
jmp 0x2142a
movq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x214b0
jmp 0x21439
movq -0x50(%rbp), %rdi
movb $0x0, -0x3d(%rbp)
leaq 0x3c130(%rip), %rsi     # 0x5d578
leaq -0x776f(%rip), %rdx     # 0x19ce0
callq 0x6700
jmp 0x214a5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x21479
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x6280
testb $0x1, -0x3d(%rbp)
jne 0x21481
jmp 0x2148a
movq -0x50(%rbp), %rdi
callq 0x6310
jmp 0x2149c
movq -0x48(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, 0x24(%rax)
addq $0x50, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x6750
nopw %cs:(%rax,%rax)
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, 0x180(%rax)
jbe 0x228eb
movq -0x18(%rbp), %rdi
callq 0x22c20
movq -0x18(%rbp), %rdi
movq $0x1, 0x180(%rdi)
callq 0x22d30
movq -0x18(%rbp), %rdi
movq $0x0, 0x180(%rdi)
movq -0x10(%rbp), %rsi
callq 0x22ea0
movq -0x18(%rbp), %rdi
callq 0x22f50
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
movq $0x0, 0x180(%rdi)
addq $0x110, %rdi            # imm = 0x110
callq 0x23030
movq -0x50(%rbp), %rdi
addq $0x140, %rdi            # imm = 0x140
callq 0x23050
movq -0x50(%rbp), %rax
addq $0x98, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x17b20
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x17b50
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x17b80
testb $0x1, %al
jne 0x22c96
jmp 0x22cbf
leaq -0x18(%rbp), %rdi
callq 0x17bc0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x17be0
movq %rax, %rdi
callq 0x23070
leaq -0x18(%rbp), %rdi
callq 0x17d60
jmp 0x22c83
movq -0x50(%rbp), %rax
addq $0x158, %rax            # imm = 0x158
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x230a0
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0x230d0
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x23100
testb $0x1, %al
jne 0x22cfa
jmp 0x22d23
leaq -0x38(%rbp), %rdi
callq 0x23140
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
callq 0x23160
movq %rax, %rdi
callq 0x22c20
leaq -0x38(%rbp), %rdi
callq 0x23180
jmp 0x22ce7
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x80(%rbp)
addq $0x98, %rdi
callq 0x10090
movq -0x80(%rbp), %rdi
movq %rax, -0x18(%rbp)
addq $0x98, %rdi
callq 0x100c0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x23370
movq %rax, -0x10(%rbp)
cmpq $0x1, -0x10(%rbp)
jle 0x22e1d
movb $0x1, -0x55(%rbp)
movl $0x38, %edi
callq 0x6200
movq -0x80(%rbp), %rsi
movq %rax, -0x88(%rbp)
addq $0x8, %rsi
leaq -0x48(%rbp), %rdi
callq 0x61d0
jmp 0x22daf
movq -0x88(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x233b0
jmp 0x22dc1
movq -0x88(%rbp), %rdi
movb $0x0, -0x55(%rbp)
leaq 0x3a8e5(%rip), %rsi     # 0x5d6b8
leaq 0x646(%rip), %rdx       # 0x23420
callq 0x6700
jmp 0x22e93
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x22e07
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x6280
testb $0x1, -0x55(%rbp)
jne 0x22e0f
jmp 0x22e1b
movq -0x88(%rbp), %rdi
callq 0x6310
jmp 0x22e8a
movq -0x80(%rbp), %rax
addq $0x158, %rax            # imm = 0x158
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rdi
callq 0x13280
movq %rax, -0x68(%rbp)
movq -0x60(%rbp), %rdi
callq 0x132d0
movq %rax, -0x70(%rbp)
leaq -0x68(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x13110
testb $0x1, %al
jne 0x22e58
jmp 0x22e81
leaq -0x68(%rbp), %rdi
callq 0x13170
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rdi
callq 0x23160
movq %rax, %rdi
callq 0x22d30
leaq -0x68(%rbp), %rdi
callq 0x13190
jmp 0x22e45
addq $0x90, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x6750
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq 0x180(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x180(%rax)
movb $0x0, -0x11(%rbp)
movq -0x10(%rbp), %rdi
callq 0x86b0
xorb $-0x1, %al
testb $0x1, %al
jne 0x22edf
jmp 0x22ef2
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x11(%rbp), %rdx
callq 0x237a0
jmp 0x22ece
movq -0x38(%rbp), %rax
cmpq $0x0, 0x178(%rax)
jne 0x22f3b
movq -0x38(%rbp), %rdi
callq 0x23880
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x238d0
movq -0x38(%rbp), %rsi
leaq -0x30(%rbp), %rdi
xorl %edx, %edx
callq 0x23a80
movq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1d9a0
leaq -0x30(%rbp), %rdi
callq 0x8710
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x58(%rbp)
movq (%rdi), %rax
callq *0x10(%rax)
movq -0x58(%rbp), %rdi
addq $0x50, %rdi
callq 0x2fef0
testb $0x1, %al
jne 0x22f7d
jmp 0x22f8a
movq -0x58(%rbp), %rdi
addq $0x50, %rdi
callq 0x2ff10
movq -0x58(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x2e910
leaq -0x28(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x26c80
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x26cd0
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x2ff50
testb $0x1, %al
jne 0x22fd5
leaq -0x28(%rbp), %rdi
callq 0x152a0
jmp 0x23014
leaq -0x30(%rbp), %rdi
callq 0x26c40
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0x22f50
jmp 0x22ff0
jmp 0x22ff2
leaq -0x30(%rbp), %rdi
callq 0x26c20
jmp 0x22fb9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x152a0
jmp 0x2301a
addq $0x60, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x6750
nopw %cs:(%rax,%rax)
nopl (%rax)