LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/meirdev[P]HexViewer/./CLI11.hpp
// Function: CLI::App::_process_extras(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&)
void _process_extras(std::vector<std::string> &args) {
        if(!(allow_extras_ || prefix_command_)) {
            size_t num_left_over = remaining_size();
            if(num_left_over > 0) {
                args = remaining(false);
                throw ExtrasError(args);
            }
        }

        for(App_p &sub : subcommands_) {
            if(sub->count() > 0)
                sub->_process_extras(args);
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %rsi
cmpb $0x0, 0x48(%rdi)
jne 0x135d8
cmpb $0x0, 0x4a(%rsi)
jne 0x135d8
movq 0x110(%rsi), %rax
movq 0x118(%rsi), %rcx
cmpq %rcx, %rax
je 0x135d8
xorl %edx, %edx
xorl %edi, %edi
cmpl $0x1, (%rax)
setne %dil
addq %rdi, %rdx
addq $0x28, %rax
cmpq %rcx, %rax
jne 0x135be
testq %rdx, %rdx
jne 0x13610
movq 0x158(%rsi), %r14
movq 0x160(%rsi), %r15
cmpq %r15, %r14
je 0x13606
movq (%r14), %rdi
cmpq $0x0, 0x180(%rdi)
je 0x13600
movq %rbx, %rsi
callq 0x1358e
addq $0x8, %r14
jmp 0x135e6
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x18(%rsp), %r14
movq %r14, %rdi
xorl %edx, %edx
callq 0x13698
movq %rbx, %rdi
movq %r14, %rsi
callq 0x10c4c
movq %r14, %rdi
callq 0x714a
movl $0x38, %edi
callq 0x5170
movq %rax, %r14
movq %rsp, %rdi
movq %rbx, %rsi
callq 0xc400
movq %rsp, %rsi
movq %r14, %rdi
callq 0x1b7f6
leaq 0x1c424(%rip), %rsi     # 0x2fa80
leaq 0x8325(%rip), %rdx      # 0x1b988
movq %r14, %rdi
callq 0x54d0
movq %rax, %rbx
movq %rsp, %rdi
callq 0x714a
jmp 0x13690
movq %rax, %rbx
movq %rsp, %rdi
callq 0x714a
jmp 0x13688
movq %rax, %rbx
movq %r14, %rdi
callq 0x5230
movq %rbx, %rdi
callq 0x5510
// File: /workspace/github_cpp_makefile_star2_O3/meirdev[P]HexViewer/./CLI11.hpp
// Function: CLI::App::remaining[abi:cxx11](bool) const
std::vector<std::string> remaining(bool recurse = false) const {
        std::vector<std::string> miss_list;
        for(const std::pair<detail::Classifier, std::string> &miss : missing_) {
            miss_list.push_back(std::get<1>(miss));
        }

        // Recurse into subcommands
        if(recurse) {
            for(const App *sub : parsed_subcommands_) {
                std::vector<std::string> output = sub->remaining(recurse);
                std::copy(std::begin(output), std::end(output), std::back_inserter(miss_list));
            }
        }
        return miss_list;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x110(%rsi), %r15
movq 0x118(%rsi), %r12
cmpq %r12, %r15
je 0x136e1
leaq 0x8(%r15), %rsi
movq %rbx, %rdi
callq 0xe1c4
addq $0x28, %r15
jmp 0x136ca
testb %bpl, %bpl
je 0x1374e
movq 0x140(%r14), %r12
movq 0x148(%r14), %r13
cmpq %r13, %r12
je 0x1374e
movq %rsp, %r14
movq (%r12), %rsi
movq %r14, %rdi
movl $0x1, %edx
callq 0x13698
movq (%rsp), %r15
movq 0x8(%rsp), %rbp
subq %r15, %rbp
sarq $0x5, %rbp
testq %rbp, %rbp
jle 0x1373d
incq %rbp
movq %rbx, %rdi
movq %r15, %rsi
callq 0xe1c4
addq $0x20, %r15
decq %rbp
cmpq $0x1, %rbp
ja 0x13725
movq %r14, %rdi
callq 0x714a
addq $0x8, %r12
cmpq %r13, %r12
jne 0x136fc
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x13762
movq %rax, %r14
jmp 0x13772
movq %rax, %r14
movq %rsp, %rdi
callq 0x714a
movq %rbx, %rdi
callq 0x714a
movq %r14, %rdi
callq 0x5510
// File: /workspace/github_cpp_makefile_star2_O3/meirdev[P]HexViewer/./CLI11.hpp
// Function: CLI::App::_recognize(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
detail::Classifier _recognize(const std::string &current) const {
        std::string dummy1, dummy2;

        if(current == "--")
            return detail::Classifier::POSITIONAL_MARK;
        if(_valid_subcommand(current))
            return detail::Classifier::SUBCOMMAND;
        if(detail::split_long(current, dummy1, dummy2))
            return detail::Classifier::LONG;
        if(detail::split_short(current, dummy1, dummy2))
            return detail::Classifier::SHORT;
        if((allow_windows_style_options_) && (detail::split_windows(current, dummy1, dummy2)))
            return detail::Classifier::WINDOWS;
        return detail::Classifier::NONE;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
xorl %eax, %eax
movq %rax, -0x8(%r15)
movb %al, (%r15)
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq %rax, -0x8(%r12)
movb %al, (%r12)
leaq 0xfaad(%rip), %rsi      # 0x2326d
movq %rbx, %rdi
callq 0x50d0
testl %eax, %eax
je 0x13839
movq %r14, %rdi
movq %rbx, %rsi
callq 0x14aa8
movl $0x5, %ebp
testb %al, %al
jne 0x1383e
leaq 0x20(%rsp), %rsi
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x14be4
movl $0x3, %ebp
testb %al, %al
jne 0x1383e
leaq 0x20(%rsp), %rsi
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x14d8b
movl $0x2, %ebp
testb %al, %al
jne 0x1383e
cmpb $0x1, 0x173(%r14)
jne 0x13835
leaq 0x20(%rsp), %rsi
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x14e58
movl $0x4, %ebp
testb %al, %al
jne 0x1383e
xorl %ebp, %ebp
jmp 0x1383e
movl $0x1, %ebp
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x13854
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x52c0
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x1386b
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x52c0
movl %ebp, %eax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x13893
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x52c0
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x138aa
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x52c0
movq %rbx, %rdi
callq 0x5510
// File: /workspace/github_cpp_makefile_star2_O3/meirdev[P]HexViewer/./CLI11.hpp
// Function: CLI::App::_valid_subcommand(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
bool _valid_subcommand(const std::string &current) const {
        // Don't match if max has been reached - but still check parents
        if(require_subcommand_max_ != 0 && parsed_subcommands_.size() >= require_subcommand_max_) {
            return parent_ != nullptr && parent_->_valid_subcommand(current);
        }

        for(const App_p &com : subcommands_)
            if(com->check_name(current) && !*com)
                return true;

        // Check parent if exists, else return false
        return parent_ != nullptr && parent_->_valid_subcommand(current);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x190(%r14), %rax
testq %rax, %rax
je 0x14af0
movq 0x148(%r14), %rcx
subq 0x140(%r14), %rcx
sarq $0x3, %rcx
cmpq %rax, %rcx
jb 0x14af0
movq 0x178(%r14), %r14
testq %r14, %r14
jne 0x14abc
jmp 0x14ba8
movq 0x158(%r14), %r13
movq 0x160(%r14), %rbp
cmpq %rbp, %r13
je 0x14b92
leaq 0x8(%rsp), %r15
movq (%r13), %r12
leaq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x1e780
movq %r12, %rdi
movq %r15, %rsi
callq 0x14f9c
testb %al, %al
je 0x14b69
movq (%r13), %rax
movq 0x180(%rax), %r12
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x14b62
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x52c0
testq %r12, %r12
jne 0x14b85
jmp 0x14bac
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x14b85
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x52c0
addq $0x8, %r13
cmpq %rbp, %r13
jne 0x14b0c
movq 0x178(%r14), %rdi
testq %rdi, %rdi
je 0x14ba8
movq %rbx, %rsi
callq 0x14aa8
jmp 0x14bae
xorl %eax, %eax
jmp 0x14bae
movb $0x1, %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x14bdc
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x52c0
movq %rbx, %rdi
callq 0x5510
// File: /workspace/github_cpp_makefile_star2_O3/meirdev[P]HexViewer/./CLI11.hpp
// Function: CLI::detail::split_long(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
inline bool split_long(const std::string &current, std::string &name, std::string &value) {
    if(current.size() > 2 && current.substr(0, 2) == "--" && valid_first_char(current[2])) {
        auto loc = current.find_first_of('=');
        if(loc != std::string::npos) {
            name = current.substr(2, loc - 2);
            value = current.substr(loc + 1);
        } else {
            name = current.substr(2);
            value = "";
        }
        return true;
    } else
        return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
cmpq $0x3, 0x8(%rdi)
jb 0x14cfb
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
xorl %r12d, %r12d
leaq 0x8(%rsp), %r13
movl $0x2, %ecx
movq %r13, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x52e0
leaq 0xe646(%rip), %rsi      # 0x2326d
movq %r13, %rdi
callq 0x50d0
testl %eax, %eax
jne 0x14c42
movq (%r14), %rax
movsbl 0x2(%rax), %edi
callq 0xfd74
movl %eax, %r12d
leaq 0x18(%rsp), %rbp
movq -0x10(%rbp), %rdi
cmpq %rbp, %rdi
je 0x14c5d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x52c0
testb %r12b, %r12b
je 0x14cfb
movq %r14, %rdi
movl $0x3d, %esi
xorl %edx, %edx
callq 0x53c0
cmpq $-0x1, %rax
je 0x14cff
movq %rax, %r12
leaq -0x2(%rax), %rcx
leaq 0x8(%rsp), %r13
movl $0x2, %edx
movq %r13, %rdi
movq %r14, %rsi
callq 0x52e0
movq %r15, %rdi
movq %r13, %rsi
callq 0x5370
movq (%r13), %rdi
cmpq %rbp, %rdi
je 0x14cbc
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x52c0
incq %r12
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq $-0x1, %rcx
callq 0x52e0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5370
movq (%r15), %rdi
cmpq %rbp, %rdi
je 0x14d54
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x52c0
jmp 0x14d54
xorl %eax, %eax
jmp 0x14d56
leaq 0x8(%rsp), %r12
movl $0x2, %edx
movq %r12, %rdi
movq %r14, %rsi
movq $-0x1, %rcx
callq 0x52e0
movq %r15, %rdi
movq %r12, %rsi
callq 0x5370
movq (%r12), %rdi
cmpq %rbp, %rdi
je 0x14d3c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x52c0
movq 0x8(%rbx), %rdx
leaq 0xea17(%rip), %rcx      # 0x2375e
movq %rbx, %rdi
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x5460
movb $0x1, %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x14d83
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x52c0
movq %rbx, %rdi
callq 0x5510
// File: /workspace/github_cpp_makefile_star2_O3/meirdev[P]HexViewer/./CLI11.hpp
// Function: CLI::detail::split_short(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
inline bool split_short(const std::string &current, std::string &name, std::string &rest) {
    if(current.size() > 1 && current[0] == '-' && valid_first_char(current[1])) {
        name = current.substr(1, 1);
        rest = current.substr(2);
        return true;
    } else
        return false;
}

// Assembly:
cmpq $0x2, 0x8(%rdi)
jb 0x14e47
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
movq (%rdi), %rax
cmpb $0x2d, (%rax)
jne 0x14e4a
movq %rdx, %rbx
movq %rsi, %r15
movsbl 0x1(%rax), %edi
callq 0xfd74
testb %al, %al
je 0x14e4a
leaq 0x8(%rsp), %r12
movl $0x1, %edx
movl $0x1, %ecx
movq %r12, %rdi
movq %r14, %rsi
callq 0x52e0
movq %r15, %rdi
movq %r12, %rsi
callq 0x5370
movq (%r12), %rdi
leaq 0x18(%rsp), %r12
cmpq %r12, %rdi
je 0x14e07
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x52c0
leaq 0x8(%rsp), %r15
movl $0x2, %edx
movq %r15, %rdi
movq %r14, %rsi
movq $-0x1, %rcx
callq 0x52e0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5370
movq (%r15), %rdi
cmpq %r12, %rdi
je 0x14e43
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x52c0
movb $0x1, %al
jmp 0x14e4c
xorl %eax, %eax
retq
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/meirdev[P]HexViewer/./CLI11.hpp
// Function: CLI::detail::split_windows(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
inline bool split_windows(const std::string &current, std::string &name, std::string &value) {
    if(current.size() > 1 && current[0] == '/' && valid_first_char(current[1])) {
        auto loc = current.find_first_of(':');
        if(loc != std::string::npos) {
            name = current.substr(1, loc - 1);
            value = current.substr(loc + 1);
        } else {
            name = current.substr(1);
            value = "";
        }
        return true;
    } else
        return false;
}

// Assembly:
cmpq $0x2, 0x8(%rdi)
jb 0x14f2c
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %r14
movq (%rdi), %rax
cmpb $0x2f, (%rax)
jne 0x14f2f
movq %rdx, %rbx
movq %rsi, %r15
movsbl 0x1(%rax), %edi
callq 0xfd74
testb %al, %al
je 0x14f2f
movq %r14, %rdi
movl $0x3a, %esi
xorl %edx, %edx
callq 0x53c0
cmpq $-0x1, %rax
je 0x14f33
movq %rax, %r12
leaq -0x1(%rax), %rcx
movq %rsp, %r13
movl $0x1, %edx
movq %r13, %rdi
movq %r14, %rsi
callq 0x52e0
movq %r15, %rdi
movq %r13, %rsi
callq 0x5370
movq (%r13), %rdi
leaq 0x10(%rsp), %r13
cmpq %r13, %rdi
je 0x14eef
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x52c0
incq %r12
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq $-0x1, %rcx
callq 0x52e0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5370
movq (%r15), %rdi
cmpq %r13, %rdi
je 0x14f8b
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x52c0
jmp 0x14f8b
xorl %eax, %eax
retq
xorl %eax, %eax
jmp 0x14f8d
movq %rsp, %r12
movl $0x1, %edx
movq %r12, %rdi
movq %r14, %rsi
movq $-0x1, %rcx
callq 0x52e0
movq %r15, %rdi
movq %r12, %rsi
callq 0x5370
movq (%r12), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x14f73
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x52c0
movq 0x8(%rbx), %rdx
leaq 0xe7e0(%rip), %rcx      # 0x2375e
movq %rbx, %rdi
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x5460
movb $0x1, %al
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x16a87
movq 0x1a8(%rdi), %rax
cmpq 0x1b0(%rdi), %rax
je 0x16a4e
callq 0x17352
movb $0x1, 0x1d8(%rbx)
cmpq $0x0, 0x1c0(%rbx)
je 0x16a87
leaq 0x1b8(%rbx), %rdx
movq 0x1e8(%rbx), %rsi
leaq 0x8(%rsp), %rdi
callq 0x17b8a
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x17c8a
leaq 0x8(%rsp), %rdi
callq 0xe074
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rdx, %r15
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0xe074
jmp 0x16aa9
movq %rdx, %r15
movq %rax, %r14
cmpl $0x1, %r15d
jne 0x16ad4
movq %r14, %rdi
callq 0x5140
cmpb $0x1, 0x1d8(%rbx)
je 0x16ac7
callq 0x54b0
jmp 0x16a87
callq 0x5420
movq %rax, %r14
callq 0x54b0
movq %r14, %rdi
callq 0x5510
movq %rax, %rdi
callq 0x85dd
// File: /workspace/github_cpp_makefile_star2_O3/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 0x16cf4
movq (%r14), %rdi
movq 0x1b0(%rdi), %rax
cmpq 0x1a8(%rdi), %rax
je 0x16cee
cmpb $0x0, 0x1c0(%rdi)
jne 0x16cee
callq 0x17352
addq $0x8, %r14
jmp 0x16cc8
movq 0x158(%rbx), %r14
movq 0x160(%rbx), %rbx
cmpq %rbx, %r14
je 0x16d15
movq (%r14), %rdi
callq 0x16cb2
addq $0x8, %r14
jmp 0x16d02
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
movq %r12, %rdi
movq %rdx, %rsi
movl $0x8, %edx
callq 0x5490
movq (%r12), %rax
movq -0x18(%rax), %rax
cmpl $0x0, 0x48(%rsp,%rax)
jne 0x17bf4
movq (%r15), %rax
leaq 0x28(%rsp), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq *0x8(%rax)
leaq 0x28(%rsp), %rdi
callq 0x50b0
movq %rbx, %rax
addq $0x230, %rsp            # imm = 0x230
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x38, %edi
callq 0x5170
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x1e780
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x1911c
xorl %ebp, %ebp
leaq 0x17bc9(%rip), %rsi     # 0x2f800
leaq 0x3d4a(%rip), %rdx      # 0x1b988
movq %rbx, %rdi
callq 0x54d0
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x17c60
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x52c0
testb %bpl, %bpl
jne 0x17c6a
jmp 0x17c77
movq %rax, %r14
movq %rbx, %rdi
callq 0x5230
jmp 0x17c77
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x50b0
movq %r14, %rdi
callq 0x5510
nop
// File: /workspace/github_cpp_makefile_star2_O3/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), %rax
movq %rax, (%rsp)
cmpq %rax, %r12
je 0x19910
leaq 0x18(%rsp), %r13
leaq 0x8(%rsp), %rbx
movq (%r12), %r15
movq %r13, 0x8(%rsp)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x1e780
movq %r15, %rdi
movq %rbx, %rsi
callq 0x14f9c
movl %eax, %ebp
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x19901
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x52c0
testb %bpl, %bpl
jne 0x19962
addq $0x8, %r12
cmpq (%rsp), %r12
jne 0x198c2
movl $0x38, %edi
callq 0x5170
movq %rax, %rbx
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %rdi
callq 0x1e780
movb $0x1, %bpl
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x19c00
xorl %ebp, %ebp
leaq 0x15f85(%rip), %rsi     # 0x2f8d8
leaq 0x202e(%rip), %rdx      # 0x1b988
movq %rbx, %rdi
callq 0x54d0
movq (%r12), %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x1998f
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x52c0
testb %bpl, %bpl
jne 0x19999
jmp 0x199bd
movq %rax, %r14
movq %rbx, %rdi
callq 0x5230
jmp 0x199bd
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x199bd
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x52c0
movq %r14, %rdi
callq 0x5510
nop
// File: /workspace/github_cpp_makefile_star2_O3/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), %rax
movq %rax, (%rsp)
cmpq %rax, %r12
je 0x19a46
leaq 0x18(%rsp), %r13
leaq 0x8(%rsp), %rbx
movq (%r12), %r15
movq %r13, 0x8(%rsp)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x1e780
movq %r15, %rdi
movq %rbx, %rsi
callq 0x19dca
movl %eax, %ebp
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x19a37
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x52c0
testb %bpl, %bpl
jne 0x19a98
addq $0x8, %r12
cmpq (%rsp), %r12
jne 0x199f8
movl $0x38, %edi
callq 0x5170
movq %rax, %rbx
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %rdi
callq 0x1e780
movb $0x1, %bpl
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x19c00
xorl %ebp, %ebp
leaq 0x15e4f(%rip), %rsi     # 0x2f8d8
leaq 0x1ef8(%rip), %rdx      # 0x1b988
movq %rbx, %rdi
callq 0x54d0
movq (%r12), %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x19ac5
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x52c0
testb %bpl, %bpl
jne 0x19acf
jmp 0x19af3
movq %rax, %r14
movq %rbx, %rdi
callq 0x5230
jmp 0x19af3
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x19af3
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x52c0
movq %r14, %rdi
callq 0x5510
nop
// File: /workspace/github_cpp_makefile_star2_O3/meirdev[P]HexViewer/./CLI11.hpp
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> CLI::detail::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, %rdi
callq 0x53e0
movq 0x8(%r15), %rax
cmpq (%r15), %rax
je 0x1ba31
movq $-0x20, %r13
xorl %ebp, %ebp
movq %rsp, %r12
testq %rbp, %rbp
je 0x1ba06
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %r12, %rdi
callq 0x5320
movq 0x8(%r15), %rax
movq (%rax,%r13), %rsi
movq 0x8(%rax,%r13), %rdx
movq %r12, %rdi
callq 0x5320
movq 0x8(%r15), %rax
movq %rax, %rcx
subq (%r15), %rcx
incq %rbp
sarq $0x5, %rcx
addq $-0x20, %r13
cmpq %rcx, %rbp
jb 0x1b9ee
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x5480
movq 0x14573(%rip), %rsi     # 0x2ffb8
movq %rsp, %rdi
callq 0x5190
leaq 0x70(%rsp), %rdi
callq 0x5100
movq %rbx, %rax
addq $0x178, %rsp            # imm = 0x178
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1ba6e
movq %rax, %rbx
movq 0x14540(%rip), %rsi     # 0x2ffb8
movq %rsp, %rdi
callq 0x5190
leaq 0x70(%rsp), %rdi
callq 0x5100
movq %rbx, %rdi
callq 0x5510
// File: /workspace/github_cpp_makefile_star2_O3/meirdev[P]HexViewer/./CLI11.hpp
// Function: CLI::App::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
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x98(%rsi), %r14
movq 0xa0(%rsi), %r15
cmpq %r15, %r14
je 0x1c1e5
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
movq (%r14), %rdx
callq 0x1c284
cmpq 0x8(%rbx), %rax
jne 0x1c1df
movq (%r14), %rsi
movq %rbx, %rdi
callq 0xe1c4
addq $0x8, %r14
jmp 0x1c1ba
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
jmp 0x1c1f0
movq %rax, %r14
movq %rbx, %rdi
callq 0x714a
movq %r14, %rdi
callq 0x5510
nop
// File: /workspace/github_cpp_makefile_star2_O3/meirdev[P]HexViewer/./CLI11.hpp
// Function: CLI::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 0x1c5d0
addq $0x18, %r12
cmpq %r12, %rax
je 0x1c501
movq %r15, %rdi
movq %r14, %rsi
callq 0x1c57c
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x1e780
jmp 0x1c53e
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq (%r14), %rdx
leaq 0x10(%r14), %rax
cmpq %rax, %rdx
je 0x1c520
movq %rdx, (%rbx)
movq (%rax), %rcx
movq %rcx, 0x10(%rbx)
jmp 0x1c526
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movq 0x8(%r14), %rcx
movq %rcx, 0x8(%rbx)
movq %rax, (%r14)
movq $0x0, 0x8(%r14)
movb $0x0, 0x10(%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6b37(%rip), %rsi      # 0x23760
movq %rsp, %r13
movq %r13, %rdi
movq %r12, %rdx
callq 0xbe30
movq %r12, %rdi
movq %r13, %rsi
callq 0x5370
movq (%r13), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x1cc5d
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x52c0
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 (%r12), %rsi
movq 0x8(%r12), %rdx
movq %rbx, %rdi
callq 0x5320
movq 0x8(%r14), %rdx
testq %rdx, %rdx
je 0x1cce1
cmpq %r15, 0x8(%r12)
jb 0x1ccd6
leaq 0x6ab5(%rip), %rsi      # 0x2375d
movl $0x1, %edx
movq %rbx, %rdi
callq 0x5320
movq (%rbx), %rax
movq -0x18(%rax), %rax
movq %r13, 0x10(%rbx,%rax)
leaq 0x6a96(%rip), %rsi      # 0x2375e
movq %rbx, %rdi
xorl %edx, %edx
callq 0x5320
movq 0x8(%r14), %rdx
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x5320
leaq 0x6a75(%rip), %rsi      # 0x2375d
movl $0x1, %edx
movq %rbx, %rdi
callq 0x5320
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r12
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
cmpq $0x0, 0x8(%rsi)
je 0x1d885
movl %edx, %ebp
movq %rsi, %r14
leaq 0x28(%rsp), %rdi
callq 0x5210
leaq 0x40(%rsp), %rdi
movq %r14, %rsi
callq 0x5440
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
movsbl %bpl, %ebp
leaq 0x28(%rsp), %r14
leaq 0x8(%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 0x1d84e
movq %rbx, %rdi
movq %r15, %rsi
callq 0xe1c4
jmp 0x1d826
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x1d865
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x52c0
movq 0x1272c(%rip), %rsi     # 0x2ff98
leaq 0x28(%rsp), %rdi
callq 0x5240
leaq 0xa8(%rsp), %rdi
callq 0x5100
jmp 0x1d894
leaq 0x5ed2(%rip), %rsi      # 0x2375e
movq %rbx, %rdi
callq 0x1df00
movq %rbx, %rax
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1d8ae
movq %rax, %r14
jmp 0x1d8cd
movq %rax, %r14
jmp 0x1d8eb
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x1d8cd
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x52c0
movq 0x126c4(%rip), %rsi     # 0x2ff98
leaq 0x28(%rsp), %rdi
callq 0x5240
leaq 0xa8(%rsp), %rdi
callq 0x5100
movq %rbx, %rdi
callq 0x714a
movq %r14, %rdi
callq 0x5510
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
movq (%rdi), %r12
callq 0x5060
movq %rax, %rbx
movl (%rax), %ebp
movl $0x0, (%rax)
movq %rsp, %r13
movq %r12, %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x5090
movq (%r13), %rcx
subq %r12, %rcx
je 0x1ed80
movl (%rbx), %edx
cmpl $0x22, %edx
je 0x1ed8c
testl %edx, %edx
jne 0x1ed5e
movl %ebp, (%rbx)
movl %eax, (%r15)
xorq 0x8(%r14), %rcx
movslq %eax, %rdx
xorq %rax, %rdx
orq %rcx, %rdx
sete %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4aa8(%rip), %rdi      # 0x2382f
callq 0x51d0
leaq 0x4a9c(%rip), %rdi      # 0x2382f
callq 0x5410
cmpl $0x0, (%rbx)
jne 0x1ed9f
movl %ebp, (%rbx)
cmpl $0x2, %edx
je 0x1eda9
cmpl $0x1, %edx
jne 0x1edba
movq %rax, %rdi
callq 0x5140
callq 0x54b0
xorl %eax, %eax
jmp 0x1ed71
movq %rax, %rdi
callq 0x5510
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
cmpq $0x0, 0x8(%rdi)
movq (%rdi), %r12
je 0x1eebe
cmpb $0x2d, (%r12)
jne 0x1eebe
xorl %eax, %eax
jmp 0x1eefe
callq 0x5060
movq %rax, %rbx
movl (%rax), %ebp
movl $0x0, (%rax)
movq %rsp, %r13
movq %r12, %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x53d0
movq (%r13), %rcx
subq %r12, %rcx
je 0x1ef0d
movl (%rbx), %edx
cmpl $0x22, %edx
je 0x1ef19
testl %edx, %edx
jne 0x1eef4
movl %ebp, (%rbx)
movq %rax, (%r15)
cmpq 0x8(%r14), %rcx
sete %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4921(%rip), %rdi      # 0x23835
callq 0x51d0
leaq 0x4915(%rip), %rdi      # 0x23835
callq 0x5410
cmpl $0x0, (%rbx)
jne 0x1ef2c
movl %ebp, (%rbx)
cmpl $0x2, %edx
je 0x1ef36
cmpl $0x1, %edx
jne 0x1ef48
movq %rax, %rdi
callq 0x5140
callq 0x54b0
jmp 0x1eeba
movq %rax, %rdi
callq 0x5510
// File: /workspace/github_cpp_makefile_star2_O3/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 0x406c(%rip), %rsi      # 0x23087
movq %r14, %rdi
callq 0x50d0
testl %eax, %eax
je 0x1f051
leaq 0x5535(%rip), %rsi      # 0x24563
movq %r14, %rdi
callq 0x50d0
testl %eax, %eax
jne 0x1f072
movl $0x38, %edi
callq 0x52b0
movq %rax, %r14
movq %rax, %rdi
callq 0x1f3e8
jmp 0x1f06a
movl $0x28, %edi
callq 0x52b0
movq %rax, %r14
movzbl %bpl, %esi
movq %rax, %rdi
callq 0x1fec4
movq %r14, (%rbx)
popq %rbx
popq %r14
popq %rbp
retq
movl $0x10, %edi
callq 0x5170
movq %rax, %r14
leaq 0x54e5(%rip), %rsi      # 0x2456b
movq %rax, %rdi
callq 0x5130
movq 0x10f5b(%rip), %rsi     # 0x2fff0
movq 0x10f14(%rip), %rdx     # 0x2ffb0
movq %r14, %rdi
callq 0x54d0
movq %rax, %rbx
movq %r14, %rdi
callq 0x5230
jmp 0x1f0cb
movq %rax, %rbx
movl $0x28, %esi
jmp 0x1f0c3
movq %rax, %rbx
movl $0x38, %esi
movq %r14, %rdi
callq 0x52c0
movq %rbx, %rdi
callq 0x5510
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2175c
testl %ebp, %ebp
je 0x1f186
movq %rsp, %rdi
movl %ebp, %esi
callq 0x217be
testq %rbx, %rbx
je 0x1f196
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x217ea
movq %rsp, %rdi
callq 0x217f0
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x1f1b5
movq 0x38(%rsp), %rsi
subq %rdi, %rsi
callq 0x52c0
addq $0x48, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x1f1d6
movq 0x38(%rsp), %rsi
subq %rdi, %rsi
callq 0x52c0
movq %rbx, %rdi
callq 0x5510
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rdi), %rax
cmpq %rdx, %rax
jbe 0x1f283
movq %rdx, %r15
movq 0x8(%rbx), %rdi
leaq (%rdi,%rdx), %rcx
cmpq %rax, %rcx
jbe 0x1f2ec
movq (%rbx), %r12
testq %r12, %r12
je 0x1f2c4
movq %r12, %rdi
callq 0x5160
movq 0x10d52(%rip), %rdi     # 0x2ffc8
movq %r12, %rsi
movq %rax, %rdx
callq 0x5320
jmp 0x1f2e2
testq %r14, %r14
je 0x1f2a4
movq %r14, %rdi
callq 0x5160
movq 0x10d31(%rip), %rdi     # 0x2ffc8
movq %r14, %rsi
movq %rax, %rdx
callq 0x5320
jmp 0x1f311
movq 0x10d1d(%rip), %rax     # 0x2ffc8
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
leaq (%rax,%rcx), %rdi
movl 0x20(%rax,%rcx), %esi
orl $0x1, %esi
callq 0x54c0
jmp 0x1f311
movq 0x10cfd(%rip), %rax     # 0x2ffc8
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
leaq (%rax,%rcx), %rdi
movl 0x20(%rax,%rcx), %esi
orl $0x1, %esi
callq 0x54c0
movq $0x0, 0x8(%rbx)
xorl %edi, %edi
testq %r15, %r15
je 0x1f303
addq (%rbx), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x54a0
movq 0x8(%rbx), %rdi
addq %r15, %rdi
movq %rdi, 0x8(%rbx)
movq (%rbx), %rax
movb $0x0, (%rax,%rdi)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1f390
movq %r14, %rdi
movq %r13, %rsi
callq 0x1f320
leaq 0x3ef2(%rip), %r13      # 0x23760
movq %rax, %rdi
movq %r13, %rsi
callq 0x1f20c
xorl %ebp, %ebp
leaq 0x3edf(%rip), %rbx      # 0x23761
testq %rbp, %rbp
je 0x1f89a
testb $0x7, %bpl
movq %rbx, %rsi
cmoveq %r13, %rsi
movq %r14, %rdi
callq 0x1f20c
movq (%r15), %rax
movzwl (%rax,%rbp,2), %esi
shll $0x6, %esi
addq 0x8(%r12), %rsi
movq %r14, %rdi
callq 0x1f320
incq %rbp
cmpq $0x10, %rbp
jne 0x1f882
leaq 0x4cc3(%rip), %rsi      # 0x24584
movq %r14, %rdi
callq 0x1f20c
xorl %ebx, %ebx
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 0x1f320
incq %rbx
cmpq $0x10, %rbx
jne 0x1f8cb
leaq 0x4c8c(%rip), %rsi      # 0x24586
movq %r14, %rdi
callq 0x1f20c
leaq 0x3e54(%rip), %rsi      # 0x2375d
movq %rax, %rdi
callq 0x1f20c
movq %r14, %rdi
callq 0x1f3a0
leaq 0xf(%rsp), %rdx
movq 0x10(%rsp), %rbx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x7642
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_O3/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 0x5210
testq %r14, %r14
je 0x20a22
leaq 0x10(%rsp), %r12
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r12, %rdi
callq 0x5320
decq %r14
jne 0x20a0e
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x5480
movq 0xf562(%rip), %rsi      # 0x2ff98
movq %rsp, %rdi
callq 0x5240
leaq 0x80(%rsp), %rdi
callq 0x5100
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x20a5c
movq %rax, %rbx
movq 0xf532(%rip), %rsi      # 0x2ff98
movq %rsp, %rdi
callq 0x5240
leaq 0x80(%rsp), %rdi
callq 0x5100
movq %rbx, %rdi
callq 0x5510
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r12
pushq %rbx
subq $0x188, %rsp            # imm = 0x188
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
movq %rsp, %rdi
callq 0x5210
leaq 0x10(%rsp), %r15
cmpb $0x1, 0x20(%r12)
jne 0x20bc1
leaq 0x3a80(%rip), %rsi      # 0x245b9
movl $0xb, %edx
movq %r15, %rdi
callq 0x5320
movq 0x10(%rsp), %rax
movq -0x18(%rax), %rcx
leaq (%r15,%rcx), %r12
cmpb $0x0, 0xf1(%rsp,%rcx)
jne 0x20b78
movq %r12, %rdi
movl $0x20, %esi
callq 0x52a0
movb $0x1, 0xe1(%r12)
movq 0x10(%rsp), %rax
movb $0x30, 0xe0(%r12)
movq -0x18(%rax), %rcx
movq $0x8, 0x20(%rsp,%rcx)
movq -0x18(%rax), %rax
movl 0x28(%rsp,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x28(%rsp,%rax)
movq %r15, %rdi
movq %r14, %rsi
callq 0x51f0
leaq 0x3a02(%rip), %rsi      # 0x245b4
movl $0x4, %edx
movq %rax, %rdi
callq 0x5320
jmp 0x20c26
movq 0x10(%rsp), %rax
movq -0x18(%rax), %rcx
leaq (%r15,%rcx), %r12
cmpb $0x0, 0xf1(%rsp,%rcx)
jne 0x20bf3
movq %r12, %rdi
movl $0x20, %esi
callq 0x52a0
movb $0x1, 0xe1(%r12)
movq 0x10(%rsp), %rax
movb $0x30, 0xe0(%r12)
movq -0x18(%rax), %rcx
movq $0x8, 0x20(%rsp,%rcx)
movq -0x18(%rax), %rax
movl 0x28(%rsp,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x28(%rsp,%rax)
movq %r15, %rdi
movq %r14, %rsi
callq 0x51f0
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x5480
movq 0xf35e(%rip), %rsi      # 0x2ff98
movq %rsp, %rdi
callq 0x5240
leaq 0x80(%rsp), %rdi
callq 0x5100
movq %rbx, %rax
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0xf32d(%rip), %rsi      # 0x2ff98
movq %rsp, %rdi
callq 0x5240
leaq 0x80(%rsp), %rdi
callq 0x5100
movq %rbx, %rdi
callq 0x5510
// File: /workspace/github_cpp_makefile_star2_O3/meirdev[P]HexViewer/DataProcessing/DataProcessing.cpp
// Function: DataProcessing::setOffset(int)
void DataProcessing::setOffset(int _offset)
{
    if (_offset < 0)
    {
        _offset = static_cast<int>(m_file.size())+_offset;

        if (_offset < 0)
        {
            _offset = 0;
        }
    }

    m_offset = _offset;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
testl %esi, %esi
jns 0x217dd
movq 0x20(%rbx), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
addl %ebp, %eax
xorl %ebp, %ebp
testl %eax, %eax
cmovgl %eax, %ebp
movl %ebp, %eax
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/JoshCplusplus[P]Chemistry-Atom-Simulator-/main.cc
// Function: print_board()
void print_board(){
	for(int i = 0; i < x_size*y_size; i++){
		if(i % 31 == 0 && i > 0) cout << endl;
		cout << board[i];
	}
	cout << endl;
	usleep(300000);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
xorl %r14d, %r14d
movq 0x65fd(%rip), %rbx      # 0x9fd0
leaq 0x6c56(%rip), %r15      # 0xa630
xorl %r12d, %r12d
xorl %r13d, %r13d
testq %r14, %r14
je 0x3a37
movzwl %r12w, %eax
imull $0x843, %eax, %eax      # imm = 0x843
shrl $0x10, %eax
movl %r12d, %ecx
subl %eax, %ecx
movzwl %cx, %ecx
shrl %ecx
addl %eax, %ecx
shrl $0x4, %ecx
movl %ecx, %eax
shll $0x5, %eax
subl %ecx, %eax
addl %r13d, %eax
testw %ax, %ax
jne 0x3a37
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2150
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20d0
movq (%r14,%r15), %rsi
movq 0x8(%r14,%r15), %rdx
movq %rbx, %rdi
callq 0x2180
decl %r13d
incl %r12d
addq $0x20, %r14
cmpq $0x3a20, %r14           # imm = 0x3A20
jne 0x39e0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2150
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20d0
movl $0x493e0, %edi          # imm = 0x493E0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x21d0
// File: /workspace/github_cpp_makefile_star2_O3/JoshCplusplus[P]Chemistry-Atom-Simulator-/./atom.h
// Function: molecule::molecule(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>>, double, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
molecule(string name1, string atom1, string atom2, double energy1,string newmessage){
		name = name1;
		madeof = make_pair(atom1,atom2);
		energy = energy1;
		message = newmessage;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r8, -0x48(%rbp)
movsd %xmm0, -0x40(%rbp)
movq %rcx, %r13
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, -0x38(%rbp)
movq %rax, (%rdi)
xorl %eax, %eax
movq %rax, 0x8(%rdi)
movb %al, 0x10(%rdi)
leaq 0x20(%rdi), %rcx
movq %rcx, -0x30(%rbp)
leaq 0x30(%rdi), %rcx
movq %rcx, 0x20(%rdi)
movq %rax, 0x28(%rdi)
movb %al, 0x30(%rdi)
leaq 0x50(%rdi), %rcx
movq %rcx, 0x40(%rdi)
movq %rax, 0x48(%rdi)
movb %al, 0x50(%rdi)
leaq 0x68(%rdi), %r12
leaq 0x78(%rdi), %r15
movq %r15, 0x68(%rdi)
movq %rax, 0x70(%rdi)
movb %al, 0x78(%rdi)
callq 0x20a0
leaq -0x88(%rbp), %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x5440
leaq 0x40(%rbx), %r14
leaq -0x88(%rbp), %rsi
movq -0x30(%rbp), %rdi
callq 0x21a0
leaq -0x68(%rbp), %r13
movq %r14, %rdi
movq %r13, %rsi
callq 0x21a0
movq (%r13), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x4d12
callq 0x2140
leaq -0x78(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4d24
callq 0x2140
movsd -0x40(%rbp), %xmm0
movsd %xmm0, 0x60(%rbx)
movq %r12, %rdi
movq -0x48(%rbp), %rsi
callq 0x20a0
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4d4b
movq %rax, %r14
movq (%r12), %rdi
cmpq %r15, %rdi
je 0x4d5c
callq 0x2140
movq -0x30(%rbp), %rdi
callq 0x4f26
movq (%rbx), %rdi
cmpq -0x38(%rbp), %rdi
je 0x4d73
callq 0x2140
movq %r14, %rdi
callq 0x2230
nop