// File: /workspace/github_cpp_makefile_star2_O2/meirdev[P]HexViewer/./CLI11.hpp
// Function: CLI::App::_parse_arg(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>>>>&, CLI::detail::Classifier)
void _parse_arg(std::vector<std::string> &args, detail::Classifier current_type) {

        std::string current = args.back();

        std::string arg_name;
        std::string value;
        std::string rest;

        switch(current_type) {
        case detail::Classifier::LONG:
            if(!detail::split_long(current, arg_name, value))
                throw HorribleError("Long parsed but missing (you should not see this):" + args.back());
            break;
        case detail::Classifier::SHORT:
            if(!detail::split_short(current, arg_name, rest))
                throw HorribleError("Short parsed but missing! You should not see this");
            break;
        case detail::Classifier::WINDOWS:
            if(!detail::split_windows(current, arg_name, value))
                throw HorribleError("windows option parsed but missing! You should not see this");
            break;
        default:
            throw HorribleError("parsing got called with invalid option! You should not see this");
        }

        auto op_ptr =
            std::find_if(std::begin(options_), std::end(options_), [arg_name, current_type](const Option_p &opt) {
                if(current_type == detail::Classifier::LONG)
                    return opt->check_lname(arg_name);
                if(current_type == detail::Classifier::SHORT)
                    return opt->check_sname(arg_name);
                // this will only get called for detail::Classifier::WINDOWS
                return opt->check_lname(arg_name) || opt->check_sname(arg_name);
            });

        // Option not found
        if(op_ptr == std::end(options_)) {
            // If a subcommand, try the master command
            if(parent_ != nullptr && fallthrough_)
                return parent_->_parse_arg(args, current_type);
            // Otherwise, add to missing
            else {
                args.pop_back();
                missing_.emplace_back(current_type, current);
                return;
            }
        }

        args.pop_back();

        // Get a reference to the pointer to make syntax bearable
        Option_p &op = *op_ptr;

        int num = op->get_items_expected();

        // Make sure we always eat the minimum for unlimited vectors
        int collected = 0;

        // --this=value
        if(!value.empty()) {
            // If exact number expected
            if(num > 0)
                num--;
            op->add_result(value);
            parse_order_.push_back(op.get());
            collected += 1;
        } else if(num == 0) {
            op->add_result("");
            parse_order_.push_back(op.get());
            // -Trest
        } else if(!rest.empty()) {
            if(num > 0)
                num--;
            op->add_result(rest);
            parse_order_.push_back(op.get());
            rest = "";
            collected += 1;
        }

        // Unlimited vector parser
        if(num < 0) {
            while(!args.empty() && _recognize(args.back()) == detail::Classifier::NONE) {
                if(collected >= -num) {
                    // We could break here for allow extras, but we don't

                    // If any positionals remain, don't keep eating
                    if(_count_remaining_positionals() > 0)
                        break;
                }
                op->add_result(args.back());
                parse_order_.push_back(op.get());
                args.pop_back();
                collected++;
            }

            // Allow -- to end an unlimited list and "eat" it
            if(!args.empty() && _recognize(args.back()) == detail::Classifier::POSITIONAL_MARK)
                args.pop_back();

        } else {
            while(num > 0 && !args.empty()) {
                num--;
                std::string current_ = args.back();
                args.pop_back();
                op->add_result(current_);
                parse_order_.push_back(op.get());
            }

            if(num > 0) {
                throw ArgumentMismatch::TypedAtLeast(op->get_name(), num, op->get_type_name());
            }
        }

        if(!rest.empty()) {
            rest = "-" + rest;
            args.push_back(rest);
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x248, %rsp            # imm = 0x248
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r15
movl %edx, 0x14(%rsp)
movq 0x8(%rsi), %rsi
addq $-0x20, %rsi
leaq 0xa0(%rsp), %rdi
callq 0x53f0
leaq 0x90(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
xorl %ecx, %ecx
leaq 0x70(%rsp), %rdx
movq %rdx, -0x10(%rdx)
andq $0x0, -0x8(%rdx)
leaq 0x48(%rsp), %rsi
movq %rsi, -0x10(%rsi)
andq $0x0, -0x8(%rsi)
movb %cl, (%rax)
movb %cl, (%rdx)
movb %cl, (%rsi)
cmpl $0x2, %ebp
je 0xf783
cmpl $0x4, %ebp
je 0xf711
cmpl $0x3, %ebp
jne 0xfbf1
leaq 0xa0(%rsp), %rdi
leaq 0x80(%rsp), %rsi
leaq 0x60(%rsp), %rdx
callq 0x10045
testb %al, %al
jne 0xf7a5
pushq $0x38
popq %rdi
callq 0x51a0
movq %rax, %r14
movq 0x8(%rbx), %rdx
addq $-0x20, %rdx
leaq 0x9d2b(%rip), %rsi      # 0x193ff
leaq 0x1e8(%rsp), %rdi
callq 0x94d9
movb $0x1, %bpl
leaq 0x1e8(%rsp), %rsi
movq %r14, %rdi
callq 0x10796
xorl %ebp, %ebp
leaq 0x1807b(%rip), %rsi     # 0x27778
leaq 0x4b02(%rip), %rdx      # 0x14206
movq %r14, %rdi
callq 0x54e0
jmp 0xfc91
leaq 0xa0(%rsp), %rdi
leaq 0x80(%rsp), %rsi
leaq 0x60(%rsp), %rdx
callq 0x10221
testb %al, %al
jne 0xf7a5
pushq $0x38
popq %rdi
callq 0x51a0
movq %rax, %r14
leaq 0x9d23(%rip), %rsi      # 0x19464
leaq 0x1a8(%rsp), %rdi
leaq 0x18(%rsp), %rdx
callq 0x6844
movb $0x1, %bpl
leaq 0x1a8(%rsp), %rsi
movq %r14, %rdi
callq 0x10796
xorl %ebp, %ebp
leaq 0x18009(%rip), %rsi     # 0x27778
leaq 0x4a90(%rip), %rdx      # 0x14206
movq %r14, %rdi
callq 0x54e0
jmp 0xfc91
leaq 0xa0(%rsp), %rdi
leaq 0x80(%rsp), %rsi
leaq 0x38(%rsp), %rdx
callq 0x1018a
testb %al, %al
je 0xfc42
movq 0x98(%r15), %r14
movq %r15, (%rsp)
movq 0xa0(%r15), %r15
leaq 0x120(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0x53f0
leaq 0x120(%rsp), %rdx
movl %ebp, 0x20(%rdx)
movq %r14, %rdi
movq %r15, %rsi
callq 0x10abf
movq %rax, %r15
leaq 0x120(%rsp), %rdi
callq 0x5180
movq (%rsp), %r14
cmpq 0xa0(%r14), %r15
je 0xf92f
movq %rbx, %rdi
callq 0xf44a
movq (%r15), %rdi
callq 0x6880
movl %eax, %ebp
cmpq $0x0, 0x68(%rsp)
pushq $0x1
popq %r12
je 0xf97d
xorl %r13d, %r13d
testl %ebp, %ebp
setg 0x8(%rsp)
movq (%r15), %r14
leaq 0x100(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x53f0
leaq 0x100(%rsp), %rsi
movq %r14, %rdi
callq 0x10b3c
leaq 0x100(%rsp), %rdi
callq 0x5180
movq (%rsp), %rax
leaq 0x128(%rax), %rdi
movq (%r15), %rax
leaq 0x18(%rsp), %rsi
movq %rax, (%rsi)
callq 0x10f64
movb 0x8(%rsp), %al
movb %al, %r13b
subl %r13d, %ebp
testl %ebp, %ebp
jns 0xfafd
negl %ebp
movq (%rsp), %rax
addq $0x128, %rax            # imm = 0x128
movq %rax, 0x8(%rsp)
leaq 0x228(%rsp), %r13
movq 0x8(%rbx), %rsi
cmpq %rsi, (%rbx)
je 0xf9fe
addq $-0x20, %rsi
movq (%rsp), %rdi
callq 0xf316
testl %eax, %eax
jne 0xf9fe
cmpl %ebp, %r12d
jl 0xf8e2
movq (%rsp), %rdi
xorl %esi, %esi
callq 0x10702
testq %rax, %rax
jne 0xf9fe
movq (%r15), %r14
movq 0x8(%rbx), %rsi
addq $-0x20, %rsi
movq %r13, %rdi
callq 0x53f0
movq %r14, %rdi
movq %r13, %rsi
callq 0x10b3c
movq %r13, %rdi
callq 0x5180
movq (%r15), %rax
movq %rax, 0x18(%rsp)
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x10f64
movq %rbx, %rdi
callq 0xf44a
incl %r12d
jmp 0xf8a7
movq 0x178(%r14), %rdi
testq %rdi, %rdi
je 0xf954
cmpb $0x1, 0x172(%r14)
jne 0xf954
movq %rbx, %rsi
movl %ebp, %edx
callq 0xf616
jmp 0xfa67
movq %rbx, %rdi
callq 0xf44a
addq $0x110, %r14            # imm = 0x110
leaq 0x14(%rsp), %rsi
leaq 0xa0(%rsp), %rdx
movq %r14, %rdi
callq 0xf408
jmp 0xfa67
testl %ebp, %ebp
je 0xfaa7
cmpq $0x0, 0x40(%rsp)
je 0xfb7a
xorl %r13d, %r13d
testl %ebp, %ebp
setg 0x8(%rsp)
movq (%r15), %r14
leaq 0xc0(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x53f0
leaq 0xc0(%rsp), %rsi
movq %r14, %rdi
callq 0x10b3c
leaq 0xc0(%rsp), %rdi
callq 0x5180
movq (%rsp), %rax
leaq 0x128(%rax), %rdi
movq (%r15), %rax
leaq 0x18(%rsp), %rsi
movq %rax, (%rsi)
callq 0x10f64
leaq 0x9db9(%rip), %rsi      # 0x197a8
leaq 0x38(%rsp), %rdi
callq 0x5570
jmp 0xf87c
movq 0x8(%rbx), %rsi
cmpq %rsi, (%rbx)
je 0xfa21
addq $-0x20, %rsi
movq (%rsp), %rdi
callq 0xf316
cmpl $0x1, %eax
jne 0xfa21
movq %rbx, %rdi
callq 0xf44a
cmpq $0x0, 0x40(%rsp)
je 0xfa67
leaq 0x983e(%rip), %rsi      # 0x1926e
leaq 0x18(%rsp), %rdi
leaq 0x38(%rsp), %rdx
callq 0x94d9
leaq 0x38(%rsp), %r14
leaq 0x18(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x5360
movq %r15, %rdi
callq 0x5180
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb27e
leaq 0x38(%rsp), %rdi
callq 0x5180
leaq 0x60(%rsp), %rdi
callq 0x5180
leaq 0x80(%rsp), %rdi
callq 0x5180
leaq 0xa0(%rsp), %rdi
callq 0x5180
addq $0x248, %rsp            # imm = 0x248
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%r15), %r14
leaq 0x9cf7(%rip), %rsi      # 0x197a8
leaq 0xe0(%rsp), %rdi
leaq 0x18(%rsp), %rdx
callq 0x6844
leaq 0xe0(%rsp), %rsi
movq %r14, %rdi
callq 0x10b3c
leaq 0xe0(%rsp), %rdi
callq 0x5180
movq (%rsp), %rax
leaq 0x128(%rax), %rdi
movq (%r15), %rax
leaq 0x18(%rsp), %rsi
movq %rax, (%rsi)
callq 0x10f64
xorl %ebp, %ebp
addq $0x128, (%rsp)          # imm = 0x128
leaq 0x18(%rsp), %r12
leaq 0x208(%rsp), %r13
testl %ebp, %ebp
jle 0xfa21
movq 0x8(%rbx), %rsi
cmpq %rsi, (%rbx)
je 0xfb82
addq $-0x20, %rsi
movq %r12, %rdi
callq 0x53f0
movq %rbx, %rdi
callq 0xf44a
movq (%r15), %r14
movq %r13, %rdi
movq %r12, %rsi
callq 0x53f0
movq %r14, %rdi
movq %r13, %rsi
callq 0x10b3c
movq %r13, %rdi
callq 0x5180
movq (%r15), %rax
movq %rax, 0x58(%rsp)
movq (%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x10f64
movq %r12, %rdi
callq 0x5180
decl %ebp
jmp 0xfb12
xorl %r12d, %r12d
jmp 0xf886
pushq $0x38
popq %rdi
callq 0x51a0
movq %rax, %r14
movq (%r15), %rsi
leaq 0x168(%rsp), %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xa9b8
movl $0xd8, %esi
addq (%r15), %rsi
leaq 0x148(%rsp), %rdi
callq 0x112f2
movb $0x1, %r15b
leaq 0x168(%rsp), %rsi
leaq 0x148(%rsp), %rcx
movq %r14, %rdi
movl %ebp, %edx
callq 0x10b58
xorl %r15d, %r15d
leaq 0x17bdb(%rip), %rsi     # 0x277b8
leaq 0x4622(%rip), %rdx      # 0x14206
movq %r14, %rdi
callq 0x54e0
jmp 0xfc91
pushq $0x38
popq %rdi
callq 0x51a0
movq %rax, %r14
leaq 0x989c(%rip), %rsi      # 0x1949f
leaq 0x188(%rsp), %rdi
leaq 0x18(%rsp), %rdx
callq 0x6844
movb $0x1, %bpl
leaq 0x188(%rsp), %rsi
movq %r14, %rdi
callq 0x10796
xorl %ebp, %ebp
leaq 0x17b47(%rip), %rsi     # 0x27778
leaq 0x45ce(%rip), %rdx      # 0x14206
movq %r14, %rdi
callq 0x54e0
jmp 0xfc91
pushq $0x38
popq %rdi
callq 0x51a0
movq %rax, %r14
leaq 0x97de(%rip), %rsi      # 0x19432
leaq 0x1c8(%rsp), %rdi
leaq 0x18(%rsp), %rdx
callq 0x6844
movb $0x1, %bpl
leaq 0x1c8(%rsp), %rsi
movq %r14, %rdi
callq 0x10796
xorl %ebp, %ebp
leaq 0x17af6(%rip), %rsi     # 0x27778
leaq 0x457d(%rip), %rdx      # 0x14206
movq %r14, %rdi
callq 0x54e0
jmp 0xfda9
movq %rax, %rbx
leaq 0xe0(%rsp), %rdi
jmp 0xfda2
jmp 0xfda9
jmp 0xfda9
movq %rax, %rbx
leaq 0xc0(%rsp), %rdi
jmp 0xfda2
movq %rax, %rbx
leaq 0x1c8(%rsp), %rdi
jmp 0xfd01
jmp 0xfd79
movq %rax, %rbx
leaq 0x1a8(%rsp), %rdi
jmp 0xfd01
jmp 0xfd79
movq %rax, %rbx
leaq 0x1e8(%rsp), %rdi
jmp 0xfd01
jmp 0xfd79
movq %rax, %rbx
leaq 0x188(%rsp), %rdi
callq 0x5180
testb %bpl, %bpl
jne 0xfd7c
jmp 0xfdac
jmp 0xfd79
jmp 0xfda9
jmp 0xfda9
movq %rax, %rbx
leaq 0x100(%rsp), %rdi
jmp 0xfda2
movq %rax, %rbx
leaq 0x120(%rsp), %rdi
jmp 0xfda2
jmp 0xfda9
jmp 0xfda9
jmp 0xfda9
jmp 0xfda9
movq %rax, %rbx
leaq 0x228(%rsp), %rdi
jmp 0xfda2
movq %rax, %rbx
leaq 0x148(%rsp), %rdi
callq 0x5180
jmp 0xfd63
movq %rax, %rbx
movb $0x1, %r15b
leaq 0x168(%rsp), %rdi
callq 0x5180
testb %r15b, %r15b
jne 0xfd7c
jmp 0xfdac
jmp 0xfda9
movq %rax, %rbx
movq %r14, %rdi
callq 0x5240
jmp 0xfdac
jmp 0xfd88
movq %rax, %rbx
jmp 0xfd9d
movq %rax, %rbx
leaq 0x208(%rsp), %rdi
callq 0x5180
leaq 0x18(%rsp), %rdi
callq 0x5180
jmp 0xfdac
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x5180
leaq 0x60(%rsp), %rdi
callq 0x5180
leaq 0x80(%rsp), %rdi
callq 0x5180
leaq 0xa0(%rsp), %rdi
callq 0x5180
movq %rbx, %rdi
callq 0x5510