// File: /workspace/github_cpp_makefile_star2_O1/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
movq %rsi, %rbx
movq %rdi, %r15
movl %edx, 0x14(%rsp)
movq 0x8(%rsi), %rax
leaq 0x88(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movq -0x20(%rax), %rsi
movq -0x18(%rax), %rdx
addq %rsi, %rdx
leaq 0x78(%rsp), %rdi
callq 0x1eb20
leaq 0x68(%rsp), %rcx
movq %rcx, -0x10(%rcx)
xorl %eax, %eax
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
leaq 0xa8(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
leaq 0x48(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
movl 0x14(%rsp), %eax
cmpl $0x2, %eax
je 0x13e1c
cmpl $0x4, %eax
je 0x13d99
cmpl $0x3, %eax
jne 0x1456d
leaq 0x78(%rsp), %rdi
leaq 0x58(%rsp), %rsi
leaq 0x98(%rsp), %rdx
callq 0x14cbd
testb %al, %al
jne 0x13e38
movl $0x38, %edi
callq 0x5170
movq %rax, %r14
movq 0x8(%rbx), %rdx
addq $-0x20, %rdx
leaq 0xf6a3(%rip), %rsi      # 0x233ff
leaq 0x228(%rsp), %rdi
callq 0xbe64
movb $0x1, %bpl
leaq 0x228(%rsp), %rsi
movq %r14, %rdi
callq 0x15864
xorl %ebp, %ebp
leaq 0x1b9fb(%rip), %rsi     # 0x2f780
leaq 0x7f2e(%rip), %rdx      # 0x1bcba
movq %r14, %rdi
callq 0x54d0
jmp 0x1462d
leaq 0x78(%rsp), %rdi
leaq 0x58(%rsp), %rsi
leaq 0x98(%rsp), %rdx
callq 0x14f3a
testb %al, %al
jne 0x13e38
movl $0x38, %edi
callq 0x5170
movq %rax, %r14
leaq 0x1b8(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xf68c(%rip), %rsi      # 0x23464
leaq 0xf6bf(%rip), %rdx      # 0x2349e
leaq 0x1a8(%rsp), %rdi
callq 0xc794
movb $0x1, %bpl
leaq 0x1a8(%rsp), %rsi
movq %r14, %rdi
callq 0x15864
xorl %ebp, %ebp
leaq 0x1b978(%rip), %rsi     # 0x2f780
leaq 0x7eab(%rip), %rdx      # 0x1bcba
movq %r14, %rdi
callq 0x54d0
jmp 0x1462d
leaq 0x78(%rsp), %rdi
leaq 0x58(%rsp), %rsi
leaq 0x38(%rsp), %rdx
callq 0x14e6d
testb %al, %al
je 0x145ce
movq 0x98(%r15), %r14
movq %r15, %r13
movq 0xa0(%r15), %r15
leaq 0x170(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x58(%rsp), %rsi
movq 0x60(%rsp), %rdx
addq %rsi, %rdx
leaq 0x160(%rsp), %rdi
callq 0x1eb20
movl 0x14(%rsp), %eax
leaq 0x160(%rsp), %rdx
movl %eax, 0x20(%rdx)
movq %r14, %rdi
movq %r15, %rsi
callq 0x15c9c
movq %rax, 0x8(%rsp)
movq 0x160(%rsp), %rdi
cmpq %r12, %rdi
movq %r13, %r15
je 0x13eaf
movq 0x170(%rsp), %rsi
incq %rsi
callq 0x52c0
movq 0x8(%rsp), %rax
cmpq 0xa0(%r15), %rax
je 0x13fd5
movq 0x8(%rbx), %rax
leaq -0x20(%rax), %rcx
movq %rcx, 0x8(%rbx)
movq -0x20(%rax), %rdi
addq $-0x10, %rax
cmpq %rax, %rdi
je 0x13ee5
movq (%rax), %rsi
incq %rsi
callq 0x52c0
movq 0x8(%rsp), %rax
movq (%rax), %r14
movl 0xfc(%r14), %edx
movl 0x100(%r14), %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpl $0x0, 0x24(%r14)
jne 0x13f18
movl $0x1, %ecx
testl %eax, %eax
jns 0x13f18
movl %edx, %ecx
sarl $0x1f, %ecx
orl $0x1, %ecx
imull %edx, %eax
movl %eax, %r12d
negl %r12d
cmovsl %eax, %r12d
imull %ecx, %r12d
movq 0xa0(%rsp), %rdx
testq %rdx, %rdx
je 0x1403e
xorl %ebp, %ebp
testl %r12d, %r12d
setg 0x7(%rsp)
leaq 0x150(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0x98(%rsp), %rsi
addq %rsi, %rdx
leaq 0x140(%rsp), %rdi
callq 0x1eb20
leaq 0x1a8(%r14), %rdi
leaq 0x140(%rsp), %rsi
callq 0xe21c
movb $0x0, 0x1c0(%r14)
movq 0x140(%rsp), %rdi
cmpq %r15, %rdi
movq %r13, %r15
je 0x13fa4
movq 0x150(%rsp), %rsi
incq %rsi
callq 0x52c0
leaq 0x128(%r15), %rdi
movq 0x8(%rsp), %rax
movq (%rax), %rax
leaq 0x18(%rsp), %rsi
movq %rax, (%rsi)
callq 0x164ce
movb 0x7(%rsp), %al
movb %al, %bpl
subl %ebp, %r12d
movl $0x1, %r14d
jmp 0x14185
movq 0x178(%r15), %rdi
testq %rdi, %rdi
je 0x13ffc
cmpb $0x1, 0x172(%r15)
jne 0x13ffc
movl 0x14(%rsp), %edx
movq %rbx, %rsi
callq 0x13c90
jmp 0x1444f
movq 0x8(%rbx), %rax
leaq -0x20(%rax), %rcx
movq %rcx, 0x8(%rbx)
movq -0x20(%rax), %rdi
addq $-0x10, %rax
cmpq %rax, %rdi
je 0x14020
movq (%rax), %rsi
incq %rsi
callq 0x52c0
addq $0x110, %r15            # imm = 0x110
leaq 0x14(%rsp), %rsi
leaq 0x78(%rsp), %rdx
movq %r15, %rdi
callq 0x139a8
jmp 0x1444f
testl %eax, %eax
je 0x14106
movq 0x40(%rsp), %rdx
testq %rdx, %rdx
je 0x14182
xorl %ebp, %ebp
testl %r12d, %r12d
setg 0x7(%rsp)
leaq 0x110(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0x38(%rsp), %rsi
addq %rsi, %rdx
leaq 0x100(%rsp), %rdi
callq 0x1eb20
leaq 0x1a8(%r14), %rdi
leaq 0x100(%rsp), %rsi
callq 0xe21c
movb $0x0, 0x1c0(%r14)
movq 0x100(%rsp), %rdi
cmpq %r15, %rdi
movq %r13, %r14
je 0x140bb
movq 0x110(%rsp), %rsi
incq %rsi
callq 0x52c0
leaq 0x128(%r14), %rdi
movq 0x8(%rsp), %rax
movq (%rax), %rax
leaq 0x18(%rsp), %rsi
movq %rax, (%rsi)
callq 0x164ce
leaq 0x38(%rsp), %rdi
movq 0x8(%rdi), %rdx
leaq 0xf677(%rip), %rcx      # 0x2375e
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x5460
movb 0x7(%rsp), %al
movb %al, %bpl
subl %ebp, %r12d
movl $0x1, %r14d
movq %r13, %r15
jmp 0x14185
leaq 0x130(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0xf644(%rip), %rdx      # 0x2375e
leaq 0x120(%rsp), %rdi
movq %rdx, %rsi
callq 0xc794
leaq 0x1a8(%r14), %rdi
leaq 0x120(%rsp), %rsi
callq 0xe21c
movb $0x0, 0x1c0(%r14)
movq 0x120(%rsp), %rdi
cmpq %r12, %rdi
je 0x14163
movq 0x130(%rsp), %rsi
incq %rsi
callq 0x52c0
leaq 0x128(%r15), %rdi
movq 0x8(%rsp), %rax
movq (%rax), %rax
leaq 0x18(%rsp), %rsi
movq %rax, (%rsi)
callq 0x164ce
xorl %r12d, %r12d
xorl %r14d, %r14d
testl %r12d, %r12d
js 0x142b5
je 0x143f8
leaq 0x28(%rsp), %r13
addq $0x128, %r15            # imm = 0x128
leaq 0xd8(%rsp), %rbp
movq 0x8(%rbx), %rax
cmpq %rax, (%rbx)
je 0x144e0
movq %r13, %r14
movq %r13, 0x18(%rsp)
movq -0x20(%rax), %rsi
movq -0x18(%rax), %rdx
addq %rsi, %rdx
leaq 0x18(%rsp), %rdi
callq 0x1eb20
movq %r15, %r13
movq 0x8(%rbx), %rax
leaq -0x20(%rax), %rcx
movq %rcx, 0x8(%rbx)
movq -0x20(%rax), %rdi
addq $-0x10, %rax
cmpq %rax, %rdi
je 0x141f9
movq (%rax), %rsi
incq %rsi
callq 0x52c0
movq 0x8(%rsp), %rax
movq (%rax), %r15
leaq 0xe8(%rsp), %rax
movq %rax, 0xd8(%rsp)
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
addq %rsi, %rdx
movq %rbp, %rdi
callq 0x1eb20
leaq 0x1a8(%r15), %rdi
movq %rbp, %rsi
callq 0xe21c
movb $0x0, 0x1c0(%r15)
movq 0xd8(%rsp), %rdi
leaq 0xe8(%rsp), %rax
cmpq %rax, %rdi
je 0x14262
movq 0xe8(%rsp), %rsi
incq %rsi
callq 0x52c0
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, 0xf8(%rsp)
movq %r13, %r15
movq %r13, %rdi
leaq 0xf8(%rsp), %rsi
callq 0x164ce
movq 0x18(%rsp), %rdi
movq %r14, %r13
cmpq %r14, %rdi
je 0x1429f
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x52c0
decl %r12d
leal 0x1(%r12), %eax
cmpl $0x1, %eax
jg 0x141a8
jmp 0x143f8
movq 0x8(%rbx), %rsi
cmpq %rsi, (%rbx)
je 0x143ba
negl %r12d
leaq 0x128(%r15), %r13
addq $-0x20, %rsi
movq %r15, %rdi
callq 0x13878
testl %eax, %eax
jne 0x143ba
cmpl %r12d, %r14d
jl 0x142f8
movq %r15, %rdi
xorl %esi, %esi
callq 0x15776
testq %rax, %rax
jne 0x143ba
movq 0x8(%rsp), %rax
movq (%rax), %rbp
movq 0x8(%rbx), %rax
leaq 0xc8(%rsp), %rcx
movq %rcx, 0xb8(%rsp)
movq -0x20(%rax), %rsi
movq -0x18(%rax), %rdx
addq %rsi, %rdx
leaq 0xb8(%rsp), %rdi
callq 0x1eb20
leaq 0x1a8(%rbp), %rdi
leaq 0xb8(%rsp), %rsi
callq 0xe21c
movb $0x0, 0x1c0(%rbp)
movq 0xb8(%rsp), %rdi
leaq 0xc8(%rsp), %rax
cmpq %rax, %rdi
je 0x1436c
movq 0xc8(%rsp), %rsi
incq %rsi
callq 0x52c0
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movq %r13, %rdi
leaq 0x18(%rsp), %rsi
callq 0x164ce
movq 0x8(%rbx), %rax
leaq -0x20(%rax), %rcx
movq %rcx, 0x8(%rbx)
movq -0x20(%rax), %rdi
addq $-0x10, %rax
cmpq %rax, %rdi
je 0x143aa
movq (%rax), %rsi
incq %rsi
callq 0x52c0
incl %r14d
movq 0x8(%rbx), %rsi
cmpq %rsi, (%rbx)
jne 0x142cc
movq 0x8(%rbx), %rsi
cmpq %rsi, (%rbx)
je 0x143f8
addq $-0x20, %rsi
movq %r15, %rdi
callq 0x13878
cmpl $0x1, %eax
jne 0x143f8
movq 0x8(%rbx), %rax
leaq -0x20(%rax), %rcx
movq %rcx, 0x8(%rbx)
movq -0x20(%rax), %rdi
addq $-0x10, %rax
cmpq %rax, %rdi
je 0x143f8
movq (%rax), %rsi
incq %rsi
callq 0x52c0
cmpq $0x0, 0x40(%rsp)
je 0x1444f
leaq 0xee67(%rip), %rsi      # 0x2326e
leaq 0x18(%rsp), %rdi
leaq 0x38(%rsp), %rdx
callq 0xbe64
leaq 0x38(%rsp), %rdi
leaq 0x18(%rsp), %r14
movq %r14, %rsi
callq 0x5370
movq (%r14), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x14442
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x52c0
leaq 0x38(%rsp), %rsi
movq %rbx, %rdi
callq 0xe21c
movq 0x38(%rsp), %rdi
leaq 0x48(%rsp), %rax
cmpq %rax, %rdi
leaq 0x88(%rsp), %rbx
je 0x14473
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x52c0
movq 0x98(%rsp), %rdi
leaq 0xa8(%rsp), %rax
cmpq %rax, %rdi
leaq 0x68(%rsp), %r14
je 0x1449d
movq 0xa8(%rsp), %rsi
incq %rsi
callq 0x52c0
movq 0x58(%rsp), %rdi
cmpq %r14, %rdi
je 0x144b4
movq 0x68(%rsp), %rsi
incq %rsi
callq 0x52c0
movq 0x78(%rsp), %rdi
cmpq %rbx, %rdi
je 0x144ce
movq 0x88(%rsp), %rsi
incq %rsi
callq 0x52c0
addq $0x248, %rsp            # imm = 0x248
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x38, %edi
callq 0x5170
movq %rax, %r14
movq 0x8(%rsp), %rax
movq (%rax), %rsi
leaq 0x208(%rsp), %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xd6b2
movq 0x8(%rsp), %rax
movq (%rax), %rax
cmpq $0x0, 0xe8(%rax)
jne 0x1451d
callq 0x5120
leaq 0xd8(%rax), %rsi
leaq 0x1e8(%rsp), %rdi
callq *0xf0(%rax)
movb $0x1, %bpl
leaq 0x208(%rsp), %rsi
leaq 0x1e8(%rsp), %rcx
movq %r14, %rdi
movl %r12d, %edx
callq 0x15e32
xorl %ebp, %ebp
leaq 0x1b267(%rip), %rsi     # 0x2f7c0
leaq 0x775a(%rip), %rdx      # 0x1bcba
movq %r14, %rdi
callq 0x54d0
jmp 0x1462d
movl $0x38, %edi
callq 0x5170
movq %rax, %r14
leaq 0x198(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xef12(%rip), %rsi      # 0x2349f
leaq 0xef4a(%rip), %rdx      # 0x234de
leaq 0x188(%rsp), %rdi
callq 0xc794
movb $0x1, %bpl
leaq 0x188(%rsp), %rsi
movq %r14, %rdi
callq 0x15864
xorl %ebp, %ebp
leaq 0x1b1c3(%rip), %rsi     # 0x2f780
leaq 0x76f6(%rip), %rdx      # 0x1bcba
movq %r14, %rdi
callq 0x54d0
jmp 0x1462d
movl $0x38, %edi
callq 0x5170
movq %rax, %r14
leaq 0x1d8(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xee44(%rip), %rsi      # 0x23432
leaq 0xee6e(%rip), %rdx      # 0x23463
leaq 0x1c8(%rsp), %rdi
callq 0xc794
movb $0x1, %bpl
leaq 0x1c8(%rsp), %rsi
movq %r14, %rdi
callq 0x15864
xorl %ebp, %ebp
leaq 0x1b162(%rip), %rsi     # 0x2f780
leaq 0x7695(%rip), %rdx      # 0x1bcba
movq %r14, %rdi
callq 0x54d0
jmp 0x147fd
movq %rax, %rbx
movq 0x120(%rsp), %rdi
cmpq %r12, %rdi
je 0x14848
movq 0x130(%rsp), %rsi
jmp 0x14840
jmp 0x147fd
jmp 0x147fd
movq %rax, %rbx
movq 0x100(%rsp), %rdi
cmpq %r15, %rdi
je 0x14848
movq 0x110(%rsp), %rsi
jmp 0x14840
movq %rax, %rbx
movq 0x1c8(%rsp), %rdi
cmpq %r15, %rdi
je 0x147ec
movq 0x1d8(%rsp), %rsi
jmp 0x147dc
jmp 0x147e6
movq %rax, %rbx
movq 0x1a8(%rsp), %rdi
cmpq %r15, %rdi
je 0x147ec
movq 0x1b8(%rsp), %rsi
jmp 0x147dc
jmp 0x147e6
movq %rax, %rbx
leaq 0x238(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x147ec
movq 0x238(%rsp), %rsi
jmp 0x147dc
jmp 0x147e6
movq %rax, %rbx
movq 0x188(%rsp), %rdi
cmpq %r15, %rdi
je 0x147ec
movq 0x198(%rsp), %rsi
jmp 0x147dc
jmp 0x147e6
jmp 0x147fd
jmp 0x147fd
movq %rax, %rbx
movq 0x140(%rsp), %rdi
cmpq %r15, %rdi
je 0x14848
movq 0x150(%rsp), %rsi
jmp 0x14840
movq %rax, %rbx
leaq 0x1f8(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x147c3
movq 0x1f8(%rsp), %rsi
incq %rsi
callq 0x52c0
jmp 0x147c3
movq %rax, %rbx
movq 0x160(%rsp), %rdi
cmpq %r12, %rdi
je 0x14848
movq 0x170(%rsp), %rsi
jmp 0x14840
jmp 0x147fd
jmp 0x147fd
jmp 0x147fd
jmp 0x147fd
movq %rax, %rbx
movq 0xb8(%rsp), %rdi
leaq 0xc8(%rsp), %rax
cmpq %rax, %rdi
je 0x14848
movq 0xc8(%rsp), %rsi
jmp 0x14840
movq %rax, %rbx
movb $0x1, %bpl
leaq 0x218(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x147ec
movq 0x218(%rsp), %rsi
incq %rsi
callq 0x52c0
jmp 0x147ec
movq %rax, %rbx
movb $0x1, %bpl
testb %bpl, %bpl
je 0x14848
movq %r14, %rdi
callq 0x5230
jmp 0x14848
jmp 0x147fd
movq %rax, %rbx
jmp 0x14848
jmp 0x1482e
movq %rax, %rbx
movq 0xd8(%rsp), %rdi
leaq 0xe8(%rsp), %rax
cmpq %rax, %rdi
je 0x14831
movq 0xe8(%rsp), %rsi
incq %rsi
callq 0x52c0
jmp 0x14831
movq %rax, %rbx
movq 0x18(%rsp), %rdi
cmpq %r14, %rdi
je 0x14848
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x52c0
movq 0x38(%rsp), %rdi
leaq 0x48(%rsp), %rax
cmpq %rax, %rdi
je 0x14864
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x52c0
movq 0x98(%rsp), %rdi
leaq 0xa8(%rsp), %rax
cmpq %rax, %rdi
je 0x14889
movq 0xa8(%rsp), %rsi
incq %rsi
callq 0x52c0
movq 0x58(%rsp), %rdi
leaq 0x68(%rsp), %rax
cmpq %rax, %rdi
je 0x148a5
movq 0x68(%rsp), %rsi
incq %rsi
callq 0x52c0
movq 0x78(%rsp), %rdi
leaq 0x88(%rsp), %rax
cmpq %rax, %rdi
je 0x148c7
movq 0x88(%rsp), %rsi
incq %rsi
callq 0x52c0
movq %rbx, %rdi
callq 0x5510
nop