LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: yeonnic[P]solparser/././argx.hpp
// Function: args::FlagBase::Validate(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>> const&) const
virtual void Validate(const std::string &shortPrefix, const std::string &longPrefix) const override
            {
                if (!Matched() && IsRequired())
                {
                        std::ostringstream problem;
                        problem << "Flag '" << matcher.GetLongOrAny().str(shortPrefix, longPrefix) << "' is required";
#ifdef ARGS_NOEXCEPT
                        error = Error::Required;
                        errorMsg = problem.str();
#else
                        throw RequiredError(problem.str());
#endif
                }
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x240, %rsp            # imm = 0x240
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x218(%rbp)
movq (%rdi), %rax
callq *0x10(%rax)
testb $0x1, %al
jne 0x1d81e
movq -0x218(%rbp), %rdi
callq 0x1ff30
testb $0x1, %al
jne 0x1d655
jmp 0x1d81e
leaq -0x190(%rbp), %rdi
movq %rdi, -0x228(%rbp)
callq 0x64b0
movq -0x228(%rbp), %rdi
leaq 0x19bce(%rip), %rsi     # 0x37244
callq 0x6320
movq %rax, -0x220(%rbp)
jmp 0x1d684
movq -0x218(%rbp), %rsi
addq $0xa0, %rsi
leaq -0x1e8(%rbp), %rdi
callq 0x1ff60
jmp 0x1d6a0
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
leaq -0x1c0(%rbp), %rdi
leaq -0x1e8(%rbp), %rsi
callq 0x20010
jmp 0x1d6bd
movq -0x220(%rbp), %rdi
leaq -0x1c0(%rbp), %rsi
callq 0x62d0
movq %rax, -0x230(%rbp)
jmp 0x1d6d9
movq -0x230(%rbp), %rdi
leaq 0x19b64(%rip), %rsi     # 0x3724b
callq 0x6320
jmp 0x1d6ee
leaq -0x1c0(%rbp), %rdi
callq 0x61f0
leaq -0x1e8(%rbp), %rdi
callq 0x85f0
movb $0x1, -0x209(%rbp)
movl $0x10, %edi
callq 0x61a0
movq %rax, -0x238(%rbp)
leaq -0x208(%rbp), %rdi
leaq -0x190(%rbp), %rsi
callq 0x6340
jmp 0x1d733
movq -0x238(%rbp), %rdi
leaq -0x208(%rbp), %rsi
callq 0x20140
jmp 0x1d748
movq -0x238(%rbp), %rdi
movb $0x0, -0x209(%rbp)
leaq 0x2f383(%rip), %rsi     # 0x4cae0
leaq 0x2a1c(%rip), %rdx      # 0x20180
callq 0x65e0
jmp 0x1d833
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x198(%rbp)
movl %eax, -0x19c(%rbp)
jmp 0x1d810
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x198(%rbp)
movl %eax, -0x19c(%rbp)
jmp 0x1d7b7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x198(%rbp)
movl %eax, -0x19c(%rbp)
leaq -0x1c0(%rbp), %rdi
callq 0x61f0
leaq -0x1e8(%rbp), %rdi
callq 0x85f0
jmp 0x1d810
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x198(%rbp)
movl %eax, -0x19c(%rbp)
jmp 0x1d7f7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x198(%rbp)
movl %eax, -0x19c(%rbp)
leaq -0x208(%rbp), %rdi
callq 0x61f0
testb $0x1, -0x209(%rbp)
jne 0x1d802
jmp 0x1d80e
movq -0x238(%rbp), %rdi
callq 0x6270
jmp 0x1d810
leaq -0x190(%rbp), %rdi
callq 0x60b0
jmp 0x1d827
addq $0x240, %rsp            # imm = 0x240
popq %rbp
retq
movq -0x198(%rbp), %rdi
callq 0x6620
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: yeonnic[P]solparser/././argx.hpp
// Function: args::FlagBase::Match(args::EitherFlag const&)
virtual FlagBase *Match(const EitherFlag &flag) override
            {
                if (matcher.Match(flag))
                {
                    if ((GetOptions() & Options::Single) != Options::None && matched)
                    {
                        std::ostringstream problem;
                        problem << "Flag '" << flag.str() << "' was passed multiple times, but is only allowed to be passed once";
#ifdef ARGS_NOEXCEPT
                        error = Error::Extra;
                        errorMsg = problem.str();
#else
                        throw ExtraError(problem.str());
#endif
                    }
                    matched = true;
                    return this;
                }
                return nullptr;
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x210, %rsp            # imm = 0x210
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x1f0(%rbp)
addq $0xa0, %rdi
movq -0x18(%rbp), %rsi
callq 0x20700
testb $0x1, %al
jne 0x1de07
jmp 0x1dfbd
movq -0x1f0(%rbp), %rdi
callq 0xde40
movl %eax, %edi
movl $0x1, %esi
callq 0xde20
cmpl $0x0, %eax
je 0x1dfac
movq -0x1f0(%rbp), %rax
testb $0x1, 0xc(%rax)
je 0x1dfac
leaq -0x190(%rbp), %rdi
movq %rdi, -0x200(%rbp)
callq 0x64b0
movq -0x200(%rbp), %rdi
leaq 0x193ea(%rip), %rsi     # 0x37244
callq 0x6320
movq %rax, -0x1f8(%rbp)
jmp 0x1de68
movq -0x18(%rbp), %rsi
leaq -0x1c0(%rbp), %rdi
callq 0x20760
jmp 0x1de7a
movq -0x1f8(%rbp), %rdi
leaq -0x1c0(%rbp), %rsi
callq 0x62d0
movq %rax, -0x208(%rbp)
jmp 0x1de96
movq -0x208(%rbp), %rdi
leaq 0x193b5(%rip), %rsi     # 0x37259
callq 0x6320
jmp 0x1deab
leaq -0x1c0(%rbp), %rdi
callq 0x61f0
movb $0x1, -0x1e1(%rbp)
movl $0x10, %edi
callq 0x61a0
movq %rax, -0x210(%rbp)
leaq -0x1e0(%rbp), %rdi
leaq -0x190(%rbp), %rsi
callq 0x6340
jmp 0x1dee4
movq -0x210(%rbp), %rdi
leaq -0x1e0(%rbp), %rsi
callq 0x20820
jmp 0x1def9
movq -0x210(%rbp), %rdi
movb $0x0, -0x1e1(%rbp)
leaq 0x2ec12(%rip), %rsi     # 0x4cb20
leaq 0x294b(%rip), %rdx      # 0x20860
callq 0x65e0
jmp 0x1dfde
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x198(%rbp)
movl %eax, -0x19c(%rbp)
jmp 0x1df9e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x198(%rbp)
movl %eax, -0x19c(%rbp)
leaq -0x1c0(%rbp), %rdi
callq 0x61f0
jmp 0x1df9e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x198(%rbp)
movl %eax, -0x19c(%rbp)
jmp 0x1df85
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x198(%rbp)
movl %eax, -0x19c(%rbp)
leaq -0x1e0(%rbp), %rdi
callq 0x61f0
testb $0x1, -0x1e1(%rbp)
jne 0x1df90
jmp 0x1df9c
movq -0x210(%rbp), %rdi
callq 0x6270
jmp 0x1df9e
leaq -0x190(%rbp), %rdi
callq 0x60b0
jmp 0x1dfd2
movq -0x1f0(%rbp), %rax
movb $0x1, 0xc(%rax)
movq %rax, -0x8(%rbp)
jmp 0x1dfc5
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x210, %rsp            # imm = 0x210
popq %rbp
retq
movq -0x198(%rbp), %rdi
callq 0x6620
nop
// File: yeonnic[P]solparser/././argx.hpp
// Function: args::HelpFlag::ParseValue(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&)
virtual void ParseValue(const std::vector<std::string> &)
            {
#ifdef ARGS_NOEXCEPT
                    error = Error::Help;
                    errorMsg = Name();
#else
                    throw Help(Name());
#endif
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movb $0x1, -0x3d(%rbp)
movl $0x10, %edi
callq 0x61a0
movq -0x50(%rbp), %rsi
movq %rax, -0x48(%rbp)
movq (%rsi), %rax
movq 0x90(%rax), %rax
leaq -0x30(%rbp), %rdi
callq *%rax
jmp 0x1eb30
movq -0x48(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x22c40
jmp 0x1eb3f
movq -0x48(%rbp), %rdi
movb $0x0, -0x3d(%rbp)
leaq 0x2d85a(%rip), %rsi     # 0x4c3a8
leaq 0x412b(%rip), %rdx      # 0x22c80
callq 0x65e0
jmp 0x1eb9b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x1eb7f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x61f0
testb $0x1, -0x3d(%rbp)
jne 0x1eb87
jmp 0x1eb90
movq -0x48(%rbp), %rdi
callq 0x6270
jmp 0x1eb92
movq -0x38(%rbp), %rdi
callq 0x6620
nopl (%rax,%rax)
// File: yeonnic[P]solparser/././argx.hpp
// Function: args::Matcher::GetLongOrAny() const
EitherFlag GetLongOrAny() const
            {
                if (!longFlags.empty())
                {
                    return *longFlags.begin();
                }

                if (!shortFlags.empty())
                {
                    return *shortFlags.begin();
                }

                // should be unreachable
                return ' ';
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
addq $0x38, %rdi
callq 0x1c870
testb $0x1, %al
jne 0x1ffb8
movq -0x28(%rbp), %rdi
addq $0x38, %rdi
callq 0x201a0
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x201d0
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x20200
jmp 0x1fff7
movq -0x28(%rbp), %rdi
callq 0x1c850
testb $0x1, %al
jne 0x1ffe9
movq -0x28(%rbp), %rdi
callq 0x20230
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x20260
movq -0x38(%rbp), %rdi
movsbl (%rax), %esi
callq 0x8540
jmp 0x1fff7
movq -0x38(%rbp), %rdi
movl $0x20, %esi
callq 0x8540
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: yeonnic[P]solparser/././argx.hpp
// Function: args::NamedBase::AddDescriptionPostfix(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, bool, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool, 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>> const&) const
void AddDescriptionPostfix(std::string &dest, const bool isManual, const std::string &manual, bool isGenerated, const std::string &generated, const std::string &str) const
            {
                if (isManual && !manual.empty())
                {
                    dest += str;
                    dest += manual;
                }
                else if (!isManual && isGenerated && !generated.empty())
                {
                    dest += str;
                    dest += generated;
                }
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %r8b, %al
movq 0x10(%rbp), %r8
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %dl
movb %dl, -0x11(%rbp)
movq %rcx, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
movq %r9, -0x30(%rbp)
testb $0x1, -0x11(%rbp)
je 0x204c9
movq -0x20(%rbp), %rdi
callq 0x65c0
testb $0x1, %al
jne 0x204c9
movq 0x10(%rbp), %rsi
movq -0x10(%rbp), %rdi
callq 0x6450
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdi
callq 0x6450
jmp 0x204fe
testb $0x1, -0x11(%rbp)
jne 0x204fc
testb $0x1, -0x21(%rbp)
je 0x204fc
movq -0x30(%rbp), %rdi
callq 0x65c0
testb $0x1, %al
jne 0x204fc
movq 0x10(%rbp), %rsi
movq -0x10(%rbp), %rdi
callq 0x6450
movq -0x30(%rbp), %rsi
movq -0x10(%rbp), %rdi
callq 0x6450
jmp 0x204fe
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: yeonnic[P]solparser/././argx.hpp
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> args::detail::Join<std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string Join(const T& array, const std::string &delimiter)
        {
            std::string res;
            for (auto &element : array)
            {
                if (!res.empty())
                {
                    res += delimiter;
                }

                res += element;
            }

            return res;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x6510
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x20620
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x20650
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x20680
testb $0x1, %al
jne 0x2056d
jmp 0x205cb
leaq -0x30(%rbp), %rdi
callq 0x206c0
movq -0x60(%rbp), %rdi
movq %rax, -0x40(%rbp)
callq 0x65c0
testb $0x1, %al
jne 0x205af
movq -0x60(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x6450
jmp 0x20596
jmp 0x205af
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
callq 0x61f0
jmp 0x205e8
movq -0x60(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x6450
jmp 0x205be
jmp 0x205c0
leaq -0x30(%rbp), %rdi
callq 0x206e0
jmp 0x2055a
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x205de
movq -0x60(%rbp), %rdi
callq 0x61f0
movq -0x58(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x6620
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: yeonnic[P]solparser/././argx.hpp
// Function: args::Matcher::GetFlagStrings() const
std::vector<EitherFlag> GetFlagStrings() const
            {
                std::vector<EitherFlag> flagStrings;
                flagStrings.reserve(shortFlags.size() + longFlags.size());
                for (const char flag: shortFlags)
                {
                    flagStrings.emplace_back(flag);
                }
                for (const std::string &flag: longFlags)
                {
                    flagStrings.emplace_back(flag);
                }
                return flagStrings;
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x219e0
movq -0x80(%rbp), %rdi
callq 0x21b20
movq -0x80(%rbp), %rdi
movq %rax, -0x78(%rbp)
addq $0x38, %rdi
callq 0x21b40
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rdi
addq %rax, %rsi
callq 0x21a00
jmp 0x216de
movq -0x80(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x20230
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0x20950
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x1ca60
testb $0x1, %al
jne 0x21713
jmp 0x21757
leaq -0x38(%rbp), %rdi
callq 0x20260
movq -0x70(%rbp), %rdi
movb (%rax), %al
movb %al, -0x41(%rbp)
leaq -0x41(%rbp), %rsi
callq 0x21b60
jmp 0x21730
jmp 0x21732
leaq -0x38(%rbp), %rdi
callq 0x21bd0
jmp 0x21700
movq -0x70(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x21980
jmp 0x217dc
movq -0x80(%rbp), %rax
addq $0x38, %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
callq 0x201a0
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rdi
callq 0x20a50
movq %rax, -0x60(%rbp)
leaq -0x58(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x1d050
testb $0x1, %al
jne 0x21790
jmp 0x217b9
leaq -0x58(%rbp), %rdi
callq 0x201d0
movq -0x70(%rbp), %rdi
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rsi
callq 0x21c00
jmp 0x217ac
jmp 0x217ae
leaq -0x58(%rbp), %rdi
callq 0x21c70
jmp 0x2177d
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x217cc
movq -0x70(%rbp), %rdi
callq 0x21980
movq -0x88(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x6620
nopw %cs:(%rax,%rax)
nop
// File: yeonnic[P]solparser/././argx.hpp
// Function: args::ArgumentParser::ParseOption(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool)
OptionType ParseOption(const std::string &s, bool allowEmpty = false)
            {
                if (s.find(longprefix) == 0 && (allowEmpty || s.length() > longprefix.length()))
                {
                    return OptionType::LongFlag;
                }

                if (s.find(shortprefix) == 0 && (allowEmpty || s.length() > shortprefix.length()))
                {
                    return OptionType::ShortFlag;
                }

                return OptionType::Positional;
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x28(%rbp)
movq -0x18(%rbp), %rdi
addq $0x178, %rsi            # imm = 0x178
xorl %eax, %eax
movl %eax, %edx
callq 0x66a0
cmpq $0x0, %rax
jne 0x25081
testb $0x1, -0x19(%rbp)
jne 0x25078
movq -0x18(%rbp), %rdi
callq 0x6530
movq -0x28(%rbp), %rdi
movq %rax, -0x30(%rbp)
addq $0x178, %rdi            # imm = 0x178
callq 0x6530
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jbe 0x25081
movl $0x0, -0x4(%rbp)
jmp 0x250de
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rdi
addq $0x198, %rsi            # imm = 0x198
xorl %eax, %eax
movl %eax, %edx
callq 0x66a0
cmpq $0x0, %rax
jne 0x250d7
testb $0x1, -0x19(%rbp)
jne 0x250ce
movq -0x18(%rbp), %rdi
callq 0x6530
movq -0x28(%rbp), %rdi
movq %rax, -0x38(%rbp)
addq $0x198, %rdi            # imm = 0x198
callq 0x6530
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jbe 0x250d7
movl $0x1, -0x4(%rbp)
jmp 0x250de
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: yeonnic[P]solparser/././argx.hpp
// Function: args::ArgumentParser::AddCompletionReply(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>> const&)
bool AddCompletionReply(const std::string &cur, const std::string &choice)
            {
                if (cur.empty() || choice.find(cur) == 0)
                {
                    if (completion->syntax == "bash" && ParseOption(choice) == OptionType::LongFlag && choice.find(longseparator) != std::string::npos)
                    {
                        completion->reply.push_back(choice.substr(choice.find(longseparator) + 1));
                    } else
                    {
                        completion->reply.push_back(choice);
                    }
                    return true;
                }

                return false;
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rdi
callq 0x65c0
testb $0x1, %al
jne 0x27154
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x66a0
cmpq $0x0, %rax
jne 0x2724e
movq -0x58(%rbp), %rax
movq 0x200(%rax), %rdi
addq $0x130, %rdi            # imm = 0x130
leaq 0x101bc(%rip), %rsi     # 0x37329
callq 0x26120
testb $0x1, %al
jne 0x2717b
jmp 0x2722d
movq -0x58(%rbp), %rdi
movq -0x20(%rbp), %rsi
xorl %edx, %edx
callq 0x25010
cmpl $0x0, %eax
jne 0x2722d
movq -0x58(%rbp), %rsi
movq -0x20(%rbp), %rdi
addq $0x1b8, %rsi            # imm = 0x1B8
xorl %eax, %eax
movl %eax, %edx
callq 0x66a0
cmpq $-0x1, %rax
je 0x2722d
movq -0x58(%rbp), %rsi
movq 0x200(%rsi), %rax
addq $0x110, %rax            # imm = 0x110
movq %rax, -0x68(%rbp)
movq -0x20(%rbp), %rdi
movq %rdi, -0x70(%rbp)
addq $0x1b8, %rsi            # imm = 0x1B8
xorl %eax, %eax
movl %eax, %edx
callq 0x66a0
movq -0x70(%rbp), %rsi
movq %rax, %rdx
incq %rdx
leaq -0x40(%rbp), %rdi
movq %rdi, -0x60(%rbp)
movq $-0x1, %rcx
callq 0x6350
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rsi
callq 0x16b20
jmp 0x2720b
leaq -0x40(%rbp), %rdi
callq 0x61f0
jmp 0x27248
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x61f0
jmp 0x2725d
movq -0x58(%rbp), %rax
movq 0x200(%rax), %rdi
addq $0x110, %rdi            # imm = 0x110
movq -0x20(%rbp), %rsi
callq 0x16a30
movb $0x1, -0x1(%rbp)
jmp 0x27252
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x6620
nopw %cs:(%rax,%rax)
// File: yeonnic[P]solparser/././argx.hpp
// Function: args::Command::SelectedCommand()
Command &SelectedCommand()
            {
                Command *res = this;
                while (res->selectedCommand != nullptr)
                {
                    res = res->selectedCommand;
                }

                return *res;
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x130(%rax)
je 0x28e5f
movq -0x10(%rbp), %rax
movq 0x130(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x28e40
movq -0x10(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: yeonnic[P]solparser/././argx.hpp
// Function: args::Command::SelectedCommand() const
const Command &SelectedCommand() const
            {
                const Command *res = this;
                while (res->selectedCommand != nullptr)
                {
                    res = res->selectedCommand;
                }

                return *res;
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x130(%rax)
je 0x2d3af
movq -0x10(%rbp), %rax
movq 0x130(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x2d390
movq -0x10(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: yeonnic[P]solparser/./tokenize.cpp
// Function: ishex(char)
bool ishex(char c)
{
	if('0' <= c && c <= '9') return true;
	if('A' <= c && c <= 'F') return true;
	if('a' <= c && c <= 'f') return true;
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x2(%rbp)
movsbl -0x2(%rbp), %ecx
movl $0x30, %eax
cmpl %ecx, %eax
jg 0x2ea86
movsbl -0x2(%rbp), %eax
cmpl $0x39, %eax
jg 0x2ea86
movb $0x1, -0x1(%rbp)
jmp 0x2eac2
movsbl -0x2(%rbp), %ecx
movl $0x41, %eax
cmpl %ecx, %eax
jg 0x2eaa2
movsbl -0x2(%rbp), %eax
cmpl $0x46, %eax
jg 0x2eaa2
movb $0x1, -0x1(%rbp)
jmp 0x2eac2
movsbl -0x2(%rbp), %ecx
movl $0x61, %eax
cmpl %ecx, %eax
jg 0x2eabe
movsbl -0x2(%rbp), %eax
cmpl $0x66, %eax
jg 0x2eabe
movb $0x1, -0x1(%rbp)
jmp 0x2eac2
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax)
// File: yeonnic[P]solparser/./tokenize.cpp
// Function: hexToInt(char)
int hexToInt(char c)
{
	if('0' <= c && c <= '9') return c - '0';
	if('A' <= c && c <= 'F') return c - 'A' + 10;
	if('a' <= c && c <= 'f') return c - 'a' + 10;
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x5(%rbp)
movsbl -0x5(%rbp), %ecx
movl $0x30, %eax
cmpl %ecx, %eax
jg 0x2eafc
movsbl -0x5(%rbp), %eax
cmpl $0x39, %eax
jg 0x2eafc
movsbl -0x5(%rbp), %eax
subl $0x30, %eax
movl %eax, -0x4(%rbp)
jmp 0x2eb4d
movsbl -0x5(%rbp), %ecx
movl $0x41, %eax
cmpl %ecx, %eax
jg 0x2eb21
movsbl -0x5(%rbp), %eax
cmpl $0x46, %eax
jg 0x2eb21
movsbl -0x5(%rbp), %eax
subl $0x41, %eax
addl $0xa, %eax
movl %eax, -0x4(%rbp)
jmp 0x2eb4d
movsbl -0x5(%rbp), %ecx
movl $0x61, %eax
cmpl %ecx, %eax
jg 0x2eb46
movsbl -0x5(%rbp), %eax
cmpl $0x66, %eax
jg 0x2eb46
movsbl -0x5(%rbp), %eax
subl $0x61, %eax
addl $0xa, %eax
movl %eax, -0x4(%rbp)
jmp 0x2eb4d
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: yeonnic[P]solparser/./tree.cpp
// Function: S_ConditionalStatement(__gnu_cxx::__normal_iterator<Token const*, std::vector<Token, std::allocator<Token>>>, SolTree&)
int S_ConditionalStatement(Tokit begin, SolTree &out){
  vector<SolTree> tmp;
  int count = 0;
  auto it = begin;

  cout << "S_ConditionalStatement() called!!" << endl;
  cout << "it->str  : " << it->str << endl;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x34de0
movl $0x0, -0x2c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq 0x19751(%rip), %rdi     # 0x4cfd0
leaq 0x4511(%rip), %rsi      # 0x37d97
callq 0x6320
movq %rax, -0x50(%rbp)
jmp 0x33891
movq -0x50(%rbp), %rdi
movq 0x19724(%rip), %rsi     # 0x4cfc0
callq 0x6360
jmp 0x338a3
movq 0x19726(%rip), %rdi     # 0x4cfd0
leaq 0x4508(%rip), %rsi      # 0x37db9
callq 0x6320
movq %rax, -0x58(%rbp)
jmp 0x338bc
leaq -0x38(%rbp), %rdi
callq 0x34e00
movq -0x58(%rbp), %rdi
movq %rax, %rsi
callq 0x62d0
movq %rax, -0x60(%rbp)
jmp 0x338d7
movq -0x60(%rbp), %rdi
movq 0x196de(%rip), %rsi     # 0x4cfc0
callq 0x6360
jmp 0x338e9
ud2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x8ef0
movq -0x40(%rbp), %rdi
callq 0x6620
nopl (%rax)
// File: yeonnic[P]solparser/./tree.cpp
// Function: S_while(__gnu_cxx::__normal_iterator<Token const*, std::vector<Token, std::allocator<Token>>>, SolTree&)
int S_while(Tokit begin, SolTree &out){
  vector<SolTree> tmp;
  int count = 0;
  auto it = begin;

  cout << "S_while() called!!" << endl;
  cout << "it->str  : " << it->str << endl;

  assert(it->type == TokenType::lparen && (it+1)->type != TokenType::eof);
  it++; count++;


  
  return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x34de0
movl $0x0, -0x2c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq 0x1968e(%rip), %rdi     # 0x4cfd0
leaq 0x447c(%rip), %rsi      # 0x37dc5
callq 0x6320
movq %rax, -0x60(%rbp)
jmp 0x33954
movq -0x60(%rbp), %rdi
movq 0x19661(%rip), %rsi     # 0x4cfc0
callq 0x6360
jmp 0x33966
movq 0x19663(%rip), %rdi     # 0x4cfd0
leaq 0x4445(%rip), %rsi      # 0x37db9
callq 0x6320
movq %rax, -0x68(%rbp)
jmp 0x3397f
leaq -0x38(%rbp), %rdi
callq 0x34e00
movq -0x68(%rbp), %rdi
movq %rax, %rsi
callq 0x62d0
movq %rax, -0x70(%rbp)
jmp 0x3399a
movq -0x70(%rbp), %rdi
movq 0x1961b(%rip), %rsi     # 0x4cfc0
callq 0x6360
jmp 0x339ac
leaq -0x38(%rbp), %rdi
callq 0x34e00
movq %rax, %rcx
xorl %eax, %eax
cmpl $0x1d, 0x20(%rcx)
movb %al, -0x71(%rbp)
jne 0x339e8
leaq -0x38(%rbp), %rdi
movl $0x1, %esi
callq 0x34e20
movq %rax, -0x50(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x34e00
cmpl $0x1, 0x20(%rax)
setne %al
movb %al, -0x71(%rbp)
movb -0x71(%rbp), %al
testb $0x1, %al
jne 0x339f1
jmp 0x339f3
jmp 0x33a29
leaq 0x43de(%rip), %rdi      # 0x37dd8
leaq 0x4417(%rip), %rsi      # 0x37e18
movl $0x19, %edx
leaq 0x4416(%rip), %rcx      # 0x37e23
callq 0x6210
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x8ef0
jmp 0x33a5c
leaq -0x38(%rbp), %rdi
xorl %esi, %esi
callq 0x34e60
movq %rax, -0x58(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x78(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x8ef0
movl -0x78(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x6620
nopw %cs:(%rax,%rax)
// File: yeonnic[P]solparser/./tree.cpp
// Function: SolParser(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
SolTree SolParser(const string &source){

  auto tokens = Tokenize(source);

  //SolTree ret = SolTree(nodeType::top, "TopNode", TokenType::none);
  SolTree ret = SolTree("TopNode", NodeType::top);
  S_Top(tokens.begin(), ret);

  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x90(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x2ed80
movb $0x0, -0x29(%rbp)
leaq -0x51(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x6630
movq -0x80(%rbp), %rdx
leaq 0x320f(%rip), %rsi      # 0x37efc
leaq -0x50(%rbp), %rdi
callq 0x64f0
jmp 0x34cf8
movq -0x90(%rbp), %rdi
leaq -0x50(%rbp), %rsi
movl $0x1, %edx
callq 0x34ed0
jmp 0x34d0f
leaq -0x50(%rbp), %rdi
callq 0x61f0
leaq -0x51(%rbp), %rdi
callq 0x6390
leaq -0x28(%rbp), %rdi
callq 0x33400
movq %rax, -0x78(%rbp)
leaq -0x70(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x35380
movq -0x90(%rbp), %rsi
movq -0x70(%rbp), %rdi
callq 0x34670
jmp 0x34d4d
movb $0x1, -0x29(%rbp)
testb $0x1, -0x29(%rbp)
jne 0x34dad
jmp 0x34da1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x34d7c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x61f0
leaq -0x51(%rbp), %rdi
callq 0x6390
jmp 0x34dc6
movq -0x90(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
callq 0x80e0
jmp 0x34dc6
movq -0x90(%rbp), %rdi
callq 0x80e0
leaq -0x28(%rbp), %rdi
callq 0x32cf0
movq -0x88(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
leaq -0x28(%rbp), %rdi
callq 0x32cf0
movq -0x60(%rbp), %rdi
callq 0x6620
nopl (%rax,%rax)
// File: lemire[P]validateutf8-experiments/benchmarks/benchmark.cpp
// Function: main
int main() {
  RealDataBenchmark rdb;
  rdb.run();

  std::vector<size_t> input_size{16384};
  for (const size_t size : input_size) {
    Benchmark bench(size);
    bench.run();
  }
  return EXIT_SUCCESS;
}

// Assembly:
subq $0x1428, %rsp           # imm = 0x1428
movl $0x0, 0x1424(%rsp)
leaq 0x1408(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xf8700
movq 0x8(%rsp), %rdi
callq 0xf8940
jmp 0x38e0
movq $0x4000, 0x13c8(%rsp) # imm = 0x4000
leaq 0x13c8(%rsp), %rax
movq %rax, 0x13d0(%rsp)
movq $0x1, 0x13d8(%rsp)
leaq 0x13c7(%rsp), %rdi
movq %rdi, (%rsp)
callq 0xf8ce0
movq (%rsp), %rcx
movq 0x13d0(%rsp), %rsi
movq 0x13d8(%rsp), %rdx
leaq 0x13e0(%rsp), %rdi
callq 0xf8cf0
jmp 0x393c
leaq 0x13c7(%rsp), %rdi
callq 0xf8d80
leaq 0x13e0(%rsp), %rax
movq %rax, 0x13b8(%rsp)
movq 0x13b8(%rsp), %rdi
callq 0xf8d90
movq %rax, 0x13b0(%rsp)
movq 0x13b8(%rsp), %rdi
callq 0xf8dc0
movq %rax, 0x13a8(%rsp)
leaq 0x13b0(%rsp), %rdi
leaq 0x13a8(%rsp), %rsi
callq 0xf8df0
testb $0x1, %al
jne 0x39a1
jmp 0x3a64
leaq 0x13b0(%rsp), %rdi
callq 0xf8e30
movq (%rax), %rax
movq %rax, 0x13a0(%rsp)
movq 0x13a0(%rsp), %rsi
leaq 0x10(%rsp), %rdi
callq 0xf8e40
jmp 0x39cd
leaq 0x10(%rsp), %rdi
callq 0xf8e70
jmp 0x39d9
leaq 0x10(%rsp), %rdi
callq 0xf9200
leaq 0x13b0(%rsp), %rdi
callq 0xf9220
jmp 0x3983
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1400(%rsp)
movl %eax, 0x13fc(%rsp)
jmp 0x3aa5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1400(%rsp)
movl %eax, 0x13fc(%rsp)
leaq 0x13c7(%rsp), %rdi
callq 0xf8d80
jmp 0x3aa5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1400(%rsp)
movl %eax, 0x13fc(%rsp)
jmp 0x3a98
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1400(%rsp)
movl %eax, 0x13fc(%rsp)
leaq 0x10(%rsp), %rdi
callq 0xf9200
jmp 0x3a98
movl $0x0, 0x1424(%rsp)
leaq 0x13e0(%rsp), %rdi
callq 0xf9240
leaq 0x1408(%rsp), %rdi
callq 0xf92a0
movl 0x1424(%rsp), %eax
addq $0x1428, %rsp           # imm = 0x1428
retq
leaq 0x13e0(%rsp), %rdi
callq 0xf9240
leaq 0x1408(%rsp), %rdi
callq 0xf92a0
movq 0x1400(%rsp), %rdi
callq 0x2340
nop
// File: lemire[P]validateutf8-experiments/benchmarks/hoehrmann.h
// Function: fast_validate_dfa_utf8(signed char const*, unsigned long)
static inline fastvalidate::error_code
fast_validate_dfa_utf8(const signed char *c, size_t len) {
  const unsigned char *cu = (const unsigned char *)c;
  uint32_t state = 0;
  for (size_t i = 0; i < len; i++) {
    uint32_t byteval = (uint32_t)cu[i];
    if (fast_updatestate(&state, byteval) == UTF8_REJECT)
      return fastvalidate::error_code::UTF8_ERROR;
  }
  if (fast_updatestate(&state, 0) == UTF8_REJECT)
    return fastvalidate::error_code::UTF8_ERROR;
  return fastvalidate::error_code::SUCCESS;
}

// Assembly:
movq %rdi, -0x28(%rsp)
movq %rsi, -0x30(%rsp)
movq -0x28(%rsp), %rax
movq %rax, -0x38(%rsp)
movl $0x0, -0x3c(%rsp)
movq $0x0, -0x48(%rsp)
movq -0x48(%rsp), %rax
cmpq -0x30(%rsp), %rax
jae 0x3c8f
movq -0x38(%rsp), %rax
movq -0x48(%rsp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x4c(%rsp)
movl -0x4c(%rsp), %eax
leaq -0x3c(%rsp), %rcx
movq %rcx, -0x8(%rsp)
movl %eax, -0xc(%rsp)
movq -0x8(%rsp), %rax
movl (%rax), %eax
shll $0x8, %eax
addl -0xc(%rsp), %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x10e9d2(%rip), %rax    # 0x112630
movzbl (%rax,%rcx), %ecx
movq -0x8(%rsp), %rax
movl %ecx, (%rax)
movq -0x8(%rsp), %rax
cmpl $0x1, (%rax)
jne 0x3c7d
movl $0x1, -0x20(%rsp)
jmp 0x3ce1
jmp 0x3c7f
movq -0x48(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rsp)
jmp 0x3c15
leaq -0x3c(%rsp), %rax
movq %rax, -0x18(%rsp)
movl $0x0, -0x1c(%rsp)
movq -0x18(%rsp), %rax
movl (%rax), %eax
shll $0x8, %eax
addl -0x1c(%rsp), %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x10e976(%rip), %rax    # 0x112630
movzbl (%rax,%rcx), %ecx
movq -0x18(%rsp), %rax
movl %ecx, (%rax)
movq -0x18(%rsp), %rax
cmpl $0x1, (%rax)
jne 0x3cd9
movl $0x1, -0x20(%rsp)
jmp 0x3ce1
movl $0x0, -0x20(%rsp)
movl -0x20(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: lemire[P]validateutf8-experiments/benchmarks/hoehrmann.h
// Function: big_validate_dfa_utf8(signed char const*, unsigned long)
static inline fastvalidate::error_code
big_validate_dfa_utf8(const signed char *c, size_t len) {
  const unsigned char *cu = (const unsigned char *)c;
  uint32_t state = 0;
  for (size_t i = 0; i < len; i++) {
    uint32_t byteval = (uint32_t)cu[i];
    if (big_updatestate(&state, byteval) == UTF8_REJECT * 256)
      return fastvalidate::error_code::UTF8_ERROR;
  }
  if (big_updatestate(&state, 0) == UTF8_REJECT * 256)
    return fastvalidate::error_code::UTF8_ERROR;
  return fastvalidate::error_code::SUCCESS;
}

// Assembly:
movq %rdi, -0x28(%rsp)
movq %rsi, -0x30(%rsp)
movq -0x28(%rsp), %rax
movq %rax, -0x38(%rsp)
movl $0x0, -0x3c(%rsp)
movq $0x0, -0x48(%rsp)
movq -0x48(%rsp), %rax
cmpq -0x30(%rsp), %rax
jae 0x3d8f
movq -0x38(%rsp), %rax
movq -0x48(%rsp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x4c(%rsp)
movl -0x4c(%rsp), %eax
leaq -0x3c(%rsp), %rcx
movq %rcx, -0x8(%rsp)
movl %eax, -0xc(%rsp)
movq -0x8(%rsp), %rax
movl (%rax), %eax
addl -0xc(%rsp), %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x10f1d5(%rip), %rax    # 0x112f30
movzwl (%rax,%rcx,2), %ecx
movq -0x8(%rsp), %rax
movl %ecx, (%rax)
movq -0x8(%rsp), %rax
cmpl $0x100, (%rax)          # imm = 0x100
jne 0x3d7d
movl $0x1, -0x20(%rsp)
jmp 0x3de1
jmp 0x3d7f
movq -0x48(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rsp)
jmp 0x3d15
leaq -0x3c(%rsp), %rax
movq %rax, -0x18(%rsp)
movl $0x0, -0x1c(%rsp)
movq -0x18(%rsp), %rax
movl (%rax), %eax
addl -0x1c(%rsp), %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x10f179(%rip), %rax    # 0x112f30
movzwl (%rax,%rcx,2), %ecx
movq -0x18(%rsp), %rax
movl %ecx, (%rax)
movq -0x18(%rsp), %rax
cmpl $0x100, (%rax)          # imm = 0x100
jne 0x3dd9
movl $0x1, -0x20(%rsp)
jmp 0x3de1
movl $0x0, -0x20(%rsp)
movl -0x20(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: lemire[P]validateutf8-experiments/benchmarks/event_counter.h
// Function: event_count::operator+(event_count const&) const
event_count operator+(const event_count &other) const {
    return event_count(elapsed + other.elapsed,
                       {
                           event_counts[0] + other.event_counts[0],
                           event_counts[1] + other.event_counts[1],
                           event_counts[2] + other.event_counts[2],
                           event_counts[3] + other.event_counts[3],
                           event_counts[4] + other.event_counts[4],
                       });
  }

// Assembly:
subq $0x108, %rsp            # imm = 0x108
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x100(%rsp)
movq %rsi, 0xf8(%rsp)
movq %rdx, 0xf0(%rsp)
movq 0xf8(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movq 0xf0(%rsp), %rsi
callq 0x105110
movq 0x18(%rsp), %rdi
movsd %xmm0, 0xe8(%rsp)
addq $0x8, %rdi
movq %rdi, 0x58(%rsp)
xorl %eax, %eax
movl %eax, %esi
movq %rsi, 0x20(%rsp)
callq 0x105180
movq 0x20(%rsp), %rsi
movq (%rax), %rax
movq %rax, 0x28(%rsp)
movq 0xf0(%rsp), %rdi
addq $0x8, %rdi
callq 0x105180
movq 0x58(%rsp), %rdi
movq %rax, %rcx
movq 0x28(%rsp), %rax
movq (%rcx), %rcx
addq %rcx, %rax
movq %rax, 0x98(%rsp)
movl $0x1, %esi
movq %rsi, 0x30(%rsp)
callq 0x105180
movq 0x30(%rsp), %rsi
movq (%rax), %rax
movq %rax, 0x38(%rsp)
movq 0xf0(%rsp), %rdi
addq $0x8, %rdi
callq 0x105180
movq 0x58(%rsp), %rdi
movq %rax, %rcx
movq 0x38(%rsp), %rax
movq (%rcx), %rcx
addq %rcx, %rax
movq %rax, 0xa0(%rsp)
movl $0x2, %esi
movq %rsi, 0x40(%rsp)
callq 0x105180
movq 0x40(%rsp), %rsi
movq (%rax), %rax
movq %rax, 0x48(%rsp)
movq 0xf0(%rsp), %rdi
addq $0x8, %rdi
callq 0x105180
movq 0x58(%rsp), %rdi
movq %rax, %rcx
movq 0x48(%rsp), %rax
movq (%rcx), %rcx
addq %rcx, %rax
movq %rax, 0xa8(%rsp)
movl $0x3, %esi
movq %rsi, 0x50(%rsp)
callq 0x105180
movq 0x50(%rsp), %rsi
movq (%rax), %rax
movq %rax, 0x60(%rsp)
movq 0xf0(%rsp), %rdi
addq $0x8, %rdi
callq 0x105180
movq 0x58(%rsp), %rdi
movq %rax, %rcx
movq 0x60(%rsp), %rax
movq (%rcx), %rcx
addq %rcx, %rax
movq %rax, 0xb0(%rsp)
movl $0x4, %esi
movq %rsi, 0x68(%rsp)
callq 0x105180
movq 0x68(%rsp), %rsi
movq (%rax), %rax
movq %rax, 0x70(%rsp)
movq 0xf0(%rsp), %rdi
addq $0x8, %rdi
callq 0x105180
movq %rax, %rcx
movq 0x70(%rsp), %rax
movq (%rcx), %rcx
addq %rcx, %rax
movq %rax, 0xb8(%rsp)
leaq 0x98(%rsp), %rax
movq %rax, 0xc0(%rsp)
movq $0x5, 0xc8(%rsp)
leaq 0x97(%rsp), %rdi
movq %rdi, 0x78(%rsp)
callq 0x101bf0
movq 0x78(%rsp), %rcx
movq 0xc0(%rsp), %rsi
movq 0xc8(%rsp), %rdx
leaq 0xd0(%rsp), %rdi
callq 0x101c00
jmp 0x105071
movq 0x8(%rsp), %rdi
movsd 0xe8(%rsp), %xmm0
leaq 0xd0(%rsp), %rsi
callq 0x1051a0
jmp 0x10508e
leaq 0xd0(%rsp), %rdi
callq 0x1051d0
leaq 0x97(%rsp), %rdi
callq 0x101c90
movq 0x10(%rsp), %rax
addq $0x108, %rsp            # imm = 0x108
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
jmp 0x1050ec
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
leaq 0xd0(%rsp), %rdi
callq 0x1051d0
leaq 0x97(%rsp), %rdi
callq 0x101c90
movq 0x88(%rsp), %rdi
callq 0x2340
nopw %cs:(%rax,%rax)
// File: lemire[P]validateutf8-experiments/dependencies/utf8_v2_3_4/source/utf8/core.h
// Function: _gnu_cxx::__normal_iterator<char*, std::vector<char, std::allocator<char>>> utf8::find_invalid<__gnu_cxx::__normal_iterator<char*, std::vector<char, std::allocator<char>>>>(__gnu_cxx::__normal_iterator<char*, std::vector<char, std::allocator<char>>>, __gnu_cxx::__normal_iterator<char*, std::vector<char, std::allocator<char>>>)
octet_iterator find_invalid(octet_iterator start, octet_iterator end)
    {
        octet_iterator result = start;
        while (result != end) {
            utf8::internal::utf_error err_code = utf8::internal::validate_next(result, end);
            if (err_code != internal::UTF8_OK)
                return result;
        }
        return result;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x105f20
testb $0x1, %al
jne 0x105eed
jmp 0x105f13
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rsi
leaq 0x20(%rsp), %rdi
callq 0x105f60
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
je 0x105f11
jmp 0x105f15
jmp 0x105ed8
jmp 0x105f15
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nop
// File: fatiiates[P]CDLL-with-cpp-make-gcc/./src/ArrayList.cpp
// Function: ArrayList::reserve(int)
void ArrayList::reserve(int newCapacity){
      CircularDoublyLinkedList **temp = new CircularDoublyLinkedList*[newCapacity];

      for (int i = 0; i < length; i++)
        temp[i] = items[i];

      delete [] items;
      items = temp;
      capacity =  newCapacity;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movslq -0xc(%rbp), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x2030
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x25a9
movq -0x28(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2577
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x25c3
movq -0x30(%rbp), %rdi
callq 0x2200
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, (%rax)
movl -0xc(%rbp), %ecx
movl %ecx, 0xc(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: fatiiates[P]CDLL-with-cpp-make-gcc/./src/ArrayList.cpp
// Function: ArrayList::elementAt(int)
CircularDoublyLinkedList* ArrayList::elementAt(int index){
      if(index < 0 || index >= length)
        throw invalid_argument("İndex 0'dan küçük, kapasiteye eşit veya kapasiteden büyük olamaz . Error Code: 101");
      else
        return items[index];
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $0x0, -0xc(%rbp)
jl 0x26a9
movq -0x28(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x8(%rcx), %eax
jl 0x26f9
movl $0x10, %edi
callq 0x20c0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
leaq 0x2940(%rip), %rsi      # 0x5004
callq 0x2310
jmp 0x26cb
movq -0x30(%rbp), %rdi
movq 0x5902(%rip), %rsi      # 0x7fd8
movq 0x58eb(%rip), %rdx      # 0x7fc8
callq 0x22a0
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x2110
jmp 0x270e
movq -0x28(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
addq $0x30, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x22c0
nopw (%rax,%rax)
// File: fatiiates[P]CDLL-with-cpp-make-gcc/./src/ArrayList.cpp
// Function: ArrayList::insert(int, CircularDoublyLinkedList*)
void ArrayList::insert(int index,CircularDoublyLinkedList* item){
      if(index < 0 || index > length)
        throw invalid_argument("İndex 0'dan küçük veya kapasiteden büyük olamaz . Error Code: 101");
      else{
        if(length == capacity) reserve(2*capacity);
        for (int i = length - 1; i >= index; i--)
          items[i+1] = items[i];
        items[index] = item;
        length++;
      }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpl $0x0, -0xc(%rbp)
jl 0x277d
movq -0x30(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x8(%rcx), %eax
jle 0x27cd
movl $0x10, %edi
callq 0x20c0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
leaq 0x28c6(%rip), %rsi      # 0x505e
callq 0x2310
jmp 0x279f
movq -0x38(%rbp), %rdi
movq 0x582e(%rip), %rsi      # 0x7fd8
movq 0x5817(%rip), %rdx      # 0x7fc8
callq 0x22a0
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x2110
jmp 0x2848
movq -0x30(%rbp), %rcx
movl 0x8(%rcx), %eax
cmpl 0xc(%rcx), %eax
jne 0x27e7
movq -0x30(%rbp), %rdi
movl 0xc(%rdi), %esi
shll %esi
callq 0x2530
movq -0x30(%rbp), %rax
movl 0x8(%rax), %eax
subl $0x1, %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0xc(%rbp), %eax
jl 0x2826
movq -0x30(%rbp), %rax
movq (%rax), %rcx
movslq -0x28(%rbp), %rdx
movq (%rcx,%rdx,8), %rdx
movq (%rax), %rax
movl -0x28(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x28(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x27f4
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rsi
movq (%rax), %rcx
movslq -0xc(%rbp), %rdx
movq %rsi, (%rcx,%rdx,8)
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x22c0
nopw %cs:(%rax,%rax)
// File: fatiiates[P]CDLL-with-cpp-make-gcc/./src/CircularDoublyLinkedList.cpp
// Function: CircularDoublyLinkedList::FindPreNode(int)
Node* CircularDoublyLinkedList::FindPreNode(int index){
      int i=1;
      Node* prv = head;
      for (Node* itr = head;i != index; itr=itr->next,i++) {
        prv = prv->next;
      }
      return prv;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl $0x1, -0x10(%rbp)
movq (%rax), %rcx
movq %rcx, -0x18(%rbp)
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
je 0x297f
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x2954
movq -0x18(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: fatiiates[P]CDLL-with-cpp-make-gcc/./src/CircularDoublyLinkedList.cpp
// Function: CircularDoublyLinkedList::indexOf(unsigned char const&) const
int CircularDoublyLinkedList::indexOf(const unsigned char& item) const {
      int i = 0;
      for (Node* itr=head;i != size;itr=itr->next) {
        if(itr->data == item) return i;
				i++;
      }
      return -1;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x1c(%rbp)
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl 0x8(%rcx), %eax
je 0x2daf
movq -0x28(%rbp), %rax
movzbl (%rax), %eax
movq -0x18(%rbp), %rcx
movzbl (%rcx), %ecx
cmpl %ecx, %eax
jne 0x2d98
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x2db6
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x2d72
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: fatiiates[P]CDLL-with-cpp-make-gcc/./src/CircularDoublyLinkedList.cpp
// Function: CircularDoublyLinkedList::remove(unsigned char const&)
void CircularDoublyLinkedList::remove(const unsigned char& item){
      int index = indexOf(item);
      if (index == -1)
        throw invalid_argument("Eleman listeye ait degil. Error Code: 104");
      else
        removeAt(index);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq -0x10(%rbp), %rsi
callq 0x2d50
movl %eax, -0x14(%rbp)
cmpl $-0x1, -0x14(%rbp)
jne 0x2e3a
movl $0x10, %edi
callq 0x20c0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
leaq 0x233f(%rip), %rsi      # 0x5144
callq 0x2310
jmp 0x2e0c
movq -0x38(%rbp), %rdi
movq 0x51c1(%rip), %rsi      # 0x7fd8
movq 0x51aa(%rip), %rdx      # 0x7fc8
callq 0x22a0
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x2110
jmp 0x2e4c
movq -0x30(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x2e60
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x22c0
nopw %cs:(%rax,%rax)
// File: fatiiates[P]CDLL-with-cpp-make-gcc/./src/CircularDoublyLinkedList.cpp
// Function: CircularDoublyLinkedList::find(unsigned char const&)
bool CircularDoublyLinkedList::find(const unsigned char& item){
      int i=0;
      for (Node* itr=head;i != size;itr=itr->next,i++)
        if(itr->data == item) return true;

      return false;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x1c(%rbp)
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl 0x8(%rcx), %eax
je 0x30cf
movq -0x28(%rbp), %rax
movzbl (%rax), %eax
movq -0x18(%rbp), %rcx
movzbl (%rcx), %ecx
cmpl %ecx, %eax
jne 0x30b6
movb $0x1, -0x1(%rbp)
jmp 0x30d3
jmp 0x30b8
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3092
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw (%rax,%rax)
// File: fatiiates[P]CDLL-with-cpp-make-gcc/./src/CircularDoublyLinkedList.cpp
// Function: CircularDoublyLinkedList::elementAt(int)
const unsigned char& CircularDoublyLinkedList::elementAt(int index){
      if(index == 0)
        return first();
      else if(index == (size -1))
        return last();

      return FindPreNode(index)->next->data;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x310c
movq -0x20(%rbp), %rdi
callq 0x29d0
movq %rax, -0x8(%rbp)
jmp 0x3142
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
movl 0x8(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jne 0x312c
movq -0x20(%rbp), %rdi
callq 0x2a80
movq %rax, -0x8(%rbp)
jmp 0x3142
jmp 0x312e
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x2930
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)