LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/meirdev[P]HexViewer/./CLI11.hpp
// Function: CLI::App::check_name(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) const
bool check_name(std::string name_to_check) const {
        std::string local_name = name_;
        if(ignore_underscore_) {
            local_name = detail::remove_underscore(name_);
            name_to_check = detail::remove_underscore(name_to_check);
        }
        if(ignore_case_) {
            local_name = detail::to_lower(name_);
            name_to_check = detail::to_lower(name_to_check);
        }

        return local_name == name_to_check;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x8(%rdi), %r14
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq 0x53f0
cmpb $0x1, 0x171(%r15)
jne 0x103d5
leaq 0xa8(%rsp), %rdi
movq %r14, %rsi
callq 0x53f0
leaq 0x8(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
callq 0xdb38
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %r12
movq %r12, %rsi
callq 0x5360
movq %r12, %rdi
callq 0x5180
leaq 0xa8(%rsp), %rdi
callq 0x5180
leaq 0x88(%rsp), %rdi
movq %rbx, %rsi
callq 0x53f0
leaq 0x8(%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0xdb38
leaq 0x8(%rsp), %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x5360
movq %r12, %rdi
callq 0x5180
leaq 0x88(%rsp), %rdi
callq 0x5180
cmpb $0x1, 0x170(%r15)
jne 0x1045d
leaq 0x68(%rsp), %rdi
movq %r14, %rsi
callq 0x53f0
leaq 0x8(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0xd7ac
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %r14
movq %r14, %rsi
callq 0x5360
movq %r14, %rdi
callq 0x5180
leaq 0x68(%rsp), %rdi
callq 0x5180
leaq 0x48(%rsp), %rdi
movq %rbx, %rsi
callq 0x53f0
leaq 0x8(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0xd7ac
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5360
movq %r14, %rdi
callq 0x5180
leaq 0x48(%rsp), %rdi
callq 0x5180
leaq 0x28(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0xda19
movl %eax, %ebx
movq %r14, %rdi
callq 0x5180
movl %ebx, %eax
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
jmp 0x104ba
jmp 0x104c1
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
jmp 0x104ba
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
jmp 0x104ba
jmp 0x104c1
jmp 0x104c1
movq %rax, %rbx
leaq 0xa8(%rsp), %rdi
callq 0x5180
jmp 0x104c4
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x5180
movq %rbx, %rdi
callq 0x5510
// File: /workspace/github_cpp_makefile_star2_O2/meirdev[P]HexViewer/./CLI11.hpp
// Function: CLI::App::_count_remaining_positionals(bool) const
size_t _count_remaining_positionals(bool required = false) const {
        size_t retval = 0;
        for(const Option_p &opt : options_)
            if(opt->get_positional() && (!required || opt->get_required()) && opt->get_items_expected() > 0 &&
               static_cast<int>(opt->count()) < opt->get_items_expected())
                retval = static_cast<size_t>(opt->get_items_expected()) - opt->count();

        return retval;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %esi, %ebx
movq 0x98(%rdi), %r15
movq 0xa0(%rdi), %r12
xorl %r14d, %r14d
cmpq %r12, %r15
je 0x10788
movq (%r15), %rdi
cmpq $0x0, 0x60(%rdi)
je 0x10782
testb %bl, %bl
je 0x10737
cmpb $0x1, 0x20(%rdi)
jne 0x10782
callq 0x6880
testl %eax, %eax
jle 0x10782
movq (%r15), %rdi
movq 0x1b0(%rdi), %r13
subq 0x1a8(%rdi), %r13
shrq $0x5, %r13
callq 0x6880
cmpl %r13d, %eax
jle 0x10782
movq (%r15), %rdi
callq 0x6880
movslq %eax, %r14
movq (%r15), %rax
movq 0x1b0(%rax), %rcx
subq 0x1a8(%rax), %rcx
sarq $0x5, %rcx
subq %rcx, %r14
addq $0x8, %r15
jmp 0x1071e
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/meirdev[P]HexViewer/./CLI11.hpp
// Function: CLI::App::_process_ini()
void _process_ini() {
        // Process an INI file
        if(config_ptr_ != nullptr) {
            if(*config_ptr_) {
                config_ptr_->run_callback();
                config_required_ = true;
            }
            if(!config_name_.empty()) {
                try {
                    std::vector<ConfigItem> values = config_formatter_->from_file(config_name_);
                    _parse_config(values);
                } catch(const FileError &) {
                    if(config_required_)
                        throw;
                }
            }
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0x1e0(%rdi), %rdi
testq %rdi, %rdi
je 0x114e7
movq 0x1a8(%rdi), %rax
cmpq 0x1b0(%rdi), %rax
je 0x114ae
callq 0x11b96
movb $0x1, 0x1d8(%rbx)
cmpq $0x0, 0x1c0(%rbx)
je 0x114e7
leaq 0x1b8(%rbx), %rdx
movq 0x1e8(%rbx), %rsi
leaq 0x8(%rsp), %rdi
callq 0x12140
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x1221e
leaq 0x8(%rsp), %rdi
callq 0xb138
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rdx, %r15
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0xb138
jmp 0x11509
movq %rdx, %r15
movq %rax, %r14
cmpl $0x1, %r15d
jne 0x11534
movq %r14, %rdi
callq 0x5140
cmpb $0x1, 0x1d8(%rbx)
je 0x11527
callq 0x54d0
jmp 0x114e7
callq 0x5420
movq %rax, %r14
callq 0x54d0
movq %r14, %rdi
callq 0x5510
movq %rax, %rdi
callq 0x7380
// File: /workspace/github_cpp_makefile_star2_O2/meirdev[P]HexViewer/./CLI11.hpp
// Function: CLI::App::_process_callbacks()
void _process_callbacks() {
        for(const Option_p &opt : options_) {
            if(opt->count() > 0 && !opt->get_callback_run()) {
                opt->run_callback();
            }
        }

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x98(%rdi), %r14
movq 0xa0(%rdi), %r15
cmpq %r15, %r14
je 0x116be
movq (%r14), %rdi
movq 0x1b0(%rdi), %rax
cmpq 0x1a8(%rdi), %rax
je 0x116b8
cmpb $0x0, 0x1c0(%rdi)
jne 0x116b8
callq 0x11b96
addq $0x8, %r14
jmp 0x11692
movq 0x158(%rbx), %r14
movq 0x160(%rbx), %rbx
cmpq %rbx, %r14
je 0x116df
movq (%r14), %rdi
callq 0x1167c
addq $0x8, %r14
jmp 0x116cc
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/meirdev[P]HexViewer/./CLI11.hpp
// Function: CLI::Config::from_file(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::vector<ConfigItem> from_file(const std::string &name) {
        std::ifstream input{name};
        if(!input.good())
            throw FileError::Missing(name);

        return from_config(input);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x230, %rsp            # imm = 0x230
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x28(%rsp), %r12
pushq $0x8
popq %rdx
movq %r12, %rdi
movq %r14, %rsi
callq 0x54b0
movq (%r12), %rax
movq -0x18(%rax), %rax
cmpl $0x0, 0x48(%rsp,%rax)
jne 0x121a8
movq (%r15), %rax
leaq 0x28(%rsp), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq *0x8(%rax)
leaq 0x28(%rsp), %rdi
callq 0x50d0
movq %rbx, %rax
addq $0x230, %rsp            # imm = 0x230
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
pushq $0x38
popq %rdi
callq 0x51a0
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x53f0
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x12b5c
xorl %ebp, %ebp
leaq 0x1561f(%rip), %rsi     # 0x277f8
leaq 0x2026(%rip), %rdx      # 0x14206
movq %rbx, %rdi
callq 0x54e0
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x5180
testb %bpl, %bpl
jne 0x121ff
jmp 0x1220c
movq %rax, %r14
movq %rbx, %rdi
callq 0x5240
jmp 0x1220c
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x50d0
movq %r14, %rdi
callq 0x5510
// File: /workspace/github_cpp_makefile_star2_O2/meirdev[P]HexViewer/./CLI11.hpp
// Function: CLI::App::get_subcommand(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) const
App *get_subcommand(std::string subcom) const {
        for(const App_p &subcomptr : subcommands_)
            if(subcomptr->check_name(subcom))
                return subcomptr.get();
        throw OptionNotFound(subcom);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq 0x158(%rdi), %r12
movq 0x160(%rdi), %r13
leaq 0x28(%rsp), %rbx
cmpq %r13, %r12
je 0x130e5
movq (%r12), %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x53f0
movq %r15, %rdi
movq %rbx, %rsi
callq 0x10312
movl %eax, %ebp
movq %rbx, %rdi
callq 0x5180
testb %bpl, %bpl
jne 0x130d2
addq $0x8, %r12
jmp 0x1309e
movq (%r12), %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x38
popq %rdi
callq 0x51a0
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x53f0
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x13312
xorl %ebp, %ebp
leaq 0x147ba(%rip), %rsi     # 0x278d0
leaq 0x10e9(%rip), %rdx      # 0x14206
movq %rbx, %rdi
callq 0x54e0
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x5180
testb %bpl, %bpl
jne 0x1313c
jmp 0x13153
movq %rax, %r14
movq %rbx, %rdi
callq 0x5240
jmp 0x13153
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x5180
movq %r14, %rdi
callq 0x5510
nop
// File: /workspace/github_cpp_makefile_star2_O2/meirdev[P]HexViewer/./CLI11.hpp
// Function: CLI::App::get_option(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Option *get_option(std::string option_name) {
        for(Option_p &opt : options_) {
            if(opt->check_name(option_name)) {
                return opt.get();
            }
        }
        throw OptionNotFound(option_name);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq 0x98(%rdi), %r12
movq 0xa0(%rdi), %r13
leaq 0x28(%rsp), %rbx
cmpq %r13, %r12
je 0x131e9
movq (%r12), %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x53f0
movq %r15, %rdi
movq %rbx, %rsi
callq 0x13434
movl %eax, %ebp
movq %rbx, %rdi
callq 0x5180
testb %bpl, %bpl
jne 0x131d6
addq $0x8, %r12
jmp 0x131a2
movq (%r12), %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x38
popq %rdi
callq 0x51a0
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x53f0
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x13312
xorl %ebp, %ebp
leaq 0x146b6(%rip), %rsi     # 0x278d0
leaq 0xfe5(%rip), %rdx       # 0x14206
movq %rbx, %rdi
callq 0x54e0
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x5180
testb %bpl, %bpl
jne 0x13240
jmp 0x13257
movq %rax, %r14
movq %rbx, %rdi
callq 0x5240
jmp 0x13257
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x5180
movq %r14, %rdi
callq 0x5510
nop
// File: /workspace/github_cpp_makefile_star2_O2/meirdev[P]HexViewer/./CLI11.hpp
// Function: CLI::RequiredError::Subcommand(unsigned long)
static RequiredError Subcommand(size_t min_subcom) {
        if(min_subcom == 1)
            return RequiredError("A subcommand");
        else
            return RequiredError("Requires at least " + std::to_string(min_subcom) + " subcommands",
                                 ExitCodes::RequiredError);
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
cmpq $0x1, %rsi
jne 0x13d9b
leaq 0x598b(%rip), %rsi      # 0x19703
leaq 0x48(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x6844
leaq 0x48(%rsp), %rsi
movq %rbx, %rdi
callq 0x13c0e
leaq 0x48(%rsp), %rdi
jmp 0x13dfb
leaq 0x68(%rsp), %r14
movq %r14, %rdi
callq 0x66c2
leaq 0x5961(%rip), %rsi      # 0x19710
leaq 0x8(%rsp), %rdi
movq %r14, %rdx
callq 0xaebb
leaq 0x5960(%rip), %rdx      # 0x19723
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x69e3
leaq 0x28(%rsp), %rsi
pushq $0x6a
popq %rdx
movq %rbx, %rdi
callq 0x14036
leaq 0x28(%rsp), %rdi
callq 0x5180
leaq 0x8(%rsp), %rdi
callq 0x5180
leaq 0x68(%rsp), %rdi
callq 0x5180
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x5180
jmp 0x13e20
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5180
jmp 0x13e39
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
jmp 0x13e3e
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x5180
jmp 0x13e48
movq %rax, %rbx
movq %rbx, %rdi
callq 0x5510
// File: /workspace/github_cpp_makefile_star2_O2/meirdev[P]HexViewer/./CLI11.hpp
// Function: CLI::App::remaining_size(bool) const
size_t remaining_size(bool recurse = false) const {
        auto remaining_options = static_cast<size_t>(std::count_if(
            std::begin(missing_), std::end(missing_), [](const std::pair<detail::Classifier, std::string> &val) {
                return val.first != detail::Classifier::POSITIONAL_MARK;
            }));
        if(recurse) {
            for(const App_p &sub : subcommands_) {
                remaining_options += sub->remaining_size(recurse);
            }
        }
        return remaining_options;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %r14
movq 0x110(%rdi), %rdi
movq 0x118(%r14), %rsi
callq 0x14226
movq %rax, %rbx
testl %ebp, %ebp
je 0x1411d
movq 0x158(%r14), %r15
movq 0x160(%r14), %r14
pushq $0x1
popq %rbp
cmpq %r14, %r15
je 0x1411d
movq (%r15), %rdi
movl %ebp, %esi
callq 0x140ce
addq %rax, %rbx
addq $0x8, %r15
jmp 0x14105
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/meirdev[P]HexViewer/./CLI11.hpp
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> CLI::detail::rjoin<std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::string rjoin(const T &v, std::string delim = ",") {
    std::ostringstream s;
    for(size_t start = 0; start < v.size(); start++) {
        if(start > 0)
            s << delim;
        s << v[v.size() - start - 1];
    }
    return s.str();
}

// Assembly:
pushq %rbp
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, %r12
movq %r12, %rdi
callq 0x53d0
pushq $-0x20
popq %r13
xorl %ebp, %ebp
movq (%r15), %rsi
movq 0x8(%r15), %rax
subq %rsi, %rax
movq %rax, %rcx
sarq $0x5, %rcx
cmpq %rcx, %rbp
jae 0x142b1
testq %rbp, %rbp
je 0x1429a
movq %r12, %rdi
movq %r14, %rsi
callq 0x52a0
movq (%r15), %rsi
movq 0x8(%r15), %rax
subq %rsi, %rax
addq %r13, %rsi
addq %rax, %rsi
movq %r12, %rdi
callq 0x52a0
incq %rbp
addq $-0x20, %r13
jmp 0x1426a
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x5490
movq %rsp, %rdi
callq 0x50b0
movq %rbx, %rax
addq $0x178, %rsp            # imm = 0x178
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x142dd
movq %rax, %rbx
movq %rsp, %rdi
callq 0x50b0
movq %rbx, %rdi
callq 0x5510
// File: /workspace/github_cpp_makefile_star2_O2/meirdev[P]HexViewer/./CLI11.hpp
// Function: CLI::App::help(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, CLI::AppFormatMode) const
std::string help(std::string prev = "", AppFormatMode mode = AppFormatMode::Normal) const {
        if(prev.empty())
            prev = get_name();
        else
            prev += " " + get_name();

        // Delegate to subcommand if needed
        auto selected_subcommands = get_subcommands();
        if(!selected_subcommands.empty())
            return selected_subcommands.at(0)->help(prev, mode);
        else
            return formatter_->make_help(this, prev, mode);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdx)
je 0x1444c
leaq 0x8(%r15), %rsi
leaq 0x28(%rsp), %r12
movq %r12, %rdi
callq 0x53f0
leaq 0x538a(%rip), %rsi      # 0x197ab
leaq 0x8(%rsp), %rdi
movq %r12, %rdx
callq 0xaebb
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x5580
leaq 0x8(%rsp), %rdi
callq 0x5180
leaq 0x28(%rsp), %rdi
jmp 0x1446b
leaq 0x8(%r15), %rsi
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x53f0
movq %r14, %rdi
movq %r12, %rsi
callq 0x5360
movq %r12, %rdi
callq 0x5180
leaq 0x140(%r15), %rsi
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x13fc2
movq (%r12), %rax
cmpq 0x8(%r12), %rax
je 0x144c0
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x1458a
movq (%rax), %r15
leaq 0x68(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x53f0
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
movl %ebp, %ecx
callq 0x143e6
jmp 0x144ed
movq 0xe0(%r15), %r13
leaq 0x48(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x53f0
movq (%r13), %rax
movq %rbx, %rdi
movq %r13, %rsi
movq %r15, %rdx
movq %r12, %rcx
movl %ebp, %r8d
callq *0x10(%rax)
movq %r12, %rdi
callq 0x5180
leaq 0x8(%rsp), %rdi
callq 0xe91c
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
jmp 0x14526
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x5180
jmp 0x1454e
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5180
jmp 0x1453f
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x5180
jmp 0x14558
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xe91c
movq %rbx, %rdi
callq 0x5510
// File: /workspace/github_cpp_makefile_star2_O2/meirdev[P]HexViewer/./CLI11.hpp
// Function: CLI::App::get_groups[abi:cxx11]() const
std::vector<std::string> get_groups() const {
        std::vector<std::string> groups;

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

        return groups;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq 0x98(%rsi), %r14
movq 0xa0(%rsi), %r15
cmpq %r15, %r14
je 0x14830
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
movq (%r14), %rdx
callq 0x148ed
cmpq 0x8(%rbx), %rax
jne 0x1482a
movq (%r14), %rsi
movq %rbx, %rdi
callq 0xb27e
addq $0x8, %r14
jmp 0x14805
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
jmp 0x1483b
movq %rax, %r14
movq %rbx, %rdi
callq 0x6542
movq %r14, %rdi
callq 0x5510
// File: /workspace/github_cpp_makefile_star2_O2/meirdev[P]HexViewer/./CLI11.hpp
// Function: CLI::FormatterBase::get_label(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) const
std::string get_label(std::string key) const {
        if(labels_.find(key) == labels_.end())
            return key;
        else
            return labels_.at(key);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x10(%rsi), %r15
movq %r15, %rdi
movq %rdx, %rsi
callq 0x14bf2
addq $0x18, %r12
cmpq %r12, %rax
je 0x14b63
movq %r15, %rdi
movq %r14, %rsi
callq 0x14bac
movq %rbx, %rdi
movq %rax, %rsi
callq 0x53f0
jmp 0x14b6e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x53b0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/meirdev[P]HexViewer/./CLI11.hpp
// Function: CLI::detail::format_help(std::ostream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned long)
inline std::ostream &format_help(std::ostream &out, std::string name, std::string description, size_t wid) {
    name = "  " + name;
    out << std::setw(static_cast<int>(wid)) << std::left << name;
    if(!description.empty()) {
        if(name.length() >= wid)
            out << "\n" << std::setw(static_cast<int>(wid)) << "";
        out << description;
    }
    out << "\n";
    return out;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x47ef(%rip), %rsi      # 0x197aa
movq %rsp, %r13
movq %r13, %rdi
movq %r12, %rdx
callq 0x94d9
movq %r12, %rdi
movq %r13, %rsi
callq 0x5360
movq %r13, %rdi
callq 0x5180
movq (%rbx), %rax
movq -0x18(%rax), %rcx
movslq %r15d, %r13
movq %r13, 0x10(%rbx,%rcx)
movq -0x18(%rax), %rax
movl $0xffffff4f, %ecx       # imm = 0xFFFFFF4F
andl 0x18(%rbx,%rax), %ecx
orl $0x20, %ecx
movl %ecx, 0x18(%rbx,%rax)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x52a0
cmpq $0x0, 0x8(%r14)
je 0x1504d
cmpq %r15, 0x8(%r12)
jb 0x15042
leaq 0x4788(%rip), %rsi      # 0x197a7
movq %rbx, %rdi
callq 0x52c0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movq %r13, 0x10(%rax,%rcx)
leaq 0x476e(%rip), %rsi      # 0x197a8
movq %rax, %rdi
callq 0x52c0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x52a0
leaq 0x4753(%rip), %rsi      # 0x197a7
movq %rbx, %rdi
callq 0x52c0
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/meirdev[P]HexViewer/./CLI11.hpp
// Function: CLI::detail::find_and_replace(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>>)
inline std::string find_and_replace(std::string str, std::string from, std::string to) {

    size_t start_pos = 0;

    while((start_pos = str.find(from, start_pos)) != std::string::npos) {
        str.replace(start_pos, from.length(), to);
        start_pos += to.length();
    }

    return str;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
xorl %r13d, %r13d
movq %r14, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x55b0
cmpq $-0x1, %rax
je 0x150b5
movq %rax, %r13
movq 0x8(%r12), %rdx
movq %r14, %rdi
movq %rax, %rsi
movq %r15, %rcx
callq 0x5110
addq 0x8(%r15), %r13
jmp 0x15085
movq %rbx, %rdi
movq %r14, %rsi
callq 0x53b0
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/meirdev[P]HexViewer/./CLI11.hpp
// Function: CLI::detail::split(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char)
inline std::vector<std::string> split(const std::string &s, char delim) {
    std::vector<std::string> elems;
    // Check to see if empty string, give consistent result
    if(s.empty())
        elems.emplace_back("");
    else {
        std::stringstream ss;
        ss.str(s);
        std::string item;
        while(std::getline(ss, item, delim)) {
            elems.push_back(item);
        }
    }
    return elems;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rdi, %rbx
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
cmpq $0x0, 0x8(%rsi)
je 0x15838
movl %edx, %ebp
movq %rsi, %r14
leaq 0x20(%rsp), %rdi
callq 0x5220
leaq 0x38(%rsp), %rdi
movq %r14, %rsi
callq 0x5440
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movsbl %bpl, %ebp
leaq 0x20(%rsp), %r14
movq %rsp, %r15
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x5550
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x15824
movq %rbx, %rdi
movq %r15, %rsi
callq 0xb27e
jmp 0x157fc
movq %rsp, %rdi
callq 0x5180
leaq 0x20(%rsp), %rdi
callq 0x5250
jmp 0x15847
leaq 0x3f69(%rip), %rsi      # 0x197a8
movq %rbx, %rdi
callq 0x15e08
movq %rbx, %rax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1585f
movq %rax, %r14
jmp 0x1586f
movq %rax, %r14
jmp 0x15879
movq %rax, %r14
movq %rsp, %rdi
callq 0x5180
leaq 0x20(%rsp), %rdi
callq 0x5250
movq %rbx, %rdi
callq 0x6542
movq %r14, %rdi
callq 0x5510
nop
// File: /workspace/github_cpp_makefile_star2_O2/meirdev[P]HexViewer/./CLI11.hpp
// Function: bool CLI::detail::lexical_cast<int, (CLI::detail::enabler)0>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int&)
bool lexical_cast(std::string input, T &output) {
    try {
        size_t n = 0;
        long long output_ll = std::stoll(input, &n, 0);
        output = static_cast<T>(output_ll);
        return n == input.size() && static_cast<long long>(output) == output_ll;
    } catch(const std::invalid_argument &) {
        return false;
    } catch(const std::out_of_range &) {
        return false;
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rsi
andq $0x0, (%rsi)
xorl %edx, %edx
callq 0x16858
movl %eax, (%r14)
movq (%rsp), %rcx
xorq 0x8(%rbx), %rcx
movslq %eax, %rdx
xorq %rax, %rdx
orq %rcx, %rdx
sete %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
cmpl $0x2, %edx
je 0x1683f
cmpl $0x1, %edx
jne 0x16850
movq %rax, %rdi
callq 0x5140
callq 0x54d0
xorl %eax, %eax
jmp 0x1682d
movq %rax, %rdi
callq 0x5510
// File: /workspace/github_cpp_makefile_star2_O2/meirdev[P]HexViewer/./CLI11.hpp
// Function: bool CLI::detail::lexical_cast<unsigned long, (CLI::detail::enabler)0>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned long&)
bool lexical_cast(std::string input, T &output) {
    if(!input.empty() && input.front() == '-')
        return false; // std::stoull happily converts negative values to junk without any errors.

    try {
        size_t n = 0;
        unsigned long long output_ll = std::stoull(input, &n, 0);
        output = static_cast<T>(output_ll);
        return n == input.size() && static_cast<unsigned long long>(output) == output_ll;
    } catch(const std::invalid_argument &) {
        return false;
    } catch(const std::out_of_range &) {
        return false;
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdi)
je 0x16a3d
movq (%rbx), %rax
cmpb $0x2d, (%rax)
jne 0x16a3d
xorl %eax, %eax
jmp 0x16a5c
movq %rsp, %rsi
andq $0x0, (%rsi)
movq %rbx, %rdi
xorl %edx, %edx
callq 0x16a85
movq %rax, (%r14)
movq (%rsp), %rax
cmpq 0x8(%rbx), %rax
sete %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
cmpl $0x2, %edx
je 0x16a6e
cmpl $0x1, %edx
jne 0x16a7d
movq %rax, %rdi
callq 0x5140
callq 0x54d0
jmp 0x16a39
movq %rax, %rdi
callq 0x5510
// File: /workspace/github_cpp_makefile_star2_O2/meirdev[P]HexViewer/HexViewer.cpp
// Function: HexViewer::setStyle(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool)
void HexViewer::setStyle(const std::string& _style, bool _colors)
{
    if (_style == "hexyl")
    {
        m_style = new Hexyl(_colors);
    }
    else if (_style == "hexdump")
    {
        m_style = new HexDump;
    }
    else
    {
        throw std::runtime_error("Can't load theme");
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x2414(%rip), %rsi      # 0x19087
movq %r14, %rdi
callq 0xc7ec
testb %al, %al
je 0x16c98
pushq $0x28
popq %rdi
callq 0x52d0
movq %rax, %r14
movzbl %bpl, %esi
movq %rax, %rdi
callq 0x176e4
jmp 0x16cbe
leaq 0x3914(%rip), %rsi      # 0x1a5b3
movq %r14, %rdi
callq 0xc7ec
testb %al, %al
je 0x16cc6
pushq $0x38
popq %rdi
callq 0x52d0
movq %rax, %r14
movq %rax, %rdi
callq 0x16f94
movq %r14, (%rbx)
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x51a0
movq %rax, %r14
leaq 0x38e3(%rip), %rsi      # 0x1a5bb
movq %rax, %rdi
callq 0x5130
movq 0x11309(%rip), %rsi     # 0x27ff0
movq 0x112c2(%rip), %rdx     # 0x27fb0
movq %r14, %rdi
callq 0x54e0
movq %rax, %rbx
movq %r14, %rdi
callq 0x5240
jmp 0x16d18
movq %rax, %rbx
pushq $0x38
jmp 0x16d0f
movq %rax, %rbx
pushq $0x28
popq %rsi
movq %r14, %rdi
callq 0x52e0
movq %rbx, %rdi
callq 0x5510
// File: /workspace/github_cpp_makefile_star2_O2/meirdev[P]HexViewer/HexViewer.cpp
// Function: HexViewer::print(int, unsigned long)
void HexViewer::print(int _offset, size_t _length)
{
    DataProcessing dataProcessing(*m_printer, *m_style, *m_file);

    if (_offset)
    {
        dataProcessing.setOffset(_offset);
    }

    if (_length)
    {
        dataProcessing.setLength(_length);
    }

    dataProcessing.process();
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x48, %rsp
movq %rdx, %rbx
movl %esi, %ebp
movq (%rdi), %rdx
movq 0x8(%rdi), %rsi
movq 0x10(%rdi), %rcx
movq %rsp, %rdi
callq 0x1866c
testl %ebp, %ebp
je 0x16dce
movq %rsp, %rdi
movl %ebp, %esi
callq 0x186c0
testq %rbx, %rbx
je 0x16dde
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x186ec
movq %rsp, %rdi
callq 0x186f2
leaq 0x28(%rsp), %rdi
callq 0x16e0c
addq $0x48, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x16e0c
movq %rbx, %rdi
callq 0x5510
// File: /workspace/github_cpp_makefile_star2_O2/meirdev[P]HexViewer/StringBuffer/StringBuffer.cpp
// Function: StringBuffer::inputString(char const*, unsigned long)
StringBuffer& StringBuffer::inputString(const char* _string, size_t _size)
{
    if (_size >= m_size)
    {
        std::cout << _string;
        
        return *this;
    }
    
    if (_size+m_position > m_size)
    {
        std::cout << m_buffer;

        m_position = 0;
    }
    
    std::copy(_string, _string+_size, m_buffer+m_position);

    m_position          += _size;
    m_buffer[m_position] = 0;

    return *this;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
movq 0x10(%rdi), %rax
cmpq %rdx, %rax
jbe 0x16ef1
movq %rdx, %r14
movq 0x8(%rbx), %rdi
leaq (%rdi,%rdx), %rcx
cmpq %rax, %rcx
jbe 0x16eca
movq (%rbx), %rsi
movq 0x11102(%rip), %rdi     # 0x27fc0
callq 0x52c0
andq $0x0, 0x8(%rbx)
xorl %edi, %edi
testq %r14, %r14
je 0x16ee1
addq (%rbx), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x54c0
movq 0x8(%rbx), %rdi
addq %r14, %rdi
movq %rdi, 0x8(%rbx)
movq (%rbx), %rax
movb $0x0, (%rax,%rdi)
jmp 0x16f00
movq 0x110c8(%rip), %rdi     # 0x27fc0
movq %r15, %rsi
callq 0x52c0
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/meirdev[P]HexViewer/Style/HexDump/HexDump.cpp
// Function: HexDump::row(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<unsigned short, std::allocator<unsigned short>> const&)
std::string HexDump::row(const std::string& _position, const std::vector<unsigned short>& _bytes)
{
    m_rowBuffer.clear();

    m_rowBuffer << _position << "  ";
    
    for (size_t i = 0; i < 16; ++i)
    {
        if (i)
        {
            if (i % 8 == 0)
            {
                m_rowBuffer << "  ";
            }
            else
            {
                m_rowBuffer << " ";
            }
        }

        m_rowBuffer << getByte(_bytes[i]);
    }
    
    m_rowBuffer << "  |";
    
    for (size_t i = 0; i < 16; ++i)
    {
        m_rowBuffer << getText(_bytes[i]);
    }

    m_rowBuffer << "|" << "\n";

    return m_rowBuffer.get();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r15
movq %rdx, %r13
movq %rsi, %r12
movq %rdi, 0x10(%rsp)
leaq 0x20(%rsi), %r14
movq %r14, %rdi
callq 0x16f3a
movq %r14, %rdi
movq %r13, %rsi
callq 0x16f0a
leaq 0x2588(%rip), %r13      # 0x197aa
movq %rax, %rdi
movq %r13, %rsi
callq 0x16e68
xorl %ebp, %ebp
leaq 0x2575(%rip), %rbx      # 0x197ab
testq %rbp, %rbp
je 0x17254
cmpq $0x10, %rbp
je 0x17270
testb $0x7, %bpl
movq %rbx, %rsi
cmoveq %r13, %rsi
movq %r14, %rdi
callq 0x16e68
movq (%r15), %rax
movzwl (%rax,%rbp,2), %esi
shll $0x6, %esi
addq 0x8(%r12), %rsi
movq %r14, %rdi
callq 0x16f0a
incq %rbp
jmp 0x17236
leaq 0x335d(%rip), %rsi      # 0x1a5d4
movq %r14, %rdi
callq 0x16e68
xorl %ebx, %ebx
cmpq $0x10, %rbx
je 0x172ab
movq (%r15), %rax
movzwl (%rax,%rbx,2), %eax
movq 0x8(%r12), %rcx
shll $0x6, %eax
leaq (%rcx,%rax), %rsi
addq $0x20, %rsi
movq %r14, %rdi
callq 0x16f0a
incq %rbx
jmp 0x17281
leaq 0x3324(%rip), %rsi      # 0x1a5d6
movq %r14, %rdi
callq 0x16e68
leaq 0x24e6(%rip), %rsi      # 0x197a7
movq %rax, %rdi
callq 0x16e68
movq %r14, %rdi
callq 0x16f46
leaq 0xf(%rsp), %rdx
movq 0x10(%rsp), %rbx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x6844
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/meirdev[P]HexViewer/Style/Hexyl/Hexyl.cpp
// Function: Hexyl::row(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<unsigned short, std::allocator<unsigned short>> const&)
std::string Hexyl::row(const std::string& _position, const std::vector<unsigned short>& _bytes)
{
    std::stringstream row;

    row << "│" << _position << "│ ";

    for (size_t i = 0; i < 16; ++i)
    {
        if (i)
        {
            if (i % 8 == 0)
            {
                row << " ┊ ";
            }
            else
            {
                row << " ";
            }
        }

        row << getByte(_bytes[i]);
    }
    
    row << " │";
    
    for (size_t i = 0; i < 16; ++i)
    {
        if (i && (i % 8 == 0))
        {
            row << "┊";
        }

        row << getText(_bytes[i]);
    }

    row << "│" << std::endl;

    return row.str();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movq %rcx, %r14
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rsp), %rdi
callq 0x5220
leaq 0x20(%rsp), %r12
leaq 0x2a18(%rip), %rsi      # 0x1a621
movq %r12, %rdi
callq 0x52c0
movq %rax, %rdi
movq %r13, %rsi
callq 0x52a0
leaq 0x29f2(%rip), %rsi      # 0x1a615
movq %rax, %rdi
callq 0x52c0
movq %rbx, 0x8(%rsp)
xorl %r13d, %r13d
leaq 0x29e0(%rip), %rbp      # 0x1a61a
leaq 0x1b6a(%rip), %rbx      # 0x197ab
testq %r13, %r13
je 0x17c5f
cmpq $0x10, %r13
je 0x17c84
testb $0x7, %r13b
movq %rbx, %rsi
cmoveq %rbp, %rsi
movq %r12, %rdi
callq 0x52c0
movq (%r14), %rax
movzwl (%rax,%r13,2), %eax
movq 0x8(%r15), %rcx
imulq $0x60, %rax, %rax
leaq (%rcx,%rax), %rsi
addq $0x20, %rsi
movq %r12, %rdi
callq 0x52a0
incq %r13
jmp 0x17c41
leaq 0x2995(%rip), %rsi      # 0x1a620
movq %r12, %rdi
callq 0x52c0
movq 0x8(%rsp), %rbx
xorl %ebp, %ebp
leaq 0x2984(%rip), %r13      # 0x1a625
cmpq $0x10, %rbp
je 0x17ce7
testq %rbp, %rbp
sete %al
testb $0x7, %bpl
setne %cl
orb %al, %cl
jne 0x17cc3
movq %r12, %rdi
movq %r13, %rsi
callq 0x52c0
movq (%r14), %rax
movzwl (%rax,%rbp,2), %eax
movq 0x8(%r15), %rcx
imulq $0x60, %rax, %rax
leaq (%rcx,%rax), %rsi
addq $0x40, %rsi
movq %r12, %rdi
callq 0x52a0
incq %rbp
jmp 0x17ca1
leaq 0x2933(%rip), %rsi      # 0x1a621
movq %r12, %rdi
callq 0x52c0
movq %rax, %rdi
callq 0x5190
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x5490
leaq 0x10(%rsp), %rdi
callq 0x5250
movq %rbx, %rax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x17d2e
jmp 0x17d2e
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x5250
movq %rbx, %rdi
callq 0x5510
// File: /workspace/github_cpp_makefile_star2_O2/meirdev[P]HexViewer/Style/Hexyl/Hexyl.cpp
// Function: Repeat(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long)
static std::string Repeat(const std::string& _string, size_t _length)
{
    std::stringstream fs;

    for (size_t i = 0; i < _length; ++i)
    {
        fs << _string;
    }

    return fs.str();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x188, %rsp            # imm = 0x188
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsp, %rdi
callq 0x5220
leaq 0x10(%rsp), %r12
subq $0x1, %r14
jb 0x17d7a
movq %r12, %rdi
movq %r15, %rsi
callq 0x52a0
jmp 0x17d67
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x5490
movq %rsp, %rdi
callq 0x5250
movq %rbx, %rax
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x17da3
movq %rax, %rbx
movq %rsp, %rdi
callq 0x5250
movq %rbx, %rdi
callq 0x5510
// File: /workspace/github_cpp_makefile_star2_O2/meirdev[P]HexViewer/Style/Hexyl/Hexyl.cpp
// Function: Hexyl::position[abi:cxx11](unsigned long)
inline std::string Hexyl::position(size_t _position)
{
    std::stringstream position;

    if (m_colourful)
    {
        position << "\x1b[38;5;242m" << std::setfill('0') << std::setw(8) << std::hex << _position << "\x1b[0m";
    }
    else
    {
        position << std::setfill('0') << std::setw(8) << std::hex << _position;
    }

    return position.str();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5220
leaq 0x18(%rsp), %rdi
cmpb $0x1, 0x20(%r15)
jne 0x17e78
leaq 0x27df(%rip), %rsi      # 0x1a609
callq 0x52c0
pushq $0x30
popq %rsi
movq %rax, %rdi
callq 0x5480
movq (%rax), %rcx
movq -0x18(%rcx), %rdx
movq $0x8, 0x10(%rax,%rdx)
movq -0x18(%rcx), %rcx
movl 0x18(%rax,%rcx), %edx
andl $-0x4b, %edx
orl $0x8, %edx
movl %edx, 0x18(%rax,%rcx)
movq %rax, %rdi
movq %r14, %rsi
callq 0x5200
leaq 0x2796(%rip), %rsi      # 0x1a604
movq %rax, %rdi
callq 0x52c0
jmp 0x17ead
pushq $0x30
popq %rsi
callq 0x5480
movq (%rax), %rcx
movq -0x18(%rcx), %rdx
movq $0x8, 0x10(%rax,%rdx)
movq -0x18(%rcx), %rcx
movl 0x18(%rax,%rcx), %edx
andl $-0x4b, %edx
orl $0x8, %edx
movl %edx, 0x18(%rax,%rcx)
movq %rax, %rdi
movq %r14, %rsi
callq 0x5200
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x5490
leaq 0x8(%rsp), %rdi
callq 0x5250
movq %rbx, %rax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5250
movq %rbx, %rdi
callq 0x5510
nop
// File: /workspace/github_cpp_makefile_star2_O2/meirdev[P]HexViewer/Style/Hexyl/Hexyl.cpp
// Function: Hexyl::header[abi:cxx11]()
inline std::string Hexyl::header()
{
    std::stringstream header;

    std::string repeat8  = Repeat("─", 8);
    std::string repeat25 = Repeat("─", 25);

    header << "┌" << repeat8 << "┬" << repeat25 << "┬" << repeat25 << "┬" << repeat8 << "┬" << repeat8 << "┐" << std::endl;

    return header.str();
}

// Assembly:
pushq %rbx
subq $0x1f0, %rsp            # imm = 0x1F0
movq %rdi, %rbx
leaq 0x68(%rsp), %rdi
callq 0x5220
leaq 0x26f9(%rip), %rsi      # 0x1a629
leaq 0x8(%rsp), %rdi
leaq 0x48(%rsp), %rdx
callq 0x6844
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
pushq $0x8
popq %rdx
callq 0x17d43
leaq 0x8(%rsp), %rdi
callq 0x5180
leaq 0x26c7(%rip), %rsi      # 0x1a629
leaq 0x48(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x6844
leaq 0x8(%rsp), %rdi
leaq 0x48(%rsp), %rsi
pushq $0x19
popq %rdx
callq 0x17d43
leaq 0x48(%rsp), %rdi
callq 0x5180
leaq 0x78(%rsp), %rdi
leaq 0x2694(%rip), %rsi      # 0x1a62d
callq 0x52c0
leaq 0x28(%rsp), %rsi
movq %rax, %rdi
callq 0x52a0
leaq 0x267f(%rip), %rsi      # 0x1a631
movq %rax, %rdi
callq 0x52c0
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x52a0
leaq 0x2663(%rip), %rsi      # 0x1a631
movq %rax, %rdi
callq 0x52c0
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x52a0
leaq 0x2647(%rip), %rsi      # 0x1a631
movq %rax, %rdi
callq 0x52c0
leaq 0x28(%rsp), %rsi
movq %rax, %rdi
callq 0x52a0
leaq 0x262b(%rip), %rsi      # 0x1a631
movq %rax, %rdi
callq 0x52c0
leaq 0x28(%rsp), %rsi
movq %rax, %rdi
callq 0x52a0
leaq 0x2613(%rip), %rsi      # 0x1a635
movq %rax, %rdi
callq 0x52c0
movq %rax, %rdi
callq 0x5190
leaq 0x80(%rsp), %rsi
movq %rbx, %rdi
callq 0x5490
leaq 0x8(%rsp), %rdi
callq 0x5180
leaq 0x28(%rsp), %rdi
callq 0x5180
leaq 0x68(%rsp), %rdi
callq 0x5250
movq %rbx, %rax
addq $0x1f0, %rsp            # imm = 0x1F0
popq %rbx
retq
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
jmp 0x18092
movq %rax, %rbx
jmp 0x18097
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
jmp 0x1809c
movq %rax, %rbx
jmp 0x180a1
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5180
leaq 0x28(%rsp), %rdi
callq 0x5180
leaq 0x68(%rsp), %rdi
callq 0x5250
movq %rbx, %rdi
callq 0x5510
nop
// File: /workspace/github_cpp_makefile_star2_O2/meirdev[P]HexViewer/Style/Hexyl/Hexyl.cpp
// Function: Hexyl::footer[abi:cxx11]()
inline std::string Hexyl::footer()
{
    std::stringstream footer;

    std::string repeat8  = Repeat("─", 8);
    std::string repeat25 = Repeat("─", 25);

    footer << "└" << repeat8 << "┴" << repeat25 << "┴" << repeat25 << "┴" << repeat8 << "┴" << repeat8 << "┘" << std::endl;

    return footer.str();
}

// Assembly:
pushq %rbx
subq $0x1f0, %rsp            # imm = 0x1F0
movq %rdi, %rbx
leaq 0x68(%rsp), %rdi
callq 0x5220
leaq 0x2559(%rip), %rsi      # 0x1a629
leaq 0x8(%rsp), %rdi
leaq 0x48(%rsp), %rdx
callq 0x6844
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
pushq $0x8
popq %rdx
callq 0x17d43
leaq 0x8(%rsp), %rdi
callq 0x5180
leaq 0x2527(%rip), %rsi      # 0x1a629
leaq 0x48(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x6844
leaq 0x8(%rsp), %rdi
leaq 0x48(%rsp), %rsi
pushq $0x19
popq %rdx
callq 0x17d43
leaq 0x48(%rsp), %rdi
callq 0x5180
leaq 0x78(%rsp), %rdi
leaq 0x2500(%rip), %rsi      # 0x1a639
callq 0x52c0
leaq 0x28(%rsp), %rsi
movq %rax, %rdi
callq 0x52a0
leaq 0x24eb(%rip), %rsi      # 0x1a63d
movq %rax, %rdi
callq 0x52c0
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x52a0
leaq 0x24cf(%rip), %rsi      # 0x1a63d
movq %rax, %rdi
callq 0x52c0
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x52a0
leaq 0x24b3(%rip), %rsi      # 0x1a63d
movq %rax, %rdi
callq 0x52c0
leaq 0x28(%rsp), %rsi
movq %rax, %rdi
callq 0x52a0
leaq 0x2497(%rip), %rsi      # 0x1a63d
movq %rax, %rdi
callq 0x52c0
leaq 0x28(%rsp), %rsi
movq %rax, %rdi
callq 0x52a0
leaq 0x247f(%rip), %rsi      # 0x1a641
movq %rax, %rdi
callq 0x52c0
movq %rax, %rdi
callq 0x5190
leaq 0x80(%rsp), %rsi
movq %rbx, %rdi
callq 0x5490
leaq 0x8(%rsp), %rdi
callq 0x5180
leaq 0x28(%rsp), %rdi
callq 0x5180
leaq 0x68(%rsp), %rdi
callq 0x5250
movq %rbx, %rax
addq $0x1f0, %rsp            # imm = 0x1F0
popq %rbx
retq
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
jmp 0x18232
movq %rax, %rbx
jmp 0x18237
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
jmp 0x1823c
movq %rax, %rbx
jmp 0x18241
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5180
leaq 0x28(%rsp), %rdi
callq 0x5180
leaq 0x68(%rsp), %rdi
callq 0x5250
movq %rbx, %rdi
callq 0x5510
nop
// File: /workspace/github_cpp_makefile_star2_O2/meirdev[P]HexViewer/FileStream/LocalFile/LocalFile.cpp
// Function: LocalFile::size()
inline size_t LocalFile::size()
{
    size_t currentPosition = tell();

    m_file.seekg(0, std::ios_base::end);

    size_t fileSize = tell();

    m_file.seekg(currentPosition, std::ios_base::beg);

    return fileSize;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x20(%rax)
movq %rax, %r14
leaq 0x8(%rbx), %r15
pushq $0x2
popq %rdx
movq %r15, %rdi
xorl %esi, %esi
callq 0x53e0
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x20(%rax)
movq %rax, %rbx
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x53e0
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/meirdev[P]HexViewer/DataProcessing/DataProcessing.cpp
// Function: DataProcessing::process()
void DataProcessing::process()
{
    const size_t bufferSize = 4096;

    char* buffer = new char[bufferSize];

    m_file.seek(m_offset);

    m_printer << m_style.header();

    size_t totalLength = 0;

    while (!m_file.eof())
    {
        size_t readBytes = m_file.read(buffer, bufferSize);

        for (size_t i = 0; (totalLength < m_length) && (i < readBytes); ++i, ++totalLength)
        {
            printByte(buffer[i]);
        }

        if (totalLength == m_length)
        {
            break;
        }
    }

    printEnd();

    m_printer << m_style.footer();

    m_printer.flush();

    delete[] buffer;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %r14
movl $0x1000, %edi           # imm = 0x1000
callq 0x5030
movq %rax, %rbx
movq (%r14), %rsi
movq 0x20(%r14), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x10(%r14), %r15
movq 0x18(%r14), %rsi
movq (%rsi), %rax
movq %rsp, %r12
movq %r12, %rdi
callq *0x18(%rax)
movq (%r15), %rax
movq %r15, %rdi
movq %r12, %rsi
callq *0x18(%rax)
movq %rsp, %rdi
callq 0x5180
xorl %r12d, %r12d
movq 0x20(%r14), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
testb %al, %al
jne 0x18799
movq 0x20(%r14), %rdi
movq (%rdi), %rax
movl $0x1000, %edx           # imm = 0x1000
movq %rbx, %rsi
callq *0x10(%rax)
movq %rax, %r15
xorl %r13d, %r13d
leaq (%r12,%r13), %rax
movq 0x8(%r14), %rcx
cmpq %rcx, %rax
jae 0x18791
cmpq %r15, %r13
jae 0x18791
movzbl (%rbx,%r13), %esi
movq %r14, %rdi
callq 0x187fe
incq %r13
jmp 0x1876d
movq %rax, %r12
cmpq %rcx, %rax
jne 0x18747
movq %r14, %rdi
callq 0x18840
movq 0x10(%r14), %r15
movq 0x18(%r14), %rsi
movq (%rsi), %rax
movq %rsp, %r12
movq %r12, %rdi
callq *0x20(%rax)
movq (%r15), %rax
movq %r15, %rdi
movq %r12, %rsi
callq *0x18(%rax)
movq %rsp, %rdi
callq 0x5180
movq 0x10(%r14), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rbx, %rdi
callq 0x53a0
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x187eb
movq %rax, %rbx
movq %rsp, %rdi
callq 0x5180
movq %rbx, %rdi
callq 0x5510
// File: /workspace/github_cpp_makefile_star2_O2/meirdev[P]HexViewer/DataProcessing/DataProcessing.cpp
// Function: DataProcessing::printByte(unsigned char)
inline void DataProcessing::printByte(unsigned char _byte)
{
    m_bytes.push_back(_byte);

    size_t size = m_bytes.size();

    if (size && (size % m_blockSize == 0))
    {
        printRow();
    }
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
addq $0x28, %rdi
leaq 0xe(%rsp), %rax
movw %si, (%rax)
movq %rax, %rsi
callq 0x18932
movq 0x30(%rbx), %rax
subq 0x28(%rbx), %rax
je 0x1883a
sarq %rax
xorl %edx, %edx
divq 0x40(%rbx)
testq %rdx, %rdx
jne 0x1883a
movq %rbx, %rdi
callq 0x1888c
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/meirdev[P]HexViewer/DataProcessing/DataProcessing.cpp
// Function: DataProcessing::printEnd()
inline void DataProcessing::printEnd()
{
    size_t size = m_bytes.size();

    if (size && (size != m_blockSize))
    {
        m_bytes.insert(m_bytes.begin()+size, m_blockSize-size, 256);
    }

    printRow();
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x28(%rdi), %rsi
movq 0x30(%rdi), %rax
movq %rax, %rcx
subq %rsi, %rcx
subq %rsi, %rax
je 0x1887d
sarq %rcx
movq 0x40(%rbx), %rdx
subq %rcx, %rdx
je 0x1887d
leaq 0x28(%rbx), %rdi
addq %rax, %rsi
leaq 0xe(%rsp), %rcx
movw $0x100, (%rcx)          # imm = 0x100
callq 0x18aa8
movq %rbx, %rdi
callq 0x1888c
addq $0x10, %rsp
popq %rbx
retq
nop